browser-debugger-cli 0.7.2 → 0.9.0

package/dist/runtime/dom/formSubmitHelpers.js

@@ -0,0 +1,326 @@
+/**
+ * Form submission helpers with smart network waiting.
+ */
+import { CDPTimeoutError } from '../../connection/errors.js';
+import { trackInFlightRequests } from '../../connection/inFlightRequests.js';
+import { submitNetworkBusyWarning, submitTimeoutError } from '../../errors/messages.js';
+import { ELEMENT_IDENTITY_JS } from './elementInfo.js';
+import { throwIfInvalidSelector } from './formFillHelpers/shared.js';
+import { FIND_ELEMENTS_JS, selectorArgsJS } from './targetNode.js';
+import { summarizePendingRequests } from '../page/loadingState.js';
+import { EXIT_CODES } from '../../utils/exitCodes.js';
+import { clickElement } from './formFillHelpers/index.js';
+/**
+ * Page script deciding how to submit the target.
+ *
+ * A `<form>` is submitted with `requestSubmit()` (what pressing a submit
+ * button does); a submit button or other element inside a form is clicked
+ * with real mouse events by the caller. Fails, like a browser would refuse,
+ * when the form has invalid fields, and for elements that are neither a form
+ * nor a button.
+ */
+const PREPARE_SUBMIT_SCRIPT = `
+(function(selector, parts, index) {
+  const matches = (${FIND_ELEMENTS_JS})(selector, parts);
+  if (matches.length === 0) {
+    return { action: 'fail', reason: 'not-found', error: 'Element not found: ' + selector };
+  }
+  const el = typeof index === 'number' ? matches[index] : matches[0];
+  if (!el) {
+    return {
+      action: 'fail',
+      reason: 'range',
+      error: 'Index ' + index + ' out of range (found ' + matches.length + ' elements)'
+    };
+  }
+  const isForm = el.tagName === 'FORM';
+  const isButton = el.matches('button, input[type=submit], input[type=image], [role=button]');
+  const isSubmitter = el.matches('button:not([type]), button[type=submit], input[type=submit], input[type=image]');
+  const form = isForm ? el : el.form || el.closest('form');
+  if (!isForm && !isButton) {
+    return {
+      action: 'fail',
+      reason: 'not-submittable',
+      error: 'Element is neither a form nor a submit button: <' + el.tagName.toLowerCase() + '>'
+    };
+  }
+  const submitters = isForm
+    ? Array.from(el.elements).filter((f) =>
+        f.matches('button:not([type]), button[type=submit], input[type=submit], input[type=image]')
+      )
+    : [];
+  if (submitters.length > 0 && submitters.every((f) => f.matches(':disabled'))) {
+    // A user could not submit: Enter does nothing while the default button is disabled
+    return { action: 'fail', reason: 'disabled', error: 'The form\\'s submit button is disabled' };
+  }
+  if ((isForm || isSubmitter) && form && !form.noValidate && !el.formNoValidate && !form.checkValidity()) {
+    const invalid = Array.from(form.elements)
+      .filter((f) => f.willValidate && !f.checkValidity())
+      .map((f) => (f.name || f.id || f.tagName.toLowerCase()) + ': ' + f.validationMessage);
+    return { action: 'fail', reason: 'invalid', error: 'Form has invalid fields - ' + invalid.join('; ') };
+  }
+  if (isForm) {
+    // Like pressing Enter: the form's default button is the submitter, so its
+    // name=value is sent too
+    const submitter = submitters.find((f) => !f.matches(':disabled'));
+    const element = (${ELEMENT_IDENTITY_JS})(submitter || el);
+    if (submitter) el.requestSubmit(submitter);
+    else el.requestSubmit();
+    return { action: 'submitted', clicked: Boolean(submitter), element: element };
+  }
+  return { action: 'click' };
+})`;
+const FAILURE_EXIT_CODES = {
+    'not-found': EXIT_CODES.RESOURCE_NOT_FOUND,
+    range: EXIT_CODES.INVALID_ARGUMENTS,
+    'not-submittable': EXIT_CODES.INVALID_ARGUMENTS,
+    invalid: EXIT_CODES.INVALID_ARGUMENTS,
+    disabled: EXIT_CODES.INVALID_ARGUMENTS,
+};
+const FAILURE_SUGGESTIONS = {
+    'not-found': 'Verify the selector matches a form or submit button',
+    range: 'Use an --index within the number of matches',
+    'not-submittable': 'Target the <form> or its submit button, or use "bdg dom click" for other elements',
+    invalid: 'Fill the listed fields first (see "bdg dom form" for their state)',
+    disabled: 'Complete the steps that enable the button first (see "bdg dom form" for its state)',
+};
+/**
+ * Watches navigation and network activity from before a submission is
+ * triggered, so fast navigations are not missed.
+ *
+ * A navigation is a new document committed in the main frame
+ * (`Page.frameNavigated`), whatever its URL: a POST that redirects back to
+ * the form's own URL (a login error) navigates too.
+ */
+class SubmissionWatcher {
+    navigated = false;
+    documentRequest;
+    onChange = null;
+    requests;
+    disposers = [];
+    /**
+     * @param cdp - CDP connection
+     */
+    constructor(cdp) {
+        this.requests = trackInFlightRequests(cdp, () => this.onChange?.());
+        this.disposers.push(this.requests.dispose);
+        this.disposers.push(cdp.on('Page.frameNavigated', (params, sessionId) => {
+            if (sessionId !== undefined || params.frame.parentId !== undefined)
+                return;
+            this.navigated = true;
+            this.onChange?.();
+        }), cdp.on('Network.requestWillBeSent', (params, sessionId) => {
+            if (sessionId !== undefined || params.type !== 'Document')
+                return;
+            this.documentRequest ??= {
+                requestId: params.requestId,
+                method: params.request.method,
+                url: params.request.url,
+                startedAt: Date.now(),
+            };
+        }), cdp.on('Network.responseReceived', (params) => {
+            if (params.requestId !== this.documentRequest?.requestId)
+                return;
+            this.documentRequest.status = params.response.status;
+            this.documentRequest.statusText = params.response.statusText;
+        }), cdp.on('Network.loadingFailed', (params) => {
+            if (params.requestId !== this.documentRequest?.requestId)
+                return;
+            this.documentRequest.errorText = params.errorText;
+        }));
+    }
+    /** Whether the main frame navigated since watching began. */
+    get navigationOccurred() {
+        return this.navigated;
+    }
+    /** How far the first page request sent since watching began got, if one was sent */
+    get firstDocumentRequest() {
+        const request = this.documentRequest;
+        if (!request)
+            return undefined;
+        const answered = request.status !== undefined || request.errorText !== undefined;
+        return {
+            method: request.method,
+            url: request.url,
+            ...(!answered && { pendingMs: Date.now() - request.startedAt }),
+            ...(request.status !== undefined && { status: request.status }),
+            ...(request.statusText && { statusText: request.statusText }),
+            ...(request.errorText !== undefined && { errorText: request.errorText }),
+        };
+    }
+    /** Requests still in flight */
+    get pendingRequests() {
+        return this.requests.count;
+    }
+    /** Requests started since watching began. */
+    get networkRequests() {
+        return this.requests.started;
+    }
+    /**
+     * Wait until the network is idle for `waitNetwork` ms and, if requested,
+     * the main frame navigated. When a requested navigation happened but the
+     * network was still busy at the timeout (a slow script or tracker on the
+     * new page), the wait ends without an error: resolves to `'busy'`.
+     *
+     * @param options - Wait conditions
+     * @returns `'idle'`, or `'busy'` when only the network wait timed out
+     * @throws CDPTimeoutError after `timeout` ms
+     */
+    wait(options) {
+        const { waitNavigation, waitNetwork, timeout } = options;
+        return new Promise((resolve, reject) => {
+            let idle = null;
+            const finish = () => {
+                clearTimeout(deadline);
+                if (idle)
+                    clearTimeout(idle);
+                this.onChange = null;
+            };
+            const deadline = setTimeout(() => {
+                finish();
+                if (waitNavigation && this.navigated)
+                    resolve('busy');
+                else
+                    reject(new CDPTimeoutError('Wait for completion timed out', new Error(`${timeout}ms`)));
+            }, timeout);
+            const check = () => {
+                const networkIdle = waitNetwork === 0 || this.requests.count === 0;
+                if (networkIdle && (!waitNavigation || this.navigated)) {
+                    finish();
+                    resolve('idle');
+                }
+            };
+            const schedule = () => {
+                if (idle)
+                    clearTimeout(idle);
+                idle = null;
+                if (waitNetwork === 0)
+                    check();
+                else if (this.requests.count === 0)
+                    idle = setTimeout(check, waitNetwork);
+            };
+            this.onChange = schedule;
+            schedule();
+        });
+    }
+    /** Stop watching. */
+    dispose() {
+        this.disposers.forEach((dispose) => dispose());
+    }
+}
+/**
+ * Submit the target: `requestSubmit()` for a form, a real click otherwise.
+ *
+ * @param cdp - CDP connection
+ * @param selector - Selector (or bound-node placeholder)
+ * @param index - Optional 0-based index among matches
+ * @returns Failure result, or whether a submit button was used
+ */
+async function triggerSubmit(cdp, selector, index) {
+    const response = (await cdp.send('Runtime.evaluate', {
+        expression: `(${PREPARE_SUBMIT_SCRIPT})(${selectorArgsJS(selector)}, ${index ?? 'null'})`,
+        returnByValue: true,
+        userGesture: true,
+    }));
+    if (response.exceptionDetails)
+        throwIfInvalidSelector(response.exceptionDetails, selector);
+    const prepared = response.result?.value;
+    if (!prepared || prepared.action === 'fail') {
+        const reason = prepared?.reason ?? 'not-found';
+        const failure = {
+            success: false,
+            error: prepared?.error ?? 'Could not submit',
+            selector,
+            clicked: false,
+            exitCode: FAILURE_EXIT_CODES[reason],
+            suggestion: FAILURE_SUGGESTIONS[reason],
+            ...(reason === 'not-submittable' && { unsuitableElement: true }),
+        };
+        return { failure };
+    }
+    if (prepared.action === 'submitted') {
+        return { clicked: prepared.clicked === true, element: prepared.element };
+    }
+    const click = await clickElement(cdp, selector, index !== undefined ? { index } : {});
+    if (click.success)
+        return { clicked: true, element: click.element };
+    const failure = {
+        success: false,
+        error: click.error ?? 'Click failed',
+        selector,
+        clicked: false,
+        ...(click.exitCode !== undefined && { exitCode: click.exitCode }),
+        ...(click.suggestion !== undefined && { suggestion: click.suggestion }),
+    };
+    return { failure };
+}
+/**
+ * The requests still running in the session, the longest-running first.
+ *
+ * @param pendingRequests - Source of the session's pending requests
+ * @returns The ones to name and the count, none without a source
+ */
+function pendingSummary(pendingRequests) {
+    if (!pendingRequests)
+        return {};
+    const requests = [...pendingRequests()];
+    return {
+        pending: summarizePendingRequests(requests, Date.now()),
+        pendingCount: requests.length,
+    };
+}
+/**
+ * Submit a form and wait for the result.
+ *
+ * @param cdp - CDP connection
+ * @param selector - Form or submit button selector (or bound-node placeholder)
+ * @param options - Submit options
+ * @returns Submit result
+ */
+export async function submitForm(cdp, selector, options = {}) {
+    const { index, waitNavigation = false, waitNetwork = 1000, timeout = 10000 } = options;
+    const startTime = Date.now();
+    const watcher = new SubmissionWatcher(cdp);
+    try {
+        const triggered = await triggerSubmit(cdp, selector, index);
+        if ('failure' in triggered)
+            return triggered.failure;
+        const outcome = waitNetwork > 0 || waitNavigation
+            ? await watcher.wait({ waitNavigation, waitNetwork, timeout })
+            : 'idle';
+        return {
+            success: true,
+            selector,
+            ...(triggered.element !== undefined && { element: triggered.element }),
+            clicked: triggered.clicked,
+            networkRequests: watcher.networkRequests,
+            navigationOccurred: watcher.navigationOccurred,
+            waitTimeMs: Date.now() - startTime,
+            ...(outcome === 'busy' && {
+                warning: submitNetworkBusyWarning(timeout, watcher.pendingRequests),
+            }),
+        };
+    }
+    catch (error) {
+        if (!(error instanceof CDPTimeoutError))
+            throw error;
+        const err = submitTimeoutError(timeout, waitNavigation, {
+            document: watcher.firstDocumentRequest,
+            ...pendingSummary(options.pendingRequests),
+        });
+        return {
+            success: false,
+            error: err.message,
+            selector,
+            clicked: true,
+            navigationOccurred: watcher.navigationOccurred,
+            waitTimeMs: Date.now() - startTime,
+            exitCode: EXIT_CODES.CDP_TIMEOUT,
+            suggestion: err.suggestion,
+        };
+    }
+    finally {
+        watcher.dispose();
+    }
+}
+//# sourceMappingURL=formSubmitHelpers.js.map

