@reticlehq/browser 3.6.0 → 3.8.0

package/dist/dom/a11y.js

@@ -2,7 +2,8 @@ import { readTestId } from './addressing/testid-attr.js';
 import { DEFAULT_TESTID_ATTR, ElementState, REDACTED_VALUE, } from '@reticlehq/core';
 import { isButton, isHtmlElement, isImage, isInput, isMeter, isOutput, isProgress, isSelect, isTextArea, } from './realm.js';
 import { refs } from './addressing/refs.js';
-import { capturedRootOf } from './shadow-registry.js';
+import { parentAcrossShadowBoundary } from './shadow-registry.js';
+import { clippingBox, overflowAxes, scrolledInto, } from './paint-context.js';
 import { inspectChart } from './chart.js';
 import { isSensitiveKey } from '../security/serialization.js';
 import { formatSource, sourceFromDom } from './addressing/source.js';
@@ -35,36 +36,46 @@ const NAME_FROM_CONTENT = new Set([
 const INPUT_TEXT_TYPES = new Set(['text', 'email', 'tel', 'url', 'password', '']);
 function inputRole(input) {
     const type = input.type.toLowerCase();
-    if ('search' === type)
+    if ('search' === type) {
         return 'searchbox';
-    if (INPUT_TEXT_TYPES.has(type))
+    }
+    if (INPUT_TEXT_TYPES.has(type)) {
         return 'textbox';
-    if ('checkbox' === type)
+    }
+    if ('checkbox' === type) {
         return 'checkbox';
-    if ('radio' === type)
+    }
+    if ('radio' === type) {
         return 'radio';
-    if ('range' === type)
+    }
+    if ('range' === type) {
         return 'slider';
-    if ('number' === type)
+    }
+    if ('number' === type) {
         return 'spinbutton';
-    if ('submit' === type || 'button' === type || 'reset' === type)
+    }
+    if ('submit' === type || 'button' === type || 'reset' === type) {
         return 'button';
+    }
     return 'textbox';
 }
 function hasAuthorNaming(el) {
     const label = el.getAttribute('aria-label');
-    if (label !== null && label.trim().length > 0)
+    if (label !== null && label.trim().length > 0) {
         return true;
+    }
     const labelledby = el.getAttribute('aria-labelledby');
-    if (labelledby !== null && labelledby.trim().length > 0)
+    if (labelledby !== null && labelledby.trim().length > 0) {
         return true;
+    }
     const title = el.getAttribute('title');
     return title !== null && title.trim().length > 0;
 }
 export function getRole(el) {
     const explicit = el.getAttribute('role');
-    if (explicit !== null && explicit.trim().length > 0)
+    if (explicit !== null && explicit.trim().length > 0) {
         return explicit.trim();
+    }
     const tag = el.tagName.toLowerCase();
     switch (tag) {
         case 'a':
@@ -154,25 +165,30 @@ function collapse(text) {
 }
 function labelledByText(el) {
     const ids = el.getAttribute('aria-labelledby');
-    if (null === ids)
+    if (null === ids) {
         return null;
+    }
     const parts = [];
     for (const id of ids.split(/\s+/)) {
         const ref = el.ownerDocument.getElementById(id);
-        if (ref !== null)
+        if (ref !== null) {
             parts.push(collapse(textWithoutHidden(ref)));
+        }
     }
     const joined = parts.join(' ').trim();
     return joined.length > 0 ? joined : null;
 }
 function textWithoutHidden(node) {
-    if (node.nodeType === Node.TEXT_NODE)
+    if (node.nodeType === Node.TEXT_NODE) {
         return node.textContent ?? '';
-    if (node.nodeType !== Node.ELEMENT_NODE)
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
         return '';
+    }
     const el = node;
-    if ('true' === el.getAttribute('aria-hidden'))
+    if ('true' === el.getAttribute('aria-hidden')) {
         return '';
+    }
     if (isImage(el)) {
         const alt = el.getAttribute('alt');
         return null === alt ? '' : alt;
@@ -181,11 +197,13 @@ function textWithoutHidden(node) {
     let lastWasElement = false;
     for (const child of el.childNodes) {
         const piece = textWithoutHidden(child);
-        if (0 === piece.length)
+        if (0 === piece.length) {
             continue;
+        }
         const isEl = Node.ELEMENT_NODE === child.nodeType;
-        if (result.length > 0 && (isEl || lastWasElement))
+        if (result.length > 0 && (isEl || lastWasElement)) {
             result += ' ';
+        }
         result += piece;
         lastWasElement = isEl;
     }
@@ -193,15 +211,18 @@ function textWithoutHidden(node) {
 }
 export function getAccessibleName(el) {
     const labelled = labelledByText(el);
-    if (labelled !== null)
+    if (labelled !== null) {
         return labelled;
+    }
     const ariaLabel = el.getAttribute('aria-label');
-    if (ariaLabel !== null && ariaLabel.trim().length > 0)
+    if (ariaLabel !== null && ariaLabel.trim().length > 0) {
         return ariaLabel.trim();
+    }
     if (isImage(el)) {
         const alt = el.getAttribute('alt');
-        if (alt !== null)
+        if (alt !== null) {
             return alt.trim();
+        }
     }
     const isLabelable = isInput(el) ||
         isTextArea(el) ||
@@ -217,16 +238,36 @@ export function getAccessibleName(el) {
                 .map((l) => collapse(textWithoutHidden(l)))
                 .join(' ')
                 .trim();
-            if (text.length > 0)
+            if (text.length > 0) {
                 return text;
+            }
         }
     }
     if ('fieldset' === el.tagName.toLowerCase()) {
         const legend = [...el.children].find((child) => 'legend' === child.tagName.toLowerCase());
         if (legend !== undefined) {
             const text = collapse(textWithoutHidden(legend));
-            if (text.length > 0)
+            if (text.length > 0) {
                 return text;
+            }
+        }
+    }
+    if ('table' === el.tagName.toLowerCase()) {
+        const caption = [...el.children].find((child) => 'caption' === child.tagName.toLowerCase());
+        if (caption !== undefined) {
+            const text = collapse(textWithoutHidden(caption));
+            if (text.length > 0) {
+                return text;
+            }
+        }
+    }
+    if ('figure' === el.tagName.toLowerCase()) {
+        const figcaption = [...el.children].find((child) => 'figcaption' === child.tagName.toLowerCase());
+        if (figcaption !== undefined) {
+            const text = collapse(textWithoutHidden(figcaption));
+            if (text.length > 0) {
+                return text;
+            }
         }
     }
     if (isInput(el) || isTextArea(el) || isSelect(el)) {
@@ -234,49 +275,68 @@ export function getAccessibleName(el) {
             const type = el.type.toLowerCase();
             if ('submit' === type || 'button' === type || 'reset' === type) {
                 const value = collapse(el.value);
-                if (value.length > 0)
+                if (value.length > 0) {
                     return value;
+                }
             }
         }
         if (isInput(el) || isTextArea(el)) {
             const placeholder = el.getAttribute('placeholder');
-            if (placeholder !== null && placeholder.trim().length > 0)
+            if (placeholder !== null && placeholder.trim().length > 0) {
                 return placeholder.trim();
+            }
         }
     }
     if (NAME_FROM_CONTENT.has(getRole(el))) {
         const text = collapse(textWithoutHidden(el));
-        if (text.length > 0)
+        if (text.length > 0) {
             return text;
+        }
     }
     const title = el.getAttribute('title');
-    if (title !== null && title.trim().length > 0)
+    if (title !== null && title.trim().length > 0) {
         return title.trim();
+    }
     return '';
 }
 function ariaBool(el, attr) {
     const value = el.getAttribute(attr);
-    if (null === value)
+    if (null === value) {
         return undefined;
+    }
     return 'true' === value;
 }
 export function getStates(el, visible = isVisible(el)) {
     const states = [ElementState.PRESENT];
     states.push(visible ? ElementState.VISIBLE : ElementState.HIDDEN);
-    const disabledProp = (isButton(el) || isInput(el) || isSelect(el) || isTextArea(el)) && el.disabled;
-    const disabled = disabledProp || true === ariaBool(el, 'aria-disabled');
+    const disabled = el.matches(':disabled') || true === ariaBool(el, 'aria-disabled');
     states.push(disabled ? ElementState.DISABLED : ElementState.ENABLED);
     const checkedProp = isInput(el) && ('checkbox' === el.type || 'radio' === el.type) && el.checked;
-    if (checkedProp || true === ariaBool(el, 'aria-checked'))
+    if (checkedProp || true === ariaBool(el, 'aria-checked')) {
         states.push(ElementState.CHECKED);
-    if (true === ariaBool(el, 'aria-expanded'))
+    }
+    if (true === ariaBool(el, 'aria-expanded') || isOpenDetailsSummary(el)) {
         states.push(ElementState.EXPANDED);
-    if (true === ariaBool(el, 'aria-pressed'))
+    }
+    if (true === ariaBool(el, 'aria-pressed')) {
         states.push(ElementState.PRESSED);
-    if (el.ownerDocument.activeElement === el)
+    }
+    if (el.ownerDocument.activeElement === el) {
         states.push(ElementState.FOCUSED);
+    }
     return states;
 }
+function isOpenDetailsSummary(el) {
+    const details = el.parentElement;
+    if (HTML_SUMMARY_TAG !== el.localName ||
+        null === details ||
+        HTML_DETAILS_TAG !== details.localName) {
+        return false;
+    }
+    const summary = Array.from(details.children).find((child) => HTML_SUMMARY_TAG === child.localName);
+    return summary === el && details.hasAttribute(HTML_DETAILS_OPEN_ATTRIBUTE);
+}
+const SENSITIVE_AUTOCOMPLETE = /\b(cc-|current-password|new-password|one-time-code)/i;
 export function isSensitiveField(el) {
     if (!isInput(el) && !isTextArea(el) && !isSelect(el)) {
         return false;
@@ -289,15 +349,16 @@ export function isSensitiveField(el) {
         el.getAttribute(DEFAULT_TESTID_ATTR) ?? '',
         el.getAttribute('aria-label') ?? '',
     ];
-    const sensitiveAutocomplete = /current-password|new-password|cc-number|cc-csc|one-time-code/i.test(autocomplete);
+    const sensitiveAutocomplete = SENSITIVE_AUTOCOMPLETE.test(autocomplete);
     return ((isInput(el) && 'password' === el.type.toLowerCase()) ||
         sensitiveAutocomplete ||
         identifiers.some(isSensitiveKey));
 }
 export function getValue(el) {
     if (isInput(el) || isTextArea(el) || isSelect(el)) {
-        if (isSensitiveField(el))
-            return REDACTED_VALUE;
+        if (isSensitiveField(el)) {
+            return '' === el.value ? '' : REDACTED_VALUE;
+        }
         return el.value;
     }
     const valueNow = el.getAttribute('aria-valuenow');
@@ -305,82 +366,290 @@ export function getValue(el) {
 }
 function hiddenInsideClosedDetails(el) {
     const parent = el.parentElement;
-    if (null === parent)
+    if (null === parent) {
         return false;
+    }
     const details = parent.closest(HTML_DETAILS_TAG);
-    if (null === details || details.hasAttribute(HTML_DETAILS_OPEN_ATTRIBUTE))
+    if (null === details || details.hasAttribute(HTML_DETAILS_OPEN_ATTRIBUTE)) {
         return false;
+    }
     const summary = Array.from(details.children).find((child) => HTML_SUMMARY_TAG === child.localName);
     return summary === undefined || !summary.contains(el);
 }
 function stalledFade(el) {
-    if (!el.ownerDocument.hidden || !('getAnimations' in el))
+    if (!el.ownerDocument.hidden || !('getAnimations' in el)) {
         return false;
+    }
     return el.getAnimations().some((a) => 'running' === a.playState || a.pending);
 }
-function selfHidden(el) {
-    if ('true' === el.getAttribute('aria-hidden'))
-        return true;
-    if (isHtmlElement(el) && el.hidden)
+const OVERLAY_ARIA_HIDDEN = 'data-aria-hidden';
+function hiddenByAnOverlay(el) {
+    return el.hasAttribute(OVERLAY_ARIA_HIDDEN);
+}
+function selfCssHidden(el, style) {
+    if (isHtmlElement(el) && el.hidden) {
         return true;
-    if (hiddenInsideClosedDetails(el))
+    }
+    if (hiddenInsideClosedDetails(el)) {
         return true;
-    const view = el.ownerDocument.defaultView;
-    if (view !== null) {
-        const style = view.getComputedStyle(el);
+    }
+    if (style !== null) {
         if ('none' === style.display ||
             'hidden' === style.visibility ||
             'collapse' === style.visibility) {
             return true;
         }
-        if (0 === Number.parseFloat(style.opacity || '1') && !stalledFade(el))
+        if (0 === Number.parseFloat(style.opacity || '1') && !stalledFade(el)) {
             return true;
+        }
     }
     return false;
 }
-function slotInCapturedClosedRoot(el) {
-    const host = el.parentElement;
-    if (null === host || null !== host.shadowRoot)
-        return null;
-    const root = capturedRootOf(host);
-    if (null === root)
-        return null;
-    for (const slot of Array.from(root.querySelectorAll('slot'))) {
-        if (slot.assignedElements().includes(el))
-            return slot;
+function selfHidden(el, style) {
+    if ('true' === el.getAttribute('aria-hidden') && !hiddenByAnOverlay(el)) {
+        return true;
+    }
+    return selfCssHidden(el, style);
+}
+export function isHiddenByAriaOnly(el) {
+    let foundAriaHidden = false;
+    let current = el;
+    while (null !== current) {
+        if ('true' === current.getAttribute('aria-hidden')) {
+            foundAriaHidden = true;
+        }
+        const style = current.ownerDocument.defaultView?.getComputedStyle(current) ?? null;
+        if (selfCssHidden(current, style)) {
+            return false;
+        }
+        current = parentAcrossShadowBoundary(current);
+    }
+    return foundAriaHidden;
+}
+export function isRenderedOutsideAriaHidden(el) {
+    let current = el;
+    while (null !== current) {
+        if ('true' === current.getAttribute('aria-hidden')) {
+            return false;
+        }
+        const style = current.ownerDocument.defaultView?.getComputedStyle(current) ?? null;
+        if (selfCssHidden(current, style)) {
+            return false;
+        }
+        current = parentAcrossShadowBoundary(current);
+    }
+    return true;
+}
+const CLIPPING_OVERFLOW = new Set(['hidden', 'clip']);
+const SCROLLING_OVERFLOW = new Set(['auto', 'scroll']);
+const NON_CLIPPING_DISPLAY = new Set([
+    'contents',
+    'table-row',
+    'table-row-group',
+    'table-header-group',
+    'table-footer-group',
+    'table-column',
+    'table-column-group',
+]);
+const TRANSFORM_CONTAINING_BLOCK_PROPERTIES = new Set([
+    'transform',
+    'translate',
+    'rotate',
+    'scale',
+    'perspective',
+]);
+const CONTAINING_BLOCK_PROPERTIES = new Set([
+    ...TRANSFORM_CONTAINING_BLOCK_PROPERTIES,
+    'filter',
+    'backdrop-filter',
+]);
+const CONTAINING_BLOCK_CONTAIN = new Set(['layout', 'paint', 'strict', 'content']);
+const REPLACED_INLINE_TAGS = new Set([
+    'img',
+    'video',
+    'audio',
+    'canvas',
+    'iframe',
+    'embed',
+    'object',
+    'input',
+    'textarea',
+    'select',
+]);
+const visibilityInfoMemos = new WeakMap();
+function visibilityInfoMemo(memo) {
+    if (memo === undefined) {
+        return new Map();
+    }
+    let info = visibilityInfoMemos.get(memo);
+    if (info === undefined) {
+        info = new Map();
+        visibilityInfoMemos.set(memo, info);
+    }
+    return info;
+}
+function ownVisibilityInfo(el, memo) {
+    let info = memo.get(el);
+    if (info === undefined) {
+        const style = el.ownerDocument.defaultView?.getComputedStyle(el) ?? null;
+        if (selfHidden(el, style)) {
+            info = {
+                hidden: true,
+                style,
+                parent: null,
+                clipX: false,
+                clipY: false,
+                scrollX: false,
+                scrollY: false,
+                hasClipping: false,
+            };
+            memo.set(el, info);
+            return info;
+        }
+        const parent = parentAcrossShadowBoundary(el);
+        const inherited = null === parent ? undefined : ownVisibilityInfo(parent, memo);
+        const [overflowX, overflowY] = overflowAxes(style);
+        const root = el.ownerDocument.documentElement;
+        const viewportOverflow = el === root ||
+            (el === el.ownerDocument.body &&
+                overflowAxes(ownVisibilityInfo(root, memo).style).every((axis) => 'visible' === axis));
+        const hasClipBox = !viewportOverflow &&
+            !NON_CLIPPING_DISPLAY.has(style?.display ?? '') &&
+            !(isHtmlElement(el) && 'inline' === style?.display);
+        const clipX = hasClipBox && CLIPPING_OVERFLOW.has(overflowX);
+        const clipY = hasClipBox && CLIPPING_OVERFLOW.has(overflowY);
+        info = {
+            hidden: true === inherited?.hidden,
+            style,
+            parent,
+            clipX,
+            clipY,
+            scrollX: hasClipBox && SCROLLING_OVERFLOW.has(overflowX),
+            scrollY: hasClipBox && SCROLLING_OVERFLOW.has(overflowY),
+            hasClipping: clipX || clipY || true === inherited?.hasClipping,
+        };
+        memo.set(el, info);
+    }
+    return info;
+}
+function positionedContainingBlock(el, fixed, memo) {
+    for (let parent = ownVisibilityInfo(el, memo).parent; parent !== null; parent = ownVisibilityInfo(parent, memo).parent) {
+        const style = ownVisibilityInfo(parent, memo).style;
+        if (null === style || 'contents' === style.display) {
+            continue;
+        }
+        if (!fixed && '' !== style.position && 'static' !== style.position) {
+            return parent;
+        }
+        const transformable = !('inline' === style.display &&
+            isHtmlElement(parent) &&
+            !REPLACED_INLINE_TAGS.has(parent.localName)) &&
+            'table-column' !== style.display &&
+            'table-column-group' !== style.display;
+        const applies = (property) => transformable || !TRANSFORM_CONTAINING_BLOCK_PROPERTIES.has(property);
+        if ([...CONTAINING_BLOCK_PROPERTIES].some((property) => {
+            const value = style.getPropertyValue(property);
+            return applies(property) && '' !== value && 'none' !== value;
+        }) ||
+            style.willChange
+                .split(',')
+                .some((property) => CONTAINING_BLOCK_PROPERTIES.has(property.trim()) && applies(property.trim())) ||
+            (transformable &&
+                !NON_CLIPPING_DISPLAY.has(style.display) &&
+                (style.contain.split(/\s+/).some((value) => CONTAINING_BLOCK_CONTAIN.has(value)) ||
+                    'auto' === style.contentVisibility))) {
+            return parent;
+        }
     }
     return null;
 }
-function parentAcrossShadowBoundary(el) {
-    const slot = el.assignedSlot ?? slotInCapturedClosedRoot(el);
-    if (null !== slot)
-        return slot;
-    if (null !== el.parentElement)
-        return el.parentElement;
-    const host = el.getRootNode().host;
-    return host ?? null;
+function visibleBounds(el, memo, initial, throughScrollers = false) {
+    let bounds = initial;
+    const target = ownVisibilityInfo(el, memo);
+    if (target.hidden) {
+        return null;
+    }
+    if (null === target.parent || !ownVisibilityInfo(target.parent, memo).hasClipping) {
+        return bounds;
+    }
+    let clipFrom;
+    for (let current = el; current !== null; current = ownVisibilityInfo(current, memo).parent) {
+        const info = ownVisibilityInfo(current, memo);
+        if (info.hidden) {
+            return null;
+        }
+        if (current === clipFrom) {
+            clipFrom = undefined;
+        }
+        const style = info.style;
+        if (throughScrollers &&
+            current !== el &&
+            undefined === clipFrom &&
+            (info.scrollX || info.scrollY)) {
+            bounds ??= el.getBoundingClientRect();
+            if (bounds.width > 0 && bounds.height > 0) {
+                bounds = scrolledInto(bounds, clippingBox(current, info), info.scrollX, info.scrollY);
+            }
+        }
+        if (current !== el && undefined === clipFrom && (info.clipX || info.clipY)) {
+            bounds ??= el.getBoundingClientRect();
+            if (bounds.width > 0 && bounds.height > 0) {
+                const clip = clippingBox(current, info);
+                const left = info.clipX ? Math.max(bounds.left, clip.left) : bounds.left;
+                const right = info.clipX ? Math.min(bounds.right, clip.right) : bounds.right;
+                const top = info.clipY ? Math.max(bounds.top, clip.top) : bounds.top;
+                const bottom = info.clipY ? Math.min(bounds.bottom, clip.bottom) : bounds.bottom;
+                if (right <= left || bottom <= top) {
+                    return null;
+                }
+                bounds = { left, right, top, bottom, width: right - left, height: bottom - top };
+            }
+        }
+        if (clipFrom === undefined && ('absolute' === style?.position || 'fixed' === style?.position)) {
+            clipFrom = positionedContainingBlock(current, 'fixed' === style?.position, memo);
+        }
+    }
+    return bounds;
 }
 export function isInViewport(el, memo) {
-    if (!isVisible(el, memo))
+    if (!isVisible(el, memo)) {
         return false;
+    }
     const view = el.ownerDocument.defaultView;
-    if (null === view)
+    if (null === view) {
+        return false;
+    }
+    const r = visibleBounds(el, visibilityInfoMemo(memo), el.getBoundingClientRect());
+    if (null === r || undefined === r) {
         return false;
-    const r = el.getBoundingClientRect();
-    if (r.width <= 0 || r.height <= 0)
+    }
+    if (r.width <= 0 || r.height <= 0) {
         return false;
+    }
     return r.bottom > 0 && r.right > 0 && r.top < view.innerHeight && r.left < view.innerWidth;
 }
+function collapsed(el, memo) {
+    const own = ownVisibilityInfo(el, memo);
+    if (!own.clipX && !own.clipY) {
+        return false;
+    }
+    const rects = Array.from(el.getClientRects());
+    return (rects.length > 0 &&
+        rects.every((r) => (own.clipX && 0 === r.width) || (own.clipY && 0 === r.height)));
+}
 export function isVisible(el, memo) {
-    if (!el.isConnected)
+    if (!el.isConnected) {
         return false;
+    }
     const cached = memo?.get(el);
-    if (cached !== undefined)
+    if (cached !== undefined) {
         return cached;
-    const parent = parentAcrossShadowBoundary(el);
-    const result = !selfHidden(el) && (null === parent || isVisible(parent, memo));
-    if (memo !== undefined)
+    }
+    const info = visibilityInfoMemo(memo);
+    const result = visibleBounds(el, info, undefined, true) !== null && !collapsed(el, info);
+    if (memo !== undefined) {
         memo.set(el, result);
+    }
     return result;
 }
 const MAX_TEXT = 80;
@@ -400,17 +669,21 @@ export function describe(el, memo) {
         states: getStates(el, visible),
         visible,
     };
-    if (value !== undefined && value.length > 0)
+    if (value !== undefined && value.length > 0) {
         base.value = value;
-    if (text.length > 0 && text !== name)
+    }
+    if (text.length > 0 && text !== name) {
         base.text = text;
+    }
     const source = formatSource(sourceFromDom(el));
-    if (source !== undefined)
+    if (source !== undefined) {
         base.source = source;
+    }
     if (el.querySelector('path, polyline, polygon') !== null) {
         const faults = inspectChart(el).findings;
-        if (faults.length > 0)
+        if (faults.length > 0) {
             base.chart = faults;
+        }
     }
     return base;
 }

package/dist/dom/addressing/coverage-markers.d.ts

@@ -0,0 +1,6 @@
+export declare function coverageMarkers(doc: Document): string[];
+export declare function notApplicableFor(page: {
+    buildPlugin: boolean;
+    adapters: readonly string[];
+    markers: readonly string[];
+}): string[];

package/dist/dom/addressing/coverage-markers.js

@@ -0,0 +1,13 @@
+import { CoverageMarker, SOURCE_MAPPING_CAPABILITY, DATA_RETICLE_SOURCE_ATTR, RETICLE_OVERLAY_SELECTOR, } from '@reticlehq/core';
+import { testIdSelector } from './testid-attr.js';
+const appCarries = (doc, selector) => Array.from(doc.querySelectorAll(selector)).some((el) => null === el.closest(RETICLE_OVERLAY_SELECTOR));
+export function coverageMarkers(doc) {
+    return [
+        ...(appCarries(doc, `[${DATA_RETICLE_SOURCE_ATTR}]`) ? [CoverageMarker.SOURCE] : []),
+        ...(appCarries(doc, testIdSelector()) ? [CoverageMarker.TESTID] : []),
+    ];
+}
+export function notApplicableFor(page) {
+    const couldStamp = page.buildPlugin || 0 < page.adapters.length || page.markers.includes(CoverageMarker.SOURCE);
+    return couldStamp ? [] : [SOURCE_MAPPING_CAPABILITY];
+}

package/dist/dom/chart.d.ts

@@ -17,7 +17,7 @@ export interface CanvasChartData {
     library: 'chartjs' | 'echarts';
     data: unknown;
 }
-export declare function canvasChartData(canvas: Element, globals: {
+export interface ChartGlobals {
     Chart?: {
         getChart?: (el: Element) => {
             data?: unknown;
@@ -28,4 +28,5 @@ export declare function canvasChartData(canvas: Element, globals: {
             getOption?: () => unknown;
         } | undefined;
     };
-}): CanvasChartData | null;
+}
+export declare function canvasChartData(canvas: Element, globals: ChartGlobals | Window): CanvasChartData | null;