rebrowser-playwright-core 1.49.1 → 1.64.1

package/lib/server/page.js

@@ -1,873 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Worker = exports.PageBinding = exports.Page = exports.InitScript = void 0;
-var frames = _interopRequireWildcard(require("./frames"));
-var input = _interopRequireWildcard(require("./input"));
-var js = _interopRequireWildcard(require("./javascript"));
-var _screenshotter = require("./screenshotter");
-var _timeoutSettings = require("../common/timeoutSettings");
-var _browserContext = require("./browserContext");
-var _console = require("./console");
-var accessibility = _interopRequireWildcard(require("./accessibility"));
-var _fileChooser = require("./fileChooser");
-var _progress = require("./progress");
-var _utils = require("../utils");
-var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../utils/debugLogger");
-var _comparators = require("../utils/comparators");
-var _instrumentation = require("./instrumentation");
-var _selectorParser = require("../utils/isomorphic/selectorParser");
-var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
-var _errors = require("./errors");
-var _helper = require("./helper");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/**
- * 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 _instrumentation.SdkObject {
-  constructor(delegate, browserContext) {
-    super(browserContext, 'page');
-    this._closedState = 'open';
-    this._closedPromise = new _manualPromise.ManualPromise();
-    this._initialized = false;
-    this._eventsToEmitAfterInitialized = [];
-    this._crashed = false;
-    this.openScope = new _utils.LongStandingScope();
-    this._browserContext = void 0;
-    this.keyboard = void 0;
-    this.mouse = void 0;
-    this.touchscreen = void 0;
-    this._timeoutSettings = void 0;
-    this._delegate = void 0;
-    this._emulatedSize = void 0;
-    this._extraHTTPHeaders = void 0;
-    this._emulatedMedia = {};
-    this._interceptFileChooser = false;
-    this._pageBindings = new Map();
-    this.initScripts = [];
-    this._screenshotter = void 0;
-    this._frameManager = void 0;
-    this.accessibility = void 0;
-    this._workers = new Map();
-    this.pdf = void 0;
-    this.coverage = void 0;
-    this._clientRequestInterceptor = void 0;
-    this._serverRequestInterceptor = void 0;
-    this._ownedContext = void 0;
-    this._pageIsError = void 0;
-    this._video = null;
-    this._opener = void 0;
-    this._isServerSideOnly = false;
-    this._locatorHandlers = new Map();
-    this._lastLocatorHandlerUid = 0;
-    this._locatorHandlerRunningCounter = 0;
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
-    this._closeReason = void 0;
-    this.attribution.page = this;
-    this._delegate = delegate;
-    this._browserContext = browserContext;
-    this.accessibility = new accessibility.Accessibility(delegate.getAccessibilityTree.bind(delegate));
-    this.keyboard = new input.Keyboard(delegate.rawKeyboard);
-    this.mouse = new input.Mouse(delegate.rawMouse, this);
-    this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
-    this._timeoutSettings = new _timeoutSettings.TimeoutSettings(browserContext._timeoutSettings);
-    this._screenshotter = new _screenshotter.Screenshotter(this);
-    this._frameManager = new frames.FrameManager(this);
-    if (delegate.pdf) this.pdf = delegate.pdf.bind(delegate);
-    this.coverage = delegate.coverage ? delegate.coverage() : null;
-  }
-  async initOpener(opener) {
-    if (!opener) return;
-    const openerPage = await opener.pageOrError();
-    if (openerPage instanceof Page && !openerPage.isClosed()) this._opener = openerPage;
-  }
-  reportAsNew(error = undefined, contextEvent = _browserContext.BrowserContext.Events.Page) {
-    if (error) {
-      // Initialization error could have happened because of
-      // context/browser closure. Just ignore the page.
-      if (this._browserContext.isClosingOrClosed()) return;
-      this._setIsError(error);
-    }
-    this._initialized = true;
-    this.emitOnContext(contextEvent, this);
-    for (const {
-      event,
-      args
-    } of this._eventsToEmitAfterInitialized) this._browserContext.emit(event, ...args);
-    this._eventsToEmitAfterInitialized = [];
-
-    // It may happen that page initialization finishes after Close event has already been sent,
-    // in that case we fire another Close event to ensure that each reported Page will have
-    // corresponding Close event after it is reported on the context.
-    if (this.isClosed()) this.emit(Page.Events.Close);else this.instrumentation.onPageOpen(this);
-  }
-  initializedOrUndefined() {
-    return this._initialized ? this : undefined;
-  }
-  emitOnContext(event, ...args) {
-    if (this._isServerSideOnly) return;
-    this._browserContext.emit(event, ...args);
-  }
-  emitOnContextOnceInitialized(event, ...args) {
-    if (this._isServerSideOnly) return;
-    // Some events, like console messages, may come before page is ready.
-    // In this case, postpone the event until page is initialized,
-    // and dispatch it to the client later, either on the live Page,
-    // or on the "errored" Page.
-    if (this._initialized) this._browserContext.emit(event, ...args);else this._eventsToEmitAfterInitialized.push({
-      event,
-      args
-    });
-  }
-  async resetForReuse(metadata) {
-    this.setDefaultNavigationTimeout(undefined);
-    this.setDefaultTimeout(undefined);
-    this._locatorHandlers.clear();
-    await this._removeExposedBindings();
-    await this._removeInitScripts();
-    await this.setClientRequestInterceptor(undefined);
-    await this._setServerRequestInterceptor(undefined);
-    await this.setFileChooserIntercepted(false);
-    // Re-navigate once init scripts are gone.
-    await this.mainFrame().goto(metadata, 'about:blank');
-    this._emulatedSize = undefined;
-    this._emulatedMedia = {};
-    this._extraHTTPHeaders = undefined;
-    this._interceptFileChooser = false;
-    await Promise.all([this._delegate.updateEmulatedViewportSize(), this._delegate.updateEmulateMedia(), this._delegate.updateFileChooserInterception()]);
-    await this._delegate.resetForReuse();
-  }
-  _didClose() {
-    this._frameManager.dispose();
-    this._frameThrottler.dispose();
-    (0, _utils.assert)(this._closedState !== 'closed', 'Page closed twice');
-    this._closedState = 'closed';
-    this.emit(Page.Events.Close);
-    this._closedPromise.resolve();
-    this.instrumentation.onPageClose(this);
-    this.openScope.close(new _errors.TargetClosedError());
-  }
-  _didCrash() {
-    this._frameManager.dispose();
-    this._frameThrottler.dispose();
-    this.emit(Page.Events.Crash);
-    this._crashed = true;
-    this.instrumentation.onPageClose(this);
-    this.openScope.close(new Error('Page crashed'));
-  }
-  async _onFileChooserOpened(handle) {
-    let multiple;
-    try {
-      multiple = await handle.evaluate(element => !!element.multiple);
-    } catch (e) {
-      // Frame/context may be gone during async processing. Do not throw.
-      return;
-    }
-    if (!this.listenerCount(Page.Events.FileChooser)) {
-      handle.dispose();
-      return;
-    }
-    const fileChooser = new _fileChooser.FileChooser(this, handle, multiple);
-    this.emit(Page.Events.FileChooser, fileChooser);
-  }
-  context() {
-    return this._browserContext;
-  }
-  opener() {
-    return this._opener;
-  }
-  mainFrame() {
-    return this._frameManager.mainFrame();
-  }
-  frames() {
-    return this._frameManager.frames();
-  }
-  setDefaultNavigationTimeout(timeout) {
-    this._timeoutSettings.setDefaultNavigationTimeout(timeout);
-  }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  async exposeBinding(name, needsHandle, playwrightBinding) {
-    if (this._pageBindings.has(name)) throw new Error(`Function "${name}" has been already registered`);
-    if (this._browserContext._pageBindings.has(name)) throw new Error(`Function "${name}" has been already registered in the browser context`);
-    const binding = new PageBinding(name, playwrightBinding, needsHandle);
-    this._pageBindings.set(name, binding);
-    await this._delegate.addInitScript(binding.initScript);
-    await Promise.all(this.frames().map(frame => frame.evaluateExpression(binding.initScript.source).catch(e => {})));
-  }
-  async _removeExposedBindings() {
-    for (const [key, binding] of this._pageBindings) {
-      if (!binding.internal) this._pageBindings.delete(key);
-    }
-  }
-  setExtraHTTPHeaders(headers) {
-    this._extraHTTPHeaders = headers;
-    return this._delegate.updateExtraHTTPHeaders();
-  }
-  extraHTTPHeaders() {
-    return this._extraHTTPHeaders;
-  }
-  async _onBindingCalled(payload, context) {
-    if (this._closedState === 'closed') return;
-    await PageBinding.dispatch(this, payload, context);
-  }
-  _addConsoleMessage(type, args, location, text) {
-    const message = new _console.ConsoleMessage(this, type, text, args, location);
-    const intercepted = this._frameManager.interceptConsoleMessage(message);
-    if (intercepted) {
-      args.forEach(arg => arg.dispose());
-      return;
-    }
-    this.emitOnContextOnceInitialized(_browserContext.BrowserContext.Events.Console, message);
-  }
-  async reload(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to reload(),
-      // so we should await it immediately.
-      const [response] = await Promise.all([
-      // Reload must be a new document, and should not be confused with a stray pushState.
-      this.mainFrame()._waitForNavigation(progress, true /* requiresNewDocument */, options), this._delegate.reload()]);
-      return response;
-    }), this._timeoutSettings.navigationTimeout(options));
-  }
-  async goBack(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to goBack,
-      // so we should catch it immediately.
-      let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
-        error = e;
-        return null;
-      });
-      const result = await this._delegate.goBack();
-      if (!result) return null;
-      const response = await waitPromise;
-      if (error) throw error;
-      return response;
-    }), this._timeoutSettings.navigationTimeout(options));
-  }
-  async goForward(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to goForward,
-      // so we should catch it immediately.
-      let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
-        error = e;
-        return null;
-      });
-      const result = await this._delegate.goForward();
-      if (!result) return null;
-      const response = await waitPromise;
-      if (error) throw error;
-      return response;
-    }), this._timeoutSettings.navigationTimeout(options));
-  }
-  requestGC() {
-    return this._delegate.requestGC();
-  }
-  registerLocatorHandler(selector, noWaitAfter) {
-    const uid = ++this._lastLocatorHandlerUid;
-    this._locatorHandlers.set(uid, {
-      selector,
-      noWaitAfter
-    });
-    return uid;
-  }
-  resolveLocatorHandler(uid, remove) {
-    const handler = this._locatorHandlers.get(uid);
-    if (remove) this._locatorHandlers.delete(uid);
-    if (handler) {
-      var _handler$resolved;
-      (_handler$resolved = handler.resolved) === null || _handler$resolved === void 0 || _handler$resolved.resolve();
-      handler.resolved = undefined;
-    }
-  }
-  unregisterLocatorHandler(uid) {
-    this._locatorHandlers.delete(uid);
-  }
-  async performActionPreChecks(progress) {
-    await this._performWaitForNavigationCheck(progress);
-    progress.throwIfAborted();
-    await this._performLocatorHandlersCheckpoint(progress);
-    progress.throwIfAborted();
-    // Wait once again, just in case a locator handler caused a navigation.
-    await this._performWaitForNavigationCheck(progress);
-  }
-  async _performWaitForNavigationCheck(progress) {
-    var _mainFrame$pendingDoc;
-    if (process.env.PLAYWRIGHT_SKIP_NAVIGATION_CHECK) return;
-    const mainFrame = this._frameManager.mainFrame();
-    if (!mainFrame || !mainFrame.pendingDocument()) return;
-    const url = (_mainFrame$pendingDoc = mainFrame.pendingDocument()) === null || _mainFrame$pendingDoc === void 0 || (_mainFrame$pendingDoc = _mainFrame$pendingDoc.request) === null || _mainFrame$pendingDoc === void 0 ? void 0 : _mainFrame$pendingDoc.url();
-    const toUrl = url ? `" ${(0, _utils.trimStringWithEllipsis)(url, 200)}"` : '';
-    progress.log(`  waiting for${toUrl} navigation to finish...`);
-    await _helper.helper.waitForEvent(progress, mainFrame, frames.Frame.Events.InternalNavigation, e => {
-      if (!e.isPublic) return false;
-      if (!e.error) progress.log(`  navigated to "${(0, _utils.trimStringWithEllipsis)(mainFrame.url(), 200)}"`);
-      return true;
-    }).promise;
-  }
-  async _performLocatorHandlersCheckpoint(progress) {
-    // Do not run locator handlers from inside locator handler callbacks to avoid deadlocks.
-    if (this._locatorHandlerRunningCounter) return;
-    for (const [uid, handler] of this._locatorHandlers) {
-      if (!handler.resolved) {
-        if (await this.mainFrame().isVisibleInternal(handler.selector, {
-          strict: true
-        })) {
-          handler.resolved = new _manualPromise.ManualPromise();
-          this.emit(Page.Events.LocatorHandlerTriggered, uid);
-        }
-      }
-      if (handler.resolved) {
-        ++this._locatorHandlerRunningCounter;
-        progress.log(`  found ${(0, _utils.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)}, intercepting action to run the handler`);
-        const promise = handler.resolved.then(async () => {
-          progress.throwIfAborted();
-          if (!handler.noWaitAfter) {
-            progress.log(`  locator handler has finished, waiting for ${(0, _utils.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)} to be hidden`);
-            await this.mainFrame().waitForSelectorInternal(progress, handler.selector, false, {
-              state: 'hidden'
-            });
-          } else {
-            progress.log(`  locator handler has finished`);
-          }
-        });
-        await this.openScope.race(promise).finally(() => --this._locatorHandlerRunningCounter);
-        // Avoid side-effects after long-running operation.
-        progress.throwIfAborted();
-        progress.log(`  interception handler has finished, continuing`);
-      }
-    }
-  }
-  async emulateMedia(options) {
-    if (options.media !== undefined) this._emulatedMedia.media = options.media;
-    if (options.colorScheme !== undefined) this._emulatedMedia.colorScheme = options.colorScheme;
-    if (options.reducedMotion !== undefined) this._emulatedMedia.reducedMotion = options.reducedMotion;
-    if (options.forcedColors !== undefined) this._emulatedMedia.forcedColors = options.forcedColors;
-    await this._delegate.updateEmulateMedia();
-  }
-  emulatedMedia() {
-    var _contextOptions$color, _contextOptions$reduc, _contextOptions$force;
-    const contextOptions = this._browserContext._options;
-    return {
-      media: this._emulatedMedia.media || 'no-override',
-      colorScheme: this._emulatedMedia.colorScheme !== undefined ? this._emulatedMedia.colorScheme : (_contextOptions$color = contextOptions.colorScheme) !== null && _contextOptions$color !== void 0 ? _contextOptions$color : 'light',
-      reducedMotion: this._emulatedMedia.reducedMotion !== undefined ? this._emulatedMedia.reducedMotion : (_contextOptions$reduc = contextOptions.reducedMotion) !== null && _contextOptions$reduc !== void 0 ? _contextOptions$reduc : 'no-preference',
-      forcedColors: this._emulatedMedia.forcedColors !== undefined ? this._emulatedMedia.forcedColors : (_contextOptions$force = contextOptions.forcedColors) !== null && _contextOptions$force !== void 0 ? _contextOptions$force : 'none'
-    };
-  }
-  async setViewportSize(viewportSize) {
-    this._emulatedSize = {
-      viewport: {
-        ...viewportSize
-      },
-      screen: {
-        ...viewportSize
-      }
-    };
-    await this._delegate.updateEmulatedViewportSize();
-  }
-  viewportSize() {
-    var _this$emulatedSize;
-    return ((_this$emulatedSize = this.emulatedSize()) === null || _this$emulatedSize === void 0 ? void 0 : _this$emulatedSize.viewport) || null;
-  }
-  emulatedSize() {
-    if (this._emulatedSize) return this._emulatedSize;
-    const contextOptions = this._browserContext._options;
-    return contextOptions.viewport ? {
-      viewport: contextOptions.viewport,
-      screen: contextOptions.screen || contextOptions.viewport
-    } : null;
-  }
-  async bringToFront() {
-    await this._delegate.bringToFront();
-  }
-  async addInitScript(source) {
-    const initScript = new InitScript(source);
-    this.initScripts.push(initScript);
-    await this._delegate.addInitScript(initScript);
-  }
-  async _removeInitScripts() {
-    this.initScripts = this.initScripts.filter(script => script.internal);
-    await this._delegate.removeNonInternalInitScripts();
-  }
-  needsRequestInterception() {
-    return !!this._clientRequestInterceptor || !!this._serverRequestInterceptor || !!this._browserContext._requestInterceptor;
-  }
-  async setClientRequestInterceptor(handler) {
-    this._clientRequestInterceptor = handler;
-    await this._delegate.updateRequestInterception();
-  }
-  async _setServerRequestInterceptor(handler) {
-    this._serverRequestInterceptor = handler;
-    await this._delegate.updateRequestInterception();
-  }
-  async expectScreenshot(metadata, options = {}) {
-    const locator = options.locator;
-    const rafrafScreenshot = locator ? async (progress, timeout) => {
-      return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
-    } : async (progress, timeout) => {
-      await this.performActionPreChecks(progress);
-      await this.mainFrame().rafrafTimeout(timeout);
-      return await this._screenshotter.screenshotPage(progress, options || {});
-    };
-    const comparator = (0, _comparators.getComparator)('image/png');
-    const controller = new _progress.ProgressController(metadata, this);
-    if (!options.expected && options.isNot) return {
-      errorMessage: '"not" matcher requires expected result'
-    };
-    try {
-      const format = (0, _screenshotter.validateScreenshotOptions)(options || {});
-      if (format !== 'png') throw new Error('Only PNG screenshots are supported');
-    } catch (error) {
-      return {
-        errorMessage: error.message
-      };
-    }
-    let intermediateResult = undefined;
-    const areEqualScreenshots = (actual, expected, previous) => {
-      const comparatorResult = actual && expected ? comparator(actual, expected, options) : undefined;
-      if (comparatorResult !== undefined && !!comparatorResult === !!options.isNot) return true;
-      if (comparatorResult) intermediateResult = {
-        errorMessage: comparatorResult.errorMessage,
-        diff: comparatorResult.diff,
-        actual,
-        previous
-      };
-      return false;
-    };
-    const callTimeout = this._timeoutSettings.timeout(options);
-    return controller.run(async progress => {
-      let actual;
-      let previous;
-      const pollIntervals = [0, 100, 250, 500];
-      progress.log(`${metadata.apiName}${callTimeout ? ` with timeout ${callTimeout}ms` : ''}`);
-      if (options.expected) progress.log(`  verifying given screenshot expectation`);else progress.log(`  generating new stable screenshot expectation`);
-      let isFirstIteration = true;
-      while (true) {
-        var _pollIntervals$shift;
-        progress.throwIfAborted();
-        if (this.isClosed()) throw new Error('The page has closed');
-        const screenshotTimeout = (_pollIntervals$shift = pollIntervals.shift()) !== null && _pollIntervals$shift !== void 0 ? _pollIntervals$shift : 1000;
-        if (screenshotTimeout) progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
-        previous = actual;
-        actual = await rafrafScreenshot(progress, screenshotTimeout).catch(e => {
-          progress.log(`failed to take screenshot - ` + e.message);
-          return undefined;
-        });
-        if (!actual) continue;
-        // Compare against expectation for the first iteration.
-        const expectation = options.expected && isFirstIteration ? options.expected : previous;
-        if (areEqualScreenshots(actual, expectation, previous)) break;
-        if (intermediateResult) progress.log(intermediateResult.errorMessage);
-        isFirstIteration = false;
-      }
-      if (!isFirstIteration) progress.log(`captured a stable screenshot`);
-      if (!options.expected) return {
-        actual
-      };
-      if (isFirstIteration) {
-        progress.log(`screenshot matched expectation`);
-        return {};
-      }
-      if (areEqualScreenshots(actual, options.expected, undefined)) {
-        progress.log(`screenshot matched expectation`);
-        return {};
-      }
-      throw new Error(intermediateResult.errorMessage);
-    }, callTimeout).catch(e => {
-      var _intermediateResult;
-      // Q: Why not throw upon isSessionClosedError(e) as in other places?
-      // A: We want user to receive a friendly diff between actual and expected/previous.
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
-      let errorMessage = e.message;
-      if (e instanceof _errors.TimeoutError && (_intermediateResult = intermediateResult) !== null && _intermediateResult !== void 0 && _intermediateResult.previous) errorMessage = `Failed to take two consecutive stable screenshots.`;
-      return {
-        log: (0, _utils.compressCallLog)(e.message ? [...metadata.log, e.message] : metadata.log),
-        ...intermediateResult,
-        errorMessage,
-        timedOut: e instanceof _errors.TimeoutError
-      };
-    });
-  }
-  async screenshot(metadata, options = {}) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this._screenshotter.screenshotPage(progress, options), this._timeoutSettings.timeout(options));
-  }
-  async close(metadata, options = {}) {
-    if (this._closedState === 'closed') return;
-    if (options.reason) this._closeReason = options.reason;
-    const runBeforeUnload = !!options.runBeforeUnload;
-    if (this._closedState !== 'closing') {
-      this._closedState = 'closing';
-      // This might throw if the browser context containing the page closes
-      // while we are trying to close the page.
-      await this._delegate.closePage(runBeforeUnload).catch(e => _debugLogger.debugLogger.log('error', e));
-    }
-    if (!runBeforeUnload) await this._closedPromise;
-    if (this._ownedContext) await this._ownedContext.close(options);
-  }
-  _setIsError(error) {
-    this._pageIsError = error;
-    this._frameManager.createDummyMainFrameIfNeeded();
-  }
-  isClosed() {
-    return this._closedState === 'closed';
-  }
-  hasCrashed() {
-    return this._crashed;
-  }
-  isClosedOrClosingOrCrashed() {
-    return this._closedState !== 'open' || this._crashed;
-  }
-  _addWorker(workerId, worker) {
-    this._workers.set(workerId, worker);
-    this.emit(Page.Events.Worker, worker);
-  }
-  _removeWorker(workerId) {
-    const worker = this._workers.get(workerId);
-    if (!worker) return;
-    worker.didClose();
-    this._workers.delete(workerId);
-  }
-  _clearWorkers() {
-    for (const [workerId, worker] of this._workers) {
-      worker.didClose();
-      this._workers.delete(workerId);
-    }
-  }
-  async setFileChooserIntercepted(enabled) {
-    this._interceptFileChooser = enabled;
-    await this._delegate.updateFileChooserInterception();
-  }
-  fileChooserIntercepted() {
-    return this._interceptFileChooser;
-  }
-  frameNavigatedToNewDocument(frame) {
-    this.emit(Page.Events.InternalFrameNavigatedToNewDocument, frame);
-    const origin = frame.origin();
-    if (origin) this._browserContext.addVisitedOrigin(origin);
-  }
-  allInitScripts() {
-    const bindings = [...this._browserContext._pageBindings.values(), ...this._pageBindings.values()];
-    return [...bindings.map(binding => binding.initScript), ...this._browserContext.initScripts, ...this.initScripts];
-  }
-  getBinding(name) {
-    return this._pageBindings.get(name) || this._browserContext._pageBindings.get(name);
-  }
-  setScreencastOptions(options) {
-    this._delegate.setScreencastOptions(options).catch(e => _debugLogger.debugLogger.log('error', e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
-  }
-  throttleScreencastFrameAck(ack) {
-    // Don't ack immediately, tracing has smart throttling logic that is implemented here.
-    this._frameThrottler.ack(ack);
-  }
-  temporarilyDisableTracingScreencastThrottling() {
-    this._frameThrottler.recharge();
-  }
-  async safeNonStallingEvaluateInAllFrames(expression, world, options = {}) {
-    await Promise.all(this.frames().map(async frame => {
-      try {
-        await frame.nonStallingEvaluateInExistingContext(expression, world);
-      } catch (e) {
-        if (options.throwOnJSErrors && js.isJavaScriptErrorInEvaluate(e)) throw e;
-      }
-    }));
-  }
-  async hideHighlight() {
-    await Promise.all(this.frames().map(frame => frame.hideHighlight().catch(() => {})));
-  }
-  markAsServerSideOnly() {
-    this._isServerSideOnly = true;
-  }
-}
-exports.Page = Page;
-Page.Events = {
-  Close: 'close',
-  Crash: 'crash',
-  Download: 'download',
-  FileChooser: 'filechooser',
-  FrameAttached: 'frameattached',
-  FrameDetached: 'framedetached',
-  InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
-  LocatorHandlerTriggered: 'locatorhandlertriggered',
-  ScreencastFrame: 'screencastframe',
-  Video: 'video',
-  WebSocket: 'websocket',
-  Worker: 'worker'
-};
-class Worker extends _instrumentation.SdkObject {
-  constructor(parent, url, targetId, session) {
-    super(parent, 'worker');
-    this._url = void 0;
-    this._executionContextPromise = void 0;
-    this._executionContextCallback = void 0;
-    this._existingExecutionContext = null;
-    this.openScope = new _utils.LongStandingScope();
-    this._targetId = void 0;
-    this._session = void 0;
-    this._url = url;
-    this._executionContextCallback = () => {};
-    this._executionContextPromise = new Promise(x => this._executionContextCallback = x);
-    this._targetId = targetId;
-    this._session = session;
-  }
-  _createExecutionContext(delegate) {
-    this._existingExecutionContext = new js.ExecutionContext(this, delegate, 'worker');
-    this._executionContextCallback(this._existingExecutionContext);
-  }
-  url() {
-    return this._url;
-  }
-  didClose() {
-    if (this._existingExecutionContext) this._existingExecutionContext.contextDestroyed('Worker was closed');
-    this.emit(Worker.Events.Close, this);
-    this.openScope.close(new Error('Worker closed'));
-  }
-  async getExecutionContext() {
-    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0' && !this._existingExecutionContext) {
-      await this._session.__re__emitExecutionContext({
-        world: 'main',
-        targetId: this._targetId
-      });
-    }
-    return this._executionContextPromise;
-  }
-  async evaluateExpression(expression, isFunction, arg) {
-    return js.evaluateExpression(await this.getExecutionContext(), expression, {
-      returnByValue: true,
-      isFunction
-    }, arg);
-  }
-  async evaluateExpressionHandle(expression, isFunction, arg) {
-    return js.evaluateExpression(await this.getExecutionContext(), expression, {
-      returnByValue: false,
-      isFunction
-    }, arg);
-  }
-}
-exports.Worker = Worker;
-Worker.Events = {
-  Close: 'close'
-};
-class PageBinding {
-  constructor(name, playwrightFunction, needsHandle) {
-    this.name = void 0;
-    this.playwrightFunction = void 0;
-    this.initScript = void 0;
-    this.needsHandle = void 0;
-    this.internal = void 0;
-    this.name = name;
-    this.playwrightFunction = playwrightFunction;
-    this.initScript = new InitScript(`(${addPageBinding.toString()})(${JSON.stringify(PageBinding.kPlaywrightBinding)}, ${JSON.stringify(name)}, ${needsHandle}, (${_utilityScriptSerializers.source})())`, true /* internal */);
-    this.needsHandle = needsHandle;
-    this.internal = name.startsWith('__pw');
-  }
-  static async dispatch(page, payload, context) {
-    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0' && !payload.includes('{')) {
-      // ignore as it's not a JSON but a string from addBinding method
-      return;
-    }
-    const {
-      name,
-      seq,
-      serializedArgs
-    } = JSON.parse(payload);
-    try {
-      (0, _utils.assert)(context.world);
-      const binding = page.getBinding(name);
-      if (!binding) throw new Error(`Function "${name}" is not exposed`);
-      let result;
-      if (binding.needsHandle) {
-        const handle = await context.evaluateHandle(takeHandle, {
-          name,
-          seq
-        }).catch(e => null);
-        result = await binding.playwrightFunction({
-          frame: context.frame,
-          page,
-          context: page._browserContext
-        }, handle);
-      } else {
-        if (!Array.isArray(serializedArgs)) throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
-        const args = serializedArgs.map(a => (0, _utilityScriptSerializers.parseEvaluationResultValue)(a));
-        result = await binding.playwrightFunction({
-          frame: context.frame,
-          page,
-          context: page._browserContext
-        }, ...args);
-      }
-      context.evaluate(deliverResult, {
-        name,
-        seq,
-        result
-      }).catch(e => _debugLogger.debugLogger.log('error', e));
-    } catch (error) {
-      context.evaluate(deliverResult, {
-        name,
-        seq,
-        error
-      }).catch(e => _debugLogger.debugLogger.log('error', e));
-    }
-    function takeHandle(arg) {
-      const handle = globalThis[arg.name]['handles'].get(arg.seq);
-      globalThis[arg.name]['handles'].delete(arg.seq);
-      return handle;
-    }
-    function deliverResult(arg) {
-      const callbacks = globalThis[arg.name]['callbacks'];
-      if ('error' in arg) callbacks.get(arg.seq).reject(arg.error);else callbacks.get(arg.seq).resolve(arg.result);
-      callbacks.delete(arg.seq);
-    }
-  }
-}
-exports.PageBinding = PageBinding;
-PageBinding.kPlaywrightBinding = '__playwright__binding__';
-function addPageBinding(playwrightBinding, bindingName, needsHandle, utilityScriptSerializers) {
-  const binding = globalThis[playwrightBinding];
-  globalThis[bindingName] = (...args) => {
-    const me = globalThis[bindingName];
-    if (needsHandle && args.slice(1).some(arg => arg !== undefined)) throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
-    let callbacks = me['callbacks'];
-    if (!callbacks) {
-      callbacks = new Map();
-      me['callbacks'] = callbacks;
-    }
-    const seq = (me['lastSeq'] || 0) + 1;
-    me['lastSeq'] = seq;
-    let handles = me['handles'];
-    if (!handles) {
-      handles = new Map();
-      me['handles'] = handles;
-    }
-    const promise = new Promise((resolve, reject) => callbacks.set(seq, {
-      resolve,
-      reject
-    }));
-    let payload;
-    if (needsHandle) {
-      handles.set(seq, args[0]);
-      payload = {
-        name: bindingName,
-        seq
-      };
-    } else {
-      const serializedArgs = [];
-      for (let i = 0; i < args.length; i++) {
-        serializedArgs[i] = utilityScriptSerializers.serializeAsCallArgument(args[i], v => {
-          return {
-            fallThrough: v
-          };
-        });
-      }
-      payload = {
-        name: bindingName,
-        seq,
-        serializedArgs
-      };
-    }
-    binding(JSON.stringify(payload));
-    return promise;
-  };
-  globalThis[bindingName].__installed = true;
-}
-class InitScript {
-  constructor(source, internal) {
-    this.source = void 0;
-    this.internal = void 0;
-    const guid = (0, _utils.createGuid)();
-    this.source = `(() => {
-      globalThis.__pwInitScripts = globalThis.__pwInitScripts || {};
-      const hasInitScript = globalThis.__pwInitScripts[${JSON.stringify(guid)}];
-      if (hasInitScript)
-        return;
-      globalThis.__pwInitScripts[${JSON.stringify(guid)}] = true;
-      ${source}
-    })();`;
-    this.internal = !!internal;
-  }
-}
-exports.InitScript = InitScript;
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._defaultInterval = void 0;
-    this._throttlingInterval = void 0;
-    this._nonThrottledFrames = void 0;
-    this._budget = void 0;
-    this._throttlingEnabled = false;
-    this._timeoutId = void 0;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
-  }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = undefined;
-    }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    // Send all acks, reset budget.
-    for (const ack of this._acks) ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
-    }
-  }
-  ack(ack) {
-    if (!this._timeoutId) {
-      // Already disposed.
-      ack();
-      return;
-    }
-    this._acks.push(ack);
-  }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      // Non-throttled frame budget is exceeded. Next ack will be throttled.
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      // Either not throttling, or still under budget. Next ack will be after the default timeout.
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
-  }
-}