package/dist/runtime/dom/formTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Type definitions for form discovery command.
+ *
+ * Re-exports shared types from types.js and defines command-specific types.
+ */
+export type { FieldValidation, FieldOption, FormFieldType, FieldState, FormField, FormButton, FormBlocker, FormSummary, FormStep, DiscoveredForm, FormDiscoveryResult, } from '../../types.js';
+export type { RawFormData, RawForm, RawField, RawButton } from '../../ipc/protocol/domTypes.js';
+//# sourceMappingURL=formTypes.d.ts.map

package/dist/runtime/dom/frameLayout.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Layout of an element inside a cross-origin iframe that shares the page's
+ * process (an a11y query can return those).
+ *
+ * The element is measured in its own frame, whose scripts cannot see the top
+ * page, so its measurements are relative to the frame's viewport. The
+ * iframe element holding the frame is measured in its own document, and the
+ * element is placed in the top-level viewport through it: mapped by the
+ * frame's position and scale, clipped to the frame's viewport and to what clips the
+ * iframe, and fixed, scrolled or hidden as the iframe is.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { Protocol } from '../../connection/typed-cdp.js';
+import type { LayoutBox } from '../../ipc/protocol/domTypes.js';
+import { type FrameMapping } from './frameScopedConnection.js';
+import type { RawLayout } from './layout.js';
+/**
+ * Ids of all frames below a frame tree's root.
+ *
+ * @param tree - Frame tree
+ * @returns Frame ids, depth-first
+ */
+export declare function childFrameIds(tree: Protocol.Page.FrameTree | undefined): string[];
+/**
+ * The iframe element whose document holds an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns Backend node id of the iframe element, undefined when not found
+ */
+export declare function findFrameOwner(cdp: CDPConnection, objectId: string): Promise<number | undefined>;
+/**
+ * Overlap of boxes.
+ *
+ * @param boxes - Boxes (null ones are left out)
+ * @returns Overlap (zero size when they do not overlap)
+ */
+export declare function intersection(...boxes: Array<LayoutBox | null>): LayoutBox;
+/**
+ * Whether a box lies inside another.
+ *
+ * @param inner - Inner box
+ * @param outer - Outer box
+ * @returns True when it does
+ */
+export declare function inside(inner: LayoutBox, outer: LayoutBox): boolean;
+/**
+ * Place an element measured inside a cross-origin frame in the top-level
+ * viewport, through the measurements of the frame's iframe element: mapped by
+ * the frame's position and scale (border, padding, `transform`, `zoom`),
+ * clipped to the frame's viewport and to what clips the iframe.
+ *
+ * @param raw - The element, measured in its frame
+ * @param owner - The iframe element, measured in its document
+ * @param mapping - How the frame's viewport maps into the top-level viewport
+ * @returns The element's layout in the top-level page (unchanged when the
+ *   iframe could not be measured)
+ */
+export declare function placeInOwnerFrame(raw: RawLayout, owner: RawLayout, mapping: FrameMapping): RawLayout;
+//# sourceMappingURL=frameLayout.d.ts.map

