patchright-core 1.57.0 → 1.59.0

package/lib/client/browserContext.js

@@ -39,7 +39,9 @@ var import_channelOwner = require("./channelOwner");
 var import_clientHelper = require("./clientHelper");
 var import_clock = require("./clock");
 var import_consoleMessage = require("./consoleMessage");
+var import_debugger = require("./debugger");
 var import_dialog = require("./dialog");
+var import_disposable = require("./disposable");
 var import_errors = require("./errors");
 var import_events = require("./events");
 var import_fetch = require("./fetch");
@@ -71,9 +73,9 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._harRecorders = /* @__PURE__ */ new Map();
     this._closingStatus = "none";
     this._harRouters = [];
-    this.routeInjecting = false;
     this._options = initializer.options;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
+    this.debugger = import_debugger.Debugger.from(initializer.debugger);
     this.tracing = import_tracing.Tracing.from(initializer.tracing);
     this.request = import_fetch.APIRequestContext.from(initializer.requestContext);
     this.request._timeoutSettings = this._timeoutSettings;
@@ -204,7 +206,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     const page = route.request()._safePage();
     const routeHandlers = this._routes.slice();
     for (const routeHandler of routeHandlers) {
-      if (page?._closeWasCalled || this._closingStatus !== "none")
+      if (page?._closeWasCalled || this.isClosed())
         return;
       if (!routeHandler.matches(route.request().url()))
         continue;
@@ -261,6 +263,9 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   pages() {
     return [...this._pages];
   }
+  isClosed() {
+    return this._closingStatus !== "none";
+  }
   async newPage() {
     if (this._ownerPage)
       throw new Error("Please use browser.newContext()");
@@ -309,24 +314,24 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || void 0 });
   }
   async addInitScript(script, arg) {
-    await this.installInjectRoute();
     const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
-    await this._channel.addInitScript({ source });
+    return import_disposable.DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
   async exposeBinding(name, callback, options = {}) {
-    await this.installInjectRoute();
-    await this._channel.exposeBinding({ name, needsHandle: options.handle });
+    const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
+    return import_disposable.DisposableObject.from(result.disposable);
   }
   async exposeFunction(name, callback) {
-    await this.installInjectRoute();
-    await this._channel.exposeBinding({ name });
+    const result = await this._channel.exposeBinding({ name });
     const binding = (source, ...args) => callback(...args);
     this._bindings.set(name, binding);
+    return import_disposable.DisposableObject.from(result.disposable);
   }
   async route(url, handler, options = {}) {
     this._routes.unshift(new network.RouteHandler(this._platform, this._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns({ title: "Route requests" });
+    return new import_disposable.DisposableStub(() => this.unroute(url, handler));
   }
   async routeWebSocket(url, handler) {
     this._webSocketRoutes.unshift(new network.WebSocketRouteHandler(this._options.baseURL, url, handler));
@@ -417,6 +422,10 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     }
     return state;
   }
+  async setStorageState(storageState) {
+    const state = await prepareStorageState(this._platform, storageState);
+    await this._channel.setStorageState({ storageState: state });
+  }
   backgroundPages() {
     return [];
   }
@@ -442,7 +451,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     await this.close();
   }
   async close(options = {}) {
-    if (this._closingStatus !== "none")
+    if (this.isClosed())
       return;
     this._closeReason = options.reason;
     this._closingStatus = "closing";
@@ -478,20 +487,8 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._onRecorderEventSink = void 0;
     await this._channel.disableRecorder();
   }
-  async installInjectRoute() {
-    if (this.routeInjecting) return;
-    await this.route("**/*", async (route) => {
-      try {
-        if (route.request().resourceType() === "document" && route.request().url().startsWith("http")) {
-          const protocol = route.request().url().split(":")[0];
-          await route.fallback({ url: protocol + "://patchright-init-script-inject.internal/" });
-        } else {
-          await route.fallback();
-        }
-      } catch (error) {
-        await route.fallback();
-      }
-    });
+  async _exposeConsoleApi() {
+    await this._channel.exposeConsoleApi();
   }
 }
 async function prepareStorageState(platform, storageState) {

package/lib/client/browserType.js

@@ -25,12 +25,9 @@ var import_browser = require("./browser");
 var import_browserContext = require("./browserContext");
 var import_channelOwner = require("./channelOwner");
 var import_clientHelper = require("./clientHelper");
-var import_events = require("./events");
 var import_assert = require("../utils/isomorphic/assert");
 var import_headers = require("../utils/isomorphic/headers");
-var import_time = require("../utils/isomorphic/time");
-var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
-var import_webSocket = require("./webSocket");
+var import_connect = require("./connect");
 var import_timeoutSettings = require("./timeoutSettings");
 class BrowserType extends import_channelOwner.ChannelOwner {
   constructor() {
@@ -73,13 +70,13 @@ class BrowserType extends import_channelOwner.ChannelOwner {
     return await this._serverLauncher.launchServer(options);
   }
   async launchPersistentContext(userDataDir, options = {}) {
-    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
     (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
     options = this._playwright.selectors._withSelectorOptions({
       ...this._playwright._defaultLaunchOptions,
-      ...this._playwright._defaultContextOptions,
       ...options
     });
+    await this._instrumentation.runBeforeCreateBrowserContext(options);
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
     const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const persistentParams = {
       ...contextParams,
@@ -101,57 +98,18 @@ class BrowserType extends import_channelOwner.ChannelOwner {
     await this._instrumentation.runAfterCreateBrowserContext(context);
     return context;
   }
-  async connect(optionsOrWsEndpoint, options) {
-    if (typeof optionsOrWsEndpoint === "string")
-      return await this._connect({ ...options, wsEndpoint: optionsOrWsEndpoint });
-    (0, import_assert.assert)(optionsOrWsEndpoint.wsEndpoint, "options.wsEndpoint is required");
-    return await this._connect(optionsOrWsEndpoint);
+  async connect(optionsOrEndpoint, options) {
+    if (typeof optionsOrEndpoint === "string")
+      return await this._connect({ ...options, endpoint: optionsOrEndpoint });
+    (0, import_assert.assert)(optionsOrEndpoint.wsEndpoint, "options.wsEndpoint is required");
+    return await this._connect({ ...options, endpoint: optionsOrEndpoint.wsEndpoint });
   }
   async _connect(params) {
     const logger = params.logger;
     return await this._wrapApiCall(async () => {
-      const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
-      const headers = { "x-playwright-browser": this.name(), ...params.headers };
-      const connectParams = {
-        wsEndpoint: params.wsEndpoint,
-        headers,
-        exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
-        slowMo: params.slowMo,
-        timeout: params.timeout || 0
-      };
-      if (params.__testHookRedirectPortForwarding)
-        connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
-      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
-      let browser;
-      connection.on("close", () => {
-        for (const context of browser?.contexts() || []) {
-          for (const page of context.pages())
-            page._onClose();
-          context._onClose();
-        }
-        setTimeout(() => browser?._didClose(), 0);
-      });
-      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
-        if (params.__testHookBeforeCreateBrowser)
-          await params.__testHookBeforeCreateBrowser();
-        const playwright = await connection.initializePlaywright();
-        if (!playwright._initializer.preLaunchedBrowser) {
-          connection.close();
-          throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
-        }
-        playwright.selectors = this._playwright.selectors;
-        browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
-        browser._connectToBrowserType(this, {}, logger);
-        browser._shouldCloseConnectionOnClose = true;
-        browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
-        return browser;
-      }, deadline);
-      if (!result.timedOut) {
-        return result.result;
-      } else {
-        connection.close();
-        throw new Error(`Timeout ${params.timeout}ms exceeded`);
-      }
+      const browser = await (0, import_connect.connectToBrowser)(this._playwright, { browserName: this.name(), ...params });
+      browser._connectToBrowserType(this, {}, logger);
+      return browser;
     });
   }
   async connectOverCDP(endpointURLOrOptions, options) {
@@ -169,7 +127,8 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       endpointURL,
       headers,
       slowMo: params.slowMo,
-      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params)
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params),
+      isLocal: params.isLocal
     });
     const browser = import_browser.Browser.from(result.browser);
     browser._connectToBrowserType(this, {}, params.logger);
@@ -177,6 +136,16 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
     return browser;
   }
+  async _connectOverCDPTransport(transport) {
+    if (this.name() !== "chromium")
+      throw new Error("Connecting over CDP is only supported in Chromium.");
+    const result = await this._channel.connectOverCDPTransport({ transport });
+    const browser = import_browser.Browser.from(result.browser);
+    browser._connectToBrowserType(this, {}, void 0);
+    if (result.defaultContext)
+      await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
+    return browser;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/client/cdpSession.js

@@ -28,8 +28,12 @@ class CDPSession extends import_channelOwner.ChannelOwner {
   }
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this._channel.on("event", ({ method, params }) => {
-      this.emit(method, params);
+    this._channel.on("event", (event) => {
+      this.emit(event.method, event.params);
+      this.emit("event", event);
+    });
+    this._channel.on("close", () => {
+      this.emit("close", this);
     });
     this.on = super.on;
     this.addListener = super.addListener;

package/lib/client/channelOwner.js

@@ -118,7 +118,7 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
       get: (obj, prop) => {
         if (typeof prop === "string") {
           const validator = (0, import_validator.maybeFindValidator)(this._type, prop, "Params");
-          const { internal } = import_protocolMetainfo.methodMetainfo.get(this._type + "." + prop) || {};
+          const { internal } = (0, import_protocolMetainfo.getMetainfo)({ type: this._type, method: prop }) || {};
           if (validator) {
             return async (params) => {
               return await this._wrapApiCall(async (apiZone) => {

package/lib/client/clientHelper.js

@@ -53,7 +53,8 @@ async function evaluationScript(platform, fun, arg, addSourceUrl = true) {
   throw new Error("Either path or content property must be present");
 }
 function addSourceUrlToScript(source, path) {
-  return source;
+  return `${source}
+//# sourceURL=${path.replace(/\n/g, "")}`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/client/clock.js

@@ -26,7 +26,6 @@ class Clock {
     this._browserContext = browserContext;
   }
   async install(options = {}) {
-    await this._browserContext.installInjectRoute();
     await this._browserContext._channel.clockInstall(options.time !== void 0 ? parseTime(options.time) : {});
   }
   async fastForward(ticks) {

package/lib/client/{webSocket.js → connect.js}

@@ -16,13 +16,62 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var webSocket_exports = {};
-__export(webSocket_exports, {
-  connectOverWebSocket: () => connectOverWebSocket
+var connect_exports = {};
+__export(connect_exports, {
+  connectToBrowser: () => connectToBrowser,
+  connectToEndpoint: () => connectToEndpoint
 });
-module.exports = __toCommonJS(webSocket_exports);
+module.exports = __toCommonJS(connect_exports);
+var import_time = require("../utils/isomorphic/time");
+var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
+var import_browser = require("./browser");
 var import_connection = require("./connection");
-async function connectOverWebSocket(parentConnection, params) {
+var import_events = require("./events");
+async function connectToBrowser(playwright, params) {
+  const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
+  const nameParam = params.browserName ? { "x-playwright-browser": params.browserName } : {};
+  const headers = { ...nameParam, ...params.headers };
+  const connectParams = {
+    endpoint: params.endpoint,
+    headers,
+    exposeNetwork: params.exposeNetwork,
+    slowMo: params.slowMo,
+    timeout: params.timeout || 0
+  };
+  if (params.__testHookRedirectPortForwarding)
+    connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
+  const connection = await connectToEndpoint(playwright._connection, connectParams);
+  let browser;
+  connection.on("close", () => {
+    for (const context of browser?.contexts() || []) {
+      for (const page of context.pages())
+        page._onClose();
+      context._onClose();
+    }
+    setTimeout(() => browser?._didClose(), 0);
+  });
+  const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
+    if (params.__testHookBeforeCreateBrowser)
+      await params.__testHookBeforeCreateBrowser();
+    const playwright2 = await connection.initializePlaywright();
+    if (!playwright2._initializer.preLaunchedBrowser) {
+      connection.close();
+      throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
+    }
+    playwright2.selectors = playwright2.selectors;
+    browser = import_browser.Browser.from(playwright2._initializer.preLaunchedBrowser);
+    browser._shouldCloseConnectionOnClose = true;
+    browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
+    return browser;
+  }, deadline);
+  if (!result.timedOut) {
+    return result.result;
+  } else {
+    connection.close();
+    throw new Error(`Timeout ${params.timeout}ms exceeded`);
+  }
+}
+async function connectToEndpoint(parentConnection, params) {
   const localUtils = parentConnection.localUtils();
   const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
   const connectHeaders = await transport.connect(params);
@@ -71,7 +120,7 @@ class JsonPipeTransport {
 }
 class WebSocketTransport {
   async connect(params) {
-    this._ws = new window.WebSocket(params.wsEndpoint);
+    this._ws = new window.WebSocket(params.endpoint);
     return [];
   }
   async send(message) {
@@ -89,5 +138,6 @@ class WebSocketTransport {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  connectOverWebSocket
+  connectToBrowser,
+  connectToEndpoint
 });

package/lib/client/connection.js

@@ -30,7 +30,9 @@ var import_browserType = require("./browserType");
 var import_cdpSession = require("./cdpSession");
 var import_channelOwner = require("./channelOwner");
 var import_clientInstrumentation = require("./clientInstrumentation");
+var import_debugger = require("./debugger");
 var import_dialog = require("./dialog");
+var import_disposable = require("./disposable");
 var import_electron = require("./electron");
 var import_elementHandle = require("./elementHandle");
 var import_errors = require("./errors");
@@ -232,9 +234,15 @@ class Connection extends import_eventEmitter.EventEmitter {
       case "CDPSession":
         result = new import_cdpSession.CDPSession(parent, type, guid, initializer);
         break;
+      case "Debugger":
+        result = new import_debugger.Debugger(parent, type, guid, initializer);
+        break;
       case "Dialog":
         result = new import_dialog.Dialog(parent, type, guid, initializer);
         break;
+      case "Disposable":
+        result = new import_disposable.DisposableObject(parent, type, guid, initializer);
+        break;
       case "Electron":
         result = new import_electron.Electron(parent, type, guid, initializer);
         break;

package/lib/client/consoleMessage.js

@@ -48,6 +48,9 @@ class ConsoleMessage {
   location() {
     return this._event.location;
   }
+  timestamp() {
+    return this._event.timestamp;
+  }
   _inspect() {
     return this.text();
   }

package/lib/client/debugger.js

@@ -0,0 +1,57 @@
+"use strict";
+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 debugger_exports = {};
+__export(debugger_exports, {
+  Debugger: () => Debugger
+});
+module.exports = __toCommonJS(debugger_exports);
+var import_channelOwner = require("./channelOwner");
+var import_events = require("./events");
+class Debugger extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._pausedDetails = null;
+    this._channel.on("pausedStateChanged", ({ pausedDetails }) => {
+      this._pausedDetails = pausedDetails ?? null;
+      this.emit(import_events.Events.Debugger.PausedStateChanged);
+    });
+  }
+  static from(channel) {
+    return channel._object;
+  }
+  async requestPause() {
+    await this._channel.requestPause();
+  }
+  async resume() {
+    await this._channel.resume();
+  }
+  async next() {
+    await this._channel.next();
+  }
+  async runTo(location) {
+    await this._channel.runTo({ location });
+  }
+  pausedDetails() {
+    return this._pausedDetails;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Debugger
+});

package/lib/client/dialog.js

@@ -23,6 +23,7 @@ __export(dialog_exports, {
 module.exports = __toCommonJS(dialog_exports);
 var import_channelOwner = require("./channelOwner");
 var import_page = require("./page");
+var import_errors = require("./errors");
 class Dialog extends import_channelOwner.ChannelOwner {
   static from(dialog) {
     return dialog._object;
@@ -47,7 +48,13 @@ class Dialog extends import_channelOwner.ChannelOwner {
     await this._channel.accept({ promptText });
   }
   async dismiss() {
-    await this._channel.dismiss();
+    try {
+      await this._channel.dismiss();
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/client/disposable.js

@@ -0,0 +1,76 @@
+"use strict";
+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 disposable_exports = {};
+__export(disposable_exports, {
+  DisposableObject: () => DisposableObject,
+  DisposableStub: () => DisposableStub,
+  disposeAll: () => disposeAll
+});
+module.exports = __toCommonJS(disposable_exports);
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+class DisposableObject extends import_channelOwner.ChannelOwner {
+  static from(channel) {
+    return channel._object;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+  async dispose() {
+    try {
+      await this._channel.dispose();
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+}
+class DisposableStub {
+  constructor(dispose) {
+    this._dispose = dispose;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+  async dispose() {
+    if (!this._dispose)
+      return;
+    try {
+      const dispose = this._dispose;
+      this._dispose = void 0;
+      await dispose();
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+}
+async function disposeAll(disposables) {
+  const copy = [...disposables];
+  disposables.length = 0;
+  await Promise.all(copy.map((d) => d.dispose()));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DisposableObject,
+  DisposableStub,
+  disposeAll
+});

package/lib/client/electron.js

@@ -44,6 +44,7 @@ class Electron extends import_channelOwner.ChannelOwner {
       ...await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options),
       env: (0, import_clientHelper.envObjectToArray)(options.env ? options.env : this._platform.env),
       tracesDir: options.tracesDir,
+      artifactsDir: options.artifactsDir,
       timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
     };
     const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);

package/lib/client/elementHandle.js

@@ -231,7 +231,7 @@ async function convertInputFiles(platform, files, context) {
       throw new Error("File paths cannot be mixed with buffers");
     const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(platform, items);
     if (context._connection.isRemote()) {
-      const files2 = localDirectory ? (await platform.fs().promises.readdir(localDirectory, { withFileTypes: true, recursive: true })).filter((f) => f.isFile()).map((f) => platform.path().join(f.path, f.name)) : localPaths;
+      const files2 = localDirectory ? (await platform.fs().promises.readdir(localDirectory, { withFileTypes: true, recursive: true })).filter((f) => f.isFile()).map((f) => platform.path().join(f.parentPath, f.name)) : localPaths;
       const { writableStreams, rootDir } = await context._wrapApiCall(async () => context._channel.createTempFiles({
         rootDirName: localDirectory ? platform.path().basename(localDirectory) : void 0,
         items: await Promise.all(files2.map(async (file) => {

package/lib/client/events.js

@@ -36,6 +36,9 @@ const Events = {
   Browser: {
     Disconnected: "disconnected"
   },
+  Debugger: {
+    PausedStateChanged: "pausedstatechanged"
+  },
   BrowserContext: {
     Console: "console",
     Close: "close",

package/lib/client/fetch.js

@@ -39,10 +39,8 @@ class APIRequest {
     this._playwright = playwright;
   }
   async newContext(options = {}) {
-    options = {
-      ...this._playwright._defaultContextOptions,
-      ...options
-    };
+    options = { ...options };
+    await this._playwright._instrumentation.runBeforeCreateRequestContext(options);
     const storageState = typeof options.storageState === "string" ? JSON.parse(await this._playwright._platform.fs().promises.readFile(options.storageState, "utf8")) : options.storageState;
     const context = APIRequestContext.from((await this._playwright._channel.newRequest({
       ...options,

package/lib/client/frame.js

@@ -166,18 +166,14 @@ class Frame extends import_channelOwner.ChannelOwner {
   async frameElement() {
     return import_elementHandle.ElementHandle.from((await this._channel.frameElement()).element);
   }
-  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
+  async evaluateHandle(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return import_jsHandle.JSHandle.from(result.handle);
   }
-  async evaluate(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
-    return (0, import_jsHandle.parseResult)(result.value);
-  }
-  async _evaluateFunction(functionDeclaration) {
-    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: (0, import_jsHandle.serializeArgument)(void 0) });
+  async evaluate(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async _evaluateExposeUtilityScript(pageFunction, arg) {
@@ -205,9 +201,9 @@ class Frame extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async $$eval(selector, pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 4);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
+  async $$eval(selector, pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async $$(selector) {