@a11y-oracle/axe-bridge 1.0.0

package/dist/lib/resolver-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-pipeline.d.ts","sourceRoot":"","sources":["../../src/lib/resolver-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAE5D;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAUhD;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,eAAe,EAAE,OAAO,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,eAAe,GACtB,IAAI,CAmCN;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAIzC"}

package/dist/lib/resolver-pipeline.js

@@ -0,0 +1,94 @@
+/**
+ * @module resolver-pipeline
+ *
+ * Shared utilities for axe-core incomplete rule resolvers.
+ * Provides the common clone → find-rule → analyze → promote → return
+ * pipeline that every resolver follows.
+ */
+/**
+ * Extract the innermost CSS selector from an axe node's target.
+ *
+ * axe-core represents selectors as arrays where shadow DOM targets
+ * have multiple entries. We use the last (innermost) selector.
+ */
+export function getSelector(node) {
+    return node.target[node.target.length - 1] ?? '';
+}
+/**
+ * Deep-clone an AxeResults object to avoid mutating the original.
+ */
+export function cloneResults(results) {
+    return JSON.parse(JSON.stringify(results));
+}
+/**
+ * Create a rule shell (all metadata, no nodes) from an existing rule.
+ */
+export function ruleShell(rule) {
+    return {
+        id: rule.id,
+        impact: rule.impact,
+        tags: [...rule.tags],
+        description: rule.description,
+        help: rule.help,
+        helpUrl: rule.helpUrl,
+        nodes: [],
+    };
+}
+/**
+ * Apply node promotions to a cloned AxeResults object.
+ *
+ * Moves nodes from the incomplete rule entry into the passes and
+ * violations arrays, then updates or removes the incomplete entry.
+ *
+ * @param clone - The cloned AxeResults to mutate.
+ * @param ruleIndex - Index of the rule in `clone.incomplete`.
+ * @param rule - The incomplete rule being resolved.
+ * @param result - Categorized nodes from the resolver's analysis.
+ */
+export function applyPromotions(clone, ruleIndex, rule, result) {
+    const ruleId = rule.id;
+    // Promote violations
+    if (result.violationNodes.length > 0) {
+        const existing = clone.violations.find((r) => r.id === ruleId);
+        if (existing) {
+            existing.nodes.push(...result.violationNodes);
+        }
+        else {
+            clone.violations.push({
+                ...ruleShell(rule),
+                nodes: result.violationNodes,
+            });
+        }
+    }
+    // Promote passes
+    if (result.passNodes.length > 0) {
+        const existing = clone.passes.find((r) => r.id === ruleId);
+        if (existing) {
+            existing.nodes.push(...result.passNodes);
+        }
+        else {
+            clone.passes.push({
+                ...ruleShell(rule),
+                nodes: result.passNodes,
+            });
+        }
+    }
+    // Update or remove the incomplete entry
+    if (result.incompleteNodes.length > 0) {
+        rule.nodes = result.incompleteNodes;
+    }
+    else {
+        clone.incomplete.splice(ruleIndex, 1);
+    }
+}
+/**
+ * Find a rule by ID in the incomplete array.
+ *
+ * @returns The rule index and rule object, or null if not found.
+ */
+export function findIncompleteRule(clone, ruleId) {
+    const index = clone.incomplete.findIndex((r) => r.id === ruleId);
+    if (index === -1)
+        return null;
+    return { index, rule: clone.incomplete[index] };
+}

package/dist/lib/resolvers/aria-hidden-focus.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module aria-hidden-focus
+ *
+ * Resolver for axe-core's `aria-hidden-focus` incomplete rule.
+ * Detects focusable elements inside `aria-hidden="true"` containers
+ * that are reachable via keyboard Tab navigation.
+ *
+ * Uses a single Tab traversal for ALL flagged nodes (not per-node)
+ * to avoid O(N*M) Tab presses.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, AriaHiddenFocusOptions } from '../types.js';
+/**
+ * Resolve incomplete `aria-hidden-focus` results.
+ *
+ * Focusable elements inside `aria-hidden="true"` containers should not
+ * be reachable via keyboard. This resolver:
+ * 1. Collects all flagged selectors into a lookup set
+ * 2. Resets focus to `<body>`
+ * 3. Tabs through the page up to `maxTabs` times
+ * 4. At each step, checks if the focused element matches a flagged selector
+ *
+ * Reachable via Tab → **Violation**. Not reached → **Pass**.
+ *
+ * @param cdp - CDP session for keyboard dispatch and DOM queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional traversal limit.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveAriaHiddenFocus(cdp: CDPSessionLike, axeResults: AxeResults, options?: AriaHiddenFocusOptions): Promise<AxeResults>;
+//# sourceMappingURL=aria-hidden-focus.d.ts.map

package/dist/lib/resolvers/aria-hidden-focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria-hidden-focus.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/aria-hidden-focus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAW,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAa/E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,UAAU,CAAC,CA8HrB"}

package/dist/lib/resolvers/aria-hidden-focus.js

@@ -0,0 +1,148 @@
+/**
+ * @module aria-hidden-focus
+ *
+ * Resolver for axe-core's `aria-hidden-focus` incomplete rule.
+ * Detects focusable elements inside `aria-hidden="true"` containers
+ * that are reachable via keyboard Tab navigation.
+ *
+ * Uses a single Tab traversal for ALL flagged nodes (not per-node)
+ * to avoid O(N*M) Tab presses.
+ */
+import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'aria-hidden-focus';
+/** Default maximum number of Tab presses before stopping traversal. */
+const DEFAULT_MAX_TABS = 100;
+/**
+ * Resolve incomplete `aria-hidden-focus` results.
+ *
+ * Focusable elements inside `aria-hidden="true"` containers should not
+ * be reachable via keyboard. This resolver:
+ * 1. Collects all flagged selectors into a lookup set
+ * 2. Resets focus to `<body>`
+ * 3. Tabs through the page up to `maxTabs` times
+ * 4. At each step, checks if the focused element matches a flagged selector
+ *
+ * Reachable via Tab → **Violation**. Not reached → **Pass**.
+ *
+ * @param cdp - CDP session for keyboard dispatch and DOM queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional traversal limit.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveAriaHiddenFocus(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const maxTabs = options?.maxTabs ?? DEFAULT_MAX_TABS;
+    const keyboard = new KeyboardEngine(cdp);
+    // Build a map from selector to node for quick lookup
+    const selectorToNode = new Map();
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        selectorToNode.set(selector, node);
+    }
+    // Track which selectors were reached during traversal
+    const reachedSelectors = new Set();
+    // Reset focus to body
+    await cdp.send('Runtime.evaluate', {
+        expression: 'document.activeElement?.blur(); document.body.focus(); void 0;',
+        returnByValue: true,
+    });
+    // Tab through the page, checking at each step
+    let previousSelector = '';
+    for (let i = 0; i < maxTabs; i++) {
+        await keyboard.press('Tab');
+        // Get the currently focused element's unique selector
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const el = document.activeElement;
+        if (!el || el === document.body) return null;
+        // Build a selector that matches what axe-core generates
+        // Try ID first
+        if (el.id) return '#' + el.id;
+        // Build path
+        const path = [];
+        let current = el;
+        while (current && current !== document.body && current !== document.documentElement) {
+          let seg = current.tagName.toLowerCase();
+          if (current.id) {
+            seg = '#' + current.id;
+            path.unshift(seg);
+            break;
+          }
+          const parent = current.parentElement;
+          if (parent) {
+            const siblings = Array.from(parent.children).filter(
+              c => c.tagName === current.tagName
+            );
+            if (siblings.length > 1) {
+              const idx = siblings.indexOf(current) + 1;
+              seg += ':nth-child(' + idx + ')';
+            }
+          }
+          path.unshift(seg);
+          current = current.parentElement;
+        }
+        return path.join(' > ');
+      })()`,
+            returnByValue: true,
+        });
+        const focusedSelector = result.result.value;
+        // If we've looped back to body or same element, stop
+        if (!focusedSelector)
+            break;
+        if (focusedSelector === previousSelector)
+            break;
+        previousSelector = focusedSelector;
+        // Check if focused element matches any flagged selector
+        for (const [selector] of selectorToNode) {
+            if (reachedSelectors.has(selector))
+                continue;
+            // Check if the currently focused element matches this selector
+            const matchResult = await cdp.send('Runtime.evaluate', {
+                expression: `(() => {
+          const el = document.activeElement;
+          if (!el) return false;
+          try {
+            return el.matches(${JSON.stringify(selector)}) ||
+                   el === document.querySelector(${JSON.stringify(selector)});
+          } catch { return false; }
+        })()`,
+                returnByValue: true,
+            });
+            if (matchResult.result.value) {
+                reachedSelectors.add(selector);
+            }
+        }
+        // Early exit if all selectors have been found
+        if (reachedSelectors.size === selectorToNode.size)
+            break;
+    }
+    // Classify nodes
+    const passNodes = [];
+    const violationNodes = [];
+    for (const [selector, node] of selectorToNode) {
+        if (reachedSelectors.has(selector)) {
+            // Element inside aria-hidden is reachable via Tab → Violation
+            violationNodes.push(node);
+        }
+        else {
+            // Element is not reachable via Tab → Pass
+            passNodes.push(node);
+        }
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}

package/dist/lib/resolvers/content-on-hover.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module content-on-hover
+ *
+ * Resolver for axe-core's `content-on-hover` incomplete rule
+ * (WCAG 1.4.13 Content on Hover or Focus). Verifies that
+ * hover-triggered content is both hoverable and dismissible.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, ContentOnHoverOptions } from '../types.js';
+/**
+ * Resolve incomplete `content-on-hover` results.
+ *
+ * For each flagged trigger element:
+ * 1. Set up a MutationObserver to detect new content
+ * 2. Hover the trigger element via `Input.dispatchMouseEvent`
+ * 3. Wait for content to appear
+ * 4. **Hoverable test:** Move mouse to new content; if it disappears → Violation
+ * 5. **Dismissible test:** Press Escape; if content persists → Violation
+ * 6. Both pass → **Pass**
+ *
+ * @param cdp - CDP session for mouse/keyboard dispatch and DOM queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional delay configuration.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveContentOnHover(cdp: CDPSessionLike, axeResults: AxeResults, options?: ContentOnHoverOptions): Promise<AxeResults>;
+//# sourceMappingURL=content-on-hover.d.ts.map

package/dist/lib/resolvers/content-on-hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-on-hover.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/content-on-hover.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAW,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAgB9E;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,UAAU,CAAC,CA2MrB"}

package/dist/lib/resolvers/content-on-hover.js

@@ -0,0 +1,230 @@
+/**
+ * @module content-on-hover
+ *
+ * Resolver for axe-core's `content-on-hover` incomplete rule
+ * (WCAG 1.4.13 Content on Hover or Focus). Verifies that
+ * hover-triggered content is both hoverable and dismissible.
+ */
+import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'content-on-hover';
+/** Default delay waiting for content to appear after hover. */
+const DEFAULT_HOVER_DELAY = 300;
+/** Default delay waiting for content to disappear after dismiss. */
+const DEFAULT_DISMISS_DELAY = 200;
+/**
+ * Resolve incomplete `content-on-hover` results.
+ *
+ * For each flagged trigger element:
+ * 1. Set up a MutationObserver to detect new content
+ * 2. Hover the trigger element via `Input.dispatchMouseEvent`
+ * 3. Wait for content to appear
+ * 4. **Hoverable test:** Move mouse to new content; if it disappears → Violation
+ * 5. **Dismissible test:** Press Escape; if content persists → Violation
+ * 6. Both pass → **Pass**
+ *
+ * @param cdp - CDP session for mouse/keyboard dispatch and DOM queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional delay configuration.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveContentOnHover(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const hoverDelay = options?.hoverDelay ?? DEFAULT_HOVER_DELAY;
+    const dismissDelay = options?.dismissDelay ?? DEFAULT_DISMISS_DELAY;
+    const keyboard = new KeyboardEngine(cdp);
+    const passNodes = [];
+    const violationNodes = [];
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        // Set up MutationObserver and get trigger element position
+        const setupResult = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const trigger = document.querySelector(${JSON.stringify(selector)});
+        if (!trigger) return null;
+        const rect = trigger.getBoundingClientRect();
+
+        // Set up observer to detect newly added elements
+        window.__a11yHoverNewContent = [];
+        window.__a11yHoverObserver = new MutationObserver((mutations) => {
+          for (const mutation of mutations) {
+            for (const added of mutation.addedNodes) {
+              if (added.nodeType === 1) {
+                window.__a11yHoverNewContent.push(added);
+              }
+            }
+          }
+        });
+        window.__a11yHoverObserver.observe(document.body, {
+          childList: true,
+          subtree: true,
+        });
+
+        // Record initial visibility state of potential tooltip/popup elements
+        // (some implementations toggle visibility rather than adding nodes)
+        const tooltips = document.querySelectorAll('[role="tooltip"], .tooltip, [data-tooltip]');
+        window.__a11yHoverInitialHidden = new Set();
+        tooltips.forEach(t => {
+          const cs = window.getComputedStyle(t);
+          if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') {
+            window.__a11yHoverInitialHidden.add(t);
+          }
+        });
+
+        return {
+          x: Math.round(rect.x + rect.width / 2),
+          y: Math.round(rect.y + rect.height / 2),
+        };
+      })()`,
+            returnByValue: true,
+        });
+        if (!setupResult.result.value) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        const { x: triggerX, y: triggerY } = setupResult.result.value;
+        // Hover the trigger element
+        await cdp.send('Input.dispatchMouseEvent', {
+            type: 'mouseMoved',
+            x: triggerX,
+            y: triggerY,
+        });
+        // Wait for content to appear
+        await delay(hoverDelay);
+        // Check for new content
+        const contentResult = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        // Check for newly added nodes
+        let newContent = window.__a11yHoverNewContent || [];
+
+        // Also check for elements that became visible
+        const tooltips = document.querySelectorAll('[role="tooltip"], .tooltip, [data-tooltip]');
+        tooltips.forEach(t => {
+          if (window.__a11yHoverInitialHidden && window.__a11yHoverInitialHidden.has(t)) {
+            const cs = window.getComputedStyle(t);
+            if (cs.display !== 'none' && cs.visibility !== 'hidden' && cs.opacity !== '0') {
+              newContent.push(t);
+            }
+          }
+        });
+
+        if (newContent.length === 0) return null;
+
+        // Get position of the first new content element
+        const content = newContent[0];
+        const rect = content.getBoundingClientRect();
+        return {
+          x: Math.round(rect.x + rect.width / 2),
+          y: Math.round(rect.y + rect.height / 2),
+          visible: rect.width > 0 && rect.height > 0,
+        };
+      })()`,
+            returnByValue: true,
+        });
+        if (!contentResult.result.value || !contentResult.result.value.visible) {
+            // No hover content appeared — likely a false positive from axe-core
+            // or content appeared too slowly. Leave as incomplete.
+            await cleanup(cdp);
+            incompleteNodes.push(node);
+            continue;
+        }
+        const { x: contentX, y: contentY } = contentResult.result.value;
+        // Test 1: HOVERABLE — Move mouse to the new content
+        await cdp.send('Input.dispatchMouseEvent', {
+            type: 'mouseMoved',
+            x: contentX,
+            y: contentY,
+        });
+        await delay(dismissDelay);
+        // Check if content is still visible
+        const hoverableResult = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const newContent = window.__a11yHoverNewContent || [];
+        if (newContent.length === 0) return false;
+        const content = newContent[0];
+        // Check if it's still in the DOM and visible
+        if (!document.contains(content)) return false;
+        const cs = window.getComputedStyle(content);
+        if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') return false;
+        const rect = content.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      })()`,
+            returnByValue: true,
+        });
+        const isHoverable = hoverableResult.result.value;
+        if (!isHoverable) {
+            // Content disappears when mouse moves to it → Violation
+            await cleanup(cdp);
+            violationNodes.push(node);
+            continue;
+        }
+        // Move mouse back to trigger to re-show content for dismiss test
+        await cdp.send('Input.dispatchMouseEvent', {
+            type: 'mouseMoved',
+            x: triggerX,
+            y: triggerY,
+        });
+        await delay(hoverDelay);
+        // Test 2: DISMISSIBLE — Press Escape key
+        await keyboard.press('Escape');
+        await delay(dismissDelay);
+        // Check if content was dismissed
+        const dismissedResult = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const newContent = window.__a11yHoverNewContent || [];
+        if (newContent.length === 0) return true;
+        const content = newContent[0];
+        if (!document.contains(content)) return true;
+        const cs = window.getComputedStyle(content);
+        if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') return true;
+        const rect = content.getBoundingClientRect();
+        return rect.width === 0 || rect.height === 0;
+      })()`,
+            returnByValue: true,
+        });
+        const isDismissible = dismissedResult.result.value;
+        await cleanup(cdp);
+        if (!isDismissible) {
+            // Content cannot be dismissed with Escape → Violation
+            violationNodes.push(node);
+        }
+        else {
+            // Content is both hoverable and dismissible → Pass
+            passNodes.push(node);
+        }
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}
+/**
+ * Clean up the MutationObserver and temporary state.
+ */
+async function cleanup(cdp) {
+    await cdp.send('Runtime.evaluate', {
+        expression: `(() => {
+      if (window.__a11yHoverObserver) {
+        window.__a11yHoverObserver.disconnect();
+        delete window.__a11yHoverObserver;
+      }
+      delete window.__a11yHoverNewContent;
+      delete window.__a11yHoverInitialHidden;
+    })()`,
+        returnByValue: true,
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/resolvers/focus-indicator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module focus-indicator
+ *
+ * Resolver for axe-core's incomplete focus-indicator-related rules
+ * (WCAG 2.4.7 Focus Visible). Takes before/after screenshots of
+ * elements in resting vs focused states and pixel-diffs them.
+ *
+ * If the screenshots are identical → no visible focus indicator → Violation.
+ * If they differ → focus indicator is present → Pass.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, FocusIndicatorOptions } from '../types.js';
+/**
+ * Resolve incomplete focus-indicator results.
+ *
+ * For each flagged element:
+ * 1. Capture a clipped screenshot of the element in resting state
+ * 2. Focus the element via `element.focus()`
+ * 3. Wait for CSS transitions to settle
+ * 4. Capture a second screenshot
+ * 5. Pixel-diff the two images
+ *
+ * Different → **Pass** (focus indicator visible).
+ * Identical → **Violation** (no visible focus change).
+ *
+ * @param cdp - CDP session for screenshots and focus dispatch.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional delay and threshold configuration.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveFocusIndicator(cdp: CDPSessionLike, axeResults: AxeResults, options?: FocusIndicatorOptions): Promise<AxeResults>;
+//# sourceMappingURL=focus-indicator.d.ts.map

package/dist/lib/resolvers/focus-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-indicator.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/focus-indicator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAW,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAmB9E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,UAAU,CAAC,CAkHrB"}