search-auditor 0.1.1 → 0.2.0

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

@@ -0,0 +1,19 @@
+/** IMG-4: Photos are served in modern formats. */
+import { finder } from "auditor-engine";
+import { imgs, NEGOTIATED } from "./shared.js";
+export const img4 = {
+    id: "IMG-4",
+    group: "IMG",
+    level: "info",
+    applies: (site, t) => (site.pages.some((p) => p.images.length) ? null : t.skipNoImages),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // JPEG and PNG with no WebP or AVIF next to them; a <picture> with a modern source or an image CDN is fine.
+            const old = imgs(p.fetched.body).filter((i) => /\.(jpe?g|png)(\?|#|$)/i.test(i.src) && !i.modernSource && !NEGOTIATED.test(i.src));
+            if (old.length)
+                add(p.fetched.publicUrl, t.oldFormats(old.length, old[0].src));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** IMG-5: Images open. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel, statusOf } from "../util.js";
+export const img5 = {
+    id: "IMG-5",
+    group: "IMG",
+    level: "error",
+    applies: (site, t) => (seoOf(site).images.size ? null : t.skipNoOwnImages),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const [url, p] of seoOf(site).images)
+            if (p.status === 0 || p.status >= 400)
+                for (const page of p.from ?? [])
+                    add(page, t.brokenImage(rel(url, site.base), statusOf(p)));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,20 @@
+/** IMG-6: Images are not heavier than they need to be. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel } from "../util.js";
+import { MAX_IMAGE_BYTES } from "./shared.js";
+export const img6 = {
+    id: "IMG-6",
+    group: "IMG",
+    level: "warn",
+    applies: (site, t) => (seoOf(site).images.size ? null : t.skipNoOwnImages),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // By Content-Length: a server that does not send it is not guessed at.
+        for (const [url, p] of seoOf(site).images)
+            if (p.status === 200 && (p.bytes ?? 0) > MAX_IMAGE_BYTES)
+                for (const page of p.from ?? [])
+                    add(page, t.heavyImage(rel(url, site.base), Math.round(p.bytes / 1024), MAX_IMAGE_BYTES / 1024));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,22 @@
+/** IMG-7: Alt text describes the image. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+import { imgs, MAX_ALT, POOR_ALT } from "./shared.js";
+export const img7 = {
+    id: "IMG-7",
+    group: "IMG",
+    level: "info",
+    applies: (site, t) => (site.pages.some((p) => p.images.length) ? null : t.skipNoImages),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // An empty alt is a deliberate «decorative»; a file name, «image» or a whole paragraph is not a description.
+            const poor = imgs(p.fetched.body)
+                .map((i) => (i.alt ?? "").trim())
+                .filter((alt) => alt && (POOR_ALT.test(alt) || alt.length > MAX_ALT));
+            if (poor.length)
+                add(p.fetched.publicUrl, t.poorAlt(poor.length, short(poor[0], 40)));
+        }
+        return out;
+    },
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Images (IMG): can image search and screen readers tell what an image shows, and do images keep the page fast.
+ * Alt text on every image that describes it, width and height so the layout does not jump, lazy loading below the
+ * first screen but not for the first image, modern formats, images that open, and none heavier than it needs to be.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const imgRules: SeoRule[];

package/dist/rules/img/index.js

@@ -0,0 +1,8 @@
+import { img1 } from "./img-1.js";
+import { img2 } from "./img-2.js";
+import { img3 } from "./img-3.js";
+import { img4 } from "./img-4.js";
+import { img5 } from "./img-5.js";
+import { img6 } from "./img-6.js";
+import { img7 } from "./img-7.js";
+export const imgRules = [img1, img2, img3, img4, img5, img6, img7];

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

@@ -0,0 +1,26 @@
+/** One <img> of the raw HTML, with the attributes the checks need. */
+export interface Img {
+    src: string;
+    alt: string | null;
+    width: string | null;
+    height: string | null;
+    loading: string;
+    /** Inside a <picture> that offers WebP or AVIF. */
+    modernSource: boolean;
+    /** Characters of text before the image: a rough stand-in for «is it on the first screen». */
+    textBefore: number;
+}
+/** Every <img> in document order, and whether a <picture> around it offers a modern format. */
+export declare function imgs(html: string): Img[];
+/** An image heavier than this slows the page more than it needs to. */
+export declare const MAX_IMAGE_BYTES: number;
+/** More text than this before an image and it is below the first screen, where lazy loading is right. */
+export declare const FIRST_SCREEN_TEXT = 1000;
+/** From this many images on a page, the ones below the first screen should load lazily. */
+export declare const LAZY_FROM = 5;
+/** Alt text longer than this is a paragraph, not a description: screen readers read it in full. */
+export declare const MAX_ALT = 150;
+/** URLs that already serve WebP or AVIF to browsers that take it: image CDNs and framework image endpoints. */
+export declare const NEGOTIATED: RegExp;
+/** Alt text that names a file or a kind of thing, not what the image shows. */
+export declare const POOR_ALT: RegExp;

package/dist/rules/img/shared.js

@@ -0,0 +1,38 @@
+/** Constants and helpers shared by the IMG checks. */
+import { decode, textContent } from "auditor-engine";
+const attr = (tag, name) => {
+    const m = tag.match(new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i"));
+    return m ? (m[1] ?? m[2] ?? m[3] ?? "") : null;
+};
+/** Every <img> in document order, and whether a <picture> around it offers a modern format. */
+export function imgs(html) {
+    const pictures = [...html.matchAll(/<picture\b[\s\S]*?<\/picture>/gi)].map((m) => ({
+        start: m.index,
+        end: m.index + m[0].length,
+        modern: /<source\b[^>]*type\s*=\s*["']?image\/(webp|avif)/i.test(m[0]),
+    }));
+    return [...html.matchAll(/<img\b[^>]*>/gi)].map((m) => {
+        const tag = m[0];
+        return {
+            src: decode(attr(tag, "src") ?? attr(tag, "data-src") ?? ""),
+            alt: attr(tag, "alt") === null ? null : decode(attr(tag, "alt")),
+            width: attr(tag, "width"),
+            height: attr(tag, "height"),
+            loading: (attr(tag, "loading") ?? "").toLowerCase(),
+            modernSource: pictures.some((p) => p.modern && m.index > p.start && m.index < p.end),
+            textBefore: textContent(html.slice(0, m.index).replace(/<(script|style|head)\b[\s\S]*?<\/\1>/gi, "")).replace(/\s+/g, " ").trim().length,
+        };
+    });
+}
+/** An image heavier than this slows the page more than it needs to. */
+export const MAX_IMAGE_BYTES = 500 * 1024;
+/** More text than this before an image and it is below the first screen, where lazy loading is right. */
+export const FIRST_SCREEN_TEXT = 1000;
+/** From this many images on a page, the ones below the first screen should load lazily. */
+export const LAZY_FROM = 5;
+/** Alt text longer than this is a paragraph, not a description: screen readers read it in full. */
+export const MAX_ALT = 150;
+/** URLs that already serve WebP or AVIF to browsers that take it: image CDNs and framework image endpoints. */
+export const NEGOTIATED = /\/_next\/image|\/_vercel\/image|\/cdn-cgi\/image\/|[?&](fm|format|f)=(webp|avif|auto)|[,/]f_auto|\/image\/upload\//i;
+/** Alt text that names a file or a kind of thing, not what the image shows. */
+export const POOR_ALT = /^(img|image|dsc|dscn|photo|pic|picture|screenshot|screen shot|снимок|фото|изображение|картинка|рисунок)?[\s_-]*\d*(\.(jpe?g|png|webp|gif|svg|avif))?$/i;

package/dist/rules/index.d.ts

@@ -1,5 +1,5 @@
 import type { SeoRule } from "./util.ts";
 export type { SeoRule };
-/** Group ids in checklist order: the order a site owner fixes things in. */
+/** Group ids in checklist order: the order a site owner fixes things in. One module per group, named after it. */
 export declare const SEO_GROUPS: readonly ["IDX", "SEC", "CAN", "MAP", "META", "STR", "LNK", "IMG", "DATA", "LANG"];
 export declare const seoRules: SeoRule[];

package/dist/rules/index.js

@@ -1,7 +1,24 @@
-import { linkRules } from "./links.js";
-import { pageRules } from "./page.js";
-import { siteRules } from "./site.js";
-/** Group ids in checklist order: the order a site owner fixes things in. */
+import { canRules } from "./can/index.js";
+import { dataRules } from "./data/index.js";
+import { idxRules } from "./idx/index.js";
+import { imgRules } from "./img/index.js";
+import { langRules } from "./lang/index.js";
+import { lnkRules } from "./lnk/index.js";
+import { mapRules } from "./map/index.js";
+import { metaRules } from "./meta/index.js";
+import { secRules } from "./sec/index.js";
+import { strRules } from "./str/index.js";
+/** Group ids in checklist order: the order a site owner fixes things in. One module per group, named after it. */
 export const SEO_GROUPS = ["IDX", "SEC", "CAN", "MAP", "META", "STR", "LNK", "IMG", "DATA", "LANG"];
-const all = [...siteRules, ...pageRules, ...linkRules];
-export const seoRules = SEO_GROUPS.flatMap((g) => all.filter((r) => r.group === g));
+export const seoRules = [
+    ...idxRules,
+    ...secRules,
+    ...canRules,
+    ...mapRules,
+    ...metaRules,
+    ...strRules,
+    ...lnkRules,
+    ...imgRules,
+    ...dataRules,
+    ...langRules,
+];

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

@@ -0,0 +1,8 @@
+/**
+ * Language versions (LANG): hreflang for multilingual sites, so search engines show each visitor their language.
+ * Valid codes, each language once, full addresses, every version listing itself and the others back, an x-default,
+ * targets that are working canonical pages, and a hreflang language that matches the page it points to.
+ * Only on sites that use hreflang.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const langRules: SeoRule[];

package/dist/rules/lang/index.js

@@ -0,0 +1,9 @@
+import { lang1 } from "./lang-1.js";
+import { lang2 } from "./lang-2.js";
+import { lang3 } from "./lang-3.js";
+import { lang4 } from "./lang-4.js";
+import { lang5 } from "./lang-5.js";
+import { lang6 } from "./lang-6.js";
+import { lang7 } from "./lang-7.js";
+import { lang8 } from "./lang-8.js";
+export const langRules = [lang1, lang2, lang3, lang4, lang5, lang6, lang7, lang8];

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

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

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

@@ -0,0 +1,17 @@
+/** LANG-1: hreflang codes are valid. */
+import { finder } from "auditor-engine";
+import { HREFLANG, hasHreflang } from "./shared.js";
+export const lang1 = {
+    id: "LANG-1",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages)
+            for (const h of p.hreflang)
+                if (!HREFLANG.test(h.lang))
+                    add(p.fetched.publicUrl, t.badHreflang(h.lang));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,30 @@
+/** LANG-2: Language versions point at each other. */
+import { finder, isSameSite } from "auditor-engine";
+import { absolute, norm, rel } from "../util.js";
+import { hasHreflang } from "./shared.js";
+export const lang2 = {
+    id: "LANG-2",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const o = { target: site.target, base: site.base };
+        // Only pairs where both pages were audited: a translation outside the sample is not known to be one-way.
+        const audited = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
+        for (const p of site.pages) {
+            const self = norm(p.fetched.publicUrl);
+            for (const h of p.hreflang) {
+                if (h.lang.toLowerCase() === "x-default")
+                    continue;
+                const href = absolute(h.href, p.fetched.publicUrl);
+                if (!href || !isSameSite(href, o) || norm(href) === self)
+                    continue;
+                const other = audited.get(norm(href));
+                if (other && !other.hreflang.some((b) => norm(absolute(b.href, other.fetched.publicUrl)) === self))
+                    add(p.fetched.publicUrl, t.oneWayHreflang(h.lang, rel(href, site.base)));
+            }
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,22 @@
+/** LANG-3: There is an x-default for other languages. */
+import { finder } from "auditor-engine";
+import { hasHreflang } from "./shared.js";
+export const lang3 = {
+    id: "LANG-3",
+    group: "LANG",
+    level: "info",
+    applies(site, t) {
+        if (!hasHreflang(site))
+            return t.skipNoHreflang;
+        return site.pages.some((p) => new Set(p.hreflang.filter((h) => h.lang.toLowerCase() !== "x-default").map((h) => h.lang.toLowerCase())).size > 1) ? null : t.skipOneLanguage;
+    },
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const langs = [...new Set(p.hreflang.map((h) => h.lang.toLowerCase()))];
+            if (langs.length > 1 && !langs.includes("x-default"))
+                add(p.fetched.publicUrl, t.noXDefault(langs.join(", ")));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,23 @@
+/** LANG-4: Every version lists itself in hreflang. */
+import { finder } from "auditor-engine";
+import { absolute, norm } from "../util.js";
+import { hasHreflang } from "./shared.js";
+export const lang4 = {
+    id: "LANG-4",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Google wants each version in its own list: a set that leaves the page out may be ignored.
+        for (const p of site.pages) {
+            if (!p.hreflang.length)
+                continue;
+            const self = norm(p.fetched.publicUrl);
+            const lists = p.hreflang.some((h) => h.lang.toLowerCase() !== "x-default" && norm(absolute(h.href, p.fetched.publicUrl)) === self);
+            if (!lists)
+                add(p.fetched.publicUrl, t.noSelfHreflang);
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,33 @@
+/** LANG-5: hreflang leads to working canonical pages. */
+import { finder, isSameSite } from "auditor-engine";
+import { absolute, norm, rel, statusOf } from "../util.js";
+import { hasHreflang } from "./shared.js";
+export const lang5 = {
+    id: "LANG-5",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const o = { target: site.target, base: site.base };
+        // What is known about each address: audited pages, and those that failed. Others are not guessed at.
+        const pages = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
+        const failed = new Map(site.failed.map((f) => [norm(f.publicUrl), f]));
+        for (const p of site.pages)
+            for (const h of p.hreflang) {
+                const href = absolute(h.href, p.fetched.publicUrl);
+                if (!href || !isSameSite(href, o))
+                    continue;
+                const where = rel(href, site.base);
+                const bad = failed.get(norm(href));
+                const target = pages.get(norm(href));
+                if (bad)
+                    add(p.fetched.publicUrl, t.hreflangStatus(h.lang, where, statusOf(bad)));
+                else if (target?.fetched.redirected && target.fetched.finalUrl && norm(target.fetched.finalUrl) !== norm(href))
+                    add(p.fetched.publicUrl, t.hreflangRedirects(h.lang, where, rel(target.fetched.finalUrl, site.base)));
+                else if (target?.canonical && norm(absolute(target.canonical, href)) !== norm(href))
+                    add(p.fetched.publicUrl, t.hreflangNotCanonical(h.lang, where, rel(absolute(target.canonical, href), site.base)));
+            }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,25 @@
+/** LANG-6: The hreflang language matches the language of the page it points to. */
+import { finder } from "auditor-engine";
+import { absolute, norm, rel } from "../util.js";
+import { hasHreflang, primary } from "./shared.js";
+export const lang6 = {
+    id: "LANG-6",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const pages = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
+        for (const p of site.pages)
+            for (const h of p.hreflang) {
+                if (h.lang.toLowerCase() === "x-default")
+                    continue;
+                const target = pages.get(norm(absolute(h.href, p.fetched.publicUrl)));
+                const declared = target ? primary(target.htmlLang) : "";
+                // Compared by language only: hreflang="en-GB" on a page with lang="en" is fine.
+                if (target && declared && declared !== primary(h.lang))
+                    add(p.fetched.publicUrl, t.hreflangLangMismatch(h.lang, rel(target.fetched.publicUrl, site.base), target.htmlLang));
+            }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,25 @@
+/** LANG-7: Each language is listed once. */
+import { finder } from "auditor-engine";
+import { absolute, norm } from "../util.js";
+import { hasHreflang } from "./shared.js";
+export const lang7 = {
+    id: "LANG-7",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // The same code for two different addresses: search engines cannot tell which one to show and may drop both.
+            const byCode = new Map();
+            for (const h of p.hreflang) {
+                const code = h.lang.toLowerCase();
+                byCode.set(code, new Set([...(byCode.get(code) ?? []), norm(absolute(h.href, p.fetched.publicUrl))]));
+            }
+            const twice = [...byCode].filter(([, urls]) => urls.size > 1).map(([code]) => code);
+            if (twice.length)
+                add(p.fetched.publicUrl, t.duplicateHreflang(twice.join(", ")));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,19 @@
+/** LANG-8: hreflang addresses are full. */
+import { finder } from "auditor-engine";
+import { hasHreflang } from "./shared.js";
+export const lang8 = {
+    id: "LANG-8",
+    group: "LANG",
+    level: "warn",
+    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Google requires fully qualified addresses in hreflang: «/ru/» is not one.
+        for (const p of site.pages) {
+            const relative = p.hreflang.filter((h) => !/^https?:\/\//i.test(h.href.trim()));
+            if (relative.length)
+                add(p.fetched.publicUrl, t.relativeHreflang(relative.length, relative[0].href));
+        }
+        return out;
+    },
+};

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

@@ -0,0 +1,7 @@
+/** Constants and helpers shared by the LANG checks. */
+import type { SeoRule } from "../util.ts";
+/** ISO 639-1 language, optional ISO 15924 script and region (ISO 3166-1 or UN M.49), or x-default. */
+export declare const HREFLANG: RegExp;
+export declare const hasHreflang: (site: Parameters<SeoRule["run"]>[0]) => boolean;
+/** The language of a code or of <html lang>, without script and region: «en» for en-GB, «zh» for zh-Hant. */
+export declare const primary: (code: string) => string;

package/dist/rules/lang/shared.js

@@ -0,0 +1,5 @@
+/** ISO 639-1 language, optional ISO 15924 script and region (ISO 3166-1 or UN M.49), or x-default. */
+export const HREFLANG = /^(x-default|[a-z]{2,3}(-[a-z]{4})?(-([a-z]{2}|\d{3}))?)$/i;
+export const hasHreflang = (site) => site.pages.some((p) => p.hreflang.length);
+/** The language of a code or of <html lang>, without script and region: «en» for en-GB, «zh» for zh-Hant. */
+export const primary = (code) => code.trim().toLowerCase().split(/[-_]/)[0] ?? "";

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

@@ -0,0 +1,8 @@
+/**
+ * Links (LNK): how the pages link to each other, and whether those links work for people and crawlers.
+ * No broken links and no links through redirects; every page linked from another (on a full audit); links a crawler
+ * can follow, without nofollow on the site's own pages, with text that says where they go; and links to other sites
+ * that still exist. Problems are reported on the page that has the link: that is where they get fixed.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const lnkRules: SeoRule[];

package/dist/rules/lnk/index.js

@@ -0,0 +1,8 @@
+import { lnk1 } from "./lnk-1.js";
+import { lnk2 } from "./lnk-2.js";
+import { lnk3 } from "./lnk-3.js";
+import { lnk4 } from "./lnk-4.js";
+import { lnk5 } from "./lnk-5.js";
+import { lnk6 } from "./lnk-6.js";
+import { lnk7 } from "./lnk-7.js";
+export const lnkRules = [lnk1, lnk2, lnk3, lnk4, lnk5, lnk6, lnk7];

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

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

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

@@ -0,0 +1,22 @@
+/** LNK-1: Internal links work. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel, statusOf } from "../util.js";
+export const lnk1 = {
+    id: "LNK-1",
+    group: "LNK",
+    level: "error",
+    applies: (site, t) => (seoOf(site).linksFound ? null : t.skipNoLinks),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const { links, linksFound, linksChecked } = seoOf(site);
+        // Reported on the pages that have the link: that is where it gets fixed.
+        for (const [url, p] of links)
+            if (p.status === 0 || p.status >= 400)
+                for (const page of p.from ?? [site.base])
+                    add(page, t.brokenLink(rel(url, site.base), statusOf(p)));
+        if (linksChecked < linksFound)
+            add("site", t.linksNotChecked(linksChecked, linksFound), "info");
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** LNK-2: Internal links do not go through redirects. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { norm, rel } from "../util.js";
+export const lnk2 = {
+    id: "LNK-2",
+    group: "LNK",
+    level: "warn",
+    applies: (site, t) => (seoOf(site).linksFound ? null : t.skipNoLinks),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const [url, p] of seoOf(site).links)
+            if (p.status > 0 && p.status < 400 && p.redirected && norm(p.finalUrl) !== norm(url))
+                for (const page of p.from ?? [site.base])
+                    add(page, t.redirectLink(rel(url, site.base), rel(p.finalUrl, site.base)));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,32 @@
+/** LNK-3: Every page is linked from another page. */
+import { finder, isSameSite } from "auditor-engine";
+import { norm } from "../util.js";
+/** Every same-site sitemap address was audited: only then is «no page links here» a fact, not a gap in the sample. */
+const fullyAudited = (site) => {
+    const o = { target: site.target, base: site.base };
+    const audited = new Set([...site.pages.map((p) => p.fetched.publicUrl), ...site.failed.map((f) => f.publicUrl)].map(norm));
+    const listed = (site.sitemap?.urls ?? []).map((u) => u.loc).filter((u) => isSameSite(u, o));
+    return listed.length > 0 && listed.every((u) => audited.has(norm(u)));
+};
+export const lnk3 = {
+    id: "LNK-3",
+    group: "LNK",
+    level: "warn",
+    applies: (site, t) => (!site.sitemap ? t.skipNoSitemap : fullyAudited(site) ? null : t.skipPartialSample),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const home = norm(`${site.base}/`);
+        const linked = new Set();
+        for (const p of site.pages)
+            for (const href of p.links)
+                if (norm(href) !== norm(p.fetched.publicUrl))
+                    linked.add(norm(href));
+        // A page no other page links to is found only through the sitemap, and gets no weight from the site.
+        for (const p of site.pages) {
+            const self = norm(p.fetched.publicUrl);
+            if (self !== home && !linked.has(self))
+                add(p.fetched.publicUrl, t.orphan);
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** LNK-4: Links can be followed by a crawler. */
+import { finder } from "auditor-engine";
+import { anchors } from "./shared.js";
+export const lnk4 = {
+    id: "LNK-4",
+    group: "LNK",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // No href, a bare «#» or javascript: — a crawler has nowhere to go. An <a name> or <a id> target is fine.
+            const dead = anchors(p.fetched.body).filter((a) => a.href === null ? !a.named : a.href.trim() === "#" || /^\s*javascript:/i.test(a.href));
+            if (dead.length)
+                add(p.fetched.publicUrl, t.uncrawlableLinks(dead.length, dead[0].text || dead[0].label || "…"));
+        }
+        return out;
+    },
+};

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

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