@asamuzakjp/dom-selector 8.2.0 → 8.2.1

package/package.json

@@ -25,20 +25,20 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@asamuzakjp/generational-cache": "^3.0.1",
     "bidi-js": "^1.0.3",
     "css-tree": "^3.2.1",
-    "is-potential-custom-element-name": "^1.0.1"
+    "is-potential-custom-element-name": "^1.0.1",
+    "lru-cache": "^11.5.2"
   },
   "devDependencies": {
     "@types/css-tree": "^2.3.11",
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.1.1",
     "c8": "^11.0.0",
     "chai": "^6.2.2",
     "commander": "^15.0.0",
-    "eslint": "^9.39.4",
+    "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-jsdoc": "^63.0.10",
+    "eslint-plugin-jsdoc": "^63.0.13",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-regexp": "^3.1.1",
     "eslint-plugin-unicorn": "^65.0.1",
@@ -47,7 +47,7 @@
     "mitata": "^1.0.34",
     "mocha": "^11.7.6",
     "neostandard": "^0.13.0",
-    "prettier": "^3.9.1",
+    "prettier": "^3.9.5",
     "sinon": "^22.0.0",
     "tinybench": "^6.0.2",
     "typescript": "^6.0.3",
@@ -88,5 +88,5 @@
   "engines": {
     "node": "^22.13.0 || >=24.0.0"
   },
-  "version": "8.2.0"
+  "version": "8.2.1"
 }

package/src/index.js

@@ -6,7 +6,7 @@
  */
 
 /* import */
-import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { LRUCache } from 'lru-cache';
 import { Finder } from './js/finder.js';
 import { Nwsapi } from './js/nwsapi.js';
 import { extractSubjectsAst } from './js/parser.js';
@@ -26,7 +26,7 @@ import {
   TARGET_LINEAL,
   TARGET_SELF
 } from './js/constant.js';
-const CACHE_SIZE = 2048;
+const CACHE_SIZE = 4096;
 
 /* regexp */
 const REG_SELECTOR = /[[\]():\\"'`]/;
@@ -60,11 +60,11 @@ export class DOMSelector {
     this.#window = window;
     this.#document = document ?? window.document;
     this.#idlUtils = idlUtils;
-    this.#cache = new GenerationalCache(cacheSize ?? CACHE_SIZE, {
-      strictvalidate: false
+    this.#cache = new LRUCache({
+      max: cacheSize ?? CACHE_SIZE
     });
     this.#finder = new Finder(this.#window);
-    this.#nwsapi = new Nwsapi(this.#window, this.#document);
+    this.#nwsapi = new Nwsapi(this.#window, this.#document, cacheSize);
   }
 
   /**

package/src/js/constant.js

@@ -7,6 +7,8 @@ export const ATRULE = 'Atrule';
 export const ATTR_SELECTOR = 'AttributeSelector';
 export const CLASS_SELECTOR = 'ClassSelector';
 export const COMBINATOR = 'Combinator';
+export const DIR_NEXT = 'next';
+export const DIR_PREV = 'prev';
 export const IDENT = 'Identifier';
 export const ID_SELECTOR = 'IdSelector';
 export const NOT_SUPPORTED_ERR = 'NotSupportedError';

package/src/js/evaluator.js

@@ -19,7 +19,6 @@ import {
   isCustomElement,
   isFocusVisible,
   isFocusableArea,
-  isVisible,
   populateHasAllowlist,
   resolveContent,
   traverseNode
@@ -30,6 +29,8 @@ import {
   ATTR_SELECTOR,
   CLASS_SELECTOR,
   COMBINATOR,
+  DIR_NEXT,
+  DIR_PREV,
   DOCUMENT_FRAGMENT_NODE,
   ELEMENT_NODE,
   FORM_PARTS,
@@ -49,8 +50,6 @@ import {
   TEXT_NODE,
   TYPE_SELECTOR
 } from './constant.js';
-const DIR_NEXT = 'next';
-const DIR_PREV = 'prev';
 const KEYS_FORM = new Set([...FORM_PARTS, 'fieldset', 'form']);
 const KEYS_FORM_PS_VALID = new Set([...FORM_PARTS, 'form']);
 const KEYS_INPUT_CHECK = new Set(INPUT_CHECK);
@@ -141,6 +140,33 @@ export class Evaluator {
     this._registerEventListeners();
   }
 
+  /**
+   * Sets up the evaluator.
+   * @param {string} selector - The CSS selector.
+   * @param {object} node - Document, DocumentFragment, or Element.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.check] - Indicates if running in internal check().
+   * @param {boolean} [opt.noexcept] - If true, exceptions are not thrown.
+   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
+   * @returns {object} The evaluator instance.
+   */
+  setup(selector, node, opt = {}) {
+    const { check, noexcept, warn } = opt;
+    this.check = !!check;
+    this.noexcept = !!noexcept;
+    this.warn = !!warn;
+    this.matchOpts = { warn: this.warn };
+    [this.document, this.root, this.shadow] = resolveContent(node);
+    this.node = node;
+    this.pseudoElements = [];
+    this.invalidate = false;
+    this.clearResults();
+    this.#documentURL = null;
+    this.#verifyShadowHost = false;
+    this.#walkers = null;
+    return this;
+  }
+
   /**
    * Handles errors.
    * @param {Error} e - The error object.
@@ -171,39 +197,12 @@ export class Evaluator {
     throw e;
   };
 
-  /**
-   * Sets up the evaluator.
-   * @param {string} selector - The CSS selector.
-   * @param {object} node - Document, DocumentFragment, or Element.
-   * @param {object} [opt] - Options.
-   * @param {boolean} [opt.check] - Indicates if running in internal check().
-   * @param {boolean} [opt.noexcept] - If true, exceptions are not thrown.
-   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
-   * @returns {object} The matcher instance.
-   */
-  setup(selector, node, opt = {}) {
-    const { check, noexcept, warn } = opt;
-    this.check = !!check;
-    this.noexcept = !!noexcept;
-    this.warn = !!warn;
-    this.matchOpts = { warn: this.warn };
-    [this.document, this.root, this.shadow] = resolveContent(node);
-    this.node = node;
-    this.pseudoElements = [];
-    this.invalidate = false;
-    this.clearResults();
-    this.#documentURL = null;
-    this.#verifyShadowHost = false;
-    this.#walkers = null;
-    return this;
-  }
-
   /**
    * Clear cached results.
    * @param {boolean} all - Clear all results.
    * @returns {void}
    */
