patchright-core 1.57.0 → 1.59.0

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");
@@ -181,7 +178,7 @@ class FrameManager {
     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);
@@ -197,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);
@@ -352,6 +349,11 @@ class FrameManager {
     frame.emit(Frame.Events.InternalNavigation, event);
   }
 }
+const FrameEvent = {
+  InternalNavigation: "internalnavigation",
+  AddLifecycle: "addlifecycle",
+  RemoveLifecycle: "removelifecycle"
+};
 class Frame extends import_instrumentation.SdkObject {
   constructor(page, id, parentFrame) {
     super(page, "frame");
@@ -384,11 +386,7 @@ class Frame extends import_instrumentation.SdkObject {
       this._startNetworkIdleTimer();
   }
   static {
-    this.Events = {
-      InternalNavigation: "internalnavigation",
-      AddLifecycle: "addlifecycle",
-      RemoveLifecycle: "removelifecycle"
-    };
+    this.Events = FrameEvent;
   }
   isDetached() {
     return this._detachedScope.isClosed();
@@ -399,13 +397,10 @@ 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() {
-    this._isolatedWorld = void 0;
-    this._mainWorld = void 0;
-    this._iframeWorld = void 0;
     for (const event of this._firedLifecycleEvents)
       this.emit(Frame.Events.RemoveLifecycle, event);
     this._firedLifecycleEvents.clear();
@@ -474,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");
@@ -574,7 +569,7 @@ class Frame extends import_instrumentation.SdkObject {
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
     return request ? progress.race(request._finalRequest().response()) : null;
   }
-  async _waitForLoadState(progress, state) {
+  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;
@@ -582,72 +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._mainFrameSession._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) {
-          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._mainFrameSession._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) {
-        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._mainFrameSession._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() && iframeExecutionContextId) {
-      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");
@@ -664,18 +599,13 @@ class Frame extends import_instrumentation.SdkObject {
     return value;
   }
   async evaluateExpressionHandle(expression, options = {}, arg) {
-    const context = await this._context(options.world ?? "utility");
+    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)
@@ -687,37 +617,57 @@ 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.strict, true, async (handle) => {
-      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 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)}`;
         }
+        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;
+      }
+      if (options.omitReturnValue) {
+        result.dispose();
+        return null;
       }
-      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();
+      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");
+    });
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   async dispatchEvent(progress, selector, type, eventInit = {}, options, scope) {
@@ -728,22 +678,16 @@ class Frame extends import_instrumentation.SdkObject {
   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();
@@ -753,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, null, 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, null, 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 {
@@ -796,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._mainFrameSession._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() {
@@ -968,26 +906,74 @@ class Frame extends import_instrumentation.SdkObject {
       return true;
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action, returnAction) {
-    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, strict, performActionPreChecks, 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) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: 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._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
   }
   async dblclick(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._dblclick(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._dblclick(progress, options)));
   }
   async dragAndDrop(progress, source, target, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options, async (handle) => {
       return handle._retryPointerAction(progress, "move and down", false, async (point) => {
         await this._page.mouse.move(progress, point.x, point.y);
         await this._page.mouse.down(progress);
@@ -997,7 +983,7 @@ class Frame extends import_instrumentation.SdkObject {
         position: options.sourcePosition
       });
     }));
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, { ...options, performActionPreChecks: false }, async (handle) => {
       return handle._retryPointerAction(progress, "move and up", false, async (point) => {
         await this._page.mouse.move(progress, point.x, point.y, { steps: options.steps });
         await this._page.mouse.up(progress);
@@ -1011,16 +997,16 @@ class Frame extends import_instrumentation.SdkObject {
   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._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._tap(progress, options)));
   }
   async fill(progress, selector, value, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._fill(progress, value, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._fill(progress, value, options)));
   }
   async focus(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._focus(progress)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._focus(progress)));
   }
   async blur(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._blur(progress)));
   }
   async resolveSelector(progress, selector, options = {}) {
     const element = await progress.race(this.selectors.query(selector, options));
@@ -1104,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.strict, 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;
     }
   }
@@ -1173,35 +1120,32 @@ class Frame extends import_instrumentation.SdkObject {
     return this._elementState(progress, selector, "checked", options, scope);
   }
   async hover(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._hover(progress, options)));
   }
   async selectOption(progress, selector, elements, values, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._selectOption(progress, elements, values, options));
+    return await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._selectOption(progress, elements, values, options));
   }
   async setInputFiles(progress, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params, (handle) => handle._setInputFiles(progress, inputFileItems)));
   }
   async type(progress, selector, text, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._type(progress, text, options)));
   }
   async press(progress, selector, key, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._press(progress, key, options)));
   }
   async check(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, true, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._setChecked(progress, true, options)));
   }
   async uncheck(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, false, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._setChecked(progress, false, options)));
   }
   async waitForTimeout(progress, timeout) {
     return progress.wait(timeout);
   }
-  async ariaSnapshot(progress, selector) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => progress.race(handle.ariaSnapshot()));
-  }
-  async expect(progress, selector, options, timeout) {
-    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
+  async expect(progress, selector, options) {
+    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeoutForLogs ? ` with timeout ${options.timeoutForLogs}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
     const fixupMetadataError = (result) => {
       if (result.matches === options.isNot)
@@ -1210,17 +1154,19 @@ class Frame extends import_instrumentation.SdkObject {
     try {
       if (selector)
         progress.log(`waiting for ${this._asLocator(selector)}`);
-      await this._page.performActionPreChecks(progress);
+      if (!options.noAutoWaiting)
+        await this._page.performActionPreChecks(progress);
       try {
         const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
-        if (resultOneShot.matches !== options.isNot)
+        if (options.noAutoWaiting || resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if (this.isNonRetriableError(e))
+        if (options.noAutoWaiting || this.isNonRetriableError(e))
           throw e;
       }
       const result = await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-        await this._page.performActionPreChecks(progress);
+        if (!options.noAutoWaiting)
+          await this._page.performActionPreChecks(progress);
         const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
         if (matches === options.isNot) {
           return continuePolling;
@@ -1247,55 +1193,36 @@ 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) {
-      const { frame, info } = await race(this.selectors.resolveFrameForSelector(selector, { strict: true }));
-      const action = async (result) => {
-        if (!result) {
-          if (options.expectedNumber === 0)
-            return { matches: true };
-          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 };
-          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, !isArray, false, action, "returnAll", null);
-      } else {
-        var { log, matches, received, missingReceived } = await race(this._retryWithProgressIfNotConnected(progress, selector, !isArray, false, 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) {
-      lastIntermediateResult.received = missingReceived ? "<element(s) not found>" : received;
+      if (missingReceived) {
+        lastIntermediateResult.errorMessage = "Error: element(s) not found";
+      } else {
+        lastIntermediateResult.errorMessage = void 0;
+        lastIntermediateResult.received = received;
+      }
       lastIntermediateResult.isSet = true;
       if (!missingReceived && !Array.isArray(received))
         progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
@@ -1375,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)
@@ -1406,54 +1342,27 @@ class Frame extends import_instrumentation.SdkObject {
   }
   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") {
-        promise = scopeParentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
-          const callback = injected.eval(callbackText2);
-          const haha = callback(injected, handle2, taskData2);
-          return haha;
-        }, {
-          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.strict, false, async (handle) => {
-        if (handle.parentNode.constructor.name == "ElementHandle") {
-          return await handle.parentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
-            const callback = injected.eval(callbackText2);
-            const haha = callback(injected, handle2, taskData2);
-            return haha;
-          }, {
-            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) {
@@ -1503,229 +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) {
-          var resolvedNode = await client._sendMayFail("DOM.resolveNode", {
-            nodeId: describedNode.node.contentDocument.nodeId
-          });
-          var _executionContextId = parseInt(resolvedNode.object.objectId.split(".")[1], 10);
-          return _executionContextId;
-        }
-      }
-    } catch (e) {
-    }
-    return 0;
-  }
-  async _retryWithoutProgress(progress, selector, strict, performActionPreChecks, action, returnAction, continuePolling) {
-    if (performActionPreChecks) await this._page.performActionPreChecks(progress);
-    const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict });
-    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;
-    const documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
-    let currentScopingElements;
-    try {
-      currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, documentScope, progress, resolved.info.parsed);
-    } catch (e) {
-      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling3;
-      await progress.race(resolved.injected.evaluateHandle((injected, { error }) => {
-        throw error;
-      }, { error: e }));
-    }
-    if (currentScopingElements.length == 0) {
-      if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
-        const result2 = await action(null);
-        return result2 === "internal:continuepolling" ? continuePolling2 : result2;
-      }
-      return continuePolling;
-    }
-    const resultElement = currentScopingElements[0];
-    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 " + resultElement.preview());
+  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;
-      }
-      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("").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 {