eaa-kit 0.3.0 → 0.5.0

package/dist/{result-DLxd2Eip.js → result-BWcYXeRs.js}

@@ -1,6 +1,15 @@
 import { pathToFileURL } from "node:url";
 import axe from "axe-core";
 //#region src/audit/result.ts
+/**
+* Per-page ceiling for an audit, in milliseconds.
+*
+* Lives here rather than in the jsdom runner because the worker pool needs it
+* to set its own deadline, and the pool deliberately does not import jsdom —
+* loading 630 ms of dependency to supervise threads that each load their own
+* would be pure overhead. The same reason ENGINE_BLIND_RULES sits here.
+*/
+const DEFAULT_PAGE_TIMEOUT_MS = 3e4;
 /** WCAG 2.2 AA and everything it builds on. Best-practice rules stay off. */
 const DEFAULT_TAGS = [
 	"wcag2a",
@@ -10,6 +19,83 @@ const DEFAULT_TAGS = [
 	"wcag22aa"
 ];
 /**
+* Rules this engine structurally cannot decide.
+*
+* jsdom has no layout: every element reports a 0x0 box, computed style is
+* limited to the inline cascade, and nothing is ever fetched. axe-core does not
+* know that, so it happily returns `pass` for some of these — `target-size`
+* passes on any page because a 0x0 target gets measured against nothing, and
+* `color-contrast` passes on pages whose colours were never computed. Both were
+* observed on real sites. Reporting either as a pass would be a false clean
+* bill of health, so every rule listed here is force-reported as incomplete no
+* matter which bucket axe-core put it in.
+*
+* The browser runner passes an empty map instead: with real layout these rules
+* are exactly the ones it exists to answer.
+*
+* Rules tagged `experimental` are listed for completeness but filtered out at
+* scope time: axe-core does not run them by default, so a browser run would not
+* evaluate them either and telling the user to re-run with --browser would be
+* misleading.
+*/
+const ENGINE_BLIND_RULES = {
+	"color-contrast": {
+		detail: "needs rendered foreground and background colours",
+		applicabilityUnreliable: false
+	},
+	"color-contrast-enhanced": {
+		detail: "needs rendered foreground and background colours",
+		applicabilityUnreliable: false
+	},
+	"target-size": {
+		detail: "needs element geometry; every box is 0x0 without layout",
+		applicabilityUnreliable: false
+	},
+	"scrollable-region-focusable": {
+		detail: "needs computed overflow",
+		applicabilityUnreliable: true
+	},
+	"link-in-text-block": {
+		detail: "needs rendered colours and text decoration",
+		applicabilityUnreliable: true
+	},
+	"no-autoplay-audio": {
+		detail: "needs media duration, and media is never loaded",
+		applicabilityUnreliable: true
+	},
+	"avoid-inline-spacing": {
+		detail: "needs computed spacing after the full cascade",
+		applicabilityUnreliable: false
+	},
+	"p-as-heading": {
+		detail: "needs computed font size and weight",
+		applicabilityUnreliable: false
+	},
+	"css-orientation-lock": {
+		detail: "needs CSS media query evaluation",
+		applicabilityUnreliable: true
+	}
+};
+const blindScopeCache = /* @__PURE__ */ new Map();
+/**
+* Blind rules the requested tag filter would actually have run. Experimental
+* rules are excluded: axe-core leaves them off by default, so a browser run
+* would not have evaluated them either.
+*/
+function blindRulesInScope(tags) {
+	const key = [...tags].sort().join(",");
+	const cached = blindScopeCache.get(key);
+	if (cached) return cached;
+	const inScope = /* @__PURE__ */ new Map();
+	for (const rule of axe.getRules([...tags])) {
+		if (rule.tags.includes("experimental")) continue;
+		const blind = ENGINE_BLIND_RULES[rule.ruleId];
+		if (blind) inScope.set(rule.ruleId, blind);
+	}
+	blindScopeCache.set(key, inScope);
+	return inScope;
+}
+/**
 * The URL a page is audited under, shared by every runner so their reports name
 * the same page. Without a base URL that is the file it came off disk as.
 */
@@ -45,17 +131,42 @@ function ruleOutcomes(audit) {
 		...audit.inapplicable
 	];
 }
