search-auditor 0.1.0 → 0.2.0

package/dist/rules/lnk/lnk-5.js

@@ -0,0 +1,22 @@
+/** LNK-5: Internal links do not carry nofollow. */
+import { finder, isSameSite } from "auditor-engine";
+import { absolute, rel } from "../util.js";
+import { anchors } from "./shared.js";
+export const lnk5 = {
+    id: "LNK-5",
+    group: "LNK",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const o = { target: site.target, base: site.base };
+        for (const p of site.pages) {
+            const own = anchors(p.fetched.body)
+                .filter((a) => a.href && /\bnofollow\b/i.test(a.rel))
+                .map((a) => absolute(a.href, p.fetched.publicUrl))
+                .filter((u) => u && isSameSite(u, o));
+            if (own.length)
+                add(p.fetched.publicUrl, t.nofollowInternal(own.length, rel(own[0], site.base)));
+        }
+        return out;
+    },
+};

package/dist/rules/lnk/lnk-6.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const lnk6: SeoRule;

package/dist/rules/lnk/lnk-6.js

@@ -0,0 +1,24 @@
+/** LNK-6: Link text says where the link goes. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+import { anchors, VAGUE } from "./shared.js";
+export const lnk6 = {
+    id: "LNK-6",
+    group: "LNK",
+    level: "info",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const links = anchors(p.fetched.body).filter((a) => a.href && !a.href.startsWith("#"));
+            // «Read more» and friends: the text a search engine uses to learn what the target page is about.
+            const vague = links.filter((a) => !a.label && VAGUE.test(a.text.replace(/[\s→›»….:!>]+$/u, "")));
+            // No text, no label, no alt: an icon or an image link that names nothing.
+            const nameless = links.filter((a) => !a.text && !a.label && !a.alt);
+            if (vague.length)
+                add(p.fetched.publicUrl, t.vagueLinks(vague.length, short(vague[0].text, 30)));
+            if (nameless.length)
+                add(p.fetched.publicUrl, t.namelessLinks(nameless.length, nameless[0].href));
+        }
+        return out;
+    },
+};

package/dist/rules/lnk/lnk-7.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const lnk7: SeoRule;

package/dist/rules/lnk/lnk-7.js

@@ -0,0 +1,26 @@
+/** LNK-7: Links to other sites still work. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { statusOf } from "../util.js";
+import { GONE } from "./shared.js";
+export const lnk7 = {
+    id: "LNK-7",
+    group: "LNK",
+    level: "warn",
+    applies(site, t) {
+        const external = [...seoOf(site).external.values()];
+        if (!external.length)
+            return t.skipNoExternal;
+        // Not one outside site answered at all: the audit runs without internet access, so nothing can be told dead.
+        return external.some((p) => p.status > 0) ? null : t.skipNoNetwork;
+    },
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Only answers that mean «gone»: many sites turn bots away with 403, 429 or 999, and that is not a dead link.
+        for (const [url, p] of seoOf(site).external)
+            if (p.status === 404 || p.status === 410 || (p.status === 0 && GONE.test(p.error ?? "")))
+                for (const page of p.from ?? [])
+                    add(page, t.deadExternal(url, statusOf(p)));
+        return out;
+    },
+};

package/dist/rules/lnk/shared.d.ts

@@ -0,0 +1,20 @@
+/** One <a> of the raw HTML: its href as written, rel, the text a person and a crawler read, and its attributes. */
+export interface Anchor {
+    href: string | null;
+    rel: string;
+    text: string;
+    /** aria-label or title: a name for links whose text is an icon. */
+    label: string;
+    /** The alt of images inside the link, which names an image link. */
+    alt: string;
+    named: boolean;
+}
+/** Every <a>…</a> in the HTML. A regex is enough here: links do not nest. */
+export declare function anchors(html: string): Anchor[];
+/** Link texts that say nothing about where the link goes. */
+export declare const VAGUE: RegExp;
+/**
+ * Error codes that mean the domain is gone: no DNS record. Timeouts, refused connections and EAI_AGAIN («try again»)
+ * say more about the network the audit runs in than about the site, so they never count as dead.
+ */
+export declare const GONE: RegExp;

package/dist/rules/lnk/shared.js