-  clearResults(all = false) {
+  clearResults = (all = false) => {
     this.#anbCache = null;
     this.#focusWithinCache = null;
     this.#invalidateResults = null;
@@ -217,7 +216,7 @@ export class Evaluator {
       this.#filterLeavesCache = null;
       this.#results = new WeakMap();
     }
-  }
+  };
 
   /**
    * Matches a selector.
@@ -253,9 +252,11 @@ export class Evaluator {
     }
     const results = this.invalidate ? this.#invalidateResults : this.#results;
     let result = results.get(leaves);
-    if (result && result.has(node)) {
-      const { matched } = result.get(node);
-      return matched;
+    if (result) {
+      const nodeResult = result.get(node);
+      if (nodeResult) {
+        return nodeResult.matched;
+      }
     }
     let cacheable = true;
     if (node.nodeType === ELEMENT_NODE && KEYS_FORM.has(node.localName)) {
@@ -307,10 +308,11 @@ export class Evaluator {
     if (!this.#filterLeavesCache) {
       this.#filterLeavesCache = new WeakMap();
     }
-    if (this.#filterLeavesCache.has(leaves)) {
-      return this.#filterLeavesCache.get(leaves);
+    let filterLeaves = this.#filterLeavesCache.get(leaves);
+    if (filterLeaves) {
+      return filterLeaves;
     }
-    const filterLeaves = leaves.slice(1);
+    filterLeaves = leaves.slice(1);
     this.#filterLeavesCache.set(leaves, filterLeaves);
     return filterLeaves;
   };
@@ -518,7 +520,7 @@ export class Evaluator {
               this.#psDefaultCache = new WeakMap();
             }
             let defaultSubmit = this.#psDefaultCache.get(form);
-            if (!defaultSubmit) {
+            if (defaultSubmit === undefined) {
               const walker = this.createTreeWalker(form, { force: true });
               let refNode = traverseNode(form, walker);
               refNode = walker.firstChild();
@@ -587,7 +589,7 @@ export class Evaluator {
             this.#psIndeterminateCache = new WeakMap();
           }
           let parentCache = this.#psIndeterminateCache.get(parent);
-          if (!parentCache) {
+          if (parentCache === undefined) {
             parentCache = new Map();
             this.#psIndeterminateCache.set(parent, parentCache);
           }
@@ -644,7 +646,7 @@ export class Evaluator {
             this.#psValidCache = new WeakMap();
           }
           let valid = this.#psValidCache.get(node);
-          if (valid === undefined && !this.#psValidCache.has(node)) {
+          if (valid === undefined) {
             const walker = this.createTreeWalker(node, { force: true });
             let refNode = traverseNode(node, walker);
             refNode = walker.firstChild();
@@ -919,6 +921,9 @@ export class Evaluator {
         if (!this.#focusWithinCache) {
           this.#focusWithinCache = new Set();
           let currentFocus = this.document.activeElement;
+          while (currentFocus?.shadowRoot?.activeElement) {
+            currentFocus = currentFocus.shadowRoot.activeElement;
+          }
           if (currentFocus && isFocusableArea(currentFocus)) {
             while (currentFocus) {
               this.#focusWithinCache.add(currentFocus);
@@ -933,23 +938,6 @@ export class Evaluator {
                 break;
               }
             }
-          } else if (currentFocus && currentFocus.shadowRoot) {
-            let shadowFocus = currentFocus.shadowRoot.activeElement;
-            if (shadowFocus) {
-              while (shadowFocus) {
-                this.#focusWithinCache.add(shadowFocus);
-                if (shadowFocus.parentNode) {
-                  shadowFocus = shadowFocus.parentNode;
-                } else if (
-                  shadowFocus.nodeType === DOCUMENT_FRAGMENT_NODE &&
-                  shadowFocus.host
-                ) {
-                  shadowFocus = shadowFocus.host;
-                } else {
-                  break;
-                }
-              }
-            }
           }
         }
         return this.#focusWithinCache.has(node);
@@ -1047,10 +1035,11 @@ export class Evaluator {
     if (!this.#walkers) {
       this.#walkers = new WeakMap();
     }
-    if (this.#walkers.has(node)) {
-      return this.#walkers.get(node);
+    let walker = this.#walkers.get(node);
+    if (walker) {
+      return walker;
     }
-    const walker = this.document.createTreeWalker(node, whatToShow);
+    walker = this.document.createTreeWalker(node, whatToShow);
     this.#walkers.set(node, walker);
     return walker;
   };
@@ -1116,7 +1105,11 @@ export class Evaluator {
       case ' ':
       default: {
         if (dir === DIR_NEXT) {
-          for (const refNode of this._findDescendantNodes(leaves, node, opt)) {
+          for (const refNode of this.yieldFindDescendantNodes(
+            leaves,
+            node,
+            opt
+          )) {
             yield refNode;
           }
         } else {
@@ -1138,6 +1131,99 @@ export class Evaluator {
     }
   }
 
+  /**
+   * Traverses all descendant nodes and yields matches.
+   * @param {object} baseNode - The base Element node or Element.shadowRoot.
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} opt - Options.
+   * @yields {object} The matched node.
+   */
+  *yieldTraverseAllDescendants(baseNode, leaves, opt) {
+    const walker = this.createTreeWalker(baseNode);
+    traverseNode(baseNode, walker);
+    let currentNode = walker.firstChild();
+    while (currentNode) {
+      if (this.matchLeaves(leaves, currentNode, opt)) {
+        yield currentNode;
+      }
+      currentNode = walker.nextNode();
+    }
+  }
+
+  /**
+   * Finds descendant nodes and yields matches.
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} baseNode - The base Element node or Element.shadowRoot.
+   * @param {object} opt - Options.
+   * @yields {object} The matched node.
+   */
+  *yieldFindDescendantNodes(leaves, baseNode, opt) {
+    const [{ name, type: leafType }] = leaves;
+    const leafName = unescapeSelector(name);
+    const filterLeaves = this.getFilterLeaves(leaves);
+    const isSimple = filterLeaves.length === 0;
+
+    switch (leafType) {
+      case ID_SELECTOR: {
+        if (
+          !this.shadow &&
+          baseNode.nodeType === ELEMENT_NODE &&
+          this.root.nodeType !== ELEMENT_NODE
+        ) {
+          const foundNode = this.root.getElementById(leafName);
+          if (
+            foundNode &&
+            foundNode !== baseNode &&
+            baseNode.contains(foundNode)
+          ) {
+            if (isSimple || this.matchLeaves(filterLeaves, foundNode, opt)) {
+              yield foundNode;
+            }
+          }
+          return;
+        }
+        break;
+      }
+      case CLASS_SELECTOR: {
+        if (typeof baseNode.getElementsByClassName === 'function') {
+          const collection = baseNode.getElementsByClassName(leafName);
+          for (let i = 0, len = collection.length; i < len; i++) {
+            const foundNode = collection[i];
+            if (isSimple || this.matchLeaves(filterLeaves, foundNode, opt)) {
+              yield foundNode;
+            }
+          }
+          return;
+        }
+        break;
+      }
+      case TYPE_SELECTOR: {
+        if (
+          typeof baseNode.getElementsByTagName === 'function' &&
+          !leafName.includes('|')
+        ) {
+          const collection = baseNode.getElementsByTagName(leafName);
+          for (let i = 0, len = collection.length; i < len; i++) {
+            const foundNode = collection[i];
+            if (isSimple || this.matchLeaves(filterLeaves, foundNode, opt)) {
+              yield foundNode;
+            }
+          }
+          return;
+        }
+        break;
+      }
+      case PS_ELEMENT_SELECTOR: {
+        matchPseudoElementSelector(leafName, leafType, opt);
+        return;
+      }
+      default: {
+        // no-op
+      }
+    }
+    yield* this.yieldTraverseAllDescendants(baseNode, leaves, opt);
+  }
+
   /**
    * Handles focus events.
    * @private
@@ -1201,16 +1287,37 @@ export class Evaluator {
    * @returns {Array.<Array.<object>>} The selector branches.
    */
   _getSelectorBranches = selector => {
-    if (this.#astCache.has(selector)) {
-      return this.#astCache.get(selector);
+    let branches = this.#astCache.get(selector);
+    if (branches) {
+      return branches;
     }
-    const { branches } = walkAST(selector);
+    const walkedResult = walkAST(selector);
+    branches = walkedResult.branches;
     this.#astCache.set(selector, branches);
     return branches;
   };
 
   /**
-   * Evaluates An+B mathematically (O(1) without generating new arrays/sets).
+   * Checks if a node matches any of the given selector branches.
+   * @private
+   * @param {Array.<Array.<object>>} branches - The selector branches to test.
+   * @param {object} node - The element node to match against.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {boolean} True if any branch matches, otherwise false.
+   */
+  _filterNthChildOfSelectorBranches = (branches, node, opt) => {
+    let filterMatch = false;
+    for (const branch of branches) {
+      if (this.matchLeaves(branch, node, opt)) {
+        filterMatch = true;
+        break;
+      }
+    }
+    return filterMatch;
+  };
+
+  /**
+   * Evaluates An+B mathematically.
    * @private
    * @param {object} ast - The AST.
    * @param {object} node - The Element node.
@@ -1219,16 +1326,32 @@ export class Evaluator {
    * @returns {boolean} True if matches, otherwise false.
    */
   _matchAnPlusB = (ast, node, nthName, opt) => {
+    const {
+      localName,
+      namespaceURI,
+      nextElementSibling,
+      parentNode,
+      previousElementSibling
+    } = node;
+    if (!parentNode && node !== this.root) {
+      return false;
+    }
     if (!this.#anbCache) {
       this.#anbCache = new WeakMap();
     }
     let anb = this.#anbCache.get(ast);
-    if (!anb) {
+    if (anb === undefined) {
       const {
         nth: { a, b, name: nthIdentName },
         selector
       } = ast;
-      anb = { a: 0, b: 0, selector: null };
+      anb = {
+        a: 0,
+        b: 0,
+        isLast: nthName.includes('last'),
+        isOfType: nthName.includes('of-type'),
+        selector: null
+      };
       if (nthIdentName) {
         if (nthIdentName === 'even') {
           anb.a = 2;
@@ -1238,78 +1361,62 @@ export class Evaluator {
           anb.b = 1;
         }
       } else {
-        anb.a = typeof a === 'string' && /-?\d+/.test(a) ? a * 1 : 0;
-        anb.b = typeof b === 'string' && /-?\d+/.test(b) ? b * 1 : 0;
+        const intA = parseInt(a);
+        if (Number.isInteger(intA)) {
+          anb.a = intA;
+        }
+        const intB = parseInt(b);
+        if (Number.isInteger(intB)) {
+          anb.b = intB;
+        }
       }
-      if (
-        selector &&
-        (nthName === 'nth-child' || nthName === 'nth-last-child')
-      ) {
+      if (selector && /^nth-(?:last-)?child$/.test(nthName)) {
         anb.selector = selector;
       }
       this.#anbCache.set(ast, anb);
     }
-    if (
-      nthName !== 'nth-child' &&
-      nthName !== 'nth-last-child' &&
-      nthName !== 'nth-of-type' &&
-      nthName !== 'nth-last-of-type'
-    ) {
-      return false;
-    }
-    const isLast = nthName.includes('last');
-    const isOfType = nthName.includes('of-type');
-    const hasFilter = !!anb.selector;
-    if (hasFilter) {
-      const selectorBranches = this._getSelectorBranches(anb.selector);
-      let filterMatch = false;
-      for (let i = 0; i < selectorBranches.length; i++) {
-        if (this.matchLeaves(selectorBranches[i], node, opt)) {
-          filterMatch = true;
-          break;
-        }
-      }
+    const { a, b, isLast, isOfType, selector: anbSelector } = anb;
+    const startNode = isLast ? nextElementSibling : previousElementSibling;
+    let pos = 1;
+    if (anbSelector) {
+      const selectorBranches = this._getSelectorBranches(anbSelector);
+      const filterMatch = this._filterNthChildOfSelectorBranches(
+        selectorBranches,
+        node,
+        opt
+      );
       if (!filterMatch) {
         return false;
       }
-    }
-    const { parentNode } = node;
-    if (!parentNode && node !== this.root) {
-      return false;
-    }
-    let pos = 1;
-    let current = isLast
-      ? node.nextElementSibling
-      : node.previousElementSibling;
-    while (current) {
-      let match = true;
-      if (isOfType) {
-        match =
-          current.localName === node.localName &&
-          current.namespaceURI === node.namespaceURI;
-      } else if (hasFilter) {
-        const selectorBranches = this._getSelectorBranches(anb.selector);
-        let filterMatch = false;
-        for (let i = 0; i < selectorBranches.length; i++) {
-          if (this.matchLeaves(selectorBranches[i], current, opt)) {
-            filterMatch = true;
-            break;
-          }
+      let current = startNode;
+      while (current) {
+        if (
+          this._filterNthChildOfSelectorBranches(selectorBranches, current, opt)
+        ) {
+          pos++;
         }
-        if (filterMatch && (this.node === current || isVisible(current))) {
-          match = true;
+        current = isLast
+          ? current.nextElementSibling
+          : current.previousElementSibling;
+      }
+    } else {
+      let current = startNode;
+      while (current) {
+        if (isOfType) {
+          if (
+            current.localName === localName &&
+            current.namespaceURI === namespaceURI
+          ) {
+            pos++;
+          }
         } else {
-          match = false;
+          pos++;
         }
+        current = isLast
+          ? current.nextElementSibling
+          : current.previousElementSibling;
       }
-      if (match) {
-        pos++;
-      }
-      current = isLast
-        ? current.nextElementSibling
-        : current.previousElementSibling;
     }
-    const { a, b } = anb;
     if (a === 0) {
       return pos === b;
     }
@@ -1576,7 +1683,7 @@ export class Evaluator {
       this.#psHasFilterCache = new WeakMap();
     }
     let rootCache = this.#psHasFilterCache.get(this.root);
-    if (!rootCache) {
+    if (rootCache === undefined) {
       rootCache = new WeakMap();
       this.#psHasFilterCache.set(this.root, rootCache);
     }
@@ -2032,118 +2139,4 @@ export class Evaluator {
     }
     return false;
   };
-
-  /**
-   * Traverses all descendant nodes and collects matches.
-   * @private
-   * @param {object} baseNode - The base Element node or Element.shadowRoot.
-   * @param {Array.<object>} leaves - The AST leaves.
-   * @param {object} opt - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
-   */
-  _traverseAllDescendants = (baseNode, leaves, opt) => {
-    const walker = this.createTreeWalker(baseNode);
-    traverseNode(baseNode, walker);
-    let currentNode = walker.firstChild();
-    const nodes = new Set();
-    while (currentNode) {
-      if (this.matchLeaves(leaves, currentNode, opt)) {
-        nodes.add(currentNode);
-      }
-      currentNode = walker.nextNode();
-    }
-    return nodes;
-  };
-
-  /**
-   * Finds descendant nodes.
-   * @private
-   * @param {Array.<object>} leaves - The AST leaves.
-   * @param {object} baseNode - The base Element node or Element.shadowRoot.
-   * @param {object} opt - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
-   */
-  _findDescendantNodes = (leaves, baseNode, opt) => {
-    const [leaf] = leaves;
-    const filterLeaves = this.getFilterLeaves(leaves);
-    const { type: leafType } = leaf;
-    switch (leafType) {
-      case ID_SELECTOR: {
-        const canUseGetElementById =
-          !this.shadow &&
-          baseNode.nodeType === ELEMENT_NODE &&
-          this.root.nodeType !== ELEMENT_NODE;
-        if (canUseGetElementById) {
-          const leafName = unescapeSelector(leaf.name);
-          const nodes = new Set();
-          const foundNode = this.root.getElementById(leafName);
-          if (
-            foundNode &&
-            foundNode !== baseNode &&
-            baseNode.contains(foundNode)
-          ) {
-            const isCompoundSelector = filterLeaves.length > 0;
-            if (
-              !isCompoundSelector ||
-              this.matchLeaves(filterLeaves, foundNode, opt)
-            ) {
-              nodes.add(foundNode);
-            }
-          }
-          return nodes;
-        }
-        break;
-      }
-      case CLASS_SELECTOR: {
-        if (typeof baseNode.getElementsByClassName === 'function') {
-          const leafName = unescapeSelector(leaf.name);
-          const collection = baseNode.getElementsByClassName(leafName);
-          const nodes = new Set();
-          const isCompoundSelector = filterLeaves.length > 0;
-          for (let i = 0, len = collection.length; i < len; i++) {
-            const foundNode = collection[i];
-            if (
-              !isCompoundSelector ||
-              this.matchLeaves(filterLeaves, foundNode, opt)
-            ) {
-              nodes.add(foundNode);
-            }
-          }
-          return nodes;
-        }
-        break;
-      }
-      case TYPE_SELECTOR: {
-        const leafName = unescapeSelector(leaf.name);
-        if (
-          typeof baseNode.getElementsByTagName === 'function' &&
-          !leafName.includes('|')
-        ) {
-          const collection = baseNode.getElementsByTagName(leafName);
-          const nodes = new Set();
-          const isCompoundSelector = filterLeaves.length > 0;
-          for (let i = 0, len = collection.length; i < len; i++) {
-            const foundNode = collection[i];
-            if (
-              !isCompoundSelector ||
-              this.matchLeaves(filterLeaves, foundNode, opt)
-            ) {
-              nodes.add(foundNode);
-            }
-          }
-          return nodes;
-        }
-        break;
-      }
-      case PS_ELEMENT_SELECTOR: {
-        const leafName = unescapeSelector(leaf.name);
-        matchPseudoElementSelector(leafName, leafType, opt);
-        return new Set();
-      }
-      default: {
-        // no-op
-      }
-    }
-    return this._traverseAllDescendants(baseNode, leaves, opt);
-  };
 }

package/src/js/finder.js

@@ -19,6 +19,8 @@ import { generateException, sortNodes, traverseNode } from './utility.js';
 import {
   CLASS_SELECTOR,
   COMBINATOR,
+  DIR_NEXT,
+  DIR_PREV,
   DOCUMENT_FRAGMENT_NODE,
   ELEMENT_NODE,
   ID_SELECTOR,
@@ -30,8 +32,6 @@ import {
   TARGET_SELF,
   TYPE_SELECTOR
 } from './constant.js';
-const DIR_NEXT = 'next';
-const DIR_PREV = 'prev';
 
 /**
  * Finder
@@ -70,6 +70,117 @@ export class Finder extends Evaluator {
     return this;
   }
 
+  /**
+   * Finds matched nodes.
+   * @param {string} targetType - The target type.
+   * @returns {Set.<object>|object} A collection of matched nodes.
+   */
+  find = targetType => {
+    let collection;
+    try {
+      collection = this._collectNodes(targetType);
+    } catch (e) {
+      if (this.check) {
+        return {
+          ast: this.#selectorAST,
+          match: false,
+          pseudoElement: this.pseudoElements.length
+            ? this.pseudoElements.join('')
+            : null
+        };
+      } else {
+        throw e;
+      }
+    }
+    const [[...branches], collectedNodes] = collection;
+    const l = branches.length;
+    let sort = l > 1 && targetType === TARGET_ALL;
+    let nodes = new Set();
+    for (let i = 0; i < l; i++) {
+      const { branch, dir, find } = branches[i];
+      if (!branch.length || !find) {
+        continue;
+      }
+      const entryNodes = collectedNodes[i];
+      const lastIndex = branch.length - 1;
+      if (lastIndex === 0) {
+        if (
+          (targetType === TARGET_ALL || targetType === TARGET_FIRST) &&
+          this.node.nodeType === ELEMENT_NODE
+        ) {
+          for (const node of entryNodes) {
+            if (node !== this.node) {
+              if (targetType === TARGET_ALL || this.node.contains(node)) {
+                nodes.add(node);
+                if (targetType === TARGET_FIRST) {
+                  break;
+                }
+              }
+            }
+          }
+        } else if (targetType === TARGET_ALL) {
+          if (nodes.size) {
+            for (const node of entryNodes) {
+              nodes.add(node);
+            }
+            sort = true;
+          } else {
+            nodes = new Set(entryNodes);
+          }
+        } else {
+          if (entryNodes.length) {
+            nodes.add(entryNodes[0]);
+          }
+        }
+      } else if (targetType === TARGET_ALL) {
+        const newNodes = this._processComplexBranchAll(branch, entryNodes, dir);
+        if (nodes.size) {
+          for (const newNode of newNodes) {
+            nodes.add(newNode);
+          }
+          sort = true;
+        } else {
+          nodes = newNodes;
+        }
+      } else {
+        const matchedNode = this._processComplexBranchFirst(
+          branch,
+          entryNodes,
+          dir,
+          targetType
+        );
+        if (matchedNode) {
+          nodes.add(matchedNode);
+        }
+      }
+    }
+    if (this.check) {
+      return {
+        ast: this.#selectorAST,
+        match: nodes.size > 0,
+        pseudoElement: this.pseudoElements.length
+          ? this.pseudoElements.join('')
+          : null
+      };
+    }
+    if (targetType === TARGET_FIRST || targetType === TARGET_ALL) {
+      nodes.delete(this.node);
+    }
+    if ((sort || targetType === TARGET_FIRST) && nodes.size > 1) {
+      return new Set(sortNodes(nodes));
+    }
+    return nodes;
+  };
+
+  /**
+   * Gets AST for selector.
+   * @param {string} selector - The selector text.
+   * @returns {object} The AST for the selector.
+   */
+  getAST = selector => {
+    return parseSelector(selector);
+  };
+
   /**
    * Processes selector branches into the internal AST structure.
    * @private
@@ -1014,115 +1125,4 @@ export class Finder extends Evaluator {
     }
     return null;
   };
-
-  /**
-   * Finds matched nodes.
-   * @param {string} targetType - The target type.
-   * @returns {Set.<object>|object} A collection of matched nodes.
-   */
-  find = targetType => {
-    let collection;
-    try {
-      collection = this._collectNodes(targetType);
-    } catch (e) {
-      if (this.check) {
-        return {
-          ast: this.#selectorAST,
-          match: false,
-          pseudoElement: this.pseudoElements.length
-            ? this.pseudoElements.join('')
-            : null
-        };
-      } else {
-        throw e;
-      }
-    }
-    const [[...branches], collectedNodes] = collection;
-    const l = branches.length;
-    let sort = l > 1 && targetType === TARGET_ALL;
-    let nodes = new Set();
-    for (let i = 0; i < l; i++) {
-      const { branch, dir, find } = branches[i];
-      if (!branch.length || !find) {
-        continue;
-      }
-      const entryNodes = collectedNodes[i];
-      const lastIndex = branch.length - 1;
-      if (lastIndex === 0) {
-        if (
-          (targetType === TARGET_ALL || targetType === TARGET_FIRST) &&
-          this.node.nodeType === ELEMENT_NODE
-        ) {
-          for (const node of entryNodes) {
-            if (node !== this.node) {
-              if (targetType === TARGET_ALL || this.node.contains(node)) {
-                nodes.add(node);
-                if (targetType === TARGET_FIRST) {
-                  break;
-                }
-              }
-            }
-          }
-        } else if (targetType === TARGET_ALL) {
-          if (nodes.size) {
-            for (const node of entryNodes) {
-              nodes.add(node);
-            }
-            sort = true;
-          } else {
-            nodes = new Set(entryNodes);
-          }
-        } else {
-          if (entryNodes.length) {
-            nodes.add(entryNodes[0]);
-          }
-        }
-      } else if (targetType === TARGET_ALL) {
-        const newNodes = this._processComplexBranchAll(branch, entryNodes, dir);
-        if (nodes.size) {
-          for (const newNode of newNodes) {
-            nodes.add(newNode);
-          }
-          sort = true;
-        } else {
-          nodes = newNodes;
-        }
-      } else {
-        const matchedNode = this._processComplexBranchFirst(
-          branch,
-          entryNodes,
-          dir,
-          targetType
-        );
-        if (matchedNode) {
-          nodes.add(matchedNode);
-        }
-      }
-    }
-    if (this.check) {
-      return {
-        ast: this.#selectorAST,
-        match: nodes.size > 0,
-        pseudoElement: this.pseudoElements.length
-          ? this.pseudoElements.join('')
-          : null
-      };
-    }
-    if (targetType === TARGET_FIRST || targetType === TARGET_ALL) {
-      nodes.delete(this.node);
-    }
-    if ((sort || targetType === TARGET_FIRST) && nodes.size > 1) {
-      return new Set(sortNodes(nodes));
-    }
-    return nodes;
-  };
-
-  /**
-   * Gets AST for selector.
-   * @param {string} selector - The selector text.
-   * @returns {object} The AST for the selector.
-   */
-  getAST = selector => {
-    return parseSelector(selector);
-  };
 }

package/src/js/matcher.js

@@ -33,6 +33,8 @@ const KEYS_FORM_PS_DISABLED = new Set([
   'option'
 ]);
 const KEYS_INPUT_EDIT = new Set(INPUT_EDIT);
+
+/* regexp */
 const REG_LANG_VALID = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
 
 /**

package/src/js/nwsapi.js

@@ -5,7 +5,7 @@
  */
 
 /* import */
-import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { LRUCache } from 'lru-cache';
 import { isContentEditable } from './utility.js';
 
 /* constants */
@@ -465,13 +465,12 @@ export class Nwsapi {
   constructor(window, document, cacheSize = CACHE_SIZE) {
     this.#window = window;
     const cacheOpt = {
-      cacheFunction: true,
-      strictValidate: false
+      max: cacheSize
     };
-    this.#matchLambdas = new GenerationalCache(cacheSize, cacheOpt);
-    this.#selectLambdas = new GenerationalCache(cacheSize, cacheOpt);
-    this.#matchResolvers = new GenerationalCache(cacheSize, cacheOpt);
-    this.#selectResolvers = new GenerationalCache(cacheSize, cacheOpt);
+    this.#matchLambdas = new LRUCache(cacheOpt);
+    this.#selectLambdas = new LRUCache(cacheOpt);
+    this.#matchResolvers = new LRUCache(cacheOpt);
+    this.#selectResolvers = new LRUCache(cacheOpt);
     this.#nthChildState = {
       idx: 0,
       len: 0,

package/src/js/parser.js

@@ -55,10 +55,12 @@ const KEYS_PS_CLASS_STATE = new Set([
   'valid'
 ]);
 const KEYS_SHADOW_HOST = new Set(['host', 'host-context']);
+const U_FFFD = '\uFFFD';
+
+/* regexp */
 const REG_EMPTY_PS_FUNC =
   /(?<=:(?:dir|has|host(?:-context)?|is|lang|not|nth-(?:last-)?(?:child|of-type)|where))\(\s+\)/g;
 const REG_SHADOW_PS_ELEMENT = /^part|slotted$/;
-const U_FFFD = '\uFFFD';
 
 /**
  * Unescapes a CSS selector string.

package/src/js/utility.js

@@ -45,6 +45,8 @@ const KEYS_NODE_FOCUSABLE_SVG = new Set([
   'symbol',
   'title'
 ]);
+
+/* regexp */
 const REG_IS_HTML = /^(?:application\/xhtml\+x|text\/ht)ml$/;
 const REG_IS_XML =
   /^(?:application\/(?:[\w\-.]+\+)?|image\/[\w\-.]+\+|text\/)xml$/;

package/types/js/constant.d.ts

@@ -2,6 +2,8 @@ export const ATRULE: "Atrule";
 export const ATTR_SELECTOR: "AttributeSelector";
 export const CLASS_SELECTOR: "ClassSelector";
 export const COMBINATOR: "Combinator";
+export const DIR_NEXT: "next";
+export const DIR_PREV: "prev";
 export const IDENT: "Identifier";
 export const ID_SELECTOR: "IdSelector";
 export const NOT_SUPPORTED_ERR: "NotSupportedError";

package/types/js/evaluator.d.ts

@@ -2,9 +2,6 @@ export class Evaluator {
     constructor(window: object);
     window: object;
     documentCache: WeakMap<WeakKey, any>;
-    onError: (e: Error, opt?: {
-        noexcept?: boolean | undefined;
-    }) => void;
     setup(selector: string, node: object, opt?: {
         check?: boolean | undefined;
         noexcept?: boolean | undefined;
@@ -19,7 +16,10 @@ export class Evaluator {
     node: object | undefined;
     pseudoElements: any[] | undefined;
     invalidate: boolean | undefined;
-    clearResults(all?: boolean): void;
+    onError: (e: Error, opt?: {
+        noexcept?: boolean | undefined;
+    }) => void;
+    clearResults: (all?: boolean) => void;
     matchSelector: (ast: object, node: object, opt: object) => boolean;
     matchLeaves: (leaves: Array<object>, node: object, opt: object) => boolean;
     getFilterLeaves: (leaves: Array<object>) => Array<object>;
@@ -35,11 +35,14 @@ export class Evaluator {
     yieldCombinatorMatches(twig: object, node: object, opt?: {
         dir?: string | undefined;
     }): Generator<any, void, unknown>;
+    yieldTraverseAllDescendants(baseNode: object, leaves: Array<object>, opt: object): Generator<any, void, unknown>;
+    yieldFindDescendantNodes(leaves: Array<object>, baseNode: object, opt: object): Generator<any, void, unknown>;
     private _handleFocusEvent;
     private _handleKeyboardEvent;
     private _handleMouseEvent;
     private _registerEventListeners;
     private _getSelectorBranches;
+    private _filterNthChildOfSelectorBranches;
     private _matchAnPlusB;
     private _hasCombinatorMatch;
     private _matchHasPseudoFunc;
@@ -52,7 +55,5 @@ export class Evaluator {
     private _evaluateHostContextPseudo;
     private _matchSelectorForElement;
     private _matchSelectorForShadowRoot;
-    private _traverseAllDescendants;
-    private _findDescendantNodes;
     #private;
 }

package/types/js/finder.d.ts

@@ -1,4 +1,6 @@
 export class Finder extends Evaluator {
+    find: (targetType: string) => Set<object> | object;
+    getAST: (selector: string) => object;
     private _processSelectorBranches;
     private _correspond;
     private _traverseAndCollectNodes;
@@ -19,8 +21,6 @@ export class Finder extends Evaluator {
     private _hasValidPathPrev;
     private _processComplexBranchAll;
     private _processComplexBranchFirst;
-    find: (targetType: string) => Set<object> | object;
-    getAST: (selector: string) => object;
     #private;
 }
 import { Evaluator } from './evaluator.js';