patchright-core 1.57.0 → 1.59.0

package/lib/server/chromium/crBrowser.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var crBrowser_exports = {};
 __export(crBrowser_exports, {
   CRBrowser: () => CRBrowser,
-  CRBrowserContext: () => CRBrowserContext
+  CRBrowserContext: () => CRBrowserContext,
+  shouldProxyLoopback: () => shouldProxyLoopback
 });
 module.exports = __toCommonJS(crBrowser_exports);
 var import_path = __toESM(require("path"));
@@ -54,6 +55,7 @@ class CRBrowser extends import_browser.Browser {
     this._serviceWorkers = /* @__PURE__ */ new Map();
     this._version = "";
     this._majorVersion = 0;
+    this._revision = "";
     this._tracingRecording = false;
     this._userAgent = "";
     this._connection = connection;
@@ -75,6 +77,7 @@ class CRBrowser extends import_browser.Browser {
     if (options.__testHookOnConnectToBrowser)
       await options.__testHookOnConnectToBrowser();
     const version = await session.send("Browser.getVersion");
+    browser._revision = version.revision;
     browser._version = version.product.substring(version.product.indexOf("/") + 1);
     try {
       browser._majorVersion = +browser._version.split(".")[0];
@@ -100,10 +103,10 @@ class CRBrowser extends import_browser.Browser {
     const proxy = options.proxyOverride || options.proxy;
     let proxyBypassList = void 0;
     if (proxy) {
-      if (process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK)
-        proxyBypassList = proxy.bypass;
-      else
+      if (shouldProxyLoopback(proxy.bypass))
         proxyBypassList = "<-loopback>" + (proxy.bypass ? `,${proxy.bypass}` : "");
+      else
+        proxyBypassList = proxy.bypass;
     }
     const { browserContextId } = await this._session.send("Target.createBrowserContext", {
       disposeOnDetach: true,
@@ -284,11 +287,12 @@ class CRBrowser extends import_browser.Browser {
     return this._clientRootSessionPromise;
   }
 }
+const CREvents = {
+  ServiceWorker: "serviceworker"
+};
 class CRBrowserContext extends import_browserContext.BrowserContext {
   static {
-    this.CREvents = {
-      ServiceWorker: "serviceworker"
-    };
+    this.CREvents = CREvents;
   }
   constructor(browser, browserContextId, options) {
     super(browser, options, browserContextId);
@@ -388,15 +392,25 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       ["midi-sysex", "midiSysex"],
       ["storage-access", "storageAccess"],
       ["local-fonts", "localFonts"],
-      ["local-network-access", "localNetworkAccess"]
+      ["local-network-access", ["localNetworkAccess", "localNetwork", "loopbackNetwork"]],
+      ["screen-wake-lock", "wakeLockScreen"]
     ]);
-    const filtered = permissions.map((permission) => {
-      const protocolPermission = webPermissionToProtocol.get(permission);
-      if (!protocolPermission)
-        throw new Error("Unknown permission: " + permission);
-      return protocolPermission;
-    });
-    await this._browser._session.send("Browser.grantPermissions", { origin: origin === "*" ? void 0 : origin, browserContextId: this._browserContextId, permissions: filtered });
+    const grantPermissions = async (mapping) => {
+      const filtered = permissions.flatMap((permission) => {
+        const protocolPermission = mapping.get(permission);
+        if (!protocolPermission)
+          throw new Error("Unknown permission: " + permission);
+        return typeof protocolPermission === "string" ? [protocolPermission] : protocolPermission;
+      });
+      await this._browser._session.send("Browser.grantPermissions", { origin: origin === "*" ? void 0 : origin, browserContextId: this._browserContextId, permissions: filtered });
+    };
+    try {
+      await grantPermissions(webPermissionToProtocol);
+    } catch (e) {
+      const fallbackMapping = new Map(webPermissionToProtocol);
+      fallbackMapping.set("local-network-access", ["localNetworkAccess"]);
+      await grantPermissions(fallbackMapping);
+    }
   }
   async doClearPermissions() {
     await this._browser._session.send("Browser.resetPermissions", { browserContextId: this._browserContextId });
@@ -436,7 +450,8 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       await page.delegate.addInitScript(initScript);
   }
   async doRemoveInitScripts(initScripts) {
-    for (const page of this.pages()) await page.delegate.removeInitScripts();
+    for (const page of this.pages())
+      await page.delegate.removeInitScripts(initScripts);
   }
   async doUpdateRequestInterception() {
     for (const page of this.pages())
@@ -455,7 +470,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
   async doClose(reason) {
     await this.dialogManager.closeBeforeUnloadDialogs();
     if (!this._browserContextId) {
-      await this.stopVideoRecording();
       await this._browser.close({ reason });
       return;
     }
@@ -468,9 +482,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       this._browser._serviceWorkers.delete(targetId);
     }
   }
-  async stopVideoRecording() {
-    await Promise.all(this._crPages().map((crPage) => crPage._mainFrameSession._stopVideoRecording()));
-  }
   onClosePersistent() {
   }
   async clearCache() {
@@ -501,15 +512,17 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     const rootSession = await this._browser._clientRootSession();
     return rootSession.attachToTarget(targetId);
   }
-  async doExposeBinding(binding) {
-    for (const page of this.pages()) await page.delegate.exposeBinding(binding);
-  }
-  async doRemoveExposedBindings() {
-    for (const page of this.pages()) await page.delegate.removeExposedBindings();
-  }
+}
+function shouldProxyLoopback(bypass) {
+  if (process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK)
+    return false;
+  const hosts = (bypass || "").split(",").map((s) => s.trim());
+  const shouldBypassSomeLoopback = ["localhost", "127.0.0.1", "::1", "[::]", "[::1]", "<loopback>", "<-loopback>"].some((host) => hosts.includes(host));
+  return !shouldBypassSomeLoopback;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRBrowser,
-  CRBrowserContext
+  CRBrowserContext,
+  shouldProxyLoopback
 });

package/lib/server/chromium/crConnection.js

@@ -94,11 +94,6 @@ class CRSession extends import_instrumentation.SdkObject {
     this._parentSession = parentSession;
     this._sessionId = sessionId;
     this._eventListener = eventListener;
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   _markAsCrashed() {
     this._crashed = true;

package/lib/server/chromium/crDevTools.js

@@ -44,8 +44,6 @@ class CRDevTools {
         return;
       const parsed = JSON.parse(event.payload);
       let result = void 0;
-      if (this.__testHookOnBinding)
-        this.__testHookOnBinding(parsed);
       if (parsed.method === "getPreferences") {
         if (this._prefs === void 0) {
           try {
@@ -72,6 +70,7 @@ class CRDevTools {
       }).catch((e) => null);
     });
     Promise.all([
+      session.send("Runtime.enable"),
       session.send("Runtime.addBinding", { name: kBindingName }),
       session.send("Page.enable"),
       session.send("Page.addScriptToEvaluateOnNewDocument", { source: `

package/lib/server/chromium/crNetworkManager.js

@@ -31,7 +31,6 @@ __export(crNetworkManager_exports, {
   CRNetworkManager: () => CRNetworkManager
 });
 module.exports = __toCommonJS(crNetworkManager_exports);
-var import_crypto = __toESM(require("crypto"));
 var import_utils = require("../../utils");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_helper = require("../helper");
@@ -50,7 +49,6 @@ class CRNetworkManager {
     this._requestIdToRequestPausedEvent = /* @__PURE__ */ new Map();
     this._responseExtraInfoTracker = new ResponseExtraInfoTracker();
     this._sessions = /* @__PURE__ */ new Map();
-    this._alreadyTrackedNetworkIds = /* @__PURE__ */ new Set();
     this._page = page;
     this._serviceWorker = serviceWorker;
   }
@@ -153,7 +151,7 @@ class CRNetworkManager {
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: false });
+    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: enabled });
     let fetchPromise = Promise.resolve(void 0);
     if (!info.workerFrame) {
       if (enabled)
@@ -228,7 +226,6 @@ class CRNetworkManager {
     return !this._credentials.origin || new URL(url).origin.toLowerCase() === this._credentials.origin.toLowerCase();
   }
   _onRequestPaused(sessionInfo, event) {
-    if (this._alreadyTrackedNetworkIds.has(event.networkId)) return;
     if (!event.networkId) {
       sessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
       return;
@@ -242,7 +239,7 @@ class CRNetworkManager {
       this._requestIdToRequestWillBeSentEvent.delete(requestId);
     } else {
       const existingRequest = this._requestIdToRequest.get(requestId);
-      const alreadyContinuedParams = existingRequest?._route?._alreadyContinuedParams;
+      const alreadyContinuedParams = existingRequest?._originalRequestRoute?._alreadyContinuedParams;
       if (alreadyContinuedParams && !event.redirectedRequestId) {
         sessionInfo.session._sendMayFail("Fetch.continueRequest", {
           ...alreadyContinuedParams,
@@ -254,7 +251,6 @@ class CRNetworkManager {
     }
   }
   _onRequest(requestWillBeSentSessionInfo, requestWillBeSentEvent, requestPausedSessionInfo, requestPausedEvent) {
-    if (this._alreadyTrackedNetworkIds.has(requestWillBeSentEvent.initiator.requestId)) return;
     if (requestWillBeSentEvent.request.url.startsWith("data:"))
       return;
     let redirectedFrom = null;
@@ -300,9 +296,13 @@ class CRNetworkManager {
     if (requestPausedEvent) {
       if (redirectedFrom || !this._userRequestInterceptionEnabled && this._protocolRequestInterceptionEnabled) {
         headersOverride = redirectedFrom?._originalRequestRoute?._alreadyContinuedParams?.headers;
+        if (headersOverride) {
+          const originalHeaders = Object.entries(requestPausedEvent.request.headers).map(([name, value]) => ({ name, value }));
+          headersOverride = network.applyHeadersOverrides(originalHeaders, headersOverride);
+        }
         requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
-        route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId, this._page, requestPausedEvent.networkId, this);
+        route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId);
       }
     }
     const isNavigationRequest = requestWillBeSentEvent.requestId === requestWillBeSentEvent.loaderId && requestWillBeSentEvent.type === "Document";
@@ -333,7 +333,7 @@ class CRNetworkManager {
       const response2 = await session.send("Network.getResponseBody", { requestId: request._requestId });
       if (response2.body || !expectedLength)
         return Buffer.from(response2.body, response2.base64Encoded ? "base64" : "utf8");
-      if (request._route?._fulfilled)
+      if (request._originalRequestRoute?._fulfilled)
         return Buffer.from("");
       const resource = await session.send("Network.loadNetworkResource", { url: request.request.url(), frameId: this._serviceWorker ? void 0 : request.request.frame()._id, options: { disableCache: false, includeCredentials: true } });
       const chunks = [];
@@ -372,7 +372,8 @@ class CRNetworkManager {
         responseStart: -1
       };
     }
-    const response = new network.Response(request.request, responsePayload.status, responsePayload.statusText, (0, import_utils.headersObjectToArray)(responsePayload.headers), timing, getResponseBody, !!responsePayload.fromServiceWorker, responsePayload.protocol);
+    const response = new network.Response(request.request, responsePayload.status, responsePayload.statusText, (0, import_utils.headersObjectToArray)(responsePayload.headers), timing, getResponseBody, !!responsePayload.fromServiceWorker);
+    response._setHttpVersion(responsePayload?.protocol ?? null);
     if (responsePayload?.remoteIPAddress && typeof responsePayload?.remotePort === "number") {
       response._serverAddrFinished({
         ipAddress: responsePayload.remoteIPAddress,
@@ -478,7 +479,6 @@ class InterceptableRequest {
     this._requestId = requestWillBeSentEvent.requestId;
     this._interceptionId = requestPausedEvent && requestPausedEvent.requestId;
     this._documentId = documentId;
-    this._route = route;
     this._originalRequestRoute = route ?? redirectedFrom?._originalRequestRoute;
     const {
       headers,
@@ -486,26 +486,18 @@ class InterceptableRequest {
       url,
       postDataEntries = null
     } = requestPausedEvent ? requestPausedEvent.request : requestWillBeSentEvent.request;
-    const type = (requestWillBeSentEvent.type || "").toLowerCase();
     let postDataBuffer = null;
     const entries = postDataEntries?.filter((entry) => entry.bytes);
     if (entries && entries.length)
       postDataBuffer = Buffer.concat(entries.map((entry) => Buffer.from(entry.bytes, "base64")));
-    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, type, method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
+    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || "Other"), method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
   }
 }
 class RouteImpl {
-  constructor(session, interceptionId, page, networkId, sessionManager) {
+  constructor(session, interceptionId) {
     this._fulfilled = false;
-    this._sessionManager = void 0;
-    this._networkId = void 0;
-    this._page = void 0;
     this._session = session;
     this._interceptionId = interceptionId;
-    this._page = page;
-    this._networkId = networkId;
-    this._sessionManager = sessionManager;
-    import_eventsHelper.eventsHelper.addEventListener(this._session, "Fetch.requestPaused", async (e) => await this._networkRequestIntercepted(e));
   }
   async continue(overrides) {
     this._alreadyContinuedParams = {
@@ -515,117 +507,17 @@ class RouteImpl {
       method: overrides.method,
       postData: overrides.postData ? overrides.postData.toString("base64") : void 0
     };
-    if (overrides.url && (overrides.url === "http://patchright-init-script-inject.internal/" || overrides.url === "https://patchright-init-script-inject.internal/")) {
-      await catchDisallowedErrors(async () => {
-        this._sessionManager._alreadyTrackedNetworkIds.add(this._networkId);
-        this._session._sendMayFail("Fetch.continueRequest", { requestId: this._interceptionId, interceptResponse: true });
-      });
-    } else {
-      await catchDisallowedErrors(async () => {
-        await this._session._sendMayFail("Fetch.continueRequest", this._alreadyContinuedParams);
-      });
-    }
+    await catchDisallowedErrors(async () => {
+      await this._session.send("Fetch.continueRequest", this._alreadyContinuedParams);
+    });
   }
   async fulfill(response) {
-    const isTextHtml = response.headers.some((header) => header.name.toLowerCase() === "content-type" && header.value.includes("text/html"));
-    var allInjections = [...this._page.delegate._mainFrameSession._evaluateOnNewDocumentScripts];
-    for (const binding of this._page.delegate._browserContext._pageBindings.values()) {
-      if (!allInjections.includes(binding)) allInjections.push(binding);
-    }
-    if (isTextHtml && allInjections.length) {
-      let useNonce = false;
-      let scriptNonce = null;
-      if (response.isBase64) {
-        response.isBase64 = false;
-        response.body = Buffer.from(response.body, "base64").toString("utf-8");
-      }
-      const cspHeaderNames = ["content-security-policy", "content-security-policy-report-only"];
-      for (let i = 0; i < response.headers.length; i++) {
-        const headerName = response.headers[i].name.toLowerCase();
-        if (cspHeaderNames.includes(headerName)) {
-          const originalCsp = response.headers[i].value || "";
-          if (!useNonce) {
-            const nonceMatch = originalCsp.match(/script-src[^;]*'nonce-([^'"\s;]+)'/i);
-            if (nonceMatch && nonceMatch[1]) {
-              scriptNonce = nonceMatch[1];
-              useNonce = true;
-            }
-          }
-          const fixedCsp = this._fixCSP(originalCsp, scriptNonce);
-          response.headers[i].value = fixedCsp;
-        }
-      }
-      if (typeof response.body === "string" && response.body.length) {
-        response.body = response.body.replace(
-          /<meta[^>]*http-equiv=(?:"|')?Content-Security-Policy(?:"|')?[^>]*>/gi,
-          (match) => {
-            const contentMatch = match.match(/content=(?:"|')([^"']*)(?:"|')/i);
-            if (contentMatch && contentMatch[1]) {
-              let originalCsp = contentMatch[1];
-              originalCsp = originalCsp.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#x22;/g, '"').replace(/&nbsp;/g, " ").replace(/&#(d+);/g, (match2, dec) => String.fromCharCode(dec)).replace(/&#x([0-9a-fA-F]+);/g, (match2, hex) => String.fromCharCode(parseInt(hex, 16)));
-              if (!useNonce) {
-                const nonceMatch = originalCsp.match(/script-src[^;]*'nonce-([^'"\s;]+)'/i);
-                if (nonceMatch && nonceMatch[1]) {
-                  scriptNonce = nonceMatch[1];
-                  useNonce = true;
-                }
-              }
-              const fixedCsp = this._fixCSP(originalCsp, scriptNonce);
-              const encodedCsp = fixedCsp.replace(/'/g, "&#x27;").replace(/"/g, "&#x22;");
-              return match.replace(contentMatch[1], encodedCsp);
-            }
-            return match;
-          }
-        );
-      }
-      let injectionHTML = "";
-      allInjections.forEach((script) => {
-        let scriptId = import_crypto.default.randomBytes(22).toString("hex");
-        let scriptSource = script.source || script;
-        const nonceAttr = useNonce ? `nonce="${scriptNonce}"` : "";
-        injectionHTML += `<script class="${this._page.delegate.initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
-      });
-      const lower = response.body.toLowerCase();
-      const headStartIndex = lower.indexOf("<head");
-      if (headStartIndex !== -1) {
-        const headEndTagIndex = lower.indexOf("</head>", headStartIndex);
-        if (headEndTagIndex !== -1) {
-          const headOpenEnd = response.body.indexOf(">", headStartIndex) + 1;
-          const headContent = response.body.slice(headOpenEnd, headEndTagIndex);
-          const headContentLower = headContent.toLowerCase();
-          const firstScriptIndex = headContentLower.indexOf("<script");
-          if (firstScriptIndex !== -1) {
-            const insertPosition = headOpenEnd + firstScriptIndex;
-            response.body = response.body.slice(0, insertPosition) + injectionHTML + response.body.slice(insertPosition);
-          } else {
-            response.body = response.body.slice(0, headEndTagIndex) + injectionHTML + response.body.slice(headEndTagIndex);
-          }
-        } else {
-          const headStartTagEnd = response.body.indexOf(">", headStartIndex) + 1;
-          response.body = response.body.slice(0, headStartTagEnd) + injectionHTML + response.body.slice(headStartTagEnd);
-        }
-      } else {
-        const doctypeIndex = lower.indexOf("<!doctype");
-        if (doctypeIndex === 0) {
-          const doctypeEnd = response.body.indexOf(">", doctypeIndex) + 1;
-          response.body = response.body.slice(0, doctypeEnd) + injectionHTML + response.body.slice(doctypeEnd);
-        } else {
-          const htmlIndex = lower.indexOf("<html");
-          if (htmlIndex !== -1) {
-            const htmlTagEnd = response.body.indexOf(">", htmlIndex) + 1;
-            response.body = response.body.slice(0, htmlTagEnd) + `<head>${injectionHTML}</head>` + response.body.slice(htmlTagEnd);
-          } else {
-            response.body = injectionHTML + response.body;
-          }
-        }
-      }
-    }
     this._fulfilled = true;
     const body = response.isBase64 ? response.body : Buffer.from(response.body).toString("base64");
     const responseHeaders = splitSetCookieHeader(response.headers);
     await catchDisallowedErrors(async () => {
       await this._session.send("Fetch.fulfillRequest", {
-        requestId: response.interceptionId ? response.interceptionId : this._interceptionId,
+        requestId: this._interceptionId,
         responseCode: response.status,
         responsePhrase: network.statusText(response.status),
         responseHeaders,
@@ -643,111 +535,6 @@ class RouteImpl {
       });
     });
   }
-  _fixCSP(csp, scriptNonce) {
-    if (!csp || typeof csp !== "string") return csp;
-    const directives = csp.split(";").map((d) => d.trim()).filter((d) => d && d.length > 0);
-    const fixedDirectives = [];
-    let hasScriptSrc = false;
-    for (let directive of directives) {
-      if (!directive.trim()) continue;
-      const directiveMatch = directive.match(/^([a-zA-Z-]+)\s+(.*)$/);
-      if (!directiveMatch) {
-        fixedDirectives.push(directive);
-        continue;
-      }
-      const directiveName = directiveMatch[1].toLowerCase();
-      const directiveValues = directiveMatch[2].split(/\s+/).filter((v) => v.length > 0);
-      switch (directiveName) {
-        case "script-src":
-          hasScriptSrc = true;
-          let values = [...directiveValues];
-          if (scriptNonce && !values.some((v) => v.includes(`nonce-${scriptNonce}`))) {
-            values.push(`'nonce-${scriptNonce}'`);
-          }
-          if (!values.includes("'unsafe-eval'")) {
-            values.push("'unsafe-eval'");
-          }
-          if (!values.includes("'unsafe-inline'") && !scriptNonce) {
-            values.push("'unsafe-inline'");
-          }
-          if (!values.includes("*") && !values.includes("'self'") && !values.some((v) => v.includes("https:"))) {
-            values.push("*");
-          }
-          fixedDirectives.push(`script-src ${values.join(" ")}`);
-          break;
-        case "style-src":
-          let styleValues = [...directiveValues];
-          if (!styleValues.includes("'unsafe-inline'")) {
-            styleValues.push("'unsafe-inline'");
-          }
-          fixedDirectives.push(`style-src ${styleValues.join(" ")}`);
-          break;
-        case "img-src":
-          let imgValues = [...directiveValues];
-          if (!imgValues.includes("data:") && !imgValues.includes("*")) {
-            imgValues.push("data:");
-          }
-          fixedDirectives.push(`img-src ${imgValues.join(" ")}`);
-          break;
-        case "font-src":
-          let fontValues = [...directiveValues];
-          if (!fontValues.includes("data:") && !fontValues.includes("*")) {
-            fontValues.push("data:");
-          }
-          fixedDirectives.push(`font-src ${fontValues.join(" ")}`);
-          break;
-        case "connect-src":
-          let connectValues = [...directiveValues];
-          const hasWs = connectValues.some((v) => v.includes("ws:") || v.includes("wss:") || v === "*");
-          if (!hasWs) {
-            connectValues.push("ws:", "wss:");
-          }
-          fixedDirectives.push(`connect-src ${connectValues.join(" ")}`);
-          break;
-        case "frame-ancestors":
-          let frameAncestorValues = [...directiveValues];
-          if (frameAncestorValues.includes("'none'")) {
-            frameAncestorValues = ["'self'"];
-          }
-          fixedDirectives.push(`frame-ancestors ${frameAncestorValues.join(" ")}`);
-          break;
-        default:
-          fixedDirectives.push(directive);
-          break;
-      }
-    }
-    if (!hasScriptSrc) {
-      if (scriptNonce) {
-        fixedDirectives.push(`script-src 'self' 'unsafe-eval' 'nonce-${scriptNonce}' *`);
-      } else {
-        fixedDirectives.push(`script-src 'self' 'unsafe-eval' 'unsafe-inline' *`);
-      }
-    }
-    return fixedDirectives.join("; ");
-  }
-  async _networkRequestIntercepted(event) {
-    if (event.resourceType !== "Document") {
-      return;
-    }
-    if (this._networkId != event.networkId || !this._sessionManager._alreadyTrackedNetworkIds.has(event.networkId)) return;
-    try {
-      if (event.responseStatusCode >= 301 && event.responseStatusCode <= 308 || event.redirectedRequestId && !event.responseStatusCode) {
-        await this._session.send("Fetch.continueRequest", { requestId: event.requestId, interceptResponse: true });
-      } else {
-        const responseBody = await this._session.send("Fetch.getResponseBody", { requestId: event.requestId });
-        await this.fulfill({
-          headers: event.responseHeaders,
-          isBase64: true,
-          body: responseBody.body,
-          status: event.responseStatusCode,
-          interceptionId: event.requestId,
-          resourceType: event.resourceType
-        });
-      }
-    } catch (error) {
-      await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
-    }
-  }
 }
 async function catchDisallowedErrors(callback) {
   try {
@@ -876,6 +663,44 @@ class ResponseExtraInfoTracker {
     this._requests.delete(requestId);
   }
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "Stylesheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Media":
+      return "media";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "TextTrack":
+      return "texttrack";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "EventSource":
+      return "eventsource";
+    case "WebSocket":
+      return "websocket";
+    case "Manifest":
+      return "manifest";
+    case "Ping":
+      return "ping";
+    case "CSPViolationReport":
+      return "cspreport";
+    case "Prefetch":
+    case "SignedExchange":
+    case "Preflight":
+    case "FedCM":
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRNetworkManager