@reticlehq/browser 3.9.0 → 3.10.0

package/dist/dom/chart-geometry.d.ts

@@ -0,0 +1,7 @@
+export declare const CHART_SHAPE_CAP = 120;
+export interface ChartReading {
+    label: string;
+    shapes: string[];
+    cut?: number;
+}
+export declare function readCharts(root: Element): ChartReading[];

package/dist/dom/chart-geometry.js

@@ -0,0 +1,39 @@
+export const CHART_SHAPE_CAP = 120;
+const MIN_CHART_WIDTH = 120;
+const MIN_CHART_HEIGHT = 60;
+const SHAPE_TAGS = ['rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'path'];
+const NOT_DRAWN = 'defs, clipPath, mask, pattern, marker, symbol';
+const pct = (v, of) => {
+    const n = Math.round((v / of) * 1000) / 10;
+    return Object.is(n, -0) ? '0' : String(n);
+};
+export function readCharts(root) {
+    const out = [];
+    const svgs = Array.from(root.querySelectorAll('svg')).filter((s) => null === s.parentElement?.closest('svg'));
+    for (const svg of svgs) {
+        const frame = svg.getBoundingClientRect();
+        if (frame.width < MIN_CHART_WIDTH || frame.height < MIN_CHART_HEIGHT) {
+            continue;
+        }
+        const marks = Array.from(svg.querySelectorAll(SHAPE_TAGS.join(','))).filter((el) => null === el.closest(NOT_DRAWN));
+        const shapes = [];
+        for (const el of marks) {
+            const b = el.getBoundingClientRect();
+            if (0 === b.width && 0 === b.height) {
+                continue;
+            }
+            const x = pct(b.left - frame.left, frame.width);
+            const y = pct(b.top - frame.top, frame.height);
+            shapes.push(`${el.tagName.toLowerCase()} ${x} ${y} ${pct(b.width, frame.width)} ${pct(b.height, frame.height)}`);
+        }
+        if (0 === shapes.length) {
+            continue;
+        }
+        const label = svg.getAttribute('aria-label') ?? `chart ${String(out.length + 1)}`;
+        const kept = shapes.slice(0, CHART_SHAPE_CAP);
+        out.push(shapes.length > CHART_SHAPE_CAP
+            ? { label, shapes: kept, cut: shapes.length - CHART_SHAPE_CAP }
+            : { label, shapes: kept });
+    }
+    return out;
+}

package/dist/dom/occlusion.js

@@ -13,6 +13,10 @@ export function hitTestOccluder(el, rect) {
     const doc = el.ownerDocument;
     if (typeof doc.elementFromPoint !== 'function')
         return null;
+    const passThrough = pointerPassesThrough(el, rect);
+    if (passThrough !== undefined) {
+        return passThrough;
+    }
     const withStack = doc;
     const isOursButNotTheTarget = (candidate) => isReticleUi(candidate) &&
         candidate !== el &&
@@ -41,3 +45,20 @@ export function hitTestOccluder(el, rect) {
     }
     return worstCount >= BLOCKED_MAJORITY ? worst : null;
 }
+function pointerPassesThrough(el, rect) {
+    const view = el.ownerDocument.defaultView;
+    if (null === view || 'none' !== view.getComputedStyle(el).pointerEvents) {
+        return undefined;
+    }
+    const top = el.ownerDocument.elementFromPoint(rect.left + rect.width / 2, rect.top + rect.height / 2);
+    if (null === top || el.contains(top) || isReticleUi(top)) {
+        return null;
+    }
+    const labels = 'labels' in el ? el.labels : null;
+    for (const label of labels ?? []) {
+        if (label === top || label.contains(top)) {
+            return null;
+        }
+    }
+    return top;
+}

package/dist/dom/query-finders.d.ts

@@ -1,6 +1,6 @@
 import { type ElementQuery } from '@reticlehq/core';
 export declare function elementsUnder(container: HTMLElement): HTMLElement[];
-export declare function isNonRendered(el: Element): boolean;
+export declare function ownWords(el: Element): string;
 export declare function isHiddenNativeOption(el: HTMLElement): boolean;
 export declare function queryByRoleAndName(container: HTMLElement, role: string, name: string | undefined): HTMLElement[];
 export declare function findIn(container: HTMLElement, query: ElementQuery): HTMLElement[];

package/dist/dom/query-finders.js

@@ -1,7 +1,7 @@
 import { DATA_RETICLE_SOURCE_ATTR, QueryBy } from '@reticlehq/core';
 import { isInput, isSelect, isTextArea } from './realm.js';
 import { getAccessibleName, getRole } from './a11y.js';
-import { isVisible } from './visibility.js';
+import { isNonRendered, isVisible } from './visibility.js';
 import { identifyComponent } from '../registry/stores/adapters.js';
 import { readTestId, testIdSelector } from './addressing/testid-attr.js';
 import { exactVisibleText, fuzzyVisibleText, comparableText, paintedCase, textMatches, } from './text-match.js';
@@ -12,10 +12,6 @@ export function elementsUnder(container) {
     const self = Node.ELEMENT_NODE === container.nodeType ? [container] : [];
     return [...self, ...Array.from(container.querySelectorAll('*'))];
 }
-const NON_RENDERED_TAGS = ['script', 'style', 'template', 'noscript'];
-export function isNonRendered(el) {
-    return NON_RENDERED_TAGS.includes(el.tagName.toLowerCase());
-}
 function directText(el) {
     if (isInput(el)) {
         const type = el.type.toLowerCase();
@@ -67,15 +63,22 @@ function findByComponentName(container, component) {
     }
     return out;
 }
+export function ownWords(el) {
+    return (el.textContent ?? '').replace(/\s+/g, ' ').trim();
+}
 function findByComponent(container, query) {
+    const words = query.text === undefined ? undefined : query.text.replace(/\s+/g, ' ').trim();
+    const role = query.role;
+    const keep = (els) => els.filter((el) => (words === undefined || ownWords(el) === words) &&
+        (role === undefined || matchesRole(getRole(el), role)));
     if (query.source !== undefined) {
-        const bySource = findBySource(container, query.source);
+        const bySource = keep(findBySource(container, query.source));
         if (bySource.length > 0) {
             return bySource;
         }
     }
     if (query.component !== undefined && query.component.length > 0) {
-        return findByComponentName(container, query.component);
+        return keep(findByComponentName(container, query.component));
     }
     return [];
 }

package/dist/dom/query.d.ts

@@ -1,4 +1,5 @@
 import { ElementState, type ElementQuery, type MatchResult, type NearestTarget, type QueryResult } from '@reticlehq/core';
+export declare function embeddedRootsUnder(root: HTMLElement): HTMLElement[];
 export declare const ATTR_VALUE_MAX = 512;
 export declare function matchQuery(query: ElementQuery, state?: ElementState, limit?: number, wholePhrase?: boolean, diagnose?: boolean, fullText?: boolean): MatchResult;
 export declare const MAX_NEAREST_NAME = 60;

package/dist/dom/query.js

@@ -1,21 +1,23 @@
 import { ALTERNATIVE_TESTID_ATTRS, DEFAULT_TESTID_ATTR, ElementState, QueryBy, REDACTED_VALUE, TRANSPORT_LIMITS, } from '@reticlehq/core';
-import { isActionTarget, isElement, isFrame } from './realm.js';
+import { isElement, isFrame } from './realm.js';
 import { capturedRootOf } from './shadow-registry.js';
 import { getAccessibleName, getRole, describe, getStates } from './a11y.js';
-import { isHiddenByAriaOnly, isInViewport, isRenderedOutsideAriaHidden, isVisible, } from './visibility.js';
+import { isHiddenByAriaOnly, isHiddenSubtree, isInViewport, isRenderedOutsideAriaHidden, isVisible, isNonRendered, } from './visibility.js';
 import { dialogCovering, isIgnored, isReticleOverlay, isWordsIgnored } from './dom-ignore.js';
+import { hitTestOccluder } from './occlusion.js';
 import { isSensitiveKey } from '../security/serialization.js';
 import { declaredTestids } from '../registry/capabilities.js';
 import { refs } from './addressing/refs.js';
+import { firstIn, firstListIn, hintRoots, pageContent, resolveContainers } from './scope-roots.js';
 import { getTestIdAttr, readTestId, testIdSelector } from './addressing/testid-attr.js';
 import { stableSelectorFor } from './stable-selector.js';
 import { fuzzyVisibleText, normaliseVisibleText, comparableText, foldTypography, textMatches, unreadableMatch, } from './text-match.js';
 import { pageRoute } from '../security/page-location.js';
-import { elementsUnder, findIn, isNonRendered, queryByRoleAndName } from './query-finders.js';
+import { elementsUnder, findIn, queryByRoleAndName } from './query-finders.js';
 import { INTERACTIVE } from './snapshot.js';
 const MAX_PRESENT_TESTIDS = 12;
 function visibleTextOf(el, memo) {
-    if (isNonRendered(el) || isWordsIgnored(el)) {
+    if (isHiddenSubtree(el, memo) || isNonRendered(el) || isWordsIgnored(el)) {
         return '';
     }
     const visible = isVisible(el, memo);
@@ -26,6 +28,9 @@ function visibleTextOf(el, memo) {
             text += node.textContent ?? '';
         }
         else if (isElement(node)) {
+            if (isHiddenSubtree(node, memo)) {
+                continue;
+            }
             const own = visibleTextOf(node, memo);
             text += apart || ownBox(node) ? ` ${own} ` : own;
         }
@@ -40,24 +45,6 @@ function ownBox(el) {
     const display = el.ownerDocument.defaultView?.getComputedStyle(el).display ?? 'inline';
     return !display.startsWith('inline') && 'contents' !== display;
 }
-function resolveContainer(scope) {
-    if (scope === undefined) {
-        return { container: document.body, scopeMissing: false };
-    }
-    const byRef = refs.resolve(scope);
-    if (isActionTarget(byRef)) {
-        return { container: byRef, scopeMissing: false };
-    }
-    try {
-        const found = document.querySelector(scope);
-        if (isActionTarget(found)) {
-            return { container: found, scopeMissing: false };
-        }
-    }
-    catch {
-    }
-    return { container: null, scopeMissing: true };
-}
 function readableFrameBody(frame) {
     try {
         return frame.contentDocument?.body ?? null;
@@ -67,7 +54,7 @@ function readableFrameBody(frame) {
     }
 }
 const FRAME_DEPTH_MAX = 3;
-function embeddedRootsUnder(root) {
+export function embeddedRootsUnder(root) {
     const found = [];
     const walk = (node, depth) => {
         for (const el of node.querySelectorAll('*')) {
@@ -95,19 +82,20 @@ function embeddedRootsUnder(root) {
     return found;
 }
 function findCandidates(query) {
-    const { container, scopeMissing } = resolveContainer(query.scope);
-    if (null === container) {
-        return { candidates: [], scopeMissing: true };
+    const { containers, scopeMissing } = resolveContainers(query.scope);
+    const scopeMatches = containers.length;
+    if (0 === scopeMatches) {
+        return { candidates: [], scopeMissing: true, scopeMatches };
     }
     if (true === query.self) {
         if (query.scope === undefined) {
-            return { candidates: [], scopeMissing };
-        }
-        if (query.text !== undefined &&
-            !textMatches(visibleTextOf(container, new Map()), query, query.text)) {
-            return { candidates: [], scopeMissing };
+            return { candidates: [], scopeMissing, scopeMatches };
         }
-        return { candidates: isIgnored(container) ? [] : [container], scopeMissing };
+        const visibleMemo = new Map();
+        const selves = containers.filter((container) => !isIgnored(container) &&
+            (query.text === undefined ||
+                textMatches(visibleTextOf(container, visibleMemo), query, query.text)));
+        return { candidates: selves, scopeMissing, scopeMatches };
     }
     const seen = new Set();
     const out = [];
@@ -117,6 +105,9 @@ function findCandidates(query) {
             if (seen.has(el)) {
                 continue;
             }
+            if (!pageContent(el, query.scope)) {
+                continue;
+            }
             if (ignored(el)) {
                 continue;
             }
@@ -124,11 +115,13 @@ function findCandidates(query) {
             out.push(el);
         }
     };
-    collect(findIn(container, query));
-    for (const embedded of embeddedRootsUnder(container)) {
-        collect(findIn(embedded, query));
+    for (const container of containers) {
+        collect(findIn(container, query));
+        for (const embedded of embeddedRootsUnder(container)) {
+            collect(findIn(embedded, query));
+        }
     }
-    return { candidates: out, scopeMissing };
+    return { candidates: out, scopeMissing, scopeMatches };
 }
 export const ATTR_VALUE_MAX = 512;
 const ATTR_KEYS_MAX = 12;
@@ -143,10 +136,29 @@ function projectAttrs(el, keys) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+function receivesPointer(el, memo) {
+    if (!isVisible(el, memo)) {
+        return false;
+    }
+    const rect = el.getBoundingClientRect();
+    if (0 === rect.width || 0 === rect.height) {
+        return true;
+    }
+    return isInViewport(el, memo) && null === hitTestOccluder(el, rect);
+}
 function inState(el, state, memo) {
     if (ElementState.IN_VIEWPORT === state) {
         return isInViewport(el, memo);
     }
+    if (ElementState.RECEIVES_POINTER === state) {
+        return receivesPointer(el, memo);
+    }
+    if (ElementState.VISIBLE === state) {
+        return isVisible(el, memo);
+    }
+    if (ElementState.HIDDEN === state) {
+        return !isVisible(el, memo);
+    }
     return getStates(el, isVisible(el, memo)).includes(state);
 }
 const MAX_DESCRIBED = TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS;
@@ -154,8 +166,10 @@ export function matchQuery(query, state, limit = MAX_DESCRIBED, wholePhrase = tr
     const found = findCandidates(query);
     const scopeMissing = found.scopeMissing;
     const wanted = wholePhrase && textOnly(query) ? wantedTextOf(query) : undefined;
-    const scope = 0 === found.candidates.length ? resolveContainer(query.scope).container : null;
-    const owner = null === scope || wanted === undefined ? undefined : splitTextOwner(scope, wanted, query);
+    const scopes = 0 === found.candidates.length ? resolveContainers(query.scope).containers : [];
+    const owner = wanted === undefined
+        ? undefined
+        : firstIn(scopes, (scope) => splitTextOwner(scope, wanted, query));
     const elements = owner === undefined ? found.candidates : [owner];
     const visMemo = new Map();
     const filtered = state === undefined ? elements : elements.filter((el) => inState(el, state, visMemo));
@@ -186,6 +200,7 @@ export function matchQuery(query, state, limit = MAX_DESCRIBED, wholePhrase = tr
         elements: descriptors,
         ...(fullText ? { fullText: true } : {}),
         ...(scopeMissing ? { scopeMissing: true } : {}),
+        ...(found.scopeMatches > 1 ? { scopeMatches: found.scopeMatches } : {}),
         ...(covered === undefined ? {} : { coveredBy: covered }),
         ...(unreadable === undefined ? {} : { unreadable }),
         ...(0 === filtered.length ? { hint: buildEmptyHint(query, state, diagnose) } : {}),
@@ -204,7 +219,7 @@ function resolveLabelledBy(el) {
     return text.length > 0 ? text : undefined;
 }
 function buildPresentRegions(query) {
-    const container = resolveContainer(query.scope).container ?? document.body;
+    const roots = hintRoots(query.scope);
     const regions = [];
     const CONTAINER_ROLES = [
         'list',
@@ -225,7 +240,7 @@ function buildPresentRegions(query) {
         'tablist',
     ];
     for (const role of CONTAINER_ROLES) {
-        const containers = queryByRoleAndName(container, role, undefined);
+        const containers = roots.flatMap((root) => queryByRoleAndName(root, role, undefined));
         for (const el of containers) {
             if (isReticleOverlay(el)) {
                 continue;
@@ -269,6 +284,9 @@ function splitTextOwner(container, wanted, query) {
         if (isIgnored(el)) {
             continue;
         }
+        if (!pageContent(el, query.scope)) {
+            continue;
+        }
         if (!textMatches(visibleTextOf(el, memo), query, wanted)) {
             continue;
         }
@@ -283,7 +301,7 @@ function splitTextOwner(container, wanted, query) {
     }
     return best;
 }
-function caseOnlyMatch(container, wanted) {
+function caseOnlyMatch(container, wanted, scope) {
     const target = comparableText(wanted).toLowerCase();
     if (0 === target.length) {
         return undefined;
@@ -293,6 +311,9 @@ function caseOnlyMatch(container, wanted) {
         if (isIgnored(el)) {
             continue;
         }
+        if (!pageContent(el, scope)) {
+            continue;
+        }
         const text = normaliseVisibleText(visibleTextOf(el, memo));
         const at = foldTypography(text).toLowerCase().indexOf(target);
         if (-1 !== at) {
@@ -474,14 +495,17 @@ function textInAriaHidden(container, wanted) {
     return true;
 }
 function buildEmptyHint(query, state, diagnose = true) {
-    const container = resolveContainer(query.scope).container ?? document.body;
-    const all = container.querySelectorAll(testIdSelector());
+    const roots = hintRoots(query.scope);
+    const all = roots.flatMap((root) => Array.from(root.querySelectorAll(testIdSelector())));
     const present = [];
     const seen = new Set();
-    for (const el of Array.from(all)) {
+    for (const el of all) {
         if (isIgnored(el)) {
             continue;
         }
+        if (!pageContent(el, query.scope)) {
+            continue;
+        }
         const id = readTestId(el);
         if (null === id || 0 === id.length || seen.has(id)) {
             continue;
@@ -503,14 +527,14 @@ function buildEmptyHint(query, state, diagnose = true) {
     };
     const wanted = wantedTextOf(query);
     if (wanted !== undefined) {
-        const owner = splitTextOwner(container, wanted, query);
+        const owner = firstIn(roots, (root) => splitTextOwner(root, wanted, query));
         if (owner !== undefined) {
             const described = describe(owner);
             const selector = stableSelectorFor(owner);
             hint.splitText = selector === undefined ? described : { ...described, selector };
         }
         else if (true === query.matchCase) {
-            const shown = caseOnlyMatch(container, wanted);
+            const shown = firstIn(roots, (root) => caseOnlyMatch(root, wanted, query.scope));
             if (shown !== undefined) {
                 hint.caseMiss = shown;
             }
@@ -520,19 +544,19 @@ function buildEmptyHint(query, state, diagnose = true) {
         wanted !== undefined &&
         hint.splitText === undefined &&
         (state === undefined || ElementState.VISIBLE === state || ElementState.IN_VIEWPORT === state)) {
-        if (textInAriaHidden(container, wanted)) {
+        if (roots.some((root) => textInAriaHidden(root, wanted))) {
             hint.ariaHiddenMatch = true;
         }
     }
-    const near = nameNearMisses(container, query);
+    const near = firstListIn(roots, (root) => nameNearMisses(root, query));
     if (near.length > 0) {
         hint.nameNearMiss = near;
     }
-    const elsewhere = testidFoundUnder(container, query);
+    const elsewhere = firstIn(roots, (root) => testidFoundUnder(root, query));
     if (elsewhere !== undefined) {
         hint.testidFoundUnder = elsewhere;
     }
-    const nearest = diagnose ? nearestTargets(container, query) : [];
+    const nearest = diagnose ? firstListIn(roots, (root) => nearestTargets(root, query)) : [];
     if (nearest.length > 0) {
         hint.nearest = nearest;
     }
@@ -543,7 +567,10 @@ export function elementsMatching(query) {
 }
 export function runQuery(query, limit) {
     const result = matchQuery(query, undefined, limit, false);
-    const scopeFields = true === result.scopeMissing ? { scopeMissing: true } : {};
+    const scopeFields = {
+        ...(true === result.scopeMissing ? { scopeMissing: true } : {}),
+        ...(result.scopeMatches === undefined ? {} : { scopeMatches: result.scopeMatches }),
+    };
     if (0 === result.elements.length) {
         return {
             elements: result.elements,

package/dist/dom/scope-roots.d.ts

@@ -0,0 +1,8 @@
+export declare function resolveContainers(scope: string | undefined): {
+    containers: HTMLElement[];
+    scopeMissing: boolean;
+};
+export declare function hintRoots(scope: string | undefined): HTMLElement[];
+export declare function firstIn<T>(roots: HTMLElement[], find: (root: HTMLElement) => T | undefined): T | undefined;
+export declare function firstListIn<T>(roots: HTMLElement[], find: (root: HTMLElement) => T[]): T[];
+export declare function pageContent(el: Element, scope: string | undefined): boolean;

package/dist/dom/scope-roots.js

@@ -0,0 +1,44 @@
+import { isActionTarget } from './realm.js';
+import { refs } from './addressing/refs.js';
+export function resolveContainers(scope) {
+    let containers = [];
+    if (scope === undefined) {
+        containers = [document.documentElement];
+    }
+    else {
+        const byRef = refs.resolve(scope);
+        if (isActionTarget(byRef)) {
+            containers = [byRef];
+        }
+        else {
+            try {
+                containers = Array.from(document.querySelectorAll(scope)).filter(isActionTarget);
+            }
+            catch {
+            }
+        }
+    }
+    return { containers, scopeMissing: 0 === containers.length };
+}
+export function hintRoots(scope) {
+    const { containers } = resolveContainers(scope);
+    return containers.length > 0 ? containers : [document.body];
+}
+export function firstIn(roots, find) {
+    for (const root of roots) {
+        const found = find(root);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
+export function firstListIn(roots, find) {
+    return (firstIn(roots, (root) => {
+        const found = find(root);
+        return found.length > 0 ? found : undefined;
+    }) ?? []);
+}
+export function pageContent(el, scope) {
+    return scope !== undefined || !el.closest('head');
+}

package/dist/dom/snapshot.d.ts

@@ -1,5 +1,6 @@
 import { SnapshotMode } from '@reticlehq/core';
 import { type LayoutFinding } from './layout-audit.js';
+import { type ChartReading } from './chart-geometry.js';
 export declare const INTERACTIVE: Set<string>;
 interface SnapshotStatus {
     route: string;
@@ -14,6 +15,7 @@ interface SnapshotResult {
     truncated: boolean;
     scopeMissing?: boolean;
     audit?: LayoutFinding[];
+    charts?: ChartReading[];
     leanSkipped?: number;
     hiddenSkipped?: number;
     domElements?: number;
@@ -28,6 +30,7 @@ interface SnapshotOptions {
     includeRoot?: boolean | undefined;
     ids?: boolean | undefined;
     audit?: boolean | undefined;
+    charts?: boolean | undefined;
 }
 export declare const MAX_UNREAD_BRANCHES = 50;
 export declare function buildSnapshot(options?: SnapshotOptions): SnapshotResult;

package/dist/dom/snapshot.js

@@ -7,6 +7,7 @@ import { refs } from './addressing/refs.js';
 import { readTestId } from './addressing/testid-attr.js';
 import { identifyComponent } from '../registry/stores/adapters.js';
 import { auditLayout } from './layout-audit.js';
+import { readCharts } from './chart-geometry.js';
 import { pageRoute } from '../security/page-location.js';
 import { isIgnored, isReticleOverlay } from './dom-ignore.js';
 export const INTERACTIVE = new Set([
@@ -40,6 +41,10 @@ function directText(el) {
     const collapsed = (parts.own ? parts.text : '').replace(/\s+/g, ' ').trim();
     return collapsed.length > TEXT_MAX ? `${collapsed.slice(0, TEXT_MAX)}…` : collapsed;
 }
+const foldText = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+function textBesideName(own, name) {
+    return 0 < name.length && foldText(own) === foldText(name) ? '' : own;
+}
 function readingParts(el) {
     let text = '';
     let own = false;
@@ -193,7 +198,8 @@ function visit(child, depth, ctx, inLive) {
     const interactive = INTERACTIVE.has(role);
     const announce = inLive || announces(child, role);
     const lean = ctx.mode === SnapshotMode.INTERACTIVE && !announce;
-    const text = !lean && 0 === name.length ? directText(child) : '';
+    const ownText = lean || (interactive && 0 < name.length) ? '' : directText(child);
+    const text = textBesideName(ownText, name);
     const layout = lean ? '' : layoutSignature(style);
     const actionable = interactive;
     const meaningful = actionable || role !== 'generic' || name.length > 0 || text.length > 0 || layout.length > 0;
@@ -203,7 +209,7 @@ function visit(child, depth, ctx, inLive) {
     }
     if (include) {
         ctx.nodes += 1;
-        ctx.lines.push('generic' === role && text.length > 0 && 0 === layout.length
+        ctx.lines.push('generic' === role && 0 === name.length && text.length > 0 && 0 === layout.length
             ? formatTextLine(depth, text)
             : formatLine(child, depth, role, name, layout, text, true === ctx.ids));
         walk(child, depth + 1, ctx, announce);
@@ -352,5 +358,6 @@ export function buildSnapshot(options = {}) {
         ...(ctx.unread.length > 0 ? { unread: ctx.unread } : {}),
         ...(ctx.unreadOverflow ? { unreadOverflow: true } : {}),
         ...(true === options.audit ? { audit: auditLayout(root) } : {}),
+        ...(true === options.charts ? { charts: readCharts(root) } : {}),
     };
 }

package/dist/dom/text-match.js

@@ -3,14 +3,15 @@ import { stalledFade } from './visibility.js';
 export function normaliseVisibleText(value) {
     return value.replace(/\s+/g, ' ').trim().normalize('NFC');
 }
-const SINGLE_QUOTES = /[\u2018\u2019]/g;
-const DOUBLE_QUOTES = /[\u201c\u201d]/g;
+const SINGLE_QUOTES = /[\u2018-\u201b]/g;
+const DOUBLE_QUOTES = /[\u201c-\u201f]/g;
 const DASHES = /[\u2013\u2014]/g;
 export function foldTypography(value) {
     return value.replace(SINGLE_QUOTES, "'").replace(DOUBLE_QUOTES, '"').replace(DASHES, '-');
 }
+const INVISIBLE_FORMAT = /[\u00ad\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g;
 export function comparableText(value) {
-    return foldTypography(normaliseVisibleText(value));
+    return foldTypography(normaliseVisibleText(value.replace(INVISIBLE_FORMAT, '')));
 }
 export function fuzzyVisibleText(actual, expected) {
     return comparableText(actual).toLowerCase().includes(comparableText(expected).toLowerCase());

package/dist/dom/theme.js

@@ -34,19 +34,18 @@ export function tokenNames() {
     }
     return names;
 }
-function palette() {
+function palette(cs) {
     const byColor = new Map();
-    const root = document.body ?? document.documentElement;
-    if (null === root)
+    const host = document.body ?? document.documentElement;
+    if (null === host)
         return byColor;
-    const rootStyle = getComputedStyle(root);
     const probe = document.createElement('span');
     probe.style.position = 'absolute';
     probe.style.pointerEvents = 'none';
-    document.body.appendChild(probe);
+    host.appendChild(probe);
     try {
         for (const name of tokenNames()) {
-            const rgb = toRgb(probe, rootStyle.getPropertyValue(name).trim());
+            const rgb = toRgb(probe, cs.getPropertyValue(name).trim());
             if (null === rgb)
                 continue;
             const named = byColor.get(rgb);
@@ -90,7 +89,7 @@ function sole(names) {
     return 1 === names.length ? (names[0] ?? null) : null;
 }
 export function themeReport(cs) {
-    const byColor = palette();
+    const byColor = palette(cs);
     const colorTokens = byColor.get(cs.color) ?? [];
     const backgroundTokens = byColor.get(cs.backgroundColor) ?? [];
     const colorOff = !isTransparent(cs.color) && 0 === colorTokens.length;

package/dist/dom/visibility.d.ts

@@ -2,7 +2,9 @@ export declare const HTML_DETAILS_TAG = "details";
 export declare const HTML_DETAILS_OPEN_ATTRIBUTE = "open";
 export declare const HTML_SUMMARY_TAG = "summary";
 export declare function stalledFade(el: Element): boolean;
+export declare function isNonRendered(el: Element): boolean;
 export declare function isHiddenByAriaOnly(el: Element): boolean;
 export declare function isRenderedOutsideAriaHidden(el: Element): boolean;
 export declare function isInViewport(el: Element, memo?: Map<Element, boolean>): boolean;
+export declare function isHiddenSubtree(el: Element, memo?: Map<Element, boolean>): boolean;
 export declare function isVisible(el: Element, memo?: Map<Element, boolean>): boolean;