patchright-core 1.50.1 → 1.51.1

package/lib/server/frames.js

@@ -8,26 +8,27 @@ var _crExecutionContext = require("./chromium/crExecutionContext");
 var _dom = _interopRequireWildcard(require("./dom"));
 var dom = _dom;
 var _crypto = _interopRequireDefault(require("crypto"));
+var _browserContext = require("./browserContext");
+var _errors = require("./errors");
+var _fileUploadUtils = require("./fileUploadUtils");
+var _frameSelectors = require("./frameSelectors");
 var _helper = require("./helper");
-var _eventsHelper = require("../utils/eventsHelper");
+var _instrumentation = require("./instrumentation");
 var js = _interopRequireWildcard(require("./javascript"));
 var network = _interopRequireWildcard(require("./network"));
 var _page = require("./page");
-var types = _interopRequireWildcard(require("./types"));
-var _browserContext = require("./browserContext");
 var _progress = require("./progress");
+var types = _interopRequireWildcard(require("./types"));
 var _utils = require("../utils");
-var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../utils/debugLogger");
-var _instrumentation = require("./instrumentation");
-var _protocolError = require("./protocolError");
-var _selectorParser = require("../utils/isomorphic/selectorParser");
-var _frameSelectors = require("./frameSelectors");
-var _errors = require("./errors");
-var _fileUploadUtils = require("./fileUploadUtils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _protocolError2 = require("./protocolError");
+var _debugLogger = require("./utils/debugLogger");
+var _eventsHelper = require("./utils/eventsHelper");
+var _selectorParser2 = require("../utils/isomorphic/selectorParser");
+var _manualPromise = require("../utils/isomorphic/manualPromise");
+var _callLog = require("./callLog");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 // undetected-undetected_playwright-patch - custom imports
 
 /**
@@ -735,49 +736,28 @@ class Frame extends _instrumentation.SdkObject {
     const {
       state = 'visible'
     } = options;
-    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-      progress.throwIfAborted();
-      if (!resolved) {
-        if (state === 'hidden' || state === 'detached') return null;
-        return continuePolling;
-      }
-      const result = await 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 element = elements[0];
-        const visible = element ? injected.utils.isElementVisible(element) : false;
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict) throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
+    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
+          }]) => {
+            return handle ? injected.utils.isElementVisible(handle) : false;
+          }, {
+            handle
+          });
+        } else {
+          visible = await handle.parentNode.evaluate((injected, {
+            handle
+          }) => {
+            return handle ? injected.utils.isElementVisible(handle) : false;
+          }, {
+            handle
+          });
         }
-        return {
-          log,
-          element,
-          visible,
-          attached: !!element
-        };
-      }, {
-        info: resolved.info,
-        root: resolved.frame === this ? scope : undefined
-      });
-      const {
-        log,
-        visible,
-        attached
-      } = await result.evaluate(r => ({
-        log: r.log,
-        visible: r.visible,
-        attached: r.attached
-      }));
-      if (log) progress.log(log);
+      }
       const success = {
         attached,
         detached: !attached,
@@ -785,23 +765,20 @@ class Frame extends _instrumentation.SdkObject {
         hidden: !visible
       }[state];
       if (!success) {
-        result.dispose();
-        return continuePolling;
+        return "internal:continuepolling";
       }
       if (options.omitReturnValue) {
-        result.dispose();
         return null;
       }
-      const element = state === 'attached' || state === 'visible' ? await result.evaluateHandle(r => r.element) : null;
-      result.dispose();
+      const element = state === 'attached' || state === 'visible' ? handle : null;
       if (!element) return null;
       if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
       try {
-        return await element._adoptTo(await resolved.frame._mainContext());
+        return element;
       } catch (e) {
-        return continuePolling;
+        return "internal:continuepolling";
       }
-    });
+    }, 'returnOnNotResolved');
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   async dispatchEvent(metadata, selector, type, eventInit = {}, options = {}, scope) {
@@ -863,7 +840,7 @@ class Frame extends _instrumentation.SdkObject {
         return retVal;
       });
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, _protocolError.isSessionClosedError)(e)) throw e;
+      if (js.isJavaScriptErrorInEvaluate(e) || (0, _protocolError2.isSessionClosedError)(e)) throw e;
       throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
     }
   }
@@ -1053,70 +1030,78 @@ class Frame extends _instrumentation.SdkObject {
   }
   _isErrorThatCannotBeRetried(e) {
     // Always fail on JavaScript errors or when the main connection is closed.
-    if (js.isJavaScriptErrorInEvaluate(e) || (0, _protocolError.isSessionClosedError)(e)) return true;
+    if (js.isJavaScriptErrorInEvaluate(e) || (0, _protocolError2.isSessionClosedError)(e)) return true;
     // Certain errors opt-out of the retries, throw.
-    if (dom.isNonRecoverableDOMError(e) || (0, _selectorParser.isInvalidSelectorError)(e)) return true;
+    if (dom.isNonRecoverableDOMError(e) || (0, _selectorParser2.isInvalidSelectorError)(e)) return true;
     // If the call is made on the detached frame - throw.
     if (this.isDetached()) return true;
     // Retry upon all other errors.
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action) {
-    progress.log(`waiting for ${this._asLocator(selector)}`);
+  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action, returnAction) {
+    progress.log("waiting for " + this._asLocator(selector));
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
       if (performActionPreChecks) await this._page.performActionPreChecks(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, {
         strict
       });
       progress.throwIfAborted();
-      if (!resolved) return continuePolling;
-      const result = await resolved.injected.evaluateHandle((injected, {
-        info,
-        callId
-      }) => {
-        const elements = injected.querySelectorAll(info.parsed, document);
-        if (callId) injected.markTargetElements(new Set(elements), callId);
-        const element = elements[0];
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict) throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${injected.previewNode(element)}`;
-        }
-        return {
-          log,
-          success: !!element,
-          element
-        };
-      }, {
-        info: resolved.info,
-        callId: progress.metadata.id
+      if (!resolved) {
+        if (returnAction === 'returnOnNotResolved' || returnAction === 'returnAll') return null;
+        return continuePolling;
+      }
+      try {
+        var client = this._page._delegate._sessionForFrame(resolved.frame)._client;
+      } catch (e) {
+        var client = this._page._delegate._mainFrameSession._client;
+      }
+      var context = await resolved.frame._context("main");
+      const documentNode = await client.send('Runtime.evaluate', {
+        expression: "document",
+        serializationOptions: {
+          serialization: "idOnly"
+        },
+        contextId: context.delegate._contextId
       });
-      const {
-        log,
-        success
-      } = await result.evaluate(r => ({
-        log: r.log,
-        success: r.success
-      }));
-      if (log) progress.log(log);
-      if (!success) {
-        result.dispose();
+      const documentScope = new dom.ElementHandle(context, documentNode.result.objectId);
+      const currentScopingElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, resolved.info.parsed);
+      if (currentScopingElements.length == 0) {
+        // TODO: Dispose?
+        if (returnAction === 'returnOnNotResolved' || returnAction === 'returnAll') return null;
         return continuePolling;
       }
-      const element = await result.evaluateHandle(r => r.element);
-      result.dispose();
+      const resultElement = currentScopingElements[0];
+      if (currentScopingElements.length > 1) {
+        if (resolved.info.strict) {
+          await 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());
+      }
       try {
-        const result = await action(element);
+        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 {
-        element === null || element === void 0 || element.dispose();
-      }
+      } finally {}
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
@@ -1255,22 +1240,42 @@ class Frame extends _instrumentation.SdkObject {
   }
   async isVisibleInternal(selector, options = {}, scope) {
     try {
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-      if (!resolved) return false;
-      return await 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 : undefined
-      });
+      const custom_metadata = {
+        "internal": false,
+        "log": []
+      };
+      const controller = new _progress.ProgressController(custom_metadata, this);
+      return await controller.run(async progress => {
+        progress.log("waiting for " + this._asLocator(selector));
+        const promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, false, async handle => {
+          if (handle.parentNode.constructor.name == "ElementHandle") {
+            return await handle.parentNode.evaluateInUtility(([injected, node, {
+              handle
+            }]) => {
+              const state = handle ? injected.elementState(handle, 'visible') : {
+                matches: false,
+                received: 'error:notconnected'
+              };
+              return state.matches;
+            }, {
+              handle
+            });
+          } else {
+            return await handle.parentNode.evaluate((injected, {
+              handle
+            }) => {
+              const state = handle ? injected.elementState(handle, 'visible') : {
+                matches: false,
+                received: 'error:notconnected'
+              };
+              return state.matches;
+            }, {
+              handle
+            });
+          }
+        });
+        return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+      }, 100); // A bit geeky but its okay :D
     } catch (e) {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e) || (0, _protocolError.isSessionClosedError)(e)) throw e;
       return false;
@@ -1343,7 +1348,7 @@ class Frame extends _instrumentation.SdkObject {
   async ariaSnapshot(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, handle => handle.ariaSnapshot());
+      return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, handle => handle.ariaSnapshot(options));
     }, this._page._timeoutSettings.timeout(options));
   }
   async expect(metadata, selector, options) {
@@ -1381,7 +1386,7 @@ class Frame extends _instrumentation.SdkObject {
         });
         if (resultOneShot.matches !== options.isNot) return resultOneShot;
       } catch (e) {
-        if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
+        if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser2.isInvalidSelectorError)(e)) throw e;
         // Ignore any other errors from one-shot, we'll handle them during retries.
       }
       if (timeout > 0) {
@@ -1390,7 +1395,7 @@ class Frame extends _instrumentation.SdkObject {
       }
       if (timeout < 0) return {
         matches: options.isNot,
-        log: (0, _utils.compressCallLog)(metadata.log),
+        log: (0, _callLog.compressCallLog)(metadata.log),
         timedOut: true,
         received: lastIntermediateResult.received
       };
@@ -1418,10 +1423,10 @@ class Frame extends _instrumentation.SdkObject {
     } catch (e) {
       // Q: Why not throw upon isSessionClosedError(e) as in other places?
       // A: We want user to receive a friendly message containing the last intermediate result.
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
+      if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser2.isInvalidSelectorError)(e)) throw e;
       const result = {
         matches: options.isNot,
-        log: (0, _utils.compressCallLog)(metadata.log)
+        log: (0, _callLog.compressCallLog)(metadata.log)
       };
       if (lastIntermediateResult.isSet) result.received = lastIntermediateResult.received;
       if (e instanceof _errors.TimeoutError) result.timedOut = true;
@@ -1429,52 +1434,55 @@ class Frame extends _instrumentation.SdkObject {
     }
   }
   async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    var _info$world;
-    const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, {
-      strict: true
-    });
-    progress.throwIfAborted();
-    const {
-      frame,
-      info
-    } = selectorInFrame || {
-      frame: this,
-      info: undefined
-    };
-    const world = options.expression === 'to.have.property' ? 'main' : (_info$world = info === null || info === void 0 ? void 0 : info.world) !== null && _info$world !== void 0 ? _info$world : 'utility';
-    const context = await frame._context(world);
-    const injected = await context.injectedScript();
-    progress.throwIfAborted();
-    const {
-      log,
-      matches,
-      received,
-      missingReceived
-    } = await injected.evaluate(async (injected, {
-      info,
-      options,
-      callId
-    }) => {
-      const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
-      if (callId) injected.markTargetElements(new Set(elements), callId);
-      const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
-      let log = '';
-      if (isArray) log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;else if (elements.length > 1) throw injected.strictModeViolationError(info.parsed, elements);else if (elements.length) log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-      return {
-        log,
-        ...(await injected.expect(elements[0], options, elements))
-      };
-    }, {
-      info,
-      options,
-      callId: progress.metadata.id
-    });
-    if (log) progress.log(log);
-    // Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
+    progress.log("waiting for " + this._asLocator(selector));
+    const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
+    const promise = await this._retryWithProgressIfNotConnected(progress, selector, !isArray, false, async result => {
+      const handle = result[0];
+      const handles = result[1];
+      if (handle.parentNode.constructor.name == "ElementHandle") {
+        return await handle.parentNode.evaluateInUtility(async ([injected, node, {
+          handle,
+          options,
+          handles
+        }]) => {
+          return await injected.expect(handle, options, handles);
+        }, {
+          handle,
+          options,
+          handles
+        });
+      } else {
+        return await handle.parentNode.evaluate(async (injected, {
+          handle,
+          options,
+          handles
+        }) => {
+          return await injected.expect(handle, options, handles);
+        }, {
+          handle,
+          options,
+          handles
+        });
+      }
+    }, 'returnAll');
+
+    // Default Values, if no Elements found
+    var matches = false;
+    var received = 0;
+    var missingReceived = null;
+    if (promise) {
+      matches = promise.matches;
+      received = promise.received;
+      missingReceived = promise.missingReceived;
+    } else if (options.expectedNumber === 0) {
+      matches = true;
+    }
+
+    // Note: missingReceived avoids unexpected value "undefined" when element was not found.
     if (matches === options.isNot) {
       lastIntermediateResult.received = missingReceived ? '<element(s) not found>' : received;
       lastIntermediateResult.isSet = true;
-      if (!missingReceived && !Array.isArray(received)) progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
+      if (!missingReceived && !Array.isArray(received)) progress.log('  unexpected value "' + renderUnexpectedValue(options.expression, received) + '"');
     }
     return {
       matches,
@@ -1589,44 +1597,35 @@ class Frame extends _instrumentation.SdkObject {
     const callbackText = body.toString();
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      progress.log(`waiting for ${this._asLocator(selector)}`);
-      const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-        const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-        progress.throwIfAborted();
-        if (!resolved) return continuePolling;
-        const {
-          log,
-          success,
-          value
-        } = await resolved.injected.evaluate((injected, {
-          info,
-          callbackText,
-          taskData,
-          callId,
-          root
-        }) => {
-          const callback = injected.eval(callbackText);
-          const element = injected.querySelector(info.parsed, root || document, info.strict);
-          if (!element) return {
-            success: false
-          };
-          const log = `  locator resolved to ${injected.previewNode(element)}`;
-          if (callId) injected.markTargetElements(new Set([element]), callId);
-          return {
-            log,
-            success: true,
-            value: callback(injected, element, taskData)
-          };
-        }, {
-          info: resolved.info,
-          callbackText,
-          taskData,
-          callId: progress.metadata.id,
-          root: resolved.frame === this ? scope : undefined
-        });
-        if (log) progress.log(log);
-        if (!success) return continuePolling;
-        return value;
+      progress.log("waiting for " + this._asLocator(selector));
+      const promise = this._retryWithProgressIfNotConnected(progress, selector, false, false, async handle => {
+        if (handle.parentNode.constructor.name == "ElementHandle") {
+          return await handle.parentNode.evaluateInUtility(([injected, node, {
+            callbackText,
+            handle,
+            taskData
+          }]) => {
+            const callback = injected.eval(callbackText);
+            return callback(injected, handle, taskData);
+          }, {
+            callbackText,
+            handle,
+            taskData
+          });
+        } else {
+          return await handle.parentNode.evaluate((injected, {
+            callbackText,
+            handle,
+            taskData
+          }) => {
+            const callback = injected.eval(callbackText);
+            return callback(injected, handle, taskData);
+          }, {
+            callbackText,
+            handle,
+            taskData
+          });
+        }
       });
       return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
     }, this._page._timeoutSettings.timeout(options));
@@ -1741,6 +1740,164 @@ class Frame extends _instrumentation.SdkObject {
     } catch (e) {}
     return 0;
   }
+  async _customFindElementsByParsed(resolved, client, context, documentScope, progress, parsed) {
+    var parsedEdits = {
+      ...parsed
+    };
+    // Note: We start scoping at document level
+    var currentScopingElements = [documentScope];
+    while (parsed.parts.length > 0) {
+      var part = parsed.parts.shift();
+      parsedEdits.parts = [part];
+      var isUsingXPath = false;
+      // Getting All Elements
+      var elements = [];
+      var elementsIndexes = [];
+      if (part.name == "xpath") {
+        isUsingXPath = true;
+      } else 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._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) {
+          const describedScope = await client.send('DOM.describeNode', {
+            objectId: scope._objectId,
+            depth: -1,
+            pierce: true
+          });
+
+          // Elements Queryed in the "current round"
+          var queryingElements = [];
+          if (!isUsingXPath) {
+            function findClosedShadowRoots(node, results = []) {
+              if (!node || typeof node !== 'object') return results;
+              if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
+                for (const shadowRoot of node.shadowRoots) {
+                  if (shadowRoot.shadowRootType === 'closed' && shadowRoot.backendNodeId) {
+                    results.push(shadowRoot.backendNodeId);
+                  }
+                  findClosedShadowRoots(shadowRoot, results);
+                }
+              }
+              if (node.nodeName !== 'IFRAME' && node.children && Array.isArray(node.children)) {
+                for (const child of node.children) {
+                  findClosedShadowRoots(child, results);
+                }
+              }
+              return results;
+            }
+            var shadowRootBackendIds = findClosedShadowRoots(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,
+                callId
+              }]) => {
+                const elements = injected.querySelectorAll(parsed, node);
+                if (callId) injected.markTargetElements(new Set(elements), callId);
+                return elements;
+              }, {
+                parsed: parsedEdits,
+                callId: progress.metadata.id
+              });
+              const shadowElementsAmount = await shadowElements.getProperty("length");
+              queryingElements.push([shadowElements, shadowElementsAmount, shadowRoot]);
+            }
+          }
+
+          // Document Root Elements (not in CSR)
+          const rootElements = await scope.evaluateHandleInUtility(([injected, node, {
+            parsed,
+            callId
+          }]) => {
+            const elements = injected.querySelectorAll(parsed, node);
+            if (callId) injected.markTargetElements(new Set(elements), callId);
+            return elements;
+          }, {
+            parsed: parsedEdits,
+            callId: progress.metadata.id
+          });
+          const rootElementsAmount = await rootElements.getProperty("length");
+          queryingElements.push([rootElements, rootElementsAmount, resolved.injected]);
+
+          // Querying and Sorting the elements by their backendNodeId
+          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
+                }]) => {
+                  return elementsToCheck[index];
+                }, {
+                  index: i,
+                  elementsToCheck: elementsToCheck
+                });
+              } else {
+                var elementToCheck = await parentNode.evaluateHandle((injected, {
+                  index,
+                  elementsToCheck
+                }) => {
+                  return elementsToCheck[index];
+                }, {
+                  index: i,
+                  elementsToCheck: elementsToCheck
+                });
+              }
+              // For other Functions/Utilities
+              elementToCheck.parentNode = parentNode;
+              var resolvedElement = await client.send('DOM.describeNode', {
+                objectId: elementToCheck._objectId,
+                depth: -1
+              });
+              // Note: Possible Bug, Maybe well actually have to check the Documents Node Position instead of using the backendNodeId
+              elementToCheck.backendNodeId = resolvedElement.node.backendNodeId;
+              elements.push(elementToCheck);
+            }
+          }
+        }
+      }
+      // Setting currentScopingElements to the elements we just queried
+      currentScopingElements = [];
+      for (var element of elements) {
+        var elemIndex = element.backendNodeId;
+        // Sorting the Elements by their occourance in the DOM
+        var elemPos = elementsIndexes.findIndex(index => index > elemIndex);
+
+        // Sort the elements by their backendNodeId
+        if (elemPos === -1) {
+          currentScopingElements.push(element);
+          elementsIndexes.push(elemIndex);
+        } else {
+          currentScopingElements.splice(elemPos, 0, element);
+          elementsIndexes.splice(elemPos, 0, elemIndex);
+        }
+      }
+    }
+    return currentScopingElements;
+  }
 }
 exports.Frame = Frame;
 Frame.Events = {