eaa-kit 0.1.0 → 0.2.0

package/dist/{baseline-Itspu3-Y.js → baseline-CV_3lbER.js}

@@ -1,2 +1,2 @@
-import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-DQTnNlc4.js";
+import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-CgBmzFTr.js";
 export { BaselineError, applyBaseline, readBaseline };

package/dist/{baseline-DQTnNlc4.js → baseline-CgBmzFTr.js}

@@ -1,30 +1,30 @@
+import { _ as withDefault, c as object, f as safeParse, i as isoDate$1, l as optional, o as nullable, p as string, s as number, t as array } from "./schema-CMZ8ItGk.js";
 import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
-import { z } from "zod";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Default filename, used by the CLI when no path is given. */
 const DEFAULT_BASELINE_FILE = "eaa-baseline.json";
-const entrySchema = z.object({
+const entrySchema = object({
 	/** Page path relative to the audited directory, POSIX separators. */
-	page: z.string(),
-	ruleId: z.string(),
+	page: string(),
+	ruleId: string(),
 	/** Identity of the element, from elementFingerprint. */
-	fingerprint: z.string(),
+	fingerprint: string(),
 	/** Carried for readability only; matching never looks at these. */
-	selector: z.string().default(""),
-	help: z.string().default(""),
-	impact: z.string().nullable().default(null),
+	selector: withDefault(string(), () => ""),
+	help: withDefault(string(), () => ""),
+	impact: withDefault(nullable(string()), () => null),
 	/** ISO date the entry was written. */
-	acceptedOn: z.string().default(""),
+	acceptedOn: withDefault(string(), () => ""),
 	/** ISO date after which this entry stops suppressing anything. */
-	expiresOn: z.iso.date().optional(),
+	expiresOn: optional(isoDate$1()),
 	/** Why this is being lived with. Free text, for whoever reads the file. */
-	note: z.string().optional()
+	note: optional(string())
 });
-const baselineSchema = z.object({
-	schemaVersion: z.number(),
-	createdOn: z.string().default(""),
-	entries: z.array(entrySchema).default([])
+const baselineSchema = object({
+	schemaVersion: number(),
+	createdOn: withDefault(string(), () => ""),
+	entries: withDefault(array(entrySchema), () => [])
 });
 var BaselineError = class extends Error {
 	name = "BaselineError";
@@ -142,7 +142,7 @@ async function readBaseline(file, cwd = process.cwd()) {
 	} catch (cause) {
 		throw new BaselineError(`${path.basename(target)} is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
 	}
-	const result = baselineSchema.safeParse(value);
+	const result = safeParse(baselineSchema, value);
 	if (!result.success) {
 		const issues = result.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`).slice(0, 5);
 		throw new BaselineError(`${path.basename(target)} is not an eaa-kit baseline (${issues.join("; ")})`);

package/dist/cli/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { f as COUNTRIES, h as STATEMENT_LOCALES, i as readAuditReport, l as loadConfig, o as StatementError, p as ConfigError, t as renderStatement } from "../render-K9KxDDSA.js";
+import { l as STATEMENT_LOCALES, o as COUNTRIES, r as loadConfig, s as ConfigError } from "../load-sCkKsvGQ.js";
+import { i as readAuditReport, o as StatementError, t as renderStatement } from "../render-BO0nVrrZ.js";
 import { i as isImpactLevel, n as IMPACT_LEVELS, t as DEFAULT_FAIL_ON } from "../impact-DvgBjupx.js";
 import { t as TOOL_VERSION } from "../version-B3v4rNoG.js";
-import { i as buildBaseline, n as DEFAULT_BASELINE_FILE, s as writeBaseline, t as BaselineError } from "../baseline-DQTnNlc4.js";
-import { a as collectPages, i as BuildDirectoryError, n as isOutputFormat, r as runAuditCommand, t as OUTPUT_FORMATS } from "../audit-6gbV0Zjd.js";
+import { i as buildBaseline, n as DEFAULT_BASELINE_FILE, s as writeBaseline, t as BaselineError } from "../baseline-CgBmzFTr.js";
+import { i as resolvePages, n as isOutputFormat, r as runAuditCommand, t as OUTPUT_FORMATS } from "../audit-D4gju2BT.js";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { Command, InvalidArgumentError } from "commander";
@@ -23,39 +24,26 @@ import pc from "picocolors";
 */
 async function runBaselineCommand(dir, options = {}) {
 	const cwd = options.cwd ?? process.cwd();
-	let pages;
-	try {
-		pages = await collectPages(path.resolve(cwd, dir), {
-			...options.include ? { include: options.include } : {},
-			...options.exclude ? { exclude: options.exclude } : {}
-		});
-	} catch (cause) {
-		if (cause instanceof BuildDirectoryError) {
-			process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-			return {
-				entries: 0,
-				exitCode: 2
-			};
-		}
-		throw cause;
-	}
-	if (pages.length === 0) {
-		process.stderr.write(`${pc.yellow("warning")} No HTML files found in ${dir}\n`);
-		return {
-			entries: 0,
-			exitCode: 2
-		};
-	}
-	process.stderr.write(pc.dim(`Auditing ${pages.length} ${pages.length === 1 ? "page" : "pages"} in ${dir}…\n`));
+	const resolved = await resolvePages(path.resolve(cwd, dir), {
+		...options,
+		label: dir
+	});
+	if (!resolved) return {
+		entries: 0,
+		exitCode: 2
+	};
+	const { pages, origin, label } = resolved;
+	process.stderr.write(pc.dim(`Auditing ${pages.length} ${pages.length === 1 ? "page" : "pages"} in ${label}…\n`));
+	const effectiveBaseUrl = options.baseUrl ?? origin;
 	const runnerOptions = {
-		...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+		...effectiveBaseUrl === void 0 ? {} : { baseUrl: effectiveBaseUrl },
 		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
 	};
 	let audits;
 	if (options.browser) {
-		const { BrowserUnavailableError, runBrowserAudit } = await import("../playwright-BfWuTG_u.js");
+		const { BrowserUnavailableError, runBrowserAudit } = await import("../playwright-DWux49V3.js");
 		try {
-			audits = await runBrowserAudit(path.resolve(cwd, dir), pages, runnerOptions);
+			audits = await runBrowserAudit(options.url === void 0 ? path.resolve(cwd, dir) : void 0, pages, runnerOptions);
 		} catch (cause) {
 			if (cause instanceof BrowserUnavailableError) {
 				process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
@@ -177,8 +165,10 @@ function formatFor(output) {
 const program = new Command();
 program.exitOverride();
 program.name("eaa-kit").description("WCAG 2.2 AA auditor and EU accessibility statement generator for static sites.\nNot legal advice.").version(TOOL_VERSION, "-v, --version");
-program.command("audit").description("Audit built HTML against WCAG 2.2 AA").argument("[dir]", "directory holding the built site", "./dist").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--fail-on <impact>", `exit 1 on violations at or above this impact (${IMPACT_LEVELS.join("|")})`, parseImpact, DEFAULT_FAIL_ON).option("--format <format>", `output format (${OUTPUT_FORMATS.join("|")})`, parseFormat, "console").option("--output <path>", "write the report to a file instead of stdout").option("--browser", "audit in real Chromium, covering the rules jsdom cannot evaluate").option("--concurrency <n>", "worker threads to audit with, or 1 for none (default: from the page and core count)", parseConcurrency).option("--baseline <path>", "accept the violations recorded in this file; fail only on new ones").action(async (dir, options) => {
+program.command("audit").description("Audit built HTML against WCAG 2.2 AA").argument("[dir]", "directory holding the built site (default: found automatically)").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "audit a running site instead of a build directory").option("--no-build", "never run the project build or start its server").option("--per-page", "also list every page and its result").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--fail-on <impact>", `exit 1 on violations at or above this impact (${IMPACT_LEVELS.join("|")})`, parseImpact, DEFAULT_FAIL_ON).option("--format <format>", `output format (${OUTPUT_FORMATS.join("|")})`, parseFormat, "console").option("--output <path>", "write the report to a file instead of stdout").option("--browser", "audit in real Chromium, covering the rules jsdom cannot evaluate").option("--concurrency <n>", "worker threads to audit with, or 1 for none (default: from the page and core count)", parseConcurrency).option("--baseline <path>", "accept the violations recorded in this file; fail only on new ones").action(async (dir, options) => {
 	const { exitCode } = await runAuditCommand(dir, {
+		...options["build"] === false ? { noBuild: true } : {},
+		...options["perPage"] === true ? { perPage: true } : {},
 		...Array.isArray(options["include"]) ? { include: options["include"] } : {},
 		...Array.isArray(options["exclude"]) ? { exclude: options["exclude"] } : {},
 		...typeof options["baseUrl"] === "string" ? { baseUrl: options["baseUrl"] } : {},
@@ -187,11 +177,16 @@ program.command("audit").description("Audit built HTML against WCAG 2.2 AA").arg
 		...typeof options["output"] === "string" ? { output: options["output"] } : {},
 		...options["browser"] === true ? { browser: true } : {},
 		...typeof options["concurrency"] === "number" ? { concurrency: options["concurrency"] } : {},
-		...typeof options["baseline"] === "string" ? { baseline: options["baseline"] } : {}
+		...typeof options["baseline"] === "string" ? { baseline: options["baseline"] } : {},
+		...typeof options["url"] === "string" ? { url: options["url"] } : {},
+		...options["allowRemote"] === true ? { allowRemote: true } : {},
+		...options["ignoreRobots"] === true ? { ignoreRobots: true } : {},
+		...typeof options["maxPages"] === "number" ? { maxPages: options["maxPages"] } : {},
+		...typeof options["maxDepth"] === "number" ? { maxDepth: options["maxDepth"] } : {}
 	});
 	process.exitCode = exitCode;
 });
-program.command("baseline").description("Record the violations a build already has, so later runs fail only on new ones").argument("[dir]", "directory holding the built site", "./dist").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--output <path>", `where to write it (default: ${DEFAULT_BASELINE_FILE})`).option("--note <text>", "recorded on every entry, for whoever reads the file").option("--expires-on <date>", "ISO date after which the entries stop suppressing", parseDate).option("--browser", "audit in real Chromium instead of jsdom").option("--concurrency <n>", "worker threads to audit with, or 1 for none", parseConcurrency).action(async (dir, options) => {
+program.command("baseline").description("Record the violations a build already has, so later runs fail only on new ones").argument("[dir]", "directory holding the built site", "./dist").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "record a baseline from a running site instead of a directory").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--output <path>", `where to write it (default: ${DEFAULT_BASELINE_FILE})`).option("--note <text>", "recorded on every entry, for whoever reads the file").option("--expires-on <date>", "ISO date after which the entries stop suppressing", parseDate).option("--browser", "audit in real Chromium instead of jsdom").option("--concurrency <n>", "worker threads to audit with, or 1 for none", parseConcurrency).action(async (dir, options) => {
 	const { exitCode } = await runBaselineCommand(dir, {
 		...Array.isArray(options["include"]) ? { include: options["include"] } : {},
 		...Array.isArray(options["exclude"]) ? { exclude: options["exclude"] } : {},
@@ -200,7 +195,21 @@ program.command("baseline").description("Record the violations a build already h
 		...typeof options["note"] === "string" ? { note: options["note"] } : {},
 		...typeof options["expiresOn"] === "string" ? { expiresOn: options["expiresOn"] } : {},
 		...options["browser"] === true ? { browser: true } : {},
-		...typeof options["concurrency"] === "number" ? { concurrency: options["concurrency"] } : {}
+		...typeof options["concurrency"] === "number" ? { concurrency: options["concurrency"] } : {},
+		...typeof options["url"] === "string" ? { url: options["url"] } : {},
+		...options["allowRemote"] === true ? { allowRemote: true } : {},
+		...options["ignoreRobots"] === true ? { ignoreRobots: true } : {},
+		...typeof options["maxPages"] === "number" ? { maxPages: options["maxPages"] } : {},
+		...typeof options["maxDepth"] === "number" ? { maxDepth: options["maxDepth"] } : {}
+	});
+	process.exitCode = exitCode;
+});
+program.command("init").description("Write an eaa.config.json to generate statements from").option("--output <path>", "write here instead of eaa.config.json").option("--force", "overwrite a config that is already there").option("-y, --yes", "take every default without asking").action(async (options) => {
+	const { runInitCommand } = await import("../init-DRKIdpK1.js");
+	const { exitCode } = await runInitCommand({
+		...typeof options["output"] === "string" ? { output: options["output"] } : {},
+		...options["force"] === true ? { force: true } : {},
+		...options["yes"] === true ? { yes: true } : {}
 	});
 	process.exitCode = exitCode;
 });
@@ -232,6 +241,17 @@ function parseDate(value) {
 	if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || Number.isNaN(Date.parse(`${value}T00:00:00Z`))) throw new InvalidArgumentError("expected an ISO date, e.g. 2026-12-31");
 	return value;
 }
+function parsePositive(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 1) throw new InvalidArgumentError("expected a whole number of 1 or more");
+	return parsed;
+}
+/** Depth 0 is meaningful here: audit only the entry page. */
+function parseDepth(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 0) throw new InvalidArgumentError("expected a whole number of 0 or more");
+	return parsed;
+}
 function parseConcurrency(value) {
 	const parsed = Number(value);
 	if (!Number.isInteger(parsed) || parsed < 1) throw new InvalidArgumentError("expected a whole number of 1 or more");

package/dist/crawl-CtJbMNNb.js

@@ -0,0 +1,254 @@
+/** Requests in flight at once. Politeness, not throughput. */
+const REQUEST_CONCURRENCY = 4;
+var CrawlError = class extends Error {
+	name = "CrawlError";
+};
+/** Hosts that are this machine. Anything else needs allowRemote. */
+function isLoopback(hostname) {
+	const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	return host === "localhost" || host === "::1" || host.endsWith(".localhost") || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host);
+}
+function parseEntryUrl(raw, allowRemote = false) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new CrawlError(`${raw} is not a URL. Include the scheme, e.g. http://localhost:3000`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new CrawlError(`${raw} is not an http or https URL`);
+	if (!allowRemote && !isLoopback(url.hostname)) throw new CrawlError(`${url.host} is not a local address, and eaa-kit does not crawl remote hosts by default.\n  Auditing a site you do not control sends it traffic and reads pages you may not
+  have meant to. Pass --allow-remote if this is your site and you meant to.`);
+	return url;
+}
+/**
+* Page path used as the page's identity, relative to the origin.
+*
+* This is what appears in reports and what a baseline matches on, so it has to
+* be stable across runs and independent of how the link was written. The query
+* string is dropped — two URLs differing only by a tracking parameter are the
+* same page — and the fragment with it.
+*/
+function pageIdentity(url) {
+	const path = url.pathname.replace(/^\/+/, "");
+	return path === "" ? "/" : path;
+}
+/** Same site: same protocol, host and port. */
+function sameOrigin(a, b) {
+	return a.origin === b.origin;
+}
+/**
+* Links worth following. Anything that is not a page — an asset, a download, a
+* mailto: — is left alone, and so is anything off-origin.
+*/
+const NON_PAGE = /\.(?:css|js|mjs|json|xml|txt|png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|eot|pdf|zip|gz|mp4|webm|mp3|wav)$/i;
+function linksFrom(html, from) {
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of html.matchAll(/<a\b[^>]*?\shref\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+))/gi)) {
+		const raw = (match[2] ?? match[3] ?? match[4] ?? "").trim();
+		if (raw === "" || raw.startsWith("#")) continue;
+		if (/^(?:mailto|tel|javascript|data):/i.test(raw)) continue;
+		let target;
+		try {
+			target = new URL(raw, from);
+		} catch {
+			continue;
+		}
+		target.hash = "";
+		if (!sameOrigin(target, from)) continue;
+		if (NON_PAGE.test(target.pathname)) continue;
+		if (seen.has(target.href)) continue;
+		seen.add(target.href);
+		found.push(target);
+	}
+	return found;
+}
+/** Page URLs listed in a sitemap, including one level of sitemap index. */
+function urlsFromSitemap(xml, origin) {
+	const urls = [];
+	for (const match of xml.matchAll(/<loc>\s*([^<]+?)\s*<\/loc>/gi)) {
+		const raw = match[1];
+		if (!raw) continue;
+		try {
+			const url = new URL(raw);
+			url.hash = "";
+			if (sameOrigin(url, origin)) urls.push(url);
+		} catch {}
+	}
+	return urls;
+}
+/** One request, with a timeout, returning HTML or a reason it is not a page. */
+async function fetchPage(url, impl, timeoutMs, origin) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const response = await impl(url.href, {
+			signal: controller.signal,
+			redirect: "follow",
+			headers: {
+				accept: "text/html,application/xhtml+xml",
+				"user-agent": "eaa-kit"
+			}
+		});
+		if (!response.ok) return {
+			ok: false,
+			reason: `HTTP ${response.status}`
+		};
+		const finalUrl = new URL(response.url || url.href);
+		finalUrl.hash = "";
+		if (finalUrl.origin !== origin) return {
+			ok: false,
+			reason: `redirected off ${origin} to ${finalUrl.origin}`
+		};
+		const type = response.headers.get("content-type") ?? "";
+		if (!/\b(?:text\/html|application\/xhtml\+xml)\b/i.test(type)) return {
+			ok: false,
+			reason: `not HTML (${type.split(";")[0] || "no content-type"})`
+		};
+		return {
+			ok: true,
+			value: {
+				url: finalUrl,
+				html: await response.text()
+			}
+		};
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		return {
+			ok: false,
+			reason: controller.signal.aborted ? `timed out after ${timeoutMs}ms` : message
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Paths robots.txt disallows for us. Only the wildcard group is read. */
+function disallowedPaths(robots) {
+	const lines = robots.split(/\r?\n/).map((line) => line.replace(/#.*$/, "").trim());
+	const paths = [];
+	let applies = false;
+	for (const line of lines) {
+		const agent = /^user-agent\s*:\s*(.+)$/i.exec(line);
+		if (agent) {
+			applies = (agent[1] ?? "").trim() === "*";
+			continue;
+		}
+		const rule = /^disallow\s*:\s*(.*)$/i.exec(line);
+		if (rule && applies) {
+			const value = (rule[1] ?? "").trim();
+			if (value !== "") paths.push(value);
+		}
+	}
+	return paths;
+}
+/**
+* Paths this crawler must not visit, from the site's own robots.txt.
+*
+* Read directly rather than through fetchPage, which correctly refuses anything
+* that is not a page. A site with no robots.txt disallows nothing.
+*/
+async function blockedPaths(entry, impl) {
+	try {
+		const response = await impl(new URL("/robots.txt", entry).href, { redirect: "follow" });
+		return response.ok ? disallowedPaths(await response.text()) : [];
+	} catch {
+		return [];
+	}
+}
+/**
+* Page URLs the site lists for itself.
+*
+* Worth one request: a sitemap finds pages nothing links to, which link
+* following alone never reaches.
+*/
+async function sitemapUrls(entry, impl) {
+	try {
+		const response = await impl(new URL("/sitemap.xml", entry).href, { redirect: "follow" });
+		return response.ok ? urlsFromSitemap(await response.text(), entry) : [];
+	} catch {
+		return [];
+	}
+}
+/**
+* Fetch a site's pages, starting at `entry`.
+*
+* Pages come back sorted by identity, so two crawls of the same site produce
+* the same report even though the requests finish in whatever order the server
+* answers them — the same guarantee the directory collector gives.
+*/
+async function crawlSite(entry, options = {}) {
+	const impl = options.fetchImpl ?? fetch;
+	const maxPages = options.maxPages ?? 200;
+	const maxDepth = options.maxDepth ?? 3;
+	const timeoutMs = options.timeoutMs ?? 15e3;
+	const failures = [];
+	const blocked = options.ignoreRobots ? [] : await blockedPaths(entry, impl);
+	const allowed = (url) => !blocked.some((path) => url.pathname.startsWith(path));
+	let discovery = "links";
+	const queue = [];
+	const queued = /* @__PURE__ */ new Set();
+	const enqueue = (url, depth) => {
+		if (queued.has(url.href) || !allowed(url)) return;
+		queued.add(url.href);
+		queue.push({
+			url,
+			depth
+		});
+	};
+	const listed = await sitemapUrls(entry, impl);
+	if (listed.length > 0) {
+		discovery = "sitemap";
+		for (const url of listed) enqueue(url, 0);
+	}
+	enqueue(entry, 0);
+	const pages = [];
+	while (queue.length > 0 && pages.length < maxPages) {
+		const batch = queue.splice(0, Math.min(REQUEST_CONCURRENCY, maxPages - pages.length));
+		const results = await Promise.all(batch.map(async (item) => ({
+			item,
+			result: await fetchPage(item.url, impl, timeoutMs, entry.origin)
+		})));
+		for (const { item, result } of results) {
+			if (!result.ok) {
+				failures.push({
+					url: item.url.href,
+					reason: result.reason
+				});
+				continue;
+			}
+			const { url, html } = result.value;
+			pages.push({
+				absolutePath: url.href,
+				relativePath: pageIdentity(url),
+				html: html.charCodeAt(0) === 65279 ? html.slice(1) : html
+			});
+			options.onProgress?.(pages.length, queue.length);
+			if (item.depth < maxDepth) for (const link of linksFrom(html, url)) enqueue(link, item.depth + 1);
+		}
+	}
+	return {
+		pages: byIdentity(pages),
+		origin: entry.origin,
+		failures,
+		truncated: queue.length > 0,
+		discovery
+	};
+}
+/**
+* One page per identity, in a stable order.
+*
+* The queue already refuses a URL it has seen, so this catches the case the
+* queue cannot: two different URLs that redirect to the same page. Sorting is
+* what makes two crawls of one site produce the same report even though the
+* requests finish in whatever order the server answers them.
+*/
+function byIdentity(pages) {
+	const seen = /* @__PURE__ */ new Set();
+	return pages.filter((page) => {
+		if (seen.has(page.relativePath)) return false;
+		seen.add(page.relativePath);
+		return true;
+	}).sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+//#endregion
+export { CrawlError, crawlSite, parseEntryUrl };