phantomwright-driver-core 1.57.0 → 1.57.1

package/lib/protocol/validator.js

@@ -610,6 +610,7 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  focusControl: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
   userDataDir: import_validatorPrimitives.tString,
   slowMo: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tFloat)
 });
@@ -702,6 +703,7 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  focusControl: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
     bypass: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
@@ -773,6 +775,7 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  focusControl: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
     bypass: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
@@ -888,7 +891,8 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
     strictSelectors: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
     serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
     selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
-    testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
+    testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    focusControl: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
   })
 });
 import_validatorPrimitives.scheme.BrowserContextBindingCallEvent = (0, import_validatorPrimitives.tObject)({
@@ -1522,7 +1526,8 @@ import_validatorPrimitives.scheme.FrameEvalOnSelectorAllParams = (0, import_vali
   selector: import_validatorPrimitives.tString,
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.FrameEvalOnSelectorAllResult = (0, import_validatorPrimitives.tObject)({
   value: (0, import_validatorPrimitives.tType)("SerializedValue")
@@ -1619,7 +1624,8 @@ import_validatorPrimitives.scheme.FrameDispatchEventResult = (0, import_validato
 import_validatorPrimitives.scheme.FrameEvaluateExpressionParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.FrameEvaluateExpressionResult = (0, import_validatorPrimitives.tObject)({
   value: (0, import_validatorPrimitives.tType)("SerializedValue")
@@ -1627,7 +1633,8 @@ import_validatorPrimitives.scheme.FrameEvaluateExpressionResult = (0, import_val
 import_validatorPrimitives.scheme.FrameEvaluateExpressionHandleParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.FrameEvaluateExpressionHandleResult = (0, import_validatorPrimitives.tObject)({
   handle: (0, import_validatorPrimitives.tChannel)(["ElementHandle", "JSHandle"])
@@ -1911,7 +1918,8 @@ import_validatorPrimitives.scheme.WorkerCloseEvent = (0, import_validatorPrimiti
 import_validatorPrimitives.scheme.WorkerEvaluateExpressionParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.WorkerEvaluateExpressionResult = (0, import_validatorPrimitives.tObject)({
   value: (0, import_validatorPrimitives.tType)("SerializedValue")
@@ -1919,7 +1927,8 @@ import_validatorPrimitives.scheme.WorkerEvaluateExpressionResult = (0, import_va
 import_validatorPrimitives.scheme.WorkerEvaluateExpressionHandleParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.WorkerEvaluateExpressionHandleResult = (0, import_validatorPrimitives.tObject)({
   handle: (0, import_validatorPrimitives.tChannel)(["ElementHandle", "JSHandle"])
@@ -1943,7 +1952,8 @@ import_validatorPrimitives.scheme.ElementHandleDisposeResult = (0, import_valida
 import_validatorPrimitives.scheme.JSHandleEvaluateExpressionParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.ElementHandleEvaluateExpressionParams = (0, import_validatorPrimitives.tType)("JSHandleEvaluateExpressionParams");
 import_validatorPrimitives.scheme.JSHandleEvaluateExpressionResult = (0, import_validatorPrimitives.tObject)({
@@ -1953,7 +1963,8 @@ import_validatorPrimitives.scheme.ElementHandleEvaluateExpressionResult = (0, im
 import_validatorPrimitives.scheme.JSHandleEvaluateExpressionHandleParams = (0, import_validatorPrimitives.tObject)({
   expression: import_validatorPrimitives.tString,
   isFunction: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
-  arg: (0, import_validatorPrimitives.tType)("SerializedArgument")
+  arg: (0, import_validatorPrimitives.tType)("SerializedArgument"),
+  isolatedContext: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
 });
 import_validatorPrimitives.scheme.ElementHandleEvaluateExpressionHandleParams = (0, import_validatorPrimitives.tType)("JSHandleEvaluateExpressionHandleParams");
 import_validatorPrimitives.scheme.JSHandleEvaluateExpressionHandleResult = (0, import_validatorPrimitives.tObject)({
@@ -2778,6 +2789,7 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  focusControl: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
   pkg: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
   args: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)(import_validatorPrimitives.tString)),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({

package/lib/server/browserContext.js

@@ -126,9 +126,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
       `);
     }
     if (this._options.serviceWorkers === "block")
-      await this.addInitScript(void 0, `
-if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };
-`);
+      await this.addInitScript(void 0, `navigator.serviceWorker.register = async () => { };`);
     if (this._options.permissions)
       await this.grantPermissions(this._options.permissions);
   }
@@ -249,27 +247,16 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       if (page.getBinding(name))
         throw new Error(`Function "${name}" has been already registered in one of the pages`);
     }
-    await progress.race(this.exposePlaywrightBindingIfNeeded());
     const binding = new import_page2.PageBinding(name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.doAddInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+    await this.doExposeBinding(binding);
   }
   async removeExposedBindings(bindings) {
-    bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
-    for (const binding of bindings)
-      this._pageBindings.delete(binding.name);
-    await this.doRemoveInitScripts(bindings.map((binding) => binding.initScript));
-    const cleanup = bindings.map((binding) => `{ ${binding.cleanupScript} };
-`).join("");
-    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
+    for (const key of this._pageBindings.keys()) {
+      if (!key.startsWith("__pw")) this._pageBindings.delete(key);
+    }
+    await this.doRemoveExposedBindings();
   }
   async grantPermissions(permissions, origin) {
     let resolvedOrigin = "*";
@@ -372,9 +359,8 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     }
   }
   async removeInitScripts(initScripts) {
-    const set = new Set(initScripts);
-    this.initScripts = this.initScripts.filter((script) => !set.has(script));
-    await this.doRemoveInitScripts(initScripts);
+    this.initScripts.splice(0, this.initScripts.length);
+    await this.doRemoveInitScripts();
   }
   async addRequestInterceptor(progress, handler) {
     this.requestInterceptors.push(handler);
@@ -683,7 +669,8 @@ const defaultNewContextParamValues = {
   acceptDownloads: "accept",
   strictSelectors: false,
   serviceWorkers: "allow",
-  locale: "en-US"
+  locale: "en-US",
+  focusControl: false
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/chromium/chromiumSwitches.js

@@ -56,27 +56,17 @@ const chromiumSwitches = (assistantMode, channel, android) => [
   "--disable-background-networking",
   "--disable-background-timer-throttling",
   "--disable-backgrounding-occluded-windows",
-  "--disable-back-forward-cache",
   // Avoids surprises like main request not being intercepted during page.goBack().
   "--disable-breakpad",
-  "--disable-client-side-phishing-detection",
-  "--disable-component-extensions-with-background-pages",
-  "--disable-component-update",
   // Avoids unneeded network activity after startup.
   "--no-default-browser-check",
-  "--disable-default-apps",
   "--disable-dev-shm-usage",
-  "--disable-extensions",
   "--disable-features=" + disabledFeatures(assistantMode).join(","),
   process.env.PLAYWRIGHT_LEGACY_SCREENSHOT ? "" : "--enable-features=CDPScreenshotNewSurface",
-  "--allow-pre-commit-input",
   "--disable-hang-monitor",
-  "--disable-ipc-flooding-protection",
-  "--disable-popup-blocking",
   "--disable-prompt-on-repost",
   "--disable-renderer-backgrounding",
   "--force-color-profile=srgb",
-  "--metrics-recording-only",
   "--no-first-run",
   "--password-store=basic",
   "--use-mock-keychain",
@@ -85,18 +75,16 @@ const chromiumSwitches = (assistantMode, channel, android) => [
   "--export-tagged-pdf",
   // https://chromium-review.googlesource.com/c/chromium/src/+/4853540
   "--disable-search-engine-choice-screen",
-  // https://issues.chromium.org/41491762
-  "--unsafely-disable-devtools-self-xss-warnings",
   // Edge can potentially restart on Windows (msRelaunchNoCompatLayer) which looses its file descriptors (stdout/stderr) and CDP (3/4). Disable until fixed upstream.
   "--edge-skip-compat-layer-relaunch",
-  assistantMode ? "" : "--enable-automation",
   // This disables Chrome for Testing infobar that is visible in the persistent context.
   // The switch is ignored everywhere else, including Chromium/Chrome/Edge.
   "--disable-infobars",
   // Less annoying popups.
   "--disable-search-engine-choice-screen",
   // Prevents the "three dots" menu crash in IdentityManager::HasPrimaryAccount for ephemeral contexts.
-  android ? "" : "--disable-sync"
+  android ? "" : "--disable-sync",
+  "--disable-blink-features=AutomationControlled"
 ].filter(Boolean);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/chromium/crBrowser.js

@@ -436,8 +436,7 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       await page.delegate.addInitScript(initScript);
   }
   async doRemoveInitScripts(initScripts) {
-    for (const page of this.pages())
-      await page.delegate.removeInitScripts(initScripts);
+    for (const page of this.pages()) await page.delegate.removeInitScripts();
   }
   async doUpdateRequestInterception() {
     for (const page of this.pages())
@@ -502,6 +501,12 @@ 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();
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/chromium/crDevTools.js

@@ -72,7 +72,6 @@ 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,6 +31,7 @@ __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");
@@ -49,6 +50,7 @@ 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;
   }
@@ -151,7 +153,7 @@ class CRNetworkManager {
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: enabled });
+    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: false });
     let fetchPromise = Promise.resolve(void 0);
     if (!info.workerFrame) {
       if (enabled)
@@ -226,6 +228,7 @@ 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;
@@ -251,6 +254,7 @@ 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;
@@ -298,7 +302,7 @@ class CRNetworkManager {
         headersOverride = redirectedFrom?._originalRequestRoute?._alreadyContinuedParams?.headers;
         requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
-        route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId);
+        route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId, this._page, requestPausedEvent.networkId, this);
       }
     }
     const isNavigationRequest = requestWillBeSentEvent.requestId === requestWillBeSentEvent.loaderId && requestWillBeSentEvent.type === "Document";
@@ -491,10 +495,17 @@ class InterceptableRequest {
   }
 }
 class RouteImpl {
-  constructor(session, interceptionId) {
+  constructor(session, interceptionId, page, networkId, sessionManager) {
     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 = {
@@ -504,17 +515,134 @@ class RouteImpl {
       method: overrides.method,
       postData: overrides.postData ? overrides.postData.toString("base64") : void 0
     };
-    await catchDisallowedErrors(async () => {
-      await this._session.send("Fetch.continueRequest", this._alreadyContinuedParams);
-    });
+    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);
+      });
+    }
   }
   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];
+    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();
+          let firstScriptIndex = -1;
+          let searchPos = 0;
+          const endSearchPos = headContentLower.length;
+          while (searchPos < endSearchPos) {
+            const commentStart = headContentLower.indexOf("<!--", searchPos);
+            const scriptStart = headContentLower.indexOf("<script", searchPos);
+            if (scriptStart === -1 || scriptStart >= endSearchPos) {
+              break;
+            }
+            if (commentStart !== -1 && commentStart < scriptStart) {
+              const commentEnd = headContentLower.indexOf("-->", commentStart);
+              if (commentEnd !== -1) {
+                searchPos = commentEnd + 3;
+                continue;
+              } else {
+                break;
+              }
+            }
+            firstScriptIndex = scriptStart;
+            break;
+          }
+          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: this._interceptionId,
+        requestId: response.interceptionId ? response.interceptionId : this._interceptionId,
         responseCode: response.status,
         responsePhrase: network.statusText(response.status),
         responseHeaders,
@@ -532,6 +660,117 @@ 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 {
+      const url = event.request?.url || "";
+      const isPrivilegePage = url.startsWith("https://ntp.msn");
+      if (isPrivilegePage) {
+        await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+        return;
+      }
+      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 {