@asamuzakjp/dom-selector 8.0.1 → 8.1.1

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/parser.js

@@ -22,6 +22,7 @@ import {
   HEX,
   ID_SELECTOR,
   KEYS_LOGICAL,
+  KEYS_PS_CLASS_SUPPORTED,
   NTH,
   PS_CLASS_SELECTOR,
   PS_ELEMENT_SELECTOR,
@@ -219,9 +220,10 @@ export const parseSelector = sel => {
  * about its contents.
  * @param {object} ast - The AST to traverse.
  * @param {boolean} toObject - True if converts ast to object, false otherwise.
+ * @param {function(object): void} [callback] - Optional callback for each node.
  * @returns {{branches: Array<object>, info: object}} An object containing the selector branches and info.
  */
-export const walkAST = (ast = {}, toObject = false) => {
+export const walkAST = (ast = {}, toObject = false, callback = null) => {
   const branches = new Set();
   const info = {
     hasForgivenPseudoFunc: false,
@@ -230,10 +232,14 @@ export const walkAST = (ast = {}, toObject = false) => {
     hasNotPseudoFunc: false,
     hasNthChildOfSelector: false,
     hasNestedSelector: false,
-    hasStatePseudoClass: false
+    hasStatePseudoClass: false,
+    hasUnsupportedPseudoClass: false
   };
   const opt = {
     enter(node) {
+      if (typeof callback === 'function') {
+        callback(node);
+      }
       switch (node.type) {
         case CLASS_SELECTOR: {
           if (/^-?\d/.test(node.name)) {
@@ -254,24 +260,27 @@ export const walkAST = (ast = {}, toObject = false) => {
           break;
         }
         case PS_CLASS_SELECTOR: {
-          if (KEYS_LOGICAL.has(node.name)) {
+          const name = node.name.toLowerCase();
+          if (KEYS_LOGICAL.has(name)) {
             info.hasNestedSelector = true;
             info.hasLogicalPseudoFunc = true;
-            if (node.name === 'has') {
+            if (name === 'has') {
               info.hasHasPseudoFunc = true;
-            } else if (node.name === 'not') {
+            } else if (name === 'not') {
               info.hasNotPseudoFunc = true;
             } else {
               info.hasForgivenPseudoFunc = true;
             }
-          } else if (KEYS_PS_CLASS_STATE.has(node.name)) {
+          } else if (KEYS_PS_CLASS_STATE.has(name)) {
             info.hasStatePseudoClass = true;
           } else if (
-            KEYS_SHADOW_HOST.has(node.name) &&
+            KEYS_SHADOW_HOST.has(name) &&
             Array.isArray(node.children) &&
             node.children.length
           ) {
             info.hasNestedSelector = true;
+          } else if (!KEYS_PS_CLASS_SUPPORTED.has(name)) {
+            info.hasUnsupportedPseudoClass = true;
           }
           break;
         }

package/src/js/selector.js

@@ -0,0 +1,325 @@
+/**
+ * selector.js
+ */
+
+/* import */
+import * as cssTree from 'css-tree';
+import { generateException } from './utility.js';
+
+/* constants */
+import {
+  COMBINATOR,
+  COMBO,
+  COMPOUND_I,
+  COMPOUND_L_I,
+  DESCEND,
+  HAS_COMPOUND,
+  KEYS_LOGICAL,
+  KEYS_PS_CLASS_SUPPORTED,
+  LOGIC_COMPLEX,
+  LOGIC_COMPOUND,
+  N_TH,
+  PSEUDO_CLASS,
+  PS_CLASS_SELECTOR,
+  PS_ELEMENT_SELECTOR,
+  SELECTOR,
+  SYNTAX_ERR,
+  TARGET_ALL
+} from './constant.js';
+
+/* regexp */
+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_COMPLEX = new RegExp(`${COMPOUND_I}${COMBO}${COMPOUND_I}`, 'i');
+const REG_COMPOUND = new RegExp(`^${COMPOUND_L_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})`
+);
+const REG_LOGIC_COMPOUND = new RegExp(
+  `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPOUND})`
+);
+const REG_LOGIC_HAS_COMPOUND = new RegExp(
+  `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPOUND}|${HAS_COMPOUND})`
+);
+const REG_END_WITH_HAS = new RegExp(`:${HAS_COMPOUND}$`);
+const REG_WO_LOGICAL = new RegExp(`:(?!${PSEUDO_CLASS}|${N_TH})`);
+const REG_COMBO = new RegExp(COMBO);
+const REG_ID = /#(\D[^#.*]+)/g;
+const REG_CLASS = /\.(\D[^#.*]+)/g;
+const REG_TAG = /^([^#.]+)/;
+const REG_INVALID_SYNTAX =
+  /[+~>]\s*[+~>]|^\s*[+~>]|[+~>]\s*$|^\s*,|,\s*,|,\s*$/;
+
+/**
+ * Find a nested :has() pseudo-class.
+ * @param {object} leaf - The AST leaf to check.
+ * @returns {?object} The leaf if it's :has, otherwise null.
+ */
+export const findNestedHas = leaf => leaf.name === 'has';
+
+/**
+ * Find a logical pseudo-class that contains a nested :has().
+ * @param {object} leaf - The AST leaf to check.
+ * @returns {?object} The leaf if it matches, otherwise null.
+ */
+export const findLogicalWithNestedHas = leaf => {
+  if (KEYS_LOGICAL.has(leaf.name) && cssTree.find(leaf, findNestedHas)) {
+    return leaf;
+  }
+  return null;
+};
+
+/**
+ * Validates nesting restrictions within :has() arguments.
+ * @param {Array<object>} astChildren - The AST nodes representing the :has() arguments.
+ * @returns {boolean} False if there's an invalid nesting constraint violation.
+ */
+export const validateHasNesting = astChildren => {
+  const l = astChildren.length;
+  for (let i = 0; i < l; i++) {
+    const item = cssTree.find(astChildren[i], findLogicalWithNestedHas);
+    if (item) {
+      // If nested :has() is wrapped inside :is() or :where(), it is forgiven.
+      if (item.name !== 'is' && item.name !== 'where') {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+/**
+ * Creates a callback function to validate :has() nesting during AST walk.
+ * @param {object} globalObj - The global window object.
+ * @returns {function(object): void} The callback function for walkAST.
+ */
+export const createHasValidator = globalObj => node => {
+  if (
+    node.type === PS_CLASS_SELECTOR &&
+    node.name.toLowerCase() === 'has' &&
+    !validateHasNesting(Array.from(node.children || []))
+  ) {
+    const css = cssTree.generate(node);
+    throw generateException(
+      `Disallowed nested :has() pseudo-class: ${css}`,
+      SYNTAX_ERR,
+      globalObj
+    );
+  }
+};
+
+/**
+ * Check if a combinator node is invalid (leading, trailing, or consecutive).
+ * @param {string} type - The current node type.
+ * @param {string|null} prevType - The previous node type.
+ * @param {boolean} isLast - Whether the current node is the last in the list.
+ * @returns {boolean} True if the combinator is invalid.
+ */
+export const isInvalidCombinator = (type, prevType, isLast) =>
+  type === COMBINATOR &&
+  (prevType === null || prevType === COMBINATOR || isLast);
+
+/**
+ * Checks if a given AST is supported by the DOMSelector engine.
+ * @param {object} ast - The AST to validate.
+ * @returns {boolean} True if the selector is fully supported.
+ */
+export const isSupportedAST = ast => {
+  let isSupported = true;
+  const walk = (
+    node,
+    context = { insideHas: false, insideForgiving: false }
+  ) => {
+    if (!isSupported || !node) {
+      return;
+    }
+    const nextContext = { ...context };
+    if (node.type === PS_ELEMENT_SELECTOR) {
+      isSupported = false;
+      return;
+    } else if (node.type === PS_CLASS_SELECTOR) {
+      let name = node.name;
+      if (name && typeof name === 'string') {
+        name = name.toLowerCase();
+      }
+      if (!KEYS_PS_CLASS_SUPPORTED.has(name)) {
+        isSupported = false;
+        return;
+      }
+      if (name === 'has') {
+        if (context.insideHas && !context.insideForgiving) {
+          isSupported = false;
+          return;
+        }
+        nextContext.insideHas = true;
+      } else if (name === 'is' || name === 'where') {
+        nextContext.insideForgiving = true;
+      }
+    }
+    if (node.children) {
+      let prevType = null;
+      if (node.children.head !== undefined) {
+        let current = node.children.head;
+        while (current) {
+          if (!current.data) {
+            current = current.next;
+            continue;
+          }
+          const childType = current.data.type;
+          if (
+            node.type === SELECTOR &&
+            isInvalidCombinator(childType, prevType, !current.next)
+          ) {
+            if (!(prevType === null && context.insideHas)) {
+              isSupported = false;
+              return;
+            }
+          }
+          prevType = childType;
+          walk(current.data, nextContext);
+          if (!isSupported) {
+            return;
+          }
+          current = current.next;
+        }
+      } else if (Array.isArray(node.children)) {
+        const l = node.children.length;
+        for (let i = 0; i < l; i++) {
+          const child = node.children[i];
+          if (!child) {
+            continue;
+          }
+          const childType = child.type;
+          if (
+            node.type === SELECTOR &&
+            isInvalidCombinator(childType, prevType, i === l - 1)
+          ) {
+            if (!(prevType === null && context.insideHas)) {
+              isSupported = false;
+              return;
+            }
+          }
+          prevType = childType;
+          walk(child, nextContext);
+          if (!isSupported) {
+            return;
+          }
+        }
+      }
+    }
+    if (node.selector) {
+      walk(node.selector, nextContext);
+    }
+  };
+  walk(ast);
+  return isSupported;
+};
+
+/**
+ * Extracts the rightmost subject keys (id, class, tag) from a selector.
+ * @param {string} selector - The CSS selector string to parse.
+ * @param {boolean} caseSensitive - True if the tag should be case-sensitive.
+ * @returns {Array<{id: string|null, className: string|null, tag: string|null}>} The list of extracted keys for each selector group.
+ */
+export const extractSubjectsRegExp = (selector, caseSensitive) => {
+  const subjects = [];
+  const groups = selector.split(',');
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i].trim();
+    if (!group) {
+      continue;
+    }
+    const compounds = group.split(REG_COMBO);
+    const rightmost = compounds[compounds.length - 1];
+    let idKey = null;
+    let classKey = null;
+    let tagKey = null;
+    if (rightmost) {
+      const idMatch = rightmost.match(REG_ID);
+      if (idMatch) {
+        idKey = idMatch[idMatch.length - 1].slice(1);
+      }
+      const classMatch = rightmost.match(REG_CLASS);
+      if (classMatch) {
+        classKey = classMatch[classMatch.length - 1].slice(1);
+      }
+      const tagMatch = rightmost.match(REG_TAG);
+      if (tagMatch) {
+        const tag = tagMatch[1];
+        if (tag !== '*') {
+          tagKey = caseSensitive ? tag : tag.toLowerCase();
+        }
+      }
+    }
+    subjects.push({ id: idKey, className: classKey, tag: tagKey });
+  }
+  return subjects;
+};
+
+/**
+ * Filter a selector for use with nwsapi.
+ * @param {string} selector - The selector string.
+ * @param {string} target - The target type.
+ * @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 ||
+    typeof selector !== 'string' ||
+    /null|undefined/.test(selector)
+  ) {
+    return false;
+  }
+  // Validate syntax.
+  if (REG_INVALID_SYNTAX.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)) {
+    return false;
+  }
+  // Validate attribute selector integrity.
+  if (selector.includes('[')) {
+    const index = selector.lastIndexOf('[');
+    if (selector.indexOf(']', index) === -1) {
+      return false;
+    }
+  }
+  // Target-specific early exits.
+  if (target === TARGET_ALL && !REG_COMPOUND.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);
+    // Handle :has() specifically.
+    if (selector.includes(':has(')) {
+      if (!isComplex || REG_LOGIC_HAS_COMPOUND.test(selector)) {
+        return false;
+      }
+      return REG_END_WITH_HAS.test(selector);
+    }
+    // Handle :is() and :not().
+    if (/(?:is|not)\(/.test(selector)) {
+      if (isComplex) {
+        return !REG_LOGIC_COMPLEX.test(selector);
+      } else {
+        return !REG_LOGIC_COMPOUND.test(selector);
+      }
+    }
+    // Default check for other pseudo-classes against known list.
+    if (REG_WO_LOGICAL.test(selector)) {
+      return false;
+    }
+  }
+  return true;
+};