@stablyai/internal-playwright-core 0.1.12 → 0.1.13

package/lib/server/frames.js

@@ -52,7 +52,7 @@ var import_eventsHelper = require("./utils/eventsHelper");
 var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_callLog = require("./callLog");
-var import_healingService = require("./stably/autohealing/healingService");
+var import_healingService = require("./stably/auto_heal/healingService");
 class NavigationAbortedError extends Error {
   constructor(documentId, message) {
     super(message);
@@ -70,8 +70,7 @@ class FrameManager {
     this._mainFrame = void 0;
   }
   createDummyMainFrameIfNeeded() {
-    if (!this._mainFrame)
-      this.frameAttached(kDummyFrameId, null);
+    if (!this._mainFrame) this.frameAttached(kDummyFrameId, null);
   }
   dispose() {
     for (const frame of this._frames.values()) {
@@ -88,8 +87,7 @@ class FrameManager {
     return frames;
     function collect(frame) {
       frames.push(frame);
-      for (const subframe of frame.childFrames())
-        collect(subframe);
+      for (const subframe of frame.childFrames()) collect(subframe);
     }
   }
   frame(frameId) {
@@ -116,8 +114,7 @@ class FrameManager {
     }
   }
   async waitForSignalsCreatedBy(progress, waitAfter, action) {
-    if (!waitAfter)
-      return action();
+    if (!waitAfter) return action();
     const barrier = new SignalBarrier(progress);
     this._signalBarriers.add(barrier);
     try {
@@ -131,23 +128,22 @@ class FrameManager {
     }
   }
   frameWillPotentiallyRequestNavigation() {
-    for (const barrier of this._signalBarriers)
-      barrier.retain();
+    for (const barrier of this._signalBarriers) barrier.retain();
   }
   frameDidPotentiallyRequestNavigation() {
-    for (const barrier of this._signalBarriers)
-      barrier.release();
+    for (const barrier of this._signalBarriers) barrier.release();
   }
   frameRequestedNavigation(frameId, documentId) {
     const frame = this._frames.get(frameId);
-    if (!frame)
-      return;
+    if (!frame) return;
     for (const barrier of this._signalBarriers)
       barrier.addFrameNavigation(frame);
     if (frame.pendingDocument() && frame.pendingDocument().documentId === documentId) {
       return;
     }
-    const request = documentId ? Array.from(frame._inflightRequests).find((request2) => request2._documentId === documentId) : void 0;
+    const request = documentId ? Array.from(frame._inflightRequests).find(
+      (request2) => request2._documentId === documentId
+    ) : void 0;
     frame.setPendingDocument({ documentId, request });
   }
   frameCommittedNewDocumentNavigation(frameId, url, name, documentId, initial) {
@@ -173,7 +169,12 @@ class FrameManager {
       frame._currentDocument = { documentId, request: void 0 };
     }
     frame._onClearLifecycle();
-    const navigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
+    const navigationEvent = {
+      url,
+      name,
+      newDocument: frame._currentDocument,
+      isPublic: true
+    };
     this._fireInternalFrameNavigation(frame, navigationEvent);
     if (!initial) {
       import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
@@ -183,21 +184,23 @@ class FrameManager {
   }
   frameCommittedSameDocumentNavigation(frameId, url) {
     const frame = this._frames.get(frameId);
-    if (!frame)
-      return;
+    if (!frame) return;
     const pending = frame.pendingDocument();
     if (pending && pending.documentId === void 0 && pending.request === void 0) {
       frame.setPendingDocument(void 0);
     }
     frame._url = url;
-    const navigationEvent = { url, name: frame._name, isPublic: true };
+    const navigationEvent = {
+      url,
+      name: frame._name,
+      isPublic: true
+    };
     this._fireInternalFrameNavigation(frame, navigationEvent);
     import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
   }
   frameAbortedNavigation(frameId, errorText, documentId) {
     const frame = this._frames.get(frameId);
-    if (!frame || !frame.pendingDocument())
-      return;
+    if (!frame || !frame.pendingDocument()) return;
     if (documentId !== void 0 && frame.pendingDocument().documentId !== documentId)
       return;
     const navigationEvent = {
@@ -219,8 +222,7 @@ class FrameManager {
   }
   frameLifecycleEvent(frameId, event) {
     const frame = this._frames.get(frameId);
-    if (frame)
-      frame._onLifecycleEvent(event);
+    if (frame) frame._onLifecycleEvent(event);
   }
   requestStarted(request, route) {
     const frame = request.frame();
@@ -235,30 +237,36 @@ class FrameManager {
     this._page.addNetworkRequest(request);
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.Request, request);
     if (route)
-      new network.Route(request, route).handle([...this._page.requestInterceptors, ...this._page.browserContext.requestInterceptors]);
+      new network.Route(request, route).handle([
+        ...this._page.requestInterceptors,
+        ...this._page.browserContext.requestInterceptors
+      ]);
   }
   requestReceivedResponse(response) {
-    if (response.request()._isFavicon)
-      return;
+    if (response.request()._isFavicon) return;
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.Response, response);
   }
   reportRequestFinished(request, response) {
     this._inflightRequestFinished(request);
-    if (request._isFavicon)
-      return;
-    this._page.emitOnContext(import_browserContext.BrowserContext.Events.RequestFinished, { request, response });
+    if (request._isFavicon) return;
+    this._page.emitOnContext(import_browserContext.BrowserContext.Events.RequestFinished, {
+      request,
+      response
+    });
   }
   requestFailed(request, canceled) {
     const frame = request.frame();
     this._inflightRequestFinished(request);
     if (frame.pendingDocument() && frame.pendingDocument().request === request) {
       let errorText = request.failure().errorText;
-      if (canceled)
-        errorText += "; maybe frame was detached?";
-      this.frameAbortedNavigation(frame._id, errorText, frame.pendingDocument().documentId);
+      if (canceled) errorText += "; maybe frame was detached?";
+      this.frameAbortedNavigation(
+        frame._id,
+        errorText,
+        frame.pendingDocument().documentId
+      );
     }
-    if (request._isFavicon)
-      return;
+    if (request._isFavicon) return;
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.RequestFailed, request);
   }
   removeChildFramesRecursively(frame) {
@@ -274,36 +282,28 @@ class FrameManager {
   }
   _inflightRequestFinished(request) {
     const frame = request.frame();
-    if (request._isFavicon)
-      return;
-    if (!frame._inflightRequests.has(request))
-      return;
+    if (request._isFavicon) return;
+    if (!frame._inflightRequests.has(request)) return;
     frame._inflightRequests.delete(request);
-    if (frame._inflightRequests.size === 0)
-      frame._startNetworkIdleTimer();
+    if (frame._inflightRequests.size === 0) frame._startNetworkIdleTimer();
   }
   _inflightRequestStarted(request) {
     const frame = request.frame();
-    if (request._isFavicon)
-      return;
+    if (request._isFavicon) return;
     frame._inflightRequests.add(request);
-    if (frame._inflightRequests.size === 1)
-      frame._stopNetworkIdleTimer();
+    if (frame._inflightRequests.size === 1) frame._stopNetworkIdleTimer();
   }
   interceptConsoleMessage(message) {
-    if (message.type() !== "debug")
-      return false;
+    if (message.type() !== "debug") return false;
     const tag = message.text();
     const handler = this._consoleMessageTags.get(tag);
-    if (!handler)
-      return false;
+    if (!handler) return false;
     this._consoleMessageTags.delete(tag);
     handler();
     return true;
   }
   clearWebSockets(frame) {
-    if (frame.parentFrame())
-      return;
+    if (frame.parentFrame()) return;
     this._webSockets.clear();
   }
   onWebSocketCreated(requestId, url) {
@@ -312,36 +312,29 @@ class FrameManager {
   }
   onWebSocketRequest(requestId) {
     const ws = this._webSockets.get(requestId);
-    if (ws && ws.markAsNotified())
-      this._page.emit(import_page.Page.Events.WebSocket, ws);
+    if (ws && ws.markAsNotified()) this._page.emit(import_page.Page.Events.WebSocket, ws);
   }
   onWebSocketResponse(requestId, status, statusText) {
     const ws = this._webSockets.get(requestId);
-    if (status < 400)
-      return;
-    if (ws)
-      ws.error(`${statusText}: ${status}`);
+    if (status < 400) return;
+    if (ws) ws.error(`${statusText}: ${status}`);
   }
   onWebSocketFrameSent(requestId, opcode, data) {
     const ws = this._webSockets.get(requestId);
-    if (ws)
-      ws.frameSent(opcode, data);
+    if (ws) ws.frameSent(opcode, data);
   }
   webSocketFrameReceived(requestId, opcode, data) {
     const ws = this._webSockets.get(requestId);
-    if (ws)
-      ws.frameReceived(opcode, data);
+    if (ws) ws.frameReceived(opcode, data);
   }
   webSocketClosed(requestId) {
     const ws = this._webSockets.get(requestId);
-    if (ws)
-      ws.closed();
+    if (ws) ws.closed();
     this._webSockets.delete(requestId);
   }
   webSocketError(requestId, errorMessage) {
     const ws = this._webSockets.get(requestId);
-    if (ws)
-      ws.error(errorMessage);
+    if (ws) ws.error(errorMessage);
   }
   _fireInternalFrameNavigation(frame, event) {
     frame.emit(Frame.Events.InternalNavigation, event);
@@ -367,15 +360,19 @@ class Frame extends import_instrumentation.SdkObject {
     this._parentFrame = parentFrame;
     this._currentDocument = { documentId: void 0, request: void 0 };
     this.selectors = new import_frameSelectors.FrameSelectors(this);
-    this._contextData.set("main", { contextPromise: new import_manualPromise.ManualPromise(), context: null });
-    this._contextData.set("utility", { contextPromise: new import_manualPromise.ManualPromise(), context: null });
+    this._contextData.set("main", {
+      contextPromise: new import_manualPromise.ManualPromise(),
+      context: null
+    });
+    this._contextData.set("utility", {
+      contextPromise: new import_manualPromise.ManualPromise(),
+      context: null
+    });
     this._setContext("main", null);
     this._setContext("utility", null);
-    if (this._parentFrame)
-      this._parentFrame._childFrames.add(this);
+    if (this._parentFrame) this._parentFrame._childFrames.add(this);
     this._firedLifecycleEvents.add("commit");
-    if (id !== kDummyFrameId)
-      this._startNetworkIdleTimer();
+    if (id !== kDummyFrameId) this._startNetworkIdleTimer();
   }
   static {
     this.Events = {
@@ -388,8 +385,7 @@ class Frame extends import_instrumentation.SdkObject {
     return this._detachedScope.isClosed();
   }
   _onLifecycleEvent(event) {
-    if (this._firedLifecycleEvents.has(event))
-      return;
+    if (this._firedLifecycleEvents.has(event)) return;
     this._firedLifecycleEvents.add(event);
     this.emit(Frame.Events.AddLifecycle, event);
     if (this === this._page.mainFrame() && this._url !== "about:blank")
@@ -400,24 +396,28 @@ class Frame extends import_instrumentation.SdkObject {
     for (const event of this._firedLifecycleEvents)
       this.emit(Frame.Events.RemoveLifecycle, event);
     this._firedLifecycleEvents.clear();
-    this._inflightRequests = new Set(Array.from(this._inflightRequests).filter((request) => request === this._currentDocument.request));
+    this._inflightRequests = new Set(
+      Array.from(this._inflightRequests).filter(
+        (request) => request === this._currentDocument.request
+      )
+    );
     this._stopNetworkIdleTimer();
-    if (this._inflightRequests.size === 0)
-      this._startNetworkIdleTimer();
+    if (this._inflightRequests.size === 0) this._startNetworkIdleTimer();
     this._page.mainFrame()._recalculateNetworkIdle(this);
     this._onLifecycleEvent("commit");
   }
   setPendingDocument(documentInfo) {
     this._pendingDocument = documentInfo;
     if (documentInfo)
-      this._invalidateNonStallingEvaluations("Navigation interrupted the evaluation");
+      this._invalidateNonStallingEvaluations(
+        "Navigation interrupted the evaluation"
+      );
   }
   pendingDocument() {
     return this._pendingDocument;
   }
   _invalidateNonStallingEvaluations(message) {
-    if (!this._raceAgainstEvaluationStallingEventsPromises.size)
-      return;
+    if (!this._raceAgainstEvaluationStallingEventsPromises.size) return;
     const error = new Error(message);
     for (const promise of this._raceAgainstEvaluationStallingEventsPromises)
       promise.reject(error);
@@ -430,10 +430,7 @@ class Frame extends import_instrumentation.SdkObject {
     const promise = new import_manualPromise.ManualPromise();
     this._raceAgainstEvaluationStallingEventsPromises.add(promise);
     try {
-      return await Promise.race([
-        cb(),
-        promise
-      ]);
+      return await Promise.race([cb(), promise]);
     } finally {
       this._raceAgainstEvaluationStallingEventsPromises.delete(promise);
     }
@@ -473,38 +470,54 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async raceNavigationAction(progress, action) {
-    return import_utils.LongStandingScope.raceMultiple([
-      this._detachedScope,
-      this._page.openScope
-    ], action().catch((e) => {
-      if (e instanceof NavigationAbortedError && e.documentId) {
-        const data = this._redirectedNavigations.get(e.documentId);
-        if (data) {
-          progress.log(`waiting for redirected navigation to "${data.url}"`);
-          return progress.race(data.gotoPromise);
+    return import_utils.LongStandingScope.raceMultiple(
+      [this._detachedScope, this._page.openScope],
+      action().catch((e) => {
+        if (e instanceof NavigationAbortedError && e.documentId) {
+          const data = this._redirectedNavigations.get(e.documentId);
+          if (data) {
+            progress.log(`waiting for redirected navigation to "${data.url}"`);
+            return progress.race(data.gotoPromise);
+          }
         }
-      }
-      throw e;
-    }));
+        throw e;
+      })
+    );
   }
   redirectNavigation(url, documentId, referer) {
     const controller = new import_progress.ProgressController();
     const data = {
       url,
-      gotoPromise: controller.run((progress) => this.gotoImpl(progress, url, { referer }), 0)
+      gotoPromise: controller.run(
+        (progress) => this.gotoImpl(progress, url, { referer }),
+        0
+      )
     };
     this._redirectedNavigations.set(documentId, data);
-    data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
+    data.gotoPromise.finally(
+      () => this._redirectedNavigations.delete(documentId)
+    );
   }
   async goto(progress, url, options = {}) {
-    const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
-    return this.raceNavigationAction(progress, async () => this.gotoImpl(progress, constructedNavigationURL, options));
+    const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(
+      this._page.browserContext._options.baseURL,
+      url
+    );
+    return this.raceNavigationAction(
+      progress,
+      async () => this.gotoImpl(progress, constructedNavigationURL, options)
+    );
   }
   async gotoImpl(progress, url, options) {
-    const waitUntil = verifyLifecycle("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    const waitUntil = verifyLifecycle(
+      "waitUntil",
+      options.waitUntil === void 0 ? "load" : options.waitUntil
+    );
     progress.log(`navigating to "${url}", waiting until "${waitUntil}"`);
     const headers = this._page.extraHTTPHeaders() || [];
-    const refererHeader = headers.find((h) => h.name.toLowerCase() === "referer");
+    const refererHeader = headers.find(
+      (h) => h.name.toLowerCase() === "referer"
+    );
     let referer = refererHeader ? refererHeader.value : void 0;
     if (options.referer !== void 0) {
       if (referer !== void 0 && referer !== options.referer)
@@ -524,51 +537,81 @@ class Frame extends import_instrumentation.SdkObject {
         return event2.newDocument && (event2.newDocument.documentId === navigateResult.newDocumentId || !event2.error);
       };
       const events = navigationEvents.filter(predicate);
-      if (events.length)
-        event = events[0];
+      if (events.length) event = events[0];
       else
-        event = await import_helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, predicate).promise;
+        event = await import_helper.helper.waitForEvent(
+          progress,
+          this,
+          Frame.Events.InternalNavigation,
+          predicate
+        ).promise;
       if (event.newDocument.documentId !== navigateResult.newDocumentId) {
-        throw new NavigationAbortedError(navigateResult.newDocumentId, `Navigation to "${url}" is interrupted by another navigation to "${event.url}"`);
+        throw new NavigationAbortedError(
+          navigateResult.newDocumentId,
+          `Navigation to "${url}" is interrupted by another navigation to "${event.url}"`
+        );
       }
-      if (event.error)
-        throw event.error;
+      if (event.error) throw event.error;
     } else {
       const predicate = (e) => !e.newDocument;
       const events = navigationEvents.filter(predicate);
-      if (events.length)
-        event = events[0];
+      if (events.length) event = events[0];
       else
-        event = await import_helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, predicate).promise;
+        event = await import_helper.helper.waitForEvent(
+          progress,
+          this,
+          Frame.Events.InternalNavigation,
+          predicate
+        ).promise;
     }
     if (!this._firedLifecycleEvents.has(waitUntil))
-      await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
+      await import_helper.helper.waitForEvent(
+        progress,
+        this,
+        Frame.Events.AddLifecycle,
+        (e) => e === waitUntil
+      ).promise;
     const request = event.newDocument ? event.newDocument.request : void 0;
     const response = request ? progress.race(request._finalRequest().response()) : null;
     return response;
   }
   async _waitForNavigation(progress, requiresNewDocument, options) {
-    const waitUntil = verifyLifecycle("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    const waitUntil = verifyLifecycle(
+      "waitUntil",
+      options.waitUntil === void 0 ? "load" : options.waitUntil
+    );
     progress.log(`waiting for navigation until "${waitUntil}"`);
-    const navigationEvent = await import_helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, (event) => {
-      if (event.error)
+    const navigationEvent = await import_helper.helper.waitForEvent(
+      progress,
+      this,
+      Frame.Events.InternalNavigation,
+      (event) => {
+        if (event.error) return true;
+        if (requiresNewDocument && !event.newDocument) return false;
+        progress.log(`  navigated to "${this._url}"`);
         return true;
-      if (requiresNewDocument && !event.newDocument)
-        return false;
-      progress.log(`  navigated to "${this._url}"`);
-      return true;
-    }).promise;
-    if (navigationEvent.error)
-      throw navigationEvent.error;
+      }
+    ).promise;
+    if (navigationEvent.error) throw navigationEvent.error;
     if (!this._firedLifecycleEvents.has(waitUntil))
-      await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
+      await import_helper.helper.waitForEvent(
+        progress,
+        this,
+        Frame.Events.AddLifecycle,
+        (e) => e === waitUntil
+      ).promise;
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
     return request ? progress.race(request._finalRequest().response()) : null;
   }
   async _waitForLoadState(progress, state) {
     const waitUntil = verifyLifecycle("state", state);
     if (!this._firedLifecycleEvents.has(waitUntil))
-      await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
+      await import_helper.helper.waitForEvent(
+        progress,
+        this,
+        Frame.Events.AddLifecycle,
+        (e) => e === waitUntil
+      ).promise;
   }
   async frameElement() {
     return this._page.delegate.getFrameElement(this);
@@ -596,100 +639,170 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async evaluateExpressionHandle(expression, options = {}, arg) {
     const context = await this._context(options.world ?? "main");
-    const value = await context.evaluateExpressionHandle(expression, options, arg);
+    const value = await context.evaluateExpressionHandle(
+      expression,
+      options,
+      arg
+    );
     return value;
   }
   async querySelector(selector, options) {
-    import_debugLogger.debugLogger.log("api", `    finding element using the selector "${selector}"`);
+    import_debugLogger.debugLogger.log(
+      "api",
+      `    finding element using the selector "${selector}"`
+    );
     return this.selectors.query(selector, options);
   }
   async waitForSelector(progress, selector, performActionPreChecksAndLog, options, scope) {
     if (options.visibility)
-      throw new Error("options.visibility is not supported, did you mean options.state?");
+      throw new Error(
+        "options.visibility is not supported, did you mean options.state?"
+      );
     if (options.waitFor && options.waitFor !== "visible")
-      throw new Error("options.waitFor is not supported, did you mean options.state?");
+      throw new Error(
+        "options.waitFor is not supported, did you mean options.state?"
+      );
     const { state = "visible" } = options;
     if (!["attached", "detached", "visible", "hidden"].includes(state))
-      throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
+      throw new Error(
+        `state: expected one of (attached|detached|visible|hidden)`
+      );
     if (performActionPreChecksAndLog)
-      progress.log(`waiting for ${this._asLocator(selector)}${state === "attached" ? "" : " to be " + state}`);
-    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      if (performActionPreChecksAndLog)
-        await this._page.performActionPreChecks(progress);
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved) {
-        if (state === "hidden" || state === "detached")
+      progress.log(
+        `waiting for ${this._asLocator(selector)}${state === "attached" ? "" : " to be " + state}`
+      );
+    const promise = this.retryWithProgressAndTimeouts(
+      progress,
+      [0, 20, 50, 100, 100, 500],
+      async (continuePolling) => {
+        if (performActionPreChecksAndLog)
+          await this._page.performActionPreChecks(progress);
+        const resolved = await progress.race(
+          this.selectors.resolveInjectedForSelector(selector, options, scope)
+        );
+        if (!resolved) {
+          if (state === "hidden" || state === "detached") return null;
+          return continuePolling;
+        }
+        const result = await progress.race(
+          resolved.injected.evaluateHandle(
+            (injected, { info, root }) => {
+              if (root && !root.isConnected)
+                throw injected.createStacklessError(
+                  "Element is not attached to the DOM"
+                );
+              const elements = injected.querySelectorAll(
+                info.parsed,
+                root || document
+              );
+              const element2 = elements[0];
+              const visible2 = element2 ? injected.utils.isElementVisible(element2) : false;
+              let log2 = "";
+              if (elements.length > 1) {
+                if (info.strict)
+                  throw injected.strictModeViolationError(
+                    info.parsed,
+                    elements
+                  );
+                log2 = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(
+                  elements[0]
+                )}`;
+              } else if (element2) {
+                log2 = `  locator resolved to ${visible2 ? "visible" : "hidden"} ${injected.previewNode(element2)}`;
+              }
+              return { log: log2, element: element2, visible: visible2, attached: !!element2 };
+            },
+            {
+              info: resolved.info,
+              root: resolved.frame === this ? scope : void 0
+            }
+          )
+        );
+        const { log, visible, attached } = await progress.race(
+          result.evaluate((r) => ({
+            log: r.log,
+            visible: r.visible,
+            attached: r.attached
+          }))
+        );
+        if (log) progress.log(log);
+        const success = {
+          attached,
+          detached: !attached,
+          visible,
+          hidden: !visible
+        }[state];
+        if (!success) {
+          result.dispose();
+          return continuePolling;
+        }
+        if (options.omitReturnValue) {
+          result.dispose();
           return null;
-        return continuePolling;
-      }
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, root }) => {
-        if (root && !root.isConnected)
-          throw injected.createStacklessError("Element is not attached to the DOM");
-        const elements = injected.querySelectorAll(info.parsed, root || document);
-        const element2 = elements[0];
-        const visible2 = element2 ? injected.utils.isElementVisible(element2) : false;
-        let log2 = "";
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log2 = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element2) {
-          log2 = `  locator resolved to ${visible2 ? "visible" : "hidden"} ${injected.previewNode(element2)}`;
         }
-        return { log: log2, element: element2, visible: visible2, attached: !!element2 };
-      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
-      const { log, visible, attached } = await progress.race(result.evaluate((r) => ({ log: r.log, visible: r.visible, attached: r.attached })));
-      if (log)
-        progress.log(log);
-      const success = { attached, detached: !attached, visible, hidden: !visible }[state];
-      if (!success) {
+        const element = state === "attached" || state === "visible" ? await progress.race(result.evaluateHandle((r) => r.element)) : null;
         result.dispose();
-        return continuePolling;
-      }
-      if (options.omitReturnValue) {
-        result.dispose();
-        return null;
-      }
-      const element = state === "attached" || state === "visible" ? await progress.race(result.evaluateHandle((r) => r.element)) : null;
-      result.dispose();
-      if (!element)
-        return null;
-      if (options.__testHookBeforeAdoptNode)
-        await progress.race(options.__testHookBeforeAdoptNode());
-      try {
-        const mainContext = await progress.race(resolved.frame._mainContext());
-        return await progress.race(element._adoptTo(mainContext));
-      } catch (e) {
-        return continuePolling;
+        if (!element) return null;
+        if (options.__testHookBeforeAdoptNode)
+          await progress.race(options.__testHookBeforeAdoptNode());
+        try {
+          const mainContext = await progress.race(
+            resolved.frame._mainContext()
+          );
+          return await progress.race(element._adoptTo(mainContext));
+        } catch (e) {
+          return continuePolling;
+        }
       }
-    });
+    );
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   async dispatchEvent(progress, selector, type, eventInit = {}, options, scope) {
-    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
-      injectedScript.dispatchEvent(element, data.type, data.eventInit);
-    }, { type, eventInit }, { mainWorld: true, ...options }, scope);
+    await this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injectedScript, element, data) => {
+        injectedScript.dispatchEvent(element, data.type, data.eventInit);
+      },
+      { type, eventInit },
+      { mainWorld: true, ...options },
+      scope
+    );
   }
   async evalOnSelector(selector, strict, expression, isFunction, arg, scope) {
     const handle = await this.selectors.query(selector, { strict }, scope);
     if (!handle)
       throw new Error(`Failed to find element matching selector "${selector}"`);
-    const result = await handle.evaluateExpression(expression, { isFunction }, arg);
+    const result = await handle.evaluateExpression(
+      expression,
+      { isFunction },
+      arg
+    );
     handle.dispose();
     return result;
   }
   async evalOnSelectorAll(selector, expression, isFunction, arg, scope) {
-    const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope);
-    const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg);
+    const arrayHandle = await this.selectors.queryArrayInMainWorld(
+      selector,
+      scope
+    );
+    const result = await arrayHandle.evaluateExpression(
+      expression,
+      { isFunction },
+      arg
+    );
     arrayHandle.dispose();
     return result;
   }
   async maskSelectors(selectors, color) {
     const context = await this._utilityContext();
     const injectedScript = await context.injectedScript();
-    await injectedScript.evaluate((injected, { parsed, color: color2 }) => {
-      injected.maskSelectors(parsed, color2);
-    }, { parsed: selectors, color });
+    await injectedScript.evaluate(
+      (injected, { parsed, color: color2 }) => {
+        injected.maskSelectors(parsed, color2);
+      },
+      { parsed: selectors, color }
+    );
   }
   async querySelectorAll(selector) {
     return this.selectors.queryAll(selector);
@@ -698,8 +811,7 @@ class Frame extends import_instrumentation.SdkObject {
     try {
       return await this.selectors.queryCount(selector, options);
     } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
+      if (this.isNonRetriableError(e)) throw e;
       return 0;
     }
   }
@@ -715,9 +827,10 @@ class Frame extends import_instrumentation.SdkObject {
         return retVal;
       });
     } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
-      throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
+      if (this.isNonRetriableError(e)) throw e;
+      throw new Error(
+        `Unable to retrieve content because the page is navigating and changing the content.`
+      );
     }
   }
   async setContent(progress, html, options) {
@@ -732,12 +845,17 @@ class Frame extends import_instrumentation.SdkObject {
         tagPromise.resolve();
       });
       const lifecyclePromise = progress.race(tagPromise).then(() => this._waitForLoadState(progress, waitUntil));
-      const contentPromise = progress.race(context.evaluate(({ html: html2, tag: tag2 }) => {
-        document.open();
-        console.debug(tag2);
-        document.write(html2);
-        document.close();
-      }, { html, tag }));
+      const contentPromise = progress.race(
+        context.evaluate(
+          ({ html: html2, tag: tag2 }) => {
+            document.open();
+            console.debug(tag2);
+            document.write(html2);
+            document.close();
+          },
+          { html, tag }
+        )
+      );
       await Promise.all([contentPromise, lifecyclePromise]);
       return null;
     }).finally(() => {
@@ -751,8 +869,7 @@ class Frame extends import_instrumentation.SdkObject {
     return this._url;
   }
   origin() {
-    if (!this._url.startsWith("http"))
-      return;
+    if (!this._url.startsWith("http")) return;
     return network.parseURL(this._url)?.origin;
   }
   parentFrame() {
@@ -762,18 +879,19 @@ class Frame extends import_instrumentation.SdkObject {
     return Array.from(this._childFrames);
   }
   async addScriptTag(params) {
-    const {
-      url = null,
-      content = null,
-      type = ""
-    } = params;
+    const { url = null, content = null, type = "" } = params;
     if (!url && !content)
-      throw new Error("Provide an object with a `url`, `path` or `content` property");
+      throw new Error(
+        "Provide an object with a `url`, `path` or `content` property"
+      );
     const context = await this._mainContext();
     return this._raceWithCSPError(async () => {
       if (url !== null)
         return (await context.evaluateHandle(addScriptUrl, { url, type })).asElement();
-      const result = (await context.evaluateHandle(addScriptContent, { content, type })).asElement();
+      const result = (await context.evaluateHandle(addScriptContent, {
+        content,
+        type
+      })).asElement();
       if (this._page.delegate.cspErrorsAsynchronousForInlineScripts)
         await context.evaluate(() => true);
       return result;
@@ -781,11 +899,12 @@ class Frame extends import_instrumentation.SdkObject {
     async function addScriptUrl(params2) {
       const script = document.createElement("script");
       script.src = params2.url;
-      if (params2.type)
-        script.type = params2.type;
+      if (params2.type) script.type = params2.type;
       const promise = new Promise((res, rej) => {
         script.onload = res;
-        script.onerror = (e) => rej(typeof e === "string" ? new Error(e) : new Error(`Failed to load script at ${script.src}`));
+        script.onerror = (e) => rej(
+          typeof e === "string" ? new Error(e) : new Error(`Failed to load script at ${script.src}`)
+        );
       });
       document.head.appendChild(script);
       await promise;
@@ -798,18 +917,16 @@ class Frame extends import_instrumentation.SdkObject {
       let error = null;
       script.onerror = (e) => error = e;
       document.head.appendChild(script);
-      if (error)
-        throw error;
+      if (error) throw error;
       return script;
     }
   }
   async addStyleTag(params) {
-    const {
-      url = null,
-      content = null
-    } = params;
+    const { url = null, content = null } = params;
     if (!url && !content)
-      throw new Error("Provide an object with a `url`, `path` or `content` property");
+      throw new Error(
+        "Provide an object with a `url`, `path` or `content` property"
+      );
     const context = await this._mainContext();
     return this._raceWithCSPError(async () => {
       if (url !== null)
@@ -848,21 +965,25 @@ class Frame extends import_instrumentation.SdkObject {
     let cspMessage;
     const actionPromise = func().then((r) => result = r).catch((e) => error = e);
     const errorPromise = new Promise((resolve) => {
-      listeners.push(import_eventsHelper.eventsHelper.addEventListener(this._page.browserContext, import_browserContext.BrowserContext.Events.Console, (message) => {
-        if (message.page() !== this._page || message.type() !== "error")
-          return;
-        if (message.text().includes("Content-Security-Policy") || message.text().includes("Content Security Policy")) {
-          cspMessage = message;
-          resolve();
-        }
-      }));
+      listeners.push(
+        import_eventsHelper.eventsHelper.addEventListener(
+          this._page.browserContext,
+          import_browserContext.BrowserContext.Events.Console,
+          (message) => {
+            if (message.page() !== this._page || message.type() !== "error")
+              return;
+            if (message.text().includes("Content-Security-Policy") || message.text().includes("Content Security Policy")) {
+              cspMessage = message;
+              resolve();
+            }
+          }
+        )
+      );
     });
     await Promise.race([actionPromise, errorPromise]);
     import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    if (cspMessage)
-      throw new Error(cspMessage.text());
-    if (error)
-      throw error;
+    if (cspMessage) throw new Error(cspMessage.text());
+    if (error) throw error;
     return result;
   }
   async retryWithProgressAndTimeouts(progress, timeouts, action) {
@@ -873,32 +994,30 @@ class Frame extends import_instrumentation.SdkObject {
       const timeout = timeouts[Math.min(timeoutIndex++, timeouts.length - 1)];
       if (timeout) {
         const actionPromise = new Promise((f) => setTimeout(f, timeout));
-        await progress.race(import_utils.LongStandingScope.raceMultiple([
-          this._page.openScope,
-          this._detachedScope
-        ], actionPromise));
+        await progress.race(
+          import_utils.LongStandingScope.raceMultiple(
+            [this._page.openScope, this._detachedScope],
+            actionPromise
+          )
+        );
       }
       try {
         const result = await action(continuePolling);
-        if (result === continuePolling)
-          continue;
+        if (result === continuePolling) continue;
         return result;
       } catch (e) {
-        if (this.isNonRetriableError(e))
-          throw e;
+        if (this.isNonRetriableError(e)) throw e;
         continue;
       }
     }
   }
   isNonRetriableError(e) {
-    if ((0, import_progress.isAbortError)(e))
-      return true;
+    if ((0, import_progress.isAbortError)(e)) return true;
     if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
       return true;
     if (dom.isNonRecoverableDOMError(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
       return true;
-    if (this.isDetached())
-      return true;
+    if (this.isDetached()) return true;
     return false;
   }
   _shouldAttemptAutoHealing(locatorAutohealOption) {
@@ -914,9 +1033,10 @@ class Frame extends import_instrumentation.SdkObject {
       actionName,
       error
     });
-    if (!healedSelector)
-      return void 0;
-    progress.log(`[Auto-Healing] Retrying with healed selector: ${healedSelector}`);
+    if (!healedSelector) return void 0;
+    progress.log(
+      `[Auto-Healing] Retrying with healed selector: ${healedSelector}`
+    );
     const healingTimeout = (0, import_healingService.getHealingConfig)().timeout;
     const healingController = new import_progress.ProgressController(progress.metadata);
     return await healingController.run(async (healingProgress) => {
@@ -925,123 +1045,252 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async _retryWithProgressIfNotConnectedWithHealing(progress, selector, strict, performActionPreChecks, action, actionName, autoHeal) {
     try {
-      return await this._retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action);
+      return await this._retryWithProgressIfNotConnected(
+        progress,
+        selector,
+        strict,
+        performActionPreChecks,
+        action
+      );
     } catch (error) {
-      if (!this._shouldAttemptAutoHealing(autoHeal))
-        throw error;
+      if (!this._shouldAttemptAutoHealing(autoHeal)) throw error;
       const healedResult = await this._attemptHealingRetry(
         progress,
         selector,
         actionName,
         error,
         async (healingProgress, healedSelector) => {
-          return await this._retryWithProgressIfNotConnected(healingProgress, healedSelector, strict, performActionPreChecks, action);
+          return await this._retryWithProgressIfNotConnected(
+            healingProgress,
+            healedSelector,
+            strict,
+            performActionPreChecks,
+            action
+          );
         }
       );
-      if (healedResult !== void 0)
-        return healedResult;
+      if (healedResult !== void 0) return healedResult;
       throw error;
     }
   }
   async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
-    return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      if (performActionPreChecks)
-        await this._page.performActionPreChecks(progress);
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
-      if (!resolved)
-        return continuePolling;
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
-        const elements = injected.querySelectorAll(info.parsed, document);
-        if (callId)
-          injected.markTargetElements(new Set(elements), callId);
-        const element2 = elements[0];
-        let log2 = "";
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log2 = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element2) {
-          log2 = `  locator resolved to ${injected.previewNode(element2)}`;
+    return this.retryWithProgressAndTimeouts(
+      progress,
+      [0, 20, 50, 100, 100, 500],
+      async (continuePolling) => {
+        if (performActionPreChecks)
+          await this._page.performActionPreChecks(progress);
+        const resolved = await progress.race(
+          this.selectors.resolveInjectedForSelector(selector, { strict })
+        );
+        if (!resolved) return continuePolling;
+        const result = await progress.race(
+          resolved.injected.evaluateHandle(
+            (injected, { info, callId }) => {
+              const elements = injected.querySelectorAll(info.parsed, document);
+              if (callId)
+                injected.markTargetElements(new Set(elements), callId);
+              const element2 = elements[0];
+              let log2 = "";
+              if (elements.length > 1) {
+                if (info.strict)
+                  throw injected.strictModeViolationError(
+                    info.parsed,
+                    elements
+                  );
+                log2 = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(
+                  elements[0]
+                )}`;
+              } else if (element2) {
+                log2 = `  locator resolved to ${injected.previewNode(element2)}`;
+              }
+              return { log: log2, success: !!element2, element: element2 };
+            },
+            { info: resolved.info, callId: progress.metadata.id }
+          )
+        );
+        const { log, success } = await progress.race(
+          result.evaluate((r) => ({ log: r.log, success: r.success }))
+        );
+        if (log) progress.log(log);
+        if (!success) {
+          result.dispose();
+          return continuePolling;
         }
-        return { log: log2, success: !!element2, element: element2 };
-      }, { info: resolved.info, callId: progress.metadata.id }));
-      const { log, success } = await progress.race(result.evaluate((r) => ({ log: r.log, success: r.success })));
-      if (log)
-        progress.log(log);
-      if (!success) {
+        const element = await progress.race(
+          result.evaluateHandle((r) => r.element)
+        );
         result.dispose();
-        return continuePolling;
-      }
-      const element = await progress.race(result.evaluateHandle((r) => r.element));
-      result.dispose();
-      try {
-        const result2 = await action(element, progress);
-        if (result2 === "error:notconnected") {
-          progress.log("element was detached from the DOM, retrying");
-          return continuePolling;
+        try {
+          const result2 = await action(element, progress);
+          if (result2 === "error:notconnected") {
+            progress.log("element was detached from the DOM, retrying");
+            return continuePolling;
+          }
+          return result2;
+        } finally {
+          element?.dispose();
         }
-        return result2;
-      } finally {
-        element?.dispose();
       }
-    });
+    );
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
-      await handle._frame.rafrafTimeout(progress, timeout);
-      return await this._page.screenshotter.screenshotElement(progress, handle, options);
-    });
+    return await this._retryWithProgressIfNotConnected(
+      progress,
+      selector,
+      true,
+      true,
+      async (handle) => {
+        await handle._frame.rafrafTimeout(progress, timeout);
+        return await this._page.screenshotter.screenshotElement(
+          progress,
+          handle,
+          options
+        );
+      }
+    );
   }
   async click(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._click(p, { ...options, waitAfter: !options.noWaitAfter }), "click", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._click(p, { ...options, waitAfter: !options.noWaitAfter }),
+        "click",
+        options.autoHeal
+      )
+    );
   }
   async dblclick(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._dblclick(p, options), "dblclick", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._dblclick(p, options),
+        "dblclick",
+        options.autoHeal
+      )
+    );
   }
   async dragAndDrop(progress, source, target, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle, p) => {
-      return handle._retryPointerAction(p, "move and down", false, async (point) => {
-        await this._page.mouse.move(p, point.x, point.y);
-        await this._page.mouse.down(p);
-      }, {
-        ...options,
-        waitAfter: "disabled",
-        position: options.sourcePosition
-      });
-    }));
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle, p) => {
-      return handle._retryPointerAction(p, "move and up", false, async (point) => {
-        await this._page.mouse.move(p, point.x, point.y);
-        await this._page.mouse.up(p);
-      }, {
-        ...options,
-        waitAfter: "disabled",
-        position: options.targetPosition
-      });
-    }));
+    dom.assertDone(
+      await this._retryWithProgressIfNotConnected(
+        progress,
+        source,
+        options.strict,
+        !options.force,
+        async (handle, p) => {
+          return handle._retryPointerAction(
+            p,
+            "move and down",
+            false,
+            async (point) => {
+              await this._page.mouse.move(p, point.x, point.y);
+              await this._page.mouse.down(p);
+            },
+            {
+              ...options,
+              waitAfter: "disabled",
+              position: options.sourcePosition
+            }
+          );
+        }
+      )
+    );
+    dom.assertDone(
+      await this._retryWithProgressIfNotConnected(
+        progress,
+        target,
+        options.strict,
+        false,
+        async (handle, p) => {
+          return handle._retryPointerAction(
+            p,
+            "move and up",
+            false,
+            async (point) => {
+              await this._page.mouse.move(p, point.x, point.y);
+              await this._page.mouse.up(p);
+            },
+            {
+              ...options,
+              waitAfter: "disabled",
+              position: options.targetPosition
+            }
+          );
+        }
+      )
+    );
   }
   async tap(progress, selector, options) {
     if (!this._page.browserContext._options.hasTouch)
-      throw new Error("The page does not support tap. Use hasTouch context option to enable touch support.");
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._tap(p, options), "tap", options.autoHeal));
+      throw new Error(
+        "The page does not support tap. Use hasTouch context option to enable touch support."
+      );
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._tap(p, options),
+        "tap",
+        options.autoHeal
+      )
+    );
   }
   async fill(progress, selector, value, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._fill(p, value, options), "fill", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._fill(p, value, options),
+        "fill",
+        options.autoHeal
+      )
+    );
   }
   async focus(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, true, (handle, p) => handle._focus(p), "focus", options.autoHeal));
