@asamuzakjp/dom-selector 8.0.2 → 8.1.2

package/src/js/matcher.js

@@ -116,37 +116,42 @@ export const matchPseudoElementSelector = (
  * Matches the :dir() pseudo-class against an element's directionality.
  * @param {object} ast - The AST object for the pseudo-class.
  * @param {object} node - The element node to match against.
+ * @param {WeakMap} [dirCache] - Cache for directionality.
  * @throws {TypeError} If the AST does not contain a valid direction value.
  * @returns {boolean} - True if the directionality matches, otherwise false.
  */
-export const matchDirectionPseudoClass = (ast, node) => {
+export const matchDirectionPseudoClass = (
+  ast,
+  node,
+  dirCache = new WeakMap()
+) => {
   const { name } = ast;
-  // The :dir() pseudo-class requires a direction argument (e.g., "ltr").
   if (!name) {
     const type = name === '' ? '(empty String)' : getType(name);
     throw new TypeError(`Unexpected ast type ${type}`);
   }
-  // Get the computed directionality of the element.
-  const dir = getDirectionality(node);
-  // Compare the expected direction with the element's actual direction.
+  const dir = getDirectionality(node, dirCache);
   return name === dir;
 };
 
 /**
- * Matches the :lang() pseudo-class against an element's language.
- * @see https://datatracker.ietf.org/doc/html/rfc4647#section-3.3.1
- * @param {object} ast - The AST object for the pseudo-class.
+ * Matches the :lang() pseudo-class against an element's language attribute.
+ * @param {object} ast - The AST object for the pseudo-class child.
  * @param {object} node - The element node to match against.
- * @returns {boolean} - True if the language matches, otherwise false.
+ * @param {WeakMap} [langCache] - Cache for language attributes.
+ * @throws {TypeError} If the AST does not contain a valid language value.
+ * @returns {boolean} - True if the language attribute matches, otherwise false.
  */
-export const matchLanguagePseudoClass = (ast, node) => {
-  // Get the effective language attribute for the current node.
-  const elementLang = getLanguageAttribute(node);
-  // If the element has no language, it cannot match a specific pattern.
+export const matchLanguagePseudoClass = (
+  ast,
+  node,
+  langCache = new WeakMap()
+) => {
+  const elementLang = getLanguageAttribute(node, langCache);
   if (elementLang === null) {
     return false;
   }
-  // Use cached regex.
+  // Use cached regex if available
   if (ast._langRegex !== undefined) {
     if (ast._langPattern === '*') {
       return elementLang !== '';
@@ -158,30 +163,24 @@ export const matchLanguagePseudoClass = (ast, node) => {
   }
   const { name, type, value } = ast;
   let langPattern;
-  // Determine the language pattern from the AST.
   if (type === STRING && value) {
     langPattern = value;
   } else if (type === IDENT && name) {
     langPattern = unescapeSelector(name);
   }
-  // Cache lang pattern.
   ast._langPattern = langPattern;
-  // If no valid language pattern is provided, it cannot match.
   if (typeof langPattern !== 'string') {
     ast._langRegex = null;
     return false;
   }
-  // Handle the universal selector '*' for :lang.
   if (langPattern === '*') {
     ast._langRegex = null;
     return elementLang !== '';
   }
-  // Validate the provided language pattern structure.
   if (!REG_LANG_VALID.test(langPattern)) {
     ast._langRegex = null;
     return false;
   }
-  // Build a regex for extended language range matching.
   let matcherRegex;
   if (langPattern.indexOf('-') > -1) {
     const [langMain, langSub, ...langRest] = langPattern.split('-');
@@ -199,8 +198,8 @@ export const matchLanguagePseudoClass = (ast, node) => {
   } else {
     matcherRegex = new RegExp(`^${langPattern}${LANG_PART}$`, 'i');
   }
+  // Store compiled regex in AST for subsequent matches
   ast._langRegex = matcherRegex;
-  // Test the element's language against the constructed regex.
   return matcherRegex.test(elementLang);
 };
 
@@ -208,7 +207,7 @@ export const matchLanguagePseudoClass = (ast, node) => {
  * Matches the :disabled and :enabled pseudo-classes.
  * @param {string} astName - pseudo-class name
  * @param {object} node - Element node
- * @returns {boolean} - True if matched
+ * @returns {boolean} - True if the pseudo-class matches, otherwise false.
  */
 export const matchDisabledPseudoClass = (astName, node) => {
   const { localName, parentNode } = node;
@@ -265,7 +264,7 @@ export const matchDisabledPseudoClass = (astName, node) => {
  * Match the :read-only and :read-write pseudo-classes
  * @param {string} astName - pseudo-class name
  * @param {object} node - Element node
- * @returns {boolean} - True if matched
+ * @returns {boolean} - True if the pseudo-class matches, otherwise false.
  */
 export const matchReadOnlyPseudoClass = (astName, node) => {
   const { localName } = node;
@@ -328,6 +327,42 @@ export const matchAttributeSelector = (
       globalObject
     );
   }
+  if (astMatcher === null && !astFlags && typeof astName?.name === 'string') {
+    const rawName = unescapeSelector(astName.name);
+    if (rawName.indexOf('|') === -1) {
+      if (node.hasAttribute(rawName)) {
+        return true;
+      }
+      const attrs = node.attributes;
+      if (!attrs || attrs.length === 0) {
+        return false;
+      }
+      const isHTML = node.ownerDocument.contentType === 'text/html';
+      const checkName = isHTML ? rawName.toLowerCase() : rawName;
+      for (let i = 0, len = attrs.length; i < len; i++) {
+        let itemName = attrs[i].name;
+        if (isHTML) {
+          itemName = itemName.toLowerCase();
+        }
+        const colonIdx = itemName.indexOf(':');
+        if (colonIdx > -1) {
+          const itemPrefix = itemName.substring(0, colonIdx);
+          const itemLocalName = itemName
+            .substring(colonIdx + 1)
+            .replace(/^:/, '');
+          if (itemPrefix === 'xml' && itemLocalName === 'lang') {
+            continue;
+          }
+          if (checkName === itemLocalName) {
+            return true;
+          }
+        } else if (checkName === itemName) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
   const { attributes } = node;
   // An element with no attributes cannot match.
   if (!attributes || !attributes.length) {
@@ -546,7 +581,7 @@ export const matchAttributeSelector = (
  * @param {boolean} [opt.check] - running in internal check()
  * @param {boolean} [opt.forgive] - forgive undeclared namespace
  * @param {object} [opt.globalObject] - The global object.
- * @returns {boolean} - result
+ * @returns {boolean} - True if the type selector matches, otherwise false.
  */
 export const matchTypeSelector = (
   ast,

package/src/js/nwsapi.js

@@ -413,6 +413,7 @@ export class Nwsapi {
   #selectLambdas;
   #selectResolvers;
   #snapshot;
+  #uidCounter = 0;
   #window;
 
   /* static */
@@ -463,10 +464,14 @@ export class Nwsapi {
    */
   constructor(window, document, cacheSize = CACHE_SIZE) {
     this.#window = window;
-    this.#matchLambdas = new GenerationalCache(cacheSize);
-    this.#selectLambdas = new GenerationalCache(cacheSize);
-    this.#matchResolvers = new GenerationalCache(cacheSize);
-    this.#selectResolvers = new GenerationalCache(cacheSize);
+    const cacheOpt = {
+      cacheFunction: true,
+      strictValidate: false
+    };
+    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.#nthChildState = {
       idx: 0,
       len: 0,
@@ -488,8 +493,6 @@ export class Nwsapi {
         isContentEditable,
         isIndeterminate,
         isTarget,
-        match: (selectors, element, callback) =>
-          this.match(selectors, element, callback),
         nthElement: (element, dir) =>
           solveNth(element, dir, this.#nthChildState, false),
         nthOfType: (element, dir) =>
@@ -988,12 +991,27 @@ export class Nwsapi {
     const expr = match[2]
       .replace(REX.commaGroup, ',')
       .replace(REX.trimSpaces, '');
-    const escapedExpr = expr.replace(/\\/g, '\\\\').replace(/\x22/g, '\\"');
-    if (pseudoName === 'is') {
-      return `if(s.match("${escapedExpr}",e)){${source}}`;
-    } else if (pseudoName === 'not') {
-      return `if(!s.match("${escapedExpr}",e)){${source}}`;
+    if (pseudoName === 'is' || pseudoName === 'not') {
+      const subExprs = expr.match(REX.splitGroup) || [expr];
+      const uid = ++this.#uidCounter;
+      const label = `l_${uid}`;
+      let code = `{ let r_${uid}=false, e_${uid}=e, n_${uid}=n, o_${uid}=o; ${label}: { `;
+      for (let i = 0; i < subExprs.length; i++) {
+        const subCode = this._compileSelector(
+          subExprs[i],
+          `r_${uid}=true; break ${label};`,
+          false
+        );
+        code += `{ ${subCode} } e=e_${uid}; n=n_${uid}; o=o_${uid}; `;
+      }
+      code += `} e=e_${uid}; n=n_${uid}; o=o_${uid}; `;
+      if (pseudoName === 'is') {
+        return `${code} if(r_${uid}){${source}} }`;
+      } else {
+        return `${code} if(!r_${uid}){${source}} }`;
+      }
     } else if (pseudoName === 'has') {
+      const escapedExpr = expr.replace(/\\/g, '\\\\').replace(/\x22/g, '\\"');
       this.#matchResolvers.clear();
       return `if(e.querySelector(":scope ${escapedExpr}")){${source}}`;
     }

package/src/js/selector.js

@@ -23,18 +23,17 @@ import {
   PS_ELEMENT_SELECTOR,
   SELECTOR,
   SYNTAX_ERR,
-  TAG_TYPE,
-  TARGET_ALL,
-  TARGET_FIRST
+  TARGET_ALL
 } from './constant.js';
 
 /* regexp */
-const REG_ATTR_SIMPLE = /^\[[A-Z\d-]{1,255}(?:="?[A-Z\d\s-]{1,255}"?)?\]$/i;
-const REG_TAG_SIMPLE = new RegExp(`^(?:${TAG_TYPE})$`);
 const REG_EXCLUDE_BASIC =
   /[|\\]|::|[^\u0021-\u007F\s]|\[\s*[\w$*=^|~-]+(?:(?:"[\w$*=^|~\s'-]+"|'[\w$*=^|~\s"-]+')?(?:\s+[\w$*=^|~-]+)+|"[^"\]]{1,255}|'[^'\]]{1,255})\s*\]|:(?:is|where)\(\s*\)/;
+const REG_EXCLUDE_QSA = new RegExp(
+  `(?:^(?:[A-Z]|\\.)[\\w-]*$|${COMPOUND_I}${DESCEND}${COMPOUND_I})`,
+  'i'
+);
 const REG_COMPLEX = new RegExp(`${COMPOUND_I}${COMBO}${COMPOUND_I}`, 'i');
-const REG_DESCEND = new RegExp(`${COMPOUND_I}${DESCEND}${COMPOUND_I}`, 'i');
 const REG_LOGIC_COMPLEX = new RegExp(
   `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPLEX})`
 );
@@ -266,7 +265,6 @@ export const extractSubjectsRegExp = (selector, caseSensitive) => {
  * @returns {boolean} - True if the selector is valid for nwsapi.
  */
 export const filterSelector = (selector, target) => {
-  const isQuerySelectorAll = target === TARGET_ALL;
   // Basic validation and fast-fail for null/undefined/non-string values.
   if (
     !selector ||
@@ -279,6 +277,10 @@ export const filterSelector = (selector, target) => {
   if (REG_INVALID_SYNTAX.test(selector)) {
     return false;
   }
+  // Target-specific early exits.
+  if (target === TARGET_ALL && REG_EXCLUDE_QSA.test(selector)) {
+    return false;
+  }
   // Exclude various complex or unsupported selectors early.
   // i.e. non-ASCII, escaped selectors, namespaced selectors, pseudo-elements.
   if (selector.includes('/') || REG_EXCLUDE_BASIC.test(selector)) {
@@ -291,26 +293,13 @@ export const filterSelector = (selector, target) => {
       return false;
     }
   }
-  // Target-specific early exits.
-  if (target === TARGET_FIRST) {
-    return REG_ATTR_SIMPLE.test(selector);
-  }
-  if (target === TARGET_ALL && REG_TAG_SIMPLE.test(selector)) {
-    return false;
-  }
   // Logic for pseudo-classes.
   if (selector.includes(':')) {
-    // Exclude descendant combinators in logical selectors for querySelectorAll.
-    if (isQuerySelectorAll && REG_DESCEND.test(selector)) {
-      return false;
-    }
     // Determine if the selector has complex logical structures.
-    const isComplex = isQuerySelectorAll ? false : REG_COMPLEX.test(selector);
+    const isComplex =
+      target === TARGET_ALL ? false : REG_COMPLEX.test(selector);
     // Handle :has() specifically.
     if (selector.includes(':has(')) {
-      if (isQuerySelectorAll) {
-        return false;
-      }
       if (!isComplex || REG_LOGIC_HAS_COMPOUND.test(selector)) {
         return false;
       }

package/src/js/utility.js

@@ -8,17 +8,21 @@ import isCustomElementName from 'is-potential-custom-element-name';
 
 /* constants */
 import {
+  CLASS_SELECTOR,
   DOCUMENT_FRAGMENT_NODE,
   DOCUMENT_NODE,
   DOCUMENT_POSITION_CONTAINS,
   DOCUMENT_POSITION_PRECEDING,
   ELEMENT_NODE,
+  ID_SELECTOR,
   INPUT_BUTTON,
   INPUT_EDIT,
   INPUT_LTR,
   INPUT_TEXT,
+  SHOW_ELEMENT,
   TEXT_NODE,
   TYPE_FROM,
+  TYPE_SELECTOR,
   TYPE_TO
 } from './constant.js';
 const KEYS_DIR_AUTO = new Set([...INPUT_BUTTON, ...INPUT_TEXT, 'hidden']);
@@ -297,19 +301,24 @@ export const getSlottedTextContent = node => {
  * Get directionality of a node.
  * @see https://html.spec.whatwg.org/multipage/dom.html#the-dir-attribute
  * @param {object} node - The Element node.
+ * @param {WeakMap} [dirCache] - Cache for directionality.
  * @returns {?string} - 'ltr' or 'rtl'.
  */
-export const getDirectionality = node => {
+export const getDirectionality = (node, dirCache = new WeakMap()) => {
   if (!node?.nodeType) {
     throw new TypeError(`Unexpected type ${getType(node)}`);
   }
   if (node.nodeType !== ELEMENT_NODE) {
     return null;
   }
+  if (dirCache.has(node)) {
+    return dirCache.get(node);
+  }
   const { dir: dirAttr, localName, parentNode } = node;
   const { getEmbeddingLevels } = bidiFactory();
+  let result = 'ltr';
   if (dirAttr === 'ltr' || dirAttr === 'rtl') {
-    return dirAttr;
+    result = dirAttr;
   } else if (dirAttr === 'auto') {
     let text = '';
     switch (localName) {
@@ -317,7 +326,8 @@ export const getDirectionality = node => {
         if (!node.type || KEYS_DIR_AUTO.has(node.type)) {
           text = node.value;
         } else if (KEYS_DIR_LTR.has(node.type)) {
-          return 'ltr';
+          result = 'ltr';
+          text = null; // Flag to skip text evaluation
         }
         break;
       }
@@ -357,21 +367,23 @@ export const getDirectionality = node => {
         }
       }
     }
-    if (text) {
-      const {
-        paragraphs: [{ level }]
-      } = getEmbeddingLevels(text);
-      if (level % 2 === 1) {
-        return 'rtl';
-      }
-    } else if (parentNode) {
-      const { nodeType: parentNodeType } = parentNode;
-      if (parentNodeType === ELEMENT_NODE) {
-        return getDirectionality(parentNode);
+    if (text !== null) {
+      if (text) {
+        const {
+          paragraphs: [{ level }]
+        } = getEmbeddingLevels(text);
+        if (level % 2 === 1) {
+          result = 'rtl';
+        }
+      } else if (parentNode) {
+        const { nodeType: parentNodeType } = parentNode;
+        if (parentNodeType === ELEMENT_NODE) {
+          result = getDirectionality(parentNode, dirCache);
+        }
       }
     }
   } else if (localName === 'input' && node.type === 'tel') {
-    return 'ltr';
+    result = 'ltr';
   } else if (localName === 'bdi') {
     const text = node.textContent.trim();
     if (text) {
@@ -379,7 +391,7 @@ export const getDirectionality = node => {
         paragraphs: [{ level }]
       } = getEmbeddingLevels(text);
       if (level % 2 === 1) {
-        return 'rtl';
+        result = 'rtl';
       }
     }
   } else if (parentNode) {
@@ -390,47 +402,67 @@ export const getDirectionality = node => {
           paragraphs: [{ level }]
         } = getEmbeddingLevels(text);
         if (level % 2 === 1) {
-          return 'rtl';
+          result = 'rtl';
+        } else {
+          result = 'ltr';
+        }
+      } else {
+        const { nodeType: parentNodeType } = parentNode;
+        if (parentNodeType === ELEMENT_NODE) {
+          result = getDirectionality(parentNode, dirCache);
         }
-        return 'ltr';
       }
-    }
-    const { nodeType: parentNodeType } = parentNode;
-    if (parentNodeType === ELEMENT_NODE) {
-      return getDirectionality(parentNode);
+    } else {
+      const { nodeType: parentNodeType } = parentNode;
+      if (parentNodeType === ELEMENT_NODE) {
+        result = getDirectionality(parentNode, dirCache);
+      }
     }
   }
-  return 'ltr';
+  dirCache.set(node, result);
+  return result;
 };
 
 /**
- * Traverses up the DOM tree to find the language attribute for a node.
- * It checks for 'lang' in HTML and 'xml:lang' in XML contexts.
- * @param {object} node - The starting element node.
- * @returns {string|null} The language attribute value, or null if not found.
+ * Get language attribute of a node.
+ * @param {object} node - The Element node.
+ * @param {WeakMap} [langCache] - Cache for language attributes.
+ * @returns {?string} - Language attribute value.
  */
-export const getLanguageAttribute = node => {
+export const getLanguageAttribute = (node, langCache = new WeakMap()) => {
   if (!node?.nodeType) {
     throw new TypeError(`Unexpected type ${getType(node)}`);
   }
   if (node.nodeType !== ELEMENT_NODE) {
     return null;
   }
+  if (langCache.has(node)) {
+    return langCache.get(node);
+  }
   const { contentType } = node.ownerDocument;
   const isHtml = REG_IS_HTML.test(contentType);
   const isXml = REG_IS_XML.test(contentType);
   let isShadow = false;
+  let result;
+  const visited = [];
   // Traverse up from the current node to the root.
   let current = node;
   while (current) {
+    if (current.nodeType === ELEMENT_NODE && langCache.has(current)) {
+      result = langCache.get(current);
+      break;
+    }
+    if (current.nodeType === ELEMENT_NODE) {
+      visited.push(current);
+    }
     // Check if the current node is an element.
     switch (current.nodeType) {
       case ELEMENT_NODE: {
         // Check for and return the language attribute if present.
         if (isHtml && current.hasAttribute('lang')) {
-          return current.getAttribute('lang');
+          result = current.getAttribute('lang');
         } else if (isXml && current.hasAttribute('xml:lang')) {
-          return current.getAttribute('xml:lang');
+          result = current.getAttribute('xml:lang');
         }
         break;
       }
@@ -444,9 +476,12 @@ export const getLanguageAttribute = node => {
       case DOCUMENT_NODE:
       default: {
         // Stop if we reach the root document node.
-        return null;
+        result = null;
       }
     }
+    if (result !== undefined) {
+      break;
+    }
     if (isShadow) {
       current = current.host;
       isShadow = false;
@@ -456,8 +491,13 @@ export const getLanguageAttribute = node => {
       break;
     }
   }
-  // No language attribute was found in the hierarchy.
-  return null;
+  if (result === undefined) {
+    result = null;
+  }
+  for (const visitedNode of visited) {
+    langCache.set(visitedNode, result);
+  }
+  return result;
 };
 
 /**
@@ -794,3 +834,103 @@ export const sortNodes = (nodes = []) => {
   }
   return arr;
 };
+
+/**
+ * Traverses AST nodes to find the most optimal seed selector
+ * (ID > Class > Tag).
+ * @param {Array} nodes - AST nodes to traverse.
+ * @param {object} [state] - The current state of the search.
+ * @returns {object} The search state containing the best seed.
+ */
+export const findBestSeed = (nodes, state = { seed: null, priority: 0 }) => {
+  for (const node of nodes) {
+    if (state.priority === 3) {
+      return state;
+    }
+    if (Array.isArray(node)) {
+      findBestSeed(node, state);
+    } else if (node && typeof node === 'object') {
+      // ID Selector (Fastest: getElementById)
+      if (node.type === ID_SELECTOR) {
+        state.seed = { type: 'id', value: node.name };
+        state.priority = 3;
+        return state;
+      } else if (node.type === CLASS_SELECTOR && state.priority < 2) {
+        // Class Selector (Faster: getElementsByClassName)
+        state.seed = { type: 'class', value: node.name };
+        state.priority = 2;
+      } else if (
+        node.type === TYPE_SELECTOR &&
+        state.priority < 1 &&
+        node.name !== '*'
+      ) {
+        // Type/Tag Selector (Excludes universal '*')
+        state.seed = { type: 'tag', value: node.name };
+        state.priority = 1;
+      }
+      if (node.children) {
+        findBestSeed(node.children, state);
+      }
+    }
+  }
+  return state;
+};
+
+/**
+ * Traces the DOM tree upwards and sideways from a seed element,
+ * populating the allowlist with safe paths for :has() evaluation.
+ * @param {object} current - The starting seed element.
+ * @param {WeakSet} list - The WeakSet to populate.
+ * @param {Set} visitedAncestors - The Set to track visited nodes.
+ * @returns {void}
+ */
+export const populateHasAllowlist = (current, list, visitedAncestors) => {
+  list.add(current);
+  while (
+    current &&
+    (current.nodeType === ELEMENT_NODE ||
+      current.nodeType === DOCUMENT_FRAGMENT_NODE)
+  ) {
+    if (visitedAncestors.has(current)) {
+      break;
+    }
+    visitedAncestors.add(current);
+    let sibling = current.previousElementSibling;
+    while (sibling) {
+      list.add(sibling);
+      sibling = sibling.previousElementSibling;
+    }
+    sibling = current.nextElementSibling;
+    while (sibling) {
+      list.add(sibling);
+      sibling = sibling.nextElementSibling;
+    }
+    current = current.parentNode;
+    if (current) {
+      list.add(current);
+    }
+  }
+};
+
+/**
+ * Collects all descendant elements of a given node using a TreeWalker.
+ * @param {Document|DocumentFragment|Element} node - The node to start from.
+ * @param {Document} document - The Document used to create the TreeWalker.
+ * @returns {Array<Element>} An array containing all descendant elements.
+ */
+export const collectAllDescendants = (node, document) => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (document?.nodeType !== DOCUMENT_NODE) {
+    throw new TypeError(`Unexpected type ${getType(document)}`);
+  }
+  const walker = document.createTreeWalker(node, SHOW_ELEMENT);
+  const descendants = [];
+  let refNode = walker.nextNode();
+  while (refNode) {
+    descendants.push(refNode);
+    refNode = walker.nextNode();
+  }
+  return descendants;
+};

package/types/index.d.ts

@@ -1,6 +1,6 @@
 export class DOMSelector {
     constructor(window: Window, document: Document, opt?: object);
-    clear: () => void;
+    clear: (clearAll?: boolean) => void;
     extractSubjects: (selector: string, caseSensitive?: boolean) => Array<{
         id: string | null;
         className: string | null;

package/types/js/constant.d.ts

@@ -54,8 +54,10 @@ export const DESCEND: "\\s?[\\s>]\\s?";
 export const SIBLING: "\\s?[+~]\\s?";
 export const LOGIC_IS: ":is\\(\\s*[^)]+\\s*\\)";
 export const N_TH: "nth-(?:last-)?(?:child|of-type)\\(\\s*(?:even|odd|[+-]?(?:(?:0|[1-9]\\d*)n?|n)|(?:[+-]?(?:0|[1-9]\\d*))?n\\s*[+-]\\s*(?:0|[1-9]\\d*))\\s*\\)";
+export const ATTR_TYPE: "\\[[^|\\]]+\\]";
 export const SUB_TYPE: "\\[[^|\\]]+\\]|[#.:][\\w-]+";
 export const SUB_TYPE_WO_PSEUDO: "\\[[^|\\]]+\\]|[#.][\\w-]+";
+export const TAG_TYPE_WO_UNIVERSAL: "[A-Za-z][\\w-]*";
 export const TAG_TYPE: "\\*|[A-Za-z][\\w-]*";
 export const TAG_TYPE_I: "\\*|[A-Z][\\w-]*";
 export const COMPOUND: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)";

package/types/js/finder.d.ts

@@ -22,12 +22,15 @@ export class Finder {
     private _collectNthOfType;
     private _matchAnPlusB;
     private _matchHasPseudoFunc;
+    private _buildHasAllowlist;
     private _evaluateHasPseudo;
     private _matchLogicalPseudoFunc;
+    private _evaluateLogicalPseudo;
+    private _evaluatePseudoClassFunc;
     private _matchPseudoClassSelector;
     private _evaluateHostPseudo;
     private _evaluateHostContextPseudo;
-    private _matchShadowHostPseudoClass;
+    private _evaluateShadowHost;
     private _matchSelectorForElement;
     private _matchSelectorForShadowRoot;
     private _matchSelector;

package/types/js/matcher.d.ts

@@ -3,8 +3,8 @@ export function matchPseudoElementSelector(astName: string, astType: string, { f
     globalObject?: object | undefined;
     warn?: boolean | undefined;
 }): void;
-export function matchDirectionPseudoClass(ast: object, node: object): boolean;
-export function matchLanguagePseudoClass(ast: object, node: object): boolean;
+export function matchDirectionPseudoClass(ast: object, node: object, dirCache?: WeakMap<any, any>): boolean;
+export function matchLanguagePseudoClass(ast: object, node: object, langCache?: WeakMap<any, any>): boolean;
 export function matchDisabledPseudoClass(astName: string, node: object): boolean;
 export function matchReadOnlyPseudoClass(astName: string, node: object): boolean;
 export function matchAttributeSelector(ast: object, node: object, { check, forgive, globalObject }?: {