@checkly/playwright-core 1.51.17-beta.2 → 1.54.2-beta.1

package/lib/client/page.js

@@ -1,180 +1,162 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var page_exports = {};
+__export(page_exports, {
+  BindingCall: () => BindingCall,
+  Page: () => Page
 });
-exports.Page = exports.BindingCall = void 0;
-var _accessibility = require("./accessibility");
-var _artifact = require("./artifact");
-var _channelOwner = require("./channelOwner");
-var _clientHelper = require("./clientHelper");
-var _coverage = require("./coverage");
-var _download = require("./download");
-var _elementHandle = require("./elementHandle");
-var _errors = require("./errors");
-var _events = require("./events");
-var _fileChooser = require("./fileChooser");
-var _frame = require("./frame");
-var _harRouter = require("./harRouter");
-var _input = require("./input");
-var _jsHandle = require("./jsHandle");
-var _network = require("./network");
-var _video = require("./video");
-var _waiter = require("./waiter");
-var _worker = require("./worker");
-var _timeoutSettings = require("./timeoutSettings");
-var _assert = require("../utils/isomorphic/assert");
-var _fileUtils = require("./fileUtils");
-var _headers = require("../utils/isomorphic/headers");
-var _stringUtils = require("../utils/isomorphic/stringUtils");
-var _urlMatch = require("../utils/isomorphic/urlMatch");
-var _manualPromise = require("../utils/isomorphic/manualPromise");
-var _rtti = require("../utils/isomorphic/rtti");
-/**
- * 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.
- */
-
-class Page extends _channelOwner.ChannelOwner {
-  static from(page) {
-    return page._object;
-  }
-  static fromNullable(page) {
-    return page ? Page.from(page) : null;
-  }
+module.exports = __toCommonJS(page_exports);
+var import_accessibility = require("./accessibility");
+var import_artifact = require("./artifact");
+var import_channelOwner = require("./channelOwner");
+var import_clientHelper = require("./clientHelper");
+var import_coverage = require("./coverage");
+var import_download = require("./download");
+var import_elementHandle = require("./elementHandle");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_fileChooser = require("./fileChooser");
+var import_frame = require("./frame");
+var import_harRouter = require("./harRouter");
+var import_input = require("./input");
+var import_jsHandle = require("./jsHandle");
+var import_network = require("./network");
+var import_video = require("./video");
+var import_waiter = require("./waiter");
+var import_worker = require("./worker");
+var import_timeoutSettings = require("./timeoutSettings");
+var import_assert = require("../utils/isomorphic/assert");
+var import_fileUtils = require("./fileUtils");
+var import_headers = require("../utils/isomorphic/headers");
+var import_stringUtils = require("../utils/isomorphic/stringUtils");
+var import_urlMatch = require("../utils/isomorphic/urlMatch");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_rtti = require("../utils/isomorphic/rtti");
+class Page extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this._browserContext = void 0;
-    this._ownedContext = void 0;
-    this._mainFrame = void 0;
-    this._frames = new Set();
-    this._workers = new Set();
+    this._frames = /* @__PURE__ */ new Set();
+    this._workers = /* @__PURE__ */ new Set();
     this._closed = false;
-    this._closedOrCrashedScope = new _manualPromise.LongStandingScope();
-    this._viewportSize = void 0;
+    this._closedOrCrashedScope = new import_manualPromise.LongStandingScope();
     this._routes = [];
     this._webSocketRoutes = [];
-    this.accessibility = void 0;
-    this.coverage = void 0;
-    this.keyboard = void 0;
-    this.mouse = void 0;
-    this.request = void 0;
-    this.touchscreen = void 0;
-    this.clock = void 0;
-    this._bindings = new Map();
-    this._timeoutSettings = void 0;
+    this._bindings = /* @__PURE__ */ new Map();
     this._video = null;
-    this._opener = void 0;
-    this._closeReason = void 0;
     this._closeWasCalled = false;
     this._harRouters = [];
-    this._locatorHandlers = new Map();
+    this._locatorHandlers = /* @__PURE__ */ new Map();
     this._browserContext = parent;
-    this._timeoutSettings = new _timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
-    this.accessibility = new _accessibility.Accessibility(this._channel);
-    this.keyboard = new _input.Keyboard(this);
-    this.mouse = new _input.Mouse(this);
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
+    this.accessibility = new import_accessibility.Accessibility(this._channel);
+    this.keyboard = new import_input.Keyboard(this);
+    this.mouse = new import_input.Mouse(this);
     this.request = this._browserContext.request;
-    this.touchscreen = new _input.Touchscreen(this);
+    this.touchscreen = new import_input.Touchscreen(this);
     this.clock = this._browserContext.clock;
-    this._mainFrame = _frame.Frame.from(initializer.mainFrame);
+    this._mainFrame = import_frame.Frame.from(initializer.mainFrame);
     this._mainFrame._page = this;
     this._frames.add(this._mainFrame);
-    this._viewportSize = initializer.viewportSize || null;
+    this._viewportSize = initializer.viewportSize;
     this._closed = initializer.isClosed;
     this._opener = Page.fromNullable(initializer.opener);
-    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.Artifact.from(artifact);
-      this.emit(_events.Events.Page.Download, new _download.Download(this, url, suggestedFilename, artifactObject));
+    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 = import_artifact.Artifact.from(artifact);
+      this.emit(import_events.Events.Page.Download, new import_download.Download(this, url, suggestedFilename, artifactObject));
     });
