eaa-kit 0.4.0 → 0.6.0

package/dist/{crawl-BiI1Lau_.js → crawl-BHkJmUkA.js}

@@ -1,6 +1,20 @@
-import { i as stripBom } from "./collect-CFM8gEVv.js";
+import { a as stripBom } from "./collect-Cu1q9NTB.js";
 /** Requests in flight at once. Politeness, not throughput. */
 const REQUEST_CONCURRENCY = 4;
+/**
+* Largest response body this will read, in bytes.
+*
+* A crawl reads whatever the server sends, and nothing obliges a server to send
+* something reasonable — a misconfigured export endpoint, a log streamed as
+* text/html, or a host that simply does not stop. `response.text()` buffers all
+* of it before anyone can object, so the ceiling has to be applied while the
+* body is still arriving.
+*
+* Matches the on-disk page limit: the two paths audit the same kind of
+* document, and a page that would be declined off disk should not be accepted
+* because it arrived over HTTP instead.
+*/
+const MAX_BODY_BYTES = 33554432;
 var CrawlError = class extends Error {
 	name = "CrawlError";
 };
@@ -79,7 +93,7 @@ function urlsFromSitemap(xml, origin) {
 	return urls;
 }
 /** One request, with a timeout, returning HTML or a reason it is not a page. */