+    dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        true,
+        (handle, p) => handle._focus(p),
+        "focus",
+        options.autoHeal
+      )
+    );
   }
   async blur(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle, p) => handle._blur(p)));
+    dom.assertDone(
+      await this._retryWithProgressIfNotConnected(
+        progress,
+        selector,
+        options.strict,
+        true,
+        (handle, p) => handle._blur(p)
+      )
+    );
   }
   async resolveSelector(progress, selector, options = {}) {
-    const element = await progress.race(this.selectors.query(selector, options));
-    if (!element)
-      throw new Error(`No element matching ${selector}`);
-    const generated = await progress.race(element.evaluateInUtility(async ([injected, node]) => {
-      return injected.generateSelectorSimple(node);
-    }, {}));
+    const element = await progress.race(
+      this.selectors.query(selector, options)
+    );
+    if (!element) throw new Error(`No element matching ${selector}`);
+    const generated = await progress.race(
+      element.evaluateInUtility(async ([injected, node]) => {
+        return injected.generateSelectorSimple(node);
+      }, {})
+    );
     if (!generated)
       throw new Error(`Unable to generate locator for ${selector}`);
     let frame = element._frame;
@@ -1049,9 +1298,11 @@ class Frame extends import_instrumentation.SdkObject {
     while (frame?.parentFrame()) {
       const frameElement = await progress.race(frame.frameElement());
       if (frameElement) {
-        const generated2 = await progress.race(frameElement.evaluateInUtility(async ([injected, node]) => {
-          return injected.generateSelectorSimple(node);
-        }, {}));
+        const generated2 = await progress.race(
+          frameElement.evaluateInUtility(async ([injected, node]) => {
+            return injected.generateSelectorSimple(node);
+          }, {})
+        );
         frameElement.dispose();
         if (generated2 === "error:notconnected" || !generated2)
           throw new Error(`Unable to generate locator for ${selector}`);
@@ -1063,36 +1314,81 @@ class Frame extends import_instrumentation.SdkObject {
     return { resolvedSelector };
   }
   async textContent(progress, selector, options, scope) {
-    return this._callOnElementOnceMatches(progress, selector, (injected, element) => element.textContent, void 0, options, scope);
+    return this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injected, element) => element.textContent,
+      void 0,
+      options,
+      scope
+    );
   }
   async innerText(progress, selector, options, scope) {
-    return this._callOnElementOnceMatches(progress, selector, (injectedScript, element) => {
-      if (element.namespaceURI !== "http://www.w3.org/1999/xhtml")
-        throw injectedScript.createStacklessError("Node is not an HTMLElement");
-      return element.innerText;
-    }, void 0, options, scope);
+    return this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injectedScript, element) => {
+        if (element.namespaceURI !== "http://www.w3.org/1999/xhtml")
+          throw injectedScript.createStacklessError(
+            "Node is not an HTMLElement"
+          );
+        return element.innerText;
+      },
+      void 0,
+      options,
+      scope
+    );
   }
   async innerHTML(progress, selector, options, scope) {
-    return this._callOnElementOnceMatches(progress, selector, (injected, element) => element.innerHTML, void 0, options, scope);
+    return this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injected, element) => element.innerHTML,
+      void 0,
+      options,
+      scope
+    );
   }
   async getAttribute(progress, selector, name, options, scope) {
-    return this._callOnElementOnceMatches(progress, selector, (injected, element, data) => element.getAttribute(data.name), { name }, options, scope);
+    return this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injected, element, data) => element.getAttribute(data.name),
+      { name },
+      options,
+      scope
+    );
   }
   async inputValue(progress, selector, options, scope) {
-    return this._callOnElementOnceMatches(progress, selector, (injectedScript, node) => {
-      const element = injectedScript.retarget(node, "follow-label");
-      if (!element || element.nodeName !== "INPUT" && element.nodeName !== "TEXTAREA" && element.nodeName !== "SELECT")
-        throw injectedScript.createStacklessError("Node is not an <input>, <textarea> or <select> element");
-      return element.value;
-    }, void 0, options, scope);
+    return this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injectedScript, node) => {
+        const element = injectedScript.retarget(node, "follow-label");
+        if (!element || element.nodeName !== "INPUT" && element.nodeName !== "TEXTAREA" && element.nodeName !== "SELECT")
+          throw injectedScript.createStacklessError(
+            "Node is not an <input>, <textarea> or <select> element"
+          );
+        return element.value;
+      },
+      void 0,
+      options,
+      scope
+    );
   }
   async highlight(progress, selector) {
-    const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector));
-    if (!resolved)
-      return;
-    return await progress.race(resolved.injected.evaluate((injected, { info }) => {
-      return injected.highlight(info.parsed);
-    }, { info: resolved.info }));
+    const resolved = await progress.race(
+      this.selectors.resolveInjectedForSelector(selector)
+    );
+    if (!resolved) return;
+    return await progress.race(
+      resolved.injected.evaluate(
+        (injected, { info }) => {
+          return injected.highlight(info.parsed);
+        },
+        { info: resolved.info }
+      )
+    );
   }
   async hideHighlight() {
     return this.raceAgainstEvaluationStallingEvents(async () => {
@@ -1104,9 +1400,16 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   async _elementState(progress, selector, state, options, scope) {
-    const result = await this._callOnElementOnceMatches(progress, selector, (injected, element, data) => {
-      return injected.elementState(element, data.state);
-    }, { state }, options, scope);
+    const result = await this._callOnElementOnceMatches(
+      progress,
+      selector,
+      (injected, element, data) => {
+        return injected.elementState(element, data.state);
+      },
+      { state },
+      options,
+      scope
+    );
     if (result.received === "error:notconnected")
       dom.throwElementIsNotAttached();
     return result.matches;
@@ -1117,17 +1420,29 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async isVisibleInternal(progress, selector, options = {}, scope) {
     try {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return false;
-      return await progress.race(resolved.injected.evaluate((injected, { info, root }) => {
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        const state = element ? injected.elementState(element, "visible") : { matches: false, received: "error:notconnected" };
-        return state.matches;
-      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
+      const resolved = await progress.race(
+        this.selectors.resolveInjectedForSelector(selector, options, scope)
+      );
+      if (!resolved) return false;
+      return await progress.race(
+        resolved.injected.evaluate(
+          (injected, { info, root }) => {
+            const element = injected.querySelector(
+              info.parsed,
+              root || document,
+              info.strict
+            );
+            const state = element ? injected.elementState(element, "visible") : { matches: false, received: "error:notconnected" };
+            return state.matches;
+          },
+          {
+            info: resolved.info,
+            root: resolved.frame === this ? scope : void 0
+          }
+        )
+      );
     } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
+      if (this.isNonRetriableError(e)) throw e;
       return false;
     }
   }
@@ -1147,65 +1462,155 @@ class Frame extends import_instrumentation.SdkObject {
     return this._elementState(progress, selector, "checked", options, scope);
   }
   async hover(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._hover(p, options), "hover", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._hover(p, options),
+        "hover",
+        options.autoHeal
+      )
+    );
   }
   async selectOption(progress, selector, elements, values, options) {
-    return await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._selectOption(p, elements, values, options), "selectOption", options.autoHeal);
+    return await this._retryWithProgressIfNotConnectedWithHealing(
+      progress,
+      selector,
+      options.strict,
+      !options.force,
+      (handle, p) => handle._selectOption(p, elements, values, options),
+      "selectOption",
+      options.autoHeal
+    );
   }
   async setInputFiles(progress, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, params.strict, true, (handle, p) => handle._setInputFiles(p, inputFileItems), "setInputFiles", params.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        params.strict,
+        true,
+        (handle, p) => handle._setInputFiles(p, inputFileItems),
+        "setInputFiles",
+        params.autoHeal
+      )
+    );
   }
   async type(progress, selector, text, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, true, (handle, p) => handle._type(p, text, options), "type", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        true,
+        (handle, p) => handle._type(p, text, options),
+        "type",
+        options.autoHeal
+      )
+    );
   }
   async press(progress, selector, key, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, true, (handle, p) => handle._press(p, key, options), "press", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        true,
+        (handle, p) => handle._press(p, key, options),
+        "press",
+        options.autoHeal
+      )
+    );
   }
   async check(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._setChecked(p, true, options), "check", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._setChecked(p, true, options),
+        "check",
+        options.autoHeal
+      )
+    );
   }
   async uncheck(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnectedWithHealing(progress, selector, options.strict, !options.force, (handle, p) => handle._setChecked(p, false, options), "uncheck", options.autoHeal));