-    this._channel.on('fileChooser', ({
-      element,
-      isMultiple
-    }) => this.emit(_events.Events.Page.FileChooser, new _fileChooser.FileChooser(this, _elementHandle.ElementHandle.from(element), isMultiple)));
-    this._channel.on('frameAttached', ({
-      frame
-    }) => this._onFrameAttached(_frame.Frame.from(frame)));
-    this._channel.on('frameDetached', ({
-      frame
-    }) => this._onFrameDetached(_frame.Frame.from(frame)));
-    this._channel.on('locatorHandlerTriggered', ({
-      uid
-    }) => this._onLocatorHandlerTriggered(uid));
-    this._channel.on('route', ({
-      route
-    }) => this._onRoute(_network.Route.from(route)));
-    this._channel.on('webSocketRoute', ({
-      webSocketRoute
-    }) => this._onWebSocketRoute(_network.WebSocketRoute.from(webSocketRoute)));
-    this._channel.on('video', ({
-      artifact
-    }) => {
-      const artifactObject = _artifact.Artifact.from(artifact);
+    this._channel.on("fileChooser", ({ element, isMultiple }) => this.emit(import_events.Events.Page.FileChooser, new import_fileChooser.FileChooser(this, import_elementHandle.ElementHandle.from(element), isMultiple)));
+    this._channel.on("frameAttached", ({ frame }) => this._onFrameAttached(import_frame.Frame.from(frame)));
+    this._channel.on("frameDetached", ({ frame }) => this._onFrameDetached(import_frame.Frame.from(frame)));
+    this._channel.on("locatorHandlerTriggered", ({ uid }) => this._onLocatorHandlerTriggered(uid));
+    this._channel.on("route", ({ route }) => this._onRoute(import_network.Route.from(route)));
+    this._channel.on("webSocketRoute", ({ webSocketRoute }) => this._onWebSocketRoute(import_network.WebSocketRoute.from(webSocketRoute)));
+    this._channel.on("video", ({ artifact }) => {
+      const artifactObject = import_artifact.Artifact.from(artifact);
       this._forceVideo()._artifactReady(artifactObject);
     });
-    this._channel.on('webSocket', ({
-      webSocket
-    }) => this.emit(_events.Events.Page.WebSocket, _network.WebSocket.from(webSocket)));
-    this._channel.on('worker', ({
-      worker
-    }) => this._onWorker(_worker.Worker.from(worker)));
-    this.coverage = new _coverage.Coverage(this._channel);
-    this.once(_events.Events.Page.Close, () => this._closedOrCrashedScope.close(this._closeErrorWithReason()));
-    this.once(_events.Events.Page.Crash, () => this._closedOrCrashedScope.close(new _errors.TargetClosedError()));
-    this._setEventToSubscriptionMapping(new Map([[_events.Events.Page.Console, 'console'], [_events.Events.Page.Dialog, 'dialog'], [_events.Events.Page.Request, 'request'], [_events.Events.Page.Response, 'response'], [_events.Events.Page.RequestFinished, 'requestFinished'], [_events.Events.Page.RequestFailed, 'requestFailed'], [_events.Events.Page.FileChooser, 'fileChooser']]));
+    this._channel.on("viewportSizeChanged", ({ viewportSize }) => this._viewportSize = viewportSize);
+    this._channel.on("webSocket", ({ webSocket }) => this.emit(import_events.Events.Page.WebSocket, import_network.WebSocket.from(webSocket)));
+    this._channel.on("worker", ({ worker }) => this._onWorker(import_worker.Worker.from(worker)));
+    this.coverage = new import_coverage.Coverage(this._channel);
+    this.once(import_events.Events.Page.Close, () => this._closedOrCrashedScope.close(this._closeErrorWithReason()));
+    this.once(import_events.Events.Page.Crash, () => this._closedOrCrashedScope.close(new import_errors.TargetClosedError()));
+    this._setEventToSubscriptionMapping(/* @__PURE__ */ new Map([
+      [import_events.Events.Page.Console, "console"],
+      [import_events.Events.Page.Dialog, "dialog"],
+      [import_events.Events.Page.Request, "request"],
+      [import_events.Events.Page.Response, "response"],
+      [import_events.Events.Page.RequestFinished, "requestFinished"],
+      [import_events.Events.Page.RequestFailed, "requestFailed"],
+      [import_events.Events.Page.FileChooser, "fileChooser"]
+    ]));
+  }
+  static from(page) {
+    return page._object;
+  }
+  static fromNullable(page) {
+    return page ? Page.from(page) : null;
   }
   _onFrameAttached(frame) {
     frame._page = this;
     this._frames.add(frame);
-    if (frame._parentFrame) frame._parentFrame._childFrames.add(frame);
-    this.emit(_events.Events.Page.FrameAttached, frame);
+    if (frame._parentFrame)
+      frame._parentFrame._childFrames.add(frame);
+    this.emit(import_events.Events.Page.FrameAttached, frame);
   }
   _onFrameDetached(frame) {
     this._frames.delete(frame);
     frame._detached = true;
-    if (frame._parentFrame) frame._parentFrame._childFrames.delete(frame);
-    this.emit(_events.Events.Page.FrameDetached, frame);
+    if (frame._parentFrame)
+      frame._parentFrame._childFrames.delete(frame);
+    this.emit(import_events.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._closeWasCalled) return;
-      if (!routeHandler.matches(route.request().url())) continue;
+      if (this._closeWasCalled || this._browserContext._closingStatus !== "none")
+        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);
+      if (index === -1)
+        continue;
+      if (routeHandler.willExpire())
+        this._routes.splice(index, 1);
       const handled = await routeHandler.handle(route);
-      if (!this._routes.length) this._wrapApiCall(() => this._updateInterceptionPatterns(), true).catch(() => {});
-      if (handled) return;
+      if (!this._routes.length)
+        this._updateInterceptionPatterns().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);
+    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);
@@ -187,35 +169,37 @@ class Page extends _channelOwner.ChannelOwner {
   _onWorker(worker) {
     this._workers.add(worker);
     worker._page = this;
-    this.emit(_events.Events.Page.Worker, worker);
+    this.emit(import_events.Events.Page.Worker, worker);
   }
   _onClose() {
     this._closed = true;
     this._browserContext._pages.delete(this);
     this._browserContext._backgroundPages.delete(this);
     this._disposeHarRouters();
-    this.emit(_events.Events.Page.Close, this);
+    this.emit(import_events.Events.Page.Close, this);
   }
   _onCrash() {
-    this.emit(_events.Events.Page.Crash, this);
+    this.emit(import_events.Events.Page.Crash, this);
   }
   context() {
     return this._browserContext;
   }
   async opener() {
-    if (!this._opener || this._opener.isClosed()) return null;
+    if (!this._opener || this._opener.isClosed())
+      return null;
     return this._opener;
   }
   mainFrame() {
     return this._mainFrame;
   }
   frame(frameSelector) {
-    const name = (0, _rtti.isString)(frameSelector) ? frameSelector : frameSelector.name;
-    const url = (0, _rtti.isObject)(frameSelector) ? frameSelector.url : undefined;
-    (0, _assert.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.urlMatches)(this._browserContext._options.baseURL, f.url(), url);
+    const name = (0, import_rtti.isString)(frameSelector) ? frameSelector : frameSelector.name;
+    const url = (0, import_rtti.isObject)(frameSelector) ? frameSelector.url : void 0;
+    (0, import_assert.assert)(name || url, "Either name or url matcher should be specified");
+    return this.frames().find((f) => {
+      if (name)
+        return f.name() === name;
+      return (0, import_urlMatch.urlMatches)(this._browserContext._options.baseURL, f.url(), url);
     }) || null;
   }
   frames() {
@@ -223,29 +207,18 @@ class Page extends _channelOwner.ChannelOwner {
   }
   setDefaultNavigationTimeout(timeout) {
     this._timeoutSettings.setDefaultNavigationTimeout(timeout);
-    this._wrapApiCall(async () => {
-      await this._channel.setDefaultNavigationTimeoutNoReply({
-        timeout
-      });
-    }, true).catch(() => {});
   }
   setDefaultTimeout(timeout) {
     this._timeoutSettings.setDefaultTimeout(timeout);
-    this._wrapApiCall(async () => {
-      await this._channel.setDefaultTimeoutNoReply({
-        timeout
-      });
-    }, true).catch(() => {});
   }
   _forceVideo() {
-    if (!this._video) this._video = new _video.Video(this, this._connection);
+    if (!this._video)
+      this._video = new import_video.Video(this, this._connection);
     return this._video;
   }
   video() {
-    // Note: we are creating Video object lazily, because we do not know
-    // BrowserContextOptions when constructing the page - it is assigned
-    // too late during launchPersistentContext.
-    if (!this._browserContext._options.recordVideo) return null;
+    if (!this._browserContext._options.recordVideo)
+      return null;
     return this._forceVideo();
   }
   async $(selector, options) {
@@ -258,15 +231,15 @@ class Page extends _channelOwner.ChannelOwner {
     return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
   }
   async evaluateHandle(pageFunction, arg) {
-    (0, _jsHandle.assertMaxArguments)(arguments.length, 2);
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
     return await this._mainFrame.evaluateHandle(pageFunction, arg);
   }
   async $eval(selector, pageFunction, arg) {
-    (0, _jsHandle.assertMaxArguments)(arguments.length, 3);
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
     return await this._mainFrame.$eval(selector, pageFunction, arg);
   }
   async $$eval(selector, pageFunction, arg) {
-    (0, _jsHandle.assertMaxArguments)(arguments.length, 3);
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
     return await this._mainFrame.$$eval(selector, pageFunction, arg);
   }
   async $$(selector) {
@@ -279,24 +252,17 @@ class Page extends _channelOwner.ChannelOwner {
     return await this._mainFrame.addStyleTag(options);
   }
   async exposeFunction(name, callback) {
-    await this._channel.exposeBinding({
-      name
-    });
+    await this._channel.exposeBinding({ name });
     const binding = (source, ...args) => callback(...args);
     this._bindings.set(name, binding);
   }
   async exposeBinding(name, callback, options = {}) {
-    await this._channel.exposeBinding({
-      name,
-      needsHandle: options.handle
-    });
+    await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
   }
   async setExtraHTTPHeaders(headers) {
-    (0, _network.validateHeaders)(headers);
-    await this._channel.setExtraHTTPHeaders({
-      headers: (0, _headers.headersObjectToArray)(headers)
-    });
+    (0, import_network.validateHeaders)(headers);
+    await this._channel.setExtraHTTPHeaders({ headers: (0, import_headers.headersObjectToArray)(headers) });
   }
   url() {
     return this._mainFrame.url();
@@ -311,51 +277,40 @@ class Page extends _channelOwner.ChannelOwner {
     return await this._mainFrame.goto(url, options);
   }
   async reload(options = {}) {
-    const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
-    return _network.Response.fromNullable((await this._channel.reload({
-      ...options,
-      waitUntil
-    })).response);
+    const waitUntil = (0, import_frame.verifyLoadState)("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    return import_network.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
-    });
+    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--;
+        if (handler.times !== void 0)
+          handler.times--;
         await handler.handler(handler.locator);
       }
-      remove = (handler === null || handler === void 0 ? void 0 : handler.times) === 0;
+      remove = handler?.times === 0;
     } finally {
-      if (remove) this._locatorHandlers.delete(uid);
-      this._wrapApiCall(() => this._channel.resolveLocatorHandlerNoReply({
-        uid,
-        remove
-      }), true).catch(() => {});
+      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(() => {});
+        await this._channel.unregisterLocatorHandler({ uid }).catch(() => {
+        });
       }
     }
   }
@@ -369,179 +324,165 @@ class Page extends _channelOwner.ChannelOwner {
     return await this._mainFrame.waitForURL(url, options);
   }
   async waitForRequest(urlOrPredicate, options = {}) {
-    const predicate = async request => {
-      if ((0, _rtti.isString)(urlOrPredicate) || (0, _rtti.isRegExp)(urlOrPredicate)) return (0, _urlMatch.urlMatches)(this._browserContext._options.baseURL, request.url(), urlOrPredicate);
+    const predicate = async (request) => {
+      if ((0, import_rtti.isString)(urlOrPredicate) || (0, import_rtti.isRegExp)(urlOrPredicate))
+        return (0, import_urlMatch.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.Events.Page.Request, {
-      predicate,
-      timeout: options.timeout
-    }, logLine);
+    const logLine = trimmedUrl ? `waiting for request ${trimmedUrl}` : void 0;
+    return await this._waitForEvent(import_events.Events.Page.Request, { predicate, timeout: options.timeout }, logLine);
   }
   async waitForResponse(urlOrPredicate, options = {}) {
-    const predicate = async response => {
-      if ((0, _rtti.isString)(urlOrPredicate) || (0, _rtti.isRegExp)(urlOrPredicate)) return (0, _urlMatch.urlMatches)(this._browserContext._options.baseURL, response.url(), urlOrPredicate);
+    const predicate = async (response) => {
+      if ((0, import_rtti.isString)(urlOrPredicate) || (0, import_rtti.isRegExp)(urlOrPredicate))
+        return (0, import_urlMatch.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.Events.Page.Response, {
-      predicate,
-      timeout: options.timeout
-    }, logLine);
+    const logLine = trimmedUrl ? `waiting for response ${trimmedUrl}` : void 0;
+    return await this._waitForEvent(import_events.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.TargetClosedError(this._closeReason || this._browserContext._effectiveCloseReason());
+    return new import_errors.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.Waiter.createForEvent(this, event);
-      if (logLine) waiter.log(logLine);
+      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
+      const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
+      const waiter = import_waiter.Waiter.createForEvent(this, event);
+      if (logLine)
+        waiter.log(logLine);
       waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
-      if (event !== _events.Events.Page.Crash) waiter.rejectOnEvent(this, _events.Events.Page.Crash, new Error('Page crashed'));
-      if (event !== _events.Events.Page.Close) waiter.rejectOnEvent(this, _events.Events.Page.Close, () => this._closeErrorWithReason());
+      if (event !== import_events.Events.Page.Crash)
+        waiter.rejectOnEvent(this, import_events.Events.Page.Crash, new Error("Page crashed"));
+      if (event !== import_events.Events.Page.Close)
+        waiter.rejectOnEvent(this, import_events.Events.Page.Close, () => this._closeErrorWithReason());
       const result = await waiter.waitForEvent(this, event, predicate);
       waiter.dispose();
       return result;
     });
   }
   async goBack(options = {}) {
-    const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
-    return _network.Response.fromNullable((await this._channel.goBack({
-      ...options,
-      waitUntil
-    })).response);
+    const waitUntil = (0, import_frame.verifyLoadState)("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    return import_network.Response.fromNullable((await this._channel.goBack({ ...options, waitUntil, timeout: this._timeoutSettings.navigationTimeout(options) })).response);
   }
   async goForward(options = {}) {
-    const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
-    return _network.Response.fromNullable((await this._channel.goForward({
-      ...options,
-      waitUntil
-    })).response);
+    const waitUntil = (0, import_frame.verifyLoadState)("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    return import_network.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
+      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
-    });
+    await this._channel.setViewportSize({ viewportSize });
   }
   viewportSize() {
-    return this._viewportSize;
+    return this._viewportSize || null;
   }
   async evaluate(pageFunction, arg) {
-    (0, _jsHandle.assertMaxArguments)(arguments.length, 2);
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
     return await this._mainFrame.evaluate(pageFunction, arg);
   }
   async addInitScript(script, arg) {
-    const source = await (0, _clientHelper.evaluationScript)(this._platform, script, arg);
-    await this._channel.addInitScript({
-      source
-    });
+    const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
+    await this._channel.addInitScript({ source });
   }
   async route(url, handler, options = {}) {
-    this._routes.unshift(new _network.RouteHandler(this._platform, this._browserContext._options.baseURL, url, handler, options.times));
+    this._routes.unshift(new import_network.RouteHandler(this._platform, this._browserContext._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns();
   }
   async routeFromHAR(har, options = {}) {
     const localUtils = this._connection.localUtils();
-    if (!localUtils) throw new Error('Route from har is not supported in thin clients');
+    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.HarRouter.create(localUtils, har, options.notFound || 'abort', {
-      urlMatch: options.url
-    });
+    const harRouter = await import_harRouter.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.WebSocketRouteHandler(this._browserContext._options.baseURL, url, handler));
+    this._webSocketRoutes.unshift(new import_network.WebSocketRouteHandler(this._browserContext._options.baseURL, url, handler));
     await this._updateWebSocketInterceptionPatterns();
   }
   _disposeHarRouters() {
-    this._harRouters.forEach(router => router.dispose());
+    this._harRouters.forEach((router) => router.dispose());
     this._harRouters = [];
   }
   async unrouteAll(options) {
-    await this._unrouteInternal(this._routes, [], options === null || options === void 0 ? void 0 : options.behavior);
+    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.urlMatchesEqual)(route.url, url) && (!handler || route.handler === handler)) removed.push(route);else remaining.push(route);
+      if ((0, import_urlMatch.urlMatchesEqual)(route.url, url) && (!handler || route.handler === handler))
+        removed.push(route);
+      else
+        remaining.push(route);
     }
-    await this._unrouteInternal(removed, remaining, 'default');
+    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();
-    if (!behavior || behavior === 'default') return;
-    const promises = removed.map(routeHandler => routeHandler.stop(behavior));
-    await Promise.all(promises);
   }
   async _updateInterceptionPatterns() {
-    const patterns = _network.RouteHandler.prepareInterceptionPatterns(this._routes);
-    await this._channel.setNetworkInterceptionPatterns({
-      patterns
-    });
+    const patterns = import_network.RouteHandler.prepareInterceptionPatterns(this._routes);
+    await this._channel.setNetworkInterceptionPatterns({ patterns });
   }
   async _updateWebSocketInterceptionPatterns() {
-    const patterns = _network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
-    await this._channel.setWebSocketInterceptionPatterns({
-      patterns
-    });
+    const patterns = import_network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
+    await this._channel.setWebSocketInterceptionPatterns({ patterns });
   }
   async screenshot(options = {}) {
     const mask = options.mask;
-    const copy = {
-      ...options,
-      mask: undefined
-    };
-    if (!copy.type) copy.type = (0, _elementHandle.determineScreenshotType)(options);
+    const copy = { ...options, mask: void 0, timeout: this._timeoutSettings.timeout(options) };
+    if (!copy.type)
+      copy.type = (0, import_elementHandle.determineScreenshotType)(options);
     if (mask) {
-      copy.mask = mask.map(locator => ({
+      copy.mask = mask.map((locator) => ({
         frame: locator._frame._channel,
         selector: locator._selector
       }));
     }
     const result = await this._channel.screenshot(copy);
     if (options.path) {
-      await (0, _fileUtils.mkdirIfNeeded)(this._platform, options.path);
+      await (0, import_fileUtils.mkdirIfNeeded)(this._platform, options.path);
       await this._platform.fs().promises.writeFile(options.path, result.binary);
     }
     return result.binary;
   }
   async _expectScreenshot(options) {
-    const mask = options !== null && options !== void 0 && options.mask ? options === null || options === void 0 ? void 0 : options.mask.map(locator => ({
-      frame: locator._frame._channel,
-      selector: locator._selector
-    })) : undefined;
+    const mask = options?.mask ? options?.mask.map((locator2) => ({
+      frame: locator2._frame._channel,
+      selector: locator2._selector
+    })) : void 0;
     const locator = options.locator ? {
       frame: options.locator._frame._channel,
       selector: options.locator._selector
-    } : undefined;
+    } : void 0;
     return await this._channel.expectScreenshot({
       ...options,
       isNot: !!options.isNot,
@@ -562,9 +503,13 @@ class Page extends _channelOwner.ChannelOwner {
     this._closeReason = options.reason;
     this._closeWasCalled = true;
     try {
-      if (this._ownedContext) await this._ownedContext.close();else await this._channel.close(options);
+      if (this._ownedContext)
+        await this._ownedContext.close();
+      else
+        await this._channel.close(options);
     } catch (e) {
-      if ((0, _errors.isTargetClosedError)(e) && !options.runBeforeUnload) return;
+      if ((0, import_errors.isTargetClosedError)(e) && !options.runBeforeUnload)
+        return;
       throw e;
     }
   }
@@ -578,7 +523,7 @@ class Page extends _channelOwner.ChannelOwner {
     return await this._mainFrame.dragAndDrop(source, target, options);
   }
   async dblclick(selector, options) {
-    return await this._mainFrame.dblclick(selector, options);
+    await this._mainFrame.dblclick(selector, options);
   }
   async tap(selector, options) {
     return await this._mainFrame.tap(selector, options);
@@ -683,45 +628,44 @@ class Page extends _channelOwner.ChannelOwner {
     return [...this._workers];
   }
   async pause(_options) {
-    var _this$_instrumentatio;
-    if (this._platform.isJSDebuggerAttached()) return;
+    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$_instrumentatio = this._instrumentation) === null || _this$_instrumentatio === void 0 || _this$_instrumentatio.onWillPause({
-      keepTestTimeout: !!(_options !== null && _options !== void 0 && _options.__testHookKeepTestTimeout)
-    });
+    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 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';
+      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.mkdir(platform.path().dirname(options.path), { recursive: true });
       await platform.fs().promises.writeFile(options.path, result.pdf);
     }
     return result.pdf;
   }
+  async _snapshotForAI() {
+    const result = await this._channel.snapshotForAI();
+    return result.snapshot;
+  }
 }
-exports.Page = Page;
-class BindingCall extends _channelOwner.ChannelOwner {
+class BindingCall extends import_channelOwner.ChannelOwner {
   static from(channel) {
     return channel._object;
   }
@@ -730,26 +674,33 @@ class BindingCall extends _channelOwner.ChannelOwner {
   }
   async call(func) {
     try {
-      const frame = _frame.Frame.from(this._initializer.frame);
+      const frame = import_frame.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.JSHandle.from(this._initializer.handle));else result = await func(source, ...this._initializer.args.map(_jsHandle.parseResult));
-      this._channel.resolve({
-        result: (0, _jsHandle.serializeArgument)(result)
-      }).catch(() => {});
+      if (this._initializer.handle)
+        result = await func(source, import_jsHandle.JSHandle.from(this._initializer.handle));
+      else
+        result = await func(source, ...this._initializer.args.map(import_jsHandle.parseResult));
+      this._channel.resolve({ result: (0, import_jsHandle.serializeArgument)(result) }).catch(() => {
+      });
     } catch (e) {
-      this._channel.reject({
-        error: (0, _errors.serializeError)(e)
-      }).catch(() => {});
+      this._channel.reject({ error: (0, import_errors.serializeError)(e) }).catch(() => {
+      });
     }
   }
 }
-exports.BindingCall = BindingCall;
 function trimUrl(param) {
-  if ((0, _rtti.isRegExp)(param)) return `/${(0, _stringUtils.trimStringWithEllipsis)(param.source, 50)}/${param.flags}`;
-  if ((0, _rtti.isString)(param)) return `"${(0, _stringUtils.trimStringWithEllipsis)(param, 50)}"`;
-}
+  if ((0, import_rtti.isRegExp)(param))
+    return `/${(0, import_stringUtils.trimStringWithEllipsis)(param.source, 50)}/${param.flags}`;
+  if ((0, import_rtti.isString)(param))
+    return `"${(0, import_stringUtils.trimStringWithEllipsis)(param, 50)}"`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BindingCall,
+  Page
+});