@itmetsam/samurai-framework 0.21.2 → 0.21.4

package/dist/assert/value-matchers.js

@@ -0,0 +1,53 @@
+import { format } from "./assertion-error.js";
+/** Calls `fn` and says whether it threw */
+export function callAndCatch(fn) {
+    try {
+        fn();
+        return { threw: false };
+    }
+    catch (error) {
+        return { threw: true, error };
+    }
+}
+function messageOf(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "object" && error !== null && "message" in error)
+        return String(error.message);
+    return String(error);
+}
+/** Whether what was thrown fits `expected`; with no expectation, throwing at all fits */
+export function thrownMatches(outcome, expected) {
+    if (!outcome.threw)
+        return false;
+    if (expected === undefined)
+        return true;
+    if (typeof expected === "string")
+        return messageOf(outcome.error).includes(expected);
+    if (expected instanceof RegExp)
+        return messageOf(outcome.error).search(expected) !== -1;
+    if (expected instanceof Error)
+        return messageOf(outcome.error) === expected.message;
+    return outcome.error instanceof expected;
+}
+/** What a `toThrow` failure shows as the received value */
+export function describeOutcome(outcome) {
+    return outcome.threw ? `threw ${format(outcome.error)}` : "did not throw";
+}
+/** Jest's rule: the difference is under half a unit of the last digit asked for */
+export function isCloseTo(actual, expected, digits) {
+    if (actual === expected)
+        return true;
+    return Math.abs(expected - actual) < Math.pow(10, -digits) / 2;
+}
+/** The `length` of a string, array or array-like; undefined for anything else */
+export function lengthOf(value) {
+    if (typeof value === "string")
+        return value.length;
+    if (typeof value === "object" && value !== null && "length" in value) {
+        const length = value.length;
+        if (typeof length === "number")
+            return length;
+    }
+    return undefined;
+}

package/dist/browser/dialog.js