@@ -0,0 +1,29 @@
+/** Constants and helpers shared by the LNK checks. */
+import { textContent } from "auditor-engine";
+const attr = (tag, name) => {
+    const m = tag.match(new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i"));
+    return m ? (m[1] ?? m[2] ?? m[3] ?? "") : null;
+};
+/** Every <a>…</a> in the HTML. A regex is enough here: links do not nest. */
+export function anchors(html) {
+    return [...html.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)].map((m) => {
+        const open = `<a${m[1]}>`;
+        const inner = m[2] ?? "";
+        const alts = [...inner.matchAll(/<img\b[^>]*>/gi)].map((i) => attr(i[0], "alt") ?? "").join(" ");
+        return {
+            href: attr(open, "href"),
+            rel: attr(open, "rel") ?? "",
+            text: textContent(inner).replace(/\s+/g, " ").trim(),
+            label: (attr(open, "aria-label") ?? attr(open, "title") ?? "").trim(),
+            alt: alts.trim(),
+            named: attr(open, "name") !== null || attr(open, "id") !== null,
+        };
+    });
+}
+/** Link texts that say nothing about where the link goes. */
+export const VAGUE = /^(click here|here|read more|more|learn more|see more|link|this link|continue|go|details|здесь|тут|сюда|подробнее|читать далее|читать|далее|ещё|еще|ссылка|по ссылке|перейти|узнать больше|нажмите здесь|смотреть)$/i;
+/**
+ * Error codes that mean the domain is gone: no DNS record. Timeouts, refused connections and EAI_AGAIN («try again»)
+ * say more about the network the audit runs in than about the site, so they never count as dead.
+ */
+export const GONE = /^(ENOTFOUND|ERR_NAME_NOT_RESOLVED)$/;

package/dist/rules/map/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sitemap (MAP): the map of the site for search engines, and whether it lists the right pages the right way.
+ * A valid sitemap file declared in robots.txt; full addresses on this site that answer 200 without redirects;
+ * only pages that are their own canonical; the pages the site links to; and lastmod dates search engines can trust.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const mapRules: SeoRule[];

package/dist/rules/map/index.js

@@ -0,0 +1,9 @@
+import { map1 } from "./map-1.js";
+import { map2 } from "./map-2.js";
+import { map3 } from "./map-3.js";
+import { map4 } from "./map-4.js";
+import { map5 } from "./map-5.js";
+import { map6 } from "./map-6.js";
+import { map7 } from "./map-7.js";
+import { map8 } from "./map-8.js";
+export const mapRules = [map1, map2, map3, map4, map5, map6, map7, map8];

package/dist/rules/map/map-1.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const map1: SeoRule;

package/dist/rules/map/map-1.js

@@ -0,0 +1,15 @@
+/** MAP-1: There is a sitemap, and robots.txt points to it. */
+import { finder } from "auditor-engine";
+export const map1 = {
+    id: "MAP-1",
+    group: "MAP",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        if (!site.sitemap)
+            add("site", t.noSitemap);
+        else if (site.robots && !/^\s*sitemap\s*:/im.test(site.robots.fetched.body))
+            add("site", t.sitemapNotInRobots, "info");
+        return out;
+    },
+};

package/dist/rules/map/map-2.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const map2: SeoRule;

package/dist/rules/map/map-2.js

@@ -0,0 +1,26 @@
+/** MAP-2: Sitemap addresses do not redirect. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { norm, rel } from "../util.js";
+import { inSitemap } from "./shared.js";
+export const map2 = {
+    id: "MAP-2",
+    group: "MAP",
+    level: "warn",
+    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const listed = inSitemap(site);
+        for (const f of [...site.pages.map((p) => p.fetched), ...site.failed]) {
+            if (!listed.has(norm(f.publicUrl)) || !f.redirected || !f.finalUrl)
+                continue;
+            if (norm(f.finalUrl) !== norm(f.publicUrl))
+                add(f.publicUrl, t.sitemapRedirects(rel(f.finalUrl, site.base)));
+        }
+        // And the sitemap addresses beyond the sample, requested in collect().
+        for (const [url, p] of seoOf(site).sitemapExtra)
+            if (p.status > 0 && p.status < 400 && p.redirected && norm(p.finalUrl) !== url)
+                add(url, t.sitemapRedirects(rel(p.finalUrl, site.base)));
+        return out;
+    },
+};

package/dist/rules/map/map-3.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const map3: SeoRule;

package/dist/rules/map/map-3.js

@@ -0,0 +1,24 @@
+/** MAP-3: Sitemap pages are their own canonical. */
+import { finder } from "auditor-engine";
+import { absolute, norm, rel } from "../util.js";
+import { inSitemap } from "./shared.js";
+export const map3 = {
+    id: "MAP-3",
+    group: "MAP",
+    level: "warn",
+    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const listed = inSitemap(site);
+        for (const p of site.pages) {
+            const f = p.fetched;
+            // A listed address that redirects is MAP-2's finding; its target's canonical says nothing new.
+            if (!listed.has(norm(f.publicUrl)) || (f.finalUrl && norm(f.finalUrl) !== norm(f.publicUrl)))
+                continue;
+            const href = p.canonical ? absolute(p.canonical, f.publicUrl) : "";
+            if (href && norm(href) !== norm(f.publicUrl))
+                add(f.publicUrl, t.sitemapCanonicalElsewhere(rel(href, site.base)));
+        }
+        return out;
+    },
+};