+    return dom.assertDone(
+      await this._retryWithProgressIfNotConnectedWithHealing(
+        progress,
+        selector,
+        options.strict,
+        !options.force,
+        (handle, p) => handle._setChecked(p, false, options),
+        "uncheck",
+        options.autoHeal
+      )
+    );
   }
   async waitForTimeout(progress, timeout) {
     return progress.wait(timeout);
   }
   async ariaSnapshot(progress, selector) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle, p) => p.race(handle.ariaSnapshot()));
+    return await this._retryWithProgressIfNotConnected(
+      progress,
+      selector,
+      true,
+      true,
+      (handle, p) => p.race(handle.ariaSnapshot())
+    );
   }
   async expect(progress, selector, options, timeout) {
-    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
+    progress.log(
+      `${(0, import_utils.renderTitleForCall)(progress.metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`
+    );
     const lastIntermediateResult = { isSet: false };
     const fixupMetadataError = (result) => {
       if (result.matches === options.isNot)
-        progress.metadata.error = { error: { name: "Expect", message: "Expect failed" } };
+        progress.metadata.error = {
+          error: { name: "Expect", message: "Expect failed" }
+        };
     };
     try {
-      if (selector)
-        progress.log(`waiting for ${this._asLocator(selector)}`);
+      if (selector) progress.log(`waiting for ${this._asLocator(selector)}`);
       await this._page.performActionPreChecks(progress);
       try {
-        const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
-        if (resultOneShot.matches !== options.isNot)
-          return resultOneShot;
+        const resultOneShot = await this._expectInternal(
+          progress,
+          selector,
+          options,
+          lastIntermediateResult,
+          true
+        );
+        if (resultOneShot.matches !== options.isNot) return resultOneShot;
       } catch (e) {
-        if (this.isNonRetriableError(e))
-          throw e;
+        if (this.isNonRetriableError(e)) throw e;
       }
-      const result = await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-        await this._page.performActionPreChecks(progress);
-        const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
-        if (matches === options.isNot) {
-          return continuePolling;
+      const result = await this.retryWithProgressAndTimeouts(
+        progress,
+        [100, 250, 500, 1e3],
+        async (continuePolling) => {
+          await this._page.performActionPreChecks(progress);
+          const { matches, received } = await this._expectInternal(
+            progress,
+            selector,
+            options,
+            lastIntermediateResult,
+            false
+          );
+          if (matches === options.isNot) {
+            return continuePolling;
+          }
+          return { matches, received };
         }
-        return { matches, received };
-      });
+      );
       fixupMetadataError(result);
       return result;
     } catch (e) {
-      if (!this._shouldAttemptAutoHealing(options.autoHeal))
-        throw e;
+      if (!this._shouldAttemptAutoHealing(options.autoHeal)) throw e;
       if (selector) {
         const actionName = `expect(${options.expression})`;
         const healedResult = await this._attemptHealingRetry(
@@ -1214,13 +1619,20 @@ class Frame extends import_instrumentation.SdkObject {
           actionName,
           e,
           async (healingProgress, healedSelector) => {
-            return await this.expect(healingProgress, healedSelector, options, timeout);
+            return await this.expect(
+              healingProgress,
+              healedSelector,
+              options,
+              timeout
+            );
           }
         );
-        if (healedResult !== void 0)
-          return healedResult;
+        if (healedResult !== void 0) return healedResult;
       }
-      const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(progress.metadata.log) };
+      const result = {
+        matches: options.isNot,
+        log: (0, import_callLog.compressCallLog)(progress.metadata.log)
+      };
       if ((0, import_selectorParser.isInvalidSelectorError)(e)) {
         result.errorMessage = "Error: " + e.message;
       } else if (js.isJavaScriptErrorInEvaluate(e)) {
@@ -1229,97 +1641,114 @@ class Frame extends import_instrumentation.SdkObject {
         result.received = lastIntermediateResult.received;
         result.errorMessage = lastIntermediateResult.errorMessage;
       }
-      if (e instanceof import_errors.TimeoutError)
-        result.timedOut = true;
+      if (e instanceof import_errors.TimeoutError) result.timedOut = true;
       fixupMetadataError(result);
       return result;
     }
   }
   async _expectInternal(progress, selector, options, lastIntermediateResult, noAbort) {
     const race = (p) => noAbort ? p : progress.race(p);
-    const selectorInFrame = selector ? await race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : void 0;
+    const selectorInFrame = selector ? await race(
+      this.selectors.resolveFrameForSelector(selector, { strict: true })
+    ) : void 0;
     const { frame, info } = selectorInFrame || { frame: this, info: void 0 };
     const world = options.expression === "to.have.property" ? "main" : info?.world ?? "utility";
     const context = await race(frame._context(world));
     const injected = await race(context.injectedScript());
-    const { log, matches, received, missingReceived } = await race(injected.evaluate(async (injected2, { info: info2, options: options2, callId }) => {
-      const elements = info2 ? injected2.querySelectorAll(info2.parsed, document) : [];
-      if (callId)
-        injected2.markTargetElements(new Set(elements), callId);
-      const isArray = options2.expression === "to.have.count" || options2.expression.endsWith(".array");
-      let log2 = "";
-      if (isArray)
-        log2 = `  locator resolved to ${elements.length} element${elements.length === 1 ? "" : "s"}`;
-      else if (elements.length > 1)
-        throw injected2.strictModeViolationError(info2.parsed, elements);
-      else if (elements.length)
-        log2 = `  locator resolved to ${injected2.previewNode(elements[0])}`;
-      return { log: log2, ...await injected2.expect(elements[0], options2, elements) };
-    }, { info, options, callId: progress.metadata.id }));
-    if (log)
-      progress.log(log);
+    const { log, matches, received, missingReceived } = await race(
+      injected.evaluate(
+        async (injected2, { info: info2, options: options2, callId }) => {
+          const elements = info2 ? injected2.querySelectorAll(info2.parsed, document) : [];
+          if (callId) injected2.markTargetElements(new Set(elements), callId);
+          const isArray = options2.expression === "to.have.count" || options2.expression.endsWith(".array");
+          let log2 = "";
+          if (isArray)
+            log2 = `  locator resolved to ${elements.length} element${elements.length === 1 ? "" : "s"}`;
+          else if (elements.length > 1)
+            throw injected2.strictModeViolationError(info2.parsed, elements);
+          else if (elements.length)
+            log2 = `  locator resolved to ${injected2.previewNode(elements[0])}`;
+          return {
+            log: log2,
+            ...await injected2.expect(elements[0], options2, elements)
+          };
+        },
+        { info, options, callId: progress.metadata.id }
+      )
+    );
+    if (log) progress.log(log);
     if (matches === options.isNot) {
       if (missingReceived)
         lastIntermediateResult.errorMessage = "Error: element(s) not found";
-      else
-        lastIntermediateResult.received = received;
+      else lastIntermediateResult.received = received;
       lastIntermediateResult.isSet = true;
       if (!missingReceived && !Array.isArray(received))
-        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
+        progress.log(
+          `  unexpected value "${renderUnexpectedValue(
+            options.expression,
+            received
+          )}"`
+        );
     }
     return { matches, received };
   }
   async waitForFunctionExpression(progress, expression, isFunction, arg, options, world = "main") {
     if (typeof options.pollingInterval === "number")
-      (0, import_utils.assert)(options.pollingInterval > 0, "Cannot poll with non-positive interval: " + options.pollingInterval);
+      (0, import_utils.assert)(
+        options.pollingInterval > 0,
+        "Cannot poll with non-positive interval: " + options.pollingInterval
+      );
     expression = js.normalizeEvaluationExpression(expression, isFunction);
     return this.retryWithProgressAndTimeouts(progress, [100], async () => {
       const context = world === "main" ? await progress.race(this._mainContext()) : await progress.race(this._utilityContext());
       const injectedScript = await progress.race(context.injectedScript());
-      const handle = await progress.race(injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
-        let evaledExpression;
-        const predicate = () => {
-          let result2 = evaledExpression ?? globalThis.eval(expression2);
-          if (isFunction2 === true) {
-            evaledExpression = result2;
-            result2 = result2(arg2);
-          } else if (isFunction2 === false) {
-            result2 = result2;
-          } else {
-            if (typeof result2 === "function") {
-              evaledExpression = result2;
-              result2 = result2(arg2);
-            }
-          }
-          return result2;
-        };
-        let fulfill;
-        let reject;
-        let aborted = false;
-        const result = new Promise((f, r) => {
-          fulfill = f;
-          reject = r;
-        });
-        const next = () => {
-          if (aborted)
-            return;
-          try {
-            const success = predicate();
-            if (success) {
-              fulfill(success);
-              return;
-            }
-            if (typeof polling !== "number")
-              injected.utils.builtins.requestAnimationFrame(next);
-            else
-              injected.utils.builtins.setTimeout(next, polling);
-          } catch (e) {
-            reject(e);
-          }
-        };
-        next();
-        return { result, abort: () => aborted = true };
-      }, { expression, isFunction, polling: options.pollingInterval, arg }));
+      const handle = await progress.race(
+        injectedScript.evaluateHandle(
+          (injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
+            let evaledExpression;
+            const predicate = () => {
+              let result2 = evaledExpression ?? globalThis.eval(expression2);
+              if (isFunction2 === true) {
+                evaledExpression = result2;
+                result2 = result2(arg2);
+              } else if (isFunction2 === false) {
+                result2 = result2;
+              } else {
+                if (typeof result2 === "function") {
+                  evaledExpression = result2;
+                  result2 = result2(arg2);
+                }
+              }
+              return result2;
+            };
+            let fulfill;
+            let reject;
+            let aborted = false;
+            const result = new Promise((f, r) => {
+              fulfill = f;
+              reject = r;
+            });
+            const next = () => {
+              if (aborted) return;
+              try {
+                const success = predicate();
+                if (success) {
+                  fulfill(success);
+                  return;
+                }
+                if (typeof polling !== "number")
+                  injected.utils.builtins.requestAnimationFrame(next);
+                else injected.utils.builtins.setTimeout(next, polling);
+              } catch (e) {
+                reject(e);
+              }
+            };
+            next();
+            return { result, abort: () => aborted = true };
+          },
+          { expression, isFunction, polling: options.pollingInterval, arg }
+        )
+      );
       try {
         return await progress.race(handle.evaluateHandle((h) => h.result));
       } catch (error) {
@@ -1338,7 +1767,14 @@ class Frame extends import_instrumentation.SdkObject {
         return result;
       return JSON.stringify(result);
     }`;
-    const handle = await this.waitForFunctionExpression(progress, expression, true, void 0, {}, "utility");
+    const handle = await this.waitForFunctionExpression(
+      progress,
+      expression,
+      true,
+      void 0,
+      {},
+      "utility"
+    );
     return JSON.parse(handle.rawValue());
   }
   async title() {
@@ -1346,16 +1782,19 @@ class Frame extends import_instrumentation.SdkObject {
     return context.evaluate(() => document.title);
   }
   async rafrafTimeout(progress, timeout) {
-    if (timeout === 0)
-      return;
+    if (timeout === 0) return;
     const context = await progress.race(this._utilityContext());
     await Promise.all([
       // wait for double raf
-      progress.race(context.evaluate(() => new Promise((x) => {
-        requestAnimationFrame(() => {
-          requestAnimationFrame(x);
-        });
-      }))),
+      progress.race(
+        context.evaluate(
+          () => new Promise((x) => {
+            requestAnimationFrame(() => {
+              requestAnimationFrame(x);
+            });
+          })
+        )
+      ),
       progress.wait(timeout)
     ]);
   }
@@ -1363,62 +1802,83 @@ class Frame extends import_instrumentation.SdkObject {
     this._stopNetworkIdleTimer();
     this._detachedScope.close(new Error("Frame was detached"));
     for (const data of this._contextData.values()) {
-      if (data.context)
-        data.context.contextDestroyed("Frame was detached");
+      if (data.context) data.context.contextDestroyed("Frame was detached");
       data.contextPromise.resolve({ destroyedReason: "Frame was detached" });
     }
-    if (this._parentFrame)
-      this._parentFrame._childFrames.delete(this);
+    if (this._parentFrame) this._parentFrame._childFrames.delete(this);
     this._parentFrame = null;
   }
   async _callOnElementOnceMatches(progress, selector, body, taskData, options, scope) {
     const callbackText = body.toString();
     progress.log(`waiting for ${this._asLocator(selector)}`);
-    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return continuePolling;
-      const { log, success, value } = await progress.race(resolved.injected.evaluate((injected, { info, callbackText: callbackText2, taskData: taskData2, callId, root }) => {
-        const callback = injected.eval(callbackText2);
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        if (!element)
-          return { success: false };
-        const log2 = `  locator resolved to ${injected.previewNode(element)}`;
-        if (callId)
-          injected.markTargetElements(/* @__PURE__ */ new Set([element]), callId);
-        return { log: log2, success: true, value: callback(injected, element, taskData2) };
-      }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : void 0 }));
-      if (log)
-        progress.log(log);
-      if (!success)
-        return continuePolling;
-      return value;
-    });
+    const promise = this.retryWithProgressAndTimeouts(
+      progress,
+      [0, 20, 50, 100, 100, 500],
+      async (continuePolling) => {
+        const resolved = await progress.race(
+          this.selectors.resolveInjectedForSelector(selector, options, scope)
+        );
+        if (!resolved) return continuePolling;
+        const { log, success, value } = await progress.race(
+          resolved.injected.evaluate(
+            (injected, { info, callbackText: callbackText2, taskData: taskData2, callId, root }) => {
+              const callback = injected.eval(callbackText2);
+              const element = injected.querySelector(
+                info.parsed,
+                root || document,
+                info.strict
+              );
+              if (!element) return { success: false };
+              const log2 = `  locator resolved to ${injected.previewNode(
+                element
+              )}`;
+              if (callId)
+                injected.markTargetElements(/* @__PURE__ */ new Set([element]), callId);
+              return {
+                log: log2,
+                success: true,
+                value: callback(injected, element, taskData2)
+              };
+            },
+            {
+              info: resolved.info,
+              callbackText,
+              taskData,
+              callId: progress.metadata.id,
+              root: resolved.frame === this ? scope : void 0
+            }
+          )
+        );
+        if (log) progress.log(log);
+        if (!success) return continuePolling;
+        return value;
+      }
+    );
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   _setContext(world, context) {
     const data = this._contextData.get(world);
     data.context = context;
-    if (context)
-      data.contextPromise.resolve(context);
-    else
-      data.contextPromise = new import_manualPromise.ManualPromise();
+    if (context) data.contextPromise.resolve(context);
+    else data.contextPromise = new import_manualPromise.ManualPromise();
   }
   _contextCreated(world, context) {
     const data = this._contextData.get(world);
     if (data.context) {
-      data.context.contextDestroyed("Execution context was destroyed, most likely because of a navigation");
+      data.context.contextDestroyed(
+        "Execution context was destroyed, most likely because of a navigation"
+      );
       this._setContext(world, null);
     }
     this._setContext(world, context);
   }
   _contextDestroyed(context) {
-    if (this._detachedScope.isClosed())
-      return;
-    context.contextDestroyed("Execution context was destroyed, most likely because of a navigation");
+    if (this._detachedScope.isClosed()) return;
+    context.contextDestroyed(
+      "Execution context was destroyed, most likely because of a navigation"
+    );
     for (const [world, data] of this._contextData) {
-      if (data.context === context)
-        this._setContext(world, null);
+      if (data.context === context) this._setContext(world, null);
     }
   }
   _startNetworkIdleTimer() {
@@ -1431,20 +1891,25 @@ class Frame extends import_instrumentation.SdkObject {
     }, 500);
   }
   _stopNetworkIdleTimer() {
-    if (this._networkIdleTimer)
-      clearTimeout(this._networkIdleTimer);
+    if (this._networkIdleTimer) clearTimeout(this._networkIdleTimer);
     this._networkIdleTimer = void 0;
     this._firedNetworkIdleSelf = false;
   }
   async extendInjectedScript(source, arg) {
     const context = await this._context("main");
     const injectedScriptHandle = await context.injectedScript();
-    await injectedScriptHandle.evaluate((injectedScript, { source: source2, arg: arg2 }) => {
-      injectedScript.extend(source2, arg2);
-    }, { source, arg });
+    await injectedScriptHandle.evaluate(
+      (injectedScript, { source: source2, arg: arg2 }) => {
+        injectedScript.extend(source2, arg2);
+      },
+      { source, arg }
+    );
   }
   _asLocator(selector) {
-    return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
+    return (0, import_utils.asLocator)(
+      this._page.browserContext._browser.sdkLanguage(),
+      selector
+    );
   }
 }
 class SignalBarrier {
@@ -1459,20 +1924,23 @@ class SignalBarrier {
     return this._progress.race(this._promise);
   }
   addFrameNavigation(frame) {
-    if (frame.parentFrame())
-      return;
+    if (frame.parentFrame()) return;
     this.retain();
-    const waiter = import_helper.helper.waitForEvent(this._progress, frame, Frame.Events.InternalNavigation, (e) => {
-      if (!e.isPublic)
-        return false;
-      if (!e.error && this._progress)
-        this._progress.log(`  navigated to "${frame._url}"`);
-      return true;
-    });
-    import_utils.LongStandingScope.raceMultiple([
-      frame._page.openScope,
-      frame._detachedScope
-    ], waiter.promise).catch(() => {
+    const waiter = import_helper.helper.waitForEvent(
+      this._progress,
+      frame,
+      Frame.Events.InternalNavigation,
+      (e) => {
+        if (!e.isPublic) return false;
+        if (!e.error && this._progress)
+          this._progress.log(`  navigated to "${frame._url}"`);
+        return true;
+      }
+    );
+    import_utils.LongStandingScope.raceMultiple(
+      [frame._page.openScope, frame._detachedScope],
+      waiter.promise
+    ).catch(() => {
     }).finally(() => {
       waiter.dispose();
       this.release();
@@ -1483,20 +1951,19 @@ class SignalBarrier {
   }
   release() {
     --this._protectCount;
-    if (!this._protectCount)
-      this._promise.resolve();
+    if (!this._protectCount) this._promise.resolve();
   }
 }
 function verifyLifecycle(name, waitUntil) {
-  if (waitUntil === "networkidle0")
-    waitUntil = "networkidle";
+  if (waitUntil === "networkidle0") waitUntil = "networkidle";
   if (!types.kLifecycleEvents.has(waitUntil))
-    throw new Error(`${name}: expected one of (load|domcontentloaded|networkidle|commit)`);
+    throw new Error(
+      `${name}: expected one of (load|domcontentloaded|networkidle|commit)`
+    );
   return waitUntil;
 }
 function renderUnexpectedValue(expression, received) {
-  if (expression === "to.match.aria")
-    return received ? received.raw : received;
+  if (expression === "to.match.aria") return received ? received.raw : received;
   return received;
 }
 // Annotate the CommonJS export names for ESM import in node: