@setsquare/review-sdk 0.0.1 → 0.1.1

package/dist/checks/context-change.js

@@ -0,0 +1,655 @@
+import { ON_FOCUS_HELP_URL, ON_INPUT_HELP_URL } from '../links.js';
+import { sanitiseSelectors } from '../sanitise.js';
+/**
+ * WCAG 3.2.1 On Focus (A) and 3.2.2 On Input (A): does touching a control
+ * change the context without being asked to?
+ *
+ * "Change of context" is normatively defined — user agent, viewport, focus, or
+ * content that changes the meaning of the page — and the first three are
+ * observable. The fourth is a judgement, so a large DOM mutation is
+ * needs-review rather than a violation.
+ *
+ * ---------------------------------------------------------------------------
+ * **The two halves have very different side effects, so they are gated
+ * differently. That is the decision this check exists around.**
+ *
+ * **3.2.1 is on by default.** It needs nothing the teardown focus walk does not
+ * already do — focusing every focusable element — so it adds no new class of
+ * side effect to a run that is already focusing them.
+ *
+ * **3.2.2 is opt-in, off by default** (`onInput: true`). It has to CHANGE a
+ * control's value, and a change event is where an application saves. A
+ * customer's page at teardown can be an authenticated application whose select
+ * has an autosave handler behind it, and mutating their data is a worse failure
+ * than any finding this rule could produce — worse, in particular, than being a
+ * flake, because a flake is visible and a silent write is not. So it is a
+ * choice somebody makes, and while it is off the criterion reports as "a check
+ * that did not run here", which is exactly what it is.
+ *
+ * **Text fields are never typed into, at any setting.** Only `<select>`,
+ * checkboxes and radios are touched, and their value is put back. Typing into a
+ * text field is a different risk class again: validation requests, autosave,
+ * character counters, and a half-filled form left behind.
+ * ---------------------------------------------------------------------------
+ */
+export const SETSQUARE_CONTEXT_CHECK_VERSION = 'setsquare-context@1';
+export const ON_FOCUS_RULE_ID = 'setsquare-on-focus';
+export const ON_INPUT_RULE_ID = 'setsquare-on-input';
+/** As in the focus walk: a ceiling so a large page cannot cost a scan. */
+const MAX_ELEMENTS = 120;
+const MAX_CONTROLS = 40;
+/**
+ * A DOM mutation big enough to be worth a person's attention.
+ *
+ * Not a violation at any size: "content that changes the meaning of the page"
+ * is the normative fourth kind of context change, and meaning is exactly what
+ * a node count cannot see. Twenty nodes is a threshold for asking, not for
+ * asserting.
+ */
+const LARGE_MUTATION_NODES = 20;
+/**
+ * How long to wait after changing a control before deciding nothing happened.
+ *
+ * A navigation is not synchronous with the `change` event that caused it: the
+ * request is issued after the handler returns. Without this pause the request
+ * from one control arrived while the NEXT one was being measured, and the
+ * finding named the wrong element — `select#jump`'s navigation was reported
+ * against the checkbox below it. Fifty milliseconds, times at most forty
+ * controls, on an opt-in check.
+ */
+const CHANGE_SETTLE_MS = 50;
+/* ------------------------------------------------------------------ 3.2.1 */
+/**
+ * Focus every focusable element and watch for an unrequested change of context.
+ *
+ * Runs entirely in the page, in one evaluate, because a round trip per element
+ * over a hundred and twenty of them at the end of every test is a cost nobody
+ * agreed to. That bounds what it can see, and the boundary is stated in the
+ * finding rather than papered over: `window.open` and `location.assign` /
+ * `location.replace` are patched and recorded, but `location.href = …` is a
+ * native setter on a non-configurable object and cannot be intercepted. A page
+ * that navigates that way on focus destroys the execution context, which
+ * surfaces as no evidence at all rather than as a pass.
+ */
+export async function runOnFocus(page) {
+    try {
+        const walk = await page.evaluate(focusContextWalk, {
+            maxElements: MAX_ELEMENTS,
+            largeMutation: LARGE_MUTATION_NODES,
+        });
+        return onFocusEvidence(walk);
+    }
+    catch {
+        return {};
+    }
+}
+function focusContextWalk({ maxElements, largeMutation, }) {
+    const step = (el) => {
+        const tag = el.tagName.toLowerCase();
+        if (el.id)
+            return `${tag}#${el.id}`;
+        if (el.classList.length > 0)
+            return `${tag}.${el.classList[0]}`;
+        const parent = el.parentElement;
+        if (!parent)
+            return tag;
+        return `${tag}:nth-child(${Array.prototype.indexOf.call(parent.children, el) + 1})`;
+    };
+    const describe = (el) => {
+        const parts = [];
+        let node = el;
+        for (let depth = 0; node && depth < 3; depth += 1) {
+            parts.unshift(step(node));
+            if (node.id || node.classList.length > 0)
+                break;
+            node = node.parentElement;
+            if (!node || node === document.body)
+                break;
+        }
+        return parts.join(' > ');
+    };
+    const changes = [];
+    /*
+     * Patched, not merely watched. A check that let a page open a window or
+     * navigate in order to observe it doing so would have destroyed the run to
+     * report on it — and `window.open` in particular leaves a real window behind
+     * for the rest of the session.
+     */
+    let opened;
+    let navigated;
+    const realOpen = window.open;
+    const realAssign = window.location.assign;
+    const realReplace = window.location.replace;
+    window.open = ((url) => {
+        opened = String(url ?? '');
+        return null;
+    });
+    window.location.assign = (url) => {
+        navigated = String(url);
+    };
+    window.location.replace = (url) => {
+        navigated = String(url);
+    };
+    let mutated = 0;
+    const observer = new MutationObserver((records) => {
+        for (const record of records) {
+            mutated += record.addedNodes.length + record.removedNodes.length;
+        }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    const FOCUSABLE = 'a[href],button,input,select,textarea,summary,[tabindex],[contenteditable="true"]';
+    const candidates = Array.prototype.slice
+        .call(document.querySelectorAll(FOCUSABLE))
+        .filter((el) => {
+        if (el.hasAttribute('disabled'))
+            return false;
+        if (el.getAttribute('aria-hidden') === 'true')
+            return false;
+        if (el.tabIndex < 0)
+            return false;
+        /*
+         * A CONTROL IN A SKIPPED OR INERT SUBTREE CANNOT BE FOCUSED, AND ITS OWN
+         * COMPUTED STYLE WILL NOT SAY SO.
+         *
+         * The case that made this necessary is the collapsed disclosure panel
+         * every component library ships. React Aria's renders as
+         * `hidden="until-found"`, which the UA styles with
+         * `content-visibility: hidden` rather than `display: none` — so the panel
+         * is in the layout, its descendants report a stale 67x44 box from the
+         * last time they were laid out, `display` and `visibility` on the link
+         * itself both read as perfectly ordinary, and the browser refuses focus
+         * anyway because the contents are skipped. Every check below this line
+         * passes and the element is still not focusable.
+         *
+         * `checkVisibility` is the only thing that answers this without walking
+         * every ancestor's computed style, and it is guarded because a customer's
+         * browser may predate it — the walk is still correct without it, thanks
+         * to the unchanged-focus guard below, just wasteful.
+         */
+        const cannotBeSeen = typeof el.checkVisibility === 'function' &&
+            !el.checkVisibility({ contentVisibilityAuto: true, visibilityProperty: true });
+        if (cannotBeSeen)
+            return false;
+        if (el.closest('[inert]'))
+            return false;
+        const cs = window.getComputedStyle(el);
+        if (cs.visibility === 'hidden' || cs.display === 'none')
+            return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+    });
+    let checked = 0;
+    for (const el of candidates.slice(0, maxElements)) {
+        opened = undefined;
+        navigated = undefined;
+        mutated = 0;
+        const focusedBefore = document.activeElement;
+        el.focus();
+        if (document.activeElement !== el) {
+            const landed = document.activeElement;
+            /*
+             * FOCUS THAT NEVER MOVED IS NOT FOCUS THAT MOVED SOMEWHERE.
+             *
+             * If the active element is the same one it was before we called
+             * `focus()`, the element refused focus and the browser left the previous
+             * control exactly where it was. The walk then reads its OWN last step as
+             * this step's outcome — "focusing X moved focus to Y", where Y is
+             * whatever the walk happened to focus a moment earlier.
+             *
+             * The body guard below was written for this and does not cover it,
+             * because the previous element is only the body on the first iteration.
+             * Every iteration after that inherits a real control.
+             *
+             * Found by scanning this repository's own marketing site at 768 and 390
+             * CSS pixels: below the nav's breakpoint the collapsed disclosure panel
+             * holds five controls that are laid out and unfocusable, and every one of
+             * them was reported as a level A failure reading "when a.ss-nav-link
+             * receives focus, focus moves to button#react-aria-…" — the disclosure
+             * trigger, which is simply the control the walk had focused on the step
+             * before. Ninety serious findings across eighteen surfaces, none of them
+             * real, and none of them visible from a desktop-only run. Any responsive
+             * site with a collapsing nav would have had the same.
+             *
+             * The filter above now excludes those controls before they are reached,
+             * so this guard is the backstop rather than the fix. It stays because the
+             * filter cannot be exhaustive: "the browser declined to move focus" is
+             * the general condition, and any future way of making an element
+             * unfocusable lands here.
+             */
+            if (landed === focusedBefore)
+                continue;
+            /*
+             * Focus landing on the BODY means the element refused focus, not that
+             * something took it away.
+             *
+             * A control that is present and laid out but not focusable at this
+             * moment — a disclosure trigger hidden behind a media query, a button
+             * inside an `inert` subtree — leaves `document.activeElement` at the
+             * body. That is not a change of context; there was no context change
+             * because there was no focus. Reporting it as one is how our own
+             * marketing site produced a level A violation reading "when
+             * button.shrink-0 receives focus, focus moves to button.shrink-0", which
+             * is a check describing its own mechanics.
+             */
+            if (!landed || landed === document.body || !(landed instanceof Element))
+                continue;
+            /*
+             * Focus landing INSIDE the same component is not a change of context
+             * either. A composite widget moving focus to its own inner control — a
+             * button that delegates to a nested element, a listbox that focuses its
+             * active option — is the recommended pattern, not a defect. Only focus
+             * LEAVING the component is what 3.2.1 is about.
+             */
+            if (el.contains(landed) || landed.contains(el)) {
+                checked += 1;
+                continue;
+            }
+            /*
+             * Focus moving to a SIBLING inside a composite widget is roving
+             * tabindex, which is the recommended pattern rather than a defect.
+             *
+             * A radiogroup, a toolbar, a tablist: Tab enters the group once and
+             * arrow keys move within it, so focusing a member that is not the active
+             * one hands focus to the one that is. From outside it looks like the
+             * control stealing focus; from a keyboard user's point of view nothing
+             * happened at all, because they could never have focused the member we
+             * reached for.
+             *
+             * This is what our own theme toggle does, and it produced a level A
+             * violation on every page of this repository's marketing site — the
+             * finding read "when button.shrink-0 receives focus, focus moves to
+             * button.shrink-0", two different radios with the same shape.
+             */
+            const COMPOSITE = new Set([
+                'radiogroup',
+                'toolbar',
+                'tablist',
+                'listbox',
+                'menu',
+                'menubar',
+                'tree',
+                'treegrid',
+                'grid',
+            ]);
+            let insideOneWidget = false;
+            for (let node = el.parentElement; node; node = node.parentElement) {
+                if (!node.contains(landed))
+                    continue;
+                const role = node.getAttribute('role');
+                if (role && COMPOSITE.has(role))
+                    insideOneWidget = true;
+                break;
+            }
+            if (insideOneWidget) {
+                checked += 1;
+                continue;
+            }
+            // Focus was somewhere else the instant we asked for it here. That is the
+            // commonest real 3.2.1 failure: a handler that moves focus on focus.
+            changes.push({ selector: describe(el), kind: 'focus-moved', detail: describe(landed) });
+            continue;
+        }
+        checked += 1;
+        // Let a microtask-scheduled handler run before deciding nothing happened.
+        observer.takeRecords().forEach((record) => {
+            mutated += record.addedNodes.length + record.removedNodes.length;
+        });
+        if (opened !== undefined) {
+            changes.push({ selector: describe(el), kind: 'window-opened', detail: opened });
+        }
+        else if (navigated !== undefined) {
+            changes.push({ selector: describe(el), kind: 'navigated', detail: navigated });
+        }
+        else if (mutated >= largeMutation) {
+            changes.push({ selector: describe(el), kind: 'mutation', nodes: mutated });
+        }
+    }
+    observer.disconnect();
+    window.open = realOpen;
+    window.location.assign = realAssign;
+    window.location.replace = realReplace;
+    return { checked, found: candidates.length, truncated: candidates.length > maxElements, changes };
+}
+/* ------------------------------------------------------------------ 3.2.2 */
+/**
+ * Change each `<select>`, checkbox and radio, and watch for a change of
+ * context. Opt-in; see the decision at the top of this file.
+ *
+ * Driven from Node rather than from one evaluate, unlike 3.2.1, because the
+ * failure this exists to catch — a select whose handler does
+ * `location.href = this.value` — navigates through a native setter that cannot
+ * be patched from inside the page. Playwright can see the navigation request
+ * and abort it before it commits, which is both how we detect it and how we
+ * stop it destroying the run. There are rarely more than a handful of such
+ * controls on a page, so the round trips are affordable in a way a
+ * hundred-and-twenty-element focus walk is not.
+ *
+ * Three guards, in this order, and the first is the one that matters most:
+ *
+ * 1. **Nothing is ever submitted.** A capture-phase listener cancels every
+ *    `submit` event and records that it happened — so an attempted submit is
+ *    the finding AND the thing that did not occur. A submit triggered by our
+ *    own input would be worse than any finding: it writes.
+ * 2. **No navigation commits.** Navigation requests are aborted at the route
+ *    level. The attempt is what we report.
+ * 3. **Every value is put back**, in a `finally`, whatever happened.
+ */
+export async function runOnInput(page) {
+    let unroute = false;
+    try {
+        const controls = await page.evaluate(collectControls, { max: MAX_CONTROLS });
+        if (controls.found === 0) {
+            return { inapplicable: { ruleId: ON_INPUT_RULE_ID, wcag: ON_INPUT_WCAG } };
+        }
+        let navigatedTo;
+        /*
+         * Answered with 204, not aborted.
+         *
+         * `route.abort()` on a main-frame navigation does not leave the page where
+         * it was: Chromium commits an error document, the execution context is
+         * destroyed, and the whole check dies reporting nothing — which is what the
+         * first version did, landing on `chrome-error://chromewebdata/` and
+         * throwing. A 204 No Content is the browser's own "there is nothing to
+         * navigate to": the request is made, we see it, and the current document
+         * stays exactly where it is.
+         */
+        await page.route('**/*', (route) => {
+            const request = route.request();
+            if (request.isNavigationRequest() && request.frame() === page.mainFrame()) {
+                navigatedTo = request.url();
+                return route.fulfill({ status: 204, body: '' });
+            }
+            return route.continue();
+        });
+        unroute = true;
+        const changes = [];
+        let checked = 0;
+        for (const control of controls.controls) {
+            navigatedTo = undefined;
+            const result = await page.evaluate(changeControl, {
+                selector: control.selector,
+                largeMutation: LARGE_MUTATION_NODES,
+            });
+            if (!result)
+                continue;
+            checked += 1;
+            // A navigation is issued after the handler returns, not during it.
+            await page.waitForTimeout(CHANGE_SETTLE_MS);
+            if (navigatedTo || result.submitted || result.navigated) {
+                changes.push({
+                    selector: control.selector,
+                    kind: 'navigated',
+                    detail: navigatedTo ?? result.navigated ?? 'a form submission',
+                });
+            }
+            else if (result.opened !== undefined) {
+                changes.push({ selector: control.selector, kind: 'window-opened', detail: result.opened });
+            }
+            else if (result.focusMovedTo) {
+                changes.push({
+                    selector: control.selector,
+                    kind: 'focus-moved',
+                    detail: result.focusMovedTo,
+                });
+            }
+            else if (result.mutated >= LARGE_MUTATION_NODES) {
+                changes.push({ selector: control.selector, kind: 'mutation', nodes: result.mutated });
+            }
+        }
+        return onInputEvidence({
+            checked,
+            found: controls.found,
+            truncated: controls.found > MAX_CONTROLS,
+            changes,
+        });
+    }
+    catch {
+        return {};
+    }
+    finally {
+        if (unroute)
+            await page.unroute('**/*').catch(() => { });
+    }
+}
+/**
+ * The controls this check will touch, and no others.
+ *
+ * `<select>`, checkbox and radio only. A text field is never typed into at any
+ * setting — validation requests, autosave, character counters, and a half-filled
+ * form left behind are a different risk class from flipping a checkbox back.
+ */
+function collectControls({ max }) {
+    const step = (el) => {
+        const tag = el.tagName.toLowerCase();
+        if (el.id)
+            return `${tag}#${el.id}`;
+        if (el.classList.length > 0)
+            return `${tag}.${el.classList[0]}`;
+        const parent = el.parentElement;
+        if (!parent)
+            return tag;
+        return `${tag}:nth-child(${Array.prototype.indexOf.call(parent.children, el) + 1})`;
+    };
+    const describe = (el) => {
+        const parts = [];
+        let node = el;
+        for (let depth = 0; node && depth < 3; depth += 1) {
+            parts.unshift(step(node));
+            if (node.id || node.classList.length > 0)
+                break;
+            node = node.parentElement;
+            if (!node || node === document.body)
+                break;
+        }
+        return parts.join(' > ');
+    };
+    const all = Array.prototype.slice.call(document.querySelectorAll('select, input[type="checkbox"], input[type="radio"]'));
+    const usable = all.filter((el) => {
+        if (el.hasAttribute('disabled'))
+            return false;
+        if (el.getAttribute('aria-hidden') === 'true')
+            return false;
+        const cs = window.getComputedStyle(el);
+        if (cs.visibility === 'hidden' || cs.display === 'none')
+            return false;
+        if (el instanceof HTMLSelectElement)
+            return el.options.length > 1;
+        return true;
+    });
+    return {
+        found: usable.length,
+        controls: usable.slice(0, max).map((el) => ({ selector: describe(el) })),
+    };
+}
+/**
+ * Change one control, observe, and put it back.
+ *
+ * Returns null when the selector no longer resolves — a previous control's
+ * handler may have re-rendered the page, and asserting against an element that
+ * is gone would be asserting about nothing.
+ */
+function changeControl({ selector, largeMutation }) {
+    const el = document.querySelector(selector);
+    if (!el)
+        return null;
+    const describe = (node) => {
+        const tag = node.tagName.toLowerCase();
+        if (node.id)
+            return `${tag}#${node.id}`;
+        if (node.classList.length > 0)
+            return `${tag}.${node.classList[0]}`;
+        return tag;
+    };
+    let submitted = false;
+    const blockSubmit = (event) => {
+        submitted = true;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    document.addEventListener('submit', blockSubmit, true);
+    let opened;
+    let navigated;
+    const realOpen = window.open;
+    const realAssign = window.location.assign;
+    const realReplace = window.location.replace;
+    const realSubmit = HTMLFormElement.prototype.submit;
+    window.open = ((url) => {
+        opened = String(url ?? '');
+        return null;
+    });
+    window.location.assign = (url) => {
+        navigated = String(url);
+    };
+    window.location.replace = (url) => {
+        navigated = String(url);
+    };
+    // `form.submit()` bypasses the submit EVENT entirely, so the listener above
+    // would never see it. Patched rather than trusted.
+    HTMLFormElement.prototype.submit = function patched() {
+        submitted = true;
+    };
+    let mutated = 0;
+    const observer = new MutationObserver((records) => {
+        for (const record of records) {
+            mutated += record.addedNodes.length + record.removedNodes.length;
+        }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    const before = document.activeElement;
+    const restore = [];
+    try {
+        if (el instanceof HTMLSelectElement) {
+            const original = el.selectedIndex;
+            restore.push(() => {
+                el.selectedIndex = original;
+            });
+            // The next option, or the previous one when we are already on the last.
+            el.selectedIndex = original === el.options.length - 1 ? original - 1 : original + 1;
+        }
+        else if (el instanceof HTMLInputElement) {
+            const original = el.checked;
+            restore.push(() => {
+                el.checked = original;
+            });
+            el.checked = !original;
+        }
+        else {
+            return null;
+        }
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        observer.takeRecords().forEach((record) => {
+            mutated += record.addedNodes.length + record.removedNodes.length;
+        });
+        const landed = document.activeElement;
+        const focusMovedTo = landed !== before && landed instanceof Element && landed !== el
+            ? describe(landed)
+            : undefined;
+        return {
+            mutated,
+            submitted,
+            ...(opened !== undefined ? { opened } : {}),
+            ...(navigated !== undefined ? { navigated } : {}),
+            ...(focusMovedTo ? { focusMovedTo } : {}),
+        };
+    }
+    finally {
+        for (const undo of restore)
+            undo();
+        observer.disconnect();
+        document.removeEventListener('submit', blockSubmit, true);
+        window.open = realOpen;
+        window.location.assign = realAssign;
+        window.location.replace = realReplace;
+        HTMLFormElement.prototype.submit = realSubmit;
+    }
+}
+const ON_FOCUS_WCAG = { criteria: ['3.2.1'], level: 'A', versionTags: [] };
+const ON_INPUT_WCAG = { criteria: ['3.2.2'], level: 'A', versionTags: [] };
+export function onFocusEvidence(walk) {
+    return contextEvidence(walk, {
+        ruleId: ON_FOCUS_RULE_ID,
+        wcag: ON_FOCUS_WCAG,
+        helpUrl: ON_FOCUS_HELP_URL,
+        verb: 'receives focus',
+        fix: 'Fix: move focus, open windows and navigate on activation — a click, Enter or Space — never on focus alone.',
+    });
+}
+export function onInputEvidence(walk) {
+    return contextEvidence(walk, {
+        ruleId: ON_INPUT_RULE_ID,
+        wcag: ON_INPUT_WCAG,
+        helpUrl: ON_INPUT_HELP_URL,
+        verb: 'has its value changed',
+        fix: 'Fix: put the navigation behind a button the user presses, and leave the control to set a value. A select that navigates on change is the classic form of this failure.',
+    });
+}
+/**
+ * One verdict shape for both criteria, because they differ only in what was
+ * touched. Keeping them in one function is what stops the two findings drifting
+ * into two vocabularies for one idea.
+ */
+function contextEvidence(walk, wording) {
+    if (walk.checked === 0 && walk.changes.length === 0) {
+        return { inapplicable: { ruleId: wording.ruleId, wcag: wording.wcag } };
+    }
+    const definite = walk.changes.filter((row) => row.kind !== 'mutation');
+    const judged = walk.changes.filter((row) => row.kind === 'mutation');
+    if (definite.length > 0) {
+        const first = definite[0];
+        const what = first.kind === 'focus-moved'
+            ? `focus moves to ${first.detail ?? 'another element'}`
+            : first.kind === 'window-opened'
+                ? `a new window is opened (${first.detail || 'no url given'})`
+                : `the page navigates to ${first.detail}`;
+        return {
+            finding: {
+                ruleId: wording.ruleId,
+                status: 'violation',
+                impact: 'serious',
+                wcag: wording.wcag,
+                helpUrl: wording.helpUrl,
+                evidence: {
+                    failureSummary: `When ${first.selector} ${wording.verb}, ${what} — a change of context nobody asked ` +
+                        `for. ${definite.length} control(s) affected. ${wording.fix}` +
+                        bounds(walk),
+                },
+                targets: {
+                    nodeCount: definite.length,
+                    ...sanitiseSelectors(definite.map((row) => row.selector)),
+                },
+            },
+        };
+    }
+    if (judged.length > 0) {
+        const first = judged[0];
+        return {
+            finding: {
+                ruleId: wording.ruleId,
+                status: 'incomplete',
+                impact: 'moderate',
+                wcag: wording.wcag,
+                helpUrl: wording.helpUrl,
+                evidence: {
+                    failureSummary: `When ${first.selector} ${wording.verb}, ${first.nodes} node(s) are added or removed. ` +
+                        `The fourth kind of context change is "content that changes the meaning of the page", ` +
+                        `and meaning is exactly what a node count cannot see — a revealed hint is fine, a ` +
+                        `replaced page is not. ${judged.length} control(s) affected; a person decides.` +
+                        bounds(walk),
+                },
+                targets: {
+                    nodeCount: judged.length,
+                    ...sanitiseSelectors(judged.map((row) => row.selector)),
+                },
+            },
+        };
+    }
+    return { pass: { ruleId: wording.ruleId, nodeCount: walk.checked, wcag: wording.wcag } };
+}
+function bounds(walk) {
+    return walk.truncated
+        ? ` The walk stopped after ${walk.checked} of ${walk.found} controls, so this is not the whole page.`
+        : '';
+}
+export { MAX_CONTROLS };
+//# sourceMappingURL=context-change.js.map