patchright-core 1.57.0 → 1.59.0

package/lib/server/firefox/ffBrowser.js

@@ -35,7 +35,6 @@ module.exports = __toCommonJS(ffBrowser_exports);
 var import_utils = require("../../utils");
 var import_browser = require("../browser");
 var import_browserContext = require("../browserContext");
-var import_errors = require("../errors");
 var network = __toESM(require("../network"));
 var import_ffConnection = require("./ffConnection");
 var import_ffPage = require("./ffPage");
@@ -54,7 +53,6 @@ class FFBrowser extends import_browser.Browser {
     this.session.on("Browser.detachedFromTarget", this._onDetachedFromTarget.bind(this));
     this.session.on("Browser.downloadCreated", this._onDownloadCreated.bind(this));
     this.session.on("Browser.downloadFinished", this._onDownloadFinished.bind(this));
-    this.session.on("Browser.videoRecordingFinished", this._onVideoRecordingFinished.bind(this));
   }
   static async connect(parent, transport, options) {
     const connection = new import_ffConnection.FFConnection(transport, options.protocolLogger, options.browserLogsCollector);
@@ -129,7 +127,7 @@ class FFBrowser extends import_browser.Browser {
     ffPage._page.frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
     let originPage = ffPage._page.initializedOrUndefined();
     if (!originPage) {
-      ffPage._markAsError(new Error("Starting new page download"));
+      ffPage._reportAsNew(new Error("Starting new page download"));
       if (ffPage._opener)
         originPage = ffPage._opener._page.initializedOrUndefined();
     }
@@ -141,13 +139,7 @@ class FFBrowser extends import_browser.Browser {
     const error = payload.canceled ? "canceled" : payload.error;
     this._downloadFinished(payload.uuid, error);
   }
-  _onVideoRecordingFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onDisconnect() {
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
-    this._idToVideo.clear();
     for (const ffPage of this._ffPages.values())
       ffPage.didClose();
     this._ffPages.clear();
@@ -177,8 +169,11 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
     promises.push(this.doUpdateDefaultViewport());
     if (this._options.hasTouch)
       promises.push(this._browser.session.send("Browser.setTouchOverride", { browserContextId, hasTouch: true }));
-    if (this._options.userAgent)
+    if (this._options.userAgent) {
       promises.push(this._browser.session.send("Browser.setUserAgentOverride", { browserContextId, userAgent: this._options.userAgent }));
+      const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)(this._options);
+      promises.push(this._browser.session.send("Browser.setPlatformOverride", { browserContextId, platform: navigatorPlatform || null }));
+    }
     if (this._options.bypassCSP)
       promises.push(this._browser.session.send("Browser.setBypassCSP", { browserContextId, bypassCSP: true }));
     if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors)
@@ -198,18 +193,6 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
     if (this._options.offline)
       promises.push(this.doUpdateOffline());
     promises.push(this.doUpdateDefaultEmulatedMedia());
-    if (this._options.recordVideo) {
-      promises.push(this._ensureVideosPath().then(() => {
-        return this._browser.session.send("Browser.setVideoRecordingOptions", {
-          // validateBrowserContextOptions ensures correct video size.
-          options: {
-            ...this._options.recordVideo.size,
-            dir: this._options.recordVideo.dir
-          },
-          browserContextId: this._browserContextId
-        });
-      }));
-    }
     const proxy = this._options.proxyOverride || this._options.proxy;
     if (proxy) {
       promises.push(this._browser.session.send("Browser.setContextProxy", {
@@ -276,7 +259,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
       ["geolocation", "geo"],
       ["persistent-storage", "persistent-storage"],
       ["push", "push"],
-      ["notifications", "desktop-notification"]
+      ["notifications", "desktop-notification"],
+      ["screen-wake-lock", "screen-wake-lock"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -302,6 +286,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async setUserAgent(userAgent) {
     await this._browser.session.send("Browser.setUserAgentOverride", { browserContextId: this._browserContextId, userAgent: userAgent || null });
+    const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)({ userAgent });
+    await this._browser.session.send("Browser.setPlatformOverride", { browserContextId: this._browserContextId, platform: navigatorPlatform || null });
   }
   async doUpdateOffline() {
     await this._browser.session.send("Browser.setOnlineOverride", { browserContextId: this._browserContextId, override: this._options.offline ? "offline" : "online" });
@@ -379,12 +365,6 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      if (this._options.recordVideo) {
-        await this._browser.session.send("Browser.setVideoRecordingOptions", {
-          options: void 0,
-          browserContextId: this._browserContextId
-        });
-      }
       await this._browser.close({ reason });
     } else {
       await this._browser.session.send("Browser.removeBrowserContext", { browserContextId: this._browserContextId });

package/lib/server/firefox/ffConnection.js

@@ -90,11 +90,6 @@ class FFSession extends import_events.EventEmitter {
     this._connection = connection;
     this._sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   markAsCrashed() {
     this._crashed = true;

package/lib/server/firefox/ffInput.js

@@ -23,6 +23,20 @@ __export(ffInput_exports, {
   RawTouchscreenImpl: () => RawTouchscreenImpl
 });
 module.exports = __toCommonJS(ffInput_exports);
+const kFirefoxKeyOverrides = /* @__PURE__ */ new Map([
+  ["AudioVolumeMute", { code: "VolumeMute", keyCodeWithoutLocation: 181 }],
+  ["AudioVolumeDown", { code: "VolumeDown", keyCodeWithoutLocation: 182 }],
+  ["AudioVolumeUp", { code: "VolumeUp", keyCodeWithoutLocation: 183 }]
+]);
+function toFirefoxKeyDescription(description) {
+  const override = kFirefoxKeyOverrides.get(description.key);
+  if (!override)
+    return description;
+  return {
+    ...description,
+    ...override
+  };
+}
 function toModifiersMask(modifiers) {
   let mask = 0;
   if (modifiers.has("Alt"))
@@ -59,13 +73,14 @@ class RawKeyboardImpl {
     this._client = client;
   }
   async keydown(progress, modifiers, keyName, description, autoRepeat) {
-    let text = description.text;
+    const keyDescription = toFirefoxKeyDescription(description);
+    let text = keyDescription.text;
     if (text === "\r")
       text = "";
-    const { code, key, location } = description;
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keydown",
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       key,
       repeat: autoRepeat,
@@ -74,11 +89,12 @@ class RawKeyboardImpl {
     }));
   }
   async keyup(progress, modifiers, keyName, description) {
-    const { code, key, location } = description;
+    const keyDescription = toFirefoxKeyDescription(description);
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keyup",
       key,
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       location,
       repeat: false

package/lib/server/firefox/ffNetworkManager.js

@@ -133,8 +133,7 @@ class FFNetworkManager {
       this._requests.delete(request._id);
       response._requestFinished(responseEndTime);
     }
-    if (event.protocolVersion)
-      response._setHttpVersion(event.protocolVersion);
+    response._setHttpVersion(event.protocolVersion ?? null);
     this._page.frameManager.reportRequestFinished(request.request, response);
   }
   _onRequestFailed(event) {
@@ -147,6 +146,7 @@ class FFNetworkManager {
       response.setTransferSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(-1);
+      response._setHttpVersion(null);
     }
     request.request._setFailureText(event.errorCode);
     this._page.frameManager.requestFailed(request.request, event.errorCode === "NS_BINDING_ABORTED");
@@ -170,9 +170,9 @@ const causeToResourceType = {
   TYPE_FONT: "font",
   TYPE_MEDIA: "media",
   TYPE_WEBSOCKET: "websocket",
-  TYPE_CSP_REPORT: "other",
+  TYPE_CSP_REPORT: "cspreport",
   TYPE_XSLT: "other",
-  TYPE_BEACON: "other",
+  TYPE_BEACON: "beacon",
   TYPE_FETCH: "fetch",
   TYPE_IMAGESET: "image",
   TYPE_WEB_MANIFEST: "manifest"

package/lib/server/firefox/ffPage.js

@@ -41,9 +41,9 @@ var import_ffConnection = require("./ffConnection");
 var import_ffExecutionContext = require("./ffExecutionContext");
 var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
-var import_debugLogger = require("../utils/debugLogger");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_errors = require("../errors");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
   constructor(session, browserContext, opener) {
@@ -83,22 +83,20 @@ class FFPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.workerDestroyed", this._onWorkerDestroyed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.dispatchMessageFromWorker", this._onDispatchMessageFromWorker.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.crashed", this._onCrashed.bind(this)),
-      import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.videoRecordingStarted", this._onVideoRecordingStarted.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketCreated", this._onWebSocketCreated.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketClosed", this._onWebSocketClosed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameReceived", this._onWebSocketFrameReceived.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameSent", this._onWebSocketFrameSent.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.screencastFrame", this._onScreencastFrame.bind(this))
     ];
-    this._session.once("Page.ready", () => {
-      if (this._reportedAsNew)
-        return;
-      this._reportedAsNew = true;
-      this._page.reportAsNew(this._opener?._page);
-    });
-    this.addInitScript(new import_page.InitScript(""), UTILITY_WORLD_NAME).catch((e) => this._markAsError(e));
-  }
-  async _markAsError(error) {
+    const promises = [];
+    if (!this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
+    promises.push(new Promise((f) => this._session.once("Page.ready", f)));
+    Promise.all(promises).then(() => this._reportAsNew(), (error) => this._reportAsNew(error));
+    this.addInitScript(new import_page.InitScript(this._page, ""), UTILITY_WORLD_NAME).catch((e) => this._reportAsNew(e));
+  }
+  _reportAsNew(error) {
     if (this._reportedAsNew)
       return;
     this._reportedAsNew = true;
@@ -200,7 +198,8 @@ class FFPage {
     const context = this._contextIdToContext.get(executionContextId);
     if (!context)
       return;
-    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+    const timestamp = Date.now();
+    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, timestamp);
   }
   _onDialogOpened(params) {
     this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
@@ -250,7 +249,7 @@ class FFPage {
     workerSession.on("Runtime.console", (event2) => {
       const { type, args, location } = event2;
       const context = worker.existingExecutionContext;
-      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, Date.now());
     });
   }
   _onWorkerDestroyed(event) {
@@ -272,11 +271,8 @@ class FFPage {
     this._session.markAsCrashed();
     this._page._didCrash();
   }
-  _onVideoRecordingStarted(event) {
-    this._browserContext._browser._videoStarted(this._browserContext, event.screencastId, event.file, this._page.waitForInitializedOrError());
-  }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError());
+    this._reportAsNew(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();
@@ -417,26 +413,22 @@ class FFPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const { screencastId } = await this._session.send("Page.startScreencast", options);
-      this._screencastId = screencastId;
-    } else {
-      await this._session.send("Page.stopScreencast");
-    }
+  startScreencast(options) {
+    this._session.sendMayFail("Page.startScreencast", { width: options.width, height: options.height, quality: options.quality });
+  }
+  stopScreencast() {
+    this._session.sendMayFail("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._page.throttleScreencastFrameAck(() => {
-      this._session.send("Page.screencastFrameAck", { screencastId }).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page2.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      frameSwapWallTime: event.timestamp * 1e3,
+      // timestamp is in seconds, we need to convert to milliseconds.
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._session.sendMayFail("Page.screencastFrameAck");
     });
   }
   rafCountForStablePosition() {
@@ -489,6 +481,8 @@ class FFPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return false;
   }
+  async setDockTile(image) {
+  }
 }
 function webSocketId(frameId, wsid) {
   return `${frameId}---${wsid}`;

package/lib/server/firefox/firefox.js

@@ -56,15 +56,13 @@ class Firefox extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_ffBrowser.FFBrowser.connect(this.attribution.playwright, transport, options);
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes(`as root in a regular user's session is not supported.`))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
+  doRewriteStartupLog(logs) {
+    if (logs.includes(`as root in a regular user's session is not supported.`))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
 Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? " in your GitHub Actions workflow file" : ""} when running Playwright.`, 1);
-    if (error.logs.includes("no DISPLAY environment variable specified"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+    if (logs.includes("no DISPLAY environment variable specified"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   amendEnvironment(env) {
     if (!import_path.default.isAbsolute(import_os.default.homedir()))

package/lib/server/frameSelectors.js

@@ -21,7 +21,6 @@ __export(frameSelectors_exports, {
   FrameSelectors: () => FrameSelectors
 });
 module.exports = __toCommonJS(frameSelectors_exports);
-var import_dom = require("./dom");
 var import_utils = require("../utils");
 var import_selectorParser = require("../utils/isomorphic/selectorParser");
 class FrameSelectors {
@@ -46,12 +45,14 @@ class FrameSelectors {
     }
     return adoptIfNeeded(elementHandle, await resolved.frame._mainContext());
   }
-  async queryArrayInMainWorld(selector, scope, isolatedContext) {
-    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: !isolatedContext }, scope);
+  async queryArrayInMainWorld(selector, scope) {
+    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: true }, scope);
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
     return await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
   }
   async queryCount(selector, options) {
@@ -60,7 +61,9 @@ class FrameSelectors {
       throw new Error(`Failed to find frame for selector "${selector}"`);
     await options.__testHookBeforeQuery?.();
     return await resolved.injected.evaluate((injected, { info }) => {
-      return injected.querySelectorAll(info.parsed, document).length;
+      const elements = injected.querySelectorAll(info.parsed, document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements.length;
     }, { info: resolved.info });
   }
   async queryAll(selector, scope) {
@@ -68,7 +71,9 @@ class FrameSelectors {
     if (!resolved)
       return [];
     const arrayHandle = await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
     const properties = await arrayHandle.getProperties();
     arrayHandle.dispose();
@@ -118,29 +123,9 @@ class FrameSelectors {
           throw injected.createStacklessError(`Selector "${selectorString}" resolved to ${injected.previewNode(element2)}, <iframe> was expected`);
         return element2;
       }, { info, scope: i === 0 ? scope : void 0, selectorString: (0, import_selectorParser.stringifySelector)(info.parsed) });
-      let element = handle.asElement();
-      if (!element) {
-        try {
-          var client = frame._page.delegate._sessionForFrame(frame)._client;
-        } catch (e) {
-          var client = frame._page.delegate._mainFrameSession._client;
-        }
-        var mainContext = await frame._context("main");
-        const documentNode = await client.send("Runtime.evaluate", {
-          expression: "document",
-          serializationOptions: {
-            serialization: "idOnly"
-          },
-          contextId: mainContext.delegate._contextId
-        });
-        const documentScope = new import_dom.ElementHandle(mainContext, documentNode.result.objectId);
-        var check = await this._customFindFramesByParsed(injectedScript, client, mainContext, documentScope, info.parsed);
-        if (check.length > 0) {
-          element = check[0];
-        } else {
-          return null;
-        }
-      }
+      const element = handle.asElement();
+      if (!element)
+        return null;
       const maybeFrame = await frame._page.delegate.getContentFrame(element);
       element.dispose();
       if (!maybeFrame)
@@ -161,146 +146,6 @@ class FrameSelectors {
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
-  async _customFindFramesByParsed(injected, client, context, documentScope, 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 (partNth > currentScopingElements.length || partNth < -currentScopingElements.length) {
-          return continuePolling;
-        } else {
-          currentScopingElements = [currentScopingElements.at(partNth)];
-          continue;
-        }
-      } else if (part.name == "internal:or") {
-        var orredElements = await this._customFindFramesByParsed(injected, client, context, documentScope, part.body.parsed);
-        elements = currentScopingElements.concat(orredElements);
-      } else if (part.name == "internal:and") {
-        var andedElements = await this._customFindFramesByParsed(injected, client, context, documentScope, 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) {
-          const describedScope = await client.send("DOM.describeNode", {
-            objectId: scope._objectId,
-            depth: -1,
-            pierce: true
-          });
-          var queryingElements = [];
-          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;
-          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 import_dom.ElementHandle(context, resolvedShadowRoot.object.objectId));
-          }
-          for (var shadowRoot of shadowRoots) {
-            const shadowElements = await shadowRoot.evaluateHandleInUtility(([injected2, node, { parsed: parsed2 }]) => {
-              const elements2 = injected2.querySelectorAll(parsed2, node);
-              return elements2;
-            }, {
-              parsed: parsedEdits
-            });
-            const shadowElementsAmount = await shadowElements.getProperty("length");
-            queryingElements.push([shadowElements, shadowElementsAmount, shadowRoot]);
-          }
-          const rootElements = await scope.evaluateHandleInUtility(([injected2, node, { parsed: parsed2 }]) => {
-            const elements2 = injected2.querySelectorAll(parsed2, node);
-            return elements2;
-          }, {
-            parsed: parsedEdits
-          });
-          const rootElementsAmount = await rootElements.getProperty("length");
-          queryingElements.push([rootElements, rootElementsAmount, injected]);
-          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(([injected2, node, { index, elementsToCheck: elementsToCheck2 }]) => {
-                  return elementsToCheck2[index];
-                }, { index: i, elementsToCheck });
-              } else {
-                var elementToCheck = await parentNode.evaluateHandle((injected2, { 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._findElementPositionInDomTree(elementToCheck, describedScope.node, context, "");
-              elements.push(elementToCheck);
-            }
-          }
-        }
-      }
-      const getParts = (pos) => (pos?.match(/../g) || []).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.nodePosition, e])).values()
-      );
-    }
-    return currentScopingElements;
-  }
-  _findElementPositionInDomTree(element, queryingElement, documentScope, currentIndex) {
-    if (element.backendNodeId === queryingElement.backendNodeId) {
-      return currentIndex;
-    }
-    for (const child of queryingElement.children || []) {
-      const childrenNodeIndex = queryingElement.children.indexOf(child);
-      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + childrenNodeIndex.toString());
-      if (childIndex !== null) return childIndex;
-    }
-    if (queryingElement.shadowRoots && Array.isArray(queryingElement.shadowRoots)) {
-      for (const shadowRoot of queryingElement.shadowRoots) {
-        if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
-          const shadowRootHandle = new import_dom.ElementHandle(documentScope, shadowRoot.backendNodeId);
-          const childIndex = this._findElementPositionInDomTree(element, shadowRootHandle, documentScope, currentIndex);
-          if (childIndex !== null) return childIndex;
-        }
-      }
-    }
-    return null;
-  }
 }
 async function adoptIfNeeded(handle, context) {
   if (handle._context === context)