@reticlehq/browser 3.8.2 → 3.10.0

package/dist/dom/query.js

@@ -1,20 +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);
@@ -25,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;
         }
@@ -39,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;
@@ -66,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('*')) {
@@ -94,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 = [];
@@ -116,6 +105,9 @@ function findCandidates(query) {
             if (seen.has(el)) {
                 continue;
             }
+            if (!pageContent(el, query.scope)) {
+                continue;
+            }
             if (ignored(el)) {
                 continue;
             }
@@ -123,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;
@@ -142,27 +136,51 @@ 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;
-export function matchQuery(query, state, limit = MAX_DESCRIBED, wholePhrase = true, diagnose = true) {
+export function matchQuery(query, state, limit = MAX_DESCRIBED, wholePhrase = true, diagnose = true, fullText = false) {
     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));
     const attrs = query.attrs;
-    const described = filtered.slice(0, Math.max(0, Math.min(limit, MAX_DESCRIBED)));
+    const cap = fullText
+        ? Math.min(MAX_DESCRIBED, TRANSPORT_LIMITS.MAX_FULL_TEXT_ELEMENTS)
+        : MAX_DESCRIBED;
+    const described = filtered.slice(0, Math.max(0, Math.min(limit, cap)));
     const stampViewport = described.length > 1 || ElementState.IN_VIEWPORT === state;
     const descriptors = described.map((el) => {
-        let base = describe(el, visMemo);
+        let base = describe(el, visMemo, fullText);
         if (stampViewport &&
             isInViewport(el, visMemo) &&
             !base.states.includes(ElementState.IN_VIEWPORT)) {
@@ -180,7 +198,9 @@ export function matchQuery(query, state, limit = MAX_DESCRIBED, wholePhrase = tr
         matched: filtered.length > 0,
         count: filtered.length,
         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) } : {}),
@@ -199,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',
@@ -220,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;
@@ -264,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;
         }
@@ -278,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;
@@ -288,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) {
@@ -346,6 +372,81 @@ function nameNearMisses(container, query) {
     }
     return out;
 }
+const MAX_NEAREST_TARGETS = 3;
+export const MAX_NEAREST_NAME = 60;
+function bigrams(value) {
+    const padded = ` ${value} `;
+    const out = new Set();
+    for (let i = 0; i < padded.length - 1; i += 1) {
+        out.add(padded.slice(i, i + 2));
+    }
+    return out;
+}
+export function nameSimilarity(a, b) {
+    const left = bigrams(foldTypography(a).toLowerCase());
+    const right = bigrams(foldTypography(b).toLowerCase());
+    let shared = 0;
+    for (const gram of left) {
+        if (right.has(gram)) {
+            shared += 1;
+        }
+    }
+    return (2 * shared) / (left.size + right.size);
+}
+function askedRole(query) {
+    return QueryBy.ROLE === query.by ? query.value : query.role;
+}
+function askedName(query) {
+    const value = QueryBy.ROLE === query.by ? undefined : query.value;
+    const asked = query.name ??
+        value ??
+        query.text ??
+        query.label ??
+        query.placeholder ??
+        query.testid ??
+        query.alt;
+    return asked === undefined ? '' : normaliseVisibleText(asked);
+}
+export function nearestTargets(container, query) {
+    const role = askedRole(query);
+    const name = askedName(query);
+    if (role === undefined && 0 === name.length) {
+        return [];
+    }
+    const memo = new Map();
+    const scored = [];
+    for (const el of elementsUnder(container)) {
+        const elRole = getRole(el);
+        const roleMatch = role !== undefined && elRole === role;
+        if (!roleMatch && !INTERACTIVE.has(elRole)) {
+            continue;
+        }
+        if (isIgnored(el) || !isVisible(el, memo)) {
+            continue;
+        }
+        const elName = normaliseVisibleText(getAccessibleName(el));
+        if (0 === elName.length) {
+            continue;
+        }
+        const score = 0 === name.length ? 0 : nameSimilarity(name, elName);
+        if (!roleMatch && 0 === score) {
+            continue;
+        }
+        scored.push({ el, role: elRole, name: elName, roleMatch, score });
+    }
+    scored.sort((a, b) => Number(b.roleMatch) - Number(a.roleMatch) || b.score - a.score);
+    return scored.slice(0, MAX_NEAREST_TARGETS).map((c) => {
+        const target = {
+            ref: refs.refFor(c.el),
+            role: c.role,
+            name: c.name.slice(0, MAX_NEAREST_NAME),
+        };
+        if (c.name.length > MAX_NEAREST_NAME) {
+            target.nameTruncated = true;
+        }
+        return target;
+    });
+}
 function testidFoundUnder(container, query) {
     if (QueryBy.TESTID !== query.by || undefined === query.value) {
         return undefined;
@@ -394,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;
@@ -423,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;
             }
@@ -440,18 +544,22 @@ 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 ? firstListIn(roots, (root) => nearestTargets(root, query)) : [];
+    if (nearest.length > 0) {
+        hint.nearest = nearest;
+    }
     return hint;
 }
 export function elementsMatching(query) {
@@ -459,12 +567,15 @@ 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,
             count: result.count,
-            hint: buildEmptyHint(query),
+            hint: result.hint ?? buildEmptyHint(query),
             ...scopeFields,
         };
     }

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

@@ -1,15 +1,17 @@
 import { parentAcrossShadowBoundary } from './shadow-registry.js';
+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());
@@ -81,7 +83,7 @@ export function unreadableText(el) {
     let opaque = false;
     for (let node = el; null !== node; node = parentAcrossShadowBoundary(node)) {
         const style = view.getComputedStyle(node);
-        const alpha = Number.parseFloat(style.opacity);
+        const alpha = stalledFade(node) ? 1 : Number.parseFloat(style.opacity);
         opacity *= Number.isNaN(alpha) ? 1 : alpha;
         if (opaque) {
             continue;

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

@@ -1,7 +1,10 @@
 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;