package/dist/runtime/dom/frameLayout.js

@@ -0,0 +1,140 @@
+/**
+ * Layout of an element inside a cross-origin iframe that shares the page's
+ * process (an a11y query can return those).
+ *
+ * The element is measured in its own frame, whose scripts cannot see the top
+ * page, so its measurements are relative to the frame's viewport. The
+ * iframe element holding the frame is measured in its own document, and the
+ * element is placed in the top-level viewport through it: mapped by the
+ * frame's position and scale, clipped to the frame's viewport and to what clips the
+ * iframe, and fixed, scrolled or hidden as the iframe is.
+ */
+import { mapBox } from './frameScopedConnection.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('dom');
+/**
+ * Ids of all frames below a frame tree's root.
+ *
+ * @param tree - Frame tree
+ * @returns Frame ids, depth-first
+ */
+export function childFrameIds(tree) {
+    return (tree?.childFrames ?? []).flatMap((child) => [child.frame.id, ...childFrameIds(child)]);
+}
+/**
+ * Backend node id of the document holding an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns The document's backend node id, if it could be read
+ */
+async function ownerDocumentId(cdp, objectId) {
+    const doc = (await cdp.send('Runtime.callFunctionOn', {
+        objectId,
+        functionDeclaration: 'function () { return this.ownerDocument; }',
+    }));
+    if (!doc.result.objectId)
+        return undefined;
+    const { node } = (await cdp.send('DOM.describeNode', {
+        objectId: doc.result.objectId,
+    }));
+    return node.backendNodeId;
+}
+/**
+ * The iframe element whose document holds an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns Backend node id of the iframe element, undefined when not found
+ */
+export async function findFrameOwner(cdp, objectId) {
+    try {
+        const documentId = await ownerDocumentId(cdp, objectId);
+        const { frameTree } = (await cdp.send('Page.getFrameTree'));
+        for (const frameId of childFrameIds(frameTree)) {
+            const owner = (await cdp.send('DOM.getFrameOwner', {
+                frameId,
+            }));
+            const { node } = (await cdp.send('DOM.describeNode', {
+                backendNodeId: owner.backendNodeId,
+            }));
+            if (node.contentDocument?.backendNodeId === documentId)
+                return owner.backendNodeId;
+        }
+    }
+    catch (error) {
+        log.debug(`Frame owner not found: ${getErrorMessage(error)}`);
+    }
+    return undefined;
+}
+/**
+ * Overlap of boxes.
+ *
+ * @param boxes - Boxes (null ones are left out)
+ * @returns Overlap (zero size when they do not overlap)
+ */
+export function intersection(...boxes) {
+    const present = boxes.filter((box) => box !== null);
+    const left = Math.max(...present.map((box) => box.x));
+    const top = Math.max(...present.map((box) => box.y));
+    const right = Math.min(...present.map((box) => box.x + box.width));
+    const bottom = Math.min(...present.map((box) => box.y + box.height));
+    return { x: left, y: top, width: Math.max(0, right - left), height: Math.max(0, bottom - top) };
+}
+/**
+ * Whether a box lies inside another.
+ *
+ * @param inner - Inner box
+ * @param outer - Outer box
+ * @returns True when it does
+ */
+export function inside(inner, outer) {
+    return (inner.x >= outer.x &&
+        inner.y >= outer.y &&
+        inner.x + inner.width <= outer.x + outer.width &&
+        inner.y + inner.height <= outer.y + outer.height);
+}
+/**
+ * Place an element measured inside a cross-origin frame in the top-level
+ * viewport, through the measurements of the frame's iframe element: mapped by
+ * the frame's position and scale (border, padding, `transform`, `zoom`),
+ * clipped to the frame's viewport and to what clips the iframe.
+ *
+ * @param raw - The element, measured in its frame
+ * @param owner - The iframe element, measured in its document
+ * @param mapping - How the frame's viewport maps into the top-level viewport
+ * @returns The element's layout in the top-level page (unchanged when the
+ *   iframe could not be measured)
+ */
+export function placeInOwnerFrame(raw, owner, mapping) {
+    const frame = owner.elements[0];
+    if (!raw.page || !owner.page || !frame)
+        return raw;
+    const frameView = mapBox(mapping, { x: 0, y: 0, ...raw.page.viewport });
+    const elements = raw.elements.map((element) => {
+        const inner = element.geometry;
+        const outer = frame.geometry;
+        const rect = mapBox(mapping, inner.rect);
+        const ownClip = inner.clip ? mapBox(mapping, inner.clip) : null;
+        return {
+            ...element,
+            context: [frame.element, element.context].filter(Boolean).join(' > '),
+            geometry: {
+                ...inner,
+                rect,
+                clip: intersection(ownClip, frameView, outer.clip),
+                clipper: inner.clipper ?? (inside(rect, frameView) ? outer.clipper : frame.element),
+                hidden: inner.hidden ?? (outer.hidden ? 'inside a hidden iframe' : null),
+                invisible: inner.invisible ?? outer.invisible,
+                fixed: outer.fixed,
+                sticky: outer.sticky ?? false,
+                pageScroll: outer.pageScroll,
+                scrollLock: outer.scrollLock ?? null,
+                offset: mapping.origin,
+            },
+        };
+    });
+    return { ...raw, page: owner.page, elements, crossOriginFrame: false };
+}
+//# sourceMappingURL=frameLayout.js.map

