Ce que Google lit de votre page : 6 scripts à coller dans la console

// Poids du HTML brut, tel que Googlebot le télécharge, comparé à la limite de 2 Mo
(async () => {
  const LIMITE = 2000000; // 2 Mo comptés au plus bas : Google ne dit pas s'il compte 1 000 ou 1 024 octets par Ko
  const ko = n => (n / 1000).toLocaleString('fr-FR', { maximumFractionDigits: 1 }) + ' Ko';
  const reponse = await fetch(location.href, { credentials: 'omit', cache: 'no-store' });
  const octets = new Uint8Array(await reponse.arrayBuffer()); // déjà décompressé par le navigateur
  const html = new TextDecoder().decode(octets);
  const poids = re => (html.match(re) || []).reduce((total, bloc) => total + new TextEncoder().encode(bloc).length, 0);

  console.log(`HTML brut, non compressé : ${ko(octets.length)}, soit ${(100 * octets.length / LIMITE).toLocaleString('fr-FR', { maximumFractionDigits: 1 })} % de la limite de 2 Mo.`);
  const chargement = performance.getEntriesByType('navigation')[0];
  if (chargement && chargement.encodedBodySize) {
    console.log(chargement.encodedBodySize < chargement.decodedBodySize
      ? `Au chargement, le serveur en a envoyé ${ko(chargement.encodedBodySize)} compressés : la limite porte sur la version non compressée.`
      : `Au chargement, le serveur l'a envoyé sans compression (${ko(chargement.encodedBodySize)}).`);
  }
  console.table({
    'Scripts écrits dans la page': ko(poids(/<script\b[^>]*>[\s\S]*?<\/script>/gi)),
    'Styles écrits dans la page': ko(poids(/<style\b[^>]*>[\s\S]*?<\/style>/gi)),
    'Images SVG écrites dans la page': ko(poids(/<svg\b[\s\S]*?<\/svg>/gi)),
    'Images en base64 (data:)': ko(poids(/data:[\w.+-]+\/[\w.+-]+;base64,[\w+\/=]+/g)),
  });

  if (octets.length > LIMITE) {
    const coupe = new TextDecoder().decode(octets.slice(LIMITE));
    const compte = re => (coupe.match(re) || []).length.toLocaleString('fr-FR');
    console.warn(`Google ignore les ${ko(octets.length - LIMITE)} qui suivent le 2 000 000e octet : ${compte(/<a\s/gi)} liens et ${compte(/<h[1-6]\b/gi)} titres perdus. Début de la partie ignorée :`);
    console.log(coupe.slice(0, 300));
  }
})();

