patchright-core 1.58.2 → 1.59.1

package/lib/server/frames.js

@@ -33,8 +33,6 @@ __export(frames_exports, {
   NavigationAbortedError: () => NavigationAbortedError
 });
 module.exports = __toCommonJS(frames_exports);
-var import_crExecutionContext = require("./chromium/crExecutionContext");
-var import_dom = require("./dom");
 var import_browserContext = require("./browserContext");
 var dom = __toESM(require("./dom"));
 var import_errors = require("./errors");
@@ -49,7 +47,6 @@ var import_progress = require("./progress");
 var types = __toESM(require("./types"));
 var import_utils = require("../utils");
 var import_protocolError = require("./protocolError");
-var import_debugLogger = require("./utils/debugLogger");
 var import_eventsHelper = require("./utils/eventsHelper");
 var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
@@ -177,14 +174,11 @@ class FrameManager {
     } else {
       frame._currentDocument = { documentId, request: void 0 };
     }
-    frame._iframeWorld = void 0;
-    frame._mainWorld = void 0;
-    frame._isolatedWorld = void 0;
     frame._onClearLifecycle();
     const navigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
     this._fireInternalFrameNavigation(frame, navigationEvent);
     if (!initial) {
-      import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
+      frame.apiLog(`  navigated to "${url}"`);
       this._page.frameNavigatedToNewDocument(frame);
     }
     frame.setPendingDocument(keepPending);