-async function fetchPage(url, impl, timeoutMs, origin) {
+async function fetchPage(url, impl, timeoutMs, origin, maxBodyBytes, headers) {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
@@ -88,7 +102,8 @@ async function fetchPage(url, impl, timeoutMs, origin) {
 			redirect: "follow",
 			headers: {
 				accept: "text/html,application/xhtml+xml",
-				"user-agent": "eaa-kit"
+				"user-agent": "eaa-kit",
+				...headers
 			}
 		});
 		if (!response.ok) return {
@@ -106,11 +121,16 @@ async function fetchPage(url, impl, timeoutMs, origin) {
 			ok: false,
 			reason: `not HTML (${type.split(";")[0] || "no content-type"})`
 		};
+		const body = await readCapped(response, maxBodyBytes);
+		if (body === void 0) return {
+			ok: false,
+			reason: `larger than the ${maxBodyBytes} byte limit for one page`
+		};
 		return {
 			ok: true,
 			value: {
 				url: finalUrl,
-				html: await response.text()
+				html: body
 			}
 		};
 	} catch (cause) {
@@ -123,6 +143,51 @@ async function fetchPage(url, impl, timeoutMs, origin) {
 		clearTimeout(timer);
 	}
 }
+/**
+* A response body, up to a limit, or undefined when it runs past it.
+*
+* Streamed rather than buffered, because `response.text()` has already read
+* everything by the time it could be checked, and a content-length header is
+* both optional and unverified — a chunked response carries no length at all,
+* and one that carries a length is not obliged to tell the truth. Counting the
+* bytes as they arrive is the only check that holds either way, and the body is
+* cancelled the moment it goes over so nothing keeps arriving.
+*/
+async function readCapped(response, limit) {
+	const body = response.body;
+	if (!body) {
+		const text = await response.text();
+		return text.length > limit ? void 0 : text;
+	}
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value === void 0) continue;
+			total += value.byteLength;
+			if (total > limit) {
+				await reader.cancel();
+				return;
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new TextDecoder().decode(concat(chunks, total));
+}
+function concat(chunks, total) {
+	const joined = new Uint8Array(total);
+	let at = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, at);
+		at += chunk.byteLength;
+	}
+	return joined;
+}
 /** Paths robots.txt disallows for us. Only the wildcard group is read. */
 function disallowedPaths(robots) {
 	const lines = robots.split(/\r?\n/).map((line) => line.replace(/#.*$/, "").trim());
@@ -149,12 +214,22 @@ function disallowedPaths(robots) {
 * that is not a page. A site that does not publish one is the ordinary case,
 * not a failure, so it comes back empty either way.
 */
-async function fetchSiteFile(entry, impl, name) {
+async function fetchSiteFile(entry, impl, name, timeoutMs, maxBodyBytes, headers) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
-		const response = await impl(new URL(name, entry).href, { redirect: "follow" });
-		return response.ok ? await response.text() : void 0;
+		const response = await impl(new URL(name, entry).href, {
+			redirect: "follow",
+			signal: controller.signal,
+			...headers === void 0 ? {} : { headers }
+		});
+		if (!response.ok) return void 0;
+		if (new URL(response.url || new URL(name, entry).href).origin !== entry.origin) return void 0;
+		return await readCapped(response, maxBodyBytes);
 	} catch {
 		return;
+	} finally {
+		clearTimeout(timer);
 	}
 }
 /**
@@ -169,8 +244,9 @@ async function crawlSite(entry, options = {}) {
 	const maxPages = options.maxPages ?? 200;
 	const maxDepth = options.maxDepth ?? 3;
 	const timeoutMs = options.timeoutMs ?? 15e3;
+	const maxBodyBytes = options.maxBodyBytes ?? MAX_BODY_BYTES;
 	const failures = [];
-	const robots = options.ignoreRobots ? void 0 : await fetchSiteFile(entry, impl, "/robots.txt");
+	const robots = options.ignoreRobots ? void 0 : await fetchSiteFile(entry, impl, "/robots.txt", timeoutMs, maxBodyBytes, options.headers);
 	const blocked = robots === void 0 ? [] : disallowedPaths(robots);
 	const allowed = (url) => !blocked.some((path) => url.pathname.startsWith(path));
 	let discovery = "links";
@@ -184,7 +260,7 @@ async function crawlSite(entry, options = {}) {
 			depth
 		});
 	};
-	const sitemap = await fetchSiteFile(entry, impl, options.sitemap ?? "/sitemap.xml");
+	const sitemap = await fetchSiteFile(entry, impl, options.sitemap ?? "/sitemap.xml", timeoutMs, maxBodyBytes, options.headers);
 	const listed = sitemap === void 0 ? [] : urlsFromSitemap(sitemap, entry);
 	if (listed.length > 0) {
 		discovery = "sitemap";
@@ -192,11 +268,12 @@ async function crawlSite(entry, options = {}) {
 	}
 	enqueue(entry, 0);
 	const pages = [];
+	const redirects = [];
 	while (queue.length > 0 && pages.length < maxPages) {
 		const batch = queue.splice(0, Math.min(REQUEST_CONCURRENCY, maxPages - pages.length));
 		const results = await Promise.all(batch.map(async (item) => ({
 			item,
-			result: await fetchPage(item.url, impl, timeoutMs, entry.origin)
+			result: await fetchPage(item.url, impl, timeoutMs, entry.origin, maxBodyBytes, options.headers)
 		})));
 		for (const { item, result } of results) {
 			if (!result.ok) {
@@ -207,6 +284,10 @@ async function crawlSite(entry, options = {}) {
 				continue;
 			}
 			const { url, html } = result.value;
+			if (url.href !== item.url.href) redirects.push({
+				requested: item.url.href,
+				landedOn: url.href
+			});
 			pages.push({
 				absolutePath: url.href,
 				relativePath: pageIdentity(url),
@@ -220,11 +301,38 @@ async function crawlSite(entry, options = {}) {
 		pages: byIdentity(pages),
 		origin: entry.origin,
 		failures,
+		redirects,
 		truncated: queue.length > 0,
 		discovery
 	};
 }
 /**
+* The requested URLs that a login wall swallowed, or none.
+*
+* A redirect on its own says nothing: sites normalise trailing slashes and send
+* `/` to `/en/` all day. What is not ordinary is *several* different URLs
+* answering at one address, or a whole crawl coming back as the single page the
+* entry was redirected to. Both are the shape of a sign-in page standing in
+* front of the site, and both otherwise produce a report about a page nobody
+* asked for that says it audited everything it set out to.
+*
+* Returns what was asked for and never reached, which is the one thing the run
+* has to say out loud. Deliberately shy of naming the cause: a single-page site
+* that redirects its entry looks identical from here, and being told where the
+* run actually landed is useful either way.
+*/
+function collapsedOnto(result) {
+	if (result.redirects.length === 0) return [];
+	const byDestination = /* @__PURE__ */ new Map();
+	for (const redirect of result.redirects) byDestination.set(redirect.landedOn, [...byDestination.get(redirect.landedOn) ?? [], redirect.requested]);
+	const collapsed = [];
+	for (const [landedOn, requested] of byDestination) if (requested.length > 1 || result.pages.length === 1) for (const from of requested) collapsed.push({
+		requested: from,
+		landedOn
+	});
+	return collapsed;
+}
+/**
 * One page per identity, in a stable order.
 *
 * The queue already refuses a URL it has seen, so this catches the case the
@@ -241,4 +349,4 @@ function byIdentity(pages) {
 	}).sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
 //#endregion
-export { CrawlError, crawlSite, parseEntryUrl };
+export { CrawlError, collapsedOnto, crawlSite, parseEntryUrl };

package/dist/eleventy/index.d.ts

@@ -1,4 +1,4 @@
-import { n as IntegrationOptions, t as BuildAuditError } from "../run-BMASMmwO.js";
+import { n as IntegrationOptions, t as BuildAuditError } from "../run-YiqyQA2b.js";
 //#region src/eleventy/index.d.ts
 /** What `eleventy.after` is given. Only two of its fields are read. */
 interface EleventyAfterEvent {

package/dist/eleventy/index.js

@@ -1,4 +1,4 @@
-import { n as auditBuild, r as stderrLogger, t as BuildAuditError } from "../run-DB34BSOZ.js";
+import { n as auditBuild, r as stderrLogger, t as BuildAuditError } from "../run-D7hdVXLA.js";
 import path from "node:path";
 //#region src/eleventy/index.ts
 /**

package/dist/fingerprint-BjYV_0F7.js

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+//#region src/audit/fingerprint.ts
+/**
+* A stable identity for one violating element.
+*
+* Derived from the rule, the selector and the element's own opening tag, and
+* deliberately not from the file it was found in. Two consumers need this and
+* they need it to agree: SARIF, so that moving a page does not close one code
+* scanning alert and open an identical one, and the baseline, so that an
+* accepted violation stays accepted when the surrounding page changes.
+*
+* Sixteen hex characters. This identifies a defect for humans and tooling, not
+* a secret, and a full digest in every entry would make a baseline file for a
+* large site unreadable.
+*/
+function elementFingerprint(ruleId, selector, html) {
+	return createHash("sha256").update(`${ruleId}\n${selector}\n${openingTag(html)}`).digest("hex").slice(0, 16);
+}
+/**
+* The element's own tag, without anything nested inside it.
+*
+* axe-core hands back the failing element's outerHTML, which for a leaf like
+* `<img>` is the element and for a container is the element and every
+* descendant it has. Hashing all of that made the identity of a container
+* depend on its contents — and the container that matters here is `<html>`,
+* which every document-level rule fails against: `html-has-lang`,
+* `document-title`, `landmark-one-main`, `page-has-heading-one`.
+*
+* Their outerHTML is the whole page. So adding one paragraph anywhere changed
+* the fingerprint of every document-level violation on that page, and all three
+* consumers believed it:
+*
+* - the baseline stopped suppressing barriers it had accepted, and the build
+*   went red on a page whose only change was a typo fix;
+* - `diff` reported the same untouched barrier as both new and **fixed**, which
+*   is the one thing it exists to refuse to do;
+* - SARIF churned its partialFingerprints, so code scanning closed an alert and
+*   opened an identical one on every edit.
+*
+* The identity of an element is its own tag and attributes. Where two elements
+* share those, axe-core's selector already tells them apart — it qualifies
+* ambiguous matches with `:nth-child(…)` — so nothing that was distinguishable
+* before stops being distinguishable now.
+*
+* Anything that is not an element — the empty string a rule with no attached
+* node carries — is returned unchanged, so those keep the identity they had.
+*/
+function openingTag(html) {
+	const trimmed = html.trim();
+	if (!trimmed.startsWith("<")) return trimmed;
+	let quote;
+	for (let i = 1; i < trimmed.length; i += 1) {
+		const char = trimmed[i];
+		if (quote !== void 0) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === ">") return trimmed.slice(0, i + 1);
+	}
+	return trimmed;
+}
+//#endregion
+export { elementFingerprint as t };

package/dist/{html-BGTO3ypW.js → html-Bmh7X_sM.js}

@@ -1,10 +1,12 @@
-import { a as impactRank, i as impactLabel, r as countAtOrAbove } from "./impact-DZt2oBCP.js";
-import { i as escapeText, n as count, o as standardsReference, r as escapeAttribute, t as collapse } from "./text-CKKpzkYM.js";
+import { a as impactLabel, r as byImpactThenRule } from "./impact-luGCnN8F.js";
+import { i as escapeText, n as count, r as escapeAttribute, s as standardsReference, t as collapse } from "./text-BF1LHMiV.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
-import { a as isShared, i as groupIssues, n as blindRules, o as discoveryLabel, r as coverageParts, s as missedParts, t as remediationFor } from "./remediation-Dtowi2EC.js";
-import { r as componentPath } from "./component-C3GL1Mnu.js";
-import { i as understandingUrl, r as manualCheckFor, t as buildCoverage } from "./coverage-B4IBKMO8.js";
-import { n as buildSummary } from "./json-DjEvy1nX.js";
+import { c as runEngine } from "./result-DfUru6y_.js";
+import { l as reviewSentence } from "./review-CdMK2GpQ.js";
+import { r as componentPath } from "./component-ChisoFyY.js";
+import { i as reviewSummary, n as buildCoverage, o as manualCheckFor, s as understandingUrl } from "./coverage-BD2_CYns.js";
+import { a as blindRules, c as isShared, i as remediationFor, l as issueTotals, n as missedParts, o as coverageParts, s as groupIssues, t as discoveryLabel } from "./completeness-Dwq3CPB3.js";
+import { n as buildSummary } from "./json-PNg6BeXp.js";
 import axe from "axe-core";
 //#region src/audit/report/html.ts
 /**
@@ -36,8 +38,8 @@ 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 engine = runEngine(audits);
+	const totals = buildSummary(audits, options.failOn);
 	const generatedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
 	const title = `Accessibility audit · ${options.directory}`;
 	return `<!doctype html>
@@ -54,15 +56,15 @@ ${STYLES}
 <body>
 <main>
 <h1>Accessibility audit</h1>
-${verdict(audits, failing, options)}
+${verdict(totals, options)}
 ${scoreboard(audits)}
 ${issues(audits, options)}
 ${runDetails(audits, engine, generatedAt, options)}
 ${notMeasured(options)}
-${summary(audits, failing, options)}
+${summary(totals, options)}
 ${pages(audits)}
 ${notEvaluated(audits)}
-${coverageSection(audits)}
+${coverageSection(audits, options)}
 ${footer()}
 </main>
 </body>
@@ -77,11 +79,11 @@ ${footer()}
 * 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;
+function verdict(totals, options) {
+	const unaudited = totals.pagesNotAudited;
 	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 (totals.failing > 0) return banner("fail", "Violations found", `${count(totals.failing, "violation")} at or above ${escapeText(options.failOn)}.`);
+	const below = totals.violations - totals.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.`);
 	const completeness = options.completeness;
 	if (completeness && !completeness.complete) return banner("partial", "No violations found, but the whole site was not measured", `${escapeText(missedParts(completeness).join(", "))}. This report describes ${count(completeness.audited, "page")}, not the site.`);
@@ -137,13 +139,12 @@ function notMeasured(options) {
 * the kind of bug nobody notices until a client does, so there is one place
 * that counts.
 */
-function summary(audits, failing, options) {
-	const totals = buildSummary(audits, options.failOn);
+function summary(totals, options) {
 	const impacts = IMPACT_ORDER.filter((impact) => totals.byImpact[impact] > 0).map((impact) => `  <li><span class="badge ${escapeAttribute(impact)}">${escapeText(impact)}</span> ${totals.byImpact[impact]}</li>`).join("\n");
 	return `<h2>Summary</h2>
 <ul class="counts">
   <li><strong>${count(totals.violations, "violation")}</strong> on ${totals.pagesWithViolations} of ${count(totals.pages, "page")}, across ${count(totals.violatingElements, "element")}</li>
-  <li><strong>${failing}</strong> at or above ${escapeText(options.failOn)}</li>
+  <li><strong>${totals.failing}</strong> at or above ${escapeText(options.failOn)}</li>
   <li><strong>${totals.needsReview}</strong> ${totals.needsReview === 1 ? "rule needs" : "rules need"} manual review</li>
   <li><strong>${totals.notEvaluated}</strong> ${totals.notEvaluated === 1 ? "rule was" : "rules were"} not evaluated by this engine</li>
 ${totals.accepted > 0 ? `  <li><strong>${totals.accepted}</strong> ${totals.accepted === 1 ? "element is" : "elements are"} accepted by the baseline, and not counted above</li>` : ""}
@@ -236,8 +237,8 @@ ${manualBlock(ruleId, finding)}
 * majority of WCAG, and a percentage would present a limit of automated testing
 * as a property of this site.
 */
-function coverageSection(audits) {
-	const coverage = buildCoverage(audits);
+function coverageSection(audits, options) {
+	const coverage = buildCoverage(audits, void 0, options.review);
 	const rows = coverage.criteria.map((criterion) => {
 		const url = understandingUrl(criterion.number);
 		const name = escapeText(`${criterion.number} ${criterion.title}`);
@@ -245,7 +246,7 @@ function coverageSection(audits) {
 		return `  <tr class="${escapeAttribute(criterion.status)}">
     <td>${linked}</td>
     <td>${escapeText(criterion.level)}</td>
-    <td>${statusText(criterion)}</td>
+    <td>${statusText(criterion)}${reviewCell(criterion)}</td>
   </tr>`;
 	}).join("\n");
 	return `<h2>Coverage of WCAG 2.2 AA</h2>
@@ -263,6 +264,7 @@ function coverageSection(audits) {
   of WCAG cannot be automated, and a percentage here would present that limit of automated
   testing as though it were a measurement of this site.
 </p>
+${reviewParagraph(coverage)}
 <div class="scroll">
 <table class="coverage">
 <thead><tr><th>Success criterion</th><th>Level</th><th>This run</th></tr></thead>
@@ -272,6 +274,20 @@ ${rows}
 </table>
 </div>`;
 }
+/**
+* What a person recorded, where a review was supplied.
+*
+* Its own paragraph, under the four counts and visibly apart from them: the
+* counts are what an engine measured and this is what somebody says they
+* checked. This document is the one that leaves the building, so the difference
+* between the two has to survive being quoted.
+*/
+function reviewParagraph(coverage) {
+	const summary = reviewSummary(coverage);
+	if (summary === void 0) return "";
+	return `<p class="note review">${escapeText(summary)} eaa-kit cannot check that anything
+  recorded in a review is true; it reports it as the claim it is.</p>`;
+}
 function statusText(criterion) {
 	const browser = criterion.browserWouldAnswer ? " <em>(a real browser would answer this)</em>" : "";
 	switch (criterion.status) {
@@ -281,6 +297,16 @@ function statusText(criterion) {
 		case "no-automated-rule": return "No automated rule exists; a person must check it";
 	}
 }
+/**
+* What a person recorded about this criterion, in the cell that says what the
+* run reached. The same sentence the console report prints, from the same
+* function, so two documents of one run cannot word it differently.
+*/
+function reviewCell(criterion) {
+	const review = criterion.review;
+	if (review === void 0) return "";
+	return `<br><span class="reviewed">${escapeText(reviewSentence(review))}</span>`;
+}
 function footer() {
 	return `<hr>
 <footer>
@@ -303,12 +329,6 @@ function standards(finding) {
 function standardsText(finding) {
 	return escapeText(standardsReference(finding.successCriteria, finding.enClauses));
 }
-function totalViolations(audits) {
-	return audits.reduce((total, audit) => total + audit.violations.length, 0);
-}
-function byImpactThenRule(a, b) {
-	return impactRank(a.impact) - impactRank(b.impact) || a.ruleId.localeCompare(b.ruleId);
-}
 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; }
@@ -362,6 +382,8 @@ table.coverage tr.evaluated td:last-child { color: #216e39; }
 table.coverage em { font-style: normal; opacity: 0.75; }
 ul.unreachable li { margin-bottom: 0.2rem; overflow-wrap: anywhere; }
 code.selector { color: #4a4a4a; }
+.reviewed { color: #4a4a4a; font-size: 0.95em; }
+p.note.review { border-left: 3px solid #c9c9c9; padding-left: 0.75rem; }
 p.clean { color: #216e39; }
 p.note { font-size: 0.95rem; }
 hr { border: 0; border-top: 1px solid #d4d4d4; margin: 3rem 0 1.5rem; }
@@ -401,7 +423,8 @@ ul.page-list { margin: 0.35rem 0 0; padding-left: 1.25rem; }
   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.accepted-heading, ul.accepted, .reviewed { color: #b6b6b6; }
+  p.note.review { border-left-color: #555; }
   p.clean { color: #7ee2a8; }
   .verdict.pass { background: #10240f; border-color: #7ee2a8; }
   .verdict.fail { background: #2b1111; border-color: #ff9d9d; }
@@ -467,8 +490,7 @@ function scoreboard(audits) {
 function issues(audits, options) {
 	const found = groupIssues(audits);
 	if (found.length === 0) return "";
-	const elements = found.reduce((total, issue) => total + issue.elements.length, 0);
-	const occurrences = found.reduce((total, issue) => total + issue.occurrences, 0);
+	const { elements, occurrences } = issueTotals(found);
 	const intro = occurrences === elements ? `${count(elements, "distinct element")} to fix.` : `${count(occurrences, "violation")} across the site, from ${count(elements, "distinct element")}.`;
 	return `<h2 id="issues">What to fix</h2>
 <p class="intro">${escapeText(intro)}</p>

package/dist/{impact-DZt2oBCP.js → impact-luGCnN8F.js}

@@ -36,6 +36,16 @@ function impactRank(impact) {
 function impactLabel(impact) {
 	return impact !== null && isImpactLevel(impact) ? impact : "unclassified";
 }
+/**
+* Worst first, then by rule id so two runs of the same build agree.
+*
+* The order every format lists a page's findings in. Issues are sorted by
+* `bySeverityThenReach` instead, which adds the reach a grouped issue has and a
+* single page's findings do not.
+*/
+function byImpactThenRule(a, b) {
+	return impactRank(a.impact) - impactRank(b.impact) || a.ruleId.localeCompare(b.ruleId);
+}
 /** Violations at or above `threshold`, counted per rule per page. */
 function countAtOrAbove(audits, threshold) {
 	let total = 0;
@@ -43,4 +53,4 @@ function countAtOrAbove(audits, threshold) {
 	return total;
 }
 //#endregion
-export { impactRank as a, impactLabel as i, IMPACT_LEVELS as n, isImpactLevel as o, countAtOrAbove as r, meetsThreshold as s, DEFAULT_FAIL_ON as t };
+export { impactLabel as a, meetsThreshold as c, countAtOrAbove as i, IMPACT_LEVELS as n, impactRank as o, byImpactThenRule as r, isImpactLevel as s, DEFAULT_FAIL_ON as t };