package/dist/rules/map/map-4.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const map4: SeoRule;

package/dist/rules/map/map-4.js

@@ -0,0 +1,34 @@
+/** MAP-4: The sitemap file is valid. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { statusOf } from "../util.js";
+import { MAX_BYTES, MAX_URLS } from "./shared.js";
+export const map4 = {
+    id: "MAP-4",
+    group: "MAP",
+    level: "error",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const f of seoOf(site).sitemapFiles) {
+            // No /sitemap.xml at the default address is MAP-1's finding; a declared or listed file that fails is this one.
+            if (f.status !== 200) {
+                if (f.source !== "default")
+                    add(f.url, t.sitemapStatus(statusOf(f)));
+                continue;
+            }
+            if (f.kind === "gzip")
+                continue;
+            if (f.kind === "html")
+                add(f.url, t.sitemapHtml);
+            else if (f.kind === "other")
+                add(f.url, t.sitemapNotXml);
+            if (f.count > MAX_URLS)
+                add(f.url, t.sitemapTooMany(f.count));
+            if (f.bytes > MAX_BYTES)
+                add(f.url, t.sitemapTooBig(Math.round(f.bytes / 1024 / 1024)));
+            if (f.badAmpersands)
+                add(f.url, t.sitemapAmpersand(f.badAmpersands));
+        }
+        return out;
+    },
+};

package/dist/rules/map/map-5.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const map5: SeoRule;

package/dist/rules/map/map-5.js

@@ -0,0 +1,28 @@
+/** MAP-5: Sitemap addresses are absolute and on this site. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { sitemapUrl } from "./shared.js";
+export const map5 = {
+    id: "MAP-5",
+    group: "MAP",
+    level: "warn",
+    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // The protocol takes full addresses on the sitemap's own host; others are dropped. http:// on this host is SEC-6.
+        const host = new URL(site.base).host;
+        const wrong = site.sitemap.urls
+            .map((u) => u.loc)
+            .filter((loc) => {
+            try {
+                return !/^https?:\/\//i.test(loc) || new URL(loc).host !== host;
+            }
+            catch {
+                return true;
+            }
+        });
+        if (wrong.length)
+            add(sitemapUrl(site, seoOf(site).sitemapFiles), t.sitemapForeign(wrong.length, wrong[0]));
+        return out;
+    },
+};

package/dist/rules/map/map-6.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const map6: SeoRule;

package/dist/rules/map/map-6.js

@@ -0,0 +1,22 @@
+/** MAP-6: Pages the site links to are in the sitemap. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { inSitemap } from "./shared.js";
+export const map6 = {
+    id: "MAP-6",
+    group: "MAP",
+    level: "info",
+    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const listed = inSitemap(site);
+        // Working HTML pages open to indexing only: a link that redirects or fails is LNK's finding; feeds, PDFs,
+        // pages with noindex and addresses with a query are not meant for the sitemap.
+        for (const [url, p] of seoOf(site).links) {
+            if (p.status !== 200 || p.redirected || !p.html || p.noindex || url.includes("?") || listed.has(url))
+                continue;
+            add(url, t.notInSitemap(p.from?.length ?? 0));
+        }
+        return out;
+    },
+};

package/dist/rules/map/map-7.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const map7: SeoRule;

package/dist/rules/map/map-7.js

@@ -0,0 +1,18 @@
+/** MAP-7: Every sitemap address answers. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { statusOf } from "../util.js";
+export const map7 = {
+    id: "MAP-7",
+    group: "MAP",
+    level: "error",
+    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // The sampled pages are IDX-1's: these are the sitemap addresses beyond the sample.
+        for (const [url, p] of seoOf(site).sitemapExtra)
+            if (p.status === 0 || p.status >= 400)
+                add(url, t.sitemapDead(statusOf(p)));
+        return out;
+    },
+};

package/dist/rules/map/map-8.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const map8: SeoRule;

package/dist/rules/map/map-8.js

@@ -0,0 +1,31 @@
+/** MAP-8: lastmod in the sitemap is honest. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { short } from "../util.js";
+import { SAME_LASTMOD_MIN, W3C_DATE, sitemapUrl } from "./shared.js";
+export const map8 = {
+    id: "MAP-8",
+    group: "MAP",
+    level: "warn",
+    applies: (site, t) => (site.sitemap?.urls.some((u) => u.lastmod) ? null : t.skipNoLastmod),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const where = sitemapUrl(site, seoOf(site).sitemapFiles);
+        const dates = site.sitemap.urls.map((u) => u.lastmod).filter((d) => Boolean(d));
+        const bad = dates.filter((d) => !W3C_DATE.test(d) || Number.isNaN(Date.parse(d)));
+        // A day of slack for time zones: a date tomorrow in UTC can be today on the server.
+        const future = dates.filter((d) => W3C_DATE.test(d) && Date.parse(d) > Date.now() + 86_400_000);
+        if (bad.length)
+            add(where, t.lastmodBad(bad.length, short(bad[0], 40)));
+        if (future.length)
+            add(where, t.lastmodFuture(future.length, future[0]));
+        // The same lastmod everywhere is the build time: Google learns to ignore it, and real edits go unnoticed.
+        const counts = new Map();
+        for (const d of dates)
+            counts.set(d, (counts.get(d) ?? 0) + 1);
+        const [top, n] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? ["", 0];
+        if (n >= SAME_LASTMOD_MIN && n === site.sitemap.urls.length)
+            add(where, t.lastmodSame(n, top));
+        return out;
+    },
+};

package/dist/rules/map/shared.d.ts

@@ -0,0 +1,14 @@
+/** Constants and helpers shared by the MAP checks. */
+import { type SeoRule } from "../util.ts";
+export declare const inSitemap: (site: Parameters<SeoRule["run"]>[0]) => Set<string>;
+/** Where findings about the sitemap as a whole go: its first file, or the default address. */
+export declare const sitemapUrl: (site: Parameters<SeoRule["run"]>[0], files: {
+    url: string;
+}[]) => string;
+/** The sitemap protocol's limits per file. */
+export declare const MAX_URLS = 50000;
+export declare const MAX_BYTES: number;
+/** W3C Datetime as the sitemap protocol takes it: a date, or a date and time with a time zone. */
+export declare const W3C_DATE: RegExp;
+/** A sitemap where at least this many addresses share one lastmod is stamping the build time, not the edits. */
+export declare const SAME_LASTMOD_MIN = 10;

