rebrowser-playwright-core 1.49.1 → 1.52.0

package/lib/server/page.js

@@ -1,88 +1,85 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var page_exports = {};
+__export(page_exports, {
+  InitScript: () => InitScript,
+  Page: () => Page,
+  PageBinding: () => PageBinding,
+  Worker: () => Worker,
+  kBuiltinsScript: () => kBuiltinsScript
 });
-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 {
+module.exports = __toCommonJS(page_exports);
+var accessibility = __toESM(require("./accessibility"));
+var import_browserContext = require("./browserContext");
+var import_console = require("./console");
+var import_errors = require("./errors");
+var import_fileChooser = require("./fileChooser");
+var frames = __toESM(require("./frames"));
+var import_helper = require("./helper");
+var input = __toESM(require("./input"));
+var import_instrumentation = require("./instrumentation");
+var import_builtins = require("../utils/isomorphic/builtins");
+var import_pageBinding = require("./pageBinding");
+var js = __toESM(require("./javascript"));
+var import_progress = require("./progress");
+var import_screenshotter = require("./screenshotter");
+var import_timeoutSettings = require("./timeoutSettings");
+var import_utils = require("../utils");
+var import_crypto = require("./utils/crypto");
+var import_utils2 = require("../utils");
+var import_comparators = require("./utils/comparators");
+var import_debugLogger = require("./utils/debugLogger");
+var import_selectorParser = require("../utils/isomorphic/selectorParser");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_callLog = require("./callLog");
+class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
-    super(browserContext, 'page');
-    this._closedState = 'open';
-    this._closedPromise = new _manualPromise.ManualPromise();
-    this._initialized = false;
+    super(browserContext, "page");
+    this._closedState = "open";
+    this._closedPromise = new import_manualPromise.ManualPromise();
+    this._initializedPromise = new import_manualPromise.ManualPromise();
     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.openScope = new import_utils.LongStandingScope();
     this._emulatedMedia = {};
     this._interceptFileChooser = false;
-    this._pageBindings = new Map();
+    this._pageBindings = /* @__PURE__ */ 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._workers = /* @__PURE__ */ new Map();
     this._video = null;
-    this._opener = void 0;
     this._isServerSideOnly = false;
-    this._locatorHandlers = new Map();
+    this._locatorHandlers = /* @__PURE__ */ 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;
@@ -90,82 +87,103 @@ class Page extends _instrumentation.SdkObject {
     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._timeoutSettings = new import_timeoutSettings.TimeoutSettings(browserContext._timeoutSettings);
+    this._screenshotter = new import_screenshotter.Screenshotter(this);
     this._frameManager = new frames.FrameManager(this);
-    if (delegate.pdf) this.pdf = delegate.pdf.bind(delegate);
+    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;
+  static {
+    this.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"
+    };
+  }
+  async reportAsNew(opener, error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
+    if (opener) {
+      const openerPageOrError = await opener.waitForInitializedOrError();
+      if (openerPageOrError instanceof Page && !openerPageOrError.isClosed())
+        this._opener = openerPageOrError;
+    }
+    this._markInitialized(error, contextEvent);
   }
-  reportAsNew(error = undefined, contextEvent = _browserContext.BrowserContext.Events.Page) {
+  _markInitialized(error = void 0, contextEvent = import_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);
+      if (this._browserContext.isClosingOrClosed())
+        return;
+      this._frameManager.createDummyMainFrameIfNeeded();
     }
-    this._initialized = true;
+    this._initialized = error || this;
     this.emitOnContext(contextEvent, this);
-    for (const {
-      event,
-      args
-    } of this._eventsToEmitAfterInitialized) this._browserContext.emit(event, ...args);
+    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);
+    if (this.isClosed())
+      this.emit(Page.Events.Close);
+    else
+      this.instrumentation.onPageOpen(this);
+    this._initializedPromise.resolve(this._initialized);
   }
   initializedOrUndefined() {
-    return this._initialized ? this : undefined;
+    return this._initialized ? this : void 0;
+  }
+  waitForInitializedOrError() {
+    return this._initializedPromise;
   }
   emitOnContext(event, ...args) {
-    if (this._isServerSideOnly) return;
+    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
-    });
+    if (this._isServerSideOnly)
+      return;
+    if (this._initialized)
+      this._browserContext.emit(event, ...args);
+    else
+      this._eventsToEmitAfterInitialized.push({ event, args });
   }
   async resetForReuse(metadata) {
-    this.setDefaultNavigationTimeout(undefined);
-    this.setDefaultTimeout(undefined);
+    this.setDefaultNavigationTimeout(void 0);
+    this.setDefaultTimeout(void 0);
     this._locatorHandlers.clear();
     await this._removeExposedBindings();
     await this._removeInitScripts();
-    await this.setClientRequestInterceptor(undefined);
-    await this._setServerRequestInterceptor(undefined);
+    await this.setClientRequestInterceptor(void 0);
+    await this._setServerRequestInterceptor(void 0);
     await this.setFileChooserIntercepted(false);
-    // Re-navigate once init scripts are gone.
-    await this.mainFrame().goto(metadata, 'about:blank');
-    this._emulatedSize = undefined;
+    await this.mainFrame().goto(metadata, "about:blank");
+    this._emulatedSize = void 0;
     this._emulatedMedia = {};
-    this._extraHTTPHeaders = undefined;
+    this._extraHTTPHeaders = void 0;
     this._interceptFileChooser = false;
-    await Promise.all([this._delegate.updateEmulatedViewportSize(), this._delegate.updateEmulateMedia(), this._delegate.updateFileChooserInterception()]);
+    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';
+    (0, import_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());
+    this.openScope.close(new import_errors.TargetClosedError());
   }
   _didCrash() {
     this._frameManager.dispose();
@@ -173,21 +191,20 @@ class Page extends _instrumentation.SdkObject {
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new Error('Page crashed'));
+    this.openScope.close(new Error("Page crashed"));
   }
   async _onFileChooserOpened(handle) {
     let multiple;
     try {
-      multiple = await handle.evaluate(element => !!element.multiple);
+      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);
+    const fileChooser = new import_fileChooser.FileChooser(this, handle, multiple);
     this.emit(Page.Events.FileChooser, fileChooser);
   }
   context() {
@@ -209,16 +226,20 @@ class Page extends _instrumentation.SdkObject {
     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`);
+    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 => {})));
+    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);
+      if (!binding.internal)
+        this._pageBindings.delete(key);
     }
   }
   setExtraHTTPHeaders(headers) {
@@ -229,60 +250,61 @@ class Page extends _instrumentation.SdkObject {
     return this._extraHTTPHeaders;
   }
   async _onBindingCalled(payload, context) {
-    if (this._closedState === 'closed') return;
+    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 message = new import_console.ConsoleMessage(this, type, text, args, location);
     const intercepted = this._frameManager.interceptConsoleMessage(message);
     if (intercepted) {
-      args.forEach(arg => arg.dispose());
+      args.forEach((arg) => arg.dispose());
       return;
     }
-    this.emitOnContextOnceInitialized(_browserContext.BrowserContext.Events.Console, message);
+    this.emitOnContextOnceInitialized(import_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 controller = new import_progress.ProgressController(metadata, this);
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
       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()]);
+        // Reload must be a new document, and should not be confused with a stray pushState.
+        this.mainFrame()._waitForNavigation(progress, true, 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.
+    const controller = new import_progress.ProgressController(metadata, this);
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
       let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
+      const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
       const result = await this._delegate.goBack();
-      if (!result) return null;
+      if (!result)
+        return null;
       const response = await waitPromise;
-      if (error) throw error;
+      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.
+    const controller = new import_progress.ProgressController(metadata, this);
+    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
       let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
+      const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
       const result = await this._delegate.goForward();
-      if (!result) return null;
+      if (!result)
+        return null;
       const response = await waitPromise;
-      if (error) throw error;
+      if (error)
+        throw error;
       return response;
     }), this._timeoutSettings.navigationTimeout(options));
   }
@@ -291,19 +313,16 @@ class Page extends _instrumentation.SdkObject {
   }
   registerLocatorHandler(selector, noWaitAfter) {
     const uid = ++this._lastLocatorHandlerUid;
-    this._locatorHandlers.set(uid, {
-      selector,
-      noWaitAfter
-    });
+    this._locatorHandlers.set(uid, { selector, noWaitAfter });
     return uid;
   }
   resolveLocatorHandler(uid, remove) {
     const handler = this._locatorHandlers.get(uid);
-    if (remove) this._locatorHandlers.delete(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;
+      handler.resolved?.resolve();
+      handler.resolved = void 0;
     }
   }
   unregisterLocatorHandler(uid) {
@@ -314,106 +333,99 @@ class Page extends _instrumentation.SdkObject {
     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;
+    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)}"` : '';
+    if (!mainFrame || !mainFrame.pendingDocument())
+      return;
+    const url = mainFrame.pendingDocument()?.request?.url();
+    const toUrl = url ? `" ${(0, import_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)}"`);
+    await import_helper.helper.waitForEvent(progress, mainFrame, frames.Frame.Events.InternalNavigation, (e) => {
+      if (!e.isPublic)
+        return false;
+      if (!e.error)
+        progress.log(`  navigated to "${(0, import_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;
+    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();
+        if (await this.mainFrame().isVisibleInternal(handler.selector, { strict: true })) {
+          handler.resolved = new import_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`);
+        progress.log(`  found ${(0, import_utils2.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'
-            });
+            progress.log(`  locator handler has finished, waiting for ${(0, import_utils2.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;
+    if (options.media !== void 0)
+      this._emulatedMedia.media = options.media;
+    if (options.colorScheme !== void 0)
+      this._emulatedMedia.colorScheme = options.colorScheme;
+    if (options.reducedMotion !== void 0)
+      this._emulatedMedia.reducedMotion = options.reducedMotion;
+    if (options.forcedColors !== void 0)
+      this._emulatedMedia.forcedColors = options.forcedColors;
+    if (options.contrast !== void 0)
+      this._emulatedMedia.contrast = options.contrast;
     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'
+      media: this._emulatedMedia.media || "no-override",
+      colorScheme: this._emulatedMedia.colorScheme !== void 0 ? this._emulatedMedia.colorScheme : contextOptions.colorScheme ?? "light",
+      reducedMotion: this._emulatedMedia.reducedMotion !== void 0 ? this._emulatedMedia.reducedMotion : contextOptions.reducedMotion ?? "no-preference",
+      forcedColors: this._emulatedMedia.forcedColors !== void 0 ? this._emulatedMedia.forcedColors : contextOptions.forcedColors ?? "none",
+      contrast: this._emulatedMedia.contrast !== void 0 ? this._emulatedMedia.contrast : contextOptions.contrast ?? "no-preference"
     };
   }
   async setViewportSize(viewportSize) {
-    this._emulatedSize = {
-      viewport: {
-        ...viewportSize
-      },
-      screen: {
-        ...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;
+    return this.emulatedSize()?.viewport || null;
   }
   emulatedSize() {
-    if (this._emulatedSize) return this._emulatedSize;
+    if (this._emulatedSize)
+      return this._emulatedSize;
     const contextOptions = this._browserContext._options;
-    return contextOptions.viewport ? {
-      viewport: contextOptions.viewport,
-      screen: contextOptions.screen || contextOptions.viewport
-    } : null;
+    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);
+  async addInitScript(source, name) {
+    const initScript = new InitScript(source, false, name);
     this.initScripts.push(initScript);
     await this._delegate.addInitScript(initScript);
   }
   async _removeInitScripts() {
-    this.initScripts = this.initScripts.filter(script => script.internal);
+    this.initScripts = this.initScripts.filter((script) => script.internal);
     await this._delegate.removeNonInternalInitScripts();
   }
   needsRequestInterception() {
@@ -436,114 +448,115 @@ class Page extends _instrumentation.SdkObject {
       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'
-    };
+    const comparator = (0, import_comparators.getComparator)("image/png");
+    const controller = new import_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');
+      const format = (0, import_screenshotter.validateScreenshotOptions)(options || {});
+      if (format !== "png")
+        throw new Error("Only PNG screenshots are supported");
     } catch (error) {
-      return {
-        errorMessage: error.message
-      };
+      return { errorMessage: error.message };
     }
-    let intermediateResult = undefined;
+    let intermediateResult = void 0;
     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
-      };
+      const comparatorResult = actual && expected ? comparator(actual, expected, options) : void 0;
+      if (comparatorResult !== void 0 && !!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 => {
+    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`);
+      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`);
+        if (this.isClosed())
+          throw new Error("The page has closed");
+        const screenshotTimeout = pollIntervals.shift() ?? 1e3;
+        if (screenshotTimeout)
+          progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
         previous = actual;
-        actual = await rafrafScreenshot(progress, screenshotTimeout).catch(e => {
+        actual = await rafrafScreenshot(progress, screenshotTimeout).catch((e) => {
           progress.log(`failed to take screenshot - ` + e.message);
-          return undefined;
+          return void 0;
         });
-        if (!actual) continue;
-        // Compare against expectation for the first iteration.
+        if (!actual)
+          continue;
         const expectation = options.expected && isFirstIteration ? options.expected : previous;
-        if (areEqualScreenshots(actual, expectation, previous)) break;
-        if (intermediateResult) progress.log(intermediateResult.errorMessage);
+        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(`captured a stable screenshot`);
+      if (!options.expected)
+        return { actual };
       if (isFirstIteration) {
         progress.log(`screenshot matched expectation`);
         return {};
       }
-      if (areEqualScreenshots(actual, options.expected, undefined)) {
+      if (areEqualScreenshots(actual, options.expected, void 0)) {
         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;
+    }, callTimeout).catch((e) => {
+      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_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.`;
+      if (e instanceof import_errors.TimeoutError && intermediateResult?.previous)
+        errorMessage = `Failed to take two consecutive stable screenshots.`;
       return {
-        log: (0, _utils.compressCallLog)(e.message ? [...metadata.log, e.message] : metadata.log),
+        log: (0, import_callLog.compressCallLog)(e.message ? [...metadata.log, e.message] : metadata.log),
         ...intermediateResult,
         errorMessage,
-        timedOut: e instanceof _errors.TimeoutError
+        timedOut: e instanceof import_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));
+    const controller = new import_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;
+    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 (this._closedState !== "closing") {
+      this._closedState = "closing";
+      await this._delegate.closePage(runBeforeUnload).catch((e) => import_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();
+    if (!runBeforeUnload)
+      await this._closedPromise;
+    if (this._ownedContext)
+      await this._ownedContext.close(options);
   }
   isClosed() {
-    return this._closedState === 'closed';
+    return this._closedState === "closed";
   }
   hasCrashed() {
     return this._crashed;
   }
   isClosedOrClosingOrCrashed() {
-    return this._closedState !== 'open' || this._crashed;
+    return this._closedState !== "open" || this._crashed;
   }
   _addWorker(workerId, worker) {
     this._workers.set(workerId, worker);
@@ -551,7 +564,8 @@ class Page extends _instrumentation.SdkObject {
   }
   _removeWorker(workerId) {
     const worker = this._workers.get(workerId);
-    if (!worker) return;
+    if (!worker)
+      return;
     worker.didClose();
     this._workers.delete(workerId);
   }
@@ -571,237 +585,135 @@ class Page extends _instrumentation.SdkObject {
   frameNavigatedToNewDocument(frame) {
     this.emit(Page.Events.InternalFrameNavigatedToNewDocument, frame);
     const origin = frame.origin();
-    if (origin) this._browserContext.addVisitedOrigin(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];
+    return [kBuiltinsScript, ...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._delegate.setScreencastOptions(options).catch((e) => import_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 => {
+    await Promise.all(this.frames().map(async (frame) => {
       try {
         await frame.nonStallingEvaluateInExistingContext(expression, world);
       } catch (e) {
-        if (options.throwOnJSErrors && js.isJavaScriptErrorInEvaluate(e)) throw e;
+        if (options.throwOnJSErrors && js.isJavaScriptErrorInEvaluate(e))
+          throw e;
       }
     }));
   }
   async hideHighlight() {
-    await Promise.all(this.frames().map(frame => frame.hideHighlight().catch(() => {})));
+    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 {
+class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url, targetId, session) {
-    super(parent, 'worker');
-    this._url = void 0;
-    this._executionContextPromise = void 0;
-    this._executionContextCallback = void 0;
+    super(parent, "worker");
     this._existingExecutionContext = null;
-    this.openScope = new _utils.LongStandingScope();
-    this._targetId = void 0;
-    this._session = void 0;
+    this.openScope = new import_utils.LongStandingScope();
     this._url = url;
-    this._executionContextCallback = () => {};
-    this._executionContextPromise = new Promise(x => this._executionContextCallback = x);
+    this._executionContextCallback = () => {
+    };
+    this._executionContextPromise = new Promise((x) => this._executionContextCallback = x);
     this._targetId = targetId;
     this._session = session;
   }
+  static {
+    this.Events = {
+      Close: "close"
+    };
+  }
   _createExecutionContext(delegate) {
-    this._existingExecutionContext = new js.ExecutionContext(this, delegate, 'worker');
+    this._existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
     this._executionContextCallback(this._existingExecutionContext);
+    return this._existingExecutionContext;
   }
   url() {
     return this._url;
   }
   didClose() {
-    if (this._existingExecutionContext) this._existingExecutionContext.contextDestroyed('Worker was closed');
+    if (this._existingExecutionContext)
+      this._existingExecutionContext.contextDestroyed("Worker was closed");
     this.emit(Worker.Events.Close, this);
-    this.openScope.close(new Error('Worker closed'));
+    this.openScope.close(new Error("Worker closed"));
   }
   async getExecutionContext() {
-    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0' && !this._existingExecutionContext) {
+    if (process.env["REBROWSER_PATCHES_RUNTIME_FIX_MODE"] !== "0" && !this._existingExecutionContext) {
       await this._session.__re__emitExecutionContext({
-        world: 'main',
+        world: "main",
         targetId: this._targetId
       });
     }
     return this._executionContextPromise;
   }
   async evaluateExpression(expression, isFunction, arg) {
-    return js.evaluateExpression(await this.getExecutionContext(), expression, {
-      returnByValue: true,
-      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);
+    return js.evaluateExpression(await this.getExecutionContext(), expression, { returnByValue: false, isFunction }, arg);
   }
 }
-exports.Worker = Worker;
-Worker.Events = {
-  Close: 'close'
-};
 class PageBinding {
+  static {
+    this.kPlaywrightBinding = "__playwright__binding__";
+  }
   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.initScript = new InitScript(
+      (0, import_pageBinding.createPageBindingScript)(PageBinding.kPlaywrightBinding, name, needsHandle),
+      true
+      /* internal */
+    );
     this.needsHandle = needsHandle;
-    this.internal = name.startsWith('__pw');
+    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
+    if (process.env["REBROWSER_PATCHES_RUNTIME_FIX_MODE"] !== "0" && !payload.includes("{")) {
       return;
     }
-    const {
-      name,
-      seq,
-      serializedArgs
-    } = JSON.parse(payload);
+    const { name, seq, serializedArgs } = JSON.parse(payload);
     try {
-      (0, _utils.assert)(context.world);
+      (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
-      if (!binding) throw new Error(`Function "${name}" is not exposed`);
+      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);
+        const handle = await context.evaluateHandle(import_pageBinding.takeBindingHandle, { 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);
+        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) => js.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));
+      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_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);
+      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
   }
 }
-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)();
+  constructor(source, internal, name) {
+    const guid = (0, import_crypto.createGuid)();
     this.source = `(() => {
       globalThis.__pwInitScripts = globalThis.__pwInitScripts || {};
       const hasInitScript = globalThis.__pwInitScripts[${JSON.stringify(guid)}];
@@ -811,18 +723,18 @@ class InitScript {
       ${source}
     })();`;
     this.internal = !!internal;
+    this.name = name;
   }
 }
-exports.InitScript = InitScript;
+const kBuiltinsScript = new InitScript(
+  `(${import_builtins.builtins})()`,
+  true
+  /* internal */
+);
 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;
@@ -832,15 +744,15 @@ class FrameThrottler {
   dispose() {
     if (this._timeoutId) {
       clearTimeout(this._timeoutId);
-      this._timeoutId = undefined;
+      this._timeoutId = void 0;
     }
   }
   setThrottlingEnabled(enabled) {
     this._throttlingEnabled = enabled;
   }
   recharge() {
-    // Send all acks, reset budget.
-    for (const ack of this._acks) ack();
+    for (const ack of this._acks)
+      ack();
     this._acks = [];
     this._budget = this._nonThrottledFrames;
     if (this._timeoutId) {
@@ -850,7 +762,6 @@ class FrameThrottler {
   }
   ack(ack) {
     if (!this._timeoutId) {
-      // Already disposed.
       ack();
       return;
     }
@@ -863,11 +774,17 @@ class FrameThrottler {
       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);
     }
   }
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InitScript,
+  Page,
+  PageBinding,
+  Worker,
+  kBuiltinsScript
+});