npm - eaa-kit - Versions diffs - 0.1.0 - Mend

eaa-kit 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/LICENSE +21 -0
package/README.md +102 -0
package/dist/astro/index.d.ts +90 -0
package/dist/astro/index.js +48 -0
package/dist/audit/runners/worker.d.ts +1 -0
package/dist/audit/runners/worker.js +27 -0
package/dist/audit-6gbV0Zjd.js +582 -0
package/dist/audit-VtuUOuyX.js +2 -0
package/dist/baseline-DQTnNlc4.js +169 -0
package/dist/baseline-Itspu3-Y.js +2 -0
package/dist/cli/index.d.ts +1 -0
package/dist/cli/index.js +259 -0
package/dist/escape-Dm1o_RAk.js +21 -0
package/dist/fingerprint-DRoneAjj.js +20 -0
package/dist/html-BLEuzep6.js +337 -0
package/dist/impact-DvgBjupx.js +32 -0
package/dist/impact-EEB9ZXmC.d.ts +7 -0
package/dist/index.d.ts +264 -0
package/dist/index.js +2 -0
package/dist/jsdom-BEu6Ra_2.js +163 -0
package/dist/jsdom-C6dIyaxN.js +3 -0
package/dist/json-1ESNIiHY.js +139 -0
package/dist/playwright-BfWuTG_u.js +235 -0
package/dist/pool-DixLeu8L.js +188 -0
package/dist/render-K9KxDDSA.js +774 -0
package/dist/result-2aZPfM8w.js +168 -0
package/dist/sarif-eSCuI0eX.js +192 -0
package/dist/statement/templates/at.de.md +127 -0
package/dist/statement/templates/at.en.md +121 -0
package/dist/statement/templates/ch.de.md +138 -0
package/dist/statement/templates/ch.en.md +135 -0
package/dist/statement/templates/de.de.md +129 -0
package/dist/statement/templates/de.en.md +125 -0
package/dist/version-B3v4rNoG.js +15 -0
package/package.json +95 -0

package/dist/html-BLEuzep6.js ADDED Viewed

