@sylix/coworker 1.4.2 → 1.5.2

package/dist/services/browser/sandbox/forked-client/src/client/page.js

@@ -0,0 +1,754 @@
+"use strict";
+// @ts-nocheck
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BindingCall = exports.Page = void 0;
+const artifact_1 = require("./artifact");
+const channelOwner_1 = require("./channelOwner");
+const clientHelper_1 = require("./clientHelper");
+const coverage_1 = require("./coverage");
+const disposable_1 = require("./disposable");
+const download_1 = require("./download");
+const elementHandle_1 = require("./elementHandle");
+const errors_1 = require("./errors");
+const events_1 = require("./events");
+const fileChooser_1 = require("./fileChooser");
+const frame_1 = require("./frame");
+const harRouter_1 = require("./harRouter");
+const input_1 = require("./input");
+const jsHandle_1 = require("./jsHandle");
+const network_1 = require("./network");
+const video_1 = require("./video");
+const screencast_1 = require("./screencast");
+const waiter_1 = require("./waiter");
+const worker_1 = require("./worker");
+const timeoutSettings_1 = require("./timeoutSettings");
+const assert_1 = require("../utils/isomorphic/assert");
+const fileUtils_1 = require("./fileUtils");
+const headers_1 = require("../utils/isomorphic/headers");
+const stringUtils_1 = require("../utils/isomorphic/stringUtils");
+const urlMatch_1 = require("../utils/isomorphic/urlMatch");
+const manualPromise_1 = require("../utils/isomorphic/manualPromise");
+const rtti_1 = require("../utils/isomorphic/rtti");
+const consoleMessage_1 = require("./consoleMessage");
+class Page extends channelOwner_1.ChannelOwner {
+    static from(page) {
+        return page._object;
+    }
+    static fromNullable(page) {
+        return page ? Page.from(page) : null;
+    }
+    constructor(parent, type, guid, initializer) {
+        super(parent, type, guid, initializer);
+        this._frames = new Set();
+        this._workers = new Set();
+        this._closed = false;
+        this._closedOrCrashedScope = new manualPromise_1.LongStandingScope();
+        this._routes = [];
+        this._webSocketRoutes = [];
+        this._bindings = new Map();
+        this._closeWasCalled = false;
+        this._harRouters = [];
+        this._locatorHandlers = new Map();
+        this._instrumentation.onPage(this);
+        this._browserContext = parent;
+        this._timeoutSettings = new timeoutSettings_1.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
+        this.keyboard = new input_1.Keyboard(this);
+        this.mouse = new input_1.Mouse(this);
+        this.request = this._browserContext.request;
+        this.touchscreen = new input_1.Touchscreen(this);
+        this.clock = this._browserContext.clock;
+        this._mainFrame = frame_1.Frame.from(initializer.mainFrame);
+        this._mainFrame._page = this;
+        this._frames.add(this._mainFrame);
+        this._viewportSize = initializer.viewportSize;
+        this._closed = initializer.isClosed;
+        this._opener = Page.fromNullable(initializer.opener);
+        this._video = new video_1.Video(this, this._connection, initializer.video ? artifact_1.Artifact.from(initializer.video) : undefined);
+        this.screencast = new screencast_1.Screencast(this);
+        this._channel.on("bindingCall", ({ binding }) => this._onBinding(BindingCall.from(binding)));
+        this._channel.on("close", () => this._onClose());
+        this._channel.on("crash", () => this._onCrash());
+        this._channel.on("download", ({ url, suggestedFilename, artifact }) => {
+            const artifactObject = artifact_1.Artifact.from(artifact);
+            this.emit(events_1.Events.Page.Download, new download_1.Download(this, url, suggestedFilename, artifactObject));
+        });
+        this._channel.on("fileChooser", ({ element, isMultiple }) => this.emit(events_1.Events.Page.FileChooser, new fileChooser_1.FileChooser(this, elementHandle_1.ElementHandle.from(element), isMultiple)));
+        this._channel.on("frameAttached", ({ frame }) => this._onFrameAttached(frame_1.Frame.from(frame)));
+        this._channel.on("frameDetached", ({ frame }) => this._onFrameDetached(frame_1.Frame.from(frame)));
+        this._channel.on("locatorHandlerTriggered", ({ uid }) => this._onLocatorHandlerTriggered(uid));
+        this._channel.on("route", ({ route }) => this._onRoute(network_1.Route.from(route)));
+        this._channel.on("webSocketRoute", ({ webSocketRoute }) => this._onWebSocketRoute(network_1.WebSocketRoute.from(webSocketRoute)));
+        this._channel.on("viewportSizeChanged", ({ viewportSize }) => (this._viewportSize = viewportSize));
+        this._channel.on("webSocket", ({ webSocket }) => this.emit(events_1.Events.Page.WebSocket, network_1.WebSocket.from(webSocket)));
+        this._channel.on("worker", ({ worker }) => this._onWorker(worker_1.Worker.from(worker)));
+        this.coverage = new coverage_1.Coverage(this._channel);
+        this.once(events_1.Events.Page.Close, () => this._closedOrCrashedScope.close(this._closeErrorWithReason()));
+        this.once(events_1.Events.Page.Crash, () => this._closedOrCrashedScope.close(new errors_1.TargetClosedError()));
+        this._setEventToSubscriptionMapping(new Map([
+            [events_1.Events.Page.Console, "console"],
+            [events_1.Events.Page.Dialog, "dialog"],
+            [events_1.Events.Page.Request, "request"],
+            [events_1.Events.Page.Response, "response"],
+            [events_1.Events.Page.RequestFinished, "requestFinished"],
+            [events_1.Events.Page.RequestFailed, "requestFailed"],
+            [events_1.Events.Page.FileChooser, "fileChooser"],
+        ]));
+    }
+    _onFrameAttached(frame) {
+        frame._page = this;
+        this._frames.add(frame);
+        if (frame._parentFrame)
+            frame._parentFrame._childFrames.add(frame);
+        this.emit(events_1.Events.Page.FrameAttached, frame);
+    }
+    _onFrameDetached(frame) {
+        this._frames.delete(frame);
+        frame._detached = true;
+        if (frame._parentFrame)
+            frame._parentFrame._childFrames.delete(frame);
+        this.emit(events_1.Events.Page.FrameDetached, frame);
+    }
+    async _onRoute(route) {
+        route._context = this.context();
+        const routeHandlers = this._routes.slice();
+        for (const routeHandler of routeHandlers) {
+            // If the page was closed we stall all requests right away.
+            if (this._closeWasCalled || this._browserContext.isClosedOrClosing())
+                return;
+            if (!routeHandler.matches(route.request().url()))
+                continue;
+            const index = this._routes.indexOf(routeHandler);
+            if (index === -1)
+                continue;
+            if (routeHandler.willExpire())
+                this._routes.splice(index, 1);
+            const handled = await routeHandler.handle(route);
+            if (!this._routes.length)
+                this._updateInterceptionPatterns({ internal: true }).catch(() => { });
+            if (handled)
+                return;
+        }
+        await this._browserContext._onRoute(route);
+    }
+    async _onWebSocketRoute(webSocketRoute) {
+        const routeHandler = this._webSocketRoutes.find((route) => route.matches(webSocketRoute.url()));
+        if (routeHandler)
+            await routeHandler.handle(webSocketRoute);
+        else
+            await this._browserContext._onWebSocketRoute(webSocketRoute);
+    }
+    async _onBinding(bindingCall) {
+        const func = this._bindings.get(bindingCall._initializer.name);
+        if (func) {
+            await bindingCall.call(func);
+            return;
+        }
+        await this._browserContext._onBinding(bindingCall);
+    }
+    _onWorker(worker) {
+        this._workers.add(worker);
+        worker._page = this;
+        this.emit(events_1.Events.Page.Worker, worker);
+    }
+    _onClose() {
+        this._closed = true;
+        this._browserContext._pages.delete(this);
+        this._disposeHarRouters();
+        this.emit(events_1.Events.Page.Close, this);
+    }
+    _onCrash() {
+        this.emit(events_1.Events.Page.Crash, this);
+    }
+    context() {
+        return this._browserContext;
+    }
+    async opener() {
+        if (!this._opener || this._opener.isClosed())
+            return null;
+        return this._opener;
+    }
+    mainFrame() {
+        return this._mainFrame;
+    }
+    frame(frameSelector) {
+        const name = (0, rtti_1.isString)(frameSelector) ? frameSelector : frameSelector.name;
+        const url = (0, rtti_1.isObject)(frameSelector) ? frameSelector.url : undefined;
+        (0, assert_1.assert)(name || url, "Either name or url matcher should be specified");
+        return (this.frames().find((f) => {
+            if (name)
+                return f.name() === name;
+            return (0, urlMatch_1.urlMatches)(this._browserContext._options.baseURL, f.url(), url);
+        }) || null);
+    }
+    frames() {
+        return [...this._frames];
+    }
+    setDefaultNavigationTimeout(timeout) {
+        this._timeoutSettings.setDefaultNavigationTimeout(timeout);
+    }
+    setDefaultTimeout(timeout) {
+        this._timeoutSettings.setDefaultTimeout(timeout);
+    }
+    video() {
+        return this._video;
+    }
+    async pickLocator() {
+        const { selector } = await this._channel.pickLocator({});
+        return this.locator(selector);
+    }
+    async cancelPickLocator() {
+        await this._channel.cancelPickLocator({});
+    }
+    async $(selector, options) {
+        return await this._mainFrame.$(selector, options);
+    }
+    async waitForSelector(selector, options) {
+        return await this._mainFrame.waitForSelector(selector, options);
+    }
+    async dispatchEvent(selector, type, eventInit, options) {
+        return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
+    }
+    async evaluateHandle(pageFunction, arg) {
+        (0, jsHandle_1.assertMaxArguments)(arguments.length, 2);
+        return await this._mainFrame.evaluateHandle(pageFunction, arg);
+    }
+    async $eval(selector, pageFunction, arg) {
+        (0, jsHandle_1.assertMaxArguments)(arguments.length, 3);
+        return await this._mainFrame.$eval(selector, pageFunction, arg);
+    }
+    async $$eval(selector, pageFunction, arg) {
+        (0, jsHandle_1.assertMaxArguments)(arguments.length, 3);
+        return await this._mainFrame.$$eval(selector, pageFunction, arg);
+    }
+    async $$(selector) {
+        return await this._mainFrame.$$(selector);
+    }
+    async addScriptTag(options = {}) {
+        return await this._mainFrame.addScriptTag(options);
+    }
+    async addStyleTag(options = {}) {
+        return await this._mainFrame.addStyleTag(options);
+    }
+    async exposeFunction(name, callback) {
+        const result = await this._channel.exposeBinding({ name });
+        const binding = (source, ...args) => callback(...args);
+        this._bindings.set(name, binding);
+        return disposable_1.DisposableObject.from(result.disposable);
+    }
+    async exposeBinding(name, callback, options = {}) {
+        const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
+        this._bindings.set(name, callback);
+        return disposable_1.DisposableObject.from(result.disposable);
+    }
+    async setExtraHTTPHeaders(headers) {
+        (0, network_1.validateHeaders)(headers);
+        await this._channel.setExtraHTTPHeaders({ headers: (0, headers_1.headersObjectToArray)(headers) });
+    }
+    url() {
+        return this._mainFrame.url();
+    }
+    async content() {
+        return await this._mainFrame.content();
+    }
+    async setContent(html, options) {
+        return await this._mainFrame.setContent(html, options);
+    }
+    async goto(url, options) {
+        return await this._mainFrame.goto(url, options);
+    }
+    async reload(options = {}) {
+        const waitUntil = (0, frame_1.verifyLoadState)("waitUntil", options.waitUntil === undefined ? "load" : options.waitUntil);
+        return network_1.Response.fromNullable((await this._channel.reload({
+            ...options,
+            waitUntil,
+            timeout: this._timeoutSettings.navigationTimeout(options),
+        })).response);
+    }
+    async addLocatorHandler(locator, handler, options = {}) {
+        if (locator._frame !== this._mainFrame)
+            throw new Error(`Locator must belong to the main frame of this page`);
+        if (options.times === 0)
+            return;
+        const { uid } = await this._channel.registerLocatorHandler({
+            selector: locator._selector,
+            noWaitAfter: options.noWaitAfter,
+        });
+        this._locatorHandlers.set(uid, { locator, handler, times: options.times });
+    }
+    async _onLocatorHandlerTriggered(uid) {
+        let remove = false;
+        try {
+            const handler = this._locatorHandlers.get(uid);
+            if (handler && handler.times !== 0) {
+                if (handler.times !== undefined)
+                    handler.times--;
+                await handler.handler(handler.locator);
+            }
+            remove = handler?.times === 0;
+        }
+        finally {
+            if (remove)
+                this._locatorHandlers.delete(uid);
+            this._channel.resolveLocatorHandlerNoReply({ uid, remove }).catch(() => { });
+        }
+    }
+    async removeLocatorHandler(locator) {
+        for (const [uid, data] of this._locatorHandlers) {
+            if (data.locator._equals(locator)) {
+                this._locatorHandlers.delete(uid);
+                await this._channel.unregisterLocatorHandler({ uid }).catch(() => { });
+            }
+        }
+    }
+    async waitForLoadState(state, options) {
+        return await this._mainFrame.waitForLoadState(state, options);
+    }
+    async waitForNavigation(options) {
+        return await this._mainFrame.waitForNavigation(options);
+    }
+    async waitForURL(url, options) {
+        return await this._mainFrame.waitForURL(url, options);
+    }
+    async waitForRequest(urlOrPredicate, options = {}) {
+        const predicate = async (request) => {
+            if ((0, rtti_1.isString)(urlOrPredicate) || (0, rtti_1.isRegExp)(urlOrPredicate))
+                return (0, urlMatch_1.urlMatches)(this._browserContext._options.baseURL, request.url(), urlOrPredicate);
+            return await urlOrPredicate(request);
+        };
+        const trimmedUrl = trimUrl(urlOrPredicate);
+        const logLine = trimmedUrl ? `waiting for request ${trimmedUrl}` : undefined;
+        return await this._waitForEvent(events_1.Events.Page.Request, { predicate, timeout: options.timeout }, logLine);
+    }
+    async waitForResponse(urlOrPredicate, options = {}) {
+        const predicate = async (response) => {
+            if ((0, rtti_1.isString)(urlOrPredicate) || (0, rtti_1.isRegExp)(urlOrPredicate))
+                return (0, urlMatch_1.urlMatches)(this._browserContext._options.baseURL, response.url(), urlOrPredicate);
+            return await urlOrPredicate(response);
+        };
+        const trimmedUrl = trimUrl(urlOrPredicate);
+        const logLine = trimmedUrl ? `waiting for response ${trimmedUrl}` : undefined;
+        return await this._waitForEvent(events_1.Events.Page.Response, { predicate, timeout: options.timeout }, logLine);
+    }
+    async waitForEvent(event, optionsOrPredicate = {}) {
+        return await this._waitForEvent(event, optionsOrPredicate, `waiting for event "${event}"`);
+    }
+    _closeErrorWithReason() {
+        return new errors_1.TargetClosedError(this._closeReason || this._browserContext._effectiveCloseReason());
+    }
+    async _waitForEvent(event, optionsOrPredicate, logLine) {
+        return await this._wrapApiCall(async () => {
+            const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
+            const predicate = typeof optionsOrPredicate === "function"
+                ? optionsOrPredicate
+                : optionsOrPredicate.predicate;
+            const waiter = waiter_1.Waiter.createForEvent(this, event);
+            if (logLine)
+                waiter.log(logLine);
+            waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
+            if (event !== events_1.Events.Page.Crash)
+                waiter.rejectOnEvent(this, events_1.Events.Page.Crash, new Error("Page crashed"));
+            if (event !== events_1.Events.Page.Close)
+                waiter.rejectOnEvent(this, events_1.Events.Page.Close, () => this._closeErrorWithReason());
+            const result = await waiter.waitForEvent(this, event, predicate);
+            waiter.dispose();
+            return result;
+        });
+    }
+    async goBack(options = {}) {
+        const waitUntil = (0, frame_1.verifyLoadState)("waitUntil", options.waitUntil === undefined ? "load" : options.waitUntil);
+        return network_1.Response.fromNullable((await this._channel.goBack({
+            ...options,
+            waitUntil,
+            timeout: this._timeoutSettings.navigationTimeout(options),
+        })).response);
+    }
+    async goForward(options = {}) {
+        const waitUntil = (0, frame_1.verifyLoadState)("waitUntil", options.waitUntil === undefined ? "load" : options.waitUntil);
+        return network_1.Response.fromNullable((await this._channel.goForward({
+            ...options,
+            waitUntil,
+            timeout: this._timeoutSettings.navigationTimeout(options),
+        })).response);
+    }
+    async requestGC() {
+        await this._channel.requestGC();
+    }
+    async emulateMedia(options = {}) {
+        await this._channel.emulateMedia({
+            media: options.media === null ? "no-override" : options.media,
+            colorScheme: options.colorScheme === null ? "no-override" : options.colorScheme,
+            reducedMotion: options.reducedMotion === null ? "no-override" : options.reducedMotion,
+            forcedColors: options.forcedColors === null ? "no-override" : options.forcedColors,
+            contrast: options.contrast === null ? "no-override" : options.contrast,
+        });
+    }
+    async setViewportSize(viewportSize) {
+        this._viewportSize = viewportSize;
+        await this._channel.setViewportSize({ viewportSize });
+    }
+    viewportSize() {
+        return this._viewportSize || null;
+    }
+    async evaluate(pageFunction, arg) {
+        (0, jsHandle_1.assertMaxArguments)(arguments.length, 2);
+        return await this._mainFrame.evaluate(pageFunction, arg);
+    }
+    async addInitScript(script, arg) {
+        const source = await (0, clientHelper_1.evaluationScript)(this._platform, script, arg);
+        return disposable_1.DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
+    }
+    async route(url, handler, options = {}) {
+        this._routes.unshift(new network_1.RouteHandler(this._platform, this._browserContext._options.baseURL, url, handler, options.times));
+        await this._updateInterceptionPatterns({ title: "Route requests" });
+        return new disposable_1.DisposableStub(() => this.unroute(url, handler));
+    }
+    async routeFromHAR(har, options = {}) {
+        const localUtils = this._connection.localUtils();
+        if (!localUtils)
+            throw new Error("Route from har is not supported in thin clients");
+        if (options.update) {
+            await this._browserContext._recordIntoHAR(har, this, options);
+            return;
+        }
+        const harRouter = await harRouter_1.HarRouter.create(localUtils, har, options.notFound || "abort", {
+            urlMatch: options.url,
+        });
+        this._harRouters.push(harRouter);
+        await harRouter.addPageRoute(this);
+    }
+    async routeWebSocket(url, handler) {
+        this._webSocketRoutes.unshift(new network_1.WebSocketRouteHandler(this._browserContext._options.baseURL, url, handler));
+        await this._updateWebSocketInterceptionPatterns({ title: "Route WebSockets" });
+    }
+    _disposeHarRouters() {
+        this._harRouters.forEach((router) => router.dispose());
+        this._harRouters = [];
+    }
+    async unrouteAll(options) {
+        await this._unrouteInternal(this._routes, [], options?.behavior);
+        this._disposeHarRouters();
+    }
+    async unroute(url, handler) {
+        const removed = [];
+        const remaining = [];
+        for (const route of this._routes) {
+            if ((0, urlMatch_1.urlMatchesEqual)(route.url, url) && (!handler || route.handler === handler))
+                removed.push(route);
+            else
+                remaining.push(route);
+        }
+        await this._unrouteInternal(removed, remaining, "default");
+    }
+    async _unrouteInternal(removed, remaining, behavior) {
+        this._routes = remaining;
+        if (behavior && behavior !== "default") {
+            const promises = removed.map((routeHandler) => routeHandler.stop(behavior));
+            await Promise.all(promises);
+        }
+        await this._updateInterceptionPatterns({ title: "Unroute requests" });
+    }
+    async _updateInterceptionPatterns(options) {
+        const patterns = network_1.RouteHandler.prepareInterceptionPatterns(this._routes);
+        await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }), options);
+    }
+    async _updateWebSocketInterceptionPatterns(options) {
+        const patterns = network_1.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
+        await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }), options);
+    }
+    async screenshot(options = {}) {
+        const mask = options.mask;
+        const copy = {
+            ...options,
+            path: undefined,
+            mask: undefined,
+            timeout: this._timeoutSettings.timeout(options),
+        };
+        if (!copy.type)
+            copy.type = (0, elementHandle_1.determineScreenshotType)(options);
+        if (mask) {
+            copy.mask = mask.map((locator) => ({
+                frame: locator._frame._channel,
+                selector: locator._selector,
+            }));
+        }
+        const result = await this._channel.screenshot(copy);
+        if (options.path) {
+            options.path = await (0, fileUtils_1.writeTempFile)(options.path, result.binary);
+        }
+        return result.binary;
+    }
+    async _expectScreenshot(options) {
+        const mask = options?.mask
+            ? options?.mask.map((locator) => ({
+                frame: locator._frame._channel,
+                selector: locator._selector,
+            }))
+            : undefined;
+        const locator = options.locator
+            ? {
+                frame: options.locator._frame._channel,
+                selector: options.locator._selector,
+            }
+            : undefined;
+        return await this._channel.expectScreenshot({
+            ...options,
+            isNot: !!options.isNot,
+            locator,
+            mask,
+        });
+    }
+    async title() {
+        return await this._mainFrame.title();
+    }
+    async bringToFront() {
+        await this._channel.bringToFront();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    async close(options = {}) {
+        this._closeReason = options.reason;
+        if (!options.runBeforeUnload)
+            this._closeWasCalled = true;
+        try {
+            if (this._ownedContext)
+                await this._ownedContext.close();
+            else
+                await this._channel.close(options);
+        }
+        catch (e) {
+            if ((0, errors_1.isTargetClosedError)(e) && !options.runBeforeUnload)
+                return;
+            throw e;
+        }
+    }
+    isClosed() {
+        return this._closed;
+    }
+    async click(selector, options) {
+        return await this._mainFrame.click(selector, options);
+    }
+    async dragAndDrop(source, target, options) {
+        return await this._mainFrame.dragAndDrop(source, target, options);
+    }
+    async dblclick(selector, options) {
+        await this._mainFrame.dblclick(selector, options);
+    }
+    async tap(selector, options) {
+        return await this._mainFrame.tap(selector, options);
+    }
+    async fill(selector, value, options) {
+        return await this._mainFrame.fill(selector, value, options);
+    }
+    async clearConsoleMessages() {
+        await this._channel.clearConsoleMessages();
+    }
+    async consoleMessages(options) {
+        const { messages } = await this._channel.consoleMessages({ filter: options?.filter });
+        return messages.map((message) => new consoleMessage_1.ConsoleMessage(this._platform, message, this, null));
+    }
+    async clearPageErrors() {
+        await this._channel.clearPageErrors();
+    }
+    async pageErrors(options) {
+        const { errors } = await this._channel.pageErrors({ filter: options?.filter });
+        return errors.map((error) => (0, errors_1.parseError)(error));
+    }
+    locator(selector, options) {
+        return this.mainFrame().locator(selector, options);
+    }
+    getByTestId(testId) {
+        return this.mainFrame().getByTestId(testId);
+    }
+    getByAltText(text, options) {
+        return this.mainFrame().getByAltText(text, options);
+    }
+    getByLabel(text, options) {
+        return this.mainFrame().getByLabel(text, options);
+    }
+    getByPlaceholder(text, options) {
+        return this.mainFrame().getByPlaceholder(text, options);
+    }
+    getByText(text, options) {
+        return this.mainFrame().getByText(text, options);
+    }
+    getByTitle(text, options) {
+        return this.mainFrame().getByTitle(text, options);
+    }
+    getByRole(role, options = {}) {
+        return this.mainFrame().getByRole(role, options);
+    }
+    frameLocator(selector) {
+        return this.mainFrame().frameLocator(selector);
+    }
+    async focus(selector, options) {
+        return await this._mainFrame.focus(selector, options);
+    }
+    async textContent(selector, options) {
+        return await this._mainFrame.textContent(selector, options);
+    }
+    async innerText(selector, options) {
+        return await this._mainFrame.innerText(selector, options);
+    }
+    async innerHTML(selector, options) {
+        return await this._mainFrame.innerHTML(selector, options);
+    }
+    async getAttribute(selector, name, options) {
+        return await this._mainFrame.getAttribute(selector, name, options);
+    }
+    async inputValue(selector, options) {
+        return await this._mainFrame.inputValue(selector, options);
+    }
+    async isChecked(selector, options) {
+        return await this._mainFrame.isChecked(selector, options);
+    }
+    async isDisabled(selector, options) {
+        return await this._mainFrame.isDisabled(selector, options);
+    }
+    async isEditable(selector, options) {
+        return await this._mainFrame.isEditable(selector, options);
+    }
+    async isEnabled(selector, options) {
+        return await this._mainFrame.isEnabled(selector, options);
+    }
+    async isHidden(selector, options) {
+        return await this._mainFrame.isHidden(selector, options);
+    }
+    async isVisible(selector, options) {
+        return await this._mainFrame.isVisible(selector, options);
+    }
+    async hover(selector, options) {
+        return await this._mainFrame.hover(selector, options);
+    }
+    async selectOption(selector, values, options) {
+        return await this._mainFrame.selectOption(selector, values, options);
+    }
+    async setInputFiles(selector, files, options) {
+        return await this._mainFrame.setInputFiles(selector, files, options);
+    }
+    async type(selector, text, options) {
+        return await this._mainFrame.type(selector, text, options);
+    }
+    async press(selector, key, options) {
+        return await this._mainFrame.press(selector, key, options);
+    }
+    async check(selector, options) {
+        return await this._mainFrame.check(selector, options);
+    }
+    async uncheck(selector, options) {
+        return await this._mainFrame.uncheck(selector, options);
+    }
+    async setChecked(selector, checked, options) {
+        return await this._mainFrame.setChecked(selector, checked, options);
+    }
+    async waitForTimeout(timeout) {
+        return await this._mainFrame.waitForTimeout(timeout);
+    }
+    async waitForFunction(pageFunction, arg, options) {
+        return await this._mainFrame.waitForFunction(pageFunction, arg, options);
+    }
+    async requests() {
+        const { requests } = await this._channel.requests();
+        return requests.map((request) => network_1.Request.from(request));
+    }
+    workers() {
+        return [...this._workers];
+    }
+    async pause(_options) {
+        if (this._platform.isJSDebuggerAttached())
+            return;
+        const defaultNavigationTimeout = this._browserContext._timeoutSettings.defaultNavigationTimeout();
+        const defaultTimeout = this._browserContext._timeoutSettings.defaultTimeout();
+        this._browserContext.setDefaultNavigationTimeout(0);
+        this._browserContext.setDefaultTimeout(0);
+        this._instrumentation?.onWillPause({ keepTestTimeout: !!_options?.__testHookKeepTestTimeout });
+        await this._closedOrCrashedScope.safeRace(this.context()._channel.pause());
+        this._browserContext.setDefaultNavigationTimeout(defaultNavigationTimeout);
+        this._browserContext.setDefaultTimeout(defaultTimeout);
+    }
+    async pdf(options = {}) {
+        const transportOptions = { ...options };
+        if (transportOptions.margin)
+            transportOptions.margin = { ...transportOptions.margin };
+        if (typeof options.width === "number")
+            transportOptions.width = options.width + "px";
+        if (typeof options.height === "number")
+            transportOptions.height = options.height + "px";
+        for (const margin of ["top", "right", "bottom", "left"]) {
+            const index = margin;
+            if (options.margin && typeof options.margin[index] === "number")
+                transportOptions.margin[index] = transportOptions.margin[index] + "px";
+        }
+        const result = await this._channel.pdf(transportOptions);
+        if (options.path) {
+            const platform = this._platform;
+            await platform
+                .fs()
+                .promises.mkdir(platform.path().dirname(options.path), { recursive: true });
+            await platform.fs().promises.writeFile(options.path, result.pdf);
+        }
+        return result.pdf;
+    }
+    async snapshotForAI(options = {}) {
+        return await this._channel.snapshotForAI({
+            timeout: this._timeoutSettings.timeout(options),
+            track: options.track,
+            depth: options.depth,
+        });
+    }
+    async _setDockTile(image) {
+        await this._channel.setDockTile({ image });
+    }
+}
+exports.Page = Page;
+class BindingCall extends channelOwner_1.ChannelOwner {
+    static from(channel) {
+        return channel._object;
+    }
+    constructor(parent, type, guid, initializer) {
+        super(parent, type, guid, initializer);
+    }
+    async call(func) {
+        try {
+            const frame = frame_1.Frame.from(this._initializer.frame);
+            const source = {
+                context: frame._page.context(),
+                page: frame._page,
+                frame,
+            };
+            let result;
+            if (this._initializer.handle)
+                result = await func(source, jsHandle_1.JSHandle.from(this._initializer.handle));
+            else
+                result = await func(source, ...this._initializer.args.map(jsHandle_1.parseResult));
+            this._channel.resolve({ result: (0, jsHandle_1.serializeArgument)(result) }).catch(() => { });
+        }
+        catch (e) {
+            this._channel.reject({ error: (0, errors_1.serializeError)(e) }).catch(() => { });
+        }
+    }
+}
+exports.BindingCall = BindingCall;
+function trimUrl(param) {
+    if ((0, rtti_1.isRegExp)(param))
+        return `/${(0, stringUtils_1.trimStringWithEllipsis)(param.source, 50)}/${param.flags}`;
+    if ((0, rtti_1.isString)(param))
+        return `"${(0, stringUtils_1.trimStringWithEllipsis)(param, 50)}"`;
+}
+//# sourceMappingURL=page.js.map