@@ -30,7 +30,10 @@ export class Dialog {
     }
     /** Clicks OK; `promptText` is typed into a `prompt` first */
     accept(promptText) {
-        return this.answer({ accept: true, ...(promptText !== undefined && { userText: promptText }) });
+        return this.answer({
+            accept: true,
+            ...(promptText !== undefined && { userText: promptText }),
+        });
     }
     /** Clicks Cancel */
     dismiss() {

package/dist/browser/init-script.d.ts

@@ -1,2 +1,13 @@
+import { type PreloadHandle } from "../script/preload.js";
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
 /** Wraps an init script as one function declaration; the argument is embedded as JSON because preload scripts take no arguments */
 export declare function initScriptSource(script: string | ((arg?: any) => void), arg: unknown): string;
+/** The init scripts a page registered, so they can be released with the page */
+export declare class InitScripts {
+    private scripts;
+    /** Registers `script` for every document the context loads from now on, and runs it in the one loaded now */
+    add(biDiConnector: BiDiConnector, contextId: BrowsingContext, script: string | ((arg?: any) => void), arg?: unknown): Promise<PreloadHandle>;
+    /** The scripts still registered */
+    all(): PreloadHandle[];
+}

package/dist/browser/init-script.js

@@ -1,4 +1,5 @@
 import { toFunctionDeclaration } from "../script/call-function.js";
+import { addPreload } from "../script/preload.js";
 /** Wraps an init script as one function declaration; the argument is embedded as JSON because preload scripts take no arguments */
 export function initScriptSource(script, arg) {
     if (typeof script === "string") {
@@ -14,3 +15,31 @@ export function initScriptSource(script, arg) {
     }
     return `() => (${declaration})(${argument})`;
 }
+/** The init scripts a page registered, so they can be released with the page */
+export class InitScripts {
+    constructor() {
+        this.scripts = new Set();
+    }
+    /** Registers `script` for every document the context loads from now on, and runs it in the one loaded now */
+    async add(biDiConnector, contextId, script, arg) {
+        const source = initScriptSource(script, arg);
+        const handle = await addPreload(biDiConnector, {
+            source,
+            contexts: [contextId],
+            onRunError: "log",
+        });
+        const tracked = {
+            id: handle.id,
+            dispose: async () => {
+                this.scripts.delete(tracked);
+                await handle.dispose();
+            },
+        };
+        this.scripts.add(tracked);
+        return tracked;
+    }
+    /** The scripts still registered */
+    all() {
+        return [...this.scripts];
+    }
+}

package/dist/browser/navigation-error.d.ts

@@ -9,5 +9,9 @@ export declare class NavigationError extends Error {
 }
 /** The page did not reach the awaited load state in time */
 export declare class LoadStateTimeoutError extends WaitTimeoutError<undefined> {
-    constructor(state: string, timeout: number);
+    constructor(state: string, timeout: number, operation?: string);
+}
+/** The page's URL did not match in time */
+export declare class UrlTimeoutError extends WaitTimeoutError<string> {
+    constructor(expected: string, timeout: number, lastUrl: string | undefined);
 }

package/dist/browser/navigation-error.js

@@ -11,9 +11,17 @@ export class NavigationError extends Error {
 }
 /** The page did not reach the awaited load state in time */
 export class LoadStateTimeoutError extends WaitTimeoutError {
-    constructor(state, timeout) {
+    constructor(state, timeout, operation = "waitForLoadState") {
         super(timeout, undefined);
         this.name = "LoadStateTimeoutError";
-        this.message = `waitForLoadState("${state}") did not finish within ${timeout}ms`;
+        this.message = `${operation}("${state}") did not finish within ${timeout}ms`;
+    }
+}
+/** The page's URL did not match in time */
+export class UrlTimeoutError extends WaitTimeoutError {
+    constructor(expected, timeout, lastUrl) {
+        super(timeout, lastUrl);
+        this.name = "UrlTimeoutError";
+        this.message = `waitForURL(): the URL did not match ${expected} within ${timeout}ms (last URL: ${lastUrl ?? "unknown"})`;
     }
 }

package/dist/browser/page-content.d.ts

@@ -0,0 +1,5 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+/** The page's markup now, with its doctype */
+export declare function readContent(connector: BiDiConnector, context: string): Promise<string>;
+/** Writes `html` as the page's document; true when the document reached `state` within `timeout` ms */
+export declare function writeContent(connector: BiDiConnector, context: string, html: string, state: "load" | "domcontentloaded", timeout: number): Promise<boolean>;

package/dist/browser/page-content.js

@@ -0,0 +1,43 @@
+import { callFunction } from "../script/call-function.js";
+/** The document as markup: the doctype (when there is one) followed by the document element */
+const READ_CONTENT = `() => {
+  const type = document.doctype;
+  const doctype = type
+    ? "<!DOCTYPE " + type.name +
+      (type.publicId ? ' PUBLIC "' + type.publicId + '"' : "") +
+      (!type.publicId && type.systemId ? " SYSTEM" : "") +
+      (type.systemId ? ' "' + type.systemId + '"' : "") + ">"
+    : "";
+  return doctype + document.documentElement.outerHTML;
+}`;
+/**
+ * Replaces the document in place with `document.open()`, `write()` and `close()`: scripts and styles in `html` run and
+ * apply, and the page keeps its URL and origin. The listeners are added after `open()` because it removes the old ones.
+ * Resolves true once the `load` (or `DOMContentLoaded`) event fired, false when `timeout` ms passed first.
+ */
+const WRITE_CONTENT = `async (html, state, timeout) => {
+  document.open();
+  const reached = new Promise((resolve) => {
+    const done = () => resolve(true);
+    if (state === "domcontentloaded") document.addEventListener("DOMContentLoaded", done, { once: true });
+    else window.addEventListener("load", done, { once: true });
+    setTimeout(() => resolve(false), timeout);
+  });
+  document.write(html);
+  document.close();
+  return reached;
+}`;
+/** The page's markup now, with its doctype */
+export function readContent(connector, context) {
+    return callFunction(connector, context, READ_CONTENT, [], {
+        awaitPromise: false,
+    });
+}
+/** Writes `html` as the page's document; true when the document reached `state` within `timeout` ms */
+export function writeContent(connector, context, html, state, timeout) {
+    return callFunction(connector, context, WRITE_CONTENT, [
+        html,
+        state,
+        timeout,
+    ]);
+}

package/dist/browser/page-evaluate.d.ts

@@ -0,0 +1,9 @@
+import { type PageFunction } from "../script/call-function.js";
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+/** Whether a string is the source of a function (called with the argument) rather than an expression (evaluated) */
+export declare function isFunctionSource(source: string): boolean;
+/**
+ * Runs a function, or a string, in the page and returns the result as plain JavaScript (see `fromRemoteValue`).
+ * A function (or a string holding a function's source) is called with `arg`; any other string is an expression.
+ */
+export declare function evaluateInPage<R, A>(connector: BiDiConnector, context: string, fn: PageFunction<[A], R>, arg?: A): Promise<R>;

package/dist/browser/page-evaluate.js

@@ -0,0 +1,20 @@
+import { callFunction, evaluateExpression, } from "../script/call-function.js";
+/** A function (or arrow function, async or not) written out as source, as opposed to an expression */
+const FUNCTION_SOURCE = /^\s*(?:async\s+)?(?:function\b|(?:\((?:[^()]|\([^()]*\))*\)|[\w$]+)\s*=>)/;
+/** Whether a string is the source of a function (called with the argument) rather than an expression (evaluated) */
+export function isFunctionSource(source) {
+    return FUNCTION_SOURCE.test(source);
+}
+/**
+ * Runs a function, or a string, in the page and returns the result as plain JavaScript (see `fromRemoteValue`).
+ * A function (or a string holding a function's source) is called with `arg`; any other string is an expression.
+ */
+export async function evaluateInPage(connector, context, fn, arg) {
+    if (typeof fn === "string" && !isFunctionSource(fn)) {
+        if (arg !== undefined) {
+            throw new TypeError("evaluate(): an expression takes no argument; pass a function to use one");
+        }
+        return evaluateExpression(connector, context, fn);
+    }
+    return callFunction(connector, context, fn, arg === undefined ? [] : [arg]);
+}

package/dist/browser/page-locators.d.ts

@@ -0,0 +1,18 @@
+import Locator from "../locator/locator.js";
+import type { HelperRealm } from "../locator/helper-realm.js";
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
+import type { PageConfig } from "./page-settings.js";
+/** Makes the page's locators, and holds whether they are strict */
+export declare class PageLocators {
+    private biDiConnector;
+    private id;
+    private helperRealm;
+    private pageConfig;
+    private assertOpen;
+    private strictOverride;
+    constructor(biDiConnector: BiDiConnector, id: BrowsingContext, helperRealm: HelperRealm, pageConfig: PageConfig, assertOpen: () => void);
+    locate(selector: ConstructorParameters<typeof Locator>[0]): Locator;
+    /** `undefined` goes back to config `use.strictSelectors`; a locator asks once, at its first action or read, so earlier ones that already ran keep their answer */
+    setStrictSelectors(enabled: boolean | undefined): void;
+}

package/dist/browser/page-locators.js

@@ -0,0 +1,19 @@
+import Locator from "../locator/locator.js";
+/** Makes the page's locators, and holds whether they are strict */
+export class PageLocators {
+    constructor(biDiConnector, id, helperRealm, pageConfig, assertOpen) {
+        this.biDiConnector = biDiConnector;
+        this.id = id;
+        this.helperRealm = helperRealm;
+        this.pageConfig = pageConfig;
+        this.assertOpen = assertOpen;
+    }
+    locate(selector) {
+        this.assertOpen();
+        return new Locator(selector, this.biDiConnector, this.id, this.helperRealm, [], () => this.pageConfig.strictSelectors(this.strictOverride));
+    }
+    /** `undefined` goes back to config `use.strictSelectors`; a locator asks once, at its first action or read, so earlier ones that already ran keep their answer */
+    setStrictSelectors(enabled) {
+        this.strictOverride = enabled;
+    }
+}

package/dist/browser/page-navigation.d.ts

@@ -1,4 +1,5 @@
 import type { BiDiConnector } from "../transport/bidi-connection.js";
+import { type UrlPattern } from "../network/url-match.js";
 import type { DocumentWatcher } from "./document-watcher.js";
 import type { PageConfig, ReadinessState } from "./page-settings.js";
 export type LoadState = "load" | "domcontentloaded" | "networkidle";
@@ -54,6 +55,23 @@ export declare class PageNavigation {
     waitForLoadState(state?: LoadState, options?: {
         timeout?: number;
     }): Promise<void>;
+    /**
+     * Waits until the page's URL matches `url` (a string equals it, or with `*` / `**` is a glob; a RegExp is tested on it;
+     * a function gets it as a `URL`), then waits for `waitUntil` (default "load"). A string starting with "/", "./" or
+     * "../" resolves against the base URL, as in `goto`. `timeout` applies to the URL, then again to the load state.
+     */
+    waitForURL(url: UrlPattern | ((url: URL) => boolean), options?: {
+        timeout?: number;
+        waitUntil?: LoadState;
+    }): Promise<void>;
+    /**
+     * Replaces the document with `html` (see `writeContent`) and waits for `waitUntil` (default "load"); "networkidle" is
+     * "load" plus a quiet network. The page keeps its URL.
+     */
+    setContent(html: string, options?: {
+        timeout?: number;
+        waitUntil?: LoadState;
+    }): Promise<void>;
     /**
      * Runs a navigation command and settles what waiting for it means: failures become NavigationErrors, and a
      * navigation that did not wait for the load is watched so `waitForLoadState` can tell it from the old page.

package/dist/browser/page-navigation.js

@@ -1,8 +1,11 @@
+import logger from "../logger/index.js";
 import { peekRunSettings } from "../config/run-settings.js";
 import { BiDiError } from "../transport/bidi-error.js";
 import { UnsupportedOperationError } from "../transport/unsupported.js";
-import { WaitTimeoutError } from "../wait/wait-until.js";
-import { LoadStateTimeoutError, NavigationError } from "./navigation-error.js";
+import { matchUrl } from "../network/url-match.js";
+import { waitUntil, WaitTimeoutError } from "../wait/wait-until.js";
+import { LoadStateTimeoutError, NavigationError, UrlTimeoutError, } from "./navigation-error.js";
+import { writeContent } from "./page-content.js";
 /** A URL starting with "/", "./" or "../" */
 const RELATIVE_URL = /^\.{0,2}\//;
 /** Resolves a slash-led `url` against `base`; any other URL is returned as given */
@@ -88,6 +91,53 @@ export class PageNavigation {
         if (state === "networkidle")
             await this.deps.waitForNetworkIdle({ timeout });
     }
+    /**
+     * Waits until the page's URL matches `url` (a string equals it, or with `*` / `**` is a glob; a RegExp is tested on it;
+     * a function gets it as a `URL`), then waits for `waitUntil` (default "load"). A string starting with "/", "./" or
+     * "../" resolves against the base URL, as in `goto`. `timeout` applies to the URL, then again to the load state.
+     */
+    async waitForURL(url, options = {}) {
+        this.deps.assertOpen();
+        const timeout = await this.deps.config.navigationTimeout(options.timeout);
+        const pattern = typeof url === "string" ? this.resolveURL(url, "waitForURL") : url;
+        const matches = typeof pattern === "function"
+            ? (current) => pattern(new URL(current))
+            : (current) => matchUrl(pattern, current);
+        // A read that fails while the page navigates counts as no URL yet
+        const read = () => this.deps.url().catch((err) => {
+            this.deps.assertOpen();
+            logger.debug("waitForURL could not read the URL", { err });
+            return undefined;
+        });
+        try {
+            await waitUntil(read, (current) => current !== undefined && matches(current), { timeout });
+        }
+        catch (err) {
+            if (!(err instanceof WaitTimeoutError))
+                throw err;
+            const wanted = typeof pattern === "function"
+                ? "the predicate"
+                : typeof pattern === "string"
+                    ? `"${pattern}"`
+                    : String(pattern);
+            throw new UrlTimeoutError(wanted, timeout, err.last);
+        }
+        await this.waitForLoadState(options.waitUntil, { timeout });
+    }
+    /**
+     * Replaces the document with `html` (see `writeContent`) and waits for `waitUntil` (default "load"); "networkidle" is
+     * "load" plus a quiet network. The page keeps its URL.
+     */
+    async setContent(html, options = {}) {
+        this.deps.assertOpen();
+        const timeout = await this.deps.config.navigationTimeout(options.timeout);
+        const state = options.waitUntil ?? "load";
+        const reached = await writeContent(this.connector, this.contextId, html, state === "domcontentloaded" ? "domcontentloaded" : "load", timeout);
+        if (!reached)
+            throw new LoadStateTimeoutError(state, timeout, "setContent");
+        if (state === "networkidle")
+            await this.deps.waitForNetworkIdle({ timeout });
+    }
     /**
      * Runs a navigation command and settles what waiting for it means: failures become NavigationErrors, and a
      * navigation that did not wait for the load is watched so `waitForLoadState` can tell it from the old page.

package/dist/browser/page-permissions.d.ts

@@ -0,0 +1,6 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BrowserContext } from "./browser-context.js";
+/** Grants a browser permission to the origin of the page (`url`), or to `options.origin` */
+export declare function grantPermission(biDiConnector: BiDiConnector, url: () => Promise<string>, context: () => BrowserContext | undefined, name: string, options?: {
+    origin?: string;
+}): Promise<void>;

package/dist/browser/page-permissions.js

@@ -0,0 +1,15 @@
+/** Grants a browser permission to the origin of the page (`url`), or to `options.origin` */
+export async function grantPermission(biDiConnector, url, context, name, options = {}) {
+    const origin = options.origin ?? new URL(await url()).origin;
+    // about:blank and data: pages have no origin to grant to
+    if (origin === "null")
+        throw new Error("grantPermission(): needs a page on a web origin, or an explicit origin option");
+    const browserContext = context();
+    await biDiConnector.send("permissions.setPermission", {
+        descriptor: { name },
+        state: "granted",
+        origin,
+        ...(browserContext &&
+            !browserContext.isDefault && { userContext: browserContext.id }),
+    });
+}

package/dist/browser/page-settings.d.ts

@@ -25,7 +25,10 @@ export declare class PageConfig {
             height: number;
         } | null;
         headless?: boolean;
+        strictSelectors?: boolean;
     }>;
+    /** Whether locators throw when they match several elements: the given override, else config `use.strictSelectors`, else no */
+    strictSelectors(override?: boolean): Promise<boolean>;
     /** The time (ms) a navigation or a wait may take: the call's, else config `navigation.timeout`, else 30 s */
     navigationTimeout(override?: number): Promise<number>;
     /** What a navigation waits for: the call's, else config `navigation.waitUntil`, else the load event */

package/dist/browser/page-settings.js

@@ -31,6 +31,10 @@ export class PageConfig {
             ? Promise.resolve(this.given.use)
             : readSection("use");
     }
+    /** Whether locators throw when they match several elements: the given override, else config `use.strictSelectors`, else no */
+    async strictSelectors(override) {
+        return override ?? (await this.use()).strictSelectors ?? false;
+    }
     /** The time (ms) a navigation or a wait may take: the call's, else config `navigation.timeout`, else 30 s */
     async navigationTimeout(override) {
         return (override ??

package/dist/browser/page.d.ts

@@ -1,5 +1,7 @@
 import Locator from "../locator/locator.js";
-import type { TextOptions } from "../locator/selector.js";
+import type { FilterOptions } from "../locator/filter-step.js";
+import type { RoleOptions } from "../locator/role-locator.js";
+import type { ExactOption, TextOptions } from "../locator/selector.js";
 import type { NetworkRequest } from "../network/network-tracker.js";
 import type { Recorder, RecorderOptions } from "../recorder/recorder.js";
 import { ContextTree } from "./context-tree.js";
@@ -21,8 +23,9 @@ export type { PageEventName, WaitableEventName, WaitForEventOptions, WaitOptions
 import { type PageSettings, type ReadinessState } from "./page-settings.js";
 export type { PageSettings, ReadinessState };
 import { type Viewport } from "./viewport.js";
-import { type PreloadHandle } from "../script/preload.js";
+import type { PreloadHandle } from "../script/preload.js";
 import type { BiDiConnector } from "../transport/bidi-connection.js";
+import { type PageFunction } from "../script/call-function.js";
 import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
 export type { LoadState, NavigateOptions, NavigationResult };
 export default class Page {
@@ -32,6 +35,7 @@ export default class Page {
     private helperRealm;
     private initScripts;
     private pageConfig;
+    private locators;
     private pageEvents;
     private documents;
     private nav;
@@ -43,27 +47,42 @@ export default class Page {
     private browserContext;
     private transfers;
     private evidence;
+    private knownViewport;
     /** `settings` override what `samurai.config.ts` says; without them the config is read when needed */
     constructor(biDiConnector: BiDiConnector, contextId: string, settings?: PageSettings);
     /** The BiDi browsing context id of this page's top-level context */
     get contextId(): BrowsingContext;
     /** The context tree, created on first use and shared by everything that needs to attribute frame events to this page */
     tree(): Promise<ContextTree>;
-    /** Locates an element on the page and returns an interactable object */
-    locator(xpath: string): Locator;
-    private locate;
+    /**
+     * Locates elements on the page. An xpath (`//x`, `/html/body`, `(//x)[2]`, `./x`, `xpath=…`, or an older
+     * relative one such as `a[@id='x']`) or a css selector (`input[name='x']`, `a, button`, `css=…`).
+     * `options` filter the matches, as `locator.filter()` does
+     */
+    locator(selector: string, options?: FilterOptions<Locator>): Locator;
+    /**
+     * Makes this page's locators strict (or not): an action or read on a locator matching several elements then
+     * throws `name(): strict mode violation, N elements match ...` instead of using the first. `undefined` goes back
+     * to config `use.strictSelectors` (off unless set). Applies to locators made afterwards and to earlier ones that have not
+     * run an action or read yet: a locator keeps the answer it got at its first one
+     */
+    setStrictSelectors(enabled: boolean | undefined): void;
     /** Locates elements with a CSS selector */
     getByCss(css: string): Locator;
-    /** Locates elements by their text: an exact match unless `match: "partial"` */
-    getByText(text: string, options?: TextOptions): Locator;
-    /** Locates form controls by their label text: an exact match unless `match: "partial"` */
-    getByLabel(text: string, options?: TextOptions): Locator;
+    /** Locates elements by their text: an exact match unless `match: "partial"` or `exact: false`; a RegExp is tested as written (see `TextOptions`) */
+    getByText(text: string | RegExp, options?: TextOptions): Locator;
+    /** Locates form controls by their label text: an exact match unless `match: "partial"` or `exact: false`; a RegExp is tested as written */
+    getByLabel(text: string | RegExp, options?: TextOptions): Locator;
+    /** Locates elements by their `placeholder` (see `TextOptions` for `exact` and RegExp) */
+    getByPlaceholder(text: string | RegExp, options?: ExactOption): Locator;
+    /** Locates elements by their `alt` text (images, areas, image inputs) */
+    getByAltText(text: string | RegExp, options?: ExactOption): Locator;
+    /** Locates elements by their `title` attribute */
+    getByTitle(text: string | RegExp, options?: ExactOption): Locator;
     /** Locates elements by their `data-testid` attribute */
     getByTestId(testId: string): Locator;
-    /** Locates elements by ARIA role and, optionally, accessible name */
-    getByRole(role: string, options?: {
-        name?: string;
-    }): Locator;
+    /** Locates elements by ARIA role and, optionally, accessible name and state (see `RoleOptions`) */
+    getByRole(role: string, options?: RoleOptions): Locator;
     /**
      * Runs `script` before any page script in every document this page loads from now on, and once in
      * the document that is loaded now. It runs in the page's own realm, so the page sees what it sets.
@@ -117,14 +136,58 @@ export default class Page {
     goForward(): Promise<boolean>;
     /** The URL of the page now */
     url(): Promise<string>;
+    /**
+     * Waits until the URL matches `url` (a string equals it, or with `*` / `**` is a glob; a RegExp is tested on it;
+     * a function gets it as a `URL`), then until the page reached `waitUntil` (default "load"). Also sees `pushState`.
+     * @example
+     *  await page.getByRole("button", { name: "Sign in" }).click();
+     *  await page.waitForURL("**\/dashboard");
+     */
+    waitForURL(url: UrlPattern | ((url: URL) => boolean), options?: {
+        timeout?: number;
+        waitUntil?: LoadState;
+    }): Promise<void>;
+    /** The markup of the document now, doctype included */
+    content(): Promise<string>;
+    /**
+     * Replaces the document with `html` and waits for `waitUntil` (default "load"). Scripts and styles in it run and apply;
+     * the page keeps its URL and origin (it is not a `data:` page).
+     * @example
+     *  await page.setContent("<button>Go</button><script>document.title = 'x'</script>");
+     */
+    setContent(html: string, options?: {
+        timeout?: number;
+        waitUntil?: LoadState;
+    }): Promise<void>;
     /** The title of the document now */
     title(): Promise<string>;
+    /**
+     * Runs `fn` in the page, with `arg` as its only argument, and returns the result (a promise is awaited). `fn` is a function,
+     * the source of one (`"async () => ..."`), or any other string, which is an expression (`"document.title"`; it takes no argument).
+     * Values come back as plain JavaScript: Date, Map, Set, RegExp, BigInt, NaN, undefined, nested objects and arrays;
+     * an element as an `ElementHandle`; what cannot be copied (a function, window, error, promise) as a `RemoteObject` with its `type`.
+     * The page's own error message is kept (`ScriptError`). A function written under tsx must not contain named inner functions
+     * (the transpiler adds a `__name` helper the page lacks); a string always works.
+     * @example
+     *  const count = await page.evaluate((min) => document.querySelectorAll("li").length > min, 3);
+     */
+    evaluate<R = unknown, A = unknown>(fn: PageFunction<[A], R>, arg?: A): Promise<R>;
     /**
      * Sets the size of the viewport (and, optionally, the device pixel ratio); `null` puts the browser's own size back.
      * @example
      *  await page.setViewport({ width: 390, height: 844, devicePixelRatio: 3 });
      */
     setViewport(viewport: Viewport | null): Promise<void>;
+    /** Playwright's name for `setViewport` */
+    setViewportSize(size: Viewport): Promise<void>;
+    /**
+     * The size this page was last given (`setViewport`, `setViewportSize`, or the default from config `use.viewport` when the
+     * browser opened it), read at once; null before one is known, after `setViewport(null)` and when config turns the viewport off.
+     */
+    viewportSize(): {
+        width: number;
+        height: number;
+    } | null;
     /** Gives the page the size from config `use.viewport` (1280x720 by default); the browser does this when it opens a page */
     applyDefaultViewport(): Promise<void>;
     /**