@@ -200,7 +194,7 @@ class FrameManager {
     frame._url = url;
     const navigationEvent = { url, name: frame._name, isPublic: true };
     this._fireInternalFrameNavigation(frame, navigationEvent);
-    import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
+    frame.apiLog(`  navigated to "${url}"`);
   }
   frameAbortedNavigation(frameId, errorText, documentId) {
     const frame = this._frames.get(frameId);
@@ -403,7 +397,7 @@ class Frame extends import_instrumentation.SdkObject {
     this._firedLifecycleEvents.add(event);
     this.emit(Frame.Events.AddLifecycle, event);
     if (this === this._page.mainFrame() && this._url !== "about:blank")
-      import_debugLogger.debugLogger.log("api", `  "${event}" event fired`);
+      this.apiLog(`  "${event}" event fired`);
     this._page.mainFrame()._recalculateNetworkIdle();
   }
   _onClearLifecycle() {
@@ -457,11 +451,7 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   nonStallingEvaluateInExistingContext(expression, world) {
-    return this.raceAgainstEvaluationStallingEvents(async () => {
-      try {
-        await this._context(world);
-      } catch {
-      }
+    return this.raceAgainstEvaluationStallingEvents(() => {
       const context = this._contextData.get(world)?.context;
       if (!context)
         throw new Error("Frame does not yet have the execution context");
@@ -479,7 +469,7 @@ class Frame extends import_instrumentation.SdkObject {
       this._firedLifecycleEvents.add("networkidle");
       this.emit(Frame.Events.AddLifecycle, "networkidle");
       if (this === this._page.mainFrame() && this._url !== "about:blank")
-        import_debugLogger.debugLogger.log("api", `  "networkidle" event fired`);
+        this.apiLog(`  "networkidle" event fired`);
     }
     if (frameThatAllowsRemovingNetworkIdle !== this && this._firedLifecycleEvents.has("networkidle") && !isNetworkIdle) {
       this._firedLifecycleEvents.delete("networkidle");
@@ -587,74 +577,12 @@ class Frame extends import_instrumentation.SdkObject {
   async frameElement() {
     return this._page.delegate.getFrameElement(this);
   }
-  async _context(world) {
-    if (this.isDetached()) throw new Error("Frame was detached");
-    try {
-      var client = this._page.delegate._sessionForFrame(this)._client;
-    } catch (e) {
-      var client = this._page.delegate._mainFrameSession._client;
-    }
-    var iframeExecutionContextId = await this._getFrameMainFrameContextId(client);
-    if (world == "main") {
-      if (this != this._page.mainFrame() && iframeExecutionContextId && this._iframeWorld == void 0) {
-        var executionContextId = iframeExecutionContextId;
-        var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
-        this._iframeWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-        this._page.delegate._sessionForFrame(this)._onExecutionContextCreated({
-          id: executionContextId,
-          origin: world,
-          name: world,
-          auxData: { isDefault: this === this._page.mainFrame(), type: "isolated", frameId: this._id }
-        });
-      } else if (this._mainWorld == void 0) {
-        var globalThis2 = await client._sendMayFail("Runtime.evaluate", {
-          expression: "globalThis",
-          serializationOptions: { serialization: "idOnly" }
-        });
-        if (!globalThis2) {
-          if (this.isDetached()) throw new Error("Frame was detached");
-          return;
-        }
-        var globalThisObjId = globalThis2["result"]["objectId"];
-        var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
-        var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
-        this._mainWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-        this._page.delegate._sessionForFrame(this)._onExecutionContextCreated({
-          id: executionContextId,
-          origin: world,
-          name: world,
-          auxData: { isDefault: this === this._page.mainFrame(), type: "isolated", frameId: this._id }
-        });
-      }
-    }
-    if (world != "main" && this._isolatedWorld == void 0) {
-      world = "utility";
-      var result = await client._sendMayFail("Page.createIsolatedWorld", {
-        frameId: this._id,
-        grantUniveralAccess: true,
-        worldName: world
-      });
-      if (!result) {
-        if (this.isDetached()) throw new Error("Frame was detached");
-        return;
-      }
-      var executionContextId = result.executionContextId;
-      var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
-      this._isolatedWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-      this._page.delegate._sessionForFrame(this)._onExecutionContextCreated({
-        id: executionContextId,
-        origin: world,
-        name: world,
-        auxData: { isDefault: this === this._page.mainFrame(), type: "isolated", frameId: this._id }
-      });
-    }
-    if (world != "main") {
-      return this._isolatedWorld;
-    } else if (this != this._page.mainFrame() && this._iframeWorld) {
-      return this._iframeWorld;
-    } else {
-      return this._mainWorld;
-    }
+  _context(world) {
+    return this._contextData.get(world).contextPromise.then((contextOrDestroyedReason) => {
+      if (contextOrDestroyedReason instanceof js.ExecutionContext)
+        return contextOrDestroyedReason;
+      throw new Error(contextOrDestroyedReason.destroyedReason);
+    });
   }
   _mainContext() {
     return this._context("main");
@@ -666,23 +594,18 @@ class Frame extends import_instrumentation.SdkObject {
     return this._context("utility");
   }
   async evaluateExpression(expression, options = {}, arg) {
-    const context = await this._detachedScope.race(this._context(options.world ?? "main"));
-    const value = await this._detachedScope.race(context.evaluateExpression(expression, options, arg));
+    const context = await this._context(options.world ?? "main");
+    const value = await context.evaluateExpression(expression, options, arg);
     return value;
   }
   async evaluateExpressionHandle(expression, options = {}, arg) {
-    const context = await this._detachedScope.race(this._context(options.world ?? "utility"));
-    const value = await this._detachedScope.race(context.evaluateExpressionHandle(expression, options, arg));
+    const context = await this._context(options.world ?? "main");
+    const value = await context.evaluateExpressionHandle(expression, options, arg);
     return value;
   }
   async querySelector(selector, options) {
-    return this.querySelectorAll(selector, options).then((handles) => {
-      if (handles.length === 0)
-        return null;
-      if (handles.length > 1 && options?.strict)
-        throw new Error(`Strict mode: expected one element matching selector "${selector}", found ${handles.length}`);
-      return handles[0];
-    });
+    this.apiLog(`    finding element using the selector "${selector}"`);
+    return this.selectors.query(selector, options);
   }
   async waitForSelector(progress, selector, performActionPreChecksAndLog, options, scope) {
     if (options.visibility)
@@ -694,109 +617,77 @@ class Frame extends import_instrumentation.SdkObject {
       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._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: true, __patchrightWaitForSelector: true, __patchrightInitialScope: scope }, async (handle) => {
-      if (scope) {
-        const scopeIsConnected = await scope.evaluateInUtility(([injected, node]) => node.isConnected, {}).catch(() => false);
-        if (scopeIsConnected !== true) {
-          if (state === "hidden" || state === "detached")
-            return null;
-          throw new dom.NonRecoverableDOMError("Element is not attached to the DOM");
-        }
+    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 attached = !!handle;
-      var visible = false;
-      if (attached) {
-        if (handle.parentNode.constructor.name == "ElementHandle") {
-          visible = await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
-            return handle2 ? injected.utils.isElementVisible(handle2) : false;
-          }, { handle });
-        } else {
-          visible = await handle.parentNode.evaluate((injected, { handle: handle2 }) => {
-            return handle2 ? injected.utils.isElementVisible(handle2) : false;
-          }, { handle });
+      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)}`;
         }
+        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+        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;
       }
-      const success = {
-        attached,
-        detached: !attached,
-        visible,
-        hidden: !visible
-      }[state];
-      if (!success) return "internal:continuepolling";
-      if (options.omitReturnValue) return null;
-      const element = state === "attached" || state === "visible" ? handle : null;
-      if (!element) return null;
-      if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
+      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 {
-        return element;
+        const mainContext = await progress.race(resolved.frame._mainContext());
+        return await progress.race(element._adoptTo(mainContext));
       } catch (e) {
-        return "internal:continuepolling";
+        return continuePolling;
       }
-    }, "returnOnNotResolved");
-    const resultPromise = scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
-    return resultPromise.catch((e) => {
-      if (this.isDetached() && e?.message?.includes("Execution context was destroyed"))
-        throw new Error("Frame was detached");
-      throw e;
     });
+    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   async dispatchEvent(progress, selector, type, eventInit = {}, options, scope) {
-    const eventInitHandles = [];
-    const visited = /* @__PURE__ */ new WeakSet();
-    const collectHandles = (value) => {
-      if (!value || typeof value !== "object")
-        return;
-      if (value instanceof js.JSHandle) {
-        eventInitHandles.push(value);
-        return;
-      }
-      if (visited.has(value))
-        return;
-      visited.add(value);
-      if (Array.isArray(value)) {
-        for (const item of value)
-          collectHandles(item);
-        return;
-      }
-      for (const propertyValue of Object.values(value))
-        collectHandles(propertyValue);
-    };
-    collectHandles(eventInit);
-    const allHandlesFromSameFrame = eventInitHandles.length > 0 && eventInitHandles.every((handle) => handle._context?.frame === eventInitHandles[0]?._context?.frame);
-    const handlesFrame = eventInitHandles[0]?._context?.frame;
-    const canRetryInSecondaryContext = allHandlesFromSameFrame && (handlesFrame !== this || !selector.includes("internal:control=enter-frame"));
-    const callback = (injectedScript, element, data) => {
+    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
       injectedScript.dispatchEvent(element, data.type, data.eventInit);
-    };
-    try {
-      await this._callOnElementOnceMatches(progress, selector, callback, { type, eventInit }, { mainWorld: true, ...options }, scope);
-    } catch (e) {
-      if ("JSHandles can be evaluated only in the context they were created!" === e.message && canRetryInSecondaryContext) {
-        await this._callOnElementOnceMatches(progress, selector, callback, { type, eventInit }, { ...options }, scope);
-        return;
-      }
-      throw e;
-    }
+    }, { 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, true);
+      throw new Error(`Failed to find element matching selector "${selector}"`);
+    const result = await handle.evaluateExpression(expression, { isFunction }, arg);
     handle.dispose();
     return result;
   }
-  async evalOnSelectorAll(selector, expression, isFunction, arg, scope, isolatedContext) {
-    try {
-      isolatedContext = this.selectors._parseSelector(selector, { strict: false }).world !== "main" && isolatedContext;
-      const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope, isolatedContext);
-      const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg, isolatedContext);
-      arrayHandle.dispose();
-      return result;
-    } catch (e) {
-      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return await this.evalOnSelectorAll(selector, expression, isFunction, arg, scope, isolatedContext);
-      throw e;
-    }
+  async evalOnSelectorAll(selector, expression, isFunction, arg, scope) {
+    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();
@@ -806,30 +697,16 @@ class Frame extends import_instrumentation.SdkObject {
     }, { parsed: selectors, color });
   }
   async querySelectorAll(selector) {
-    const metadata = { internal: false, log: [], method: "querySelectorAll" };
-    const progress = {
-      log: (message) => metadata.log.push(message),
-      metadata,
-      race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
-    };
-    return await this._retryWithoutProgress(progress, selector, { strict: null, performActionPreChecks: false }, async (result) => {
-      if (!result || !result[0]) return [];
-      return result[1];
-    }, "returnAll", null);
+    return this.selectors.queryAll(selector);
   }
   async queryCount(selector, options) {
-    const metadata = { internal: false, log: [], method: "queryCount" };
-    const progress = {
-      log: (message) => metadata.log.push(message),
-      metadata,
-      race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
-    };
-    return await this._retryWithoutProgress(progress, selector, { strict: null, performActionPreChecks: false }, async (result) => {
-      if (!result) return 0;
-      const handle = result[0];
-      const handles = result[1];
-      return handle ? handles.length : 0;
-    }, "returnAll", null);
+    try {
+      return await this.selectors.queryCount(selector, options);
+    } catch (e) {
+      if (this.isNonRetriableError(e))
+        throw e;
+      return 0;
+    }
   }
   async content() {
     try {
@@ -849,19 +726,27 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async setContent(progress, html, options) {
+    const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
     await this.raceNavigationAction(progress, async () => {
       const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
       progress.log(`setting frame content, waiting until "${waitUntil}"`);
-      const lifecyclePromise = new Promise((resolve, reject) => {
+      const context = await progress.race(this._utilityContext());
+      const tagPromise = new import_manualPromise.ManualPromise();
+      this._page.frameManager._consoleMessageTags.set(tag, () => {
         this._onClearLifecycle();
-        this.waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
-      });
-      const setContentPromise = this._page.delegate._sessionForFrame(this)._client.send("Page.setDocumentContent", {
-        frameId: this._id,
-        html
+        tagPromise.resolve();
       });
-      await Promise.all([setContentPromise, lifecyclePromise]);
+      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 }));
+      await Promise.all([contentPromise, lifecyclePromise]);
       return null;
+    }).finally(() => {
+      this._page.frameManager._consoleMessageTags.delete(tag);
     });
   }
   name() {
@@ -1021,11 +906,58 @@ class Frame extends import_instrumentation.SdkObject {
       return true;
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, options, action, returnAction) {
-    if (!options?.__patchrightSkipRetryLogWaiting)
-      progress.log("waiting for " + this._asLocator(selector));
+  async _retryWithProgressIfNotConnected(progress, selector, options, action) {
+    progress.log(`waiting for ${this._asLocator(selector)}`);
+    const noAutoWaiting = options.__testHookNoAutoWaiting ?? options.noAutoWaiting;
+    const performActionPreChecks = (options.performActionPreChecks ?? !options.force) && !noAutoWaiting;
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      return this._retryWithoutProgress(progress, selector, options, action, returnAction, continuePolling);
+      if (performActionPreChecks)
+        await this._page.performActionPreChecks(progress);
+      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }));
+      if (!resolved) {
+        if (noAutoWaiting)
+          throw new dom.NonRecoverableDOMError("Element(s) not found");
+        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)}`;
+        }
+        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+        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) {
+        if (noAutoWaiting)
+          throw new dom.NonRecoverableDOMError("Element(s) not found");
+        result.dispose();
+        return continuePolling;
+      }
+      const element = await progress.race(result.evaluateHandle((r) => r.element));
+      result.dispose();
+      try {
+        const result2 = await action(element);
+        if (result2 === "error:notconnected") {
+          if (noAutoWaiting)
+            throw new dom.NonRecoverableDOMError("Element is not attached to the DOM");
+          progress.log("element was detached from the DOM, retrying");
+          return continuePolling;
+        }
+        return result2;
+      } finally {
+        element?.dispose();
+      }
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
@@ -1158,56 +1090,17 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async isVisibleInternal(progress, selector, options = {}, scope) {
     try {
-      const metadata = { internal: false, log: [], method: "isVisible" };
-      const progress2 = {
-        log: (message) => metadata.log.push(message),
-        metadata,
-        race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
-      };
-      progress2.log("waiting for " + this._asLocator(selector));
-      if (selector === ":scope") {
-        const scopeParentNode = scope.parentNode || scope;
-        if (scopeParentNode.constructor.name == "ElementHandle") {
-          return await scopeParentNode.evaluateInUtility(([injected, node, { scope: handle2 }]) => {
-            const state = handle2 ? injected.elementState(handle2, "visible") : {
-              matches: false,
-              received: "error:notconnected"
-            };
-            return state.matches;
-          }, { scope });
-        } else {
-          return await scopeParentNode.evaluate((injected, node, { scope: handle2 }) => {
-            const state = handle2 ? injected.elementState(handle2, "visible") : {
-              matches: false,
-              received: "error:notconnected"
-            };
-            return state.matches;
-          }, { scope });
-        }
-      } else {
-        return await this._retryWithoutProgress(progress2, selector, { ...options, performActionPreChecks: false }, async (handle) => {
-          if (!handle) return false;
-          if (handle.parentNode.constructor.name == "ElementHandle") {
-            return await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
-              const state = handle2 ? injected.elementState(handle2, "visible") : {
-                matches: false,
-                received: "error:notconnected"
-              };
-              return state.matches;
-            }, { handle });
-          } else {
-            return await handle.parentNode.evaluate((injected, { handle: handle2 }) => {
-              const state = handle2 ? injected.elementState(handle2, "visible") : {
-                matches: false,
-                received: "error:notconnected"
-              };
-              return state.matches;
-            }, { handle });
-          }
-        }, "returnOnNotResolved", null);
-      }
+      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;
     }
   }
@@ -1251,9 +1144,6 @@ class Frame extends import_instrumentation.SdkObject {
   async waitForTimeout(progress, timeout) {
     return progress.wait(timeout);
   }
-  async ariaSnapshot(progress, selector) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: true }, (handle) => progress.race(handle.ariaSnapshot()));
-  }
   async expect(progress, selector, options) {
     progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeoutForLogs ? ` with timeout ${options.timeoutForLogs}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
@@ -1303,63 +1193,27 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async _expectInternal(progress, selector, options, lastIntermediateResult, noAbort) {
     const race = (p) => noAbort ? p : progress.race(p);
-    const isArray = options.expression === "to.have.count" || options.expression.endsWith(".array");
-    var log, matches, received, missingReceived;
-    if (selector) {
-      var frame, info;
-      try {
-        var { frame, info } = await race(this.selectors.resolveFrameForSelector(selector, { strict: true }));
-      } catch (e) {
-      }
-      const action = async (result) => {
-        if (!result) {
-          if (options.expectedNumber === 0)
-            return { matches: true };
-          if (options.isNot && options.expectedNumber)
-            return { matches: false, received: 0 };
-          if (!options.isNot && options.expression === "to.be.hidden")
-            return { matches: true };
-          if (options.isNot && options.expression === "to.be.visible")
-            return { matches: false };
-          if (!options.isNot && options.expression === "to.be.detached")
-            return { matches: true };
-          if (options.isNot && options.expression === "to.be.attached")
-            return { matches: false };
-          if (options.isNot && options.expression === "to.be.in.viewport")
-            return { matches: false };
-          if (options.expression === "to.have.text.array") {
-            if (options.expectedText.length === 0)
-              return { matches: true, received: [] };
-            if (options.isNot && options.expectedText.length !== 0)
-              return { matches: false, received: [] };
-          }
-          return { matches: options.isNot, missingReceived: true };
-        }
-        const handle = result[0];
-        const handles = result[1];
-        if (handle.parentNode.constructor.name == "ElementHandle") {
-          return await handle.parentNode.evaluateInUtility(async ([injected, node, { handle: handle2, options: options2, handles: handles2 }]) => {
-            return await injected.expect(handle2, options2, handles2);
-          }, { handle, options, handles });
-        } else {
-          return await handle.parentNode.evaluate(async (injected, { handle: handle2, options: options2, handles: handles2 }) => {
-            return await injected.expect(handle2, options2, handles2);
-          }, { handle, options, handles });
-        }
-      };
-      if (noAbort) {
-        var { log, matches, received, missingReceived } = await this._retryWithoutProgress(progress, selector, { strict: !isArray, performActionPreChecks: false }, action, "returnAll", null);
-      } else {
-        var { log, matches, received, missingReceived } = await race(this._retryWithProgressIfNotConnected(progress, selector, { strict: !isArray, performActionPreChecks: false, __patchrightSkipRetryLogWaiting: true }, action, "returnAll"));
-      }
-    } else {
-      const world = options.expression === "to.have.property" ? "main" : "utility";
-      const context = await race(this._context(world));
-      const injected = await race(context.injectedScript());
-      var { matches, received, missingReceived } = await race(injected.evaluate(async (injected2, { options: options2, callId }) => {
-        return { ...await injected2.expect(void 0, options2, []) };
-      }, { options, callId: progress.metadata.id }));
-    }
+    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])}`;
+      if (info2)
+        injected2.checkDeprecatedSelectorUsage(info2.parsed, elements);
+      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) {
@@ -1370,11 +1224,8 @@ class Frame extends import_instrumentation.SdkObject {
         lastIntermediateResult.received = received;
       }
       lastIntermediateResult.isSet = true;
-      if (!missingReceived) {
-        const rendered = renderUnexpectedValue(options.expression, received);
-        if (rendered !== void 0)
-          progress.log('  unexpected value "' + rendered + '"');
-      }
+      if (!missingReceived && !Array.isArray(received))
+        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
     }
     return { matches, received };
   }
@@ -1430,7 +1281,7 @@ class Frame extends import_instrumentation.SdkObject {
         return { result, abort: () => aborted = true };
       }, { expression, isFunction, polling: options.pollingInterval, arg }));
       try {
-        return await progress.race(this._detachedScope.race(handle.evaluateHandle((h) => h.result)));
+        return await progress.race(handle.evaluateHandle((h) => h.result));
       } catch (error) {
         await handle.evaluate((h) => h.abort()).catch(() => {
         });
@@ -1451,8 +1302,17 @@ class Frame extends import_instrumentation.SdkObject {
     return JSON.parse(handle.rawValue());
   }
   async title() {
-    const context = await this._utilityContext();
-    return context.evaluate(() => document.title);
+    try {
+      return await this.raceAgainstEvaluationStallingEvents(async () => {
+        const context = await this._utilityContext();
+        return await context.evaluate(() => document.title);
+      });
+    } catch {
+      const url = this.pendingDocument()?.request?.url();
+      if (url)
+        return `Loading ${url}`;
+      return "";
+    }
   }
   async rafrafTimeout(progress, timeout) {
     if (timeout === 0)
@@ -1476,112 +1336,33 @@ class Frame extends import_instrumentation.SdkObject {
         data.context.contextDestroyed("Frame was detached");
       data.contextPromise.resolve({ destroyedReason: "Frame was detached" });
     }
-    if (this._mainWorld)
-      this._mainWorld.contextDestroyed("Frame was detached");
-    if (this._iframeWorld)
-      this._iframeWorld.contextDestroyed("Frame was detached");
-    if (this._isolatedWorld)
-      this._isolatedWorld.contextDestroyed("Frame was detached");
     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));
-    var promise;
-    if (selector === ":scope") {
-      const scopeParentNode = scope.parentNode || scope;
-      if (scopeParentNode.constructor.name == "ElementHandle") {
-        if (options?.mainWorld) {
-          promise = (async () => {
-            const mainContext = await this._mainContext();
-            const adoptedScope = await this._page.delegate.adoptElementHandle(scope, mainContext);
-            try {
-              return await mainContext.evaluate(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
-                const callback = injected.eval(callbackText2);
-                return callback(injected, handle2, taskData2);
-              }, [
-                await mainContext.injectedScript(),
-                adoptedScope,
-                { callbackText, scope: adoptedScope, taskData }
-              ]);
-            } finally {
-              adoptedScope.dispose();
-            }
-          })();
-        } else {
-          promise = scopeParentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
-            const callback = injected.eval(callbackText2);
-            return callback(injected, handle2, taskData2);
-          }, {
-            callbackText,
-            scope,
-            taskData
-          });
-        }
-      } else {
-        promise = scopeParentNode.evaluate((injected, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }) => {
-          const callback = injected.eval(callbackText2);
-          return callback(injected, handle2, taskData2);
-        }, {
-          callbackText,
-          scope,
-          taskData
-        });
-      }
-    } else {
-      promise = this._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: false }, async (handle) => {
-        if (handle.parentNode.constructor.name == "ElementHandle") {
-          if (options?.mainWorld) {
-            const mainContext = await handle._frame._mainContext();
-            const adoptedHandle = await this._page.delegate.adoptElementHandle(handle, mainContext);
-            try {
-              return await mainContext.evaluate(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
-                const callback = injected.eval(callbackText2);
-                return callback(injected, handle2, taskData2);
-              }, [
-                await mainContext.injectedScript(),
-                adoptedHandle,
-                { callbackText, handle: adoptedHandle, taskData }
-              ]);
-            } finally {
-              adoptedHandle.dispose();
-            }
-          }
-          const [taskScope] = Object.values(taskData?.eventInit ?? {});
-          if (taskScope) {
-            const taskScopeContext = taskScope._context;
-            const adoptedHandle = await handle._adoptTo(taskScopeContext);
-            return await taskScopeContext.evaluate(([injected, node, { callbackText: callbackText2, adoptedHandle: handle2, taskData: taskData2 }]) => {
-              const callback = injected.eval(callbackText2);
-              return callback(injected, handle2, taskData2);
-            }, [
-              await taskScopeContext.injectedScript(),
-              adoptedHandle,
-              { callbackText, adoptedHandle, taskData }
-            ]);
-          }
-          return await handle.parentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
-            const callback = injected.eval(callbackText2);
-            return callback(injected, handle2, taskData2);
-          }, {
-            callbackText,
-            handle,
-            taskData
-          });
-        } else {
-          return await handle.parentNode.evaluate((injected, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }) => {
-            const callback = injected.eval(callbackText2);
-            return callback(injected, handle2, taskData2);
-          }, {
-            callbackText,
-            handle,
-            taskData
-          });
-        }
-      });
-    }
+    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;
+    });
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   _setContext(world, context) {
@@ -1631,266 +1412,32 @@ class Frame extends import_instrumentation.SdkObject {
       injectedScript.extend(source2, arg2);
     }, { source, arg });
   }