package/dist/rules/map/shared.js

@@ -0,0 +1,12 @@
+/** Constants and helpers shared by the MAP checks. */
+import { norm } from "../util.js";
+export const inSitemap = (site) => new Set((site.sitemap?.urls ?? []).map((u) => norm(u.loc)));
+/** Where findings about the sitemap as a whole go: its first file, or the default address. */
+export const sitemapUrl = (site, files) => files[0]?.url ?? `${site.base}/sitemap.xml`;
+/** The sitemap protocol's limits per file. */
+export const MAX_URLS = 50_000;
+export const MAX_BYTES = 50 * 1024 * 1024;
+/** W3C Datetime as the sitemap protocol takes it: a date, or a date and time with a time zone. */
+export const W3C_DATE = /^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2}))?)?)?$/;
+/** A sitemap where at least this many addresses share one lastmod is stamping the build time, not the edits. */
+export const SAME_LASTMOD_MIN = 10;

package/dist/rules/meta/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Meta tags (META): how a page looks in search results, its title, snippet and icon.
+ * One title and one description per page, of a length that fits the result, written for the page and not for a
+ * template, not repeated across pages or between title and description; a declared encoding, a snippet that is
+ * not forbidden, and a favicon.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const metaRules: SeoRule[];

package/dist/rules/meta/index.js

@@ -0,0 +1,10 @@
+import { meta1 } from "./meta-1.js";
+import { meta2 } from "./meta-2.js";
+import { meta3 } from "./meta-3.js";
+import { meta4 } from "./meta-4.js";
+import { meta5 } from "./meta-5.js";
+import { meta6 } from "./meta-6.js";
+import { meta7 } from "./meta-7.js";
+import { meta8 } from "./meta-8.js";
+import { meta9 } from "./meta-9.js";
+export const metaRules = [meta1, meta2, meta3, meta4, meta5, meta6, meta7, meta8, meta9];

package/dist/rules/meta/meta-1.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const meta1: SeoRule;

package/dist/rules/meta/meta-1.js

