@asamuzakjp/dom-selector 0.20.2 → 0.21.0

package/package.json

@@ -23,27 +23,32 @@
     "is-potential-custom-element-name": "^1.0.1"
   },
   "devDependencies": {
-    "@types/css-tree": "^2.3.2",
+    "@types/css-tree": "^2.3.3",
     "benchmark": "^2.1.4",
     "c8": "^8.0.1",
     "chai": "^4.3.10",
-    "eslint": "^8.51.0",
+    "eslint": "^8.52.0",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-jsdoc": "^46.8.2",
-    "eslint-plugin-regexp": "^1.15.0",
+    "eslint-plugin-regexp": "^2.1.1",
     "eslint-plugin-unicorn": "^48.0.1",
     "jsdom": "^22.1.0",
     "mocha": "^10.2.0",
-    "sinon": "^16.1.0",
-    "typescript": "^5.2.2"
+    "npm-run-all": "^4.1.5",
+    "sinon": "^17.0.0",
+    "typescript": "^5.2.2",
+    "wpt-runner": "^5.0.0"
   },
   "scripts": {
     "bench": "node benchmark/bench.js",
     "build": "npm run tsc && npm run lint && npm test",
     "lint": "eslint --fix .",
     "test": "c8 --reporter=text mocha --exit test/**/*.test.js",
-    "tsc": "npx tsc"
+    "test-wpt": "npm run update-wpt && node test/wpt/wpt-runner.js",
+    "tsc": "npx tsc",
+    "update": "npm-run-all -s update-*",
+    "update-wpt": "git submodule update --init --recursive"
   },
-  "version": "0.20.2"
+  "version": "0.21.0"
 }

package/src/js/matcher.js

