@reticlehq/browser 3.7.0 → 3.8.1

package/dist/actions/action-report.d.ts

@@ -13,9 +13,14 @@ export interface ActionEffect {
     occluded: boolean;
     occludedBy: string | null;
     scrolledIntoView: boolean;
+    occluderName?: string;
+    noSize?: true;
+    offViewport?: true;
     heldMs?: number;
     alreadyAtValue?: true;
+    canvases?: number;
 }
+export declare function visibleCanvases(doc: Document): number;
 export interface ActionResult {
     ok: true;
     ref: string;
@@ -25,6 +30,7 @@ export interface ActionResult {
     settleReason: SettleReason | null;
     effect: ActionEffect;
     testid?: string;
+    testidOf?: number;
     component?: string;
     role?: string;
     name?: string;
@@ -35,10 +41,13 @@ export interface ActionResult {
         line: number;
         column?: number;
     };
+    secret?: true;
     warning?: string;
+    reticleUi?: true;
 }
 export interface CapturedAnchor {
     testid?: string;
+    testidOf?: number;
     component?: string;
     source?: {
         file: string;
@@ -49,6 +58,7 @@ export interface CapturedAnchor {
     name?: string;
     nth?: number;
     of?: number;
+    secret?: true;
 }
 export declare function anchorOf(el: Element): CapturedAnchor;
 export declare const result: (ref: string, action: string, effect: ActionEffect, settled: boolean, settleReason: SettleReason | null, anchor: CapturedAnchor, warning?: string) => ActionResult;

package/dist/actions/action-report.js

@@ -1,25 +1,56 @@
 import { readTestId } from '../dom/addressing/testid-attr.js';
 import { QueryBy } from '@reticlehq/core';
 import { elementsMatching } from '../dom/query.js';
-import { getAccessibleName, getRole } from '../dom/a11y.js';
+import { getAccessibleName, getRole, isSensitiveField } from '../dom/a11y.js';
 import { identifyComponent } from '../registry/stores/adapters.js';
+import { isReticleUi } from '../dom/dom-ignore.js';
+const CANVAS_SELECTOR = 'canvas';
+export function visibleCanvases(doc) {
+    const width = doc.defaultView?.innerWidth ?? 0;
+    const height = doc.defaultView?.innerHeight ?? 0;
+    let count = 0;
+    for (const canvas of doc.querySelectorAll(CANVAS_SELECTOR)) {
+        if (isReticleUi(canvas)) {
+            continue;
+        }
+        const box = canvas.getBoundingClientRect();
+        const sized = box.width > 0 && box.height > 0;
+        const onScreen = box.bottom > 0 && box.right > 0 && box.top < height && box.left < width;
+        if (sized && onScreen) {
+            count += 1;
+        }
+    }
+    return count;
+}
 export function anchorOf(el) {
     const testid = readTestId(el) ?? undefined;
     const info = identifyComponent(el);
     const out = {};
-    if (testid !== undefined)
+    if (testid !== undefined) {
         out.testid = testid;
+        const shared = elementsMatching({ by: QueryBy.TESTID, value: testid }).length;
+        if (1 < shared) {
+            out.testidOf = shared;
+        }
+    }
     const component = info?.componentStack[0];
-    if (component !== undefined)
+    if (component !== undefined) {
         out.component = component;
-    if (info?.source !== undefined)
+    }
+    if (info?.source !== undefined) {
         out.source = info.source;
+    }
     const role = getRole(el);
     const name = getAccessibleName(el);
-    if (role.length > 0)
+    if (role.length > 0) {
         out.role = role;
-    if (name.length > 0)
+    }
+    if (name.length > 0) {
         out.name = name;
+    }
+    if (isSensitiveField(el)) {
+        out.secret = true;
+    }
     if (role.length > 0 && name.length > 0) {
         const same = elementsMatching({ by: QueryBy.ROLE, value: role, name });
         const at = same.indexOf(el);
@@ -40,21 +71,35 @@ export const result = (ref, action, effect, settled, settleReason, anchor, warni
         settleReason,
         effect,
     };
-    if (anchor.testid !== undefined)
+    if (anchor.testid !== undefined) {
         base.testid = anchor.testid;
-    if (anchor.component !== undefined)
+    }
+    if (anchor.testidOf !== undefined) {
+        base.testidOf = anchor.testidOf;
+    }
+    if (anchor.component !== undefined) {
         base.component = anchor.component;
-    if (anchor.source !== undefined)
+    }
+    if (anchor.source !== undefined) {
         base.source = anchor.source;
-    if (anchor.role !== undefined)
+    }
+    if (anchor.role !== undefined) {
         base.role = anchor.role;
-    if (anchor.name !== undefined)
+    }
+    if (anchor.name !== undefined) {
         base.name = anchor.name;
-    if (anchor.nth !== undefined)
+    }
+    if (anchor.nth !== undefined) {
         base.nth = anchor.nth;
-    if (anchor.of !== undefined)
+    }
+    if (anchor.of !== undefined) {
         base.of = anchor.of;
-    if (warning !== undefined)
+    }
+    if (anchor.secret !== undefined) {
+        base.secret = anchor.secret;
+    }
+    if (warning !== undefined) {
         base.warning = warning;
+    }
     return base;
 };

package/dist/actions/actions-dom.d.ts

@@ -3,6 +3,9 @@ interface ClickGeometry {
     occluded: boolean;
     occludedBy: string | null;
     scrolledIntoView: boolean;
+    occluderName?: string;
+    noSize?: true;
+    offViewport?: true;
 }
 export declare const NO_GEOMETRY: ClickGeometry;
 export declare function mouseEventFor(el: Element, type: string, init?: MouseEventInit): MouseEvent;
@@ -14,6 +17,7 @@ export declare function fireClickSequence(el: ActionTarget, hold?: {
     prevented: boolean;
     heldMs: number;
 }>;
+export declare function isOffViewport(el: Element, rect: DOMRect): boolean;
 export declare function clickGeometry(el: ActionTarget): ClickGeometry;
 export declare function firePointer(el: Element, type: string, relatedTarget?: EventTarget | null): void;
 export declare function firePointerNonBubbling(el: Element, type: string, relatedTarget?: EventTarget | null): void;

package/dist/actions/actions-dom.js

@@ -1,4 +1,6 @@
 import { refs } from '../dom/addressing/refs.js';
+import { readTestId } from '../dom/addressing/testid-attr.js';
+import { getAccessibleName, getRole } from '../dom/a11y.js';
 import { hitTestOccluder } from '../dom/occlusion.js';
 import { nativeFrame } from '../timers/native/native-timers.js';
 import { asSyntheticInput } from './synthetic/synthetic-input.js';
@@ -58,7 +60,7 @@ export async function fireClickSequence(el, hold, detail) {
 function isMeasurable(rect) {
     return rect.width > 0 || rect.height > 0;
 }
-function isOffViewport(el, rect) {
+export function isOffViewport(el, rect) {
     const win = el.ownerDocument.defaultView;
     if (null === win)
         return false;
@@ -70,21 +72,35 @@ function hitTest(el, rect) {
     const top = hitTestOccluder(el, rect);
     return null === top
         ? { occluded: false, occludedBy: null }
-        : { occluded: true, occludedBy: refs.refFor(top) };
+        : { occluded: true, occludedBy: refs.refFor(top), occluderName: nameOf(top) };
+}
+function nameOf(el) {
+    const testid = readTestId(el);
+    if (testid !== null && testid.length > 0)
+        return `[data-testid="${testid}"]`;
+    const name = getAccessibleName(el).trim();
+    return name.length > 0 ? `${getRole(el)} "${name.slice(0, 40)}"` : el.tagName.toLowerCase();
+}
+function hasNoSize(el) {
+    if (typeof el.getClientRects !== 'function')
+        return false;
+    const rects = Array.from(el.getClientRects());
+    return rects.length > 0 && rects.every((r) => 0 === r.width || 0 === r.height);
 }
 export function clickGeometry(el) {
     if (typeof el.getBoundingClientRect !== 'function')
         return NO_GEOMETRY;
     let rect = el.getBoundingClientRect();
     if (!isMeasurable(rect))
-        return NO_GEOMETRY;
+        return hasNoSize(el) ? { ...NO_GEOMETRY, noSize: true } : NO_GEOMETRY;
     let scrolledIntoView = false;
     if (isOffViewport(el, rect) && 'function' === typeof el.scrollIntoView) {
         el.scrollIntoView({ block: 'center', inline: 'center' });
         scrolledIntoView = true;
         rect = el.getBoundingClientRect();
     }
-    return { ...hitTest(el, rect), scrolledIntoView };
+    const stillOff = scrolledIntoView && isOffViewport(el, rect);
+    return { ...hitTest(el, rect), scrolledIntoView, ...(stillOff ? { offViewport: true } : {}) };
 }
 export function firePointer(el, type, relatedTarget = null) {
     asSyntheticInput(() => el.dispatchEvent(pointerEventFor(el, type, { bubbles: true, cancelable: true, relatedTarget })));

package/dist/actions/actions.d.ts

@@ -22,6 +22,7 @@ interface SequenceStepResult {
         line: number;
         column?: number;
     };
+    secret?: true;
     warning?: string;
 }
 export declare function executeSequence(steps: ActionStep[]): Promise<{

package/dist/actions/actions.js

@@ -1,25 +1,31 @@
 import { ActionType, ActionWarning, clampHoldMs, DANGEROUS_ACTION_CONFIRM_ARG, ElementState, NATIVE_INPUT_ARG, SettleReason, } from '@reticlehq/core';
+import { isHiddenNativeOption } from '../dom/query-finders.js';
+import { isReticleUi } from '../dom/dom-ignore.js';
 import { asSyntheticInput } from './synthetic/synthetic-input.js';
 import { echoRef, refs } from '../dom/addressing/refs.js';
-import { dangerousActionContext, requiresDangerousConfirmation, assertOutwardAllowed, submitControlFor, } from './danger-context.js';
+import { requiresDangerousConfirmation, assertOutwardAllowed, assertPaymentEntryAllowed, submitControlFor, } from './danger-context.js';
 import { assertEditable, assertNotRichText, isAutofillSafeTarget, setNativeValue, } from './value-input.js';
-import { getRole, isVisible, getStates } from '../dom/a11y.js';
+import { getStates } from '../dom/a11y.js';
+import { isVisible } from '../dom/visibility.js';
 import { elementHasHoverHandlers } from '../registry/stores/adapters.js';
 import { isActionTarget, isForm, isInput, isSelect, isTextArea, } from '../dom/realm.js';
-import { nativeSetTimeout, settle } from '../timers/native/native-timers.js';
+import { asSettleBudget, nativeSetTimeout, settle } from '../timers/native/native-timers.js';
+import { publishSettledField, watchActedField } from '../observers/field.js';
 import { AppearedText } from './appeared-text.js';
 import { alreadyAtCheckedState, assertAriaToggleLanded, isAriaToggle } from './check-state.js';
 import { focusedOrDocument, isReflessDocumentPress, pressCode, pressKey, pressModifiers, pressKeys, holdKey, pressCombo, dispatchKeypress, closeModalOnEscape, keyboardEvent, } from './actions-press.js';
-import { anchorOf, result } from './action-report.js';
+import { anchorOf, result, visibleCanvases, } from './action-report.js';
 function asString(value, fallback = '') {
     return 'string' === typeof value ? value : fallback;
 }
 function requireElement(ref) {
     const el = refs.resolve(ref);
-    if (null === el)
+    if (null === el) {
         throw new Error(`ref '${echoRef(ref)}' no longer resolves to an element`);
-    if (!isActionTarget(el))
+    }
+    if (!isActionTarget(el)) {
         throw new Error(`ref '${echoRef(ref)}' is not an HTML or SVG element`);
+    }
     return el;
 }
 const FILL_LIKE = new Set([
@@ -48,8 +54,9 @@ const GENERIC_ACTION_ARG_KEYS = new Set([
 function assertUploadArgs(args) {
     const keys = Object.keys(args);
     const dropped = keys.filter((k) => !UPLOAD_ARG_KEYS.has(k) && !GENERIC_ACTION_ARG_KEYS.has(k));
-    if (0 === dropped.length && keys.some((k) => UPLOAD_ARG_KEYS.has(k)))
+    if (0 === dropped.length && keys.some((k) => UPLOAD_ARG_KEYS.has(k))) {
         return;
+    }
     const detail = 0 === dropped.length
         ? 'no file was described'
         : `upload does not read ${dropped.join(', ')}, so it would be dropped`;
@@ -67,27 +74,34 @@ function assertActionAllowed(el, action, args) {
         (action === ActionType.PRESS && 'Enter' === pressKey(args));
     const dragTarget = action === ActionType.DRAG ? refs.resolve(dragTargetRef(args)) : null;
     const submitter = action === ActionType.PRESS && 'Enter' === pressKey(args) ? submitControlFor(el) : null;
-    if (canTrigger)
+    if (canTrigger) {
         assertOutwardAllowed([el, submitter, isActionTarget(dragTarget) ? dragTarget : null]);
-    const sourceDangerous = requiresDangerousConfirmation(dangerousActionContext(el), getRole(el)) ||
-        (submitter !== null &&
-            requiresDangerousConfirmation(dangerousActionContext(submitter), getRole(submitter)));
-    const targetDangerous = isActionTarget(dragTarget) &&
-        requiresDangerousConfirmation(dangerousActionContext(dragTarget), getRole(dragTarget));
+    }
+    if (action === ActionType.FILL || action === ActionType.TYPE) {
+        assertPaymentEntryAllowed(el);
+    }
+    const sourceDangerous = requiresDangerousConfirmation(el) ||
+        (submitter !== null && requiresDangerousConfirmation(submitter));
+    const targetDangerous = isActionTarget(dragTarget) && requiresDangerousConfirmation(dragTarget);
     if (canTrigger &&
         (sourceDangerous || targetDangerous) &&
         args[DANGEROUS_ACTION_CONFIRM_ARG] !== true) {
         throw new Error(`potentially destructive action blocked; retry with args.${DANGEROUS_ACTION_CONFIRM_ARG}=true`);
     }
+    if (CLICK_LIKE.has(action) && el instanceof HTMLElement && isHiddenNativeOption(el)) {
+        throw new Error('cannot click a native <option> inside a visually-hidden <select> — open the dropdown and target the visible option');
+    }
 }
 function optionValueFor(options, named) {
-    if (options.some((option) => option.value === named))
+    if (options.some((option) => option.value === named)) {
         return named;
+    }
     const byLabel = options.filter((option) => option.label.trim() === named.trim());
     return 1 === byLabel.length ? (byLabel[0]?.value ?? named) : named;
 }
 import { NO_GEOMETRY, fireClickSequence, fireTapSequence, clickGeometry, firePointer, firePointerNonBubbling, dragElement, mouseEventFor, assertNotLeaving, } from './actions-dom.js';
 import { scrollFrom } from './scroll.js';
+import { clickHitsNoControl } from './click-target.js';
 function enabledOf(el) {
     return !getStates(el).includes(ElementState.DISABLED);
 }
@@ -99,8 +113,9 @@ function valueOf(el) {
 }
 function activeRef(el) {
     const active = el.ownerDocument.activeElement;
-    if (null === active || active === el.ownerDocument.body)
+    if (null === active || active === el.ownerDocument.body) {
         return null;
+    }
     return refs.refFor(active);
 }
 async function dispatchFor(el, action, args) {
@@ -136,8 +151,9 @@ async function dispatchOther(el, action, args) {
             firePointer(el, 'pointermove', from);
             const moved = el.dispatchEvent(mouseEventFor(el, 'mousemove', { bubbles: true, cancelable: true }));
             const holdMs = clampHoldMs(args['holdMs']);
-            if (holdMs > 0)
+            if (holdMs > 0) {
                 await sleep(holdMs);
+            }
             return !moved;
         }
         case ActionType.FOCUS:
@@ -161,8 +177,9 @@ async function dispatchOther(el, action, args) {
                         'To empty a field on purpose use the `clear` action, or fill with an explicit "".');
                 }
                 assertEditable(el, 'fill');
-                if (!isAutofillSafeTarget(el))
+                if (!isAutofillSafeTarget(el)) {
                     el.focus();
+                }
                 return setNativeValue(el, args['value']);
             }
             assertNotRichText(el, 'fill');
@@ -214,8 +231,9 @@ async function dispatchOther(el, action, args) {
             if ('radio' === el.type && action === ActionType.UNCHECK) {
                 throw new Error('cannot uncheck a radio button — a real user could not; select another radio in the group');
             }
-            if (alreadyAtCheckedState(el, action))
+            if (alreadyAtCheckedState(el, action)) {
                 return false;
+            }
             const event = mouseEventFor(el, 'click', {
                 bubbles: true,
                 cancelable: true,
@@ -226,25 +244,29 @@ async function dispatchOther(el, action, args) {
         }
         case ActionType.SUBMIT: {
             const form = isForm(el) ? el : el.closest('form');
-            if (null === form)
+            if (null === form) {
                 throw new Error('no form to submit');
+            }
             form.requestSubmit();
             return false;
         }
         case ActionType.PRESS: {
             const mods = pressModifiers(args);
             const combo = pressKeys(args);
-            if (combo.length > 0)
+            if (combo.length > 0) {
                 return await pressCombo(el, combo, mods, clampHoldMs(args['holdMs']));
+            }
             const key = pressKey(args);
             const code = pressCode(args, key);
             const down = asSyntheticInput(() => el.dispatchEvent(keyboardEvent('keydown', { key, code, bubbles: true, cancelable: true, ...mods })));
             closeModalOnEscape(el, key, down);
-            if (down)
+            if (down) {
                 dispatchKeypress(el, key, code, mods);
+            }
             const hold = clampHoldMs(args['holdMs']);
-            if (hold > 0)
+            if (hold > 0) {
                 await holdKey(el, key, code, mods, hold);
+            }
             asSyntheticInput(() => el.dispatchEvent(keyboardEvent('keyup', { key, code, bubbles: true, ...mods })));
             return !down;
         }
@@ -270,8 +292,9 @@ async function dispatchOther(el, action, args) {
             if (true === args['__base64']) {
                 const bin = atob(rawContent);
                 const arr = new Uint8Array(bin.length);
-                for (let i = 0; i < bin.length; i++)
+                for (let i = 0; i < bin.length; i++) {
                     arr[i] = bin.charCodeAt(i);
+                }
                 fileBody = arr.buffer.slice(0);
             }
             const file = new File([fileBody], asString(args['name'], 'file.txt'), {
@@ -286,8 +309,9 @@ async function dispatchOther(el, action, args) {
         }
         case ActionType.DRAG: {
             const toRef = dragTargetRef(args);
-            if ('' === toRef)
+            if ('' === toRef) {
                 return await dragElement(el, null, args['data']);
+            }
             const resolved = refs.resolve(toRef);
             if (!isActionTarget(resolved)) {
                 throw new Error(`drag target '${echoRef(toRef)}' did not resolve to an element — pass a ref from ` +
@@ -299,26 +323,24 @@ async function dispatchOther(el, action, args) {
             throw new Error(`unknown action '${action}'`);
     }
 }
-function asSettleBudget(raw) {
-    if ('number' !== typeof raw || !Number.isFinite(raw))
-        return undefined;
-    return Math.max(0, Math.min(raw, FRAME_BUDGET_MS_CEILING));
-}
-const FRAME_BUDGET_MS_CEILING = 200;
 export async function executeAction(ref, action, args = {}) {
     const named = 0 < ref.length;
     const el = isReflessDocumentPress(ref, action, args) ? focusedOrDocument() : requireElement(ref);
-    if (named)
+    if (named) {
         assertActionAllowed(el, action, args);
-    if (named)
+    }
+    if (named) {
         assertNotLeaving(el);
+    }
     const anchor = named ? anchorOf(el) : {};
     const visible = isVisible(el);
     const enabled = enabledOf(el);
     const prevFocus = activeRef(el);
     const valueBefore = valueOf(el);
+    const actedField = watchActedField(el);
     const geometry = CLICK_LIKE.has(action) ? clickGeometry(el) : NO_GEOMETRY;
     const alreadyAtValue = alreadyAtCheckedState(el, action);
+    const hitsNoControl = clickHitsNoControl(el, action);
     let mutated = 0;
     const said = new AppearedText();
     const obs = new MutationObserver((records) => {
@@ -346,9 +368,11 @@ export async function executeAction(ref, action, args = {}) {
         settled = outcome.settled;
         settleReason = outcome.settled ? null : SettleReason.TIMEOUT;
         obs.disconnect();
+        actedField?.stop();
     }
     assertAriaToggleLanded(el, action, alreadyAtValue);
     const valueAfter = valueOf(el);
+    publishSettledField(el, actedField);
     const nextFocus = activeRef(el);
     const effect = {
         dispatched: true,
@@ -364,17 +388,32 @@ export async function executeAction(ref, action, args = {}) {
         occluded: geometry.occluded,
         occludedBy: geometry.occludedBy,
         scrolledIntoView: geometry.scrolledIntoView,
+        ...(geometry.occluderName === undefined ? {} : { occluderName: geometry.occluderName }),
+        ...(true === geometry.noSize ? { noSize: true } : {}),
+        ...(true === geometry.offViewport ? { offViewport: true } : {}),
         ...(heldMs > 0 ? { heldMs } : {}),
         ...(alreadyAtValue ? { alreadyAtValue: true } : {}),
+        ...canvasesOnScreen(),
     };
-    const warning = !named
-        ? ActionWarning.GLOBAL_PRESS
-        : geometry.occluded
-            ? ActionWarning.CLICK_OCCLUDED
-            : action === ActionType.HOVER && elementHasHoverHandlers(el)
-                ? ActionWarning.HOVER_NATIVE_ENTER_LEAVE
-                : undefined;
-    return result(ref, action, effect, settled, settleReason, anchor, warning);
+    let warning;
+    if (!named) {
+        warning = ActionWarning.GLOBAL_PRESS;
+    }
+    else if (geometry.occluded) {
+        warning = ActionWarning.CLICK_OCCLUDED;
+    }
+    else if (action === ActionType.HOVER && elementHasHoverHandlers(el)) {
+        warning = ActionWarning.HOVER_NATIVE_ENTER_LEAVE;
+    }
+    else if (hitsNoControl) {
+        warning = ActionWarning.CLICK_NOT_A_CONTROL;
+    }
+    const done = result(ref, action, effect, settled, settleReason, anchor, warning);
+    return isReticleUi(el) ? { ...done, reticleUi: true } : done;
+}
+function canvasesOnScreen() {
+    const canvases = visibleCanvases(document);
+    return canvases > 0 ? { canvases } : {};
 }
 const sleep = (ms) => new Promise((r) => nativeSetTimeout(r, ms));
 export async function executeSequence(steps) {
@@ -390,18 +429,27 @@ export async function executeSequence(steps) {
             settled: res.settled,
             settleReason: res.settleReason,
         };
-        if (res.testid !== undefined)
+        if (res.testid !== undefined) {
             stepBase.testid = res.testid;
-        if (res.component !== undefined)
+        }
+        if (res.component !== undefined) {
             stepBase.component = res.component;
-        if (res.role !== undefined)
+        }
+        if (res.role !== undefined) {
             stepBase.role = res.role;
-        if (res.name !== undefined)
+        }
+        if (res.name !== undefined) {
             stepBase.name = res.name;
-        if (res.source !== undefined)
+        }
+        if (res.source !== undefined) {
             stepBase.source = res.source;
-        if (res.warning !== undefined)
+        }
+        if (res.secret !== undefined) {
+            stepBase.secret = res.secret;
+        }
+        if (res.warning !== undefined) {
             stepBase.warning = res.warning;
+        }
         stepResults.push(stepBase);
     }
     return { ok: true, count: steps.length, effects, steps: stepResults };

package/dist/actions/appeared-text.js

@@ -1,4 +1,4 @@
-import { isIgnored } from '../dom/dom-ignore.js';
+import { isWordsIgnored } from '../dom/dom-ignore.js';
 import { isSensitiveField } from '../dom/a11y.js';
 const APPEARED_MAX = 200;
 const JOIN = ' | ';
@@ -45,7 +45,7 @@ export class AppearedText {
         return this.#length > APPEARED_MAX;
     }
     #add(raw, owner) {
-        if (null !== owner && isIgnored(owner))
+        if (null !== owner && isWordsIgnored(owner))
             return;
         if (null !== owner && isSensitiveField(owner))
             return;

package/dist/actions/click-target.d.ts

@@ -0,0 +1 @@
+export declare function clickHitsNoControl(el: Element, action: string): boolean;

package/dist/actions/click-target.js

@@ -0,0 +1,14 @@
+import { ActionType } from '@reticlehq/core';
+import { getRole } from '../dom/a11y.js';
+import { parentAcrossShadowBoundary } from '../dom/shadow-registry.js';
+import { INTERACTIVE } from '../dom/snapshot.js';
+const CLICK_FORWARDING = 'label, summary, [onclick], [tabindex], [contenteditable]:not([contenteditable="false"])';
+export function clickHitsNoControl(el, action) {
+    if (ActionType.CLICK !== action && ActionType.DBLCLICK !== action)
+        return false;
+    for (let node = el; node !== null; node = parentAcrossShadowBoundary(node)) {
+        if (INTERACTIVE.has(getRole(node)) || node.matches(CLICK_FORWARDING))
+            return false;
+    }
+    return 'pointer' !== getComputedStyle(el).cursor;
+}

package/dist/actions/danger-context.d.ts

@@ -1,6 +1,7 @@
 import { type ActionTarget } from '../dom/realm.js';
 export declare function dangerousActionContext(el: ActionTarget): string;
 export declare function submitControlFor(el: ActionTarget): HTMLElement | null;
-export declare function requiresDangerousConfirmation(text: string, role?: string): boolean;
+export declare function requiresDangerousConfirmation(el: ActionTarget): boolean;
 export declare function setOutwardPolicy(allowed: readonly string[] | undefined): void;
 export declare function assertOutwardAllowed(targets: readonly (ActionTarget | null)[]): void;
+export declare function assertPaymentEntryAllowed(el: ActionTarget): void;