package/dist/runtime/dom/frameOrigin.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The origin a frame's scripts really run with, for `bdg dom frames`.
+ *
+ * Chrome reports `securityOrigin: "://"` for frames without an origin of
+ * their own (srcdoc, about:blank, data:) and the URL's origin for sandboxed
+ * frames, so neither tells whether the parent can reach the frame's
+ * document. The frame's default execution context knows: it reports the
+ * inherited origin for srcdoc and about:blank, and `"://"` for opaque ones
+ * (data: URLs, sandboxes without `allow-same-origin`). A frame that has no
+ * context yet falls back to the rules below; a frame inside an opaque one
+ * counts as opaque too (sandbox flags are inherited).
+ */
+/** Origin of documents that share no origin with anything */
+export declare const OPAQUE_ORIGIN = "null";
+/** What is known about a frame's origin */
+export interface FrameOriginFacts {
+    /** Frame URL */
+    url: string;
+    /** `Page.Frame.securityOrigin` */
+    securityOrigin: string;
+    /** Origin of the frame's default execution context, when it has one */
+    contextOrigin?: string | undefined;
+    /** Origin of the parent frame (already resolved) */
+    parentOrigin?: string | undefined;
+    /** `sandbox` attribute of the frame's element, when present */
+    sandbox?: string | undefined;
+}
+/**
+ * Whether a `sandbox` attribute makes the frame's origin opaque.
+ *
+ * @param sandbox - Attribute value (undefined when the attribute is missing)
+ * @returns True unless the attribute is missing or allows same-origin
+ */
+export declare function isOpaqueSandbox(sandbox: string | undefined): boolean;
+/**
+ * The origin a frame's scripts run with.
+ *
+ * @param facts - What Chrome reports about the frame
+ * @returns e.g. `https://example.com`, or `"null"` for an opaque origin
+ */
+export declare function effectiveFrameOrigin(facts: FrameOriginFacts): string;
+/**
+ * Whether the top page's scripts cannot reach a frame's document.
+ *
+ * @param origin - The frame's effective origin
+ * @param topOrigin - The page's effective origin
+ * @returns True for a different or opaque origin
+ */
+export declare function isCrossOrigin(origin: string, topOrigin: string): boolean;
+//# sourceMappingURL=frameOrigin.d.ts.map