@@ -0,0 +1,20 @@
+/** META-1: Every page has a title of the right length. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+import { TITLE, len } from "./shared.js";
+export const meta1 = {
+    id: "META-1",
+    group: "META",
+    level: "error",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const n = len(p.title);
+            if (!n)
+                add(p.fetched.publicUrl, t.noTitle);
+            else if (n < TITLE.min || n > TITLE.max)
+                add(p.fetched.publicUrl, t.titleLength(n, short(p.title), TITLE.min, TITLE.max), "warn");
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-2.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta2: SeoRule;

package/dist/rules/meta/meta-2.js

@@ -0,0 +1,19 @@
+/** META-2: Every page has a description. */
+import { finder } from "auditor-engine";
+import { DESCRIPTION, len } from "./shared.js";
+export const meta2 = {
+    id: "META-2",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const n = len(p.description);
+            if (!n)
+                add(p.fetched.publicUrl, t.noDescription);
+            else if (n < DESCRIPTION.min || n > DESCRIPTION.max)
+                add(p.fetched.publicUrl, t.descriptionLength(n, DESCRIPTION.min, DESCRIPTION.max), "info");
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-3.d.ts

@@ -0,0 +1,2 @@
+import { type SeoRule } from "../util.ts";
+export declare const meta3: SeoRule;

package/dist/rules/meta/meta-3.js

@@ -0,0 +1,26 @@
+/** META-3: Titles and descriptions are not repeated across pages. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+export const meta3 = {
+    id: "META-3",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const repeated = (pick, message) => {
+            const by = new Map();
+            for (const p of site.pages) {
+                const v = pick(p).trim();
+                if (v)
+                    by.set(v, [...(by.get(v) ?? []), p.fetched.publicUrl]);
+            }
+            for (const [text, urls] of by)
+                if (urls.length > 1)
+                    for (const u of urls)
+                        add(u, message(urls.length, short(text)));
+        };
+        repeated((p) => p.title, t.sameTitle);
+        repeated((p) => p.description, t.sameDescription);
+        return out;
+    },
+};

package/dist/rules/meta/meta-4.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta4: SeoRule;

package/dist/rules/meta/meta-4.js

@@ -0,0 +1,22 @@
+/** META-4: One title and one description per page. */
+import { finder } from "auditor-engine";
+import { headOf } from "../../collect.js";
+export const meta4 = {
+    id: "META-4",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // In <head> only: an inline SVG has <title> of its own, and that is fine.
+            const head = headOf(p.fetched.body);
+            const titles = (head.match(/<title\b/gi) ?? []).length;
+            const descriptions = (head.match(/<meta\b[^>]*\bname\s*=\s*["']?description\b/gi) ?? []).length;
+            if (titles > 1)
+                add(p.fetched.publicUrl, t.manyTitles(titles));
+            if (descriptions > 1)
+                add(p.fetched.publicUrl, t.manyDescriptions(descriptions));
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-5.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta5: SeoRule;

package/dist/rules/meta/meta-5.js

@@ -0,0 +1,17 @@
+/** META-5: The title names the page, not a template. */
+import { finder } from "auditor-engine";
+import { GENERIC_TITLE } from "./shared.js";
+export const meta5 = {
+    id: "META-5",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const title = p.title.trim();
+            if (title && GENERIC_TITLE.test(title))
+                add(p.fetched.publicUrl, t.genericTitle(title));
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-6.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta6: SeoRule;

package/dist/rules/meta/meta-6.js

@@ -0,0 +1,18 @@
+/** META-6: The description adds to the title, not repeats it. */
+import { finder } from "auditor-engine";
+import { plain } from "./shared.js";
+export const meta6 = {
+    id: "META-6",
+    group: "META",
+    level: "info",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const [title, description] = [plain(p.title), plain(p.description)];
+            // The same words, or the title with a few characters added: the snippet says nothing the title did not.
+            if (title && description && (description === title || (description.startsWith(title) && description.length - title.length < 15)))
+                add(p.fetched.publicUrl, t.descriptionRepeatsTitle);
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-7.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta7: SeoRule;

package/dist/rules/meta/meta-7.js

@@ -0,0 +1,18 @@
+/** META-7: The page declares its encoding. */
+import { finder } from "auditor-engine";
+export const meta7 = {
+    id: "META-7",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const header = /charset\s*=/i.test(p.fetched.headers.get("content-type") ?? "");
+            // Browsers look for <meta charset> in the first 1024 bytes only.
+            const meta = /<meta\b[^>]*charset\s*=/i.test(p.fetched.body.slice(0, 1024));
+            if (!header && !meta)
+                add(p.fetched.publicUrl, t.noCharset);
+        }
+        return out;
+    },
+};

package/dist/rules/meta/meta-8.d.ts

@@ -0,0 +1,2 @@
+import type { SeoRule } from "../util.ts";
+export declare const meta8: SeoRule;