@@ -63,6 +63,7 @@ const PSEUDO_NTH = /^nth-(?:last-)?(?:child|of-type)$/;
 export class Matcher {
   /* private fields */
   #ast;
+  #cache;
   #node;
   #nodes;
   #root;
@@ -80,10 +81,11 @@ export class Matcher {
    */
   constructor(selector, node, opt = {}) {
     const { sort, warn } = opt;
-    [this.#ast, this.#nodes] = this._prepare(selector);
+    this.#selector = selector;
     this.#node = node;
+    [this.#ast, this.#nodes] = this._prepare(selector);
     this.#root = this._getRoot(node);
-    this.#selector = selector;
+    this.#cache = new WeakMap();
     this.#sort = !!sort;
     this.#warn = !!warn;
   }
@@ -123,7 +125,7 @@ export class Matcher {
         root = node;
         break;
       }
-      default: {
+      case ELEMENT_NODE: {
         if (isSameOrDescendant(node)) {
           document = node.ownerDocument;
           root = node.ownerDocument;
@@ -139,6 +141,10 @@ export class Matcher {
           document = parent.ownerDocument;
           root = parent;
         }
+        break;
+      }
+      default: {
+        throw new TypeError(`Unexpected node type: ${node.nodeName}`);
       }
     }
     return {
@@ -149,8 +155,8 @@ export class Matcher {
 
   /**
    * sort AST leaves
-   * @param {object} leaves - leaves
-   * @returns {Array} - sorted leaves
+   * @param {Array.<object>} leaves - AST leaves
+   * @returns {Array.<object>} - sorted leaves
    */
   _sortLeaves(leaves) {
     const arr = [...leaves];
@@ -185,11 +191,11 @@ export class Matcher {
   /**
    * prepare ast and nodes
    * @param {string} selector - CSS selector
-   * @returns {Array} - list and matrix
+   * @returns {Array.<Array.<object|undefined>>} - list and matrix
    */
   _prepare(selector = this.#selector) {
     const ast = parseSelector(selector);
-    const branches = walkAST(ast).values();
+    const branches = walkAST(ast);
     const tree = [];
     const nodes = [];
     let i = 0;
@@ -202,7 +208,7 @@ export class Matcher {
           if (item.type === COMBINATOR) {
             const [nextItem] = items;
             if (nextItem.type === COMBINATOR) {
-              const msg = `invalid combinator, ${item.name}${nextItem.name}`;
+              const msg = `invalid combinator ${item.name}${nextItem.name}`;
               throw new DOMException(msg, SYNTAX_ERR);
             }
             branch.push({
@@ -238,6 +244,42 @@ export class Matcher {
     ];
   }
 
+  /**
+   * throw DOMExeption on pseudo element selector
+   * @param {object} astName - AST name
+   * @throws {DOMException}
+   * @returns {void}
+   */
+  _throwOnPseudoElementSelector(astName) {
+    let msg;
+    let type;
+    switch (astName) {
+      case 'after':
+      case 'backdrop':
+      case 'before':
+      case 'cue':
+      case 'cue-region':
+      case 'first-letter':
+      case 'first-line':
+      case 'file-selector-button':
+      case 'marker':
+      case 'part':
+      case 'placeholder':
+      case 'selection':
+      case 'slotted':
+      case 'target-text': {
+        msg = `Unsupported pseudo-element ::${astName}`;
+        type = NOT_SUPPORTED_ERR;
+        break;
+      }
+      default: {
+        msg = `Unknown pseudo-element ::${astName}`;
+        type = SYNTAX_ERR;
+      }
+    }
+    throw new DOMException(msg, type);
+  }
+
   /**
    * collect nth child
    * @param {object} anb - An+B options
@@ -253,7 +295,13 @@ export class Matcher {
     const { parentNode } = node;
     const selectorNodes = new Set();
     if (selector) {
-      const branches = walkAST(selector);
+      let branches;
+      if (this.#cache.has(selector)) {
+        branches = this.#cache.get(selector);
+      } else {
+        branches = walkAST(selector);
+        this.#cache.set(selector, branches);
+      }
       const branchLen = branches.length;
       const iterator = [...parentNode.children].values();
       for (const refNode of iterator) {
@@ -287,7 +335,7 @@ export class Matcher {
               break;
             }
           }
-        } else {
+        } else if (!selector) {
           const current = arr[b - 1];
           matched.add(current);
         }
@@ -318,7 +366,9 @@ export class Matcher {
               }
             }
           } else if (i === nth) {
-            matched.add(current);
+            if (!selector) {
+              matched.add(current);
+            }
             nth += a;
           }
         }
@@ -536,7 +586,7 @@ export class Matcher {
       if (!node.hasAttribute('lang')) {
         res = node;
       }
-    } else if (/[A-Za-z\d-]+/.test(astName)) {
+    } else if (/[A-Z\d-]+/i.test(astName)) {
       const codePart = '(?:-[A-Za-z\\d]+)?';
       let reg;
       if (/-/.test(astName)) {
@@ -574,7 +624,7 @@ export class Matcher {
 
   /**
    * match :has() pseudo-class function
-   * @param {Array} leaves - leaves
+   * @param {Array.<object>} leaves - AST leaves
    * @param {object} node - Element node
    * @returns {boolean} - result
    */
@@ -627,32 +677,22 @@ export class Matcher {
 
   /**
    * match logical pseudo-class functions - :has(), :is(), :not(), :where()
-   * @param {object} ast - AST
+   * @param {object} astOpt - AST options
    * @param {object} node - Element node
    * @returns {?object} - matched node
    */
-  _matchLogicalPseudoFunc(ast, node) {
-    const branches = walkAST(ast);
-    const branchLen = branches.length;
-    const branchSelectors = [];
-    for (let i = 0; i < branchLen; i++) {
-      const leaves = branches[i].values();
-      for (const leaf of leaves) {
-        const css = generateCSS(leaf);
-        branchSelectors.push(css);
-      }
-    }
-    const branchSelector = branchSelectors.join(',');
-    const astName = unescapeSelector(ast.name);
+  _matchLogicalPseudoFunc(astOpt = {}, node) {
+    const { astName = '', branches = [], selector = '' } = astOpt;
     let res;
+    const branchLen = branches.length;
     if (astName === 'has') {
-      if (branchSelector.includes(':has(')) {
+      if (selector.includes(':has(')) {
         res = null;
       } else {
         let bool;
         for (let i = 0; i < branchLen; i++) {
           const leaves = branches[i];
-          bool = this._matchHasPseudoFunc(leaves, node);
+          bool = this._matchHasPseudoFunc(Object.assign([], leaves), node);
           if (bool) {
             break;
           }
@@ -663,7 +703,7 @@ export class Matcher {
       }
     // NOTE: according to MDN, :not() can not contain :not()
     // but spec says nothing about that?
-    } else if (astName === 'not' && branchSelector.includes(':not(')) {
+    } else if (astName === 'not' && selector.includes(':not(')) {
       res = null;
     } else {
       let bool;
@@ -699,7 +739,29 @@ export class Matcher {
     let matched = new Set();
     // :has(), :is(), :not(), :where()
     if (PSEUDO_FUNC.test(astName)) {
-      const res = this._matchLogicalPseudoFunc(ast, node);
+      let opt;
+      if (this.#cache.has(ast)) {
+        opt = this.#cache.get(ast);
+      } else {
+        const branches = walkAST(ast);
+        const branchLen = branches.length;
+        const branchSelectors = [];
+        for (let i = 0; i < branchLen; i++) {
+          const leaves = branches[i];
+          for (const leaf of leaves) {
+            const css = generateCSS(leaf);
+            branchSelectors.push(css);
+          }
+        }
+        const selector = branchSelectors.join(',');
+        opt = {
+          astName,
+          branches,
+          selector
+        };
+        this.#cache.set(ast, opt);
+      }
+      const res = this._matchLogicalPseudoFunc(opt, node);
       if (res) {
         matched.add(res);
       }
@@ -958,7 +1020,7 @@ export class Matcher {
             if (!parent) {
               parent = root;
             }
-            const nodes = [...parent.getElementsByTagName('input')].values();
+            const nodes = [...parent.getElementsByTagName('input')];
             let checked;
             for (const item of nodes) {
               if (item.getAttribute('type') === 'radio') {
@@ -1164,8 +1226,9 @@ export class Matcher {
           if (node.hasChildNodes()) {
             const nodes = node.childNodes.values();
             let bool;
-            for (const n of nodes) {
-              bool = n.nodeType !== ELEMENT_NODE && n.nodeType !== TEXT_NODE;
+            for (const refNode of nodes) {
+              bool = refNode.nodeType !== ELEMENT_NODE &&
+                refNode.nodeType !== TEXT_NODE;
               if (!bool) {
                 break;
               }
@@ -1511,44 +1574,6 @@ export class Matcher {
     return res ?? null;
   }
 
-  /**
-   * match pseudo-element selector
-   * @param {object} ast - AST
-   * @param {object} node - Element node
-   * @throws {DOMException}
-   * @returns {void}
-   */
-  _matchPseudoElementSelector(ast, node) {
-    const astName = unescapeSelector(ast.name);
-    let msg;
-    let type;
-    switch (astName) {
-      case 'after':
-      case 'backdrop':
-      case 'before':
-      case 'cue':
-      case 'cue-region':
-      case 'first-letter':
-      case 'first-line':
-      case 'file-selector-button':
-      case 'marker':
-      case 'part':
-      case 'placeholder':
-      case 'selection':
-      case 'slotted':
-      case 'target-text': {
-        msg = `Unsupported pseudo-element ::${astName}`;
-        type = NOT_SUPPORTED_ERR;
-        break;
-      }
-      default: {
-        msg = `Unknown pseudo-element ::${astName}`;
-        type = SYNTAX_ERR;
-      }
-    }
-    throw new DOMException(msg, type);
-  }
-
   /**
    * match type selector
    * @param {object} ast - AST
@@ -1633,7 +1658,8 @@ export class Matcher {
           break;
         }
         case PSEUDO_ELEMENT_SELECTOR: {
-          this._matchPseudoElementSelector(ast, node);
+          const astName = unescapeSelector(ast.name);
+          this._throwOnPseudoElementSelector(astName);
           break;
         }
         case TYPE_SELECTOR:
@@ -1650,14 +1676,13 @@ export class Matcher {
 
   /**
    * match leaves
-   * @param {Array} leaves - leaves
+   * @param {Array.<object>} leaves - AST leaves
    * @param {object} node - node
    * @returns {boolean} - result
    */
   _matchLeaves(leaves, node) {
-    const iterator = leaves.values();
     let bool;
-    for (const leaf of iterator) {
+    for (const leaf of leaves) {
       bool = this._matchSelector(leaf, node).has(node);
       if (!bool) {
         break;
@@ -1666,6 +1691,96 @@ export class Matcher {
     return !!bool;
   }
 
+  /**
+   * find descendant nodes
+   * @param {Array.<object>} leaves - AST leaves
+   * @param {object} baseNode - base Element node
+   * @returns {object} - result
+   */
+  _findDescendantNodes(leaves, baseNode) {
+    const [leaf, ...items] = leaves;
+    const { type: leafType } = leaf;
+    const leafName = unescapeSelector(leaf.name);
+    const matchItems = items.length > 0;
+    const { document, root } = this.#root;
+    let nodes = new Set();
+    let pending = false;
+    switch (leafType) {
+      case ID_SELECTOR: {
+        if (root.nodeType === ELEMENT_NODE) {
+          pending = true;
+        } else {
+          const elm = root.getElementById(leafName);
+          if (elm && elm !== baseNode) {
+            const bool = isSameOrDescendant(elm, baseNode);
+            let node;
+            if (bool) {
+              node = elm;
+            }
+            if (node) {
+              if (matchItems) {
+                const bool = this._matchLeaves(items, node);
+                if (bool) {
+                  nodes.add(node);
+                }
+              } else {
+                nodes.add(node);
+              }
+            }
+          }
+        }
+        break;
+      }
+      case CLASS_SELECTOR: {
+        const arr = [...baseNode.getElementsByClassName(leafName)];
+        if (arr.length) {
+          if (matchItems) {
+            for (const node of arr) {
+              const bool = this._matchLeaves(items, node);
+              if (bool) {
+                nodes.add(node);
+              }
+            }
+          } else {
+            nodes = new Set(arr);
+          }
+        }
+        break;
+      }
+      case TYPE_SELECTOR: {
+        if (document.contentType !== 'text/html' || /[*|]/.test(leafName)) {
+          pending = true;
+        } else {
+          const arr = [...baseNode.getElementsByTagName(leafName)];
+          if (arr.length) {
+            if (matchItems) {
+              for (const node of arr) {
+                const bool = this._matchLeaves(items, node);
+                if (bool) {
+                  nodes.add(node);
+                }
+              }
+            } else {
+              nodes = new Set(arr);
+            }
+          }
+        }
+        break;
+      }
+      case PSEUDO_ELEMENT_SELECTOR: {
+        this._throwOnPseudoElementSelector(leafName);
+        break;
+      }
+      default: {
+        pending = true;
+      }
+    }
+    return {
+      nodes,
+      pending
+    };
+  }
+
   /**
    * match combinator
    * @param {object} twig - twig
@@ -1703,8 +1818,8 @@ export class Matcher {
           break;
         }
         case '>': {
-          const iterator = [...node.children].values();
-          for (const refNode of iterator) {
+          const childNodes = [...node.children];
+          for (const refNode of childNodes) {
             const bool = this._matchLeaves(leaves, refNode);
             if (bool) {
               matched.add(refNode);
@@ -1714,18 +1829,23 @@ export class Matcher {
         }
         case ' ':
         default: {
-          const { document } = this.#root;
-          const iterator = document.createNodeIterator(node, SHOW_ELEMENT);
-          let refNode = iterator.nextNode();
-          if (refNode === node) {
-            refNode = iterator.nextNode();
-          }
-          while (refNode) {
-            const bool = this._matchLeaves(leaves, refNode);
-            if (bool) {
-              matched.add(refNode);
+          const { nodes, pending } = this._findDescendantNodes(leaves, node);
+          if (nodes.size) {
+            matched = nodes;
+          } else if (pending) {
+            const { document } = this.#root;
+            const iterator = document.createNodeIterator(node, SHOW_ELEMENT);
+            let refNode = iterator.nextNode();
+            if (refNode === node) {
+              refNode = iterator.nextNode();
+            }
+            while (refNode) {
+              const bool = this._matchLeaves(leaves, refNode);
+              if (bool) {
+                matched.add(refNode);
+              }
+              refNode = iterator.nextNode();
             }
-            refNode = iterator.nextNode();
           }
         }
       }
@@ -1855,8 +1975,8 @@ export class Matcher {
             }
           }
         } else if (root.nodeType === DOCUMENT_FRAGMENT_NODE) {
-          const iterator = [...root.children].values();
-          for (const node of iterator) {
+          const childNodes = [...root.children];
+          for (const node of childNodes) {
             if (node.classList.contains(leafName)) {
               arr.push(node);
             }
@@ -1873,8 +1993,7 @@ export class Matcher {
         }
         if (arr.length) {
           if (matchItems) {
-            const iterator = arr.values();
-            for (const node of iterator) {
+            for (const node of arr) {
               const bool = this._matchLeaves(items, node);
               if (bool) {
                 nodes.add(node);
@@ -1916,8 +2035,8 @@ export class Matcher {
             const a = [...document.getElementsByTagName(leafName)];
             arr.push(...a);
           } else if (root.nodeType === DOCUMENT_FRAGMENT_NODE) {
-            const iterator = [...root.children].values();
-            for (const node of iterator) {
+            const childNodes = [...root.children];
+            for (const node of childNodes) {
               if (node.localName === tagName) {
                 arr.push(node);
               }
@@ -1934,8 +2053,7 @@ export class Matcher {
         }
         if (arr.length) {
           if (matchItems) {
-            const iterator = arr.values();
-            for (const node of iterator) {
+            for (const node of arr) {
               const bool = this._matchLeaves(items, node);
               if (bool) {
                 nodes.add(node);
@@ -1948,6 +2066,7 @@ export class Matcher {
         break;
       }
       case PSEUDO_ELEMENT_SELECTOR: {
+        this._throwOnPseudoElementSelector(leafName);
         break;
       }
       default: {
@@ -1960,7 +2079,7 @@ export class Matcher {
         } else if (targetType === TARGET_LINEAL) {
           let refNode = this.#node;
           while (refNode) {
-            const bool = this._matchLeaves([leaf], refNode); ;
+            const bool = this._matchLeaves([leaf], refNode);
             if (bool) {
               arr.push(refNode);
             }
@@ -1971,8 +2090,7 @@ export class Matcher {
         }
         if (arr.length) {
           if (matchItems) {
-            const iterator = arr.values();
-            for (const node of iterator) {
+            for (const node of arr) {
               const bool = this._matchLeaves(items, node);
               if (bool) {
                 nodes.add(node);
@@ -1993,63 +2111,63 @@ export class Matcher {
   /**
    * collect nodes
    * @param {string} targetType - target type
-   * @returns {Array} - matrix
+   * @returns {Array.<Array.<object|undefined>>} - matrix
    */
   _collectNodes(targetType) {
-    const pendingItems = new Set();
     const ast = this.#ast.values();
-    let i = 0;
-    for (const { branch } of ast) {
-      if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
+    if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
+      const pendingItems = new Set();
+      let i = 0;
+      for (const { branch } of ast) {
         const twig = branch[0];
         const { nodes, pending } = this._findNodes(twig, targetType);
         if (nodes.size) {
           this.#nodes[i] = nodes;
         } else if (pending) {
           pendingItems.add(new Map([
-            ['i', i],
+            ['index', i],
             ['twig', twig]
           ]));
         } else {
           this.#ast[i].skip = true;
         }
-      } else {
-        const branchLen = branch.length;
-        const lastIndex = branchLen - 1;
-        const twig = branch[lastIndex];
-        const { nodes } = this._findNodes(twig, targetType);
-        if (nodes.size) {
-          this.#nodes[i] = nodes;
-        } else {
-          this.#ast[i].skip = true;
-        }
+        i++;
       }
-      i++;
-    }
-    if (pendingItems.size) {
-      const { document, root } = this.#root;
-      const iterator = document.createNodeIterator(root, SHOW_ELEMENT);
-      let nextNode = iterator.nextNode();
-      while (nextNode) {
-        let bool = false;
-        if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
+      if (pendingItems.size) {
+        const { document, root } = this.#root;
+        const iterator = document.createNodeIterator(root, SHOW_ELEMENT);
+        let nextNode = iterator.nextNode();
+        while (nextNode) {
+          let bool = false;
           if (this.#node.nodeType === ELEMENT_NODE) {
             bool = isSameOrDescendant(nextNode, this.#node);
           } else {
             bool = true;
           }
-        }
-        if (bool) {
-          for (const pendingItem of pendingItems) {
-            const { leaves } = pendingItem.get('twig');
-            const matched = this._matchLeaves(leaves, nextNode);
-            if (matched) {
-              const indexI = pendingItem.get('i');
-              this.#nodes[indexI].add(nextNode);
+          if (bool) {
+            for (const pendingItem of pendingItems) {
+              const { leaves } = pendingItem.get('twig');
+              const matched = this._matchLeaves(leaves, nextNode);
+              if (matched) {
+                const index = pendingItem.get('index');
+                this.#nodes[index].add(nextNode);
+              }
             }
           }
+          nextNode = iterator.nextNode();
+        }
+      }
+    } else {
+      let i = 0;
+      for (const { branch } of ast) {
+        const twig = branch[branch.length - 1];
+        const { nodes } = this._findNodes(twig, targetType);
+        if (nodes.size) {
+          this.#nodes[i] = nodes;
+        } else {
+          this.#ast[i].skip = true;
         }
-        nextNode = iterator.nextNode();
+        i++;
       }
     }
     return [
@@ -2061,7 +2179,7 @@ export class Matcher {
   /**
    * sort nodes
    * @param {object} nodes - collection of nodes
-   * @returns {Array} - collection of sorted nodes
+   * @returns {Array.<object|undefined>} - collection of sorted nodes
    */
   _sortNodes(nodes) {
     const arr = [...nodes];
@@ -2214,6 +2332,9 @@ export class Matcher {
    * @returns {boolean} - `true` if matched `false` otherwise
    */
   matches() {
+    if (this.#node.nodeType !== ELEMENT_NODE) {
+      throw new TypeError(`Unexpected node type: ${this.#node.nodeName}`);
+    }
     let res;
     try {
       const nodes = this._find(TARGET_SELF);
@@ -2229,6 +2350,9 @@ export class Matcher {
    * @returns {?object} - matched node
    */
   closest() {
+    if (this.#node.nodeType !== ELEMENT_NODE) {
+      throw new TypeError(`Unexpected node type: ${this.#node.nodeName}`);
+    }
     let res;
     try {
       const nodes = this._find(TARGET_LINEAL);

package/src/js/parser.js

@@ -72,7 +72,7 @@ export const unescapeSelector = (selector = '') => {
  */
 export const preprocess = (...args) => {
   if (!args.length) {
-    throw new TypeError('1 argument required, but only 0 present');
+    throw new TypeError('1 argument required, but only 0 present.');
   }
   let [selector] = args;
   if (typeof selector === 'string') {

package/types/js/matcher.d.ts

@@ -5,8 +5,8 @@ export class Matcher {
     });
     _onError(e: Error): void;
     _getRoot(node?: object): object;
-    _sortLeaves(leaves: object): any[];
-    _prepare(selector?: string): any[];
+    _sortLeaves(leaves: Array<object>): Array<object>;
+    _prepare(selector?: string): Array<Array<object | undefined>>;
     _collectNthChild(anb: {
         a: number;
         b: number;
@@ -21,8 +21,8 @@ export class Matcher {
     _matchAnPlusB(ast: object, node: object, nthName: string): object;
     _matchDirectionPseudoClass(ast: object, node: object): object | null;
     _matchLanguagePseudoClass(ast: object, node: object): object | null;
-    _matchHasPseudoFunc(leaves: any[], node: object): boolean;
-    _matchLogicalPseudoFunc(ast: object, node: object): object | null;
+    _matchHasPseudoFunc(leaves: Array<object>, node: object): boolean;
+    _matchLogicalPseudoFunc(astOpt: object, node: object): object | null;
     _matchPseudoClassSelector(ast: object, node: object): object;
     _matchAttributeSelector(ast: object, node: object): object | null;
     _matchClassSelector(ast: object, node: object): object | null;
@@ -30,13 +30,14 @@ export class Matcher {
     _matchPseudoElementSelector(ast: object, node: object): void;
     _matchTypeSelector(ast: object, node: object): object | null;
     _matchSelector(ast: object, node: object): object;
-    _matchLeaves(leaves: any[], node: object): boolean;
+    _matchLeaves(leaves: Array<object>, node: object): boolean;
+    _findDescendantNodes(leaves: Array<object>, refNode: object): object;
     _matchCombinator(twig: object, node: object, opt?: {
         find?: string;
     }): object;
     _findNodes(twig: object, targetType: string): object;
-    _collectNodes(targetType: string): any[];
-    _sortNodes(nodes: object): any[];
+    _collectNodes(targetType: string): Array<Array<object | undefined>>;
+    _sortNodes(nodes: object): Array<object | undefined>;
     _matchNodes(targetType: string): object;
     _find(targetType: string): object;
     matches(): boolean;