@queryrev/ai-readiness 0.0.0-stage → 1.0.0

package/dist/chunks/findings-_twhMw3_.js

@@ -0,0 +1,2950 @@
+import { m as createTextFetcher, n as CHECK_BUDGET_MS, p as checkTextUrl } from "./fetch-text-NUUnM91O.js";
+import { Readable } from "node:stream";
+import { createGunzip } from "node:zlib";
+// src/facts/app-shell.ts
+/**
+* The empty application shell: an HTML document over a few KiB that carries almost no text and
+* an application root element, or asks the reader to enable JavaScript. The constants are the
+* ones the site crawler's render decision uses (it imports them from here), so a page is called
+* a shell by one rule everywhere.
+*/
+/** An empty shell is HTML over this many bytes (5 KB, read as 5 KiB)... */
+var EMPTY_SHELL_MIN_BYTES = 5120;
+/** ...with fewer than this many words of main text... */
+var EMPTY_SHELL_MAX_WORDS = 50;
+/**
+* ...and an application root element. Ids that the common frameworks mount into: React
+* (create-react-app, Vite), Vue, Next.js, Nuxt, Gatsby, SvelteKit, Quasar, Remix, Docusaurus.
+*/
+var APP_ROOT_IDS = Object.freeze([
+	"root",
+	"app",
+	"__next",
+	"__nuxt",
+	"___gatsby",
+	"svelte",
+	"q-app",
+	"remix-root",
+	"__docusaurus",
+	"main-app",
+	"app-root"
+]);
+/** Elements and attributes that mark an application root besides the ids (Angular, AngularJS, React, Vue SSR). */
+var APP_ROOT_TAG = "app-root";
+var APP_ROOT_ATTRIBUTES = Object.freeze([
+	"ng-version",
+	"ng-app",
+	"data-reactroot",
+	"data-server-rendered"
+]);
+/** The same marks as one CSS selector, for a reader that has a DOM. */
+var APP_ROOT_SELECTOR = [
+	...APP_ROOT_IDS.map((id) => `[id="${id}"]`),
+	APP_ROOT_TAG,
+	...APP_ROOT_ATTRIBUTES.map((name) => `[${name}]`)
+].join(", ");
+/** "Enable JavaScript" notices, in the words sites use. */
+var JS_NOTICE = /\b(?:enable|turn on|activate|allow)\s+javascript\b|\bjavascript\s+(?:is\s+)?(?:required|disabled|needed|must be enabled|is not enabled|to run this app)\b|\brequires?\s+javascript\b|\bwithout\s+javascript\b/i;
+/** Whether one start tag (its name and its attributes by name) is an application root. */
+function isAppRoot(name, attributes) {
+	if (name === "app-root") return true;
+	const id = attributes.get("id");
+	if (id !== void 0 && APP_ROOT_IDS.includes(id)) return true;
+	return APP_ROOT_ATTRIBUTES.some((attribute) => attributes.has(attribute));
+}
+// src/robots/index.ts
+/**
+* robots.txt (RFC 9309). Parsing and matching are pure functions of text.
+*
+* Matching: the group whose user-agent equals the product token (case-insensitive) applies,
+* all such groups merged; otherwise the `*` groups merged; otherwise nothing is disallowed.
+* The longest matching rule wins, `allow` wins a tie. `*` matches any run of characters and a
+* final `$` anchors the end. `/robots.txt` itself is always allowed.
+*/
+/** Bytes of a robots.txt that are parsed (RFC 9309 asks for at least 500 KiB). */
+var ROBOTS_MAX_BYTES = 512e3;
+/** A robots.txt answer is used for at most this long (RFC 9309, section 2.4). */
+var ROBOTS_MAX_AGE_MS = 864e5;
+/** Redirects followed for robots.txt (RFC 9309 asks for at least five). */
+var ROBOTS_MAX_REDIRECTS = 5;
+var HEX = /%([0-9a-fA-F]{2})/g;
+var UNRESERVED = /[A-Za-z0-9\-._~]/;
+/**
+* One form for patterns and paths: non-ASCII and characters outside the URL path set
+* percent-encoded as UTF-8, escape hex upper case, escapes of unreserved characters decoded.
+* `*` and `$` in a pattern keep their meaning.
+*/
+function canonicalPath(text) {
+	let out = "";
+	for (const char of text) {
+		const code = char.codePointAt(0);
+		if (code > 126 || code <= 32 || char === "\"" || char === "<" || char === ">" || char === "`") for (const byte of Buffer.from(char, "utf8")) out += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+		else out += char;
+	}
+	return out.replace(HEX, (escape, hex) => {
+		const decoded = String.fromCharCode(parseInt(hex, 16));
+		return UNRESERVED.test(decoded) ? decoded : `%${hex.toUpperCase()}`;
+	});
+}
+/** The product token at the start of a `User-agent` value (`Googlebot/2.1` → `googlebot`). */
+function agentToken(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("*")) return "*";
+	const match = /^[A-Za-z_-]+/.exec(trimmed);
+	return match ? match[0].toLowerCase() : "";
+}
+/**
+* Parses a robots.txt body. Never throws; unknown lines are ignored. A group is a run of
+* user-agent lines and the rules after it; only an Allow or Disallow line ends the run, so a
+* Sitemap, Crawl-delay or unknown line between two user-agent lines does not split the group.
+*/
+function parseRobots(body, robotsUrl) {
+	let text = body.length > 512e3 ? body.slice(0, ROBOTS_MAX_BYTES) : body;
+	if (text.charCodeAt(0) === 65279) text = text.slice(1);
+	const groups = [];
+	const sitemaps = [];
+	let current = null;
+	let lastWasAgent = false;
+	let lineNumber = 0;
+	for (const rawLine of text.split(/\r\n|\r|\n/)) {
+		lineNumber += 1;
+		const line = rawLine.replace(/#.*$/, "").trim();
+		const colon = line.indexOf(":");
+		if (colon === -1) continue;
+		const key = line.slice(0, colon).trim().toLowerCase();
+		const value = line.slice(colon + 1).trim();
+		switch (key) {
+			case "user-agent": {
+				const token = agentToken(value);
+				if (!lastWasAgent || current === null) {
+					current = {
+						agents: [],
+						rules: [],
+						crawlDelay: null,
+						line: lineNumber
+					};
+					groups.push(current);
+				}
+				if (token !== "") current.agents.push(token);
+				lastWasAgent = true;
+				break;
+			}
+			case "allow":
+			case "disallow":
+				lastWasAgent = false;
+				if (current === null || value === "") break;
+				if (!value.startsWith("/") && !value.startsWith("*")) break;
+				current.rules.push({
+					allow: key === "allow",
+					pattern: canonicalPath(value),
+					line: lineNumber
+				});
+				break;
+			case "crawl-delay": {
+				const seconds = Number(value);
+				if (current !== null && Number.isFinite(seconds) && seconds >= 0) current.crawlDelay = Math.max(current.crawlDelay ?? 0, seconds);
+				break;
+			}
+			case "sitemap": try {
+				sitemaps.push(new URL(value, robotsUrl).href);
+			} catch {}
+		}
+	}
+	return Object.freeze({
+		groups: Object.freeze(groups.map((group) => Object.freeze({
+			agents: Object.freeze(group.agents),
+			rules: Object.freeze(group.rules),
+			crawlDelay: group.crawlDelay,
+			line: group.line
+		}))),
+		sitemaps: Object.freeze([...new Set(sitemaps)])
+	});
+}
+/** Whether a pattern matches the start of a path (RFC 9309 2.2.3). */
+function patternMatches(pattern, path) {
+	const anchored = pattern.endsWith("$");
+	const parts = (anchored ? pattern.slice(0, -1) : pattern).split("*");
+	if (!path.startsWith(parts[0])) return false;
+	let position = parts[0].length;
+	for (let index = 1; index < parts.length; index += 1) {
+		const part = parts[index];
+		if (index === parts.length - 1 && anchored) return path.length - part.length >= position && path.endsWith(part);
+		const found = path.indexOf(part, position);
+		if (found === -1) return false;
+		position = found + part.length;
+	}
+	return anchored ? position === path.length : true;
+}
+/** The groups that apply to a product token, merged (RFC 9309 2.2.1). */
+function groupsFor(robots, productToken) {
+	const token = productToken.toLowerCase();
+	const exact = robots.groups.filter((group) => group.agents.includes(token));
+	if (exact.length > 0) return exact;
+	return robots.groups.filter((group) => group.agents.includes("*"));
+}
+var NO_RULE = Object.freeze({
+	best: null,
+	bestGroup: null
+});
+/**
+* The deciding rule for a set of groups and a path, computed once per robots.txt: agents that
+* share their groups (several named in one group, or all on the catch-all) and repeated
+* questions reuse it, so a file of many rules is matched about once per path, not once per
+* agent. Kept with the parsed file and dropped with it.
+*/
+var DECIDED = /* @__PURE__ */ new WeakMap();
+function decidingRule(robots, groups, path) {
+	let cache = DECIDED.get(robots);
+	if (cache === void 0) {
+		cache = {
+			index: new Map(robots.groups.map((group, index) => [group, index])),
+			rules: /* @__PURE__ */ new Map()
+		};
+		DECIDED.set(robots, cache);
+	}
+	const key = `${groups.map((group) => cache.index.get(group)).join(",")}|${path}`;
+	const known = cache.rules.get(key);
+	if (known !== void 0) return known;
+	let best = null;
+	let bestGroup = null;
+	for (const group of groups) for (const rule of group.rules) {
+		if (!patternMatches(rule.pattern, path)) continue;
+		if (best === null || rule.pattern.length > best.pattern.length || rule.pattern.length === best.pattern.length && rule.allow && !best.allow) {
+			best = rule;
+			bestGroup = group;
+		}
+	}
+	const decided = Object.freeze({
+		best,
+		bestGroup
+	});
+	cache.rules.set(key, decided);
+	return decided;
+}
+function matchRobots(robots, productToken, pathAndQuery) {
+	const token = productToken.toLowerCase();
+	const groups = groupsFor(robots, token);
+	const via = groups.length === 0 ? "none" : token !== "*" && groups[0].agents.includes(token) ? "named" : "catch_all";
+	const path = canonicalPath(pathAndQuery === "" ? "/" : pathAndQuery);
+	const { best, bestGroup } = path === "/robots.txt" ? NO_RULE : decidingRule(robots, groups, path);
+	const shown = bestGroup ?? groups[0] ?? null;
+	return Object.freeze({
+		allowed: best === null || best.allow,
+		via,
+		group: shown === null ? null : Object.freeze({
+			line: shown.line,
+			agents: shown.agents
+		}),
+		rule: best
+	});
+}
+/**
+* Whether robots.txt allows a URL path (path plus `?query`, as sent in the request line) for
+* a product token.
+*/
+function isAllowedByRobots(robots, productToken, pathAndQuery) {
+	return matchRobots(robots, productToken, pathAndQuery).allowed;
+}
+/** `Crawl-delay` for a product token, in seconds; null when none is set. */
+function crawlDelayFor(robots, productToken) {
+	const delays = groupsFor(robots, productToken).map((group) => group.crawlDelay).filter((delay) => delay !== null);
+	return delays.length === 0 ? null : Math.max(...delays);
+}
+// src/crawlers/index.ts
+/**
+* Which AI crawlers are measured, and what a robots.txt says to each of them. Nothing outside
+* `STUDY_AGENTS` is measured or named.
+*/
+/**
+* The product tokens measured, and the catch-all. The study names the vendors it measures on its
+* page; any crawler not listed here is neither measured nor named.
+*/
+var STUDY_AGENTS = [
+	"GPTBot",
+	"OAI-SearchBot",
+	"ChatGPT-User",
+	"PerplexityBot",
+	"Perplexity-User",
+	"Google-Extended",
+	"Applebot-Extended",
+	"CCBot",
+	"Meta-ExternalAgent",
+	"Amazonbot",
+	"Bytespider",
+	"*"
+];
+/** The AI agents (every measured token but the catch-all). */
+var AI_AGENTS = STUDY_AGENTS.filter((agent) => agent !== "*");
+/** A pattern that matches every path: `/`, `/*` or `*`. */
+function wholeSite(pattern) {
+	return pattern === "/" || pattern === "/*" || pattern === "*";
+}
+/**
+* Verdicts depend only on the groups that apply, so they are kept per parsed file and per set
+* of groups: agents named together, or all left to the catch-all, share one computation, and a
+* large file is read about once whatever the number of agents asked about.
+*/
+var VERDICTS = /* @__PURE__ */ new WeakMap();
+function memoFor(robots) {
+	let memo = VERDICTS.get(robots);
+	if (memo === void 0) {
+		memo = {
+			index: new Map(robots.groups.map((group, index) => [group, index])),
+			housekeeping: null,
+			byGroups: /* @__PURE__ */ new Map()
+		};
+		VERDICTS.set(robots, memo);
+	}
+	return memo;
+}
+function agentVerdict(robots, agent) {
+	const token = agent.toLowerCase();
+	const own = token === "*" ? [] : robots.groups.filter((group) => group.agents.includes(token));
+	const named = own.length > 0;
+	const memo = memoFor(robots);
+	const key = named ? own.map((group) => memo.index.get(group)).join(",") : "*";
+	const known = memo.byGroups.get(key);
+	if (known !== void 0) return known;
+	const verdict = computeVerdict(robots, agent, own, named, memo);
+	memo.byGroups.set(key, verdict);
+	return verdict;
+}
+function computeVerdict(robots, agent, own, named, memo) {
+	const rules = (named ? own : robots.groups.filter((group) => group.agents.includes("*"))).flatMap((group) => group.rules);
+	const as = named ? agent : "*";
+	const rootAllowed = isAllowedByRobots(robots, as, "/");
+	const allows = rules.filter((rule) => rule.allow);
+	const disallows = rules.filter((rule) => !rule.allow);
+	let access;
+	if (!rootAllowed) access = !disallows.some((rule) => wholeSite(rule.pattern)) || allows.some((rule) => !wholeSite(rule.pattern)) ? "partial" : "blocked";
+	else if (disallows.some((rule) => wholeSite(rule.pattern))) access = allows.some((rule) => wholeSite(rule.pattern)) ? "allowed" : "partial";
+	else {
+		memo.housekeeping ??= new Set(robots.groups.filter((group) => group.agents.includes("*")).flatMap((group) => group.rules).filter((rule) => !rule.allow).map((rule) => rule.pattern));
+		const housekeeping = memo.housekeeping;
+		access = named && disallows.some((rule) => !housekeeping.has(rule.pattern)) ? "partial" : "allowed";
+	}
+	return Object.freeze({
+		access,
+		named,
+		llmsTxt: isAllowedByRobots(robots, as, "/llms.txt")
+	});
+}
+/** The verdicts of every measured agent for one robots.txt. */
+function verdictsFor(robots) {
+	return Object.fromEntries(STUDY_AGENTS.map((agent) => [agent, agentVerdict(robots, agent)]));
+}
+/** The purposes, in the order they are listed. */
+var CRAWLER_PURPOSES = [
+	"training",
+	"search",
+	"user"
+];
+/** The crawlers covered, in the order of `AI_AGENTS`. No other crawler is measured or named. */
+var CRAWLERS = Object.freeze([
+	{
+		token: "GPTBot",
+		vendor: "OpenAI",
+		purpose: "training"
+	},
+	{
+		token: "OAI-SearchBot",
+		vendor: "OpenAI",
+		purpose: "search"
+	},
+	{
+		token: "ChatGPT-User",
+		vendor: "OpenAI",
+		purpose: "user"
+	},
+	{
+		token: "PerplexityBot",
+		vendor: "Perplexity",
+		purpose: "search"
+	},
+	{
+		token: "Perplexity-User",
+		vendor: "Perplexity",
+		purpose: "user"
+	},
+	{
+		token: "Google-Extended",
+		vendor: "Google",
+		purpose: "training"
+	},
+	{
+		token: "Applebot-Extended",
+		vendor: "Apple",
+		purpose: "training"
+	},
+	{
+		token: "CCBot",
+		vendor: "Common Crawl",
+		purpose: "training"
+	},
+	{
+		token: "Meta-ExternalAgent",
+		vendor: "Meta",
+		purpose: "training"
+	},
+	{
+		token: "Amazonbot",
+		vendor: "Amazon",
+		purpose: "search"
+	},
+	{
+		token: "Bytespider",
+		vendor: "ByteDance",
+		purpose: "training"
+	}
+]);
+/** The vendors of the crawlers covered, each once, in the order of `CRAWLERS`. */
+function coveredVendors() {
+	return [...new Set(CRAWLERS.map((crawler) => crawler.vendor))];
+}
+/**
+* The scope line every report carries: which crawlers were checked. A report never claims
+* to cover every AI crawler.
+*/
+function crawlersCoveredLine() {
+	const vendors = coveredVendors();
+	const list = `${vendors.slice(0, -1).join(", ")} and ${vendors[vendors.length - 1]}`;
+	return `Crawlers covered: the ${CRAWLERS.length} AI crawlers on this list, from ${list}. Other crawlers are not checked.`;
+}
+/**
+* The access of every covered crawler: the verdict for the site, and the deciding rule for `/`
+* and for `path` (a path and query, such as `/blog/post?x=1`). A missing robots.txt is an
+* empty one: pass `parseRobots('')`.
+*/
+function crawlerAccess(robots, options = {}) {
+	const path = options.path ?? "/";
+	return CRAWLERS.map((crawler) => {
+		const verdict = agentVerdict(robots, crawler.token);
+		return Object.freeze({
+			crawler,
+			access: verdict.access,
+			named: verdict.named,
+			root: matchRobots(robots, crawler.token, "/"),
+			path: path === "/" ? null : matchRobots(robots, crawler.token, path),
+			llmsTxt: verdict.llmsTxt
+		});
+	});
+}
+// src/llms/index.ts
+/** llms.txt checks: telling the file from a page, and its structure (llmstxt.org). */
+/** A byte order mark at the start of a text. */
+var BOM = new RegExp(`^${String.fromCharCode(65279)}`);
+/** Whether a body is an HTML document (a site that answers every address with a page). */
+function looksLikeHtml(contentType, body) {
+	if (contentType === "text/html" || contentType === "application/xhtml+xml") return true;
+	const start = body.replace(BOM, "").trimStart().slice(0, 200).toLowerCase();
+	return start.startsWith("<!doctype html") || start.startsWith("<html") || start.startsWith("<head");
+}
+/**
+* A robots.txt served at another address (a site that answers every path with it): a
+* `User-agent` line and no Markdown link. It is not an llms.txt, whatever its first line.
+*/
+function looksLikeRobotsTxt(body) {
+	return /^[ \t]*user-agent[ \t]*:/im.test(body) && llmsStructure(body).links === 0;
+}
+/**
+* Characters of a file read for its structure. An llms.txt is meant to be a short map; a
+* longer file is checked on its start, so the work stays small whatever a site serves.
+*/
+var LLMS_STRUCTURE_MAX_CHARS = 262144;
+/** Whitespace as `\s` matches it, tested one character at a time. */
+var SPACE = /\s/;
+/**
+* The Markdown link targets of a text, `[text](target "title")` but not images, in one pass:
+* every search starts after the last, so no text, however built, makes it slower than
+* linear. The link text may not hold `]` or a line break; the target holds no space, `)` or
+* `>`, and may sit in `<…>`; an optional quoted title follows.
+*/
+function linkTargets(text) {
+	const out = [];
+	const length = text.length;
+	let close = -1;
+	let lineEnd = -1;
+	let stop = -1;
+	let at = 0;
+	for (;;) {
+		const open = text.indexOf("[", at);
+		if (open === -1) break;
+		if (close <= open) close = text.indexOf("]", open + 1);
+		if (close === -1) break;
+		if (lineEnd <= open) {
+			const found = text.indexOf("\n", open + 1);
+			lineEnd = found === -1 ? length : found;
+		}
+		if (lineEnd < close) {
+			at = lineEnd + 1;
+			continue;
+		}
+		if (open > 0 && text[open - 1] === "!") {
+			at = open + 1;
+			continue;
+		}
+		at = close + 1;
+		if (text[close + 1] !== "(") continue;
+		let p = close + 2;
+		while (p < length && SPACE.test(text[p])) p += 1;
+		if (text[p] === "<") p += 1;
+		const from = p;
+		if (stop < from) {
+			stop = from;
+			while (stop < length && text[stop] !== ")" && text[stop] !== ">" && !SPACE.test(text[stop])) stop += 1;
+		}
+		p = stop;
+		if (p === from) continue;
+		const target = text.slice(from, p);
+		if (text[p] === ">") p += 1;
+		let q = p;
+		while (q < length && SPACE.test(text[q])) q += 1;
+		if (q > p && text[q] === "\"") {
+			const quote = text.indexOf("\"", q + 1);
+			if (quote !== -1 && quote - q <= 1e3) {
+				let r = quote + 1;
+				while (r < length && SPACE.test(text[r])) r += 1;
+				if (text[r] === ")") {
+					out.push(target);
+					at = r + 1;
+					continue;
+				}
+			}
+		}
+		while (p < length && SPACE.test(text[p])) p += 1;
+		if (text[p] === ")") {
+			out.push(target);
+			at = p + 1;
+		}
+	}
+	return out;
+}
+/** Whether a line holds a link start: a `[` (not an image's) whose text closes with `](`. */
+function hasLinkStart(line) {
+	let open = false;
+	for (let index = 0; index < line.length; index += 1) {
+		const char = line[index];
+		if (char === "[") {
+			if (index === 0 || line[index - 1] !== "!") open = true;
+		} else if (char === "]") {
+			if (open && line[index + 1] === "(") return true;
+			open = false;
+		}
+	}
+	return false;
+}
+function llmsStructure(body) {
+	const full = body.replace(BOM, "");
+	const text = full.length > 262144 ? full.slice(0, LLMS_STRUCTURE_MAX_CHARS) : full;
+	const lines = text.split(/\r\n|\r|\n/);
+	let summary = false;
+	let sections = 0;
+	let inSection = false;
+	let sectionHasLink = false;
+	let seenH2 = false;
+	for (const line of lines) {
+		const trimmed = line.trimStart();
+		if (/^##\s+\S/.test(trimmed) && !trimmed.startsWith("###")) {
+			if (inSection && sectionHasLink) sections += 1;
+			inSection = true;
+			seenH2 = true;
+			sectionHasLink = false;
+			continue;
+		}
+		if (!seenH2 && /^>\s*\S/.test(trimmed)) summary = true;
+		if (inSection && /^[-*+]\s/.test(trimmed) && trimmed.indexOf("](", 2) !== -1 && hasLinkStart(trimmed)) sectionHasLink = true;
+	}
+	if (inSection && sectionHasLink) sections += 1;
+	const targets = linkTargets(text);
+	return {
+		bytes: Buffer.byteLength(full, "utf8"),
+		summary,
+		sections,
+		links: targets.length,
+		structured: sections > 0,
+		targets
+	};
+}
+/**
+* Whether an answer is an llms.txt: a 200, a text type that is not HTML, not a robots.txt
+* served at that address, and a body whose first non-empty line is a Markdown H1 (`# Name`),
+* which is the one part llmstxt.org requires.
+*/
+function looksLikeLlmsTxt(status, contentType, body) {
+	if (status !== 200) return false;
+	if (contentType !== null && !contentType.startsWith("text/")) return false;
+	if (looksLikeHtml(contentType, body)) return false;
+	if (looksLikeRobotsTxt(body)) return false;
+	const first = body.replace(BOM, "").split(/\r\n|\r|\n/).find((line) => line.trim() !== "");
+	return first !== void 0 && /^# \S/.test(first.trimStart());
+}
+/** Characters of an H1 kept in a report. */
+var LLMS_H1_MAX = 200;
+function headings(body) {
+	const found = [];
+	let fenced = false;
+	for (const line of body.replace(BOM, "").split(/\r\n|\r|\n/)) {
+		const trimmed = line.trimStart();
+		if (/^(```|~~~)/.test(trimmed)) {
+			fenced = !fenced;
+			continue;
+		}
+		if (!fenced && /^# \S/.test(trimmed)) found.push(trimmed.slice(2).trim());
+	}
+	return found;
+}
+/**
+* Validates an answer at `/llms.txt` against the llmstxt.org format, after the soft-404 rule:
+* an answer that is not a 200, is HTML, is a robots.txt, or does not start with an H1 is not
+* an llms.txt, whatever its status. Pure: pass what was fetched.
+*/
+function validateLlmsTxt(answer) {
+	const body = answer.body ?? "";
+	const base = {
+		status: answer.status,
+		contentType: answer.contentType,
+		bytes: Buffer.byteLength(body, "utf8"),
+		truncated: answer.truncated
+	};
+	const verdict = (() => {
+		if (answer.status === null) return "no_answer";
+		if (answer.status === 404 || answer.status === 410) return "not_found";
+		if (answer.status !== 200) return "status";
+		if (answer.contentType !== null && !answer.contentType.startsWith("text/")) return "not_text";
+		if (looksLikeHtml(answer.contentType, body)) return "html";
+		if (looksLikeRobotsTxt(body)) return "robots";
+		return looksLikeLlmsTxt(answer.status, answer.contentType, body) ? "llms_txt" : "no_h1";
+	})();
+	if (verdict !== "llms_txt") return Object.freeze({
+		...base,
+		present: false,
+		verdict,
+		h1: null,
+		h1Count: 0,
+		structure: null
+	});
+	const found = headings(body);
+	return Object.freeze({
+		...base,
+		present: true,
+		verdict,
+		h1: found[0] === void 0 ? null : found[0].slice(0, 200),
+		h1Count: found.length,
+		structure: llmsStructure(body)
+	});
+}
+// src/facts/domain.ts
+/**
+* A registrable domain without a public-suffix list. The library keeps one runtime dependency,
+* so the built-in rule is small: the last two labels, or the last three when the last two are a
+* common second-level suffix (`co.uk`, `com.au`). A caller that needs the full list passes its
+* own function (`CheckOptions.registrableDomain`, `ReadHomePageOptions.registrableDomain`).
+*/
+var SECOND_LEVEL = new Set([
+	"co.uk org.uk ac.uk gov.uk me.uk ltd.uk plc.uk net.uk sch.uk",
+	"com.au net.au org.au edu.au gov.au id.au asn.au",
+	"co.nz net.nz org.nz govt.nz ac.nz",
+	"co.jp ne.jp or.jp ac.jp go.jp ad.jp ed.jp gr.jp",
+	"co.kr or.kr ne.kr go.kr ac.kr",
+	"com.cn net.cn org.cn gov.cn edu.cn",
+	"com.hk org.hk net.hk edu.hk gov.hk",
+	"com.tw org.tw net.tw edu.tw gov.tw",
+	"com.sg org.sg net.sg edu.sg gov.sg",
+	"com.my org.my net.my edu.my gov.my",
+	"com.vn net.vn org.vn edu.vn gov.vn",
+	"co.th or.th ac.th go.th in.th",
+	"co.id or.id ac.id go.id web.id",
+	"com.ph org.ph net.ph edu.ph gov.ph",
+	"com.pk org.pk net.pk edu.pk gov.pk",
+	"com.bd org.bd net.bd edu.bd gov.bd",
+	"co.in net.in org.in ac.in gov.in edu.in firm.in gen.in ind.in",
+	"co.il org.il ac.il gov.il net.il",
+	"co.za org.za ac.za gov.za net.za web.za",
+	"com.br net.br org.br gov.br edu.br",
+	"com.ar net.ar org.ar gov.ar edu.ar",
+	"com.mx org.mx net.mx gob.mx edu.mx",
+	"com.co net.co org.co edu.co gov.co",
+	"com.pe com.ve com.uy com.ec com.bo com.py com.pa com.gt com.do",
+	"com.tr net.tr org.tr gov.tr edu.tr",
+	"com.ua org.ua net.ua gov.ua edu.ua",
+	"com.sa org.sa net.sa gov.sa edu.sa",
+	"com.eg org.eg net.eg gov.eg edu.eg",
+	"com.ng org.ng net.ng gov.ng edu.ng",
+	"co.ke or.ke ac.ke go.ke",
+	"com.gh com.tn com.dz com.ma co.ma",
+	"com.ru net.ru org.ru",
+	"com.pl net.pl org.pl",
+	"com.es org.es nom.es",
+	"com.pt org.pt",
+	"com.gr org.gr",
+	"com.cy org.cy",
+	"com.lk com.np com.kh com.mm com.kz"
+].join(" ").split(" "));
+/** A host name as comparisons use it: lower case, without one trailing dot. */
+function normalizeHost(host) {
+	const lower = host.toLowerCase();
+	return lower.endsWith(".") ? lower.slice(0, -1) : lower;
+}
+/**
+* The registrable domain of a host name (`www.shop.example.co.uk` → `example.co.uk`). A name
+* with one label, or an IP literal, is returned as it is.
+*/
+function registrableDomain(host) {
+	const name = normalizeHost(host);
+	if (name.includes(":") || /^\d{1,3}(?:\.\d{1,3}){3}$/.test(name)) return name;
+	const labels = name.split(".");
+	if (labels.length <= 2) return name;
+	const lastTwo = labels.slice(-2).join(".");
+	if (SECOND_LEVEL.has(lastTwo) && labels.length >= 3) return labels.slice(-3).join(".");
+	return lastTwo;
+}
+/** Whether `host` is the registrable domain `domain` or a name under it. */
+function isOnDomain(host, domain) {
+	const name = normalizeHost(host);
+	return name === domain || name.endsWith(`.${domain}`);
+}
+// src/net/charset.ts
+/**
+* Reading a page's bytes as text. One decoder for the library and for the studies built on it,
+* so a page in windows-1251, Shift_JIS, GBK or EUC-KR is counted the same everywhere. The order
+* is the one browsers use, shortened: a byte order mark; the `charset` of the Content-Type
+* header; a `<meta charset>` or `<meta http-equiv="Content-Type">` in the first 2 KiB; else
+* UTF-8. Labels are the WHATWG Encoding Standard's; a label it does not know is skipped.
+*/
+var LABEL = /^[a-z0-9_:.-]{2,40}$/i;
+var HEAD_BYTES = 2048;
+function known(label) {
+	if (label === void 0 || !LABEL.test(label)) return null;
+	try {
+		return new TextDecoder(label).encoding;
+	} catch {
+		return null;
+	}
+}
+/** The character set of a page by the rule above. */
+function detectCharset(bytes, contentTypeHeader) {
+	if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return "utf-8";
+	if (bytes[0] === 255 && bytes[1] === 254) return "utf-16le";
+	if (bytes[0] === 254 && bytes[1] === 255) return "utf-16be";
+	const fromHeader = known(/charset\s*=\s*["']?([^\s;"']+)/i.exec(contentTypeHeader ?? "")?.[1]);
+	if (fromHeader !== null) return fromHeader;
+	const head = Buffer.from(bytes.subarray(0, HEAD_BYTES)).toString("latin1");
+	return known(/<meta[^>]+charset\s*=\s*["']?\s*([a-z0-9_:.-]+)/i.exec(head)?.[1]) ?? "utf-8";
+}
+/**
+* The bytes of an HTML page as text. `contentTypeHeader` is the raw `Content-Type` header, with
+* its parameters. A body cut at a size cap (`truncated`) loses no character to the cut: an
+* incomplete one at the end is held back.
+*/
+function decodeHtml(bytes, contentTypeHeader, truncated = false) {
+	const charset = detectCharset(bytes, contentTypeHeader);
+	return {
+		text: new TextDecoder(charset).decode(bytes, { stream: truncated }),
+		charset
+	};
+}
+// src/facts/marks.ts
+/**
+* Text marks for answers that are not the page asked for: a bot check, and a placeholder (a
+* parking page or a web server's default page). Fixed lists, so the same body gives the same
+* answer in every tool.
+*/
+/** HTML markup anywhere in a body: no robots.txt holds it. */
+var HTML_MARKUP = /<(?:!doctype\s+html|html|head|body|script|meta|title)[\s>]/i;
+/**
+* The marks of a bot check served in place of a file: Cloudflare ("Just a moment…", its
+* challenge platform), reCAPTCHA, hCaptcha, Akamai Bot Manager, HUMAN (PerimeterX), DataDome,
+* Imperva (Incapsula), AWS WAF, Sucuri, a hosting platform's security checkpoint, Kasada, and the
+* generic wording.
+*/
+var CHALLENGE_MARKS = new RegExp([
+	"just a moment\\.\\.\\.",
+	"cf-browser-verification",
+	"cf_chl_",
+	"challenge-platform",
+	"challenges\\.cloudflare\\.com",
+	"attention required! \\| cloudflare",
+	"recaptcha",
+	"hcaptcha",
+	"errors\\.edgesuite\\.net",
+	"_sec/cp_challenge",
+	"bm-verify",
+	"px-captcha",
+	"_pxappid",
+	"perimeterx",
+	"captcha-delivery\\.com",
+	"datadome",
+	"_incapsula_resource",
+	"incapsula incident",
+	"awswaf",
+	"aws-waf-token",
+	"gokuprops",
+	"sucuri website firewall",
+	"sucuri_cloudproxy",
+	`vercel security checkpoint`,
+	"kpsdk",
+	"verify you are human",
+	"checking your browser",
+	"enable javascript and cookies to continue"
+].join("|"), "i");
+/**
+* Whether a 2xx answer at /robots.txt is not the file: a 202 (a check still running, most
+* often), or a body with no robots.txt group that is an HTML page or carries the marks of a bot
+* check. Such a site is "not read", never "read, no rules". A body with at least one group is a
+* file whatever its content type says.
+*/
+function isChallenge(status, body) {
+	if (status === 202) return true;
+	if (parseRobots(body).groups.length > 0) return false;
+	return HTML_MARKUP.test(body) || CHALLENGE_MARKS.test(body);
+}
+/** A page with fewer words than this, carrying an interstitial mark, is a bot check. */
+var CHALLENGE_MAX_WORDS = 100;
+/** A page with fewer words than this, carrying a mark, is a placeholder. */
+var PLACEHOLDER_MAX_WORDS = 150;
+/** Characters of a page searched for marks: the head and the start of the body. */
+var MARKS_SCAN_CHARS = 65536;
+/**
+* What a bot-check page says to a visitor, in its title or visible text: Cloudflare's "Just a
+* moment..." and "One more step", "Checking your browser", Imperva's "Pardon Our Interruption",
+* "Verify you are human", "Access denied" beside a captcha, a security checkpoint, and the
+* generic wording. These are for the home page, matched against text a visitor sees, never
+* against script sources: the scripts of a bot-check vendor (`challenge-platform`, a captcha
+* library, `datadome`) are loaded on ordinary pages too, and an empty application shell that
+* loads one is a page, not a check.
+*/
+var INTERSTITIAL_MARKS = new RegExp([
+	"just a moment\\.\\.\\.",
+	"one more step",
+	"checking your browser",
+	"verify you are human",
+	"are you a robot",
+	"attention required! \\| cloudflare",
+	"pardon our interruption",
+	"please complete the security check",
+	"enable javascript and cookies to continue",
+	"incapsula incident",
+	"sucuri website firewall",
+	"you have been blocked",
+	"access denied[\\s\\S]{0,200}captcha",
+	"captcha[\\s\\S]{0,200}access denied",
+	`vercel security checkpoint`,
+	"press & hold to confirm you are a human"
+].join("|"), "i");
+/**
+* Whether the home page is a bot check: a 202, or a small page (under `CHALLENGE_MAX_WORDS`
+* words of text) whose title or visible text (`text`) carries one of `INTERSTITIAL_MARKS`.
+*/
+function isHomeChallenge(status, text, mainWords) {
+	if (status === 202) return true;
+	if (mainWords >= 100) return false;
+	return INTERSTITIAL_MARKS.test(text);
+}
+/**
+* The marks of a placeholder home page, each a fixed phrase: the default pages of common web
+* servers and control panels, and the wording of domain parking pages. Matched without case
+* against the start of the page's HTML.
+*/
+var PLACEHOLDER_MARKS = Object.freeze([
+	{
+		id: "nginx_default",
+		pattern: /welcome to nginx/i
+	},
+	{
+		id: "apache_default",
+		pattern: /apache2? (?:\w+ )?default page|apache http server test page|test page for the apache/i
+	},
+	{
+		id: "apache_it_works",
+		pattern: /<h1>\s*it works!?\s*<\/h1>/i
+	},
+	{
+		id: "iis_default",
+		pattern: /iis windows server|internet information services|<title>\s*iis7?\b/i
+	},
+	{
+		id: "caddy_default",
+		pattern: /caddy works!/i
+	},
+	{
+		id: "panel_default",
+		pattern: /web server's default page|default web site page|domain default page|plesk default page|cpanel[^<]{0,40}default/i
+	},
+	{
+		id: "hosting_default",
+		pattern: /future home of something quite cool|this site can.t be reached yet|website coming\s+soon.{0,40}(?:namecheap|godaddy)/i
+	},
+	{
+		id: "parked_domain",
+		pattern: /this domain (?:is|may be) (?:for sale|parked|available)|domain (?:name )?(?:is )?for sale|buy this domain|is parked (?:free|courtesy)|parkingcrew|sedoparking|sedo\.com\/search|hugedomains|dan\.com\/buy-domain|afternic\.com\/forsale|bodis\.com|domainsponsor|above\.com\/parked/i
+	}
+]);
+/**
+* Whether the home page is a placeholder: a small page (under `PLACEHOLDER_MAX_WORDS` words of
+* text) that carries one of `PLACEHOLDER_MARKS`. Returns the mark's id, or null.
+*/
+function placeholderMark(html, mainWords) {
+	if (mainWords >= 150) return null;
+	const start = html.slice(0, MARKS_SCAN_CHARS);
+	for (const mark of PLACEHOLDER_MARKS) if (mark.pattern.test(start)) return mark.id;
+	return null;
+}
+// src/facts/words.ts
+/**
+* Word counting by the Unicode word-break rules (`Intl.Segmenter`, word-like segments), so
+* a page in Chinese or Japanese is counted too, where splitting on spaces would find one word.
+*/
+/** Counting stops here: no rule of the library looks past it, and a page cannot make it slow. */
+var MAX_WORDS_COUNTED = 1e5;
+/** Characters given to the word-break rules at most (text that is not plain ASCII). */
+var MAX_SEGMENTED_CHARS = 524288;
+var SEGMENTER = new Intl.Segmenter("en", { granularity: "word" });
+/**
+* A word in plain ASCII text, as the word-break rules see it: a run of letters and digits, with
+* a `.`, `'` or `:` joining two letters, or a `.`, `'`, `,` or `;` joining two digits. A test
+* checks this against `Intl.Segmenter` on random text, so it only makes the common case fast.
+*/
+var ASCII_WORD = /[A-Za-z0-9]+(?:(?:(?<=[A-Za-z])[.':](?=[A-Za-z])|(?<=[0-9])[.',;](?=[0-9]))[A-Za-z0-9]+)*/g;
+var PLAIN_ASCII = /^[\u0000-\u007f]*$/;
+/** Words in `text`, counted up to `limit`. Linear in the length of the text. */
+function countWords(text, limit = MAX_WORDS_COUNTED) {
+	let words = 0;
+	if (PLAIN_ASCII.test(text) && !text.includes("_")) {
+		ASCII_WORD.lastIndex = 0;
+		while (ASCII_WORD.exec(text) !== null) {
+			words += 1;
+			if (words >= limit) return {
+				words,
+				capped: true
+			};
+		}
+		return {
+			words,
+			capped: false
+		};
+	}
+	const cut = text.length > MAX_SEGMENTED_CHARS;
+	for (const segment of SEGMENTER.segment(cut ? text.slice(0, MAX_SEGMENTED_CHARS) : text)) {
+		if (!segment.isWordLike) continue;
+		words += 1;
+		if (words >= limit) return {
+			words,
+			capped: true
+		};
+	}
+	return {
+		words,
+		capped: cut
+	};
+}
+// src/generate/index.ts
+/**
+* llms.txt generation, as pure functions of text: what a page says about itself (its title,
+* first H1 and meta description, as written), the addresses a sitemap lists, and the file
+* built from them. Nothing here fetches; a caller reads the files with `fetchText` and passes
+* the text in.
+*/
+/** Characters kept of each field read from a page. */
+var TITLE_MAX = 200;
+var DESCRIPTION_MAX = 500;
+var NAMED_ENTITIES = Object.freeze({
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " ",
+	ndash: "–",
+	mdash: "—",
+	hellip: "…",
+	rsquo: "’",
+	lsquo: "‘",
+	rdquo: "”",
+	ldquo: "“",
+	copy: "©",
+	reg: "®",
+	trade: "™"
+});
+function decodeEntities(text) {
+	return text.replace(/&(#x[0-9a-fA-F]{1,6}|#[0-9]{1,7}|[a-zA-Z]{2,8});/g, (whole, body) => {
+		if (body.startsWith("#")) {
+			const code = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : Number(body.slice(1));
+			if (!Number.isInteger(code) || code <= 0 || code > 1114111 || code >= 55296 && code <= 57343) return whole;
+			return String.fromCodePoint(code);
+		}
+		return NAMED_ENTITIES[body.toLowerCase()] ?? whole;
+	});
+}
+/**
+* Control characters (C0 but tab and line breaks, DEL, C1), the bidirectional controls that
+* can reorder how text is displayed (including the Arabic letter mark) and the deprecated
+* format controls. Removed from every field read from a site.
+*/
+var UNSAFE_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u206f\u061c]/g;
+/** Text from a site made safe to show: control and reordering characters removed. */
+function stripUnsafeCharacters(text) {
+	return text.replace(UNSAFE_CHARACTERS, "");
+}
+/** Characters of a page read for its title, H1 and meta tags: its head and the start of its body. */
+var PAGE_SCAN_MAX_CHARS = 262144;
+/** Characters of a sitemap scanned: its whole size cap (5 MiB), in one linear pass. */
+var SITEMAP_SCAN_MAX_CHARS = 5242880;
+/**
+* `<loc>` tags looked at in one sitemap, empty or unusable ones included, before the scan
+* stops: enough for any list the tools take addresses from, and a bound on the work a file of
+* millions of empty tags can cause.
+*/
+var MAX_LOC_TAGS_SCANNED = 1e4;
+/**
+* Every parser below reads remote text in one forward pass: each search starts where the last
+* one ended (`indexOf`, or a regular expression of fixed text from `lastIndex`), and a search
+* that finds nothing ends the scan. So no page or sitemap, however it is built, makes the work
+* more than linear in its length; a test feeds each one adversarial text at its cap.
+*/
+/** Tags removed, in one pass: a `<` with no `>` after it keeps the rest as text. */
+function stripTags$1(raw) {
+	let out = "";
+	let at = 0;
+	for (;;) {
+		const open = raw.indexOf("<", at);
+		if (open === -1) return out + raw.slice(at);
+		const close = raw.indexOf(">", open + 1);
+		if (close === -1) return out + raw.slice(at);
+		out += `${raw.slice(at, open)} `;
+		at = close + 1;
+	}
+}
+/** One line of plain text: entities decoded, tags removed, whitespace collapsed, cut to `max`. */
+function plain(raw, max) {
+	const text = stripUnsafeCharacters(decodeEntities(stripTags$1(raw))).replace(/\s+/g, " ").trim();
+	if (text === "") return null;
+	return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+function isSpace(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+/** The attributes of one tag's text (between its name and its `>`), in one pass. */
+function attributes(tag) {
+	const found = /* @__PURE__ */ new Map();
+	const length = tag.length;
+	let at = 0;
+	while (at < length) {
+		while (at < length && (isSpace(tag[at]) || tag[at] === "/")) at += 1;
+		const from = at;
+		while (at < length && !isSpace(tag[at]) && tag[at] !== "=" && tag[at] !== "/") at += 1;
+		const name = tag.slice(from, at).toLowerCase();
+		if (name === "") {
+			at += 1;
+			continue;
+		}
+		while (at < length && isSpace(tag[at])) at += 1;
+		if (tag[at] !== "=") {
+			if (!found.has(name)) found.set(name, "");
+			continue;
+		}
+		at += 1;
+		while (at < length && isSpace(tag[at])) at += 1;
+		let value;
+		const quote = tag[at];
+		if (quote === "\"" || quote === "'") {
+			const end = tag.indexOf(quote, at + 1);
+			value = tag.slice(at + 1, end === -1 ? length : end);
+			at = end === -1 ? length : end + 1;
+		} else {
+			const start = at;
+			while (at < length && !isSpace(tag[at])) at += 1;
+			value = tag.slice(start, at);
+		}
+		if (!found.has(name)) found.set(name, value);
+	}
+	return found;
+}
+/** The next `</name` (any case) at or after `from`; -1 when there is none. */
+function closingTag(html, name, from) {
+	const pattern = new RegExp(`</${name}`, "ig");
+	pattern.lastIndex = from;
+	return pattern.exec(html)?.index ?? -1;
+}
+/** Elements whose content is not the page's own text. */
+var RAW_TEXT$1 = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"template",
+	"noscript",
+	"textarea"
+]);
+var TAG_NAME = /[a-zA-Z][a-zA-Z0-9-]*/y;
+/** Reads a page's title, first H1, meta description and robots meta from its HTML. */
+function pageMeta(input) {
+	const html = input.length > 262144 ? input.slice(0, PAGE_SCAN_MAX_CHARS) : input;
+	let title = null;
+	let h1 = null;
+	let description = null;
+	let noindex = false;
+	let at = 0;
+	for (;;) {
+		const open = html.indexOf("<", at);
+		if (open === -1) break;
+		if (html.startsWith("<!--", open)) {
+			const end = html.indexOf("-->", open + 4);
+			if (end === -1) break;
+			at = end + 3;
+			continue;
+		}
+		TAG_NAME.lastIndex = open + 1;
+		const match = TAG_NAME.exec(html);
+		if (match === null) {
+			at = open + 1;
+			continue;
+		}
+		const name = match[0].toLowerCase();
+		const tagEnd = html.indexOf(">", TAG_NAME.lastIndex);
+		if (tagEnd === -1) break;
+		at = tagEnd + 1;
+		if (RAW_TEXT$1.has(name)) {
+			const end = closingTag(html, name, at);
+			if (end === -1) break;
+			at = end;
+			continue;
+		}
+		if (name === "title" || name === "h1") {
+			const end = closingTag(html, name, at);
+			if (end === -1) break;
+			if (name === "title" && title === null) title = plain(html.slice(at, end), TITLE_MAX);
+			if (name === "h1" && h1 === null) h1 = plain(html.slice(at, end), TITLE_MAX);
+			at = end;
+			continue;
+		}
+		if (name === "meta") {
+			const attrs = attributes(html.slice(TAG_NAME.lastIndex, tagEnd));
+			const kind = (attrs.get("name") ?? "").toLowerCase();
+			const content = attrs.get("content") ?? "";
+			if (kind === "description" && description === null) description = plain(content, DESCRIPTION_MAX);
+			if (kind === "robots" && /\bnoindex\b|\bnone\b/i.test(content)) noindex = true;
+		}
+	}
+	return Object.freeze({
+		title,
+		h1,
+		description,
+		noindex
+	});
+}
+/** Reads the `<loc>` addresses of a sitemap (sitemaps.org), up to `max` of them. */
+function sitemapLocations(input, max) {
+	const xml = input.length > 5242880 ? input.slice(0, SITEMAP_SCAN_MAX_CHARS) : input;
+	const kind = /<sitemapindex\b/i.test(xml) ? "index" : /<urlset\b/i.test(xml) ? "urlset" : "unknown";
+	const locations = [];
+	const loc = /<loc\b/gi;
+	let scanned = 0;
+	while (kind !== "unknown" && locations.length < max && scanned < 1e4) {
+		if (loc.exec(xml) === null) break;
+		scanned += 1;
+		const tagEnd = xml.indexOf(">", loc.lastIndex);
+		if (tagEnd === -1) break;
+		let from = tagEnd + 1;
+		while (isSpace(xml[from])) from += 1;
+		let raw;
+		if (xml.startsWith("<![CDATA[", from)) {
+			const end = xml.indexOf("]]>", from + 9);
+			if (end === -1) break;
+			raw = xml.slice(from + 9, end);
+			loc.lastIndex = end + 3;
+		} else {
+			const end = xml.indexOf("<", from);
+			if (end === -1) break;
+			raw = xml.slice(from, end);
+			loc.lastIndex = end;
+		}
+		if (raw.length > 2112) continue;
+		const value = stripUnsafeCharacters(decodeEntities(raw.trim()));
+		if (value !== "" && value.length <= 2048) locations.push(value);
+	}
+	return Object.freeze({
+		kind,
+		locations: Object.freeze(locations)
+	});
+}
+/** The section of pages that sit at the top of the site (no first path segment). */
+var MAIN_SECTION = "Main pages";
+function oneLine(text) {
+	return stripUnsafeCharacters(text).replace(/\s+/g, " ").trim();
+}
+/** Link text with the characters that would end a Markdown link escaped. */
+function linkText(text) {
+	return oneLine(text).replace(/[\\[\]]/g, (char) => `\\${char}`);
+}
+/** A link target with the characters that would end a Markdown link encoded. */
+function linkTarget(url) {
+	return url.replace(/[()\s<>]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+/** A first path segment as a section name: `getting-started` → `Getting started`. */
+function sectionName(segment) {
+	let decoded = segment;
+	try {
+		decoded = decodeURIComponent(segment);
+	} catch {}
+	const words = oneLine(decoded.replace(/[-_+.]+/g, " ")).slice(0, 60);
+	if (words === "") return MAIN_SECTION;
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function segments(url) {
+	try {
+		return new URL(url).pathname.split("/").filter((part) => part !== "");
+	} catch {
+		return [];
+	}
+}
+/**
+* The llms.txt for a site and its pages (llmstxt.org): the site's name as the H1, its summary
+* as a blockquote, then one H2 section per folder (first path segment with pages under it), in
+* the order the pages come, the other pages first under "Main pages". Each page is a list item
+* `- [title](url): description`, the description left out when there is none. Titles and
+* descriptions are used as written, on one line.
+*/
+function renderLlmsTxt(site, pages) {
+	const folders = new Set(pages.map((page) => segments(page.url)).filter((parts) => parts.length > 1).map((parts) => parts[0]));
+	const sections = /* @__PURE__ */ new Map();
+	sections.set(MAIN_SECTION, []);
+	for (const page of pages) {
+		const first = segments(page.url)[0];
+		const name = first !== void 0 && folders.has(first) ? sectionName(first) : MAIN_SECTION;
+		const list = sections.get(name) ?? [];
+		list.push(page);
+		sections.set(name, list);
+	}
+	const lines = [`# ${oneLine(site.name) || "Site"}`, ""];
+	const summary = site.summary === null ? "" : oneLine(site.summary);
+	if (summary !== "") lines.push(`> ${summary}`, "");
+	for (const [name, list] of sections) {
+		if (list.length === 0) continue;
+		lines.push(`## ${name}`, "");
+		for (const page of list) {
+			const description = page.description === null ? "" : oneLine(page.description);
+			lines.push(`- [${linkText(page.title) || linkTarget(page.url)}](${linkTarget(page.url)})${description === "" ? "" : `: ${description}`}`);
+		}
+		lines.push("");
+	}
+	return `${lines.join("\n").trimEnd()}\n`;
+}
+// src/facts/html.ts
+/**
+* One forward pass over a page's HTML, read from a string the way a crawler that runs no
+* scripts receives it. It collects what the readers need: the text of the main content, the
+* text a visitor sees, the robots meta tags, the `itemtype` values of microdata, the
+* JSON-LD scripts, and the notice text inside `<noscript>`.
+*
+* It is not an HTML parser and makes no tree. Elements that matter are tracked by a depth
+* counter per name, so nothing here costs more than one step per tag: a search starts where
+* the last one ended, and a search that finds nothing ends the scan. A test feeds it hostile
+* pages at the 2 MiB cap and checks the time.
+*/
+/** Characters of a page scanned; the fetch cap for a page is 2 MiB, so a fetched page fits. */
+var HOME_SCAN_MAX_CHARS = 2097152;
+/** JSON-LD limits: blocks read, one block's size, all blocks' size (in characters). */
+var MAX_LD_BLOCKS = 50;
+var MAX_LD_BLOCK_CHARS = 524288;
+var MAX_LD_TOTAL_CHARS = 1048576;
+/** Characters kept of the visible text and of `<noscript>` and `<title>` text, for notices. */
+var NOTICE_TEXT_CHARS = 65536;
+var MAX_ITEMTYPES = 200;
+var MAX_ITEMTYPE_CHARS = 200;
+var MAX_META_CHARS = 1e3;
+/** Elements that belong in the head; any other start tag ends it, as a browser would. */
+var HEAD_ELEMENTS = /* @__PURE__ */ new Set([
+	"title",
+	"meta",
+	"link",
+	"script",
+	"style",
+	"base",
+	"noscript",
+	"template",
+	"head"
+]);
+/** Page-level elements left out of the fallback text (a page without `<main>`). */
+var CHROME = /* @__PURE__ */ new Set([
+	"header",
+	"nav",
+	"footer",
+	"aside"
+]);
+/** Elements that continue a word: `Hel<b>lo</b>` is one word. Every other tag ends one. */
+var INLINE = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"cite",
+	"code",
+	"data",
+	"del",
+	"dfn",
+	"em",
+	"font",
+	"i",
+	"ins",
+	"kbd",
+	"mark",
+	"q",
+	"s",
+	"samp",
+	"small",
+	"span",
+	"strike",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"tt",
+	"u",
+	"var",
+	"wbr"
+]);
+/** Elements whose content is not page text; the scan jumps to the closing tag. */
+var RAW_TEXT = /* @__PURE__ */ new Set([
+	"style",
+	"textarea",
+	"xmp",
+	"noframes",
+	"noembed",
+	"iframe",
+	"title",
+	"noscript",
+	"script"
+]);
+var NAMED_TEXT_ENTITIES = Object.freeze({
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " ",
+	ensp: " ",
+	emsp: " ",
+	thinsp: " ",
+	hairsp: " ",
+	zwnj: "",
+	zwj: "",
+	shy: "",
+	ndash: "–",
+	mdash: "—",
+	hellip: "…",
+	bull: "•",
+	middot: "·",
+	raquo: "»",
+	laquo: "«",
+	rsquo: "’",
+	lsquo: "‘",
+	rdquo: "”",
+	ldquo: "“",
+	copy: "©",
+	reg: "®",
+	trade: "™",
+	times: "×",
+	euro: "€",
+	pound: "£",
+	yen: "¥",
+	cent: "¢",
+	sect: "§",
+	deg: "°",
+	para: "¶",
+	larr: "←",
+	rarr: "→",
+	uarr: "↑",
+	darr: "↓",
+	check: "✓",
+	hearts: "♥",
+	star: "☆",
+	plusmn: "±",
+	frac12: "½",
+	infin: "∞"
+});
+/**
+* Entities in a text chunk decoded. A named entity not in the list above is almost always an
+* accented letter (`&eacute;`), so it becomes one letter and joins its word.
+*/
+function decodeText(raw) {
+	return raw.replace(/&(#x[0-9a-fA-F]{1,6}|#[0-9]{1,7}|[a-zA-Z][a-zA-Z0-9]{1,31});/g, (whole, body) => {
+		if (body.startsWith("#")) {
+			const code = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : Number(body.slice(1));
+			if (!Number.isInteger(code) || code <= 0 || code > 1114111) return whole;
+			if (code >= 55296 && code <= 57343) return " ";
+			return String.fromCodePoint(code);
+		}
+		return NAMED_TEXT_ENTITIES[body] ?? NAMED_TEXT_ENTITIES[body.toLowerCase()] ?? "e";
+	});
+}
+var CLOSING = /* @__PURE__ */ new Map();
+/** The next `</name` (any case) at or after `from`; -1 when there is none. */
+function findClosing(html, name, from) {
+	let pattern = CLOSING.get(name);
+	if (pattern === void 0) {
+		pattern = new RegExp(`</${name}`, "ig");
+		CLOSING.set(name, pattern);
+	}
+	pattern.lastIndex = from;
+	return pattern.exec(html)?.index ?? -1;
+}
+function isLetter(code) {
+	const lower = code | 32;
+	return lower >= 97 && lower <= 122;
+}
+/** The end of a start tag's name: letters, digits, `-`, `:`. */
+function nameEnd(html, from) {
+	let at = from;
+	for (;;) {
+		const code = html.charCodeAt(at);
+		if (isLetter(code) || code >= 48 && code <= 58 || code === 45) at += 1;
+		else return at;
+	}
+}
+/**
+* The `>` that ends a start tag: quotes opened right after `=` are skipped, so `title="a>b"`
+* does not end it. -1 when the tag never ends.
+*/
+function findTagEnd(html, from) {
+	let at = from;
+	let afterEquals = false;
+	for (;;) {
+		const code = html.charCodeAt(at);
+		if (Number.isNaN(code)) return -1;
+		if (code === 62) return at;
+		if ((code === 34 || code === 39) && afterEquals) {
+			const close = html.indexOf(code === 34 ? "\"" : "'", at + 1);
+			if (close === -1) return -1;
+			at = close + 1;
+			afterEquals = false;
+			continue;
+		}
+		if (code === 61) afterEquals = true;
+		else if (code !== 32 && code !== 9 && code !== 10 && code !== 13 && code !== 12) afterEquals = false;
+		at += 1;
+	}
+}
+function stripTags(raw) {
+	return raw.replace(/<[^<>]*>/g, " ");
+}
+/** Scans a page. Never throws; text it cannot make sense of is left out. */
+function scanPage(input) {
+	const truncated = input.length > HOME_SCAN_MAX_CHARS;
+	const html = truncated ? input.slice(0, HOME_SCAN_MAX_CHARS) : input;
+	const main = [];
+	const body = [];
+	const visible = [];
+	let visibleLength = 0;
+	const notice = [];
+	let noticeLength = 0;
+	const metaRobots = [];
+	const itemtypes = [];
+	const ldBlocks = [];
+	const ldBounds = /* @__PURE__ */ new Set();
+	let ldScripts = 0;
+	let ldTotal = 0;
+	let ldStopped = false;
+	let mainDepth = 0;
+	let hasMain = false;
+	let roleName = null;
+	let roleDepth = 0;
+	const chrome = /* @__PURE__ */ new Map();
+	let chromeDepth = 0;
+	let skipDepth = 0;
+	let inHead = false;
+	let pendingSeparator = false;
+	const addNotice = (text) => {
+		if (noticeLength >= NOTICE_TEXT_CHARS) return;
+		notice.push(text);
+		noticeLength += text.length;
+	};
+	const emit = (raw) => {
+		if (raw === "" || skipDepth > 0) return;
+		if (inHead && raw.trim() !== "") inHead = false;
+		if (inHead) return;
+		const inMain = mainDepth > 0 || roleDepth > 0;
+		const inBody = chromeDepth === 0;
+		const decoded = raw.includes("&") ? decodeText(raw) : raw;
+		const piece = pendingSeparator ? ` ${decoded}` : decoded;
+		pendingSeparator = false;
+		if (inMain) main.push(piece);
+		if (inBody) body.push(piece);
+		if (visibleLength < NOTICE_TEXT_CHARS) {
+			visible.push(piece);
+			visibleLength += piece.length;
+		}
+	};
+	let textFrom = 0;
+	let at = 0;
+	for (;;) {
+		const open = html.indexOf("<", at);
+		if (open === -1) break;
+		const next = html.charCodeAt(open + 1);
+		if (next === 33 || next === 63) {
+			emit(html.slice(textFrom, open));
+			if (html.startsWith("<!--", open)) {
+				const end = html.indexOf("-->", open + 4);
+				if (end === -1) {
+					textFrom = html.length;
+					break;
+				}
+				at = end + 3;
+			} else {
+				const end = html.indexOf(">", open + 2);
+				if (end === -1) {
+					textFrom = html.length;
+					break;
+				}
+				at = end + 1;
+			}
+			textFrom = at;
+			continue;
+		}
+		const closing = next === 47;
+		const nameFrom = open + (closing ? 2 : 1);
+		if (!isLetter(html.charCodeAt(nameFrom))) {
+			at = open + 1;
+			continue;
+		}
+		const nameTo = nameEnd(html, nameFrom);
+		const name = html.slice(nameFrom, nameTo).toLowerCase();
+		if (open > textFrom) emit(html.slice(textFrom, open));
+		if (closing) {
+			const end = html.indexOf(">", nameTo);
+			if (end === -1) {
+				textFrom = html.length;
+				break;
+			}
+			at = end + 1;
+			textFrom = at;
+			if (name === "main") {
+				if (mainDepth > 0) mainDepth -= 1;
+			} else if (CHROME.has(name)) {
+				const depth = chrome.get(name) ?? 0;
+				if (depth > 0) {
+					chrome.set(name, depth - 1);
+					chromeDepth -= 1;
+				}
+			} else if (name === "template" || name === "svg") {
+				if (skipDepth > 0) skipDepth -= 1;
+			} else if (name === "head") inHead = false;
+			if (name === roleName) {
+				roleDepth -= 1;
+				if (roleDepth === 0) roleName = null;
+			}
+			if (!INLINE.has(name)) pendingSeparator = true;
+			continue;
+		}
+		if (inHead && !HEAD_ELEMENTS.has(name)) inHead = false;
+		const tagEnd = findTagEnd(html, nameTo);
+		if (tagEnd === -1) {
+			textFrom = html.length;
+			break;
+		}
+		const raw = tagEnd === nameTo ? "" : html.slice(nameTo, tagEnd);
+		const selfClosing = html.charCodeAt(tagEnd - 1) === 47;
+		at = tagEnd + 1;
+		textFrom = at;
+		if (RAW_TEXT.has(name)) {
+			const end = findClosing(html, name, at);
+			if (end === -1) {
+				textFrom = html.length;
+				at = html.length;
+				break;
+			}
+			if (name === "script") {
+				if ((attributes(raw).get("type") ?? "").split(";")[0].trim().toLowerCase() === "application/ld+json") {
+					ldScripts += 1;
+					const size = end - at;
+					if (ldStopped) {} else if (ldBlocks.length >= 50) {
+						ldBounds.add("blocks");
+						ldStopped = true;
+					} else if (size > 524288) ldBounds.add("block_size");
+					else if (ldTotal + size > 1048576) {
+						ldBounds.add("total_size");
+						ldStopped = true;
+					} else {
+						ldBlocks.push(html.slice(at, end));
+						ldTotal += size;
+					}
+				}
+			} else if (name === "noscript" || name === "title") {
+				if (noticeLength < NOTICE_TEXT_CHARS) addNotice(stripTags(html.slice(at, Math.min(end, at + NOTICE_TEXT_CHARS))) + " ");
+			}
+			at = end;
+			textFrom = end;
+			pendingSeparator = true;
+			continue;
+		}
+		if (name === "meta") {
+			if (/name\s*=/i.test(raw)) {
+				const attrs = attributes(raw);
+				if ((attrs.get("name") ?? "").trim().toLowerCase() === "robots") metaRobots.push((attrs.get("content") ?? "").slice(0, MAX_META_CHARS));
+			}
+			pendingSeparator = true;
+			continue;
+		}
+		if (name === "main") {
+			mainDepth += 1;
+			hasMain = true;
+		} else if (CHROME.has(name)) {
+			chrome.set(name, (chrome.get(name) ?? 0) + 1);
+			chromeDepth += 1;
+		} else if ((name === "template" || name === "svg") && !(selfClosing && name === "svg")) skipDepth += 1;
+		else if (name === "head") inHead = true;
+		else if (name === "body") inHead = false;
+		let opensRole = false;
+		if (raw.length > 6 && /itemtype|role/i.test(raw)) {
+			const attrs = attributes(raw);
+			const itemtype = attrs.get("itemtype");
+			if (itemtype !== void 0) {
+				for (const token of itemtype.split(/\s+/)) if (token !== "" && itemtypes.length < MAX_ITEMTYPES) itemtypes.push(token.slice(0, MAX_ITEMTYPE_CHARS));
+			}
+			const role = (attrs.get("role") ?? "").trim().split(/\s+/)[0].toLowerCase();
+			if (roleName === null && role === "main" && !selfClosing) {
+				roleName = name;
+				roleDepth = 1;
+				hasMain = true;
+				opensRole = true;
+			}
+		}
+		if (!opensRole && roleName !== null && name === roleName && !selfClosing) roleDepth += 1;
+		if (!INLINE.has(name)) pendingSeparator = true;
+	}
+	emit(html.slice(textFrom));
+	return Object.freeze({
+		mainText: main.join(""),
+		bodyText: body.join(""),
+		hasMain,
+		visibleText: visible.join(""),
+		noticeText: notice.join(""),
+		metaRobots,
+		itemtypes,
+		ldBlocks,
+		ldScripts,
+		ldBounds: [...ldBounds],
+		truncated
+	});
+}
+/**
+* Whether the page has an application root element (see `isAppRoot`): a second, light pass over
+* the start tags that stops at the first one found.
+*/
+function hasAppRoot(input) {
+	const html = input.length > 2097152 ? input.slice(0, HOME_SCAN_MAX_CHARS) : input;
+	let at = 0;
+	for (;;) {
+		const open = html.indexOf("<", at);
+		if (open === -1) return false;
+		const next = html.charCodeAt(open + 1);
+		if (next === 33 || next === 63) {
+			const end = html.startsWith("<!--", open) ? html.indexOf("-->", open + 4) : html.indexOf(">", open + 2);
+			if (end === -1) return false;
+			at = end + (html.startsWith("<!--", open) ? 3 : 1);
+			continue;
+		}
+		if (next === 47 || !isLetter(next)) {
+			at = open + 1;
+			continue;
+		}
+		const nameTo = nameEnd(html, open + 1);
+		const name = html.slice(open + 1, nameTo).toLowerCase();
+		const tagEnd = findTagEnd(html, nameTo);
+		if (tagEnd === -1) return false;
+		at = tagEnd + 1;
+		if (RAW_TEXT.has(name)) {
+			const end = findClosing(html, name, at);
+			if (end === -1) return false;
+			at = end;
+			continue;
+		}
+		if (name === "app-root") return true;
+		const raw = tagEnd === nameTo ? "" : html.slice(nameTo, tagEnd);
+		if (raw.length > 4 && /\bid\s*=|ng-version|ng-app|data-reactroot|data-server-rendered/i.test(raw)) {
+			if (isAppRoot(name, attributes(raw))) return true;
+		}
+	}
+}
+// src/facts/json-ld.ts
+var MAX_LD_DEPTH = 16;
+var MAX_LD_NODES = 5e3;
+var MAX_TYPES_PER_NODE = 20;
+var MAX_TYPE_CHARS = 200;
+var SCHEMA_ORG_CONTEXT = /^\s*https?:\/\/(?:www\.)?schema\.org(?:[/#?].*)?$/i;
+/** Whether an `@context` value names schema.org (as a string, in an array, or as `@vocab`). */
+function namesSchemaOrg(context) {
+	if (typeof context === "string") return SCHEMA_ORG_CONTEXT.test(context);
+	if (Array.isArray(context)) return context.slice(0, 20).some((item) => namesSchemaOrg(item));
+	if (isObject(context)) {
+		const vocab = context["@vocab"];
+		return typeof vocab === "string" && SCHEMA_ORG_CONTEXT.test(vocab);
+	}
+	return false;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A type name without `schema:` and `http(s)://schema.org/`. */
+function schemaTypeName(raw) {
+	return raw.trim().replace(/^(?:https?:\/\/(?:www\.)?schema\.org\/|schema:)/i, "").slice(0, MAX_TYPE_CHARS);
+}
+function typeNames(value) {
+	const list = Array.isArray(value) ? value.slice(0, MAX_TYPES_PER_NODE) : [value];
+	const names = [];
+	for (const item of list) if (typeof item === "string" && item.trim() !== "") names.push(schemaTypeName(item));
+	return names;
+}
+/** The block's text without a wrapping `<!-- -->` or `<![CDATA[ ]]>`, and without a byte order mark. */
+function unwrapBlock(text) {
+	let body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	body = body.trim();
+	if (body.startsWith("<!--") && body.endsWith("-->")) body = body.slice(4, -3).trim();
+	if (body.startsWith("<![CDATA[") && body.endsWith("]]>")) body = body.slice(9, -3).trim();
+	return body;
+}
+/** Parses the blocks and walks the data that names schema.org. */
+function walkJsonLd(blocks, scripts, inheritedBounds) {
+	const bounds = new Set(inheritedBounds);
+	const typed = [];
+	let parsed = 0;
+	let schemaOrgBlocks = 0;
+	let errors = 0;
+	let nodes = 0;
+	let stopped = false;
+	for (const block of blocks) {
+		let data;
+		try {
+			data = JSON.parse(unwrapBlock(block));
+		} catch {
+			errors += 1;
+			continue;
+		}
+		parsed += 1;
+		const roots = Array.isArray(data) ? data.slice(0, 1e3) : [data];
+		let named = false;
+		for (const root of roots) {
+			if (!isObject(root) || !namesSchemaOrg(root["@context"])) continue;
+			named = true;
+			if (stopped) continue;
+			const stack = [{
+				value: root,
+				depth: 1
+			}];
+			while (stack.length > 0 && !stopped) {
+				const { value, depth } = stack.pop();
+				if (depth > 16) {
+					bounds.add("depth");
+					continue;
+				}
+				const children = [];
+				if (Array.isArray(value)) {
+					for (const item of value) if (typeof item === "object" && item !== null) children.push(item);
+				} else if (isObject(value)) {
+					nodes += 1;
+					if (nodes > 5e3) {
+						bounds.add("nodes");
+						stopped = true;
+						break;
+					}
+					if (Object.hasOwn(value, "@type")) {
+						const types = typeNames(value["@type"]);
+						if (types.length > 0) typed.push({
+							types,
+							node: value
+						});
+					}
+					for (const key of Object.keys(value)) {
+						if (key === "@context") continue;
+						const child = value[key];
+						if (typeof child === "object" && child !== null) children.push(child);
+					}
+				}
+				for (let index = children.length - 1; index >= 0; index -= 1) stack.push({
+					value: children[index],
+					depth: depth + 1
+				});
+			}
+		}
+		if (named) schemaOrgBlocks += 1;
+	}
+	return Object.freeze({
+		scripts,
+		parsed,
+		schemaOrgBlocks,
+		errors,
+		bounds: [...bounds],
+		typed
+	});
+}
+// src/facts/schema-org-organization-types.ts
+/** The schema.org release the list below was read from. */
+var SCHEMA_ORG_VERSION = "30.1";
+/** SHA-256 of that release's vocabulary file (schemaorg-current-https.jsonld). */
+var SCHEMA_ORG_SHA256 = "0a4b8c4c910fc831ec8695196510973390906a5ee34dc6b862dfec4d21a12f74";
+/** `Organization` and every schema.org type that is a subtype of it, sorted. */
+var ORGANIZATION_TYPES = Object.freeze([
+	"AccountingService",
+	"AdultEntertainment",
+	"Airline",
+	"AmusementPark",
+	"AnimalShelter",
+	"ArchiveOrganization",
+	"ArtGallery",
+	"Attorney",
+	"AutoBodyShop",
+	"AutoDealer",
+	"AutoPartsStore",
+	"AutoRental",
+	"AutoRepair",
+	"AutoWash",
+	"AutomatedTeller",
+	"AutomotiveBusiness",
+	"Bakery",
+	"BankOrCreditUnion",
+	"BarOrPub",
+	"BeautySalon",
+	"BedAndBreakfast",
+	"BikeStore",
+	"BookStore",
+	"BowlingAlley",
+	"Brewery",
+	"CafeOrCoffeeShop",
+	"Campground",
+	"Casino",
+	"ChildCare",
+	"ClothingStore",
+	"CollegeOrUniversity",
+	"ComedyClub",
+	"ComputerStore",
+	"Consortium",
+	"ConvenienceStore",
+	"Cooperative",
+	"Corporation",
+	"CovidTestingFacility",
+	"DanceGroup",
+	"DaySpa",
+	"Dentist",
+	"DepartmentStore",
+	"DiagnosticLab",
+	"Distillery",
+	"DryCleaningOrLaundry",
+	"EducationalOrganization",
+	"Electrician",
+	"ElectronicsStore",
+	"ElementarySchool",
+	"EmergencyService",
+	"EmploymentAgency",
+	"EntertainmentBusiness",
+	"ExerciseGym",
+	"FastFoodRestaurant",
+	"FinancialService",
+	"FireStation",
+	"Florist",
+	"FoodEstablishment",
+	"FundingAgency",
+	"FundingScheme",
+	"FurnitureStore",
+	"GardenStore",
+	"GasStation",
+	"GeneralContractor",
+	"GolfCourse",
+	"GovernmentOffice",
+	"GovernmentOrganization",
+	"GroceryStore",
+	"HVACBusiness",
+	"HairSalon",
+	"HardwareStore",
+	"HealthAndBeautyBusiness",
+	"HealthClub",
+	"HighSchool",
+	"HobbyShop",
+	"HomeAndConstructionBusiness",
+	"HomeGoodsStore",
+	"Hospital",
+	"Hostel",
+	"Hotel",
+	"HousePainter",
+	"IceCreamShop",
+	"IndividualPhysician",
+	"InsuranceAgency",
+	"InternetCafe",
+	"JewelryStore",
+	"LegalService",
+	"Library",
+	"LibrarySystem",
+	"LiquorStore",
+	"LocalBusiness",
+	"Locksmith",
+	"LodgingBusiness",
+	"MedicalBusiness",
+	"MedicalClinic",
+	"MedicalOrganization",
+	"MensClothingStore",
+	"MiddleSchool",
+	"MobilePhoneStore",
+	"Motel",
+	"MotorcycleDealer",
+	"MotorcycleRepair",
+	"MovieRentalStore",
+	"MovieTheater",
+	"MovingCompany",
+	"MusicGroup",
+	"MusicStore",
+	"NGO",
+	"NailSalon",
+	"NewsMediaOrganization",
+	"NightClub",
+	"Notary",
+	"OfficeEquipmentStore",
+	"OnlineBusiness",
+	"OnlineMarketplace",
+	"OnlineStore",
+	"Optician",
+	"Organization",
+	"OutletStore",
+	"PawnShop",
+	"PerformingGroup",
+	"PetStore",
+	"Pharmacy",
+	"Physician",
+	"PhysiciansOffice",
+	"Plumber",
+	"PoliceStation",
+	"PoliticalParty",
+	"PostOffice",
+	"Preschool",
+	"ProfessionalService",
+	"Project",
+	"PublicSwimmingPool",
+	"RadioStation",
+	"RealEstateAgent",
+	"RecyclingCenter",
+	"ResearchOrganization",
+	"ResearchProject",
+	"Resort",
+	"Restaurant",
+	"RoofingContractor",
+	"School",
+	"SearchRescueOrganization",
+	"SelfStorage",
+	"ShoeStore",
+	"ShoppingCenter",
+	"SkiResort",
+	"SportingGoodsStore",
+	"SportsActivityLocation",
+	"SportsClub",
+	"SportsOrganization",
+	"SportsTeam",
+	"StadiumOrArena",
+	"Store",
+	"TattooParlor",
+	"TelevisionStation",
+	"TennisComplex",
+	"TheaterGroup",
+	"TireShop",
+	"TouristInformationCenter",
+	"ToyStore",
+	"TravelAgency",
+	"VacationRental",
+	"VeterinaryCare",
+	"WholesaleStore",
+	"Winery",
+	"WorkersUnion"
+]);
+// src/facts/profiles.ts
+/**
+* Profile kinds of a `sameAs` link, by host. The list is part of the method: a host is the
+* domain or any name under it (`en.wikipedia.org`, `m.facebook.com`).
+*/
+var PROFILE_HOSTS = Object.freeze([
+	{
+		kind: "wikidata",
+		hosts: ["wikidata.org"]
+	},
+	{
+		kind: "wikipedia",
+		hosts: ["wikipedia.org"]
+	},
+	{
+		kind: "linkedin",
+		hosts: ["linkedin.com"]
+	},
+	{
+		kind: "x",
+		hosts: ["x.com", "twitter.com"]
+	},
+	{
+		kind: "facebook",
+		hosts: ["facebook.com", "fb.com"]
+	},
+	{
+		kind: "instagram",
+		hosts: ["instagram.com"]
+	},
+	{
+		kind: "youtube",
+		hosts: ["youtube.com", "youtu.be"]
+	},
+	{
+		kind: "tiktok",
+		hosts: ["tiktok.com"]
+	},
+	{
+		kind: "github",
+		hosts: ["github.com"]
+	},
+	{
+		kind: "crunchbase",
+		hosts: ["crunchbase.com"]
+	},
+	{
+		kind: "pinterest",
+		hosts: ["pinterest.com"]
+	}
+]);
+/** The kinds in the order results list them. */
+var PROFILE_KINDS = Object.freeze([...PROFILE_HOSTS.map((entry) => entry.kind), "other"]);
+/** The kind of the profile at a host name. */
+function profileKind(host) {
+	const name = host.toLowerCase();
+	for (const entry of PROFILE_HOSTS) if (entry.hosts.some((domain) => name === domain || name.endsWith(`.${domain}`))) return entry.kind;
+	return "other";
+}
+// src/facts/organization.ts
+/**
+* The Organization of a home page: which typed nodes are one, which is the primary node, and
+* what it says about itself.
+*/
+var ORGANIZATION_SET = new Set(ORGANIZATION_TYPES);
+var MAX_SAME_AS_READ = 500;
+var MAX_SAME_AS_KEPT = 100;
+var MAX_URL_CHARS = 2048;
+var NAME_CHARS = 200;
+/** Whether a (prefix-free) type name is Organization or one of its schema.org subtypes. */
+function isOrganizationType(name) {
+	return ORGANIZATION_SET.has(name);
+}
+/** A string value: a string, the first string of an array, or the `@value` of a value object. */
+function textOf(value) {
+	if (typeof value === "string") return value.trim() === "" ? null : value.trim();
+	if (Array.isArray(value)) {
+		for (const item of value.slice(0, 10)) {
+			const found = textOf(item);
+			if (found !== null) return found;
+		}
+		return null;
+	}
+	if (isObject(value) && typeof value["@value"] === "string") return textOf(value["@value"]);
+	return null;
+}
+/** An absolute http(s) URL, parsed; null otherwise. */
+function absoluteUrl(text, base) {
+	if (text === null || text === "" || text.length > MAX_URL_CHARS) return null;
+	try {
+		const url = base === void 0 ? new URL(text) : new URL(text, base);
+		return url.protocol === "http:" || url.protocol === "https:" ? url : null;
+	} catch {
+		return null;
+	}
+}
+/** The node's `url` as written, when it is an absolute http(s) URL. */
+function urlOf(node) {
+	const text = textOf(node["url"]);
+	return absoluteUrl(text) === null ? null : text;
+}
+function hasLogo(value, pageUrl) {
+	if (typeof value === "string") return absoluteUrl(value.trim(), pageUrl) !== null;
+	if (Array.isArray(value)) return value.slice(0, 10).some((item) => hasLogo(item, pageUrl));
+	if (isObject(value)) return typeof value["url"] === "string" && absoluteUrl(value["url"].trim(), pageUrl) !== null;
+	return false;
+}
+function sameAsValues(value) {
+	const list = Array.isArray(value) ? value.slice(0, MAX_SAME_AS_READ) : [value];
+	const out = [];
+	for (const item of list) if (typeof item === "string") out.push(item);
+	else if (isObject(item) && typeof item["@id"] === "string") out.push(item["@id"]);
+	return out;
+}
+/** The Organization nodes among the typed nodes, in document order. */
+function organizationNodes(typed) {
+	const found = [];
+	for (const { types, node } of typed) {
+		const type = types.find((name) => ORGANIZATION_SET.has(name));
+		if (type !== void 0) found.push({
+			type,
+			node
+		});
+	}
+	return found;
+}
+/**
+* The primary node: the first Organization node whose `url` is on the site's registrable
+* domain, else the first. Null without any.
+*/
+function primaryOrganization(nodes, siteDomain, registrable) {
+	for (const candidate of nodes) {
+		const url = absoluteUrl(urlOf(candidate.node));
+		if (url !== null && registrable(url.hostname) === siteDomain) return candidate;
+	}
+	return nodes[0] ?? null;
+}
+/** What the primary node says about itself. */
+function describeOrganization(primary, pageUrl, siteDomain, registrable) {
+	const node = primary.node;
+	const name = textOf(node["name"]);
+	const url = urlOf(node);
+	const seen = /* @__PURE__ */ new Set();
+	const sameAs = [];
+	const kinds = /* @__PURE__ */ new Set();
+	for (const text of sameAsValues(node["sameAs"])) {
+		const link = absoluteUrl(text.trim());
+		if (link === null) continue;
+		const host = normalizeHost(link.hostname);
+		if (registrable(host) === siteDomain) continue;
+		const key = `${host}${link.pathname.replace(/\/+$/, "")}${link.search}`.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (sameAs.length < MAX_SAME_AS_KEPT) sameAs.push(text.trim());
+		kinds.add(profileKind(host));
+	}
+	return Object.freeze({
+		type: primary.type,
+		name: name === null ? null : name.slice(0, NAME_CHARS),
+		url,
+		nameAndUrl: name !== null && url !== null,
+		logo: hasLogo(node["logo"], pageUrl),
+		sameAs: Object.freeze(sameAs),
+		sameAsKinds: Object.freeze(PROFILE_KINDS.filter((kind) => kinds.has(kind)))
+	});
+}
+/** Whether any `potentialAction` of the node is a `SearchAction`. */
+function hasSearchAction(node) {
+	const value = node["potentialAction"];
+	return (Array.isArray(value) ? value.slice(0, 20) : [value]).some((action) => {
+		if (!isObject(action)) return false;
+		const type = action["@type"];
+		return (Array.isArray(type) ? type : [type]).some((name) => typeof name === "string" && /(?:^|[/:])SearchAction$/.test(name));
+	});
+}
+// src/facts/home-page.ts
+/**
+* `readHomePage`: every fact the study and `checkSite` read from a home page's HTML, by one
+* pure function. The page's text is read as served: no script is run.
+*/
+/** A home page with at least this many words of main text has "text in the HTML". */
+var TEXT_IN_HTML_MIN_WORDS = 150;
+var MAX_TYPES = 200;
+var SCHEMA_TYPE_NAME = /^[A-Za-z][A-Za-z0-9]*$/;
+/** `noindex` (or `none`, which means it) in a robots meta or header value, without an agent prefix. */
+function sayNoindex(value) {
+	return value.split(",").some((token) => {
+		const word = token.trim().toLowerCase();
+		return word === "noindex" || word === "none";
+	});
+}
+/**
+* Whether `X-Robots-Tag` values say noindex to every crawler. A value may start with an agent
+* (`googlebot: noindex, nofollow`), which then applies to the rest of that value up to the next
+* agent; such a rule is for one crawler and does not count. `unavailable_after: <date>` is a
+* directive, not an agent.
+*/
+function xRobotsNoindex(values) {
+	if (values === null || values === void 0) return false;
+	const list = typeof values === "string" ? [values] : values;
+	for (const value of list.slice(0, 20)) {
+		let agent = null;
+		for (const token of value.slice(0, 2e3).split(",")) {
+			let directive = token;
+			const prefix = /^\s*([A-Za-z0-9_.-]+)\s*:\s*(.*)$/s.exec(token);
+			if (prefix !== null && prefix[1].toLowerCase() !== "unavailable_after") {
+				agent = prefix[1].toLowerCase();
+				directive = prefix[2];
+			}
+			if (agent === null && sayNoindex(directive)) return true;
+		}
+	}
+	return false;
+}
+/** Reads the facts of a home page. Never throws. */
+function readHomePage(html, url, options = {}) {
+	const registrable = options.registrableDomain ?? registrableDomain;
+	let host = "";
+	try {
+		host = normalizeHost(new URL(url).hostname);
+	} catch {
+		host = "";
+	}
+	const siteDomain = registrable(host);
+	const bytes = Buffer.byteLength(html, "utf8");
+	const scan = scanPage(html);
+	const mainSource = scan.hasMain ? "main" : "body";
+	const counted = countWords(mainSource === "main" ? scan.mainText : scan.bodyText);
+	const appRoot = hasAppRoot(html);
+	const jsNotice = JS_NOTICE.test(`${scan.noticeText} ${scan.visibleText}`);
+	let content;
+	if (bytes > 5120 && counted.words < 50 && (appRoot || jsNotice)) content = "app_shell";
+	else if (counted.words >= 150) content = "text_in_html";
+	else content = "little_text";
+	const botCheck = isHomeChallenge(null, `${scan.noticeText} ${scan.visibleText}`, counted.words);
+	const metaNoindex = scan.metaRobots.some(sayNoindex);
+	const headerNoindex = xRobotsNoindex(options.xRobotsTag);
+	const walk = walkJsonLd(scan.ldBlocks, scan.ldScripts, scan.ldBounds);
+	const types = [];
+	const typeSet = /* @__PURE__ */ new Set();
+	const addType = (name) => {
+		if (!SCHEMA_TYPE_NAME.test(name) || typeSet.has(name) || typeSet.size >= MAX_TYPES) return;
+		typeSet.add(name);
+		types.push(name);
+	};
+	for (const { types: names } of walk.typed) for (const name of names) addType(name);
+	const microdataTypes = [];
+	for (const token of scan.itemtypes) {
+		if (!/^https?:\/\/(?:www\.)?schema\.org\//i.test(token)) continue;
+		const name = schemaTypeName(token);
+		if (!microdataTypes.includes(name)) microdataTypes.push(name);
+		addType(name);
+	}
+	const primaryNode = primaryOrganization(organizationNodes(walk.typed), siteDomain, registrable);
+	const primary = primaryNode === null ? null : describeOrganization(primaryNode, url, siteDomain, registrable);
+	const microOrg = microdataTypes.find(isOrganizationType) ?? null;
+	const organization = primary !== null ? "json_ld" : microOrg !== null ? "microdata" : "none";
+	const websites = walk.typed.filter(({ types: names }) => names.includes("WebSite"));
+	const searchAction = websites.some(({ node }) => hasSearchAction(node)) || microdataTypes.includes("WebSite") && microdataTypes.includes("SearchAction");
+	return Object.freeze({
+		url,
+		host,
+		bytes,
+		scanTruncated: scan.truncated,
+		mainWords: counted.words,
+		wordsCapped: counted.capped,
+		mainSource,
+		content,
+		appRoot,
+		jsNotice,
+		botCheck,
+		noindex: metaNoindex || headerNoindex,
+		noindexSource: metaNoindex && headerNoindex ? "both" : metaNoindex ? "meta" : headerNoindex ? "header" : null,
+		jsonLd: Object.freeze({
+			scripts: walk.scripts,
+			parsed: walk.parsed,
+			schemaOrgBlocks: walk.schemaOrgBlocks,
+			errors: walk.errors,
+			bounds: walk.bounds
+		}),
+		types: Object.freeze(types),
+		microdataTypes: Object.freeze(microdataTypes),
+		organization,
+		organizationType: primary?.type ?? microOrg,
+		primary,
+		website: websites.length > 0 || microdataTypes.includes("WebSite"),
+		searchAction,
+		faqPage: walk.typed.some(({ types: names }) => names.includes("FAQPage")) || microdataTypes.includes("FAQPage")
+	});
+}
+// src/facts/home-response.ts
+/**
+* What a fetched answer for the home page means: read, or not read and why. A pure function of
+* the fetch result, so the check and the study draw the same line.
+*/
+var HTML_TYPES = /* @__PURE__ */ new Set(["text/html", "application/xhtml+xml"]);
+/** Reads the answer for the home page. `not_allowed` is not decided here: no request was made. */
+function readHomeResponse(result, options = {}) {
+	const base = {
+		requestedUrl: result.requestedUrl,
+		finalUrl: result.finalUrl,
+		status: result.status,
+		redirects: result.redirects.length,
+		truncated: result.truncated,
+		facts: null
+	};
+	const not = (outcome) => Object.freeze({
+		...base,
+		outcome
+	});
+	if (result.outcome !== "response") {
+		if (result.outcome === "redirect_refused") return not("off_site");
+		if (result.outcome === "too_many_redirects" || result.outcome === "redirect_loop" || result.outcome === "invalid_redirect") return not("redirect_error");
+		return not("network");
+	}
+	const status = result.status ?? 0;
+	if (status === 401 || status === 403) return not("forbidden");
+	if (status === 202) return not("challenge");
+	if (status !== 200) return not("error_status");
+	const text = result.rawBody === null ? result.text : decodeHtml(result.rawBody, result.headers["content-type"]?.[0] ?? null, result.truncated).text;
+	if (text === null) return not("not_html");
+	if (result.contentType !== null ? !HTML_TYPES.has(result.contentType) : !looksLikeHtml(null, text)) return not("not_html");
+	const facts = readHomePage(text, result.finalUrl, {
+		xRobotsTag: result.headers["x-robots-tag"] ?? null,
+		...options.registrableDomain === void 0 ? {} : { registrableDomain: options.registrableDomain }
+	});
+	if (facts.botCheck) return not("challenge");
+	if (placeholderMark(text, facts.mainWords) !== null) return not("placeholder");
+	return Object.freeze({
+		...base,
+		outcome: "read",
+		facts
+	});
+}
+// src/facts/reader.ts
+/** The product token this reader uses when it matches robots.txt rules (its user agent's product). */
+var READER_TOKEN = "QueryRev-AIReadiness";
+// src/facts/sitemap.ts
+/**
+* `readSitemap`: whether a file is a sitemap, and what kind. A file counts only by what it
+* holds: an HTML page at `/sitemap.xml` is not a sitemap (a site that answers every address with
+* a page), whatever its status. XML with a DOCTYPE or an ENTITY is refused unread, so no
+* entity can expand into more than the file holds.
+*/
+/** A sitemap is read to this many bytes after decompression (the fetch cap for a sitemap). */
+var SITEMAP_MAX_BYTES = 5242880;
+/** `<loc>` entries or text lines counted at most. */
+var MAX_LOCS_COUNTED = 1e5;
+/** Addresses looked at to decide whether any is on the site. */
+var LOCS_CHECKED = 500;
+var GZIP_MAGIC = [31, 139];
+function isGzip(bytes) {
+	return bytes.length >= 2 && bytes[0] === GZIP_MAGIC[0] && bytes[1] === GZIP_MAGIC[1];
+}
+/** Inflates a gzip stream to at most `cap` bytes; the rest is dropped. Null when it is corrupt. */
+async function inflateCapped(bytes, cap) {
+	const gunzip = createGunzip();
+	const chunks = [];
+	let kept = 0;
+	let truncated = false;
+	try {
+		Readable.from([Buffer.from(bytes)]).pipe(gunzip);
+		for await (const chunk of gunzip) {
+			const room = cap - kept;
+			if (chunk.length > room) {
+				chunks.push(chunk.subarray(0, room));
+				kept += room;
+				truncated = true;
+				break;
+			}
+			chunks.push(chunk);
+			kept += chunk.length;
+		}
+	} catch {
+		return null;
+	} finally {
+		gunzip.destroy();
+	}
+	return {
+		data: Buffer.concat(chunks, kept),
+		truncated
+	};
+}
+function decode(bytes, truncated) {
+	if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254) return new TextDecoder("utf-16le").decode(bytes.subarray(2), { stream: truncated });
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) return new TextDecoder("utf-16be").decode(bytes.subarray(2), { stream: truncated });
+	return new TextDecoder("utf-8").decode(bytes, { stream: truncated });
+}
+function fail(outcome, reason, base, kind = null, locs = 0) {
+	return Object.freeze({
+		outcome,
+		kind,
+		reason,
+		locs,
+		...base
+	});
+}
+var SITEMAP_NAMESPACE = "http://www\\.sitemaps\\.org/schemas/sitemap/0\\.9";
+function escapePrefix(prefix) {
+	return prefix.replace(/[.-]/g, "\\$&");
+}
+/**
+* The last 256 characters before any trailing whitespace, comments and processing instructions
+* (WordPress SEO plugins end a sitemap with a comment after the closing tag). Linear: each step
+* moves the end back.
+*/
+function tailBeforeComments(xml) {
+	let end = xml.length;
+	for (let step = 0; step < 100; step += 1) {
+		while (end > 0 && /\s/.test(xml.charAt(end - 1))) end -= 1;
+		if (end >= 3 && xml.startsWith("-->", end - 3)) {
+			const start = xml.lastIndexOf("<!--", end - 3);
+			if (start === -1) break;
+			end = start;
+		} else if (end >= 2 && xml.startsWith("?>", end - 2)) {
+			const start = xml.lastIndexOf("<?", end - 2);
+			if (start === -1) break;
+			end = start;
+		} else break;
+	}
+	return xml.slice(Math.max(0, end - 256), end);
+}
+var XML_PROLOG = /^(?:\s|<\?[\s\S]*?\?>|<!--[\s\S]*?-->)*/;
+/** Counts `<loc>` start tags, up to `MAX_LOCS_COUNTED`. */
+function countLocs(xml) {
+	const pattern = /<loc[\s>]/gi;
+	let count = 0;
+	while (pattern.exec(xml) !== null) {
+		count += 1;
+		if (count >= 1e5) break;
+	}
+	return count;
+}
+/**
+* The sitemap rules on text that is already decoded and inflated. `truncated` says the text was
+* cut at the cap: it is then read as far as it goes.
+*/
+function readSitemapText(text, contentType, siteUrl, options = {}) {
+	const registrable = options.registrableDomain ?? registrableDomain;
+	const truncated = options.truncated === true;
+	const base = {
+		gzip: options.gzip === true,
+		truncated,
+		bytes: Buffer.byteLength(text, "utf8")
+	};
+	let siteDomain = "";
+	try {
+		siteDomain = registrable(new URL(siteUrl).hostname);
+	} catch {
+		siteDomain = "";
+	}
+	const onSite = (candidate) => {
+		try {
+			const url = new URL(candidate);
+			return (url.protocol === "http:" || url.protocol === "https:") && isOnDomain(url.hostname, siteDomain);
+		} catch {
+			return false;
+		}
+	};
+	const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	if (body.trim() === "") return fail("not_a_sitemap", "empty", base);
+	if (looksLikeHtml(null, body)) return fail("not_a_sitemap", "html", base);
+	const servedAsHtml = contentType === "text/html" || contentType === "application/xhtml+xml";
+	if (body.trimStart().charAt(0) === "<") {
+		if (/<!(?:doctype|entity)\b/i.test(body)) return fail("malformed", "doctype", base);
+		const afterProlog = body.slice(XML_PROLOG.exec(body)[0].length);
+		const root = /^<(?:([A-Za-z][\w.-]*):)?([A-Za-z][\w.-]*)([^>]*)>?/.exec(afterProlog);
+		const rootName = root?.[2]?.toLowerCase();
+		const prefix = root?.[1];
+		const prefixBound = prefix === void 0 || new RegExp(`xmlns:${escapePrefix(prefix)}\\s*=\\s*["']${SITEMAP_NAMESPACE}["']`).test(root?.[3] ?? "");
+		if (rootName !== "urlset" && rootName !== "sitemapindex" || !prefixBound) return fail("not_a_sitemap", servedAsHtml ? "html" : "bad_root", base);
+		const kind = rootName === "urlset" ? "urlset" : "index";
+		const xml = prefix === void 0 ? body : body.replace(new RegExp(`<(/?)${escapePrefix(prefix)}:`, "g"), "<$1");
+		const locs = countLocs(xml);
+		if (locs === 0) return fail("malformed", "no_loc", base, kind);
+		const listed = sitemapLocations(xml, LOCS_CHECKED).locations;
+		if (listed.length === 0) return fail("malformed", "no_loc", base, kind, locs);
+		if (!listed.some(onSite)) return fail("malformed", "off_site", base, kind, locs);
+		if (!truncated && !new RegExp(`</${rootName}\\s*>$`, "i").test(tailBeforeComments(xml))) return fail("malformed", "not_closed", base, kind, locs);
+		return Object.freeze({
+			outcome: "valid",
+			kind,
+			reason: null,
+			locs,
+			...base
+		});
+	}
+	const lines = body.split(/\r\n|\r|\n/);
+	if (truncated) lines.pop();
+	const checked = lines.map((line) => line.trim()).filter((line) => line !== "").slice(0, MAX_LOCS_COUNTED);
+	if (checked.length === 0 || checked.some((line) => !/^https?:\/\/\S+$/i.test(line))) return fail("not_a_sitemap", servedAsHtml ? "html" : "text_lines", base);
+	if (!checked.slice(0, LOCS_CHECKED).some(onSite)) return fail("malformed", "off_site", base, "text", checked.length);
+	return Object.freeze({
+		outcome: "valid",
+		kind: "text",
+		reason: null,
+		locs: checked.length,
+		...base
+	});
+}
+/**
+* Reads a sitemap file from its bytes as served. A gzip file (the `.gz` sitemap, found by its
+* two first bytes) is inflated to at most `SITEMAP_MAX_BYTES`; a file that goes past the cap is
+* cut there and reported as `truncated`, and valid as far as it was read. `siteUrl` is the
+* site's own address: only `<loc>` entries on its registrable domain count.
+*/
+async function readSitemap(bytes, contentType, siteUrl, options = {}) {
+	let data = bytes;
+	let truncated = options.truncated === true;
+	let gzip = false;
+	if (isGzip(bytes)) {
+		gzip = true;
+		const inflated = await inflateCapped(bytes, SITEMAP_MAX_BYTES);
+		if (inflated === null) return fail("malformed", "gzip_failed", {
+			gzip: true,
+			truncated: false,
+			bytes: 0
+		});
+		data = inflated.data;
+		truncated = inflated.truncated;
+	} else if (bytes.length > 5242880) {
+		data = bytes.subarray(0, SITEMAP_MAX_BYTES);
+		truncated = true;
+	}
+	const facts = readSitemapText(decode(data, truncated), contentType, siteUrl, {
+		...options,
+		truncated,
+		gzip
+	});
+	return Object.freeze({
+		...facts,
+		bytes: data.length
+	});
+}
+// src/facts/findings.ts
+/**
+* The findings of a site check, drawn from the facts it gathered. Each finding has a stable id,
+* a level, one plain sentence about this site, and the evidence it rests on. A finding is given
+* for a check that applies: Organization details are judged only when an Organization was found,
+* and the page's own checks only when the home page was read.
+*/
+var DOC_BASE = "https://queryrev.com/research/ai-search-readiness#";
+/** Where each finding is explained: its own anchor where the method has one, else the method. */
+var ANCHORS = Object.freeze({
+	"home-page-read": "home-pages-read",
+	"ai-search-crawler-access": "readable-by-ai-search",
+	"json-ld-on-home-page": "json-ld-on-home-page",
+	"json-ld-errors": "json-ld-errors",
+	"organization-schema": "organization-schema",
+	"organization-microdata-only": "organization-microdata-only",
+	"organization-name-and-url": "organization-name-and-url",
+	"organization-logo": "organization-logo",
+	"organization-same-as": "organization-same-as",
+	"website-schema": "website-schema",
+	"faq-schema": "faq-schema",
+	"text-in-html": "text-in-html",
+	"app-shell": "app-shell",
+	"little-text": "little-text",
+	"noindex-home-page": "noindex-home-page",
+	"sitemap-in-robots": "sitemap-in-robots",
+	"sitemap-valid": "sitemap-valid",
+	"sitemap-cut": "sitemap-valid",
+	"llms-txt-found": "llms-txt-found"
+});
+/** The finding ids that exist, for tests and for tools that list them. */
+var FINDING_IDS = Object.freeze([
+	"site-refused",
+	"robots-txt",
+	"sitemap-in-robots",
+	"reader-blocked",
+	"ai-search-crawler-access",
+	"ai-training-crawler-access",
+	"home-page-read",
+	"home-truncated",
+	"noindex-home-page",
+	"text-in-html",
+	"app-shell",
+	"little-text",
+	"json-ld-on-home-page",
+	"json-ld-errors",
+	"json-ld-bounds",
+	"organization-schema",
+	"organization-microdata-only",
+	"organization-name-and-url",
+	"organization-logo",
+	"organization-same-as",
+	"website-schema",
+	"faq-schema",
+	"llms-txt-found",
+	"llms-txt-structure",
+	"sitemap-valid",
+	"sitemap-cut"
+]);
+function finding(id, level, message, snippet) {
+	message = stripUnsafeCharacters(message);
+	snippet = snippet === void 0 ? void 0 : stripUnsafeCharacters(snippet);
+	const docUrl = `${DOC_BASE}${ANCHORS[id] ?? "method"}`;
+	return Object.freeze(snippet === void 0 || snippet === "" ? {
+		id,
+		level,
+		message,
+		docUrl
+	} : {
+		id,
+		level,
+		message,
+		docUrl,
+		snippet: snippet.slice(0, 300)
+	});
+}
+var HOME_NOT_READ = {
+	not_allowed: ["info", `robots.txt keeps ${READER_TOKEN} from the home page, so it was not requested.`],
+	forbidden: ["warn", "The home page answered 401 or 403 to this reader, so it was not read."],
+	challenge: ["warn", "The home page answered with a bot check, so its content was not read."],
+	placeholder: ["fail", "The home page is a placeholder (a parking page or a server default page)."],
+	not_html: ["fail", "The home page did not answer with an HTML document."],
+	error_status: ["fail", "The home page did not answer with a normal 200 page."],
+	off_site: ["warn", "The home page redirects to another site, which was not followed."],
+	redirect_error: ["fail", "The home page redirects in a loop or too many times."],
+	network: ["warn", "The home page could not be reached."]
+};
+var SITEMAP_REASON = {
+	html: "the address answers with an HTML page",
+	empty: "the file is empty",
+	doctype: "the XML has a DOCTYPE or ENTITY, which is not read",
+	bad_root: "the XML does not start with urlset or sitemapindex",
+	no_loc: "it lists no address",
+	off_site: "none of the addresses it lists is on this site",
+	not_closed: "the XML is not closed",
+	text_lines: "the text is not a list of addresses",
+	gzip_failed: "the gzip file cannot be inflated"
+};
+function pageFindings(page) {
+	const out = [];
+	if (page.noindex) out.push(finding("noindex-home-page", "fail", "The home page tells crawlers not to index it (noindex).", `noindex in ${page.noindexSource === "header" ? "the X-Robots-Tag header" : page.noindexSource === "both" ? "the robots meta tag and the X-Robots-Tag header" : "the robots meta tag"}`));
+	else out.push(finding("noindex-home-page", "pass", "The home page does not say noindex."));
+	const words = `${page.mainWords}${page.wordsCapped ? "+" : ""}`;
+	if (page.content === "text_in_html") out.push(finding("text-in-html", "pass", `The page carries ${words} words of text in the HTML as served.`, `main text: ${words} words (${page.mainSource === "main" ? "main element" : "body without header, navigation and footer"})`));
+	else if (page.content === "app_shell") out.push(finding("app-shell", "fail", `The page is served as an empty application shell: ${words} words of text, and the content needs scripts.`, page.appRoot ? "an application root element is present" : "the page asks for JavaScript"));
+	else out.push(finding("little-text", "warn", `The page carries ${words} words of text in the HTML as served, under 150.`));
+	const ld = page.jsonLd;
+	if (ld.schemaOrgBlocks > 0) out.push(finding("json-ld-on-home-page", "pass", `The home page has ${ld.schemaOrgBlocks} JSON-LD block${ld.schemaOrgBlocks === 1 ? "" : "s"} naming schema.org.`, page.types.slice(0, 12).join(", ")));
+	else out.push(finding("json-ld-on-home-page", "warn", "The home page has no JSON-LD structured data."));
+	if (ld.errors > 0) out.push(finding("json-ld-errors", "warn", `${ld.errors} JSON-LD block${ld.errors === 1 ? "" : "s"} on the home page cannot be parsed as JSON.`));
+	if (ld.bounds.length > 0) out.push(finding("json-ld-bounds", "info", "The structured data is larger than this reader reads; the rest was left out.", ld.bounds.join(", ")));
+	if (page.organization === "json_ld" && page.primary !== null) {
+		const primary = page.primary;
+		out.push(finding("organization-schema", "pass", `The home page describes the organization in JSON-LD (${primary.type}).`, primary.name ?? void 0));
+		out.push(primary.nameAndUrl ? finding("organization-name-and-url", "pass", "The Organization has a name and a url.", `${primary.name ?? ""} ${primary.url ?? ""}`.trim()) : finding("organization-name-and-url", "warn", "The Organization lacks a name or an absolute http(s) url."));
+		out.push(primary.logo ? finding("organization-logo", "pass", "The Organization has a logo.") : finding("organization-logo", "info", "The Organization has no logo."));
+		out.push(primary.sameAs.length > 0 ? finding("organization-same-as", "pass", `The Organization links ${primary.sameAs.length} profile${primary.sameAs.length === 1 ? "" : "s"} elsewhere with sameAs.`, primary.sameAsKinds.join(", ")) : finding("organization-same-as", "warn", "The Organization has no sameAs link to a profile on another site."));
+	} else if (page.organization === "microdata") out.push(finding("organization-microdata-only", "warn", "The organization is described in microdata only; no JSON-LD Organization was found.", page.organizationType ?? void 0));
+	else out.push(finding("organization-schema", "warn", "The home page does not describe the organization in structured data."));
+	out.push(page.website ? finding("website-schema", "pass", page.searchAction ? "The home page has WebSite data with a SearchAction." : "The home page has WebSite data.") : finding("website-schema", "info", "The home page has no WebSite data."));
+	if (page.faqPage) out.push(finding("faq-schema", "pass", "The home page has FAQPage data."));
+	return out;
+}
+/** The findings for the facts of a check. */
+function buildFindings(site) {
+	const out = [];
+	const { robots } = site;
+	if (robots.outcome === "file") {
+		out.push(finding("robots-txt", "pass", `robots.txt found (${robots.bytes} bytes).`));
+		out.push(robots.sitemaps.length > 0 ? finding("sitemap-in-robots", "pass", "robots.txt lists a sitemap.", robots.sitemaps[0]) : finding("sitemap-in-robots", "info", "robots.txt lists no sitemap."));
+	} else if (robots.outcome === "missing") out.push(finding("robots-txt", "info", "There is no robots.txt; nothing is closed to crawlers.", robots.status === null ? void 0 : `status ${robots.status}`));
+	else {
+		out.push(finding("robots-txt", "warn", "robots.txt could not be read, so nothing else was requested.", robots.status === null ? "no answer" : `status ${robots.status}`));
+		return out;
+	}
+	if (!robots.allowsThisReader) out.push(finding("reader-blocked", "info", `robots.txt keeps ${READER_TOKEN} from the home page.`));
+	const searchAndUser = site.crawlerAccess.filter((entry) => entry.purpose !== "training");
+	const closed = searchAndUser.filter((entry) => entry.access === "blocked" || !entry.root);
+	const partial = searchAndUser.filter((entry) => entry.access === "partial" && entry.root);
+	if (closed.length > 0) out.push(finding("ai-search-crawler-access", "fail", `robots.txt keeps ${closed.length} of ${searchAndUser.length} AI search and user-fetch crawlers from the home page.`, closed.map((entry) => entry.token).join(", ")));
+	else if (partial.length > 0) out.push(finding("ai-search-crawler-access", "warn", `robots.txt closes parts of the site to ${partial.length} of ${searchAndUser.length} AI search and user-fetch crawlers.`, partial.map((entry) => entry.token).join(", ")));
+	else out.push(finding("ai-search-crawler-access", "pass", `All ${searchAndUser.length} AI search and user-fetch crawlers on the list can read the home page.`));
+	const training = site.crawlerAccess.filter((entry) => entry.purpose === "training");
+	const trainingClosed = training.filter((entry) => entry.access === "blocked");
+	out.push(finding("ai-training-crawler-access", "info", trainingClosed.length === 0 ? "No AI training crawler on the list is blocked. Blocking them is the site's choice." : `${trainingClosed.length} of ${training.length} AI training crawlers are blocked. Blocking them is the site's choice.`, trainingClosed.map((entry) => entry.token).join(", ")));
+	const home = site.home;
+	if (home !== null) {
+		if (home.outcome === "read" && home.facts !== null) {
+			out.push(finding("home-page-read", "pass", "The home page was read.", `${home.status ?? ""} ${home.finalUrl}`.trim()));
+			if (home.truncated || home.facts.scanTruncated) out.push(finding("home-truncated", "info", "The home page is larger than 2 MiB; it was read as far as the limit."));
+			out.push(...pageFindings(home.facts));
+		} else if (home.outcome !== "read") {
+			const [level, message] = HOME_NOT_READ[home.outcome];
+			out.push(finding("home-page-read", level, message, home.status === null ? void 0 : `status ${home.status}`));
+		}
+	}
+	const llms = site.llms;
+	if (!llms.asked) out.push(finding("llms-txt-found", "info", `robots.txt keeps ${READER_TOKEN} from /llms.txt, so it was not requested.`));
+	else if (llms.present) {
+		out.push(finding("llms-txt-found", "pass", "An llms.txt is present.", llms.h1 ?? void 0));
+		const missing = [];
+		if (llms.sections === 0) missing.push("a section of links");
+		out.push(missing.length === 0 ? finding("llms-txt-structure", "pass", `The llms.txt has ${llms.sections} section${llms.sections === 1 ? "" : "s"} and ${llms.links} link${llms.links === 1 ? "" : "s"}.`) : finding("llms-txt-structure", "warn", `The llms.txt lacks ${missing.join(" and ")}.`));
+	} else out.push(finding("llms-txt-found", "info", "No llms.txt was found.", llms.verdict === null ? void 0 : llms.verdict));
+	const sitemap = site.sitemap;
+	if (!sitemap.asked) out.push(finding("sitemap-valid", "info", `robots.txt keeps ${READER_TOKEN} from the sitemap, so it was not requested.`));
+	else if (sitemap.facts !== null && sitemap.facts.outcome === "valid") {
+		const facts = sitemap.facts;
+		out.push(finding("sitemap-valid", "pass", `A valid sitemap${facts.kind === "index" ? " index" : ""} lists ${facts.locs} ${facts.kind === "index" ? "sitemap" : "page"}${facts.locs === 1 ? "" : "s"}.`, sitemap.url ?? void 0));
+		if (facts.truncated) out.push(finding("sitemap-cut", "info", "The sitemap is larger than 5 MiB; it is valid as far as it was read."));
+	} else {
+		const reason = sitemap.facts?.reason;
+		out.push(finding("sitemap-valid", "warn", reason === void 0 || reason === null ? "No valid sitemap was found." : `No valid sitemap: ${SITEMAP_REASON[reason]}.`, `${sitemap.url ?? ""}${sitemap.status === null ? "" : ` (status ${sitemap.status})`}`.trim()));
+	}
+	return out;
+}
+// src/facts/check-site.ts
+/**
+* `checkSite`: reads a site's public files over the guarded fetcher and returns the facts and
+* stable findings. Requests, in order, each only if robots.txt allows this reader (its own
+* token) to make it:
+*
+* 1. `/robots.txt`
+* 2. the home page, `/`
+* 3. `/llms.txt`
+* 4. the sitemap: the first `Sitemap:` line on the same registrable domain, else `/sitemap.xml`
+*
+* A robots.txt that cannot be read ends the check: nothing else is asked. No score is given:
+* the result is facts and findings with evidence.
+*/
+var EMPTY_ROBOTS = parseRobots("");
+function sameSite(registrable, siteDomain) {
+	return (target) => registrable(target.hostname) === siteDomain;
+}
+function robotsRead(result, url) {
+	const base = {
+		url,
+		status: result.status,
+		bytes: result.bytes,
+		truncated: result.truncated
+	};
+	const notRead = () => ({
+		read: Object.freeze({
+			...base,
+			outcome: "not_read",
+			sitemaps: Object.freeze([]),
+			allowsThisReader: false
+		}),
+		robots: null
+	});
+	if (result.outcome !== "response" || result.status === null) return notRead();
+	const status = result.status;
+	if (status >= 200 && status < 300) {
+		if (result.text === null || isChallenge(status, result.text)) return notRead();
+		const robots = parseRobots(result.text, url);
+		return {
+			read: Object.freeze({
+				...base,
+				outcome: "file",
+				sitemaps: Object.freeze([...robots.sitemaps]),
+				allowsThisReader: isAllowedByRobots(robots, READER_TOKEN, "/")
+			}),
+			robots
+		};
+	}
+	if (status >= 400 && status < 500 && status !== 401 && status !== 403 && status !== 429) return {
+		read: Object.freeze({
+			...base,
+			outcome: "missing",
+			sitemaps: Object.freeze([]),
+			allowsThisReader: true
+		}),
+		robots: EMPTY_ROBOTS
+	};
+	return notRead();
+}
+var NOT_ASKED_LLMS = Object.freeze({
+	asked: false,
+	present: false,
+	verdict: null,
+	bytes: 0,
+	truncated: false,
+	h1: null,
+	sections: 0,
+	links: 0
+});
+var NOT_ASKED_SITEMAP = Object.freeze({
+	asked: false,
+	source: null,
+	url: null,
+	status: null,
+	facts: null
+});
+/** The first `Sitemap:` address on the site's registrable domain; null without one. */
+function sitemapFromRobots(lines, registrable, siteDomain) {
+	for (const line of lines) try {
+		const url = new URL(line);
+		if ((url.protocol === "http:" || url.protocol === "https:") && registrable(url.hostname) === siteDomain) return url.href;
+	} catch {}
+	return null;
+}
+function refused(origin, host, why) {
+	const finding = Object.freeze({
+		id: "site-refused",
+		level: "fail",
+		message: "The address cannot be checked: it must be a web site name or an http(s) address.",
+		docUrl: "https://queryrev.com/research/ai-search-readiness#method",
+		snippet: why
+	});
+	return Object.freeze({
+		schemaVersion: 1,
+		origin,
+		host,
+		crawlersCovered: crawlersCoveredLine(),
+		robots: Object.freeze({
+			outcome: "not_read",
+			url: "",
+			status: null,
+			bytes: 0,
+			truncated: false,
+			sitemaps: Object.freeze([]),
+			allowsThisReader: false
+		}),
+		crawlerAccess: Object.freeze([]),
+		home: null,
+		llms: NOT_ASKED_LLMS,
+		sitemap: NOT_ASKED_SITEMAP,
+		findings: Object.freeze([finding])
+	});
+}
+/**
+* Checks a site given as a host name (`example.com`) or an http(s) address (only its scheme and
+* host are used). Never throws for what a site does or for an address that cannot be checked:
+* the result says what was read and what was not.
+*/
+async function checkSite(input, options = {}) {
+	const registrable = options.registrableDomain ?? registrableDomain;
+	const typed = input.trim();
+	const checked = checkTextUrl(/^[a-z][a-z0-9+.-]*:\/\//i.test(typed) ? typed : `https://${typed}`);
+	if ("refusal" in checked) return refused("", "", checked.refusal);
+	const origin = checked.url.origin;
+	const host = checked.url.hostname;
+	const siteDomain = registrable(host);
+	const owned = options.fetcher === void 0;
+	const fetcher = options.fetcher ?? createTextFetcher();
+	const budget = AbortSignal.timeout(CHECK_BUDGET_MS);
+	const signal = options.signal === void 0 ? budget : AbortSignal.any([options.signal, budget]);
+	const redirectAllowed = sameSite(registrable, siteDomain);
+	try {
+		const robotsUrl = `${origin}/robots.txt`;
+		const { read: robots, robots: parsed } = robotsRead(await fetcher.fetchText(robotsUrl, {
+			kind: "robots",
+			signal,
+			redirectAllowed
+		}), robotsUrl);
+		let home = null;
+		let llms = NOT_ASKED_LLMS;
+		let sitemap = NOT_ASKED_SITEMAP;
+		const access = parsed === null ? [] : crawlerAccess(parsed).map((entry) => Object.freeze({
+			token: entry.crawler.token,
+			purpose: entry.crawler.purpose,
+			access: entry.access,
+			root: entry.root.allowed
+		}));
+		if (parsed !== null) {
+			fetcher.setCrawlDelay(host, crawlDelayFor(parsed, READER_TOKEN));
+			const allowed = (path) => isAllowedByRobots(parsed, READER_TOKEN, path);
+			if (allowed("/")) home = readHomeResponse(await fetcher.fetchText(`${origin}/`, {
+				kind: "page",
+				signal,
+				redirectAllowed
+			}), { registrableDomain: registrable });
+			else home = Object.freeze({
+				outcome: "not_allowed",
+				requestedUrl: `${origin}/`,
+				finalUrl: `${origin}/`,
+				status: null,
+				redirects: 0,
+				truncated: false,
+				facts: null
+			});
+			if (allowed("/llms.txt")) {
+				const result = await fetcher.fetchText(`${origin}/llms.txt`, {
+					kind: "llms",
+					signal,
+					redirectAllowed
+				});
+				const report = validateLlmsTxt({
+					status: result.outcome === "response" ? result.status : null,
+					contentType: result.contentType,
+					body: result.text,
+					truncated: result.truncated
+				});
+				llms = Object.freeze({
+					asked: true,
+					present: report.present,
+					verdict: report.verdict,
+					bytes: report.bytes,
+					truncated: report.truncated,
+					h1: report.h1,
+					sections: report.structure?.sections ?? 0,
+					links: report.structure?.links ?? 0
+				});
+			}
+			const fromRobots = sitemapFromRobots(parsed.sitemaps, registrable, siteDomain);
+			const sitemapUrl = fromRobots ?? `${origin}/sitemap.xml`;
+			let path = "/sitemap.xml";
+			try {
+				const url = new URL(sitemapUrl);
+				path = `${url.pathname}${url.search}`;
+			} catch {}
+			if (isAllowedByRobots(parsed, "QueryRev-AIReadiness", path)) {
+				const result = await fetcher.fetchText(sitemapUrl, {
+					kind: "sitemap",
+					signal,
+					redirectAllowed
+				});
+				const ok = result.outcome === "response" && result.status !== null && result.status >= 200 && result.status < 300 && result.rawBody !== null;
+				sitemap = Object.freeze({
+					asked: true,
+					source: fromRobots === null ? "well_known" : "robots",
+					url: sitemapUrl,
+					status: result.status,
+					facts: ok ? await readSitemap(result.rawBody, result.contentType, origin, {
+						truncated: result.truncated,
+						registrableDomain: registrable
+					}) : null
+				});
+			}
+		}
+		const site = {
+			schemaVersion: 1,
+			origin,
+			host,
+			crawlersCovered: crawlersCoveredLine(),
+			robots,
+			crawlerAccess: Object.freeze(access),
+			home,
+			llms,
+			sitemap
+		};
+		return Object.freeze({
+			...site,
+			findings: Object.freeze(buildFindings(site))
+		});
+	} finally {
+		if (owned) await fetcher.close();
+	}
+}
+// src/llms/findings.ts
+/**
+* The findings of an llms.txt validation, drawn from a `LlmsReport`. Used by the command line
+* and by any tool that validates the file: each finding has a stable id, a level and one plain
+* sentence, and nothing is scored.
+*/
+var DOC_URL = "https://queryrev.com/research/ai-search-readiness#llms-txt-found";
+/** The finding ids this module can return. */
+var LLMS_FINDING_IDS = Object.freeze([
+	"llms-txt-found",
+	"llms-txt-h1",
+	"llms-txt-summary",
+	"llms-txt-sections",
+	"llms-txt-cut"
+]);
+function llmsFinding(id, level, message, snippet) {
+	const text = stripUnsafeCharacters(snippet ?? "").slice(0, 300);
+	return Object.freeze(text === "" ? {
+		id,
+		level,
+		message: stripUnsafeCharacters(message),
+		docUrl: DOC_URL
+	} : {
+		id,
+		level,
+		message: stripUnsafeCharacters(message),
+		docUrl: DOC_URL,
+		snippet: text
+	});
+}
+var NOT_AN_LLMS = {
+	no_answer: "No answer arrived, so there is no llms.txt to validate.",
+	not_found: "There is no llms.txt: the address answers 404 or 410.",
+	status: "The address does not answer 200, so it is not an llms.txt.",
+	not_text: "The address answers with a type that is not text, so it is not an llms.txt.",
+	html: "The address answers 200 with an HTML page, which is not an llms.txt (a soft 404).",
+	robots: "The address answers 200 with a robots.txt, which is not an llms.txt.",
+	no_h1: "The text does not start with a Markdown H1 (# Name), which llmstxt.org requires."
+};
+/** The findings for one validated answer. */
+function llmsFindings(report) {
+	if (report.verdict !== "llms_txt" || report.structure === null) {
+		const message = NOT_AN_LLMS[report.verdict];
+		return [llmsFinding("llms-txt-found", "fail", message ?? "The answer is not an llms.txt.", report.status === null ? void 0 : `status ${report.status}`)];
+	}
+	const structure = report.structure;
+	const out = [llmsFinding("llms-txt-found", "pass", "The file is an llms.txt.", report.h1 ?? void 0)];
+	out.push(report.h1Count === 1 ? llmsFinding("llms-txt-h1", "pass", "The file has one H1, as llmstxt.org asks.") : llmsFinding("llms-txt-h1", "warn", `The file has ${report.h1Count} H1 headings; llmstxt.org asks for exactly one.`));
+	out.push(structure.summary ? llmsFinding("llms-txt-summary", "pass", "The file has a summary blockquote.") : llmsFinding("llms-txt-summary", "warn", "The file has no summary blockquote (a line starting with \">\") before its first section."));
+	out.push(structure.sections > 0 ? llmsFinding("llms-txt-sections", "pass", `The file has ${structure.sections} H2 section${structure.sections === 1 ? "" : "s"} of links and ${structure.links} link${structure.links === 1 ? "" : "s"} in all.`) : llmsFinding("llms-txt-sections", "warn", "The file has no H2 section that lists links."));
+	if (report.truncated) out.push(llmsFinding("llms-txt-cut", "info", "The file is larger than 1 MiB; it was read as far as that limit."));
+	return out;
+}
+export { looksLikeHtml as $, MAX_LOC_TAGS_SCANNED as A, CHALLENGE_MAX_WORDS as B, MAX_LD_DEPTH as C, EMPTY_SHELL_MIN_BYTES as Ct, MAX_LD_BLOCK_CHARS as D, MAX_LD_BLOCKS as E, sitemapLocations as F, isChallenge as G, INTERSTITIAL_MARKS as H, stripUnsafeCharacters as I, decodeHtml as J, isHomeChallenge as K, MAX_WORDS_COUNTED as L, attributes as M, pageMeta as N, MAX_LD_TOTAL_CHARS as O, renderLlmsTxt as P, llmsStructure as Q, countWords as R, SCHEMA_ORG_VERSION as S, EMPTY_SHELL_MAX_WORDS as St, HOME_SCAN_MAX_CHARS as T, isAppRoot as Tt, PLACEHOLDER_MARKS as U, HTML_MARKUP as V, PLACEHOLDER_MAX_WORDS as W, registrableDomain as X, detectCharset as Y, LLMS_H1_MAX as Z, PROFILE_HOSTS as _, parseRobots as _t, robotsRead as a, CRAWLER_PURPOSES as at, ORGANIZATION_TYPES as b, APP_ROOT_SELECTOR as bt, MAX_LOCS_COUNTED as c, crawlerAccess as ct, readSitemapText as d, ROBOTS_MAX_AGE_MS as dt, looksLikeLlmsTxt as et, READER_TOKEN as f, ROBOTS_MAX_BYTES as ft, xRobotsNoindex as g, matchRobots as gt, readHomePage as h, isAllowedByRobots as ht, checkSite as i, CRAWLERS as it, PAGE_SCAN_MAX_CHARS as j, MAIN_SECTION as k, SITEMAP_MAX_BYTES as l, crawlersCoveredLine as lt, TEXT_IN_HTML_MIN_WORDS as m, crawlDelayFor as mt, llmsFinding as n, validateLlmsTxt as nt, FINDING_IDS as o, STUDY_AGENTS as ot, readHomeResponse as p, ROBOTS_MAX_REDIRECTS as pt, placeholderMark as q, llmsFindings as r, AI_AGENTS as rt, buildFindings as s, agentVerdict as st, LLMS_FINDING_IDS as t, looksLikeRobotsTxt as tt, readSitemap as u, verdictsFor as ut, PROFILE_KINDS as v, APP_ROOT_ATTRIBUTES as vt, MAX_LD_NODES as w, JS_NOTICE as wt, SCHEMA_ORG_SHA256 as x, APP_ROOT_TAG as xt, profileKind as y, APP_ROOT_IDS as yt, CHALLENGE_MARKS as z };