@@ -0,0 +1,337 @@
+import { i as isImpactLevel, r as countAtOrAbove } 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 axe from "axe-core";
+//#region src/audit/report/html.ts
+/**
+* A standalone HTML audit report.
+*
+* The console report is for the person who ran the command; JSON and SARIF are
+* for other programs. This one is for somebody who was not at the terminal —
+* the client whose site it is, or the colleague who has to fix it — so it is a
+* single file that can be attached to an email and opened, with no server, no
+* assets and no scripts.
+*
+* It says exactly what the console report says, in the same order and with the
+* same refusals: the four result categories stay apart, rules this engine could
+* not evaluate are named rather than quietly dropped, and nothing here adds up
+* to a compliance claim. A report with no findings means no findings were
+* found, which is not the same as a site being accessible, and the document
+* says so in its own footer rather than leaving the reader to infer it.
+*/
+/** Elements listed per rule before the rest are summarised. */
+const MAX_NODES = 5;
+/** Longest element markup shown before it is truncated. */
+const MAX_SNIPPET = 200;
+function buildHtmlReport(audits, options) {
+	const engine = audits[0]?.engine ?? "jsdom";
+	const failing = countAtOrAbove(audits, options.failOn);
+	const generatedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+	const title = `Accessibility audit · ${options.directory}`;
+	return `<!doctype html>
+<html lang="en">
+<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>
+<h1>Accessibility audit</h1>
+${verdict(audits, failing, options)}
+${runDetails(audits, engine, generatedAt, options)}
+${summary(audits, failing, options)}
+${pages(audits)}
+${notEvaluated(audits)}
+${footer()}
+</main>
+</body>
+</html>
+`;
+}
+/**
+* The result, in words, before any of the detail.
+*
+* Not colour alone: the badge carries the word as well, because a reader who
+* cannot distinguish the two shades still has to be able to read the outcome —
+* which would be an embarrassing thing for this document in particular to get
+* wrong.
+*/
+function verdict(audits, failing, options) {
+	const unaudited = audits.filter((audit) => audit.error).length;
+	if (unaudited > 0) return banner("broken", "Could not finish", `${count(unaudited, "page")} could not be audited, so this run reached no verdict.`);
+	if (failing > 0) return banner("fail", "Violations found", `${count(failing, "violation")} at or above ${escapeText(options.failOn)}.`);
+	const below = totalViolations(audits) - failing;
+	if (below > 0) return banner("pass", "No violations at the threshold", `${count(below, "violation")} below ${escapeText(options.failOn)}, which do not fail the run.`);
+	return banner("pass", "No violations found", "Automated testing found nothing to report.");
+}
+function banner(kind, heading, detail) {
+	return `<p class="verdict ${escapeAttribute(kind)}"><strong>${escapeText(heading)}</strong> ${detail}</p>`;
+}
+function runDetails(audits, engine, generatedAt, options) {
+	const rows = [
+		["Directory", options.directory],
+		["Pages", String(audits.length)],
+		["Engine", engine === "browser" ? "Chromium" : "jsdom (browserless)"],
+		["Threshold", `${options.failOn} and above fails the run`],
+		["Generated", generatedAt],
+		["eaa-kit", `${TOOL_VERSION} · axe-core ${axe.version}`]
+	];
+	if (options.baseUrl) rows.splice(1, 0, ["Base URL", options.baseUrl]);
+	return `<h2>The run</h2>\n<dl class="run">\n${rows.map(([term, value]) => `  <div><dt>${escapeText(term)}</dt><dd>${escapeText(value)}</dd></div>`).join("\n")}\n</dl>`;
+}
+function summary(audits, failing, options) {
+	const byImpact = /* @__PURE__ */ new Map();
+	let needsReview = 0;
+	let blind = 0;
+	let passes = 0;
+	let inapplicable = 0;
+	let elements = 0;
+	let accepted = 0;
+	for (const audit of audits) {
+		for (const finding of audit.accepted ?? []) accepted += finding.nodes.length;
+		for (const finding of audit.violations) {
+			const impact = finding.impact && isImpactLevel(finding.impact) ? finding.impact : "unclassified";
+			byImpact.set(impact, (byImpact.get(impact) ?? 0) + 1);
+			elements += finding.nodes.length;
+		}
+		for (const finding of audit.incomplete) if (finding.reason === "engine-limitation") blind += 1;
+		else needsReview += 1;
+		passes += audit.passes.length;
+		inapplicable += audit.inapplicable.length;
+	}
+	const impacts = [
+		"critical",
+		"serious",
+		"moderate",
+		"minor",
+		"unclassified"
+	].filter((impact) => (byImpact.get(impact) ?? 0) > 0).map((impact) => `  <li><span class="badge ${escapeAttribute(impact)}">${escapeText(impact)}</span> ${byImpact.get(impact)}</li>`).join("\n");
+	const withViolations = audits.filter((audit) => audit.violations.length > 0).length;
+	return `<h2>Summary</h2>
+<ul class="counts">
+  <li><strong>${count(totalViolations(audits), "violation")}</strong> on ${withViolations} of ${count(audits.length, "page")}, across ${count(elements, "element")}</li>
+  <li><strong>${failing}</strong> at or above ${escapeText(options.failOn)}</li>
+  <li><strong>${needsReview}</strong> ${needsReview === 1 ? "rule needs" : "rules need"} manual review</li>
+  <li><strong>${blind}</strong> ${blind === 1 ? "rule was" : "rules were"} not evaluated by this engine</li>
+${accepted > 0 ? `  <li><strong>${accepted}</strong> ${accepted === 1 ? "element is" : "elements are"} accepted by the baseline, and not counted above</li>` : ""}
+</ul>
+${impacts ? `<ul class="impacts">\n${impacts}\n</ul>` : ""}
+<p class="note">
+  <strong>${passes}</strong> rule results were checked and met, and <strong>${inapplicable}</strong>
+  found nothing on the page to check. Those two are counted separately and never added
+  together: a rule with nothing to check is not a rule that passed, and a page with no
+  images proves nothing about image alternatives.
+</p>`;
+}
+function pages(audits) {
+	return `<h2>Pages</h2>\n${audits.map(pageSection).join("\n")}`;
+}
+function pageSection(audit) {
+	const heading = `<h3 class="page">${escapeText(audit.relativePath)}</h3>`;
+	if (audit.error) return `${heading}
+<p class="verdict broken"><strong>Not audited</strong> ${escapeText(audit.error)}</p>`;
+	const parts = [heading];
+	if (audit.violations.length === 0) parts.push((audit.accepted ?? []).length === 0 ? "<p class=\"clean\">No violations.</p>" : "<p class=\"coverage\">No new violations.</p>");
+	else {
+		const findings = [...audit.violations].sort(byImpactThenRule).map(violation).join("\n");
+		parts.push(`<ol class="findings">\n${findings}\n</ol>`);
+	}
+	const review = audit.incomplete.filter((finding) => finding.reason === "needs-review");
+	if (review.length > 0) {
+		const items = review.map((finding) => `  <li><code>${escapeText(finding.ruleId)}</code> needs manual review${standards(finding)}</li>`).join("\n");
+		parts.push(`<p class="review-heading">A human has to decide these:</p>\n<ul>\n${items}\n</ul>`);
+	}
+	const accepted = audit.accepted ?? [];
+	if (accepted.length > 0) {
+		const items = [...accepted].sort(byImpactThenRule).map((finding) => `  <li><code>${escapeText(finding.ruleId)}</code> — ${escapeText(finding.help)} (${count(finding.nodes.length, "element")})</li>`).join("\n");
+		parts.push(`<p class="accepted-heading">Accepted by the baseline. Still violations, and not counted above:</p>\n<ul class="accepted">\n${items}\n</ul>`);
+	}
+	parts.push(coverage(audit));
+	return parts.join("\n");
+}
+function violation(finding) {
+	const impact = finding.impact && isImpactLevel(finding.impact) ? finding.impact : "unclassified";
+	const shown = finding.nodes.slice(0, MAX_NODES);
+	const remaining = finding.nodes.length - shown.length;
+	const nodes = shown.map((node) => `    <li>
+      <code class="selector">${escapeText(node.target.join(" "))}</code>
+      <pre><code>${escapeText(snippet(node.html))}</code></pre>
+    </li>`).join("\n");
+	const more = remaining > 0 ? `\n    <li class="more">and ${count(remaining, "more element")}</li>` : "";
+	return `  <li class="finding">
+    <p class="rule">
+      <span class="badge ${escapeAttribute(impact)}">${escapeText(impact)}</span>
+      <code>${escapeText(finding.ruleId)}</code>
+      <a href="${escapeAttribute(finding.helpUrl)}">${escapeText(finding.help)}</a>
+    </p>
+    <p class="standards">${standardsText(finding) || "No mapped success criterion"}</p>
+    <ul class="nodes">
+${nodes}${more}
+    </ul>
+  </li>`;
+}
+/**
+* What this page's result rests on.
+*
+* The four counts stay apart for the same reason they do everywhere else: only
+* `passed` is evidence that anything was met here.
+*/
+function coverage(audit) {
+	const blind = audit.incomplete.filter((finding) => finding.reason === "engine-limitation").length;
+	const review = audit.incomplete.length - blind;
+	const parts = [`${audit.passes.length} passed`, `${audit.inapplicable.length} not applicable`];
+	if (review > 0) parts.push(`${review} to review`);
+	if (blind > 0) parts.push(`${blind} not evaluated`);
+	return `<p class="coverage">${escapeText(parts.join(" · "))}</p>`;
+}
+/**
+* Rules this engine reached no verdict on, listed once at the end.
+*
+* They are never reported as passing, and leaving them out entirely would let
+* the reader take the rest of the document for full coverage.
+*/
+function notEvaluated(audits) {
+	const byRule = /* @__PURE__ */ new Map();
+	for (const audit of audits) for (const finding of audit.incomplete) {
+		if (finding.reason !== "engine-limitation") continue;
+		const existing = byRule.get(finding.ruleId);
+		if (existing) existing.pages += 1;
+		else byRule.set(finding.ruleId, {
+			pages: 1,
+			detail: finding.reasonDetail,
+			finding
+		});
+	}
+	if (byRule.size === 0) return "";
+	return `<h2>Not evaluated</h2>
+<p>This engine reached no verdict on these rules. They are never reported as passing.</p>
+<ul class="not-evaluated">
+${[...byRule.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([ruleId, entry]) => `  <li>
+    <code>${escapeText(ruleId)}</code> on ${count(entry.pages, "page")}${standards(entry.finding)}
+    <span class="reason">${escapeText(entry.detail)}</span>
+  </li>`).join("\n")}
+</ul>`;
+}
+function footer() {
+	return `<hr>
+<footer>
+  <p>
+    Generated with <a href="https://github.com/likeBloodMoon/eaa-kit">eaa-kit</a>. Automated
+    testing finds a minority of accessibility barriers: it cannot judge whether alternative
+    text is accurate, whether a page makes sense in reading order, or whether a form can
+    actually be completed with a screen reader.
+  </p>
+  <p>
+    <strong>A report with no findings is not a compliance statement.</strong> It means
+    nothing was found by this engine, which is not the same as a site being accessible.
+  </p>
+</footer>`;
+}
+function standards(finding) {
+	const text = standardsText(finding);
+	return text ? ` — ${text}` : "";
+}
+function standardsText(finding) {
+	const parts = [...finding.successCriteria.map((criterion) => `WCAG ${criterion}`), ...finding.enClauses.map((clause) => `EN 301 549 ${clause}`)];
+	return escapeText(parts.join(", "));
+}
+/** Element markup, on one line and bounded, so one minified page cannot fill the report. */
+function snippet(html) {
+	const collapsed = html.replace(/\s+/g, " ").trim();
+	return collapsed.length > MAX_SNIPPET ? `${collapsed.slice(0, 199)}…` : collapsed;
+}
+function totalViolations(audits) {
+	return audits.reduce((total, audit) => total + audit.violations.length, 0);
+}
+function byImpactThenRule(a, b) {
+	const order = [
+		"critical",
+		"serious",
+		"moderate",
+		"minor"
+	];
+	const rank = (finding) => {
+		const index = finding.impact ? order.indexOf(finding.impact) : -1;
+		return index === -1 ? -1 : index;
+	};
+	const difference = rank(a) - rank(b);
+	return difference === 0 ? a.ruleId.localeCompare(b.ruleId) : difference;
+}
+function count(value, noun) {
+	return `${value} ${noun}${value === 1 ? "" : "s"}`;
+}
+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: 60rem; margin: 0 auto; padding: 2rem 1.25rem 4rem; }
+h1 { font-size: 1.9rem; line-height: 1.25; margin: 0 0 1rem; }
+h2 { font-size: 1.35rem; margin: 2.5rem 0 0.75rem; padding-top: 1.5rem;
+  border-top: 1px solid #d4d4d4; }
+h3.page { font-size: 1.05rem; margin: 2rem 0 0.5rem; font-family: ui-monospace, monospace; }
+p { margin: 0 0 1rem; }
+a { color: #0b4fa8; }
+a:focus-visible { outline: 3px solid currentColor; outline-offset: 2px; }
+code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.9em; }
+pre { margin: 0.4rem 0 0; padding: 0.6rem 0.75rem; overflow-x: auto;
+  background: #f4f4f5; border-radius: 4px; }
+pre code { font-size: 0.85em; }
+ul, ol { margin: 0 0 1rem; padding-left: 1.25rem; }
+li + li { margin-top: 0.5rem; }
+.verdict { padding: 0.75rem 1rem; border-radius: 4px; border-left: 4px solid; }
+.verdict.pass { background: #eef7ee; border-color: #216e39; }
+.verdict.fail { background: #fdeeee; border-color: #a01b1b; }
+.verdict.broken { background: #fdf4e3; border-color: #8a5a00; }
+.badge { display: inline-block; padding: 0 0.45rem; border-radius: 3px; font-size: 0.8rem;
+  font-weight: 600; border: 1px solid; }
+.badge.critical { background: #fdeeee; border-color: #a01b1b; color: #7a1414; }
+.badge.serious { background: #fdf1e8; border-color: #a4531b; color: #7d3f14; }
+.badge.moderate { background: #fdf9e3; border-color: #7a6100; color: #5c4900; }
+.badge.minor { background: #eef2f8; border-color: #40556f; color: #33455a; }
+.badge.unclassified { background: #f1f1f1; border-color: #565656; color: #444444; }
+dl.run { display: grid; grid-template-columns: max-content 1fr; gap: 0.25rem 1.5rem; margin: 0; }
+dl.run > div { display: contents; }
+dl.run dt { font-weight: 600; }
+dl.run dd { margin: 0; }
+ul.counts, ul.impacts { list-style: none; padding-left: 0; }
+ul.impacts li { display: inline-block; margin-right: 1rem; }
+ol.findings { list-style: none; padding-left: 0; }
+li.finding { margin: 0 0 1.5rem; padding-left: 0.9rem; border-left: 3px solid #d4d4d4; }
+p.rule { margin-bottom: 0.25rem; }
+p.standards, p.coverage, .reason, li.more, p.accepted-heading, ul.accepted { color: #4a4a4a; font-size: 0.9rem; }
+p.coverage { margin-top: 0.5rem; }
+ul.nodes { list-style: none; padding-left: 0; }
+code.selector { color: #4a4a4a; }
+p.clean { color: #216e39; }
+p.note { font-size: 0.95rem; }
+hr { border: 0; border-top: 1px solid #d4d4d4; margin: 3rem 0 1.5rem; }
+footer { color: #4a4a4a; font-size: 0.9rem; }
+@media (prefers-color-scheme: dark) {
+  body { background: #121212; color: #ededed; }
+  a { color: #9ec1ff; }
+  h2, hr { border-color: #3a3a3a; }
+  pre { background: #1e1e1e; }
+  li.finding { border-color: #3a3a3a; }
+  p.standards, p.coverage, .reason, li.more, code.selector, footer,
+  p.accepted-heading, ul.accepted { color: #b6b6b6; }
+  p.clean { color: #7ee2a8; }
+  .verdict.pass { background: #10240f; border-color: #7ee2a8; }
+  .verdict.fail { background: #2b1111; border-color: #ff9d9d; }
+  .verdict.broken { background: #2b2310; border-color: #ffd28a; }
+  .badge.critical { background: #2b1111; border-color: #ff9d9d; color: #ffc9c9; }
+  .badge.serious { background: #2b1c11; border-color: #ffbb8a; color: #ffd9bd; }
+  .badge.moderate { background: #262110; border-color: #ffe08a; color: #ffeec2; }
+  .badge.minor { background: #16202b; border-color: #a8c6e8; color: #cfdff0; }
+  .badge.unclassified { background: #1f1f1f; border-color: #b6b6b6; color: #d8d8d8; }
+}
+@media print {
+  body { background: #ffffff; color: #000000; }
+  main { max-width: none; }
+  a { color: #000000; }
+}`;
+//#endregion
+export { buildHtmlReport };

package/dist/impact-DvgBjupx.js ADDED Viewed

@@ -0,0 +1,32 @@
+//#region src/audit/impact.ts
+/** axe-core's impact scale, least to most severe. */
+const IMPACT_LEVELS = [
+	"minor",
+	"moderate",
+	"serious",
+	"critical"
+];
+/** What `--fail-on` defaults to: serious and critical break the build. */
+const DEFAULT_FAIL_ON = "serious";
+function isImpactLevel(value) {
+	return IMPACT_LEVELS.includes(value);
+}
+/**
+* Whether a violation is severe enough to fail the run.
+*
+* A violation whose impact axe-core did not classify counts at every threshold.
+* Guessing low would let an unclassified failure through silently, and a
+* missing impact is a gap in what we know, not evidence that it is harmless.
+*/
+function meetsThreshold(impact, threshold) {
+	if (impact === null || !isImpactLevel(impact)) return true;
+	return IMPACT_LEVELS.indexOf(impact) >= IMPACT_LEVELS.indexOf(threshold);
+}
+/** Violations at or above `threshold`, counted per rule per page. */
+function countAtOrAbove(audits, threshold) {
+	let total = 0;
+	for (const audit of audits) for (const finding of audit.violations) if (meetsThreshold(finding.impact, threshold)) total += 1;
+	return total;
+}
+//#endregion
+export { isImpactLevel as i, IMPACT_LEVELS as n, countAtOrAbove as r, DEFAULT_FAIL_ON as t };

package/dist/impact-EEB9ZXmC.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import "axe-core";
+//#region src/audit/impact.d.ts
+/** axe-core's impact scale, least to most severe. */
+declare const IMPACT_LEVELS: readonly ['minor', 'moderate', 'serious', 'critical'];
+type ImpactLevel = (typeof IMPACT_LEVELS)[number];
+//#endregion
+export { ImpactLevel as t };

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,264 @@
+import { t as ImpactLevel } from "./impact-EEB9ZXmC.js";
+import { z } from "zod";
+//#region src/config/define.d.ts
+/** Countries with their own supervisory body and statute text. */
+declare const COUNTRIES: readonly ['AT', 'DE', 'CH'];
+type Country = (typeof COUNTRIES)[number];
+/** Languages a statement can be rendered in. */
+declare const STATEMENT_LOCALES: readonly ['de', 'en'];
+type StatementLocale = (typeof STATEMENT_LOCALES)[number];
+/**
+ * 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.
+ */
+declare const COMPLIANCE_STATUSES: readonly ['compliant', 'partially-compliant', 'non-compliant'];
+type ComplianceStatus = (typeof COMPLIANCE_STATUSES)[number];
+declare const ASSESSMENT_METHODS: readonly ['self-assessment', 'external-audit'];
+type AssessmentMethod = (typeof ASSESSMENT_METHODS)[number];
+/**
+ * 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.
+ */
+declare const ISSUE_REASONS: readonly ['disproportionate-burden', 'out-of-scope', 'fix-planned'];
+type IssueReason = (typeof ISSUE_REASONS)[number];
+declare const configSchema: z.ZodObject<{
+  site: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodURL;
+    locale: z.ZodString;
+  }, z.core.$strip>;
+  provider: z.ZodObject<{
+    legalName: z.ZodString;
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    feedbackUrl: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strip>;
+  compliance: z.ZodObject<{
+    status: z.ZodEnum<{
+      compliant: "compliant";
+      "non-compliant": "non-compliant";
+      "partially-compliant": "partially-compliant";
+    }>;
+    standard: z.ZodDefault<z.ZodString>;
+    knownIssues: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
+      description: string;
+    }, string>>, z.ZodObject<{
+      description: z.ZodString;
+      successCriteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      en301549: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      reason: z.ZodOptional<z.ZodEnum<{
+        "disproportionate-burden": "disproportionate-burden";
+        "fix-planned": "fix-planned";
+        "out-of-scope": "out-of-scope";
+      }>>;
+      remedyBy: z.ZodOptional<z.ZodISODate>;
+    }, z.core.$strip>>, z.ZodObject<{
+      description: z.ZodString;
+      successCriteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      en301549: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      reason: z.ZodOptional<z.ZodEnum<{
+        "disproportionate-burden": "disproportionate-burden";
+        "fix-planned": "fix-planned";
+        "out-of-scope": "out-of-scope";
+      }>>;
+      remedyBy: z.ZodOptional<z.ZodISODate>;
+    }, z.core.$strip>]>>>;
+    assessedOn: z.ZodISODate;
+    assessmentMethod: z.ZodDefault<z.ZodEnum<{
+      "external-audit": "external-audit";
+      "self-assessment": "self-assessment";
+    }>>;
+    auditReason: z.ZodDefault<z.ZodEnum<{
+      "disproportionate-burden": "disproportionate-burden";
+      "fix-planned": "fix-planned";
+      "out-of-scope": "out-of-scope";
+    }>>;
+  }, z.core.$strip>;
+  enforcement: z.ZodObject<{
+    country: z.ZodEnum<{
+      AT: "AT";
+      CH: "CH";
+      DE: "DE";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type EaaConfigInput = z.input<typeof configSchema>;
+type EaaConfig = z.output<typeof configSchema>;
+type KnownIssue = EaaConfig['compliance']['knownIssues'][number];
+/**
+ * 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.
+ */
+declare function defineConfig(config: EaaConfigInput): EaaConfigInput;
+declare class ConfigError extends Error {
+  readonly issues: string[];
+  readonly name = "ConfigError";
+  constructor(message: string, issues?: string[]);
+}
+/** Validate an already-loaded config object. */
+declare function parseConfig(value: unknown, source?: string): EaaConfig;
+//#endregion
+//#region src/config/load.d.ts
+/** Checked in this order, first match wins. */
+declare const CONFIG_FILENAMES: readonly ['eaa.config.ts', 'eaa.config.mts', 'eaa.config.js', 'eaa.config.mjs', 'eaa.config.json'];
+interface LoadedConfig {
+  config: EaaConfig;
+  /** Absolute path of the file it came from. */
+  path: string;
+}
+interface LoadConfigOptions {
+  /** Where to start looking. Defaults to the working directory. */
+  cwd?: string;
+  /** Explicit path, skipping the search. */
+  path?: string;
+}
+/**
+ * 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'".
+ */
+declare function loadConfig(options?: LoadConfigOptions): Promise<LoadedConfig>;
+/** Walks up from `cwd`, so the CLI works from a subdirectory of the project. */
+declare function findConfigFile(cwd: string): Promise<string | undefined>;
+//#endregion
+//#region src/statement/error.d.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.
+ */
+declare class StatementError extends Error {
+  readonly name = "StatementError";
+}
+//#endregion
+//#region src/statement/findings.d.ts
+/** One rule that failed, folded across every page it failed on. */
+interface AuditFinding {
+  ruleId: string;
+  /**
+   * axe-core's help text. English whatever the statement's language, which is
+   * why the templates label it as coming from the tool rather than presenting
+   * it as the provider's own description.
+   */
+  help: string;
+  /** Least-to-most severe, or null when axe-core did not classify it. */
+  impact: ImpactLevel | null;
+  /** WCAG success criteria, e.g. ['1.1.1']. */
+  successCriteria: string[];
+  /** EN 301 549 clauses, e.g. ['9.1.1.1']. */
+  en301549: string[];
+  /** Pages it failed on, relative to the audited directory, sorted. */
+  pages: string[];
+}
+/** What an audit contributes to a statement. */
+interface AuditSummary {
+  /** Violations, most severe first. */
+  findings: AuditFinding[];
+  /** Pages the run covered. */
+  pages: number;
+  /** Rules that need a human decision. Not barriers, and not evidence either. */
+  needsReview: number;
+  /** Rules the engine could not evaluate. Never reported as passing. */
+  notEvaluated: number;
+  /** When the audit ran. ISO 8601. */
+  generatedAt: string;
+}
+/**
+ * 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.
+ */
+declare function summariseAuditReport(value: unknown, source?: string): AuditSummary;
+/** Read and summarise a report written by `eaa-kit audit --format json`. */
+declare function readAuditReport(file: string, cwd?: string): Promise<AuditSummary>;
+//#endregion
+//#region src/statement/html.d.ts
+/**
+ * Markdown-to-HTML for exactly the subset the statement templates emit, and
+ * nothing else.
+ *
+ * A general markdown parser is a dependency and a licence audit for a document
+ * whose entire vocabulary is four block types. What the templates produce:
+ *
+ *   # heading            level-1 and level-2 headings
+ *   ## heading
+ *   paragraph text       soft-wrapped; joined back into one paragraph
+ *   - list item          with two-space continuation lines belonging to it
+ *   ---                  a horizontal rule before the disclaimer
+ *
+ * Anything else is emitted as literal text, escaped. Emphasis, links, images
+ * and code spans are deliberately not implemented: a `**` in someone's issue
+ * description is far more likely to be a typo than a request for bold, and
+ * silently swallowing characters out of a legal document is the worse failure.
+ * Bare URLs and email addresses do become links, because they are unusable in
+ * an HTML document otherwise.
+ */
+interface HtmlDocumentOptions {
+  /**
+   * BCP 47 tag for the document text, e.g. 'de'. Becomes `<html lang>`, without
+   * which a screen reader announces German prose with an English voice.
+   */
+  lang: string;
+  /** `<title>` when the markdown has no level-1 heading to take one from. */
+  fallbackTitle: string;
+}
+/**
+ * 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.
+ */
+declare function toHtmlDocument(markdown: string, options: HtmlDocumentOptions): string;
+/** The document body: the block elements alone, for embedding in a page. */
+declare function toHtmlBody(markdown: string): string;
+//#endregion
+//#region src/statement/render.d.ts
+interface RenderStatementOptions {
+  /** Language to render in. Defaults to the site's own language when it is German. */
+  locale?: StatementLocale;
+  /** Overrides the country from the config, for previewing another template. */
+  country?: Country;
+  /**
+   * Findings from `eaa-kit audit --format json`, appended to the barriers the
+   * config lists. Left out, the statement says only what the config says.
+   */
+  audit?: AuditSummary;
+}
+interface RenderedStatement {
+  markdown: string;
+  /** The same document as a standalone HTML page. */
+  html: string;
+  locale: StatementLocale;
+  country: Country;
+  /** Template the text came from, e.g. 'at.de'. */
+  template: string;
+}
+/**
+ * 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.
+ */
+declare function renderStatement(config: EaaConfig, options?: RenderStatementOptions): Promise<RenderedStatement>;
+//#endregion
+export { ASSESSMENT_METHODS, type AssessmentMethod, type AuditFinding, type AuditSummary, COMPLIANCE_STATUSES, CONFIG_FILENAMES, COUNTRIES, type ComplianceStatus, ConfigError, type Country, type EaaConfig, type EaaConfigInput, type HtmlDocumentOptions, ISSUE_REASONS, type IssueReason, type KnownIssue, type LoadConfigOptions, type LoadedConfig, type RenderStatementOptions, type RenderedStatement, STATEMENT_LOCALES, StatementError, type StatementLocale, configSchema, defineConfig, findConfigFile, loadConfig, parseConfig, readAuditReport, renderStatement, summariseAuditReport, toHtmlBody, toHtmlDocument };

package/dist/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { _ as defineConfig, a as summariseAuditReport, c as findConfigFile, d as COMPLIANCE_STATUSES, f as COUNTRIES, g as configSchema, h as STATEMENT_LOCALES, i as readAuditReport, l as loadConfig, m as ISSUE_REASONS, n as toHtmlBody, o as StatementError, p as ConfigError, r as toHtmlDocument, s as CONFIG_FILENAMES, t as renderStatement, u as ASSESSMENT_METHODS, v as parseConfig } from "./render-K9KxDDSA.js";
2	+ export { ASSESSMENT_METHODS, COMPLIANCE_STATUSES, CONFIG_FILENAMES, COUNTRIES, ConfigError, ISSUE_REASONS, STATEMENT_LOCALES, StatementError, configSchema, defineConfig, findConfigFile, loadConfig, parseConfig, readAuditReport, renderStatement, summariseAuditReport, toHtmlBody, toHtmlDocument };