patchright-bun-core 1.58.2 → 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");
@@ -73,10 +75,10 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._harRouters = [];
     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;
-    this.request._checkUrlAllowed = (url) => this._checkUrlAllowed(url);
     this.clock = new import_clock.Clock(this);
     this._channel.on("bindingCall", ({ binding }) => this._onBinding(import_page.BindingCall.from(binding)));
     this._channel.on("close", () => this._onClose());
@@ -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()");
@@ -310,20 +315,23 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   }
   async addInitScript(script, arg) {
     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._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._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));
@@ -414,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 [];
   }
@@ -439,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,37 +490,6 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   async _exposeConsoleApi() {
     await this._channel.exposeConsoleApi();
   }
-  _setAllowedProtocols(protocols) {
-    this._allowedProtocols = protocols;
-  }
-  _checkUrlAllowed(url) {
-    if (!this._allowedProtocols)
-      return;
-    let parsedURL;
-    try {
-      parsedURL = new URL(url);
-    } catch (e) {
-      throw new Error(`Access to ${url} is blocked. Invalid URL: ${e.message}`);
-    }
-    if (!this._allowedProtocols.includes(parsedURL.protocol))
-      throw new Error(`Access to "${parsedURL.protocol}" URL is blocked. Allowed protocols: ${this._allowedProtocols.join(", ")}. Attempted URL: ${url}`);
-  }
-  _setAllowedDirectories(rootDirectories) {
-    this._allowedDirectories = rootDirectories;
-  }
-  _checkFileAccess(filePath) {
-    if (!this._allowedDirectories)
-      return;
-    const path = this._platform.path().resolve(filePath);
-    const isInsideDir = (container, child) => {
-      const path2 = this._platform.path();
-      const rel = path2.relative(container, child);
-      return !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
-    };
-    if (this._allowedDirectories.some((root) => isInsideDir(root, path)))
-      return;
-    throw new Error(`File access denied: ${filePath} is outside allowed roots. Allowed roots: ${this._allowedDirectories.length ? this._allowedDirectories.join(", ") : "none"}`);
-  }
 }
 async function prepareStorageState(platform, storageState) {
   if (typeof storageState !== "string")

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() {
@@ -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) {
@@ -178,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/{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");
@@ -48,7 +50,6 @@ var import_worker = require("./worker");
 var import_writableStream = require("./writableStream");
 var import_validator = require("../protocol/validator");
 var import_stackTrace = require("../utils/isomorphic/stackTrace");
-var import_pageAgent = require("./pageAgent");
 class Root extends import_channelOwner.ChannelOwner {
   constructor(connection) {
     super(connection, "Root", "", {});
@@ -233,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;
@@ -262,9 +269,6 @@ class Connection extends import_eventEmitter.EventEmitter {
       case "Page":
         result = new import_page.Page(parent, type, guid, initializer);
         break;
-      case "PageAgent":
-        result = new import_pageAgent.PageAgent(parent, type, guid, initializer);
-        break;
       case "Playwright":
         result = new import_playwright.Playwright(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

@@ -230,11 +230,8 @@ async function convertInputFiles(platform, files, context) {
     if (!items.every((item) => typeof item === "string"))
       throw new Error("File paths cannot be mixed with buffers");
     const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(platform, items);
-    localPaths?.forEach((path) => context._checkFileAccess(path));
-    if (localDirectory)
-      context._checkFileAccess(localDirectory);
     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",
@@ -78,9 +81,6 @@ const Events = {
     WebSocket: "websocket",
     Worker: "worker"
   },
-  PageAgent: {
-    Turn: "turn"
-  },
   WebSocket: {
     Close: "close",
     Error: "socketerror",

package/lib/client/fetch.js

@@ -133,7 +133,6 @@ class APIRequestContext extends import_channelOwner.ChannelOwner {
       (0, import_assert.assert)(options.maxRedirects === void 0 || options.maxRedirects >= 0, `'maxRedirects' must be greater than or equal to '0'`);
       (0, import_assert.assert)(options.maxRetries === void 0 || options.maxRetries >= 0, `'maxRetries' must be greater than or equal to '0'`);
       const url = options.url !== void 0 ? options.url : options.request.url();
-      this._checkUrlAllowed?.(url);
       const method = options.method || options.request?.method();
       let encodedParams = void 0;
       if (typeof options.params === "string")

package/lib/client/frame.js

@@ -101,7 +101,6 @@ class Frame extends import_channelOwner.ChannelOwner {
   }
   async goto(url, options = {}) {
     const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
-    this.page().context()._checkUrlAllowed(url);
     return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil, timeout: this._navigationTimeout(options) })).response);
   }
   _setupNavigationWaiter(options) {
@@ -177,10 +176,6 @@ class Frame extends import_channelOwner.ChannelOwner {
     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 _evaluateFunction(functionDeclaration) {
-    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: (0, import_jsHandle.serializeArgument)(void 0) });
-    return (0, import_jsHandle.parseResult)(result.value);
-  }
   async _evaluateExposeUtilityScript(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) });

package/lib/client/harRouter.js

@@ -52,9 +52,21 @@ class HarRouter {
     if (response.action === "fulfill") {
       if (response.status === -1)
         return;
+      const transformedHeaders = response.headers.reduce((headersMap, { name, value }) => {
+        if (name.toLowerCase() !== "set-cookie") {
+          headersMap[name] = value;
+        } else {
+          if (!headersMap["set-cookie"])
+            headersMap["set-cookie"] = value;
+          else
+            headersMap["set-cookie"] += `
+${value}`;
+        }
+        return headersMap;
+      }, {});
       await route.fulfill({
         status: response.status,
-        headers: Object.fromEntries(response.headers.map((h) => [h.name, h.value])),
+        headers: transformedHeaders,
         body: response.body
       });
       return;

package/lib/client/jsHandle.js

@@ -40,10 +40,6 @@ class JSHandle extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return parseResult(result.value);
   }
-  async _evaluateFunction(functionDeclaration) {
-    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: serializeArgument(void 0) });
-    return parseResult(result.value);
-  }
   async evaluateHandle(pageFunction, arg) {
     const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return JSHandle.from(result.handle);