patchright-core 1.55.2 → 1.56.0

package/lib/server/chromium/crBrowser.js

@@ -51,7 +51,6 @@ class CRBrowser extends import_browser.Browser {
     this._clientRootSessionPromise = null;
     this._contexts = /* @__PURE__ */ new Map();
     this._crPages = /* @__PURE__ */ new Map();
-    this._backgroundPages = /* @__PURE__ */ new Map();
     this._serviceWorkers = /* @__PURE__ */ new Map();
     this._version = "";
     this._tracingRecording = false;
@@ -133,7 +132,7 @@ class CRBrowser extends import_browser.Browser {
   async _waitForAllPagesToBeInitialized() {
     await Promise.all([...this._crPages.values()].map((crPage) => crPage._page.waitForInitializedOrError()));
   }
-  _onAttachedToTarget({ targetInfo, sessionId }) {
+  _onAttachedToTarget({ targetInfo, sessionId, waitingForDebugger }) {
     if (targetInfo.type === "browser")
       return;
     const session = this._session.createChildSession(sessionId);
@@ -153,16 +152,10 @@ class CRBrowser extends import_browser.Browser {
       return;
     }
     (0, import_assert.assert)(!this._crPages.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
-    (0, import_assert.assert)(!this._backgroundPages.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
     (0, import_assert.assert)(!this._serviceWorkers.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
-    if (targetInfo.type === "background_page") {
-      const backgroundPage = new import_crPage.CRPage(session, targetInfo.targetId, context, null, { hasUIWindow: false, isBackgroundPage: true });
-      this._backgroundPages.set(targetInfo.targetId, backgroundPage);
-      return;
-    }
     if (targetInfo.type === "page" || treatOtherAsPage) {
       const opener = targetInfo.openerId ? this._crPages.get(targetInfo.openerId) || null : null;
-      const crPage = new import_crPage.CRPage(session, targetInfo.targetId, context, opener, { hasUIWindow: targetInfo.type === "page", isBackgroundPage: false });
+      const crPage = new import_crPage.CRPage(session, targetInfo.targetId, context, opener, { hasUIWindow: targetInfo.type === "page" });
       this._crPages.set(targetInfo.targetId, crPage);
       return;
     }
@@ -183,12 +176,6 @@ class CRBrowser extends import_browser.Browser {
       crPage.didClose();
       return;
     }
-    const backgroundPage = this._backgroundPages.get(targetId);
-    if (backgroundPage) {
-      this._backgroundPages.delete(targetId);
-      backgroundPage.didClose();
-      return;
-    }
     const serviceWorker = this._serviceWorkers.get(targetId);
     if (serviceWorker) {
       this._serviceWorkers.delete(targetId);
@@ -200,9 +187,6 @@ class CRBrowser extends import_browser.Browser {
     for (const crPage of this._crPages.values())
       crPage.didClose();
     this._crPages.clear();
-    for (const backgroundPage of this._backgroundPages.values())
-      backgroundPage.didClose();
-    this._backgroundPages.clear();
     for (const serviceWorker of this._serviceWorkers.values())
       serviceWorker.didClose();
     this._serviceWorkers.clear();
@@ -295,7 +279,6 @@ class CRBrowser extends import_browser.Browser {
 class CRBrowserContext extends import_browserContext.BrowserContext {
   static {
     this.CREvents = {
-      BackgroundPage: "backgroundpage",
       ServiceWorker: "serviceworker"
     };
   }
@@ -480,12 +463,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     await Promise.all(this._crPages().map((crPage) => crPage._mainFrameSession._stopVideoRecording()));
   }
   onClosePersistent() {
-    for (const [targetId, backgroundPage] of this._browser._backgroundPages.entries()) {
-      if (backgroundPage._browserContext === this && backgroundPage._page.initializedOrUndefined()) {
-        backgroundPage.didClose();
-        this._browser._backgroundPages.delete(targetId);
-      }
-    }
   }
   async clearCache() {
     for (const page of this._crPages())
@@ -497,14 +474,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       browserContextId: this._browserContextId
     });
   }
-  backgroundPages() {
-    const result = [];
-    for (const backgroundPage of this._browser._backgroundPages.values()) {
-      if (backgroundPage._browserContext === this && backgroundPage._page.initializedOrUndefined())
-        result.push(backgroundPage._page);
-    }
-    return result;
-  }
   serviceWorkers() {
     return Array.from(this._browser._serviceWorkers.values()).filter((serviceWorker) => serviceWorker.browserContext === this);
   }

package/lib/server/chromium/crNetworkManager.js

@@ -533,57 +533,91 @@ class RouteImpl {
       if (!allInjections.includes(binding)) allInjections.push(binding);
     }
     if (isTextHtml && allInjections.length) {
-      let scriptNonce = import_crypto.default.randomBytes(22).toString("hex");
-      let useNonce = true;
+      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++) {
-        if (response.headers[i].name.toLowerCase() === "content-security-policy" || response.headers[i].name.toLowerCase() === "content-security-policy-report-only") {
-          let cspValue = response.headers[i].value;
-          const nonceRegex = /script-src[^;]*'nonce-([\w-]+)'/;
-          const nonceMatch = cspValue.match(nonceRegex);
-          if (nonceMatch) {
-            scriptNonce = nonceMatch[1];
-          } else {
-            if (/script-src[^;]*'unsafe-inline'/.test(cspValue)) {
-              useNonce = false;
-            } else {
-              const scriptSrcRegex = /(script-src[^;]*)(;|$)/;
-              const newCspValue = cspValue.replace(scriptSrcRegex, `$1 'nonce-${scriptNonce}'$2`);
-              response.headers[i].value = newCspValue;
+        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;
             }
           }
-          break;
+          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;
-        if (useNonce) {
-          injectionHTML += `<script class="${this._page.delegate.initScriptTag}" nonce="${scriptNonce}" id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
-        } else {
-          injectionHTML += `<script class="${this._page.delegate.initScriptTag}" id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</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>`;
       });
-      if (response.isBase64) {
-        response.isBase64 = false;
-        response.body = Buffer.from(response.body, "base64").toString("utf-8");
-      }
-      const headMatch = response.body.match(/<head[^>]*>[\s\S]*?<\/head>/i);
-      if (headMatch) {
-        response.body = response.body.replace(/(<head[^>]*>)([\s\S]*?)(<\/head>)/i, (match, headOpen, headContent, headClose) => {
-          const scriptMatch = headContent.match(/([\s\S]*?)(<script[\s\S]*?$)/i);
-          if (scriptMatch) {
-            const [beforeScript, fromScript] = [scriptMatch[1], scriptMatch[2]];
-            return `${headOpen}${beforeScript}${injectionHTML}${fromScript}${headClose}`;
+      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);
           }
-          return `${headOpen}${headContent}${injectionHTML}${headClose}`;
-        });
-      } else if (/^<!DOCTYPE[\s\S]*?>/i.test(response.body)) {
-        response.body = response.body.replace(/^<!DOCTYPE[\s\S]*?>/i, (match) => `${match}${injectionHTML}`);
-      } else if (/<html[^>]*>/i.test(response.body)) {
-        response.body = response.body.replace(/<html[^>]*>/i, `$&<head>${injectionHTML}</head>`);
+        } else {
+          const headStartTagEnd = response.body.indexOf(">", headStartIndex) + 1;
+          response.body = response.body.slice(0, headStartTagEnd) + injectionHTML + response.body.slice(headStartTagEnd);
+        }
       } else {
-        response.body = injectionHTML + response.body;
+        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;
@@ -609,6 +643,79 @@ 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 parts = directive.trim().split(/s+/);
+      if (parts.length === 0) continue;
+      const directiveName = parts[0].toLowerCase();
+      const directiveValues = parts.slice(1);
+      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'");
+          }
+          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'`);
+      }
+    }
+    return fixedDirectives.join("; ");
+  }
   async _networkRequestIntercepted(event) {
     if (event.resourceType !== "Document") {
       return;

package/lib/server/chromium/crPage.js

@@ -45,7 +45,6 @@ var network = __toESM(require("../network"));
 var import_page = require("../page");
 var import_registry = require("../registry");
 var import_crAccessibility = require("./crAccessibility");
-var import_crBrowser = require("./crBrowser");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -55,7 +54,6 @@ var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
 var import_videoRecorder = require("./videoRecorder");
-var import_browserContext = require("../browserContext");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
 class CRPage {
@@ -69,7 +67,6 @@ class CRPage {
     this._nextWindowOpenPopupFeatures = [];
     this._targetId = targetId;
     this._opener = opener;
-    this._isBackgroundPage = bits.isBackgroundPage;
     const dragManager = new import_crDragDrop.DragManager(this);
     this.rawKeyboard = new import_crInput.RawKeyboardImpl(client, browserContext._browser._platform() === "mac", dragManager);
     this.rawMouse = new import_crInput.RawMouseImpl(this, client, dragManager);
@@ -93,10 +90,9 @@ class CRPage {
       if (viewportSize)
         this._page.setEmulatedSizeFromWindowOpen({ viewport: viewportSize, screen: viewportSize });
     }
-    const createdEvent = this._isBackgroundPage ? import_crBrowser.CRBrowserContext.CREvents.BackgroundPage : import_browserContext.BrowserContext.Events.Page;
     this._mainFrameSession._initialize(bits.hasUIWindow).then(
-      () => this._page.reportAsNew(this._opener?._page, void 0, createdEvent),
-      (error) => this._page.reportAsNew(this._opener?._page, error, createdEvent)
+      () => this._page.reportAsNew(this._opener?._page, void 0),
+      (error) => this._page.reportAsNew(this._opener?._page, error)
     );
   }
   static mainFrameSession(page) {
@@ -371,13 +367,13 @@ class FrameSession {
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.exceptionThrown", (exception) => this._handleException(exception.exceptionDetails)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextCreated", (event) => this._onExecutionContextCreated(event.context)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextDestroyed", (event) => this._onExecutionContextDestroyed(event.executionContextId)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", (event) => this._onExecutionContextsCleared()),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.attachedToTarget", (event) => this._onAttachedToTarget(event)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.detachedFromTarget", (event) => this._onDetachedFromTarget(event))
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", (event) => this._onExecutionContextsCleared())
     ]);
   }
   _addBrowserListeners() {
     this._eventListeners.push(...[
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.attachedToTarget", (event) => this._onAttachedToTarget(event)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.detachedFromTarget", (event) => this._onDetachedFromTarget(event)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Inspector.targetCrashed", (event) => this._onTargetCrashed()),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.screencastFrame", (event) => this._onScreencastFrame(event)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.windowOpen", (event) => this._onWindowOpen(event))
@@ -409,6 +405,7 @@ class FrameSession {
     if (!this._isMainFrame())
       this._addRendererListeners();
     this._addBrowserListeners();
+    this._bufferedAttachedToTargetEvents = [];
     const promises = [
       this._client.send("Page.enable"),
       this._client.send("Page.getFrameTree").then(({ frameTree }) => {
@@ -416,6 +413,10 @@ class FrameSession {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
         }
+        const attachedToTargetEvents = this._bufferedAttachedToTargetEvents || [];
+        this._bufferedAttachedToTargetEvents = void 0;
+        for (const event of attachedToTargetEvents)
+          this._onAttachedToTarget(event);
         const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ":";
         if (isInitialEmptyPage) {
           lifecycleEventsEnabled.catch((e) => {
@@ -444,16 +445,7 @@ class FrameSession {
         worldName: this._crPage.utilityWorldName
       }),
       this._crPage._networkManager.addSession(this._client, void 0, this._isMainFrame()),
-      this._client.send("Target.setAutoAttach", {
-        autoAttach: true,
-        waitForDebuggerOnStart: true,
-        flatten: true,
-        filter: [
-          { type: "iframe" },
-          { type: "worker" },
-          { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
-        ]
-      })
+      this._client.send("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true })
     ];
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
@@ -644,10 +636,17 @@ class FrameSession {
       this._onExecutionContextDestroyed(contextId);
   }
   async _onAttachedToTarget(event) {
+    if (this._bufferedAttachedToTargetEvents) {
+      this._bufferedAttachedToTargetEvents.push(event);
+      return;
+    }
     const session = this._client.createChildSession(event.sessionId);
     if (event.targetInfo.type === "iframe") {
       const targetId = event.targetInfo.targetId;
-      const frame = this._page.frameManager.frame(targetId);
+      let frame = this._page.frameManager.frame(targetId);
+      if (!frame && event.targetInfo.parentFrameId) {
+        frame = this._page.frameManager.frameAttached(targetId, event.targetInfo.parentFrameId);
+      }
       if (!frame)
         return;
       this._page.frameManager.removeChildFramesRecursively(frame);
@@ -684,22 +683,14 @@ class FrameSession {
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? void 0).catch(() => {
     });
     session._sendMayFail("Runtime.runIfWaitingForDebugger");
-    session._sendMayFail("Target.setAutoAttach", {
-      autoAttach: true,
-      waitForDebuggerOnStart: true,
-      flatten: true,
-      filter: [
-        { type: "worker" },
-        { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
-      ]
-    });
+    session._sendMayFail("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
     session.on("Target.attachedToTarget", (event2) => this._onAttachedToTarget(event2));
     session.on("Target.detachedFromTarget", (event2) => this._onDetachedFromTarget(event2));
     session.on("Runtime.consoleAPICalled", (event2) => {
       const args = event2.args.map((o) => (0, import_crExecutionContext.createHandle)(worker.existingExecutionContext, o));
       this._page.addConsoleMessage(event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
     });
-    session.on("Runtime.exceptionThrown", (exception) => this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, (0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails), this._page));
+    session.on("Runtime.exceptionThrown", (exception) => this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails)));
   }
   _onDetachedFromTarget(event) {
     const workerSession = this._workerSessions.get(event.sessionId);
@@ -758,7 +749,7 @@ class FrameSession {
     ));
   }
   _handleException(exceptionDetails) {
-    this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, (0, import_crProtocolHelper.exceptionToError)(exceptionDetails), this._page);
+    this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exceptionDetails));
   }
   async _onTargetCrashed() {
     this._client._markAsCrashed();

package/lib/server/codegen/csharp.js

@@ -109,9 +109,13 @@ class CSharpLanguageGenerator {
         const options = (0, import_language.toClickOptionsForSourceCode)(action);
         if (!Object.entries(options).length)
           return `await ${subject}.${this._asLocator(action.selector)}.${method}Async();`;
-        const optionsString = formatObject(options, "    ", "Locator" + method + "Options");
+        const optionsString = formatObject(options, "    ");
         return `await ${subject}.${this._asLocator(action.selector)}.${method}Async(${optionsString});`;
       }
+      case "hover": {
+        const optionsString = action.position ? formatObject({ position: action.position }, "    ") : "";
+        return `await ${subject}.${this._asLocator(action.selector)}.HoverAsync(${optionsString});`;
+      }
       case "check":
         return `await ${subject}.${this._asLocator(action.selector)}.CheckAsync();`;
       case "uncheck":
@@ -159,11 +163,11 @@ class CSharpLanguageGenerator {
       using System.Threading.Tasks;
 
       using var playwright = await Playwright.CreateAsync();
-      await using var browser = await playwright.${toPascal(options.browserName)}.LaunchAsync(${formatObject(options.launchOptions, "    ", "BrowserTypeLaunchOptions")});
+      await using var browser = await playwright.${toPascal(options.browserName)}.LaunchAsync(${formatObject(options.launchOptions, "    ")});
       var context = await browser.NewContextAsync(${formatContextOptions(options.contextOptions, options.deviceName)});`);
     if (options.contextOptions.recordHar) {
       const url = options.contextOptions.recordHar.urlFilter;
-      formatter.add(`      await context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ", "BrowserContextRouteFromHAROptions")}` : ""});`);
+      formatter.add(`      await context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ")}` : ""});`);
     }
     formatter.newLine();
     return formatter.format();
@@ -191,14 +195,14 @@ class CSharpLanguageGenerator {
     {`);
     if (options.contextOptions.recordHar) {
       const url = options.contextOptions.recordHar.urlFilter;
-      formatter.add(`    await Context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ", "BrowserContextRouteFromHAROptions")}` : ""});`);
+      formatter.add(`    await Context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ")}` : ""});`);
     }
     return formatter.format();
   }
   generateFooter(saveStorage) {
     const offset = this._mode === "library" ? "" : "        ";
     let storageStateLine = saveStorage ? `
-${offset}await context.StorageStateAsync(new BrowserContextStorageStateOptions
+${offset}await context.StorageStateAsync(new()
 ${offset}{
 ${offset}    Path = ${quote(saveStorage)}
 ${offset}});
@@ -212,8 +216,8 @@ ${offset}});
 }
 function formatObject(value, indent = "    ", name = "") {
   if (typeof value === "string") {
-    if (["permissions", "colorScheme", "modifiers", "button", "recordHarContent", "recordHarMode", "serviceWorkers"].includes(name))
-      return `${getClassName(name)}.${toPascal(value)}`;
+    if (["colorScheme", "modifiers", "button", "recordHarContent", "recordHarMode", "serviceWorkers"].includes(name))
+      return `${getEnumName(name)}.${toPascal(value)}`;
     return quote(value);
   }
   if (Array.isArray(value))
@@ -221,35 +225,24 @@ function formatObject(value, indent = "    ", name = "") {
   if (typeof value === "object") {
     const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
     if (!keys.length)
-      return name ? `new ${getClassName(name)}` : "";
+      return `new()`;
     const tokens = [];
     for (const key of keys) {
       const property = getPropertyName(key);
       tokens.push(`${property} = ${formatObject(value[key], indent, key)},`);
     }
-    if (name)
-      return `new ${getClassName(name)}
+    return `new()
 {
 ${indent}${tokens.join(`
 ${indent}`)}
-${indent}}`;
-    return `{
-${indent}${tokens.join(`
-${indent}`)}
 ${indent}}`;
   }
   if (name === "latitude" || name === "longitude")
     return String(value) + "m";
   return String(value);
 }
-function getClassName(value) {
+function getEnumName(value) {
   switch (value) {
-    case "viewport":
-      return "ViewportSize";
-    case "proxy":
-      return "ProxySettings";
-    case "permissions":
-      return "ContextPermission";
     case "modifiers":
       return "KeyboardModifier";
     case "button":
@@ -278,18 +271,18 @@ function toPascal(value) {
   return value[0].toUpperCase() + value.slice(1);
 }
 function formatContextOptions(contextOptions, deviceName) {
-  let options = { ...contextOptions };
+  const options = { ...contextOptions };
   delete options.recordHar;
   const device = deviceName && import_deviceDescriptors.deviceDescriptors[deviceName];
   if (!device) {
     if (!Object.entries(options).length)
       return "";
-    return formatObject(options, "    ", "BrowserNewContextOptions");
+    return formatObject(options, "    ");
   }
-  options = (0, import_language.sanitizeDeviceOptions)(device, options);
-  if (!Object.entries(options).length)
+  if (!Object.entries((0, import_language.sanitizeDeviceOptions)(device, options)).length)
     return `playwright.Devices[${quote(deviceName)}]`;
-  return formatObject(options, "    ", `BrowserNewContextOptions(playwright.Devices[${quote(deviceName)}])`);
+  delete options["defaultBrowserType"];
+  return formatObject(options, "    ");
 }
 class CSharpFormatter {
   constructor(offset = 0) {

package/lib/server/codegen/java.js

@@ -91,6 +91,10 @@ class JavaLanguageGenerator {
         const optionsText = formatClickOptions(options);
         return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.${method}(${optionsText});`;
       }
+      case "hover": {
+        const optionsText = action.position ? `new Locator.HoverOptions().setPosition(${action.position.x}, ${action.position.y})` : "";
+        return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.hover(${optionsText});`;
+      }
       case "check":
         return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.check();`;
       case "uncheck":

package/lib/server/codegen/javascript.js

@@ -81,6 +81,8 @@ class JavaScriptLanguageGenerator {
         const optionsString = formatOptions(options, false);
         return `await ${subject}.${this._asLocator(action.selector)}.${method}(${optionsString});`;
       }
+      case "hover":
+        return `await ${subject}.${this._asLocator(action.selector)}.hover(${formatOptions({ position: action.position }, false)});`;
       case "check":
         return `await ${subject}.${this._asLocator(action.selector)}.check();`;
       case "uncheck":
@@ -166,7 +168,7 @@ ${useText ? "\ntest.use(" + useText + ");\n" : ""}
   }
 }
 function formatOptions(value, hasArguments) {
-  const keys = Object.keys(value);
+  const keys = Object.keys(value).filter((key) => value[key] !== void 0);
   if (!keys.length)
     return "";
   return (hasArguments ? ", " : "") + formatObject(value);

package/lib/server/codegen/python.js

@@ -83,6 +83,8 @@ class PythonLanguageGenerator {
         const optionsString = formatOptions(options, false);
         return `${subject}.${this._asLocator(action.selector)}.${method}(${optionsString})`;
       }
+      case "hover":
+        return `${subject}.${this._asLocator(action.selector)}.hover(${formatOptions({ position: action.position }, false)})`;
       case "check":
         return `${subject}.${this._asLocator(action.selector)}.check()`;
       case "uncheck":