@asamuzakjp/dom-selector 8.0.1 → 8.1.1

package/src/js/finder.js

@@ -13,21 +13,22 @@ import {
   matchTypeSelector
 } from './matcher.js';
 import {
-  findAST,
   generateCSS,
   parseSelector,
   sortAST,
   unescapeSelector,
   walkAST
 } from './parser.js';
+import { createHasValidator, isInvalidCombinator } from './selector.js';
 import {
   filterNodesByAnB,
-  findLogicalWithNestedHas,
+  findBestSeed,
   generateException,
   isCustomElement,
   isFocusVisible,
   isFocusableArea,
   isVisible,
+  populateHasAllowlist,
   resolveContent,
   sortNodes,
   traverseNode
@@ -41,6 +42,7 @@ import {
   DOCUMENT_FRAGMENT_NODE,
   ELEMENT_NODE,
   FORM_PARTS,
+  HEX,
   ID_SELECTOR,
   INPUT_CHECK,
   INPUT_DATE,
@@ -60,6 +62,8 @@ import {
   TEXT_NODE,
   TYPE_SELECTOR
 } from './constant.js';
+const ANB_FIRST = { a: 0, b: 1 };
+const ANB_LAST = { a: 0, b: 1, reverse: true };
 const DIR_NEXT = 'next';
 const DIR_PREV = 'prev';
 const KEYS_FORM = new Set([...FORM_PARTS, 'fieldset', 'form']);
@@ -105,17 +109,20 @@ const KEYS_PS_NTH_OF_TYPE = new Set([
  */
 export class Finder {
   /* private fields */
+  #anbCache;
   #ast;
-  #astCache;
+  #astCache = new WeakMap();
   #check;
+  #combinatorCache;
   #descendant;
   #document;
-  #documentCache;
+  #documentCache = new WeakMap();
   #documentURL;
   #event;
   #eventHandlers;
   #filterLeavesCache;
   #focus;
+  #focusWithinCache;
   #invalidate;
   #invalidateResults;
   #lastFocusVisible;
@@ -123,6 +130,17 @@ export class Finder {
   #nodeWalker;
   #nodes;
   #noexcept;
+  #nthChildCache;
+  #nthChildOfCache;
+  #nthChildResultCache;
+  #nthOfTypeCache;
+  #nthOfTypeResultCache;
+  #psDefaultCache;
+  #psDirCache;
+  #psHasFilterCache;
+  #psIndeterminateCache;
+  #psLangCache;
+  #psValidCache;
   #pseudoElement;
   #results;
   #root;
@@ -131,6 +149,7 @@ export class Finder {
   #selector;
   #selectorAST;
   #shadow;
+  #targetWithinCache;
   #verifyShadowHost;
   #walkers;
   #warn;
@@ -142,11 +161,6 @@ export class Finder {
    */
   constructor(window) {
     this.#window = window;
-    this.#astCache = new WeakMap();
-    this.#documentCache = new WeakMap();
-    this.#event = null;
-    this.#focus = null;
-    this.#lastFocusVisible = null;
     this.#eventHandlers = new Set([
       {
         keys: ['focus', 'focusin'],
@@ -161,7 +175,6 @@ export class Finder {
         handler: this._handleMouseEvent
       }
     ]);
-    this.#filterLeavesCache = new WeakMap();
     this._registerEventListeners();
     this.clearResults(true);
   }
@@ -218,7 +231,7 @@ export class Finder {
       this.#node !== this.#root && this.#node.nodeType === ELEMENT_NODE;
     this.#selector = selector;
     this.#pseudoElement = [];
-    this.#walkers = new WeakMap();
+    this.#walkers = null;
     this.#nodeWalker = null;
     this.#rootWalker = null;
     this.#verifyShadowHost = null;
@@ -228,14 +241,29 @@ export class Finder {
 
   /**
    * Clear cached results.
-   * @param {boolean} all - clear all results
+   * @param {boolean} all - Clear all results.
    * @returns {void}
    */
   clearResults = (all = false) => {
-    this.#invalidateResults = new WeakMap();
+    this.#anbCache = null;
+    this.#combinatorCache = null;
+    this.#focusWithinCache = null;
+    this.#invalidateResults = null;
+    this.#nthChildCache = null;
+    this.#nthChildOfCache = null;
+    this.#nthChildResultCache = null;
+    this.#nthOfTypeCache = null;
+    this.#nthOfTypeResultCache = null;
+    this.#psDefaultCache = null;
+    this.#psDirCache = null;
+    this.#psHasFilterCache = null;
+    this.#psIndeterminateCache = null;
+    this.#psLangCache = null;
+    this.#psValidCache = null;
+    this.#targetWithinCache = null;
     if (all) {
+      this.#filterLeavesCache = null;
       this.#results = new WeakMap();
-      this.#filterLeavesCache = new WeakMap();
     }
   };
 
@@ -300,28 +328,26 @@ export class Finder {
    * @private
    * @param {Array.<Array.<object>>} branches - The branches from walkAST.
    * @param {string} selector - The original selector for error reporting.
-   * @returns {{ast: Array, descendant: boolean}}
-   * An object with the AST, descendant flag.
+   * @returns {{ast: Array, descendant: boolean}} An object with the AST, descendant flag.
    */
   _processSelectorBranches = (branches, selector) => {
     let descendant = false;
     const ast = [];
-    const l = branches.length;
-    for (let i = 0; i < l; i++) {
-      const items = [...branches[i]];
+    for (const items of branches) {
       const branch = [];
-      let item = items.shift();
-      if (item && item.type !== COMBINATOR) {
+      let prevType = null;
+      const itemsLen = items.length;
+      if (itemsLen) {
         const leaves = new Set();
-        while (item) {
+        for (let j = 0; j < itemsLen; j++) {
+          const item = items[j];
+          const isLast = j === itemsLen - 1;
+          if (isInvalidCombinator(item.type, prevType, isLast)) {
+            const msg = `Invalid selector ${selector}`;
+            this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+            return { ast: [], descendant: false, invalidate: false };
+          }
           if (item.type === COMBINATOR) {
-            const [nextItem] = items;
-            if (!nextItem || nextItem.type === COMBINATOR) {
-              const msg = `Invalid selector ${selector}`;
-              this.onError(generateException(msg, SYNTAX_ERR, this.#window));
-              // Stop processing on invalid selector.
-              return { ast: [], descendant: false, invalidate: false };
-            }
             if (item.name === ' ' || item.name === '>') {
               descendant = true;
             }
@@ -339,12 +365,10 @@ export class Finder {
             }
             leaves.add(item);
           }
-          if (items.length) {
-            item = items.shift();
-          } else {
+          prevType = item.type;
+          if (isLast) {
             branch.push({ combo: null, leaves: sortAST(leaves) });
             leaves.clear();
-            break;
           }
         }
       }
@@ -384,16 +408,22 @@ export class Finder {
       }
     } else {
       this.#selectorAST = parseSelector(selector);
-      const { branches, info } = walkAST(this.#selectorAST, true);
+      const { branches, info } = walkAST(
+        this.#selectorAST,
+        true,
+        createHasValidator(this.#window)
+      );
       const {
         hasHasPseudoFunc,
         hasLogicalPseudoFunc,
         hasNthChildOfSelector,
-        hasStatePseudoClass
+        hasStatePseudoClass,
+        hasUnsupportedPseudoClass
       } = info;
       this.#invalidate =
         hasHasPseudoFunc ||
         hasStatePseudoClass ||
+        hasUnsupportedPseudoClass ||
         !!(hasLogicalPseudoFunc && hasNthChildOfSelector);
       const processed = this._processSelectorBranches(branches, selector);
       ast = processed.ast;
@@ -432,7 +462,11 @@ export class Finder {
     const { force = false, whatToShow = SHOW_CONTAINER } = opt;
     if (force) {
       return this.#document.createTreeWalker(node, whatToShow);
-    } else if (this.#walkers.has(node)) {
+    }
+    if (!this.#walkers) {
+      this.#walkers = new WeakMap();
+    }
+    if (this.#walkers.has(node)) {
       return this.#walkers.get(node);
     }
     const walker = this.#document.createTreeWalker(node, whatToShow);
@@ -499,7 +533,7 @@ export class Finder {
    * @param {number} anb.a - The 'a' value.
    * @param {number} anb.b - The 'b' value.
    * @param {boolean} [anb.reverse] - If true, reverses the order.
-   * @param {object} [anb.selector] - The AST.
+   * @param {object} [anb.selector] - The selector for 'of S'.
    * @param {object} node - The Element node.
    * @param {object} opt - Options.
    * @returns {Set.<object>} A collection of matched nodes.
@@ -526,16 +560,48 @@ export class Finder {
       }
       return matchedNode;
     }
-    const selectorBranches = selector
-      ? this._getSelectorBranches(selector)
-      : null;
-    const children = this._getFilteredChildren(
-      parentNode,
-      selectorBranches,
-      opt
-    );
-    const matchedNodes = filterNodesByAnB(children, anb);
-    return new Set(matchedNodes);
+    if (!this.#nthChildResultCache) {
+      this.#nthChildResultCache = new WeakMap();
+    }
+    let parentResultCache = this.#nthChildResultCache.get(parentNode);
+    if (!parentResultCache) {
+      parentResultCache = new WeakMap();
+      this.#nthChildResultCache.set(parentNode, parentResultCache);
+    }
+    const cachedSet = parentResultCache.get(anb);
+    if (cachedSet) {
+      return cachedSet;
+    }
+    let siblings;
+    if (selector) {
+      if (!this.#nthChildOfCache) {
+        this.#nthChildOfCache = new WeakMap();
+      }
+      let parentOfCacheMap = this.#nthChildOfCache.get(parentNode);
+      if (!parentOfCacheMap) {
+        parentOfCacheMap = new Map();
+        this.#nthChildOfCache.set(parentNode, parentOfCacheMap);
+      }
+      siblings = parentOfCacheMap.get(selector);
+      if (!siblings) {
+        const selectorBranches = this._getSelectorBranches(selector);
+        siblings = this._getFilteredChildren(parentNode, selectorBranches, opt);
+        parentOfCacheMap.set(selector, siblings);
+      }
+    } else {
+      if (!this.#nthChildCache) {
+        this.#nthChildCache = new WeakMap();
+      }
+      siblings = this.#nthChildCache.get(parentNode);
+      if (!siblings) {
+        siblings = this._getFilteredChildren(parentNode, null, opt);
+        this.#nthChildCache.set(parentNode, siblings);
+      }
+    }
+    const matchedNodes = filterNodesByAnB(siblings, anb);
+    const resultSet = new Set(matchedNodes);
+    parentResultCache.set(anb, resultSet);
+    return resultSet;
   };
 
   /**
@@ -549,27 +615,59 @@ export class Finder {
    * @returns {Set.<object>} A collection of matched nodes.
    */
   _collectNthOfType = (anb, node) => {
-    const { parentNode } = node;
+    const { localName, namespaceURI, parentNode, prefix } = node;
     if (!parentNode) {
       if (node === this.#root && anb.a * 1 + anb.b * 1 === 1) {
         return new Set([node]);
       }
       return new Set();
     }
-    const typedSiblings = [];
-    let sibling = parentNode.firstElementChild;
-    while (sibling) {
-      if (
-        sibling.localName === node.localName &&
-        sibling.namespaceURI === node.namespaceURI &&
-        sibling.prefix === node.prefix
-      ) {
-        typedSiblings.push(sibling);
+    if (!this.#nthOfTypeResultCache) {
+      this.#nthOfTypeResultCache = new WeakMap();
+    }
+    let parentResultCache = this.#nthOfTypeResultCache.get(parentNode);
+    if (!parentResultCache) {
+      parentResultCache = new WeakMap();
+      this.#nthOfTypeResultCache.set(parentNode, parentResultCache);
+    }
+    let typeResultMap = parentResultCache.get(anb);
+    if (!typeResultMap) {
+      typeResultMap = new Map();
+      parentResultCache.set(anb, typeResultMap);
+    }
+    const typeKey = `${namespaceURI || ''}|${prefix || ''}|${localName}`;
+    const cachedSet = typeResultMap.get(typeKey);
+    if (cachedSet) {
+      return cachedSet;
+    }
+    if (!this.#nthOfTypeCache) {
+      this.#nthOfTypeCache = new WeakMap();
+    }
+    let typeMap = this.#nthOfTypeCache.get(parentNode);
+    if (!typeMap) {
+      typeMap = new Map();
+      this.#nthOfTypeCache.set(parentNode, typeMap);
+    }
+    let typedSiblings = typeMap.get(typeKey);
+    if (!typedSiblings) {
+      typedSiblings = [];
+      let sibling = parentNode.firstElementChild;
+      while (sibling) {
+        if (
+          sibling.localName === localName &&
+          sibling.namespaceURI === namespaceURI &&
+          sibling.prefix === prefix
+        ) {
+          typedSiblings.push(sibling);
+        }
+        sibling = sibling.nextElementSibling;
       }
-      sibling = sibling.nextElementSibling;
+      typeMap.set(typeKey, typedSiblings);
     }
     const matchedNodes = filterNodesByAnB(typedSiblings, anb);
-    return new Set(matchedNodes);
+    const resultSet = new Set(matchedNodes);
+    typeResultMap.set(typeKey, resultSet);
+    return resultSet;
   };
 
   /**
@@ -579,53 +677,61 @@ export class Finder {
    * @param {object} node - The Element node.
    * @param {string} nthName - The name of the nth pseudo-class.
    * @param {object} opt - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
+   * @returns {boolean} True if matches, otherwise false.
    */
   _matchAnPlusB = (ast, node, nthName, opt) => {
-    const {
-      nth: { a, b, name: nthIdentName },
-      selector
-    } = ast;
-    const anbMap = new Map();
-    if (nthIdentName) {
-      if (nthIdentName === 'even') {
-        anbMap.set('a', 2);
-        anbMap.set('b', 0);
-      } else if (nthIdentName === 'odd') {
-        anbMap.set('a', 2);
-        anbMap.set('b', 1);
-      }
-      if (nthName.indexOf('last') > -1) {
-        anbMap.set('reverse', true);
-      }
-    } else {
-      if (typeof a === 'string' && /-?\d+/.test(a)) {
-        anbMap.set('a', a * 1);
-      } else {
-        anbMap.set('a', 0);
-      }
-      if (typeof b === 'string' && /-?\d+/.test(b)) {
-        anbMap.set('b', b * 1);
+    if (!this.#anbCache) {
+      this.#anbCache = new WeakMap();
+    }
+    let anb = this.#anbCache.get(ast);
+    if (!anb) {
+      const {
+        nth: { a, b, name: nthIdentName },
+        selector
+      } = ast;
+      const anbMap = new Map();
+      if (nthIdentName) {
+        if (nthIdentName === 'even') {
+          anbMap.set('a', 2);
+          anbMap.set('b', 0);
+        } else if (nthIdentName === 'odd') {
+          anbMap.set('a', 2);
+          anbMap.set('b', 1);
+        }
+        if (nthName.indexOf('last') > -1) {
+          anbMap.set('reverse', true);
+        }
       } else {
-        anbMap.set('b', 0);
+        if (typeof a === 'string' && /-?\d+/.test(a)) {
+          anbMap.set('a', a * 1);
+        } else {
+          anbMap.set('a', 0);
+        }
+        if (typeof b === 'string' && /-?\d+/.test(b)) {
+          anbMap.set('b', b * 1);
+        } else {
+          anbMap.set('b', 0);
+        }
+        if (nthName.indexOf('last') > -1) {
+          anbMap.set('reverse', true);
+        }
       }
-      if (nthName.indexOf('last') > -1) {
-        anbMap.set('reverse', true);
+      if (nthName === 'nth-child' || nthName === 'nth-last-child') {
+        if (selector) {
+          anbMap.set('selector', selector);
+        }
       }
+      anb = Object.fromEntries(anbMap);
+      this.#anbCache.set(ast, anb);
     }
     if (nthName === 'nth-child' || nthName === 'nth-last-child') {
-      if (selector) {
-        anbMap.set('selector', selector);
-      }
-      const anb = Object.fromEntries(anbMap);
       const nodes = this._collectNthChild(anb, node, opt);
-      return nodes;
+      return nodes.has(node);
     } else if (nthName === 'nth-of-type' || nthName === 'nth-last-of-type') {
-      const anb = Object.fromEntries(anbMap);
       const nodes = this._collectNthOfType(anb, node);
-      return nodes;
+      return nodes.has(node);
     }
-    return new Set();
+    return false;
   };
 
   /**
@@ -637,55 +743,113 @@ export class Finder {
    * @returns {boolean} The result.
    */
   _matchHasPseudoFunc = (astLeaves, node, opt = {}) => {
-    if (Array.isArray(astLeaves) && astLeaves.length) {
-      // Prepare a copy to avoid astLeaves being consumed.
-      const leaves = [...astLeaves];
-      const [leaf] = leaves;
-      const { type: leafType } = leaf;
-      let combo;
-      if (leafType === COMBINATOR) {
-        combo = leaves.shift();
-      } else {
-        combo = {
-          name: ' ',
-          type: COMBINATOR
-        };
-      }
-      const twigLeaves = [];
-      while (leaves.length) {
-        const [item] = leaves;
-        const { type: itemType } = item;
-        if (itemType === COMBINATOR) {
-          break;
-        } else {
-          twigLeaves.push(leaves.shift());
-        }
-      }
-      const twig = {
-        combo,
-        leaves: twigLeaves
+    const l = astLeaves.length;
+    if (!l) {
+      return false;
+    }
+    let startIndex = 0;
+    let combo;
+    if (astLeaves[0].type === COMBINATOR) {
+      combo = astLeaves[0];
+      startIndex = 1;
+    } else {
+      combo = {
+        name: ' ',
+        type: COMBINATOR
       };
-      opt.dir = DIR_NEXT;
-      const nodes = this._collectCombinatorMatches(twig, node, opt, []);
-      if (nodes.length) {
-        if (leaves.length) {
-          let bool = false;
-          for (const nextNode of nodes) {
-            bool = this._matchHasPseudoFunc(leaves, nextNode, opt);
-            if (bool) {
-              break;
-            }
+      startIndex = 0;
+    }
+    const twigLeaves = [];
+    let nextComboIndex = startIndex;
+    for (; nextComboIndex < l; nextComboIndex++) {
+      if (astLeaves[nextComboIndex].type === COMBINATOR) {
+        break;
+      }
+      twigLeaves.push(astLeaves[nextComboIndex]);
+    }
+    const twig = {
+      combo,
+      leaves: twigLeaves
+    };
+    opt.dir = DIR_NEXT;
+    const nodes = this._collectCombinatorMatches(twig, node, opt, []);
+    if (nodes.length) {
+      if (nextComboIndex < l) {
+        let bool = false;
+        const remainingLeaves = astLeaves.slice(nextComboIndex);
+        for (const nextNode of nodes) {
+          bool = this._matchHasPseudoFunc(remainingLeaves, nextNode, opt);
+          if (bool) {
+            break;
           }
-          return bool;
         }
-        return true;
+        return bool;
       }
+      return true;
     }
     return false;
   };
 
   /**
-   * Evaluates the :has() pseudo-class.
+   * Builds an Allowlist for the :has() branch using a sparse seed element.
+   * @private
+   * @param {Array} leaves - The AST leaves of the selector branch.
+   * @returns {object|null} The wrapper object containing the WeakSet, or null.
+   */
+  _buildHasAllowlist = leaves => {
+    const { seed } = findBestSeed(leaves);
+    if (!seed) {
+      return null;
+    }
+    if (this.#shadow || this.#node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+      return null;
+    }
+    let seedElements = null;
+    let isSingleNode = false;
+    if (seed.type === 'id') {
+      if (typeof this.#root.getElementById === 'function') {
+        const node = this.#root.getElementById(seed.value);
+        if (node) {
+          seedElements = node;
+          isSingleNode = true;
+        }
+      }
+    } else if (seed.type === 'class') {
+      if (typeof this.#root.getElementsByClassName === 'function') {
+        seedElements = this.#root.getElementsByClassName(seed.value);
+      }
+    } else if (seed.type === 'tag') {
+      if (typeof this.#root.getElementsByTagName === 'function') {
+        seedElements = this.#root.getElementsByTagName(seed.value);
+      }
+    }
+    if (!seedElements) {
+      return null;
+    }
+    const len = isSingleNode ? 1 : seedElements.length;
+    if (len === 0 || len > HEX * HEX) {
+      return null;
+    }
+    const filterResult = {
+      seeded: true,
+      set: new WeakSet()
+    };
+    const list = filterResult.set;
+    const visitedAncestors = new Set();
+    if (this.#node) {
+      list.add(this.#node);
+    }
+    for (let i = 0; i < len; i++) {
+      const current = isSingleNode ? seedElements : seedElements[i];
+      if (current) {
+        populateHasAllowlist(current, list, visitedAncestors);
+      }
+    }
+    return filterResult;
+  };
+
+  /**
+   * Evaluates :has() pseudo-class.
    * @private
    * @param {object} astData - The AST data.
    * @param {object} node - The Element node.
@@ -695,9 +859,28 @@ export class Finder {
   _evaluateHasPseudo = (astData, node, opt = {}) => {
     const { branches } = astData;
     let bool = false;
-    const l = branches.length;
-    for (let i = 0; i < l; i++) {
-      const leaves = branches[i];
+    if (!this.#psHasFilterCache) {
+      this.#psHasFilterCache = new WeakMap();
+    }
+    let rootCache = this.#psHasFilterCache.get(this.#root);
+    if (!rootCache) {
+      rootCache = new WeakMap();
+      this.#psHasFilterCache.set(this.#root, rootCache);
+    }
+    for (const leaves of branches) {
+      if (!rootCache.has(leaves)) {
+        const filterResult = this._buildHasAllowlist(leaves);
+        rootCache.set(leaves, filterResult);
+      }
+      const allowlist = rootCache.get(leaves);
+      if (
+        allowlist &&
+        allowlist.seeded &&
+        node.nodeType !== DOCUMENT_FRAGMENT_NODE &&
+        !allowlist.set.has(node)
+      ) {
+        continue;
+      }
       bool = this._matchHasPseudoFunc(leaves, node, opt);
       if (bool) {
         break;
@@ -721,13 +904,13 @@ export class Finder {
    * @param {object} astData - The AST data.
    * @param {object} node - The Element node.
    * @param {object} [opt] - Options.
-   * @returns {?object} The matched node.
+   * @returns {boolean} Tru if matches, otherwise false.
    */
   _matchLogicalPseudoFunc = (astData, node, opt = {}) => {
     const { astName, branches, twigBranches } = astData;
     // Handle :has().
     if (astName === 'has') {
-      return this._evaluateHasPseudo(astData, node, opt);
+      return this._evaluateHasPseudo(astData, node, opt) === node;
     }
     // Handle :is(), :not(), :where().
     const isShadowRoot =
@@ -749,7 +932,7 @@ export class Finder {
         }
       }
       if (invalid) {
-        return null;
+        return false;
       }
     }
     opt.forgive = astName === 'is' || astName === 'where';
@@ -786,658 +969,376 @@ export class Finder {
       }
     }
     if (astName === 'not') {
-      if (bool) {
-        return null;
-      }
-      return node;
-    } else if (bool) {
-      return node;
+      return !bool;
     }
-    return null;
+    return bool;
   };
 
   /**
-   * Matches pseudo-class selector.
+   * Evaluates logical pseudo-class selector.
    * @private
-   * @see https://html.spec.whatwg.org/#pseudo-classes
    * @param {object} ast - The AST.
    * @param {object} node - The Element node.
    * @param {object} [opt] - Options.
    * @param {boolean} [opt.forgive] - Ignores unknown or invalid selectors.
    * @param {boolean} [opt.warn] - If true, console warnings are enabled.
-   * @returns {Set.<object>} A collection of matched nodes.
+   * @returns {boolean} True if matches, otherwise false.
    */
-  _matchPseudoClassSelector(ast, node, opt = {}) {
+  _evaluateLogicalPseudo(ast, node, opt = {}) {
     const { children: astChildren, name: astName } = ast;
-    const { localName, parentNode } = node;
-    const { forgive, warn = this.#warn } = opt;
-    const matched = new Set();
-    // :has(), :is(), :not(), :where()
-    if (Array.isArray(astChildren) && KEYS_LOGICAL.has(astName)) {
-      if (!astChildren.length && astName !== 'is' && astName !== 'where') {
-        const css = generateCSS(ast);
-        const msg = `Invalid selector ${css}`;
-        return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
-      }
-      let astData;
-      if (this.#astCache.has(ast)) {
-        astData = this.#astCache.get(ast);
+    if (!astChildren.length && astName !== 'is' && astName !== 'where') {
+      const css = generateCSS(ast);
+      const msg = `Invalid selector ${css}`;
+      this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      return false;
+    }
+    let astData;
+    if (this.#astCache.has(ast)) {
+      astData = this.#astCache.get(ast);
+    } else {
+      const { branches } = walkAST(ast);
+      if (astName === 'has') {
+        astData = {
+          astName,
+          branches
+        };
       } else {
-        const { branches } = walkAST(ast);
-        if (astName === 'has') {
-          // Check for nested :has().
-          let forgiven = false;
-          const l = astChildren.length;
-          for (let i = 0; i < l; i++) {
-            const child = astChildren[i];
-            const item = findAST(child, findLogicalWithNestedHas);
-            if (item) {
-              const itemName = item.name;
-              if (itemName === 'is' || itemName === 'where') {
-                forgiven = true;
-                break;
-              } else {
-                const css = generateCSS(ast);
-                const msg = `Invalid selector ${css}`;
-                return this.onError(
-                  generateException(msg, SYNTAX_ERR, this.#window)
-                );
-              }
+        const twigBranches = [];
+        const l = branches.length;
+        for (let i = 0; i < l; i++) {
+          const leaves = branches[i];
+          const branch = [];
+          const leavesSet = new Set();
+          const leavesLen = leaves.length;
+          for (let j = 0; j < leavesLen; j++) {
+            const item = leaves[j];
+            if (item.type === COMBINATOR) {
+              branch.push({
+                combo: item,
+                leaves: [...leavesSet]
+              });
+              leavesSet.clear();
+            } else {
+              leavesSet.add(item);
             }
-          }
-          if (forgiven) {
-            return matched;
-          }
-          astData = {
-            astName,
-            branches
-          };
-        } else {
-          const twigBranches = [];
-          const l = branches.length;
-          for (let i = 0; i < l; i++) {
-            const [...leaves] = branches[i];
-            const branch = [];
-            const leavesSet = new Set();
-            let item = leaves.shift();
-            while (item) {
-              if (item.type === COMBINATOR) {
-                branch.push({
-                  combo: item,
-                  leaves: [...leavesSet]
-                });
-                leavesSet.clear();
-              } else if (item) {
-                leavesSet.add(item);
-              }
-              if (leaves.length) {
-                item = leaves.shift();
-              } else {
-                branch.push({
-                  combo: null,
-                  leaves: [...leavesSet]
-                });
-                leavesSet.clear();
-                break;
-              }
+            if (j === leavesLen - 1) {
+              branch.push({
+                combo: null,
+                leaves: [...leavesSet]
+              });
+              leavesSet.clear();
             }
-            twigBranches.push(branch);
           }
-          astData = {
-            astName,
-            branches,
-            twigBranches
-          };
-          this.#astCache.set(ast, astData);
+          twigBranches.push(branch);
         }
+        astData = {
+          astName,
+          branches,
+          twigBranches
+        };
       }
-      const res = this._matchLogicalPseudoFunc(astData, node, opt);
-      if (res) {
-        matched.add(res);
+      this.#astCache.set(ast, astData);
+    }
+    return this._matchLogicalPseudoFunc(astData, node, opt);
+  }
+
+  /**
+   * Evaluates pseudo-class function.
+   * @private
+   * @see https://html.spec.whatwg.org/#pseudo-classes
+   * @param {object} ast - The AST.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.forgive] - Ignores unknown or invalid selectors.
+   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
+   * @returns {boolean} True if matches, otherwise false.
+   */
+  _evaluatePseudoClassFunc(ast, node, opt = {}) {
+    const { children: astChildren, name: astName } = ast;
+    const { forgive, warn = this.#warn } = opt;
+    // :nth-child(), :nth-last-child(), nth-of-type(), :nth-last-of-type()
+    if (/^nth-(?:last-)?(?:child|of-type)$/.test(astName)) {
+      if (astChildren.length !== 1) {
+        const css = generateCSS(ast);
+        this.onError(
+          generateException(`Invalid selector ${css}`, SYNTAX_ERR, this.#window)
+        );
+        return false;
       }
-    } else if (Array.isArray(astChildren)) {
-      // :nth-child(), :nth-last-child(), nth-of-type(), :nth-last-of-type()
-      if (/^nth-(?:last-)?(?:child|of-type)$/.test(astName)) {
+      const [branch] = astChildren;
+      return this._matchAnPlusB(branch, node, astName, opt);
+    }
+    switch (astName) {
+      // :dir()
+      case 'dir': {
         if (astChildren.length !== 1) {
           const css = generateCSS(ast);
-          return this.onError(
+          this.onError(
             generateException(
               `Invalid selector ${css}`,
               SYNTAX_ERR,
               this.#window
             )
           );
+          return false;
         }
-        const [branch] = astChildren;
-        const nodes = this._matchAnPlusB(branch, node, astName, opt);
-        return nodes;
-      } else {
-        switch (astName) {
-          // :dir()
-          case 'dir': {
-            if (astChildren.length !== 1) {
-              const css = generateCSS(ast);
-              return this.onError(
-                generateException(
-                  `Invalid selector ${css}`,
-                  SYNTAX_ERR,
-                  this.#window
-                )
-              );
-            }
-            const [astChild] = astChildren;
-            const res = matchDirectionPseudoClass(astChild, node);
-            if (res) {
-              matched.add(node);
-            }
-            break;
-          }
-          // :lang()
-          case 'lang': {
-            if (!astChildren.length) {
-              const css = generateCSS(ast);
-              return this.onError(
-                generateException(
-                  `Invalid selector ${css}`,
-                  SYNTAX_ERR,
-                  this.#window
-                )
-              );
-            }
-            let bool;
-            for (const astChild of astChildren) {
-              bool = matchLanguagePseudoClass(astChild, node);
-              if (bool) {
-                break;
-              }
-            }
-            if (bool) {
-              matched.add(node);
-            }
-            break;
-          }
-          // :state()
-          case 'state': {
-            if (isCustomElement(node)) {
-              const [{ value: stateValue }] = astChildren;
-              if (stateValue) {
-                if (node[stateValue]) {
-                  matched.add(node);
-                } else {
-                  for (const i in node) {
-                    const prop = node[i];
-                    if (prop instanceof this.#window.ElementInternals) {
-                      if (prop?.states?.has(stateValue)) {
-                        matched.add(node);
-                      }
-                      break;
-                    }
-                  }
-                }
-              }
-            }
-            break;
-          }
-          case 'current':
-          case 'heading':
-          case 'nth-col':
-          case 'nth-last-col': {
-            if (warn) {
-              this.onError(
-                generateException(
-                  `Unsupported pseudo-class :${astName}()`,
-                  NOT_SUPPORTED_ERR,
-                  this.#window
-                )
-              );
-            }
-            break;
-          }
-          // Ignore :host() and :host-context().
-          case 'host':
-          case 'host-context': {
-            break;
-          }
-          // Deprecated in CSS Selectors 3.
-          case 'contains': {
-            if (warn) {
-              this.onError(
-                generateException(
-                  `Unknown pseudo-class :${astName}()`,
-                  NOT_SUPPORTED_ERR,
-                  this.#window
-                )
-              );
-            }
-            break;
-          }
-          default: {
-            if (!forgive) {
-              this.onError(
-                generateException(
-                  `Unknown pseudo-class :${astName}()`,
-                  SYNTAX_ERR,
-                  this.#window
-                )
-              );
-            }
-          }
+        const [astChild] = astChildren;
+        if (!this.#psDirCache) {
+          this.#psDirCache = new WeakMap();
         }
-      }
-    } else if (KEYS_PS_NTH_OF_TYPE.has(astName)) {
-      if (node === this.#root) {
-        matched.add(node);
-      } else if (parentNode) {
-        switch (astName) {
-          case 'first-of-type': {
-            const [node1] = this._collectNthOfType(
-              {
-                a: 0,
-                b: 1
-              },
-              node
-            );
-            if (node1) {
-              matched.add(node1);
-            }
-            break;
-          }
-          case 'last-of-type': {
-            const [node1] = this._collectNthOfType(
-              {
-                a: 0,
-                b: 1,
-                reverse: true
-              },
-              node
-            );
-            if (node1) {
-              matched.add(node1);
-            }
-            break;
-          }
-          // 'only-of-type' is handled by default.
-          default: {
-            const [node1] = this._collectNthOfType(
-              {
-                a: 0,
-                b: 1
-              },
-              node
-            );
-            if (node1 === node) {
-              const [node2] = this._collectNthOfType(
-                {
-                  a: 0,
-                  b: 1,
-                  reverse: true
-                },
-                node
-              );
-              if (node2 === node) {
-                matched.add(node);
-              }
-            }
-          }
+        const res = matchDirectionPseudoClass(astChild, node, this.#psDirCache);
+        if (res) {
+          return true;
         }
+        break;
       }
-    } else {
-      switch (astName) {
-        case 'disabled':
-        case 'enabled': {
-          const isMatch = matchDisabledPseudoClass(astName, node);
-          if (isMatch) {
-            matched.add(node);
-          }
-          break;
+      // :lang()
+      case 'lang': {
+        if (!astChildren.length) {
+          const css = generateCSS(ast);
+          this.onError(
+            generateException(
+              `Invalid selector ${css}`,
+              SYNTAX_ERR,
+              this.#window
+            )
+          );
+          return false;
         }
-        case 'read-only':
-        case 'read-write': {
-          const isMatch = matchReadOnlyPseudoClass(astName, node);
-          if (isMatch) {
-            matched.add(node);
-          }
-          break;
+        if (!this.#psLangCache) {
+          this.#psLangCache = new WeakMap();
         }
-        case 'any-link':
-        case 'link': {
-          if (
-            (localName === 'a' || localName === 'area') &&
-            node.hasAttribute('href')
-          ) {
-            matched.add(node);
+        let bool;
+        for (const astChild of astChildren) {
+          bool = matchLanguagePseudoClass(astChild, node, this.#psLangCache);
+          if (bool) {
+            break;
           }
-          break;
         }
-        case 'local-link': {
-          if (
-            (localName === 'a' || localName === 'area') &&
-            node.hasAttribute('href')
-          ) {
-            if (!this.#documentURL) {
-              this.#documentURL = new URL(this.#document.URL);
+        if (bool) {
+          return true;
+        }
+        break;
+      }
+      // :state()
+      case 'state': {
+        if (isCustomElement(node)) {
+          const [{ value: stateValue }] = astChildren;
+          if (stateValue) {
+            if (node[stateValue]) {
+              return true;
             }
-            const { href, origin, pathname } = this.#documentURL;
-            const attrURL = new URL(node.getAttribute('href'), href);
-            if (attrURL.origin === origin && attrURL.pathname === pathname) {
-              matched.add(node);
+            for (const i in node) {
+              const prop = node[i];
+              if (prop instanceof this.#window.ElementInternals) {
+                if (prop?.states?.has(stateValue)) {
+                  return true;
+                }
+                break;
+              }
             }
           }
-          break;
         }
-        case 'visited': {
-          // prevent fingerprinting
-          break;
+        break;
+      }
+      case 'current':
+      case 'heading':
+      case 'nth-col':
+      case 'nth-last-col': {
+        if (warn) {
+          this.onError(
+            generateException(
+              `Unsupported pseudo-class :${astName}()`,
+              NOT_SUPPORTED_ERR,
+              this.#window
+            )
+          );
         }
-        case 'hover': {
-          const { target, type } = this.#event ?? {};
-          if (
-            /^(?:click|mouse(?:down|over|up))$/.test(type) &&
-            target?.nodeType === ELEMENT_NODE &&
-            node.contains(target)
-          ) {
-            matched.add(node);
-          }
-          break;
+        break;
+      }
+      // Ignore :host() and :host-context().
+      case 'host':
+      case 'host-context': {
+        break;
+      }
+      // Deprecated in CSS Selectors 3.
+      case 'contains': {
+        if (warn) {
+          this.onError(
+            generateException(
+              `Unknown pseudo-class :${astName}()`,
+              NOT_SUPPORTED_ERR,
+              this.#window
+            )
+          );
         }
-        case 'active': {
-          const { buttons, target, type } = this.#event ?? {};
-          if (
-            type === 'mousedown' &&
-            buttons & 1 &&
-            target?.nodeType === ELEMENT_NODE &&
-            node.contains(target)
-          ) {
-            matched.add(node);
-          }
-          break;
+        break;
+      }
+      default: {
+        if (!forgive) {
+          this.onError(
+            generateException(
+              `Unknown pseudo-class :${astName}()`,
+              SYNTAX_ERR,
+              this.#window
+            )
+          );
         }
-        case 'target': {
-          if (!this.#documentURL) {
-            this.#documentURL = new URL(this.#document.URL);
-          }
-          const { hash } = this.#documentURL;
-          if (
-            node.id &&
-            hash === `#${node.id}` &&
-            this.#document.contains(node)
-          ) {
-            matched.add(node);
-          }
-          break;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Evaluates *-of-type pseudo-class selector.
+   * @private
+   * @param {string} astName - The AST name.
+   * @param {object} node - The Element node.
+   * @returns {boolean} True if matches, otherwise false.
+   */
+
+  /**
+   * Matches pseudo-class selector.
+   * @private
+   * @see https://html.spec.whatwg.org/#pseudo-classes
+   * @param {object} ast - The AST.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.forgive] - Ignores unknown or invalid selectors.
+   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
+   * @returns {Set.<object>|boolean} A collection of matched nodes.
+   */
+  _matchPseudoClassSelector(ast, node, opt = {}) {
+    const { children: astChildren, name: astName } = ast;
+    const { localName, parentNode } = node;
+    const { forgive, warn = this.#warn } = opt;
+    if (Array.isArray(astChildren)) {
+      // :has(), :is(), :not(), :where()
+      if (KEYS_LOGICAL.has(astName)) {
+        return this._evaluateLogicalPseudo(ast, node, opt);
+      }
+      return this._evaluatePseudoClassFunc(ast, node, opt);
+    }
+    if (KEYS_PS_NTH_OF_TYPE.has(astName)) {
+      if (!parentNode) {
+        return node === this.#root;
+      }
+      switch (astName) {
+        case 'first-of-type': {
+          const [node1] = this._collectNthOfType(ANB_FIRST, node);
+          return node1 === node;
         }
-        case 'target-within': {
-          if (!this.#documentURL) {
-            this.#documentURL = new URL(this.#document.URL);
-          }
-          const { hash } = this.#documentURL;
-          if (hash) {
-            const id = hash.replace(/^#/, '');
-            let current = this.#document.getElementById(id);
-            while (current) {
-              if (current === node) {
-                matched.add(node);
-                break;
-              }
-              current = current.parentNode;
-            }
-          }
-          break;
+        case 'last-of-type': {
+          const [node1] = this._collectNthOfType(ANB_LAST, node);
+          return node1 === node;
         }
-        case 'scope': {
-          if (this.#node.nodeType === ELEMENT_NODE) {
-            if (!this.#shadow && node === this.#node) {
-              matched.add(node);
-            }
-          } else if (node === this.#document.documentElement) {
-            matched.add(node);
+        // 'only-of-type' is handled by default.
+        default: {
+          const [node1] = this._collectNthOfType(ANB_FIRST, node);
+          if (node1 === node) {
+            const [node2] = this._collectNthOfType(ANB_LAST, node);
+            return node2 === node;
           }
-          break;
         }
-        case 'focus': {
-          const activeElement = this.#document.activeElement;
-          if (node === activeElement && isFocusableArea(node)) {
-            matched.add(node);
-          } else if (activeElement.shadowRoot) {
-            const activeShadowElement = activeElement.shadowRoot.activeElement;
-            let current = activeShadowElement;
-            while (current) {
-              if (current.nodeType === DOCUMENT_FRAGMENT_NODE) {
-                const { host } = current;
-                if (host === activeElement) {
-                  if (isFocusableArea(node)) {
-                    matched.add(node);
-                  } else {
-                    matched.add(host);
-                  }
-                }
-                break;
-              } else {
-                current = current.parentNode;
-              }
-            }
-          }
-          break;
+      }
+      return false;
+    }
+    switch (astName) {
+      /* Elemental pseudo-classes */
+      case 'defined': {
+        if (node.hasAttribute('is') || localName.includes('-')) {
+          return isCustomElement(node);
         }
-        case 'focus-visible': {
-          if (node === this.#document.activeElement && isFocusableArea(node)) {
-            let bool;
-            if (isFocusVisible(node)) {
-              bool = true;
-            } else if (this.#focus) {
-              const { relatedTarget, target: focusTarget } = this.#focus;
-              if (focusTarget === node) {
-                if (isFocusVisible(relatedTarget)) {
-                  bool = true;
-                } else if (this.#event) {
-                  const {
-                    altKey: eventAltKey,
-                    ctrlKey: eventCtrlKey,
-                    key: eventKey,
-                    metaKey: eventMetaKey,
-                    target: eventTarget,
-                    type: eventType
-                  } = this.#event;
-                  // this.#event is irrelevant if eventTarget === relatedTarget
-                  if (eventTarget === relatedTarget) {
-                    if (this.#lastFocusVisible === null) {
-                      bool = true;
-                    } else if (focusTarget === this.#lastFocusVisible) {
-                      bool = true;
-                    }
-                  } else if (eventKey === 'Tab') {
-                    if (
-                      (eventType === 'keydown' && eventTarget !== node) ||
-                      (eventType === 'keyup' && eventTarget === node)
-                    ) {
-                      if (eventTarget === focusTarget) {
-                        if (this.#lastFocusVisible === null) {
-                          bool = true;
-                        } else if (
-                          eventTarget === this.#lastFocusVisible &&
-                          relatedTarget === null
-                        ) {
-                          bool = true;
-                        }
-                      } else {
-                        bool = true;
-                      }
-                    }
-                  } else if (eventKey) {
-                    if (
-                      (eventType === 'keydown' || eventType === 'keyup') &&
-                      !eventAltKey &&
-                      !eventCtrlKey &&
-                      !eventMetaKey &&
-                      eventTarget === node
-                    ) {
-                      bool = true;
-                    }
-                  }
-                } else if (
-                  relatedTarget === null ||
-                  relatedTarget === this.#lastFocusVisible
-                ) {
-                  bool = true;
-                }
+        return (
+          node instanceof this.#window.HTMLElement ||
+          node instanceof this.#window.SVGElement
+        );
+      }
+      /* Element display state pseudo-classes */
+      case 'open': {
+        // <select> and <input type="color"> are not supported.
+        return (
+          (localName === 'details' || localName === 'dialog') &&
+          node.hasAttribute('open')
+        );
+      }
+      case 'popover-open': {
+        // FIXME: Not implemented in jsdom
+        // @see https://github.com/jsdom/jsdom/issues/3721
+        // return node.popover && isVisible(node);
+        break;
+      }
+      /* Input pseudo-classes */
+      case 'disabled':
+      case 'enabled': {
+        return matchDisabledPseudoClass(astName, node);
+      }
+      case 'read-only':
+      case 'read-write': {
+        return matchReadOnlyPseudoClass(astName, node);
+      }
+      case 'placeholder-shown': {
+        let placeholder;
+        if (node.placeholder) {
+          placeholder = node.placeholder;
+        } else if (node.hasAttribute('placeholder')) {
+          placeholder = node.getAttribute('placeholder');
+        }
+        if (typeof placeholder === 'string' && !/[\r\n]/.test(placeholder)) {
+          let targetNode;
+          if (localName === 'textarea') {
+            targetNode = node;
+          } else if (localName === 'input') {
+            if (node.hasAttribute('type')) {
+              if (KEYS_INPUT_PLACEHOLDER.has(node.getAttribute('type'))) {
+                targetNode = node;
               }
-            }
-            if (bool) {
-              this.#lastFocusVisible = node;
-              matched.add(node);
-            } else if (this.#lastFocusVisible === node) {
-              this.#lastFocusVisible = null;
-            }
-          }
-          break;
-        }
-        case 'focus-within': {
-          const activeElement = this.#document.activeElement;
-          if (node.contains(activeElement) && isFocusableArea(activeElement)) {
-            matched.add(node);
-          } else if (activeElement.shadowRoot) {
-            const activeShadowElement = activeElement.shadowRoot.activeElement;
-            if (node.contains(activeShadowElement)) {
-              matched.add(node);
             } else {
-              let current = activeShadowElement;
-              while (current) {
-                if (current.nodeType === DOCUMENT_FRAGMENT_NODE) {
-                  const { host } = current;
-                  if (host === activeElement && node.contains(host)) {
-                    matched.add(node);
-                  }
-                  break;
-                } else {
-                  current = current.parentNode;
-                }
-              }
-            }
-          }
-          break;
-        }
-        case 'open':
-        case 'closed': {
-          if (localName === 'details' || localName === 'dialog') {
-            if (node.hasAttribute('open')) {
-              if (astName === 'open') {
-                matched.add(node);
-              }
-            } else if (astName === 'closed') {
-              matched.add(node);
-            }
-          }
-          break;
-        }
-        case 'placeholder-shown': {
-          let placeholder;
-          if (node.placeholder) {
-            placeholder = node.placeholder;
-          } else if (node.hasAttribute('placeholder')) {
-            placeholder = node.getAttribute('placeholder');
-          }
-          if (typeof placeholder === 'string' && !/[\r\n]/.test(placeholder)) {
-            let targetNode;
-            if (localName === 'textarea') {
               targetNode = node;
-            } else if (localName === 'input') {
-              if (node.hasAttribute('type')) {
-                if (KEYS_INPUT_PLACEHOLDER.has(node.getAttribute('type'))) {
-                  targetNode = node;
-                }
-              } else {
-                targetNode = node;
-              }
-            }
-            if (targetNode && node.value === '') {
-              matched.add(node);
             }
           }
-          break;
-        }
-        case 'checked': {
-          const attrType = node.getAttribute('type');
-          if (
-            (node.checked &&
-              localName === 'input' &&
-              (attrType === 'checkbox' || attrType === 'radio')) ||
-            (node.selected && localName === 'option')
-          ) {
-            matched.add(node);
+          if (targetNode) {
+            return node.value === '';
           }
-          break;
         }
-        case 'indeterminate': {
-          if (
-            (node.indeterminate &&
-              localName === 'input' &&
-              node.type === 'checkbox') ||
-            (localName === 'progress' && !node.hasAttribute('value'))
-          ) {
-            matched.add(node);
-          } else if (
-            localName === 'input' &&
-            node.type === 'radio' &&
-            !node.hasAttribute('checked')
-          ) {
-            const nodeName = node.name;
-            let parent = node.parentNode;
-            while (parent) {
-              if (parent.localName === 'form') {
-                break;
-              }
-              parent = parent.parentNode;
-            }
-            if (!parent) {
-              parent = this.#document.documentElement;
-            }
-            const walker = this._createTreeWalker(parent);
-            let refNode = traverseNode(parent, walker);
-            refNode = walker.firstChild();
-            let checked;
-            while (refNode) {
-              if (
-                refNode.localName === 'input' &&
-                refNode.getAttribute('type') === 'radio'
-              ) {
-                if (refNode.hasAttribute('name')) {
-                  if (refNode.getAttribute('name') === nodeName) {
-                    checked = !!refNode.checked;
-                  }
-                } else {
-                  checked = !!refNode.checked;
-                }
-                if (checked) {
-                  break;
-                }
-              }
-              refNode = walker.nextNode();
-            }
-            if (!checked) {
-              matched.add(node);
-            }
-          }
-          break;
+        break;
+      }
+      case 'default': {
+        // option
+        if (localName === 'option') {
+          return node.hasAttribute('selected');
         }
-        case 'default': {
-          // button[type="submit"], input[type="submit"], input[type="image"]
-          const attrType = node.getAttribute('type');
-          if (
-            (localName === 'button' &&
-              !(node.hasAttribute('type') && KEYS_INPUT_RESET.has(attrType))) ||
-            (localName === 'input' &&
-              node.hasAttribute('type') &&
-              KEYS_INPUT_SUBMIT.has(attrType))
-          ) {
-            let form = node.parentNode;
-            while (form) {
-              if (form.localName === 'form') {
-                break;
-              }
-              form = form.parentNode;
+        const attrType = node.getAttribute('type');
+        // input[type="checkbox"], input[type="radio"]
+        if (
+          localName === 'input' &&
+          node.hasAttribute('type') &&
+          node.hasAttribute('checked')
+        ) {
+          return KEYS_INPUT_CHECK.has(attrType);
+        }
+        // button[type="submit"], input[type="submit"], input[type="image"]
+        if (
+          (localName === 'button' &&
+            !(node.hasAttribute('type') && KEYS_INPUT_RESET.has(attrType))) ||
+          (localName === 'input' &&
+            node.hasAttribute('type') &&
+            KEYS_INPUT_SUBMIT.has(attrType))
+        ) {
+          let form = node.parentNode;
+          while (form) {
+            if (form.localName === 'form') {
+              break;
+            }
+            form = form.parentNode;
+          }
+          if (form) {
+            if (!this.#psDefaultCache) {
+              this.#psDefaultCache = new WeakMap();
             }
-            if (form) {
-              const walker = this._createTreeWalker(form);
+            let defaultSubmit = this.#psDefaultCache.get(form);
+            if (!defaultSubmit) {
+              const walker = this._createTreeWalker(form, { force: true });
               let refNode = traverseNode(form, walker);
               refNode = walker.firstChild();
               while (refNode) {
@@ -1455,53 +1356,117 @@ export class Finder {
                     KEYS_INPUT_SUBMIT.has(nodeAttrType);
                 }
                 if (m) {
-                  if (refNode === node) {
-                    matched.add(node);
-                  }
+                  defaultSubmit = refNode;
                   break;
                 }
                 refNode = walker.nextNode();
               }
+              this.#psDefaultCache.set(form, defaultSubmit);
             }
-            // input[type="checkbox"], input[type="radio"]
-          } else if (
-            localName === 'input' &&
-            node.hasAttribute('type') &&
-            node.hasAttribute('checked') &&
-            KEYS_INPUT_CHECK.has(attrType)
-          ) {
-            matched.add(node);
-            // option
-          } else if (localName === 'option' && node.hasAttribute('selected')) {
-            matched.add(node);
+            return defaultSubmit === node;
           }
-          break;
         }
-        case 'valid':
-        case 'invalid': {
-          if (KEYS_FORM_PS_VALID.has(localName)) {
-            let valid;
-            if (node.checkValidity()) {
-              if (node.maxLength >= 0) {
-                if (node.maxLength >= node.value.length) {
-                  valid = true;
+        break;
+      }
+      case 'checked': {
+        if (localName === 'option') {
+          return node.selected;
+        }
+        if (localName === 'input') {
+          const attrType = node.getAttribute('type');
+          return (
+            node.checked && (attrType === 'checkbox' || attrType === 'radio')
+          );
+        }
+        break;
+      }
+      case 'indeterminate': {
+        if (localName === 'progress') {
+          return !node.hasAttribute('value');
+        }
+        if (localName === 'input' && node.type === 'checkbox') {
+          return node.indeterminate;
+        }
+        if (localName === 'input' && node.type === 'radio') {
+          if (node.checked || node.hasAttribute('checked')) {
+            return false;
+          }
+          const nodeName = node.name;
+          let parent = node.parentNode;
+          while (parent) {
+            if (parent.localName === 'form') {
+              break;
+            }
+            parent = parent.parentNode;
+          }
+          if (!parent) {
+            parent = this.#document.documentElement;
+          }
+          if (!this.#psIndeterminateCache) {
+            this.#psIndeterminateCache = new WeakMap();
+          }
+          let parentCache = this.#psIndeterminateCache.get(parent);
+          if (!parentCache) {
+            parentCache = new Map();
+            this.#psIndeterminateCache.set(parent, parentCache);
+          }
+          let checked = parentCache.get(nodeName);
+          if (checked === undefined) {
+            const walker = this._createTreeWalker(parent, { force: true });
+            let refNode = traverseNode(parent, walker);
+            refNode = walker.firstChild();
+            while (refNode) {
+              if (
+                refNode.localName === 'input' &&
+                refNode.getAttribute('type') === 'radio'
+              ) {
+                if (refNode.hasAttribute('name')) {
+                  if (refNode.getAttribute('name') === nodeName) {
+                    checked = !!refNode.checked;
+                  }
+                } else {
+                  checked = !!refNode.checked;
+                }
+                if (checked) {
+                  break;
                 }
-              } else {
-                valid = true;
               }
+              refNode = walker.nextNode();
             }
-            if (valid) {
-              if (astName === 'valid') {
-                matched.add(node);
+            checked = !!checked;
+            parentCache.set(nodeName, checked);
+          }
+          return !checked;
+        }
+        break;
+      }
+      case 'valid':
+      case 'invalid': {
+        if (KEYS_FORM_PS_VALID.has(localName)) {
+          let valid = false;
+          if (node.checkValidity()) {
+            if (node.maxLength >= 0) {
+              if (node.maxLength >= node.value.length) {
+                valid = true;
               }
-            } else if (astName === 'invalid') {
-              matched.add(node);
+            } else {
+              valid = true;
             }
-          } else if (localName === 'fieldset') {
-            const walker = this._createTreeWalker(node);
+          }
+          if (astName === 'invalid') {
+            return !valid;
+          }
+          return valid;
+        }
+        if (localName === 'fieldset') {
+          if (!this.#psValidCache) {
+            this.#psValidCache = new WeakMap();
+          }
+          let valid = this.#psValidCache.get(node);
+          if (valid === undefined && !this.#psValidCache.has(node)) {
+            const walker = this._createTreeWalker(node, { force: true });
             let refNode = traverseNode(node, walker);
             refNode = walker.firstChild();
-            let valid;
             if (!refNode) {
               valid = true;
             } else {
@@ -1523,201 +1488,345 @@ export class Finder {
                 refNode = walker.nextNode();
               }
             }
-            if (valid) {
-              if (astName === 'valid') {
-                matched.add(node);
-              }
-            } else if (astName === 'invalid') {
-              matched.add(node);
-            }
+            this.#psValidCache.set(node, valid);
           }
-          break;
+          if (astName === 'invalid') {
+            return !valid;
+          }
+          return valid;
         }
-        case 'in-range':
-        case 'out-of-range': {
-          const attrType = node.getAttribute('type');
-          if (
-            localName === 'input' &&
-            !(node.readOnly || node.hasAttribute('readonly')) &&
-            !(node.disabled || node.hasAttribute('disabled')) &&
-            KEYS_INPUT_RANGE.has(attrType)
-          ) {
-            const flowed =
-              node.validity.rangeUnderflow || node.validity.rangeOverflow;
-            if (astName === 'out-of-range' && flowed) {
-              matched.add(node);
-            } else if (
-              astName === 'in-range' &&
-              !flowed &&
-              (node.hasAttribute('min') ||
+        break;
+      }
+      case 'in-range':
+      case 'out-of-range': {
+        const attrType = node.getAttribute('type');
+        if (
+          localName === 'input' &&
+          !(node.readOnly || node.hasAttribute('readonly')) &&
+          !(node.disabled || node.hasAttribute('disabled')) &&
+          KEYS_INPUT_RANGE.has(attrType)
+        ) {
+          const flowed =
+            node.validity.rangeUnderflow || node.validity.rangeOverflow;
+          if (astName === 'out-of-range') {
+            return flowed;
+          }
+          return flowed
+            ? false
+            : node.hasAttribute('min') ||
                 node.hasAttribute('max') ||
-                attrType === 'range')
-            ) {
-              matched.add(node);
-            }
-          }
-          break;
+                attrType === 'range';
         }
-        case 'required':
-        case 'optional': {
-          let required;
-          let optional;
-          if (localName === 'select' || localName === 'textarea') {
-            if (node.required || node.hasAttribute('required')) {
-              required = true;
-            } else {
-              optional = true;
-            }
-          } else if (localName === 'input') {
-            if (node.hasAttribute('type')) {
-              const attrType = node.getAttribute('type');
-              if (KEYS_INPUT_REQUIRED.has(attrType)) {
-                if (node.required || node.hasAttribute('required')) {
-                  required = true;
-                } else {
-                  optional = true;
-                }
-              } else {
-                optional = true;
+        break;
+      }
+      case 'required':
+      case 'optional': {
+        let required = false;
+        if (localName === 'select' || localName === 'textarea') {
+          if (node.required || node.hasAttribute('required')) {
+            required = true;
+          }
+        } else if (localName === 'input') {
+          if (node.hasAttribute('type')) {
+            const attrType = node.getAttribute('type');
+            if (KEYS_INPUT_REQUIRED.has(attrType)) {
+              if (node.required || node.hasAttribute('required')) {
+                required = true;
               }
-            } else if (node.required || node.hasAttribute('required')) {
-              required = true;
-            } else {
-              optional = true;
             }
+          } else if (node.required || node.hasAttribute('required')) {
+            required = true;
           }
-          if (astName === 'required' && required) {
-            matched.add(node);
-          } else if (astName === 'optional' && optional) {
-            matched.add(node);
+        }
+        if (astName === 'optional') {
+          return !required;
+        }
+        return required;
+      }
+      /* Location pseudo-classes */
+      case 'any-link':
+      case 'link': {
+        return (
+          (localName === 'a' || localName === 'area') &&
+          node.hasAttribute('href')
+        );
+      }
+      case 'local-link': {
+        if (
+          (localName === 'a' || localName === 'area') &&
+          node.hasAttribute('href')
+        ) {
+          if (!this.#documentURL) {
+            this.#documentURL = new URL(this.#document.URL);
           }
-          break;
+          const { href, origin, pathname } = this.#documentURL;
+          const attrURL = new URL(node.getAttribute('href'), href);
+          return attrURL.origin === origin && attrURL.pathname === pathname;
+        }
+        break;
+      }
+      case 'visited': {
+        // prevent fingerprinting
+        break;
+      }
+      case 'target': {
+        if (!this.#documentURL) {
+          this.#documentURL = new URL(this.#document.URL);
+        }
+        const { hash } = this.#documentURL;
+        return hash && hash === `#${node.id}` && this.#document.contains(node);
+      }
+      case 'scope': {
+        if (this.#node.nodeType === ELEMENT_NODE) {
+          return !this.#shadow && node === this.#node;
+        }
+        return node === this.#document.documentElement;
+      }
+      /* Tree-structural pseudo-classes */
+      case 'root': {
+        return node === this.#document.documentElement;
+      }
+      case 'empty': {
+        if (!node.hasChildNodes()) {
+          return true;
         }
-        case 'root': {
-          if (node === this.#document.documentElement) {
-            matched.add(node);
+        const walker = this._createTreeWalker(node, {
+          force: true,
+          whatToShow: SHOW_ALL
+        });
+        let refNode = walker.firstChild();
+        let bool;
+        while (refNode) {
+          bool =
+            refNode.nodeType !== ELEMENT_NODE && refNode.nodeType !== TEXT_NODE;
+          if (!bool) {
+            break;
           }
-          break;
+          refNode = walker.nextSibling();
         }
-        case 'empty': {
-          if (node.hasChildNodes()) {
-            const walker = this._createTreeWalker(node, {
-              force: true,
-              whatToShow: SHOW_ALL
-            });
-            let refNode = walker.firstChild();
-            let bool;
-            while (refNode) {
-              bool =
-                refNode.nodeType !== ELEMENT_NODE &&
-                refNode.nodeType !== TEXT_NODE;
-              if (!bool) {
-                break;
+        return bool;
+      }
+      case 'first-child':
+      case 'last-child':
+      case 'only-child': {
+        if (!parentNode) {
+          return node === this.#root;
+        }
+        if (astName === 'first-child') {
+          return node === parentNode.firstElementChild;
+        }
+        if (astName === 'last-child') {
+          return node === parentNode.lastElementChild;
+        }
+        return (
+          node === parentNode.firstElementChild &&
+          node === parentNode.lastElementChild
+        );
+      }
+      /* User action pseudo-classes */
+      case 'hover': {
+        const { target, type } = this.#event ?? {};
+        return (
+          /^(?:click|mouse(?:down|over|up))$/.test(type) &&
+          target?.nodeType === ELEMENT_NODE &&
+          node.contains(target)
+        );
+      }
+      case 'active': {
+        const { buttons, target, type } = this.#event ?? {};
+        return (
+          type === 'mousedown' &&
+          buttons & 1 &&
+          target?.nodeType === ELEMENT_NODE &&
+          node.contains(target)
+        );
+      }
+      case 'focus': {
+        const activeElement = this.#document.activeElement;
+        if (activeElement.shadowRoot) {
+          const activeShadowElement = activeElement.shadowRoot.activeElement;
+          let current = activeShadowElement;
+          while (current) {
+            if (current.nodeType === DOCUMENT_FRAGMENT_NODE) {
+              const { host } = current;
+              if (host === activeElement) {
+                if (isFocusableArea(node)) {
+                  return true;
+                }
+                return host === node;
               }
-              refNode = walker.nextSibling();
             }
-            if (bool) {
-              matched.add(node);
+            current = current.parentNode;
+          }
+        }
+        return node === activeElement && isFocusableArea(node);
+      }
+      case 'focus-visible': {
+        if (node === this.#document.activeElement && isFocusableArea(node)) {
+          let bool;
+          if (isFocusVisible(node)) {
+            bool = true;
+          } else if (this.#focus) {
+            const { relatedTarget, target: focusTarget } = this.#focus;
+            if (focusTarget === node) {
+              if (isFocusVisible(relatedTarget)) {
+                bool = true;
+              } else if (this.#event) {
+                const {
+                  altKey: eventAltKey,
+                  ctrlKey: eventCtrlKey,
+                  key: eventKey,
+                  metaKey: eventMetaKey,
+                  target: eventTarget,
+                  type: eventType
+                } = this.#event;
+                // this.#event is irrelevant if eventTarget === relatedTarget
+                if (eventTarget === relatedTarget) {
+                  if (!this.#lastFocusVisible) {
+                    bool = true;
+                  } else if (focusTarget === this.#lastFocusVisible) {
+                    bool = true;
+                  }
+                } else if (eventKey === 'Tab') {
+                  if (
+                    (eventType === 'keydown' && eventTarget !== node) ||
+                    (eventType === 'keyup' && eventTarget === node)
+                  ) {
+                    if (eventTarget === focusTarget) {
+                      if (!this.#lastFocusVisible) {
+                        bool = true;
+                      } else if (
+                        eventTarget === this.#lastFocusVisible &&
+                        relatedTarget === null
+                      ) {
+                        bool = true;
+                      }
+                    } else {
+                      bool = true;
+                    }
+                  }
+                } else if (eventKey) {
+                  if (
+                    (eventType === 'keydown' || eventType === 'keyup') &&
+                    !eventAltKey &&
+                    !eventCtrlKey &&
+                    !eventMetaKey &&
+                    eventTarget === node
+                  ) {
+                    bool = true;
+                  }
+                }
+              } else if (
+                relatedTarget === null ||
+                relatedTarget === this.#lastFocusVisible
+              ) {
+                bool = true;
+              }
             }
-          } else {
-            matched.add(node);
-          }
-          break;
-        }
-        case 'first-child': {
-          if (
-            (parentNode && node === parentNode.firstElementChild) ||
-            node === this.#root
-          ) {
-            matched.add(node);
           }
-          break;
-        }
-        case 'last-child': {
-          if (
-            (parentNode && node === parentNode.lastElementChild) ||
-            node === this.#root
-          ) {
-            matched.add(node);
+          if (bool) {
+            this.#lastFocusVisible = node;
+            return bool;
           }
-          break;
-        }
-        case 'only-child': {
-          if (
-            (parentNode &&
-              node === parentNode.firstElementChild &&
-              node === parentNode.lastElementChild) ||
-            node === this.#root
-          ) {
-            matched.add(node);
+          if (this.#lastFocusVisible === node) {
+            this.#lastFocusVisible = null;
           }
-          break;
         }
-        case 'defined': {
-          if (node.hasAttribute('is') || localName.includes('-')) {
-            if (isCustomElement(node)) {
-              matched.add(node);
+        break;
+      }
+      case 'focus-within': {
+        if (!this.#focusWithinCache) {
+          this.#focusWithinCache = new Set();
+          let currentFocus = this.#document.activeElement;
+          if (currentFocus && isFocusableArea(currentFocus)) {
+            while (currentFocus) {
+              this.#focusWithinCache.add(currentFocus);
+              if (currentFocus.parentNode) {
+                currentFocus = currentFocus.parentNode;
+              } else if (
+                currentFocus.nodeType === DOCUMENT_FRAGMENT_NODE &&
+                currentFocus.host
+              ) {
+                currentFocus = currentFocus.host;
+              } else {
+                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;
+                }
+              }
             }
-            // NOTE: MathMLElement is not implemented in jsdom.
-          } else if (
-            node instanceof this.#window.HTMLElement ||
-            node instanceof this.#window.SVGElement
-          ) {
-            matched.add(node);
-          }
-          break;
-        }
-        case 'popover-open': {
-          // FIXME: not implemented in jsdom
-          // @see https://github.com/jsdom/jsdom/issues/3721
-          /*
-          if (node.popover && isVisible(node)) {
-            matched.add(node);
           }
-          */
-          break;
         }
-        // Ignore :host.
-        case 'host': {
-          break;
+        return this.#focusWithinCache.has(node);
+      }
+      // Ignore :host.
+      case 'host': {
+        break;
+      }
+      // Legacy pseudo-elements.
+      case 'after':
+      case 'before':
+      case 'first-letter':
+      case 'first-line': {
+        if (warn) {
+          this.onError(
+            generateException(
+              `Unsupported pseudo-element ::${astName}`,
+              NOT_SUPPORTED_ERR,
+              this.#window
+            )
+          );
         }
-        // Legacy pseudo-elements.
-        case 'after':
-        case 'before':
-        case 'first-letter':
-        case 'first-line': {
-          if (warn) {
-            this.onError(
-              generateException(
-                `Unsupported pseudo-element ::${astName}`,
-                NOT_SUPPORTED_ERR,
-                this.#window
-              )
-            );
-          }
-          break;
+        break;
+      }
+      // Not supported.
+      case 'autofill':
+      case 'blank':
+      case 'buffering':
+      case 'current':
+      case 'fullscreen':
+      case 'future':
+      case 'has-slotted':
+      case 'heading':
+      case 'modal':
+      case 'muted':
+      case 'past':
+      case 'paused':
+      case 'picture-in-picture':
+      case 'playing':
+      case 'seeking':
+      case 'stalled':
+      case 'user-invalid':
+      case 'user-valid':
+      case 'volume-locked':
+      case '-webkit-autofill': {
+        if (warn) {
+          this.onError(
+            generateException(
+              `Unsupported pseudo-class :${astName}`,
+              NOT_SUPPORTED_ERR,
+              this.#window
+            )
+          );
         }
-        // Not supported.
-        case 'autofill':
-        case 'blank':
-        case 'buffering':
-        case 'current':
-        case 'fullscreen':
-        case 'future':
-        case 'has-slotted':
-        case 'heading':
-        case 'modal':
-        case 'muted':
-        case 'past':
-        case 'paused':
-        case 'picture-in-picture':
-        case 'playing':
-        case 'seeking':
-        case 'stalled':
-        case 'user-invalid':
-        case 'user-valid':
-        case 'volume-locked':
-        case '-webkit-autofill': {
+        break;
+      }
+      default: {
+        if (astName.startsWith('-webkit-')) {
           if (warn) {
             this.onError(
               generateException(
@@ -1727,32 +1836,18 @@ export class Finder {
               )
             );
           }
-          break;
-        }
-        default: {
-          if (astName.startsWith('-webkit-')) {
-            if (warn) {
-              this.onError(
-                generateException(
-                  `Unsupported pseudo-class :${astName}`,
-                  NOT_SUPPORTED_ERR,
-                  this.#window
-                )
-              );
-            }
-          } else if (!forgive) {
-            this.onError(
-              generateException(
-                `Unknown pseudo-class :${astName}`,
-                SYNTAX_ERR,
-                this.#window
-              )
-            );
-          }
+        } else if (!forgive) {
+          this.onError(
+            generateException(
+              `Unknown pseudo-class :${astName}`,
+              SYNTAX_ERR,
+              this.#window
+            )
+          );
         }
       }
     }
-    return matched;
+    return false;
   }
 
   /**
@@ -1761,7 +1856,7 @@ export class Finder {
    * @param {Array.<object>} leaves - The AST leaves.
    * @param {object} host - The host element.
    * @param {object} ast - The original AST for error reporting.
-   * @returns {boolean} True if matched.
+   * @returns {boolean} True if matches, otherwise false.
    */
   _evaluateHostPseudo = (leaves, host, ast) => {
     const l = leaves.length;
@@ -1773,7 +1868,7 @@ export class Finder {
         this.onError(generateException(msg, SYNTAX_ERR, this.#window));
         return false;
       }
-      if (!this._matchSelector(leaf, host).has(host)) {
+      if (!this._matchSelector(leaf, host)) {
         return false;
       }
     }
@@ -1801,7 +1896,7 @@ export class Finder {
           this.onError(generateException(msg, SYNTAX_ERR, this.#window));
           return false;
         }
-        bool = this._matchSelector(leaf, parent).has(parent);
+        bool = this._matchSelector(leaf, parent);
         if (!bool) {
           break;
         }
@@ -1815,44 +1910,48 @@ export class Finder {
   };
 
   /**
-   * Matches shadow host pseudo-classes.
+   * Evaluates shadow host pseudo-classes.
    * @private
    * @param {object} ast - The AST.
    * @param {object} node - The DocumentFragment node.
-   * @returns {?object} The matched node.
+   * @returns {boolean} True if matches, otherwise false.
    */
-  _matchShadowHostPseudoClass = (ast, node) => {
+  _evaluateShadowHost = (ast, node) => {
     const { children: astChildren, name: astName } = ast;
     // Handle simple pseudo-class (no arguments).
     if (!Array.isArray(astChildren)) {
       if (astName === 'host') {
-        return node;
+        return true;
       }
       const msg = `Invalid selector :${astName}`;
-      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      return false;
     }
     // Handle functional pseudo-class like :host(...).
     if (astName !== 'host' && astName !== 'host-context') {
       const msg = `Invalid selector :${astName}()`;
-      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      return false;
     }
     if (astChildren.length !== 1) {
       const css = generateCSS(ast);
       const msg = `Invalid selector ${css}`;
-      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      return false;
     }
     const { host } = node;
     const { branches } = walkAST(astChildren[0]);
     const [branch] = branches;
     const [...leaves] = branch;
-    let isMatch = false;
-    if (astName === 'host') {
-      isMatch = this._evaluateHostPseudo(leaves, host, ast);
-      // astName === 'host-context'.
-    } else {
-      isMatch = this._evaluateHostContextPseudo(leaves, host, ast);
+    if (astName === 'host' && this._evaluateHostPseudo(leaves, host, ast)) {
+      return true;
+    } else if (
+      astName === 'host-context' &&
+      this._evaluateHostContextPseudo(leaves, host, ast)
+    ) {
+      return true;
     }
-    return isMatch ? node : null;
+    return false;
   };
 
   /**
@@ -1861,39 +1960,26 @@ export class Finder {
    * @param {object} ast - The AST.
    * @param {object} node - The Element node.
    * @param {object} opt - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
+   * @returns {boolean} True if matches, otherwise false.
    */
   _matchSelectorForElement = (ast, node, opt) => {
     const { type: astType } = ast;
     const astName = unescapeSelector(ast.name);
-    const matched = new Set();
     switch (astType) {
       case ATTR_SELECTOR: {
-        if (matchAttributeSelector(ast, node, opt)) {
-          matched.add(node);
-        }
-        break;
+        return matchAttributeSelector(ast, node, opt);
       }
       case ID_SELECTOR: {
-        if (node.id === astName) {
-          matched.add(node);
-        }
-        break;
+        return node.id === astName;
       }
       case CLASS_SELECTOR: {
-        if (node.classList.contains(astName)) {
-          matched.add(node);
-        }
-        break;
+        return node.classList.contains(astName);
       }
       case PS_CLASS_SELECTOR: {
         return this._matchPseudoClassSelector(ast, node, opt);
       }
       case TYPE_SELECTOR: {
-        if (matchTypeSelector(ast, node, opt)) {
-          matched.add(node);
-        }
-        break;
+        return matchTypeSelector(ast, node, opt);
       }
       // PS_ELEMENT_SELECTOR is handled by default.
       default: {
@@ -1901,7 +1987,7 @@ export class Finder {
           if (this.#check) {
             const css = generateCSS(ast);
             this.#pseudoElement.push(css);
-            matched.add(node);
+            return true;
           } else {
             matchPseudoElementSelector(astName, astType, opt);
           }
@@ -1910,7 +1996,7 @@ export class Finder {
         }
       }
     }
-    return matched;
+    return false;
   };
 
   /**
@@ -1919,7 +2005,7 @@ export class Finder {
    * @param {object} ast - The AST.
    * @param {object} node - The DocumentFragment node.
    * @param {object} [opt] - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
+   * @returns {boolean} True if matches, otherwise false.
    */
   _matchSelectorForShadowRoot = (ast, node, opt = {}) => {
     const { name: astName } = ast;
@@ -1927,15 +2013,14 @@ export class Finder {
       opt.isShadowRoot = true;
       return this._matchPseudoClassSelector(ast, node, opt);
     }
-    const matched = new Set();
     if (astName === 'host' || astName === 'host-context') {
-      const res = this._matchShadowHostPseudoClass(ast, node, opt);
-      if (res) {
+      const matches = this._evaluateShadowHost(ast, node, opt);
+      if (matches) {
         this.#verifyShadowHost = true;
-        matched.add(res);
+        return true;
       }
     }
-    return matched;
+    return false;
   };
 
   /**
@@ -1944,7 +2029,7 @@ export class Finder {
    * @param {object} ast - The AST.
    * @param {object} node - The Document, DocumentFragment, or Element node.
    * @param {object} opt - Options.
-   * @returns {Set.<object>} A collection of matched nodes.
+   * @returns {boolean} True if matches, otherwise false.
    */
   _matchSelector = (ast, node, opt) => {
     if (node.nodeType === ELEMENT_NODE) {
@@ -1957,7 +2042,7 @@ export class Finder {
     ) {
       return this._matchSelectorForShadowRoot(ast, node, opt);
     }
-    return new Set();
+    return false;
   };
 
   /**
@@ -1969,6 +2054,9 @@ export class Finder {
    * @returns {boolean} The result.
    */
   _matchLeaves = (leaves, node, opt) => {
+    if (!this.#invalidateResults) {
+      this.#invalidateResults = new WeakMap();
+    }
     const results = this.#invalidate ? this.#invalidateResults : this.#results;
     let result = results.get(leaves);
     if (result && result.has(node)) {
@@ -1999,7 +2087,7 @@ export class Finder {
           // No action needed for other types.
         }
       }
-      bool = this._matchSelector(leaf, node, opt).has(node);
+      bool = this._matchSelector(leaf, node, opt);
       if (!bool) {
         break;
       }
@@ -2023,6 +2111,9 @@ export class Finder {
    * @returns {Array.<object>} The filtered leaves.
    */
   _getFilterLeaves = leaves => {
+    if (!this.#filterLeavesCache) {
+      this.#filterLeavesCache = new WeakMap();
+    }
     if (this.#filterLeavesCache.has(leaves)) {
       return this.#filterLeavesCache.get(leaves);
     }
@@ -2105,7 +2196,7 @@ export class Finder {
   };
 
   /**
-   * Collects combinator matches into an array without creating intermediate sets.
+   * Collects combinator matches into an array.
    * @private
    * @param {object} twig - The twig object.
    * @param {object} node - The Element node.
@@ -2132,12 +2223,36 @@ export class Finder {
         break;
       }
       case '~': {
+        const parentNode = node.parentNode;
+        if (!parentNode) {
+          break;
+        }
+        if (!this.#combinatorCache) {
+          this.#combinatorCache = new WeakMap();
+        }
+        let cacheMap = this.#combinatorCache.get(parentNode);
+        if (!cacheMap) {
+          cacheMap = new Map();
+          this.#combinatorCache.set(parentNode, cacheMap);
+        }
+        let matchedSet = cacheMap.get(leaves);
+        if (!matchedSet) {
+          matchedSet = new Set();
+          let child = parentNode.firstElementChild;
+          while (child) {
+            if (this._matchLeaves(leaves, child, opt)) {
+              matchedSet.add(child);
+            }
+            child = child.nextElementSibling;
+          }
+          cacheMap.set(leaves, matchedSet);
+        }
         let refNode =
           dir === DIR_NEXT
             ? node.nextElementSibling
             : node.previousElementSibling;
         while (refNode) {
-          if (this._matchLeaves(leaves, refNode, opt)) {
+          if (matchedSet.has(refNode)) {
             matched.push(refNode);
           }
           refNode =
@@ -2298,8 +2413,8 @@ export class Finder {
       this.#nodeWalker = this._createTreeWalker(this.#node);
     }
     return this._traverseAndCollectNodes(this.#nodeWalker, leaves, {
-      startNode: node,
-      ...traversalOpts
+      ...traversalOpts,
+      startNode: node
     });
   };
 
@@ -2487,13 +2602,18 @@ export class Finder {
     let pending = false;
     if (targetType !== TARGET_LINEAL && /host(?:-context)?/.test(leaf.name)) {
       let shadowRoot = null;
-      if (this.#shadow && this.#node.nodeType === DOCUMENT_FRAGMENT_NODE) {
-        shadowRoot = this._matchShadowHostPseudoClass(leaf, this.#node);
-      } else if (filterLeaves.length && this.#node.nodeType === ELEMENT_NODE) {
-        shadowRoot = this._matchShadowHostPseudoClass(
-          leaf,
-          this.#node.shadowRoot
-        );
+      if (
+        this.#shadow &&
+        this.#node.nodeType === DOCUMENT_FRAGMENT_NODE &&
+        this._evaluateShadowHost(leaf, this.#node)
+      ) {
+        shadowRoot = this.#node;
+      } else if (
+        filterLeaves.length &&
+        this.#node.nodeType === ELEMENT_NODE &&
+        this._evaluateShadowHost(leaf, this.#node.shadowRoot)
+      ) {
+        shadowRoot = this.#node.shadowRoot;
       }
       if (shadowRoot) {
         let bool = true;
@@ -2503,19 +2623,11 @@ export class Finder {
           switch (filterLeaf.name) {
             case 'host':
             case 'host-context': {
-              const matchedNode = this._matchShadowHostPseudoClass(
-                filterLeaf,
-                shadowRoot
-              );
-              bool = matchedNode === shadowRoot;
+              bool = this._evaluateShadowHost(filterLeaf, shadowRoot);
               break;
             }
             case 'has': {
-              bool = this._matchPseudoClassSelector(
-                filterLeaf,
-                shadowRoot,
-                {}
-              ).has(shadowRoot);
+              bool = this._matchPseudoClassSelector(filterLeaf, shadowRoot, {});
               break;
             }
             default: {
@@ -2630,31 +2742,20 @@ export class Finder {
     const {
       leaves: [{ name: lastName, type: lastType }]
     } = lastTwig;
-    const { combo: firstCombo } = firstTwig;
     if (
       this.#selector.includes(':scope') ||
       lastType === PS_ELEMENT_SELECTOR ||
       lastType === ID_SELECTOR
     ) {
       return { dir: DIR_PREV, twig: lastTwig };
-    }
-    if (firstType === ID_SELECTOR) {
+    } else if (firstType === ID_SELECTOR) {
       return { dir: DIR_NEXT, twig: firstTwig };
-    }
-    if (firstName === '*' && firstType === TYPE_SELECTOR) {
+    } else if (firstName === '*' && firstType === TYPE_SELECTOR) {
       return { dir: DIR_PREV, twig: lastTwig };
-    }
-    if (lastName === '*' && lastType === TYPE_SELECTOR) {
+    } else if (lastName === '*' && lastType === TYPE_SELECTOR) {
       return { dir: DIR_NEXT, twig: firstTwig };
-    }
-    if (branchLen === 2) {
-      if (targetType === TARGET_FIRST) {
-        return { dir: DIR_PREV, twig: lastTwig };
-      }
-      const { name: comboName } = firstCombo;
-      if (comboName === '+' || comboName === '~') {
-        return { dir: DIR_PREV, twig: lastTwig };
-      }
+    } else if (branchLen === 1 || branchLen === 2) {
+      return { dir: DIR_PREV, twig: lastTwig };
     } else if (branchLen > 2 && this.#scoped && targetType === TARGET_FIRST) {
       if (lastType === TYPE_SELECTOR) {
         return { dir: DIR_PREV, twig: lastTwig };
@@ -2879,7 +2980,6 @@ export class Finder {
     const matchedNodes = new Set();
     const branchLen = branch.length;
     const lastIndex = branchLen - 1;
-
     if (dir === DIR_NEXT) {
       const { combo: firstCombo } = branch[0];
       for (const node of entryNodes) {