-  _asLocator(selector) {
-    return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
-  }
-  async _getFrameMainFrameContextId(client) {
-    try {
-      var globalDocument = await client._sendMayFail("DOM.getFrameOwner", { frameId: this._id });
-      if (globalDocument && globalDocument.nodeId) {
-        var describedNode = await client._sendMayFail("DOM.describeNode", {
-          backendNodeId: globalDocument.backendNodeId
-        });
-        if (describedNode && describedNode.node.contentDocument) {
-          var resolvedNode = await client._sendMayFail("DOM.resolveNode", {
-            backendNodeId: describedNode.node.contentDocument.backendNodeId
-          });
-          if (resolvedNode && resolvedNode.object && resolvedNode.object.objectId) {
-            var _executionContextId = parseInt(resolvedNode.object.objectId.split(".")[1], 10);
-            return _executionContextId;
-          }
-        }
-      }
-    } catch (e) {
-    }
-    return 0;
-  }
-  async _retryWithoutProgress(progress, selector, options, action, returnAction, continuePolling) {
-    if (options.performActionPreChecks) await this._page.performActionPreChecks(progress);
-    const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }, options.__patchrightInitialScope);
-    if (!resolved) {
-      if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
-        const result2 = await action(null);
-        return result2 === "internal:continuepolling" ? continuePolling : result2;
-      }
-      return continuePolling;
-    }
-    try {
-      var client = this._page.delegate._sessionForFrame(resolved.frame)._client;
-    } catch (e) {
-      var client = this._page.delegate._mainFrameSession._client;
-    }
-    var utilityContext = await resolved.frame._utilityContext();
-    var mainContext = await resolved.frame._mainContext();
-    const documentNode = await client._sendMayFail("Runtime.evaluate", {
-      expression: "document",
-      serializationOptions: {
-        serialization: "idOnly"
-      },
-      contextId: utilityContext.delegate._contextId
-    });
-    if (!documentNode) return continuePolling;
-    let documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
-    let initialScope = documentScope;
-    if (resolved.scope) {
-      const scopeBackendNodeId = resolved.scope._objectId ? (await client._sendMayFail("DOM.describeNode", { objectId: resolved.scope._objectId }))?.node?.backendNodeId : null;
-      if (scopeBackendNodeId) {
-        const scopeInUtility = await client._sendMayFail("DOM.resolveNode", { backendNodeId: scopeBackendNodeId, executionContextId: utilityContext.delegate._contextId });
-        if (scopeInUtility?.object?.objectId)
-          initialScope = new dom.ElementHandle(utilityContext, scopeInUtility.object.objectId);
-      }
-    }
-    progress.__patchrightInitialScope = resolved.scope;
-    const parsedSnapshot = options.__patchrightWaitForSelector ? JSON.parse(JSON.stringify(resolved.info.parsed)) : null;
-    let currentScopingElements;
-    try {
-      currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, initialScope, progress, resolved.info.parsed);
-    } catch (e) {
-      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling;
-      if (e instanceof TypeError && e.message.includes("is not a function")) return continuePolling;
-      await progress.race(resolved.injected.evaluateHandle((injected, { error }) => {
-        throw error;
-      }, { error: e }));
-    }
-    if (currentScopingElements.length == 0) {
-      if (options.__testHookNoAutoWaiting || options.noAutoWaiting)
-        throw new dom.NonRecoverableDOMError("Element(s) not found");
-      if (parsedSnapshot && (returnAction === "returnOnNotResolved" || returnAction === "returnAll")) {
-        const elementCount = await resolved.injected.evaluate((injected, { parsed }) => {
-          return injected.querySelectorAll(parsed, document).length;
-        }, { parsed: parsedSnapshot }).catch(() => 0);
-        if (elementCount > 0)
-          return continuePolling;
-      }
-      if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
-        const result2 = await action(null);
-        return result2 === "internal:continuepolling" ? continuePolling : result2;
-      }
-      return continuePolling;
-    }
-    const resultElement = currentScopingElements[0];
-    await resultElement._initializePreview().catch(() => {
-    });
-    let visibilityQualifier = "";
-    if (options && options.__patchrightWaitForSelector) {
-      visibilityQualifier = await resultElement.evaluateInUtility(([injected, node]) => injected.utils.isElementVisible(node) ? "visible" : "hidden", {}).catch(() => "");
-    }
-    if (currentScopingElements.length > 1) {
-      if (resolved.info.strict) {
-        await progress.race(resolved.injected.evaluateHandle((injected, {
-          info,
-          elements
-        }) => {
-          throw injected.strictModeViolationError(info.parsed, elements);
-        }, {
-          info: resolved.info,
-          elements: currentScopingElements
-        }));
-      }
-      progress.log("  locator resolved to " + currentScopingElements.length + " elements. Proceeding with the first one: " + resultElement.preview());
-    } else if (resultElement) {
-      progress.log("  locator resolved to " + (visibilityQualifier ? visibilityQualifier + " " : "") + resultElement.preview().replace("JSHandle@", ""));
+  async ariaSnapshot(progress, options = {}) {
+    if (options.selector && options.track)
+      throw new Error("Cannot specify both selector and track options");
+    if (options.selector && options.mode !== "ai") {
+      const snapshot2 = await this._retryWithProgressIfNotConnected(progress, options.selector, { strict: true, performActionPreChecks: true }, async (handle) => {
+        return await progress.race(handle.evaluateInUtility(([injected, element, opts]) => injected.ariaSnapshot(element, opts), { mode: "default", depth: options.depth }));
+      });
+      return { snapshot: snapshot2 };
     }
-    try {
-      var result = null;
-      if (returnAction === "returnAll") {
-        result = await action([resultElement, currentScopingElements]);
-      } else {
-        result = await action(resultElement);
-      }
-      if (result === "error:notconnected") {
-        progress.log("element was detached from the DOM, retrying");
-        return continuePolling;
-      } else if (result === "internal:continuepolling") {
-        return continuePolling;
-      }
-      if (parsedSnapshot && result === null && (options.state === "hidden" || options.state === "detached")) {
-        const visibleCount = await resolved.injected.evaluate((injected, { parsed }) => {
-          const elements = injected.querySelectorAll(parsed, document);
-          return elements.filter((e) => injected.utils.isElementVisible(e)).length;
-        }, { parsed: parsedSnapshot }).catch(() => 0);
-        if (visibleCount > 0)
-          return continuePolling;
-      }
-      return result;
-    } finally {
+    let targetFrame;
+    let info;
+    if (options.selector) {
+      const resolved = await this.selectors.resolveInjectedForSelector(options.selector, { strict: true });
+      if (!resolved)
+        throw new Error(`Selector "${options.selector}" did not resolve to any element`);
+      targetFrame = resolved.frame;
+      info = resolved.info;
+    } else {
+      targetFrame = this;
     }
+    const result = await (0, import_page.ariaSnapshotForFrame)(progress, targetFrame, { ...options, info });
+    const snapshot = options.track && result.incremental ? result.incremental.join("\n") : result.full.join("\n");
+    return { snapshot };
   }
-  async _customFindElementsByParsed(resolved, client, context, documentScope, progress, parsed) {
-    var parsedEdits = { ...parsed };
-    var currentScopingElements = [documentScope];
-    while (parsed.parts.length > 0) {
-      var part = parsed.parts.shift();
-      parsedEdits.parts = [part];
-      var elements = [];
-      var elementsIndexes = [];
-      if (part.name == "nth") {
-        const partNth = Number(part.body);
-        if (currentScopingElements.length == 0) return [];
-        if (partNth > currentScopingElements.length - 1 || partNth < -(currentScopingElements.length - 1)) {
-          if (parsed.capture !== void 0) throw new Error("Can't query n-th element in a request with the capture.");
-          return [];
-        } else {
-          currentScopingElements = [currentScopingElements.at(partNth)];
-          continue;
-        }
-      } else if (part.name == "internal:or") {
-        var orredElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
-        elements = currentScopingElements.concat(orredElements);
-      } else if (part.name == "internal:and") {
-        var andedElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
-        const backendNodeIds = new Set(andedElements.map((item) => item.backendNodeId));
-        elements = currentScopingElements.filter((item) => backendNodeIds.has(item.backendNodeId));
-      } else {
-        for (const scope of currentScopingElements) {
-          let findClosedShadowRoots2 = function(node, results = []) {
-            if (!node || typeof node !== "object") return results;
-            if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
-              for (const shadowRoot2 of node.shadowRoots) {
-                if (shadowRoot2.shadowRootType === "closed" && shadowRoot2.backendNodeId) {
-                  results.push(shadowRoot2.backendNodeId);
-                }
-                findClosedShadowRoots2(shadowRoot2, results);
-              }
-            }
-            if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
-              for (const child of node.children) {
-                findClosedShadowRoots2(child, results);
-              }
-            }
-            return results;
-          };
-          var findClosedShadowRoots = findClosedShadowRoots2;
-          const describedScope = await client.send("DOM.describeNode", {
-            objectId: scope._objectId,
-            depth: -1,
-            pierce: true
-          });
-          var queryingElements = [];
-          var shadowRootBackendIds = findClosedShadowRoots2(describedScope.node);
-          var shadowRoots = [];
-          for (var shadowRootBackendId of shadowRootBackendIds) {
-            var resolvedShadowRoot = await client.send("DOM.resolveNode", {
-              backendNodeId: shadowRootBackendId,
-              contextId: context.delegate._contextId
-            });
-            shadowRoots.push(new dom.ElementHandle(context, resolvedShadowRoot.object.objectId));
-          }
-          for (var shadowRoot of shadowRoots) {
-            const shadowElements = await shadowRoot.evaluateHandleInUtility(([injected, node, { parsed: parsed2, callId }]) => {
-              const elements2 = injected.querySelectorAll(parsed2, node);
-              if (callId) injected.markTargetElements(new Set(elements2), callId);
-              return elements2;
-            }, {
-              parsed: parsedEdits,
-              callId: progress.metadata.id
-            });
-            const shadowElementsAmount = await shadowElements.getProperty("length");
-            queryingElements.push([shadowElements, shadowElementsAmount, shadowRoot]);
-          }
-          const rootElements = await scope.evaluateHandleInUtility(([injected, node, { parsed: parsed2, callId }]) => {
-            const elements2 = injected.querySelectorAll(parsed2, node);
-            if (callId) injected.markTargetElements(new Set(elements2), callId);
-            return elements2;
-          }, {
-            parsed: parsedEdits,
-            callId: progress.metadata.id
-          });
-          const rootElementsAmount = await rootElements.getProperty("length");
-          queryingElements.push([rootElements, rootElementsAmount, scope]);
-          for (var queryedElement of queryingElements) {
-            var elementsToCheck = queryedElement[0];
-            var elementsAmount = await queryedElement[1].jsonValue();
-            var parentNode = queryedElement[2];
-            for (var i = 0; i < elementsAmount; i++) {
-              if (parentNode.constructor.name == "ElementHandle") {
-                var elementToCheck = await parentNode.evaluateHandleInUtility(([injected, node, { index, elementsToCheck: elementsToCheck2 }]) => {
-                  return elementsToCheck2[index];
-                }, { index: i, elementsToCheck });
-              } else {
-                var elementToCheck = await parentNode.evaluateHandle((injected, { index, elementsToCheck: elementsToCheck2 }) => {
-                  return elementsToCheck2[index];
-                }, { index: i, elementsToCheck });
-              }
-              elementToCheck.parentNode = parentNode;
-              var resolvedElement = await client.send("DOM.describeNode", {
-                objectId: elementToCheck._objectId,
-                depth: -1
-              });
-              elementToCheck.backendNodeId = resolvedElement.node.backendNodeId;
-              elementToCheck.nodePosition = this.selectors._findElementPositionInDomTree(elementToCheck, describedScope.node, context, "");
-              elements.push(elementToCheck);
-            }
-          }
-        }
-      }
-      const getParts = (pos) => (pos || "").split(".").filter(Boolean).map(Number);
-      elements.sort((a, b) => {
-        const partA = getParts(a.nodePosition);
-        const partB = getParts(b.nodePosition);
-        const maxLength = Math.max(partA.length, partB.length);
-        for (let i2 = 0; i2 < maxLength; i2++) {
-          const aVal = partA[i2] ?? -1;
-          const bVal = partB[i2] ?? -1;
-          if (aVal !== bVal) return aVal - bVal;
-        }
-        return 0;
-      });
-      currentScopingElements = Array.from(
-        new Map(elements.map((e) => [e.backendNodeId, e])).values()
-      );
-    }
-    return currentScopingElements;
+  _asLocator(selector) {
+    return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
   }
 }
 class SignalBarrier {