package/dist/runtime/dom/frameOrigin.js

@@ -0,0 +1,62 @@
+/**
+ * The origin a frame's scripts really run with, for `bdg dom frames`.
+ *
+ * Chrome reports `securityOrigin: "://"` for frames without an origin of
+ * their own (srcdoc, about:blank, data:) and the URL's origin for sandboxed
+ * frames, so neither tells whether the parent can reach the frame's
+ * document. The frame's default execution context knows: it reports the
+ * inherited origin for srcdoc and about:blank, and `"://"` for opaque ones
+ * (data: URLs, sandboxes without `allow-same-origin`). A frame that has no
+ * context yet falls back to the rules below; a frame inside an opaque one
+ * counts as opaque too (sandbox flags are inherited).
+ */
+/** Origin of documents that share no origin with anything */
+export const OPAQUE_ORIGIN = 'null';
+/**
+ * Whether a reported origin names a real (tuple) origin.
+ *
+ * @param origin - Origin as Chrome reports it
+ * @returns False for `"://"`, `"null"` and empty
+ */
+function isTupleOrigin(origin) {
+    return origin !== undefined && origin !== '' && origin !== '://' && origin !== OPAQUE_ORIGIN;
+}
+/**
+ * Whether a `sandbox` attribute makes the frame's origin opaque.
+ *
+ * @param sandbox - Attribute value (undefined when the attribute is missing)
+ * @returns True unless the attribute is missing or allows same-origin
+ */
+export function isOpaqueSandbox(sandbox) {
+    if (sandbox === undefined)
+        return false;
+    return !sandbox.toLowerCase().split(/\s+/).includes('allow-same-origin');
+}
+/**
+ * The origin a frame's scripts run with.
+ *
+ * @param facts - What Chrome reports about the frame
+ * @returns e.g. `https://example.com`, or `"null"` for an opaque origin
+ */
+export function effectiveFrameOrigin(facts) {
+    if (facts.contextOrigin !== undefined) {
+        return isTupleOrigin(facts.contextOrigin) ? facts.contextOrigin : OPAQUE_ORIGIN;
+    }
+    if (isOpaqueSandbox(facts.sandbox) || facts.parentOrigin === OPAQUE_ORIGIN)
+        return OPAQUE_ORIGIN;
+    if (isTupleOrigin(facts.securityOrigin))
+        return facts.securityOrigin;
+    const inherits = facts.url === '' || facts.url.startsWith('about:');
+    return inherits && isTupleOrigin(facts.parentOrigin) ? facts.parentOrigin : OPAQUE_ORIGIN;
+}
+/**
+ * Whether the top page's scripts cannot reach a frame's document.
+ *
+ * @param origin - The frame's effective origin
+ * @param topOrigin - The page's effective origin
+ * @returns True for a different or opaque origin
+ */
+export function isCrossOrigin(origin, topOrigin) {
+    return origin === OPAQUE_ORIGIN || origin !== topOrigin;
+}
+//# sourceMappingURL=frameOrigin.js.map