@lingxia/test 0.18.0 → 0.19.0

package/dist/locator.js

@@ -1,19 +1,28 @@
-import { AssertionError } from "./expect.js";
+var _a;
 import { cssEscape, formatValue } from "./format.js";
+import { ActionDeadline, TimeoutError, errorCode, isElementRefusal, isPreDispatchPageError, isTransientPageError, isTransientTransportError, } from "./deadline.js";
+import { resolveHost } from "./host.js";
 import { displayLocation } from "./ids.js";
 import { DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_POLL_INTERVAL_MS, } from "./version.js";
+import { runnerSetTimeout } from "./pending.js";
+/** Marks a locator across module copies, so `expect(locator)` retries it. */
+export const LOCATOR_BRAND = Symbol.for("lingxia.test.locator");
 export function testIdSelector(id) {
     return `[data-testid="${cssEscape(id)}"]`;
 }
 export class PageLocator {
-    constructor(page, guard, record, selector, location, options = {}) {
+    constructor(page, guard, record, selector, location, options = {}, room = () => Number.POSITIVE_INFINITY, refine = {}) {
         this.page = page;
         this.guard = guard;
         this.record = record;
         this.location = location;
         this.options = options;
+        this.room = room;
+        this.refine = refine;
+        this[_a] = true;
         this.selector = selector;
         this.options = { ...options };
+        this.refine = { ...refine };
         if (!selector.trim())
             throw new TypeError("Locator selector must not be empty");
         if (options.index !== undefined && (!Number.isInteger(options.index) || options.index < 0)) {
@@ -21,55 +30,172 @@ export class PageLocator {
         }
     }
     nth(index) {
-        return new PageLocator(this.page, this.guard, this.record, this.selector, this.location, { ...this.options, index });
+        return new PageLocator(this.page, this.guard, this.record, this.selector, this.location, { ...this.options, index }, this.room, { ...this.refine, last: false });
     }
-    async press(key, options) {
+    first() {
+        return this.nth(0);
+    }
+    last() {
+        const { index: _index, ...options } = this.options;
+        return new PageLocator(this.page, this.guard, this.record, this.selector, this.location, options, this.room, { ...this.refine, last: true });
+    }
+    filter(options) {
+        const hasText = options?.hasText;
+        if (typeof hasText !== "string" && !(hasText instanceof RegExp)) {
+            throw new TypeError("filter() needs { hasText: string | RegExp }");
+        }
+        return new PageLocator(this.page, this.guard, this.record, this.selector, this.location, this.options, this.room, { ...this.refine, hasText });
+    }
+    // Actions return the fixture's own call, not a wrapper around it: a call
+    // the spec never awaited is then the very promise the runtime stops.
+    press(key, options) {
         if (!this.page.press)
-            throw new Error("This page driver does not support press");
-        await this.act("press", options, (css, index) => this.page.press({ ...this.options, css, index, key }));
+            return Promise.reject(new Error("This page driver does not support press"));
+        return this.act("press", options, (css, index) => this.page.press({ page: this.options.page, css, index, key }), `key=${formatValue(key)}`);
+    }
+    click(options) {
+        const force = options?.force === true;
+        return this.act("click", options, (css, index) => this.page.click({ page: this.options.page, css, index, ...(force ? { force } : {}) }));
+    }
+    fill(text, options) {
+        const force = options?.force === true;
+        return this.act("fill", options, (css, index) => this.page.fill({ page: this.options.page, css, text, index, ...(force ? { force } : {}) }), this.inputDetail(text));
+    }
+    type(text, options) {
+        return this.act("type", options, (css, index) => this.page.type({ page: this.options.page, css, text, index }), this.inputDetail(text));
+    }
+    waitFor(options) {
+        const state = options?.state ?? "visible";
+        if (!["attached", "detached", "visible", "hidden", "inViewport"].includes(state)) {
+            return Promise.reject(new TypeError(`Unknown locator state: ${String(state)}`));
+        }
+        const timeout = options?.timeout ?? DEFAULT_ACTION_TIMEOUT_MS;
+        const interval = options?.interval ?? DEFAULT_POLL_INTERVAL_MS;
+        if (!Number.isFinite(timeout) || timeout <= 0 || !Number.isFinite(interval) || interval <= 0) {
+            return Promise.reject(new TypeError("Wait timeout and interval must be positive finite numbers"));
+        }
+        const deadline = new ActionDeadline(timeout, this.room());
+        return this.record("page.waitFor", `${this.target()} ${state}`, async () => {
+            let reason = "not observed";
+            let cause;
+            while (!deadline.expired()) {
+                try {
+                    const resolved = await this.resolve(deadline, "waitFor");
+                    if (reachedState(resolved, state))
+                        return;
+                    reason = this.missText(resolved);
+                    cause = undefined;
+                }
+                catch (error) {
+                    // A page mid-transition, or a read the transport dropped, is not an
+                    // answer yet; anything else is.
+                    if (!isTransientPageError(error) && !isTransientTransportError(error))
+                        throw error;
+                    reason = transientReason(error);
+                    cause = error;
+                }
+                if (deadline.expired())
+                    break;
+                await sleep(Math.min(interval, Math.max(1, deadline.remaining())));
+            }
+            throw withCause(new TimeoutError([
+                `Timed out after ${deadline.elapsed()}ms waiting for ${formatValue(this.selector)} to be ${state}.`,
+                reason,
+                deadline.clampNote(),
+                `at ${this.where()}`,
+            ].filter(Boolean).join("\n")), cause);
+        });
+    }
+    count() {
+        return this.read("count", async () => (await this.resolve(undefined, "count")).count);
+    }
+    isVisible() {
+        return this.read("isVisible", async () => {
+            const resolved = await this.resolve(undefined, "isVisible");
+            if (resolved.kind === "many")
+                throw new Error(`isVisible(): ${this.missText(resolved)}; narrow it with nth(), first(), last() or filter()`);
+            return resolved.kind === "unique";
+        });
     }
-    async click(options) {
-        await this.act("click", options, (css, index) => this.page.click({ ...this.options, css, index }));
+    textContent() {
+        return this.read("textContent", async () => (await this.single("textContent")).text);
     }
-    async fill(text, options) {
-        await this.act("fill", options, (css, index) => this.page.fill({ ...this.options, css, text, index }));
+    inputValue() {
+        return this.read("inputValue", async () => {
+            const resolved = await this.single("inputValue");
+            if (resolved.value === null)
+                throw new Error(`inputValue(): ${this.target()} has no value (not an input, textarea or select)`);
+            return resolved.value;
+        });
     }
-    async type(text, options) {
-        await this.act("type", options, (css, index) => this.page.type({ ...this.options, css, text, index }));
+    getAttribute(name) {
+        if (typeof name !== "string" || name.length === 0) {
+            return Promise.reject(new TypeError("getAttribute(name) takes an attribute name"));
+        }
+        return this.read("getAttribute", async () => (await this.single("getAttribute", [name])).attributes?.[name] ?? null);
     }
-    async query() {
-        return this.guard(() => this.page.query({ ...this.options, css: this.selector }));
+    /** A traced one-shot read. */
+    read(verb, op) {
+        return this.record(`page.${verb}`, this.target(), op);
     }
-    async resolve() {
-        const all = await this.guard(() => this.page.query({ page: this.options.page, css: this.selector, all: true }));
-        const matches = Array.isArray(all.items) ? all.items : all.exists ? [all] : [];
-        const selected = this.options.index === undefined ? undefined : matches[this.options.index];
-        const items = this.options.index === undefined ? matches : selected ? [{ ...selected, index: this.options.index }] : [];
-        const count = this.options.index === undefined ? (all.count ?? items.length) : items.length;
+    async single(verb, attributes = []) {
+        const resolved = await this.resolve(undefined, verb, attributes);
+        if (resolved.count !== 1) {
+            throw new Error(`${verb}(): ${this.missText(resolved)}` +
+                (resolved.kind === "many" ? "; narrow it with nth(), first(), last() or filter()" : ""));
+        }
+        return resolved;
+    }
+    /**
+     * One read of the locator's matches. With a deadline the query is raced
+     * against what is left of it, so a query that never returns fails `verb`.
+     */
+    async resolve(deadline, verb = "resolve", attributes = []) {
+        const query = () => this.page.query({ page: this.options.page, css: this.selector, all: true });
+        const all = await this.guard(() => deadline ? deadline.call("page.query", query, () => this.callContext(verb)) : query());
+        const raw = Array.isArray(all.items) ? all.items : all.exists ? [all] : [];
+        // Every match keeps its DOM index: the driver addresses `css` + index.
+        // Text is read as the user sees it: `innerText` line breaks depend on
+        // layout (WebKit ends a flex row's text in "\n"), so whitespace is
+        // collapsed and trimmed before any matcher sees it.
+        const indexed = raw.map((item, position) => ({
+            ...item,
+            index: item.index ?? position,
+            ...(typeof item.text === "string" ? { text: normalizeText(item.text) } : {}),
+        }));
+        const hasText = this.refine.hasText;
+        const matches = hasText === undefined ? indexed : indexed.filter((item) => textMatches(item.text ?? "", hasText));
+        const pick = this.refine.last ? matches.length - 1 : this.options.index;
+        const picked = pick === undefined ? undefined : matches[pick];
+        const items = pick === undefined ? matches : picked ? [picked] : [];
+        const count = pick !== undefined ? items.length : hasText === undefined ? (all.count ?? items.length) : items.length;
         const visibleItems = items.filter((item) => item.visible);
         const visibleCount = visibleItems.length;
+        let resolved;
         if (count === 0) {
-            return {
+            resolved = {
                 count: 0,
                 visibleCount: 0,
                 attached: false,
                 visible: false,
+                inViewport: false,
                 text: "",
                 value: null,
                 index: 0,
                 kind: "nothing",
             };
         }
-        if (count > 1) {
-            return { count, visibleCount, attached: true, visible: visibleCount > 0,
+        else if (count > 1) {
+            resolved = { count, visibleCount, attached: true, visible: visibleCount > 0, inViewport: false,
                 text: items.map(item => item.text ?? "").join("\n"), value: null, index: 0, kind: "many" };
         }
-        if (visibleCount === 0) {
-            return {
+        else if (visibleCount === 0) {
+            resolved = {
                 count,
                 visibleCount: 0,
                 attached: true,
                 visible: false,
+                inViewport: false,
                 text: items[0]?.text ?? "",
                 value: items[0]?.value ?? null,
                 index: items[0]?.index ?? 0,
@@ -77,20 +203,48 @@ export class PageLocator {
                 kind: "hidden",
             };
         }
-        const unique = visibleItems[0];
-        return {
-            count,
-            visibleCount: 1,
-            attached: true,
-            visible: true,
-            text: unique.text ?? "",
-            value: unique.value ?? null,
-            index: unique.index ?? items.indexOf(unique),
-            enabled: unique.enabled, editable: unique.editable, rect: unique.rect,
-            kind: "unique",
-        };
+        else {
+            const unique = visibleItems[0];
+            resolved = {
+                count,
+                visibleCount: 1,
+                attached: true,
+                visible: true,
+                inViewport: unique.inViewport === true,
+                text: unique.text ?? "",
+                value: unique.value ?? null,
+                index: unique.index ?? items.indexOf(unique),
+                enabled: unique.enabled, editable: unique.editable, rect: unique.rect,
+                kind: "unique",
+            };
+        }
+        if (attributes.length > 0 && count === 1) {
+            resolved.attributes = await this.readAttributes(resolved.index, attributes, deadline, verb);
+        }
+        return resolved;
+    }
+    /** A read-only look at the single match's attributes. */
+    async readAttributes(index, names, deadline, verb) {
+        if (!this.page.eval)
+            throw new Error("This page driver cannot read attributes");
+        const script = `(() => {
+      const el = document.querySelectorAll(${JSON.stringify(this.selector)})[${index}];
+      const out = {};
+      for (const name of ${JSON.stringify(names)}) out[name] = el ? el.getAttribute(name) : null;
+      return out;
+    })()`;
+        const read = () => this.page.eval({ page: this.options.page, script });
+        const value = await this.guard(() => deadline ? deadline.call("page.eval (attributes)", read, () => this.callContext(verb)) : read());
+        const out = {};
+        const record = value && typeof value === "object" ? value : {};
+        for (const name of names)
+            out[name] = typeof record[name] === "string" ? record[name] : null;
+        return out;
     }
     missText(resolved) {
+        if (resolved.kind === "unique" && !resolved.inViewport) {
+            return `locator ${formatValue(this.selector)} resolved to a visible element outside the viewport`;
+        }
         if (resolved.kind === "nothing") {
             return `locator ${formatValue(this.selector)} resolved to nothing`;
         }
@@ -102,10 +256,37 @@ export class PageLocator {
         }
         return `locator ${formatValue(this.selector)} resolved to a visible element`;
     }
-    async actionability(index, verb) {
+    /** The page instance this locator is bound to; `null` for the current page. */
+    get boundPage() {
+        return this.options.page ?? null;
+    }
+    /** The page, selector and narrowing, as the trace and failures show it. */
+    describe() {
+        return this.target();
+    }
+    inputDetail(text) {
+        // Locator names commonly reveal password fields. Declared --secret-arg
+        // values are also scrubbed from the final report by the run redactor.
+        if (/(?:password|passwd|passphrase|secret|token|credential|api[-_]?key)/i.test(this.selector)) {
+            return `value=[redacted, ${text.length} chars]`;
+        }
+        return `value=${formatValue(text)}`;
+    }
+    target() {
+        const filter = this.refine.hasText === undefined ? "" : ` filter(hasText=${formatValue(this.refine.hasText)})`;
+        const pick = this.refine.last ? " [last]" : this.options.index === undefined ? "" : ` [${this.options.index}]`;
+        return `${this.options.page ? `#${this.options.page} ` : ""}${this.selector}${filter}${pick}`;
+    }
+    where() {
+        return displayLocation(this.location.source, this.location.line, this.location.column);
+    }
+    callContext(verb) {
+        return `while trying to ${verb} ${formatValue(this.selector)}\nat ${this.where()}`;
+    }
+    async actionability(index, verb, deadline) {
         if (!this.page.eval)
             return true;
-        const result = await this.guard(() => this.page.eval({ page: this.options.page, script: `(() => {
+        const script = `(() => {
       const el = document.querySelectorAll(${JSON.stringify(this.selector)})[${index}];
       if (!el || !el.isConnected) return "element detached";
       el.scrollIntoView({block:"center", inline:"center", behavior:"instant"});
@@ -114,70 +295,216 @@ export class PageLocator {
       const r = el.getBoundingClientRect();
       const hit = document.elementFromPoint(r.left + r.width / 2, r.top + r.height / 2);
       return hit && (hit === el || el.contains(hit)) ? true : "element is obscured";
-    })()` }));
+    })()`;
+        const result = await this.guard(() => deadline.call("page.eval (actionability)", () => this.page.eval({ page: this.options.page, script }), () => this.callContext(verb)));
         return result === true ? true : String(result ?? "invalid actionability response");
     }
-    async act(verb, options, run) {
+    act(verb, options, run, input) {
+        const force = options?.force === true;
         const timeout = options?.timeout ?? DEFAULT_ACTION_TIMEOUT_MS;
-        const interval = options?.interval ?? DEFAULT_POLL_INTERVAL_MS;
-        if (!Number.isFinite(timeout) || timeout <= 0 || !Number.isFinite(interval) || interval <= 0) {
-            throw new TypeError("Action timeout and interval must be positive finite numbers");
+        const interval = DEFAULT_POLL_INTERVAL_MS;
+        if (!Number.isFinite(timeout) || timeout <= 0) {
+            return Promise.reject(new TypeError("Action timeout must be a positive finite number"));
         }
-        await this.record(`page.${verb}`, `${this.options.page ? this.options.page + " " : ""}${this.selector}${this.options.index === undefined ? "" : ` [${this.options.index}]`}`, async () => {
-            const started = Date.now();
+        const deadline = new ActionDeadline(timeout, this.room());
+        const context = () => this.callContext(verb);
+        return this.record(`page.${verb}`, `${this.target()}${input ? ` ${input}` : ""}`, async () => {
             let last;
             let previousRect;
             let reason = "not attached";
-            while (Date.now() - started < timeout) {
-                last = await this.resolve();
-                reason = this.missText(last);
-                if (last.kind === "hidden" && last.count === 1 && this.page.eval) {
-                    await this.guard(() => this.page.eval({ page: this.options.page, script: `document.querySelectorAll(${JSON.stringify(this.selector)})[${last.index}]?.scrollIntoView({block:"center", inline:"center", behavior:"instant"})` }));
-                }
-                if (last.kind === "unique") {
-                    const rect = JSON.stringify(last.rect);
-                    const stable = last.rect === undefined || previousRect === rect;
-                    previousRect = rect;
-                    if (last.enabled === false)
-                        reason = "element is disabled";
-                    else if ((verb === "fill" || verb === "type") && last.editable === false)
-                        reason = "element is not editable";
-                    else if (!stable)
-                        reason = "element is moving";
-                    else {
-                        const check = await this.actionability(last.index, verb);
-                        if (check === true) {
-                            try {
-                                await this.guard(() => run(this.selector, last.index));
-                                return;
+            // Preserve the last driver failure as the timeout cause.
+            let cause;
+            const until = async (budget) => {
+                while (!budget.expired()) {
+                    try {
+                        last = await this.resolve(budget, verb);
+                        reason = this.missText(last);
+                        cause = undefined;
+                        if (force && last.count === 1) {
+                            // Forced: attached and enabled are enough; no viewport, stability
+                            // or hit-test wait.
+                            if (last.enabled === false)
+                                reason = "element is disabled";
+                            else if ((verb === "fill" || verb === "type") && last.editable === false)
+                                reason = "element is not editable";
+                            else {
+                                try {
+                                    const index = last.index;
+                                    await this.guard(() => budget.call(`page.${verb}`, () => run(this.selector, index), context));
+                                    return true;
+                                }
+                                catch (error) {
+                                    if (!isElementRefusal(error) && !isPreDispatchPageError(error)) {
+                                        throw new DispatchFailure(error);
+                                    }
+                                    reason = error instanceof Error ? error.message : String(error);
+                                    cause = error;
+                                }
                             }
-                            catch (error) {
-                                // These native errors are raised before input dispatch. A transport
-                                // failure is ambiguous and must never resubmit an action.
-                                const message = error instanceof Error ? error.message : "";
-                                if (!/^Element (?:not found|not interactable):/.test(message))
-                                    throw error;
-                                reason = message;
-                                previousRect = undefined;
+                        }
+                        else if (last.kind === "unique") {
+                            const rect = JSON.stringify(last.rect);
+                            const stable = last.rect === undefined || previousRect === rect;
+                            previousRect = rect;
+                            if (last.enabled === false)
+                                reason = "element is disabled";
+                            else if ((verb === "fill" || verb === "type") && last.editable === false)
+                                reason = "element is not editable";
+                            else if (!stable)
+                                reason = "element is moving";
+                            else {
+                                const check = await this.actionability(last.index, verb, budget);
+                                if (check === true) {
+                                    try {
+                                        const index = last.index;
+                                        await this.guard(() => budget.call(`page.${verb}`, () => run(this.selector, index), context));
+                                        return true;
+                                    }
+                                    catch (error) {
+                                        // These native errors are raised before input dispatch. A transport
+                                        // failure is ambiguous and must never resubmit an action.
+                                        if (!isElementRefusal(error) && !isPreDispatchPageError(error)) {
+                                            throw new DispatchFailure(error);
+                                        }
+                                        reason = error instanceof Error ? error.message : String(error);
+                                        cause = error;
+                                        previousRect = undefined;
+                                    }
+                                }
+                                if (check !== true)
+                                    reason = check;
                             }
                         }
-                        if (check !== true)
-                            reason = check;
+                        else {
+                            previousRect = undefined;
+                        }
                     }
+                    catch (error) {
+                        // The page is being replaced (navigation in flight): no read or
+                        // dispatch reached it, so wait for the new page within the budget.
+                        if (error instanceof DispatchFailure)
+                            throw error.error;
+                        // Reads only: a dispatch error is a DispatchFailure, never retried.
+                        if (!isTransientPageError(error) && !isTransientTransportError(error))
+                            throw error;
+                        reason = transientReason(error);
+                        cause = error;
+                        previousRect = undefined;
+                    }
+                    await sleep(Math.min(interval, Math.max(1, budget.remaining())));
                 }
-                else {
-                    previousRect = undefined;
-                }
-                await sleep(Math.min(interval, Math.max(1, timeout - (Date.now() - started))));
-            }
-            const where = displayLocation(this.location.source, this.location.line, this.location.column);
-            throw new AssertionError(verb, reason, "stable, enabled, unobscured element", `Timed out after ${Date.now() - started}ms waiting to ${verb} ${formatValue(this.selector)}.\n${reason}\nat ${where}`);
+                return false;
+            };
+            if (await until(deadline))
+                return;
+            throw withCause(new TimeoutError([
+                `Timed out after ${deadline.elapsed()}ms waiting to ${verb} ${formatValue(this.selector)}.`,
+                reason,
+                deadline.clampNote(),
+                `at ${this.where()}`,
+            ].filter(Boolean).join("\n")), cause);
         });
     }
 }
+_a = LOCATOR_BRAND;
+/** Preserve the last driver failure without changing the public timeout code. */
+function withCause(error, cause) {
+    if (cause === undefined)
+        return error;
+    Object.assign(error, { cause });
+    const code = errorCode(cause);
+    const data = cause && typeof cause === "object" ? cause.data : undefined;
+    error.data = {
+        ...(data && typeof data === "object" ? data : {}),
+        ...(code === undefined ? {} : { driverCode: code }),
+    };
+    return error;
+}
+/** A dispatch error that must propagate as is, never be retried. */
+class DispatchFailure {
+    constructor(error) {
+        this.error = error;
+    }
+}
+function transientReason(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return isTransientTransportError(error) ? `read dropped by the transport: ${text}` : `page not ready: ${text}`;
+}
+/** `many` never satisfies `attached`/`visible`: the match is ambiguous. */
+function reachedState(resolved, state) {
+    switch (state) {
+        case "attached":
+            return resolved.kind === "unique" || resolved.kind === "hidden";
+        case "visible":
+            return resolved.kind === "unique";
+        case "hidden":
+            return resolved.visibleCount === 0;
+        case "detached":
+            return resolved.kind === "nothing";
+        case "inViewport":
+            return resolved.kind === "unique" && resolved.inViewport;
+    }
+}
+/** How long the visibility probe waits for an animation frame. */
+const VISIBILITY_FRAME_WAIT_MS = 300;
+/** The probe's whole budget: a hidden page also throttles its timers. */
+export const VISIBILITY_PROBE_BUDGET_MS = 1500;
+/**
+ * Reads `document.visibilityState` and whether an animation frame arrives.
+ * WebKit stops animation frames for a page that is hidden or in a fully
+ * covered window, so rAF- and transition-driven UI (a sheet sliding in)
+ * never moves and actionability reads it as obscured.
+ */
+export const VISIBILITY_PROBE_SCRIPT = `new Promise((resolve) => {
+  let done = false;
+  const finish = (frame) => {
+    if (done) return;
+    done = true;
+    resolve({ state: String(document.visibilityState || "unknown"), animationFrames: frame });
+  };
+  try { requestAnimationFrame(() => finish(true)); } catch (_) { finish(false); }
+  setTimeout(() => finish(false), ${VISIBILITY_FRAME_WAIT_MS});
+})`;
+/**
+ * What the probe can say: what it observed, and what usually causes that. It
+ * cannot see the window, so the cause stays a likely one.
+ */
+export const HIDDEN_PAGE_NOTE = "page looked hidden or paused";
+const HIDDEN_PAGE_CAUSE = "a covered window or a sleeping display pauses a page's animations";
+/** Why every page is hidden when the host can tell the screen is locked. */
+export const SCREEN_LOCKED_NOTE = "the screen is locked; unlock it — animations and sheets are paused";
+/** A hidden-page note, naming the lock when that is the cause. */
+export function hiddenCause(note) {
+    return note !== undefined && resolveHost().screenLocked() ? SCREEN_LOCKED_NOTE : note;
+}
+/** What the probe saw, or `undefined` for an unreadable answer. */
+export function pageVisibility(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (typeof record.state !== "string" || typeof record.animationFrames !== "boolean")
+        return undefined;
+    const hidden = record.state === "hidden" || !record.animationFrames;
+    return {
+        state: record.state,
+        animationFrames: record.animationFrames,
+        ...(hidden ? { note: `${HIDDEN_PAGE_NOTE}: visibilityState "${record.state}", ${record.animationFrames ? "animation frames running" : `no animation frame observed within ${VISIBILITY_FRAME_WAIT_MS}ms`} (${HIDDEN_PAGE_CAUSE})` } : {}),
+    };
+}
+/** Collapse every run of whitespace (newlines included) to one space and trim. */
+export function normalizeText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function textMatches(text, expected) {
+    if (expected instanceof RegExp) {
+        expected.lastIndex = 0;
+        return expected.test(text);
+    }
+    return normalizeText(text).toLowerCase().includes(normalizeText(expected).toLowerCase());
+}
 export function sleep(ms) {
     return new Promise((resolve) => {
-        setTimeout(resolve, ms);
+        runnerSetTimeout(resolve, ms);
     });
 }
 //# sourceMappingURL=locator.js.map