-function runOptions(tags) {
+function runOptions(tags, options = {}) {
 	return {
 		runOnly: {
 			type: "tag",
 			values: [...tags]
 		},
 		resultTypes: ["violations", "incomplete"],
-		preload: false
+		preload: false,
+		...options.skipBlindRules ? { rules: disabledBlindRules() } : {}
 	};
 }
 /**
+* The rules this engine cannot decide, switched off rather than run.
+*
+* Normally they are run and their verdict discarded: axe-core computes colour
+* contrast against a stylesheet jsdom never fetched, and `shapeResults` throws
+* the answer away as untrustworthy. The work is wasted either way, and it is
+* not a small amount — measured at 14-19% of a page, since colour contrast is
+* the most expensive rule axe-core has.
+*
+* What is lost is the element list. A rule that runs reports *which* elements
+* it could not decide, and those are the elements a person has to check by
+* hand; a rule that never runs cannot name them. That is the whole trade, and
+* it is why this is behind a flag rather than the default.
+*
+* What does not change is the verdict. `shapeResults` already has a pass for
+* rules axe-core skipped entirely — the preload-dependent ones arrive that way
+* — and files them as unevaluated with the same reason. A criterion this run
+* could not reach still reads as unreached.
+*/
+function disabledBlindRules() {
+	const rules = {};
+	for (const ruleId of Object.keys(ENGINE_BLIND_RULES)) rules[ruleId] = { enabled: false };
+	return rules;
+}
+/**
 * Turn raw axe-core output into a PageAudit, shared by both engines so their
 * reports are directly comparable.
 *
@@ -202,4 +313,4 @@ function enClauses(tags) {
 	return [...clauses].sort();
 }
 //#endregion
-export { ruleOutcomes as a, pageUrl as i, failedPage as n, runOptions as o, findingElements as r, shapeResults as s, DEFAULT_TAGS as t };
+export { failedPage as a, ruleOutcomes as c, successCriteria as d, blindRulesInScope as i, runOptions as l, DEFAULT_TAGS as n, findingElements as o, ENGINE_BLIND_RULES as r, pageUrl as s, DEFAULT_PAGE_TIMEOUT_MS as t, shapeResults as u };

package/dist/routes-CmdRUuOs.js

@@ -0,0 +1,265 @@
+import { i as toPosix, n as isDirectory } from "./fs-BmPtmFke.js";
+import { i as detectFramework } from "./frameworks-B4ClIJgE.js";
+import { i as readPackageJson } from "./project-CzOnkLH6.js";
+import path from "node:path";
+import { glob } from "tinyglobby";
+//#region src/audit/routes.ts
+/**
+* A path segment that serves more than one page, or none.
+*
+* Dynamic segments are refused rather than resolved: `[slug]` stands for every
+* post there is, and picking one would name a file that did not produce the
+* page in front of the reader. Private and slot folders contribute no route at
+* all.
+*/
+function classifyBracketSegment(segment) {
+	if (/^\(.*\)$/.test(segment)) return "skip";
+	if (/^[[(]|^_|^@/.test(segment)) return "refuse";
+	return "route";
+}
+/** Drop the extension, and fold an index file into the directory it sits in. */
+function withoutExtension(file) {
+	const route = file.replace(/\.[^./]+$/, "").replace(/\/index$/, "");
+	return route === "index" ? "" : route;
+}
+/** The directory a route file sits in, for routers that put the route there. */
+function containingDirectory(file) {
+	return file.includes("/") ? file.replace(/\/[^/]+$/, "") : "";
+}
+/** Keep the segments that are routes, refusing the file if any is dynamic. */
+function joinSegments(route) {
+	const kept = [];
+	for (const segment of route.split("/").filter((part) => part !== "")) {
+		const kind = classifyBracketSegment(segment);
+		if (kind === "refuse") return void 0;
+		if (kind === "skip") continue;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/** `pages/kontakt.tsx` serves `/kontakt`; the filename is the route. */
+function fileNamedRoute(file) {
+	return joinSegments(withoutExtension(file));
+}
+/** `app/kontakt/page.tsx` serves `/kontakt`; the directory is the route. */
+function directoryNamedRoute(file) {
+	return joinSegments(containingDirectory(file));
+}
+/**
+* A documentation tree whose directory layout is the URL layout.
+*
+* No dynamic segments to worry about — these are files an author wrote, one per
+* page — so the only work is folding the index file into its directory.
+*/
+function mirroredRoute(file) {
+	return withoutExtension(file);
+}
+/**
+* Remix and React Router flat routes: `blog.post.tsx` serves `/blog/post`.
+*
+* The dot is the separator, `_index` is a directory's own page, and a trailing
+* underscore on a segment escapes a parent layout without changing the URL. A
+* `$` segment is dynamic and refused, as `[slug]` is elsewhere.
+*/
+function remixRoute(file) {
+	const withoutRouteFile = file.replace(/\/route\.[^./]+$/, "");
+	const flat = withoutRouteFile === file ? withoutExtension(file) : toPosix(withoutRouteFile);
+	const leaf = flat.includes("/") ? flat.split("/").pop() : flat;
+	if (leaf === "") return void 0;
+	const kept = [];
+	for (const raw of leaf.split(".")) {
+		const segment = raw.replace(/_$/, "");
+		if (segment === "") continue;
+		if (segment === "_index") continue;
+		if (segment.startsWith("$")) return void 0;
+		if (segment.includes("[")) return void 0;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/**
+* Hugo content: `content/posts/hello.md` serves `/posts/hello/`.
+*
+* `_index.md` is a section's own page rather than a page called `_index`, which
+* is the one place Hugo's leading underscore does not mean "private".
+*/
+function hugoRoute(file) {
+	const withoutIndex = file.replace(/(^|\/)_index\.[^./]+$/, "");
+	if (withoutIndex !== file) return toPosix(withoutIndex);
+	return withoutExtension(file);
+}
+/**
+* Conventions, most specific first.
+*
+* Order still matters where the registry knows nothing about a project, which
+* is the case for a plain directory of HTML and for anything the registry has
+* not heard of.
+*/
+const CONVENTIONS = [
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "src/app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "remix",
+		ids: ["remix"],
+		dir: "app/routes",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: remixRoute
+	},
+	{
+		framework: "starlight",
+		ids: ["astro"],
+		dir: "src/content/docs",
+		pattern: "**/*.{md,mdx,mdoc}",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "astro",
+		ids: ["astro"],
+		dir: "src/pages",
+		pattern: "**/*.{astro,md,mdx,html}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "gatsby",
+		ids: ["gatsby"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,md,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "nuxt",
+		ids: ["nuxt"],
+		dir: "pages",
+		pattern: "**/*.vue",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "sveltekit",
+		ids: ["sveltekit"],
+		dir: "src/routes",
+		pattern: "**/+page.{svelte,ts,js}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "docusaurus",
+		ids: ["docusaurus"],
+		dir: "docs",
+		pattern: "**/*.{md,mdx}",
+		toRoute: (file) => {
+			const route = mirroredRoute(file);
+			return route === void 0 ? void 0 : route === "" ? "docs" : `docs/${route}`;
+		}
+	},
+	{
+		framework: "vitepress",
+		ids: ["vitepress"],
+		dir: "docs",
+		pattern: "**/*.md",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "hugo",
+		ids: ["hugo"],
+		dir: "content",
+		pattern: "**/*.{md,html}",
+		toRoute: hugoRoute
+	}
+];
+/** Every page path a build could have emitted for one route. */
+function emittedPathsFor(route) {
+	if (route === "") return [
+		"/",
+		"index.html",
+		"index.htm"
+	];
+	return [
+		route,
+		`${route}/`,
+		`${route}.html`,
+		`${route}/index.html`
+	];
+}
+/**
+* Build a page-to-source map by reading the project's route files.
+*
+* Returns undefined when the project uses no convention this understands, which
+* is not a failure — most builds are not framework projects.
+*/
+async function buildRouteMap(cwd, pkg) {
+	for (const convention of await orderedConventions(cwd, pkg)) {
+		const map = await mapConvention(cwd, convention);
+		if (map !== void 0) return map;
+	}
+}
+/**
+* Conventions to try, the detected framework's first.
+*
+* Without this, `src/pages` is claimed by whichever convention is declared
+* earliest, so a Gatsby project was reported as `next-pages`. The mapping
+* happened to be right and the name was wrong, which is the kind of detail a
+* reader notices and stops trusting the rest of the report over.
+*/
+async function orderedConventions(cwd, pkg) {
+	const detected = await detectFramework(cwd, pkg ?? await readPackageJson(cwd));
+	if (detected === void 0) return [...CONVENTIONS];
+	const id = detected.framework.id;
+	const mine = CONVENTIONS.filter((convention) => convention.ids.includes(id));
+	const rest = CONVENTIONS.filter((convention) => !convention.ids.includes(id));
+	return [...mine, ...rest];
+}
+/** Read one convention's directory, or undefined when it has nothing to say. */
+async function mapConvention(cwd, convention) {
+	const directory = path.join(cwd, convention.dir);
+	if (!await isDirectory(directory)) return void 0;
+	const files = await glob([convention.pattern], {
+		cwd: directory,
+		ignore: ["**/node_modules/**"],
+		onlyFiles: true
+	});
+	if (files.length === 0) return void 0;
+	const sources = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const route = convention.toRoute(toPosix(file));
+		if (route === void 0) continue;
+		const source = `${convention.dir}/${toPosix(file)}`;
+		for (const emitted of emittedPathsFor(route)) if (!sources.has(emitted)) sources.set(emitted, source);
+	}
+	if (sources.size === 0) return void 0;
+	return {
+		framework: convention.framework,
+		sources
+	};
+}
+/** The source file for an audited page, if the map knows one. */
+function sourceFor(map, pagePath) {
+	if (map === void 0) return void 0;
+	return map.sources.get(pagePath) ?? map.sources.get(pagePath.replace(/^\//, ""));
+}
+//#endregion
+export { buildRouteMap, sourceFor };

package/dist/{run-BW6CVuND.js → run-C2nKFcb-.js}

@@ -1,5 +1,22 @@
 //#region src/integration/run.ts
 /**
+* Where an integration writes when its host offers no logger of its own.
+*
+* stderr rather than stdout, so a line about accessibility never lands in the
+* middle of a report being piped to a file, and prefixed either way: a message
+* in somebody's build log has to say what produced it.
+*/
+function stderrLogger() {
+	const write = (message) => {
+		process.stderr.write(`eaa-kit: ${message}\n`);
+	};
+	return {
+		info: write,
+		warn: write,
+		error: write
+	};
+}
+/**
 * Thrown to fail the build. Its own class so a consumer can tell an audit
 * failure from the build tool falling over.
 */
@@ -18,7 +35,7 @@ async function auditBuild(directory, options, logger) {
 		logger.info("skipped (enabled: false)");
 		return;
 	}
-	const { runAuditCommand } = await import("./audit-CuG2hYyo.js");
+	const { runAuditCommand } = await import("./audit-DyHPmGeD.js");
 	const { exitCode } = await runAuditCommand(directory, auditOptions);
 	if (exitCode === 0) {
 		logger.info("no violations at or above the threshold");
@@ -33,4 +50,4 @@ async function auditBuild(directory, options, logger) {
 	throw new BuildAuditError(`eaa-kit: ${message}`);
 }
 //#endregion
-export { auditBuild as n, BuildAuditError as t };
+export { auditBuild as n, stderrLogger as r, BuildAuditError as t };

package/dist/{run-BMASMmwO.d.ts → run-CtcEUhbe.d.ts}

@@ -20,6 +20,13 @@ interface IntegrationOptions {
   baseUrl?: string;
   /** Audit in real Chromium. Needs the playwright peer. */
   browser?: boolean;
+  /**
+   * Skip the rules the browserless engine cannot decide rather than running
+   * them and discarding the answer. The verdict does not move — those rules are
+   * still reported as not evaluated — so what a build gives up is the list of
+   * elements a person would check by hand. No effect under `browser`.
+   */
+  fast?: boolean;
   concurrency?: number;
   baseline?: string;
   format?: OutputFormat;

package/dist/{sarif-DB3WG7T9.js → sarif-B-UBcVu8.js}

@@ -1,8 +1,8 @@
-import { o as isImpactLevel } from "./impact-YdoOtFqm.js";
-import { a as standardsReference } from "./text-BFmNtMsV.js";
+import { o as isImpactLevel } from "./impact-DZt2oBCP.js";
+import { o as standardsReference } from "./text-CKKpzkYM.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
-import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
-import { a as ruleOutcomes, r as findingElements } from "./result-DLxd2Eip.js";
+import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
+import { c as ruleOutcomes, o as findingElements } from "./result-BWcYXeRs.js";
 import path from "node:path";
 //#region src/audit/report/sarif.ts
 const SARIF_VERSION = "2.1.0";
@@ -75,7 +75,7 @@ function buildSarifReport(audits, options) {
 				toolExecutionNotifications: notifications
 			}],
 			results,
-			properties: summaryProperties(audits)
+			properties: summaryProperties(audits, options.completeness)
 		}]
 	};
 }
@@ -111,7 +111,7 @@ function toResults(finding, ruleIndex, uri, suppressions) {
 * combines the fingerprint with the location itself.
 */
 function fingerprint(ruleId, selector, html) {
-	return { "eaaKit/v1": elementFingerprint(ruleId, selector, html) };
+	return { "eaaKit/v2": elementFingerprint(ruleId, selector, html) };
 }
 /** Every rule the run knows about, so the catalogue is complete in GitHub. */
 function buildRules(audits) {
@@ -140,7 +140,7 @@ function toSarifRule(outcome) {
 * Coverage that has no place in `results` but should not vanish: a SARIF log
 * with no results must not be mistaken for "everything was checked".
 */
-function summaryProperties(audits) {
+function summaryProperties(audits, completeness) {
 	let needsReview = 0;
 	let notEvaluated = 0;
 	const notEvaluatedRules = /* @__PURE__ */ new Set();
@@ -153,7 +153,15 @@ function summaryProperties(audits) {
 		pages: audits.length,
 		needsReview,
 		notEvaluated,
-		notEvaluatedRules: [...notEvaluatedRules].sort()
+		notEvaluatedRules: [...notEvaluatedRules].sort(),
+		...completeness ? {
+			complete: completeness.complete,
+			discovery: completeness.discovery,
+			pagesAudited: completeness.audited,
+			pagesErrored: completeness.errored,
+			pagesUnreachable: completeness.unreachable.length,
+			truncated: completeness.truncated
+		} : {}
 	};
 }
 /**

package/dist/{schema-CMZ8ItGk.js → schema-DJSF4K05.js}

@@ -64,9 +64,26 @@ function string(options = {}) {
 		return value;
 	} };
 }
+function boolean() {
+	return { read: (value, path, issues) => typeof value === "boolean" ? value : fail(issues, path, "expected true or false") };
+}
 function number() {
 	return { read: (value, path, issues) => typeof value === "number" && Number.isFinite(value) ? value : fail(issues, path, "expected a number") };
 }
+/**
+* A whole number, with an optional floor.
+*
+* `number` would accept 2.5 pages and a concurrency of 0, both of which the
+* CLI's own parsers refuse. A config file is the same instruction typed
+* somewhere else, so it is held to the same rule.
+*/
+function integer(options = {}) {
+	return { read: (value, path, issues) => {
+		if (typeof value !== "number" || !Number.isInteger(value)) return fail(issues, path, "expected a whole number");
+		if (options.min !== void 0 && value < options.min) return fail(issues, path, `must be ${options.min} or more`);
+		return value;
+	} };
+}
 /** One of a fixed set. The message lists them, since that is the useful part. */
 function enumeration(values) {
 	return { read: (value, path, issues) => typeof value === "string" && values.includes(value) ? value : fail(issues, path, `expected one of ${values.join(", ")}`) };
@@ -189,4 +206,4 @@ function email() {
 	} };
 }
 //#endregion
-export { withDefault as _, isoDateTime as a, object as c, record as d, safeParse as f, url as g, union as h, isoDate as i, optional as l, transform as m, email as n, nullable as o, string as p, enumeration as r, number as s, array as t, pipe as u };
+export { union as _, integer as a, nullable as c, optional as d, pipe as f, transform as g, string as h, enumeration as i, number as l, safeParse as m, boolean as n, isoDate as o, record as p, email as r, isoDateTime as s, array as t, object as u, url as v, withDefault as y };

package/dist/statement/templates/es.en.md

@@ -0,0 +1,125 @@
+# Accessibility Statement
+
+{{ provider.legalName }} is committed to making the website {{ site.name }} accessible in
+accordance with Ley 11/2023 of 8 May 2023, which transposes Directive (EU) 2019/882 (the
+European Accessibility Act) into Spanish law. Its obligations for products and services
+apply from 28 June 2025.
+
+This accessibility statement applies to {{ site.url }}.
+
+## Compliance status
+
+{{#if compliance.isCompliant}}
+This website is fully compliant with {{ compliance.standard }}.
+{{/if}}
+{{#if compliance.isPartiallyCompliant}}
+This website is partially compliant with {{ compliance.standard }}. The content listed in
+the following section is not accessible, for the reasons given.
+{{/if}}
+{{#if compliance.isNonCompliant}}
+This website is not compliant with {{ compliance.standard }}. The content listed in the
+following section is not accessible, for the reasons given.
+{{/if}}
+
+## Non-accessible content
+
+{{#if hasKnownIssues}}
+{{#each compliance.knownIssues}}
+- {{ description }}
+{{#if standards}}
+  Requirement affected: {{ standards }}
+{{/if}}
+{{#if pageList}}
+  Pages affected: {{ pageList }}{{#if hasMorePages}} and {{ morePages }} more{{/if}}
+{{/if}}
+{{#if isDisproportionateBurden}}
+  Reason: disproportionate burden.
+{{/if}}
+{{#if isOutOfScope}}
+  Reason: the content falls outside the scope of Ley 11/2023.
+{{/if}}
+{{#if isFixPlanned}}
+  Reason: the barrier is known and is being addressed.
+{{/if}}
+{{#if remedyByFormatted}}
+  Expected to be resolved by: {{ remedyByFormatted }}
+{{/if}}
+{{#if isFromAudit}}
+  Detected by automated testing (axe-core, rule {{ ruleId }}); describe it in your own words.
+{{/if}}
+{{/each}}
+{{/if}}
+{{#if hasNoKnownIssues}}
+No non-accessible content was known at the time of assessment.
+{{/if}}
+
+## Preparation of this statement
+
+This statement was prepared on {{ compliance.assessedOnFormatted }}.
+
+{{#if compliance.isSelfAssessment}}
+It is based on a self-assessment carried out by {{ provider.legalName }}.
+{{/if}}
+{{#if compliance.isExternalAudit}}
+It is based on an assessment carried out by a third party.
+{{/if}}
+
+{{#if audit.isSinglePage}}
+The automated test run of {{ audit.checkedOnFormatted }} covered one page of this website.
+{{/if}}
+{{#if audit.isMultiPage}}
+The automated test run of {{ audit.checkedOnFormatted }} covered {{ audit.pages }}
+pages of this website.
+{{/if}}
+{{#if audit.needsReviewIsSingle}}
+One further rule check requires a manual decision.
+{{/if}}
+{{#if audit.needsReviewIsPlural}}
+{{ audit.needsReview }} further rule checks require a manual decision.
+{{/if}}
+{{#if audit.notEvaluatedIsSingle}}
+One rule check could not be decided by the tool that was used; it is not reported as met.
+{{/if}}
+{{#if audit.notEvaluatedIsPlural}}
+{{ audit.notEvaluated }} rule checks could not be decided by the tool that was used; they
+are not reported as met.
+{{/if}}
+{{#if hasAudit}}
+
+{{/if}}
+The assessment relies in part on automated testing. Automated tools detect only a subset
+of possible barriers; they are not a substitute for manual testing or for testing with
+assistive technologies.
+
+## Feedback and contact
+
+Found a barrier, or need information in an accessible format? Please get in touch:
+
+- Email: {{ provider.email }}
+{{#if provider.feedbackUrl}}
+- Contact form: {{ provider.feedbackUrl }}
+{{/if}}
+{{#if provider.phone}}
+- Phone: {{ provider.phone }}
+{{/if}}
+{{#if provider.address}}
+- Address: {{ provider.address }}
+{{/if}}
+
+We aim to respond to your feedback promptly.
+
+## Enforcement procedure
+
+If you are not satisfied with our response, you can complain to the competent market
+surveillance authority. Ley 11/2023 divides that surveillance between the national
+administration and the autonomous communities, so for a digital service the usual route is
+the consumer authority of your autonomous community.
+
+Public-sector websites and mobile applications are additionally governed by Real Decreto
+1112/2018, which requires an accessibility statement with content of its own. This document
+is not that statement.
+
+---
+
+This statement was generated with eaa-kit and is not legal advice. Review it before
+publishing, and have it checked by a lawyer if in doubt.