eaa-kit 0.1.0

package/dist/render-K9KxDDSA.js

@@ -0,0 +1,774 @@
+import { n as IMPACT_LEVELS } from "./impact-DvgBjupx.js";
+import { n as escapeText, t as escapeAttribute } from "./escape-Dm1o_RAk.js";
+import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
+import { z } from "zod";
+import { readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/config/define.ts
+/** Countries with their own supervisory body and statute text. */
+const COUNTRIES = [
+	"AT",
+	"DE",
+	"CH"
+];
+/** Languages a statement can be rendered in. */
+const STATEMENT_LOCALES = ["de", "en"];
+/**
+* Wording follows the EU model statement: fully, partially, or not conformant
+* with the standard. "partially-compliant" is the honest answer for most sites
+* and the one that carries obligations to list what is missing.
+*/
+const COMPLIANCE_STATUSES = [
+	"compliant",
+	"partially-compliant",
+	"non-compliant"
+];
+const ASSESSMENT_METHODS = ["self-assessment", "external-audit"];
+/**
+* Why a known barrier still exists. The first two are the grounds the EU regime
+* recognises for leaving something inaccessible; the third is a plain promise to
+* fix it, which is what most small sites actually mean.
+*/
+const ISSUE_REASONS = [
+	"disproportionate-burden",
+	"out-of-scope",
+	"fix-planned"
+];
+const knownIssueObject = z.object({
+	/** What is not accessible, in the statement's language. */
+	description: z.string().min(1),
+	/** WCAG success criteria, e.g. ['1.4.3']. */
+	successCriteria: z.array(z.string()).default([]),
+	/** EN 301 549 clauses, e.g. ['9.1.4.3']. */
+	en301549: z.array(z.string()).default([]),
+	reason: z.enum(ISSUE_REASONS).optional(),
+	/** ISO date by which the barrier is expected to be removed. */
+	remedyBy: z.iso.date().optional()
+});
+/**
+* A bare string is accepted as shorthand for `{ description }`. It is piped
+* through the object schema so both branches produce the same output type,
+* rather than a union that callers have to narrow before reading `remedyBy`.
+*/
+const knownIssueSchema = z.union([z.string().min(1).transform((description) => ({ description })).pipe(knownIssueObject), knownIssueObject]);
+const configSchema = z.object({
+	site: z.object({
+		name: z.string().min(1),
+		url: z.url(),
+		/** BCP 47 tag of the site itself, e.g. 'de-AT'. */
+		locale: z.string().min(2)
+	}),
+	provider: z.object({
+		/** The legal entity answerable for the service. */
+		legalName: z.string().min(1),
+		/**
+		* The feedback address. Required: the EAA obliges providers to offer a way
+		* to report accessibility barriers, and a statement without one is not
+		* usable for its purpose.
+		*/
+		email: z.email(),
+		phone: z.string().min(1).optional(),
+		address: z.string().min(1).optional(),
+		/**
+		* A contact or feedback form, offered alongside the address rather than
+		* instead of it: the EAA requires a way to report barriers, and a form is
+		* the one channel a visitor who cannot use email may still be able to use.
+		*/
+		feedbackUrl: z.url().optional()
+	}),
+	compliance: z.object({
+		status: z.enum(COMPLIANCE_STATUSES),
+		standard: z.string().min(1).default("EN 301 549 V3.2.1 (WCAG 2.2 AA)"),
+		knownIssues: z.array(knownIssueSchema).default([]),
+		/** When the assessment was carried out. */
+		assessedOn: z.iso.date(),
+		assessmentMethod: z.enum(ASSESSMENT_METHODS).default("self-assessment"),
+		/**
+		* Reason attached to barriers taken from an audit report, which carries no
+		* reason of its own. 'fix-planned' is the honest default for a barrier an
+		* automated run just found; the other two are claims only a human can make.
+		*/
+		auditReason: z.enum(ISSUE_REASONS).default("fix-planned")
+	}),
+	enforcement: z.object({ 
+	/** Drives which supervisory body and statute the template names. */
+country: z.enum(COUNTRIES) })
+});
+/**
+* Identity function that gives `eaa.config.ts` its types. Deliberately does not
+* validate: a config file is loaded and checked in one place, so that an error
+* points at the file rather than at wherever the module happened to be
+* imported.
+*/
+function defineConfig(config) {
+	return config;
+}
+var ConfigError = class extends Error {
+	issues;
+	name = "ConfigError";
+	constructor(message, issues = []) {
+		super(message);
+		this.issues = issues;
+	}
+};
+/** Validate an already-loaded config object. */
+function parseConfig(value, source = "config") {
+	const result = configSchema.safeParse(value);
+	if (result.success) return result.data;
+	const issues = result.error.issues.map((issue) => {
+		const path = issue.path.join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	});
+	throw new ConfigError(`${source} is not valid`, issues);
+}
+//#endregion
+//#region src/config/load.ts
+/** Checked in this order, first match wins. */
+const CONFIG_FILENAMES = [
+	"eaa.config.ts",
+	"eaa.config.mts",
+	"eaa.config.js",
+	"eaa.config.mjs",
+	"eaa.config.json"
+];
+/**
+* Find and load `eaa.config.{ts,mts,js,mjs,json}`.
+*
+* TypeScript configs are imported directly: Node strips types natively from
+* 22.18 onwards, which is below this package's floor, so no bundler or loader
+* dependency is needed. The failure mode that remains is a project with no
+* package.json at all, where Node cannot tell ESM from CommonJS; the error says
+* so rather than surfacing "Unexpected token 'export'".
+*/
+async function loadConfig(options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const file = options.path ? path.resolve(cwd, options.path) : await findConfigFile(cwd);
+	if (!file) throw new ConfigError(`No config file found in ${cwd} or its parent directories`, CONFIG_FILENAMES.map((name) => `looked for ${name}`));
+	if (!await isFile(file)) throw new ConfigError(`Config file not found: ${file}`);
+	return {
+		config: parseConfig(file.endsWith(".json") ? await importJson(file) : await importModule(file), path.basename(file)),
+		path: file
+	};
+}
+/** Walks up from `cwd`, so the CLI works from a subdirectory of the project. */
+async function findConfigFile(cwd) {
+	let directory = path.resolve(cwd);
+	while (true) {
+		for (const name of CONFIG_FILENAMES) {
+			const candidate = path.join(directory, name);
+			if (await isFile(candidate)) return candidate;
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+async function importJson(file) {
+	const raw = await readFile(file, "utf8");
+	try {
+		return JSON.parse(raw);
+	} catch (cause) {
+		throw new ConfigError(`${path.basename(file)} is not valid JSON`, [cause instanceof Error ? cause.message : String(cause)]);
+	}
+}
+async function importModule(file) {
+	let module;
+	try {
+		module = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		const hint = message.includes("Unexpected token") ? "If the project has no package.json, Node cannot tell ESM from CommonJS. Add one with \"type\": \"module\", or use eaa.config.json." : message;
+		throw new ConfigError(`Could not load ${path.basename(file)}`, [hint]);
+	}
+	if (module.default === void 0) throw new ConfigError(`${path.basename(file)} has no default export`, ["Expected: export default defineConfig({ … })"]);
+	return module.default;
+}
+async function isFile(candidate) {
+	try {
+		return (await stat(candidate)).isFile();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/statement/error.ts
+/**
+* Lives in its own module so that both the renderer and the audit-report reader
+* can throw it without importing each other.
+*
+* Everything the statement command can fail on lands here: a missing template,
+* an audit report it cannot read. The CLI turns it into exit code 2, since a
+* statement that could not be produced is never a statement with a problem in
+* it — nothing is emitted at all.
+*/
+var StatementError = class extends Error {
+	name = "StatementError";
+};
+/**
+* Only the fields the statement reads. Everything else in the report — node
+* markup, selectors, passes, inapplicable — is audit detail with no place in a
+* legal document, and unknown keys are dropped rather than being carried along.
+*/
+const reportSchema = z.object({
+	schemaVersion: z.number(),
+	generatedAt: z.iso.datetime(),
+	summary: z.object({
+		pages: z.number(),
+		needsReview: z.number(),
+		notEvaluated: z.number()
+	}),
+	rules: z.record(z.string(), z.object({
+		help: z.string(),
+		successCriteria: z.array(z.string()).default([]),
+		en301549: z.array(z.string()).default([])
+	})),
+	pages: z.array(z.object({
+		path: z.string(),
+		violations: z.array(z.object({
+			ruleId: z.string(),
+			impact: z.string().nullable().default(null)
+		})).default([])
+	}))
+});
+/**
+* Turn a parsed `eaa-kit audit --format json` document into statement input.
+*
+* Only violations become barriers. A rule needing manual review has not been
+* found inaccessible, and a rule the engine could not evaluate has not been
+* found anything at all; listing either as non-accessible content would be a
+* claim the audit never made. Both are carried as counts instead, so the
+* statement can say how much the automated run left open.
+*/
+function summariseAuditReport(value, source = "audit report") {
+	const result = reportSchema.safeParse(value);
+	if (!result.success) throw new StatementError(`${source} is not an eaa-kit JSON report (${result.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`).slice(0, 5).join("; ")})`);
+	const report = result.data;
+	if (report.schemaVersion !== 1) throw new StatementError(`${source} has schemaVersion ${report.schemaVersion}; this version of eaa-kit reads 1`);
+	const byRule = /* @__PURE__ */ new Map();
+	const rules = new Map(Object.entries(report.rules));
+	for (const page of report.pages) for (const violation of page.violations) {
+		const rule = rules.get(violation.ruleId);
+		if (!rule) throw new StatementError(`${source} references rule ${violation.ruleId}, which is not in its rule index`);
+		const existing = byRule.get(violation.ruleId);
+		if (existing) {
+			if (!existing.pages.includes(page.path)) existing.pages.push(page.path);
+			continue;
+		}
+		byRule.set(violation.ruleId, {
+			ruleId: violation.ruleId,
+			help: rule.help,
+			impact: toImpact(violation.impact),
+			successCriteria: rule.successCriteria,
+			en301549: rule.en301549,
+			pages: [page.path]
+		});
+	}
+	const findings = [...byRule.values()];
+	for (const finding of findings) finding.pages.sort();
+	findings.sort(bySeverityThenRule);
+	return {
+		findings,
+		pages: report.summary.pages,
+		needsReview: report.summary.needsReview,
+		notEvaluated: report.summary.notEvaluated,
+		generatedAt: report.generatedAt
+	};
+}
+/** Read and summarise a report written by `eaa-kit audit --format json`. */
+async function readAuditReport(file, cwd = process.cwd()) {
+	const target = path.resolve(cwd, file);
+	let raw;
+	try {
+		raw = await readFile(target, "utf8");
+	} catch {
+		throw new StatementError(`Could not read the audit report at ${file}`);
+	}
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch (cause) {
+		throw new StatementError(`${path.basename(target)} is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	return summariseAuditReport(value, path.basename(target));
+}
+function toImpact(value) {
+	return IMPACT_LEVELS.includes(value ?? "") ? value : null;
+}
+/**
+* Most severe first, then by rule id so two runs of the same build order the
+* list identically. An unclassified impact sorts with the most severe, on the
+* same reasoning as `--fail-on`: a missing impact is a gap in what we know, not
+* evidence that the barrier is harmless.
+*/
+function bySeverityThenRule(a, b) {
+	const rank = (finding) => finding.impact === null ? IMPACT_LEVELS.length : IMPACT_LEVELS.indexOf(finding.impact);
+	const difference = rank(b) - rank(a);
+	return difference === 0 ? a.ruleId.localeCompare(b.ruleId) : difference;
+}
+//#endregion
+//#region src/statement/html.ts
+/**
+* A standalone, self-contained HTML page.
+*
+* Self-contained because the common destination is a CMS or a static host where
+* a second file would have to be wired up by hand. The markup inside `<main>`
+* carries no classes and no inline styles, so lifting it into an existing page
+* template and dropping this one's `<style>` block is a copy and paste.
+*/
+function toHtmlDocument(markdown, options) {
+	const body = toHtmlBody(markdown);
+	const title = firstHeading(markdown) ?? options.fallbackTitle;
+	return `<!doctype html>
+<html lang="${escapeAttribute(options.lang)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="eaa-kit ${escapeAttribute(TOOL_VERSION)}">
+<title>${escapeText(title)}</title>
+<style>
+${STYLES}
+</style>
+</head>
+<body>
+<main>
+${body}
+</main>
+</body>
+</html>
+`;
+}
+/** The document body: the block elements alone, for embedding in a page. */
+function toHtmlBody(markdown) {
+	const html = [];
+	const lines = markdown.split("\n");
+	let index = 0;
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		if (line.trim() === "") {
+			index += 1;
+			continue;
+		}
+		const heading = /^(#{1,3})\s+(.*)$/.exec(line);
+		if (heading?.[1] && heading[2] !== void 0) {
+			const level = heading[1].length;
+			html.push(`<h${level}>${inline(heading[2].trim())}</h${level}>`);
+			index += 1;
+			continue;
+		}
+		if (/^-{3,}$/.test(line.trim())) {
+			html.push("<hr>");
+			index += 1;
+			continue;
+		}
+		if (isListItem(line)) {
+			const list = takeList(lines, index);
+			html.push(list.html);
+			index = list.next;
+			continue;
+		}
+		const paragraph = takeParagraph(lines, index);
+		html.push(`<p>${inline(paragraph.text)}</p>`);
+		index = paragraph.next;
+	}
+	return html.join("\n");
+}
+const STYLES = `:root { color-scheme: light dark; }
+body { margin: 0; background: #ffffff; color: #1a1a1a;
+  font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; line-height: 1.6; }
+main { max-width: 44rem; margin: 0 auto; padding: 2rem 1.25rem 4rem; }
+h1 { font-size: 1.9rem; line-height: 1.25; margin: 0 0 1.5rem; }
+h2 { font-size: 1.3rem; line-height: 1.3; margin: 2.5rem 0 0.75rem; }
+p { margin: 0 0 1rem; }
+ul { margin: 0 0 1rem; padding-left: 1.25rem; }
+li + li { margin-top: 0.75rem; }
+a { color: #0b4fa8; }
+a:focus-visible { outline: 3px solid currentColor; outline-offset: 2px; }
+hr { border: 0; border-top: 1px solid #767676; margin: 2.5rem 0; }
+@media (prefers-color-scheme: dark) {
+  body { background: #121212; color: #ededed; }
+  a { color: #9ec1ff; }
+}`;
+function isListItem(line) {
+	return /^[-*]\s+/.test(line);
+}
+/** A continuation line: indented, and part of the item above it. */
+function isContinuation(line) {
+	return /^\s+\S/.test(line) && !isListItem(line.trim());
+}
+/**
+* One `<ul>`, with each item's continuation lines kept inside the item it
+* belongs to. The templates put an issue's standards reference, reason and
+* remedy date on those lines, and promoting them to items of their own would
+* read as four separate barriers instead of one described in detail.
+*/
+function takeList(lines, from) {
+	const items = [];
+	let index = from;
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		if (isListItem(line)) {
+			items.push([line.replace(/^[-*]\s+/, "").trim()]);
+			index += 1;
+			continue;
+		}
+		const current = items.at(-1);
+		if (current && isContinuation(line)) {
+			current.push(line.trim());
+			index += 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		html: `<ul>\n${items.map((item) => `  <li>${item.map(inline).join("<br>\n  ")}</li>`).join("\n")}\n</ul>`,
+		next: index
+	};
+}
+/** Soft-wrapped lines are one paragraph, as in markdown. */
+function takeParagraph(lines, from) {
+	const collected = [];
+	let index = from;
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		if (line.trim() === "" || isListItem(line) || /^#{1,3}\s/.test(line) || /^-{3,}$/.test(line)) break;
+		collected.push(line.trim());
+		index += 1;
+	}
+	return {
+		text: collected.join(" "),
+		next: index
+	};
+}
+function firstHeading(markdown) {
+	for (const line of markdown.split("\n")) {
+		const match = /^#\s+(.*)$/.exec(line);
+		if (match?.[1]) return match[1].trim();
+	}
+}
+/** URLs and email addresses, which the templates write bare. */
+const LINKABLE = /(https?:\/\/[^\s<>"']+|[\w.!#$%&'*+/=?^`{|}~-]+@[\w-]+(?:\.[\w-]+)+)/g;
+function inline(text) {
+	let output = "";
+	let cursor = 0;
+	for (const match of text.matchAll(LINKABLE)) {
+		const raw = match[0];
+		const start = match.index;
+		output += escapeText(text.slice(cursor, start));
+		const trailing = trailingPunctuation(raw);
+		const target = raw.slice(0, raw.length - trailing.length);
+		const href = target.includes("@") ? `mailto:${target}` : target;
+		output += `<a href="${escapeAttribute(href)}">${escapeText(target)}</a>${escapeText(trailing)}`;
+		cursor = start + raw.length;
+	}
+	return output + escapeText(text.slice(cursor));
+}
+function trailingPunctuation(candidate) {
+	let end = candidate.length;
+	while (end > 0) {
+		const character = candidate[end - 1] ?? "";
+		if (".,;:!?".includes(character)) {
+			end -= 1;
+			continue;
+		}
+		if (character === ")" && !candidate.slice(0, end).includes("(")) {
+			end -= 1;
+			continue;
+		}
+		break;
+	}
+	return candidate.slice(end);
+}
+//#endregion
+//#region src/statement/template.ts
+var TemplateError = class extends Error {
+	name = "TemplateError";
+};
+function renderTemplate(template, scope) {
+	return renderScope(stripStandaloneTags(template), [scope]);
+}
+/**
+* A block tag alone on its line loses that line entirely, the way mustache
+* treats standalone tags. Without this, every conditional leaves a blank line
+* behind and a list item ends up separated from its own detail lines.
+*/
+function stripStandaloneTags(template) {
+	return template.replace(/^[ \t]*(\{\{[#/][^}]*\}\})[ \t]*\r?\n/gm, "$1");
+}
+function renderScope(template, scopes) {
+	let output = "";
+	let index = 0;
+	while (index < template.length) {
+		const open = template.indexOf("{{", index);
+		if (open === -1) {
+			output += template.slice(index);
+			break;
+		}
+		output += template.slice(index, open);
+		const close = template.indexOf("}}", open);
+		if (close === -1) throw new TemplateError(`Unclosed tag at position ${open}`);
+		const tag = template.slice(open + 2, close).trim();
+		if (tag.startsWith("#")) {
+			const [kind, path] = splitBlockTag(tag);
+			const body = findBlockBody(template, kind, close + 2);
+			output += renderBlock(kind, path, body.content, scopes);
+			index = body.end;
+			continue;
+		}
+		if (tag.startsWith("/")) throw new TemplateError(`Unexpected closing tag {{${tag}}}`);
+		output += stringify(lookup(tag, scopes));
+		index = close + 2;
+	}
+	return output;
+}
+function splitBlockTag(tag) {
+	const match = /^#(if|each)\s+(\S+)$/.exec(tag);
+	if (!match?.[1] || !match[2]) throw new TemplateError(`Malformed block tag {{${tag}}}`);
+	return [match[1], match[2]];
+}
+/** Finds the matching close tag, counting nested blocks of the same kind. */
+function findBlockBody(template, kind, from) {
+	const openTag = new RegExp(`\\{\\{#${kind}\\s`, "g");
+	const closeTag = new RegExp(`\\{\\{/${kind}\\}\\}`, "g");
+	let depth = 1;
+	let cursor = from;
+	while (depth > 0) {
+		openTag.lastIndex = cursor;
+		closeTag.lastIndex = cursor;
+		const next = closeTag.exec(template);
+		if (!next) throw new TemplateError(`Missing {{/${kind}}}`);
+		const nested = openTag.exec(template);
+		if (nested && nested.index < next.index) {
+			depth += 1;
+			cursor = nested.index + nested[0].length;
+			continue;
+		}
+		depth -= 1;
+		if (depth === 0) return {
+			content: template.slice(from, next.index),
+			end: next.index + next[0].length
+		};
+		cursor = next.index + next[0].length;
+	}
+	throw new TemplateError(`Missing {{/${kind}}}`);
+}
+function renderBlock(kind, path, body, scopes) {
+	const value = lookup(path, scopes);
+	if (kind === "if") return isTruthy(value) ? renderScope(body, scopes) : "";
+	if (!Array.isArray(value)) return "";
+	return value.map((item) => renderScope(body, [item, ...scopes])).join("");
+}
+function isTruthy(value) {
+	if (Array.isArray(value)) return value.length > 0;
+	return Boolean(value);
+}
+function lookup(path, scopes) {
+	if (path === ".") return scopes[0];
+	const segments = path.split(".");
+	for (const scope of scopes) {
+		const value = resolve(scope, segments);
+		if (value !== void 0) return value;
+	}
+}
+function resolve(scope, segments) {
+	let current = scope;
+	for (const segment of segments) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[segment];
+		if (current === void 0) return void 0;
+	}
+	return current;
+}
+function stringify(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return value.map(stringify).join(", ");
+	return String(value);
+}
+//#endregion
+//#region src/statement/render.ts
+/** How many affected pages a barrier lists before it starts counting instead. */
+const MAX_LISTED_PAGES = 5;
+/**
+* Render an accessibility statement from a validated config.
+*
+* All prose lives in the templates. This function only decides which template
+* to load and prepares the values it interpolates, including the booleans the
+* template branches on, so that no German sentence is assembled in TypeScript.
+*/
+async function renderStatement(config, options = {}) {
+	const country = options.country ?? config.enforcement.country;
+	const locale = options.locale ?? defaultLocale(config);
+	const template = `${country.toLowerCase()}.${locale}`;
+	const markdown = tidy(renderTemplate(await loadTemplate(template), buildScope(config, locale, options.audit)));
+	return {
+		markdown,
+		html: toHtmlDocument(markdown, {
+			lang: locale,
+			fallbackTitle: config.site.name
+		}),
+		locale,
+		country,
+		template
+	};
+}
+/** A German-language site gets a German statement unless told otherwise. */
+function defaultLocale(config) {
+	return config.site.locale.toLowerCase().startsWith("de") ? "de" : "en";
+}
+/**
+* Values the templates interpolate.
+*
+* Enum-shaped fields become booleans here rather than being compared inside the
+* template, which keeps the template language trivial and puts the mapping
+* somewhere that can be typechecked.
+*/
+function buildScope(config, locale, audit) {
+	const issues = [...config.compliance.knownIssues.map((issue) => toIssueScope(issue, locale)), ...(audit?.findings ?? []).map((finding) => toFindingScope(finding, config.compliance.auditReason))];
+	return {
+		site: { ...config.site },
+		provider: { ...config.provider },
+		compliance: {
+			standard: config.compliance.standard,
+			knownIssues: issues,
+			assessedOnFormatted: formatDate(config.compliance.assessedOn, locale),
+			isCompliant: config.compliance.status === "compliant",
+			isPartiallyCompliant: config.compliance.status === "partially-compliant",
+			isNonCompliant: config.compliance.status === "non-compliant",
+			isSelfAssessment: config.compliance.assessmentMethod === "self-assessment",
+			isExternalAudit: config.compliance.assessmentMethod === "external-audit"
+		},
+		audit: audit ? toAuditScope(audit, locale) : void 0,
+		hasAudit: audit !== void 0,
+		hasKnownIssues: issues.length > 0,
+		hasNoKnownIssues: issues.length === 0
+	};
+}
+/**
+* What the automated run itself contributes to the "preparation" section.
+*
+* The counts are here because leaving them out would let a reader take the
+* barrier list for the whole picture. A rule the engine could not evaluate was
+* not checked, and saying so is the same commitment the audit report makes.
+*/
+function toAuditScope(audit, locale) {
+	return {
+		pages: audit.pages,
+		isSinglePage: audit.pages === 1,
+		isMultiPage: audit.pages > 1,
+		needsReview: audit.needsReview,
+		needsReviewIsSingle: audit.needsReview === 1,
+		needsReviewIsPlural: audit.needsReview > 1,
+		notEvaluated: audit.notEvaluated,
+		notEvaluatedIsSingle: audit.notEvaluated === 1,
+		notEvaluatedIsPlural: audit.notEvaluated > 1,
+		checkedOnFormatted: formatDate(audit.generatedAt.slice(0, 10), locale)
+	};
+}
+function toIssueScope(issue, locale) {
+	return {
+		...reasonScope(issue.reason),
+		description: issue.description,
+		standards: standardsReference(issue.successCriteria, issue.en301549),
+		remedyByFormatted: issue.remedyBy ? formatDate(issue.remedyBy, locale) : "",
+		isFromAudit: false,
+		ruleId: "",
+		pageList: "",
+		morePages: 0,
+		hasMorePages: false
+	};
+}
+/**
+* An audit finding as a barrier.
+*
+* `description` is axe-core's help text, which is English however the statement
+* is written, so the templates mark it as the tool's words rather than the
+* provider's and tell the reader to replace it. Generating German legal prose
+* from an English rule description is not something to do behind someone's
+* back, and a statement is published under their name, not ours.
+*/
+function toFindingScope(finding, reason) {
+	const listed = finding.pages.slice(0, MAX_LISTED_PAGES);
+	const remaining = finding.pages.length - listed.length;
+	return {
+		...reasonScope(reason),
+		description: finding.help,
+		standards: standardsReference(finding.successCriteria, finding.en301549),
+		remedyByFormatted: "",
+		isFromAudit: true,
+		ruleId: finding.ruleId,
+		pageList: listed.join(", "),
+		morePages: remaining,
+		hasMorePages: remaining > 0
+	};
+}
+/** Enum to booleans, so no template has to compare strings. */
+function reasonScope(reason) {
+	return {
+		isDisproportionateBurden: reason === "disproportionate-burden",
+		isOutOfScope: reason === "out-of-scope",
+		isFixPlanned: reason === "fix-planned"
+	};
+}
+function standardsReference(successCriteria, en301549) {
+	return [...successCriteria.map((criterion) => `WCAG ${criterion}`), ...en301549.map((clause) => `EN 301 549 ${clause}`)].join(", ");
+}
+/**
+* 2026-08-20 becomes 20. August 2026 or 20 August 2026.
+*
+* Every date reaching this has been through a schema that checks it, so the
+* fallback should be unreachable. It is here because the alternative to
+* returning the string unchanged is Intl throwing a RangeError from inside a
+* document generator, and a statement that comes out with an odd-looking date
+* is recoverable in a way that a stack trace is not.
+*/
+function formatDate(iso, locale) {
+	const date = /* @__PURE__ */ new Date(`${iso}T00:00:00Z`);
+	if (Number.isNaN(date.getTime())) return iso;
+	return new Intl.DateTimeFormat(locale === "de" ? "de-AT" : "en-GB", {
+		day: "numeric",
+		month: "long",
+		year: "numeric",
+		timeZone: "UTC"
+	}).format(date);
+}
+/**
+* Block tags sit on their own lines in the templates, which leaves blank lines
+* behind once they are removed. Collapse runs of them so the markdown does not
+* come out full of gaps.
+*/
+function tidy(markdown) {
+	return `${markdown.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim()}\n`;
+}
+let templateDirectory;
+async function loadTemplate(name) {
+	templateDirectory ??= await findTemplateDirectory();
+	const directory = templateDirectory;
+	const file = path.join(directory, `${name}.md`);
+	try {
+		return await readFile(file, "utf8");
+	} catch {
+		throw new StatementError(`No statement template for ${name}. Available: ${(await readdir(directory)).filter((entry) => entry.endsWith(".md")).map((entry) => entry.replace(/\.md$/, "")).sort().join(", ")}`);
+	}
+}
+/**
+* Templates ship as files rather than being inlined, so they have to be found
+* at runtime. The layout differs between running from source and running the
+* bundle, where every module collapses into dist/cli/index.js, so the
+* candidates are tried in order rather than assuming one.
+*/
+async function findTemplateDirectory() {
+	const here = fileURLToPath(new URL(".", import.meta.url));
+	const candidates = [
+		path.join(here, "templates"),
+		path.join(here, "..", "statement", "templates"),
+		path.join(here, "statement", "templates")
+	];
+	for (const candidate of candidates) try {
+		if ((await stat(candidate)).isDirectory()) return candidate;
+	} catch {}
+	throw new StatementError(`Could not locate the statement templates. Looked in: ${candidates.join(", ")}`);
+}
+//#endregion
+export { defineConfig as _, summariseAuditReport as a, findConfigFile as c, COMPLIANCE_STATUSES as d, COUNTRIES as f, configSchema as g, STATEMENT_LOCALES as h, readAuditReport as i, loadConfig as l, ISSUE_REASONS as m, toHtmlBody as n, StatementError as o, ConfigError as p, toHtmlDocument as r, CONFIG_FILENAMES as s, renderStatement as t, ASSESSMENT_METHODS as u, parseConfig as v };