// Fichiers CSS et JavaScript chargés par la page : Google lit chacun séparément, avec la même limite de 2 Mo
(() => {
  const LIMITE = 2000000;
  const ko = n => (n / 1000).toLocaleString('fr-FR', { maximumFractionDigits: 1 }) + ' Ko';
  const pasUneImageNiUnePolice = r => !/\.(woff2?|ttf|otf|eot|png|jpe?g|gif|webp|avif|svg|ico)([?#]|$)/i.test(r.name);
  const fichiers = performance.getEntriesByType('resource').filter(r =>
    r.initiatorType === 'script' || /\.(m?js|css)([?#]|$)/i.test(r.name) ||
    (r.initiatorType === 'link' && pasUneImageNiUnePolice(r)));

  console.table(fichiers.map(r => ({
    fichier: r.name.split(/[?#]/)[0].split('/').slice(-2).join('/'),
    'non compressé': r.decodedBodySize ? ko(r.decodedBodySize) : 'inconnu (autre domaine)',
    'au-delà de 2 Mo': r.decodedBodySize > LIMITE ? 'OUI : Google ne lit que le début' : '',
  })));
  const trop = fichiers.filter(r => r.decodedBodySize > LIMITE).length;
  console.log(trop ? `${trop} fichier(s) dépassent 2 Mo.` : `${fichiers.length} fichier(s) CSS et JavaScript, aucun ne dépasse 2 Mo (parmi ceux qui sont mesurables).`);
})();

// Ce que contient la page avant JavaScript (HTML brut), comparé à la page affichée
(async () => {
  const reponse = await fetch(location.href, { credentials: 'omit', cache: 'no-store' });
  const brut = new DOMParser().parseFromString(await reponse.text(), 'text/html');
  const baseBrut = new URL(brut.querySelector('base[href]')?.getAttribute('href') || reponse.url, reponse.url).href;
  const mots = doc => {
    const corps = doc.body.cloneNode(true);
    corps.querySelectorAll('script, style, noscript, template').forEach(e => e.remove());
    return (corps.textContent.match(/[\p{L}\p{N}]+/gu) || []).length;
  };
  const liens = (doc, base) => new Set([...doc.querySelectorAll('a[href]')].map(a => {
    try { return new URL(a.getAttribute('href'), base).href; } catch (e) { return a.getAttribute('href'); }
  }));
  const titres = doc => new Set([...doc.querySelectorAll('h1, h2, h3')].map(h => h.textContent.trim().replace(/\s+/g, ' ')));

  const motsBrut = mots(brut), motsAffiches = mots(document);
  console.log(`Mots dans le HTML brut : ${motsBrut.toLocaleString('fr-FR')}. Dans la page affichée : ${motsAffiches.toLocaleString('fr-FR')}. Part présente sans JavaScript : ${Math.round(100 * motsBrut / Math.max(motsAffiches, 1))} %.`);
  const liensBrut = liens(brut, baseBrut), titresBrut = titres(brut);
  const ajouts = [
    ...[...liens(document, document.baseURI)].filter(l => !liensBrut.has(l)).map(l => ({ type: 'lien', valeur: l })),
    ...[...titres(document)].filter(t => !titresBrut.has(t)).map(t => ({ type: 'titre', valeur: t })),
  ];
  console.log(ajouts.length ? `${ajouts.length} lien(s) ou titre(s) n'existent qu'après JavaScript :` : 'Aucun lien ni titre ajouté par JavaScript.');
  if (ajouts.length) console.table(ajouts);
})();

// Les balises que Google lit en premier, dans le HTML brut (et l'en-tête X-Robots-Tag du serveur)
(async () => {
  const reponse = await fetch(location.href, { credentials: 'omit', cache: 'no-store' });
  const doc = new DOMParser().parseFromString(await reponse.text(), 'text/html');
  const base = new URL(doc.querySelector('base[href]')?.getAttribute('href') || reponse.url, reponse.url).href;
  const texte = e => e.textContent.trim().replace(/\s+/g, ' ');
  const titre = texte(doc.querySelector('title') || doc.createElement('title'));
  const description = doc.querySelector('meta[name="description" i]')?.getAttribute('content')?.trim() || '';
  const canonique = doc.querySelector('link[rel="canonical" i]')?.getAttribute('href');
  const urlCanonique = canonique ? new URL(canonique, base).href : '';
  const robots = [...doc.querySelectorAll('meta[name="robots" i], meta[name="googlebot" i]')];
  const h1 = [...doc.querySelectorAll('h1')];
  const jsonld = [...doc.querySelectorAll('script[type="application/ld+json"]')].map(s => {
    try { const d = JSON.parse(s.textContent); return [].concat(d['@graph'] || d).map(x => x['@type']).join(', '); }
    catch (e) { return 'JSON invalide'; }
  });

  console.table({
    'Code HTTP': reponse.status + (reponse.redirected ? ` (après redirection vers ${reponse.url})` : ''),
    'En-tête X-Robots-Tag': reponse.headers.get('x-robots-tag') || 'absent',
    'Balise meta robots': robots.map(m => `${m.getAttribute('name')} = ${m.getAttribute('content')}`).join(' | ') || 'absente : indexable par défaut',
    'Title': titre ? `${titre} (${titre.length} caractères)` : 'ABSENT',
    'Meta description': description ? `${description} (${description.length} caractères)` : 'absente',
    'Canonique': urlCanonique ? urlCanonique + (urlCanonique === reponse.url ? ' (cette page)' : ' (AUTRE URL que cette page)') : 'absente',
    'Langue (lang)': doc.documentElement.getAttribute('lang') || 'ABSENTE',
    'Titres H1': `${h1.length} : ${h1.map(texte).join(' | ')}`,
    'Versions linguistiques (hreflang)': doc.querySelectorAll('link[rel="alternate"][hreflang]').length,
    'Données structurées (JSON-LD)': jsonld.join(' ; ') || 'aucune',
  });
})();

// Les liens que Google peut suivre, et ceux qu'il risque de ne pas suivre
(() => {
  const n = x => x.toLocaleString('fr-FR');
  const intitule = a => (a.textContent.trim() || a.getAttribute('aria-label') || a.querySelector('img[alt]')?.getAttribute('alt') || '').replace(/\s+/g, ' ').slice(0, 60);
  const liens = [...document.querySelectorAll('a')];
  const aRevoir = [];
  liens.forEach(a => {
    const href = a.getAttribute('href');
    let probleme = '';
    if (href === null) probleme = 'pas de href : Google peut ne pas le suivre';
    else if (/^\s*javascript:/i.test(href)) probleme = 'href en javascript: : Google peut ne pas le suivre';
    else if (href.trim() === '' || href.trim() === '#') probleme = 'href vide ou # : ne mène nulle part';
    else if (!intitule(a)) probleme = 'aucun texte ni alt : lien sans intitulé';
    if (probleme) aRevoir.push({ lien: intitule(a) || a.outerHTML.slice(0, 60), href: href ?? '', probleme });
  });
  document.querySelectorAll('[onclick]:not(a):not(button):not(input):not(label), span[href], div[href], [role="link"]:not(a)').forEach(e =>
    aRevoir.push({ lien: (e.textContent.trim() || e.outerHTML).replace(/\s+/g, ' ').slice(0, 60), href: e.getAttribute('href') || '', probleme: `<${e.tagName.toLowerCase()}> cliquable : Google peut ne pas le suivre` }));

  const explorables = liens.filter(a => /^https?:$/.test(a.protocol) && a.getAttribute('href')?.trim() && !/^\s*#/.test(a.getAttribute('href')));
  const internes = explorables.filter(a => a.hostname === location.hostname).length;
  const nofollow = explorables.filter(a => /\bnofollow\b/i.test(a.rel)).length;
  console.log(`${n(explorables.length)} liens explorables vers d'autres pages : ${n(internes)} internes, ${n(explorables.length - internes)} externes, dont ${n(nofollow)} en nofollow. ${n(aRevoir.length)} élément(s) à revoir.`);
  if (aRevoir.length) console.table(aRevoir);
})();

// Images : texte alternatif, dimensions, chargement différé dans le premier écran
(() => {
  const hauteurEcran = window.innerHeight;
  const images = [...document.images].filter(img => img.getBoundingClientRect().width > 0); // images affichées
  const lignes = images.map(img => {
    const dansLePremierEcran = img.getBoundingClientRect().top + window.scrollY < hauteurEcran;
    return {
      image: (img.currentSrc || img.src).split(/[?#]/)[0].split('/').pop().slice(0, 50),
      alt: !img.hasAttribute('alt') ? 'ABSENT' : img.alt.trim() === '' ? '(vide : image décorative)' : img.alt.slice(0, 50),
      'width et height': img.hasAttribute('width') && img.hasAttribute('height') ? 'oui' : 'NON',
      'premier écran': dansLePremierEcran ? 'oui' : '',
      'chargement différé': img.loading === 'lazy' ? (dansLePremierEcran ? 'OUI : à retirer' : 'oui') : '',
    };
  });
  const compte = test => lignes.filter(test).length;
  console.log(`${lignes.length} images affichées : ${compte(l => l.alt === 'ABSENT')} sans attribut alt, ${compte(l => l['width et height'] === 'NON')} sans dimensions, ${compte(l => l['chargement différé'].startsWith('OUI'))} en chargement différé dans le premier écran.`);
  console.table(lignes);
})();