@asamuzakjp/dom-selector 0.2.1 → 0.2.2

package/README.md

@@ -2,8 +2,8 @@
 
 [![build](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml)
 [![CodeQL](https://github.com/asamuzaK/domSelector/actions/workflows/codeql.yml/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/codeql.yml)
+[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/dom-selector)](https://www.npmjs.com/package/@asamuzakjp/dom-selector)
 <!--
-[![npm](https://img.shields.io/npm/v/dom-selector)](https://www.npmjs.com/package/url-sanitizer)
 [![release](https://img.shields.io/github/v/release/asamuzaK/domSelector)](https://github.com/asamuzaK/domSelector/releases)
 -->
 
@@ -14,7 +14,7 @@ Retrieve DOM node from the given CSS selector.
 ## Install
 
 ```console
-npm i dom-selector
+npm i @asamuzakjp/dom-selector
 ```
 
 

package/package.json

@@ -41,5 +41,5 @@
     "test": "c8 --reporter=text mocha --exit test/**/*.test.js",
     "tsc": "npx tsc"
   },
-  "version": "0.2.1"
+  "version": "0.2.2"
 }

package/src/js/constant.js

@@ -4,44 +4,16 @@
 
 module.exports = {
   AN_PLUS_B: 'AnPlusB',
-  AT_RULE: 'Atrule',
-  AT_RULE_PRELUDE: 'AtrulePrelude',
   ATTRIBUTE_SELECTOR: 'AttributeSelector',
-  BLOCK: 'Block',
-  BRACKETS: 'Brackets',
-  CDC: 'CDC',
-  CDO: 'CDO',
   CLASS_SELECTOR: 'ClassSelector',
   COMBINATOR: 'Combinator',
-  COMMENT: 'Comment',
-  DECLARATION: 'Declaration',
-  DECLARATION_LIST: 'DeclarationList',
-  DIMENSION: 'Dimension',
-  FUNCTION: 'Function',
-  HASH: 'Hash',
   ID_SELECTOR: 'IdSelector',
   IDENTIFIER: 'Identifier',
-  MEDIA_FEATURE: 'MediaFeature',
-  MEDIA_QUERY: 'MediaQuery',
-  MEDIA_QUERY_LIST: 'MediaQueryList',
-  NESTING_SELECTOR: 'NestingSelector',
   NTH: 'Nth',
-  NUMBER: 'Number',
-  OPERATOR: 'Operator',
-  PARENTHESES: 'Parentheses',
-  PERCENTAGE: 'Percentage',
   PSEUDO_CLASS_SELECTOR: 'PseudoClassSelector',
-  PSEUDO_ELEMENT_SELECTOR: 'PseudoElementSelector',
-  RATIO: 'Ratio',
   RAW: 'Raw',
-  RULE: 'Rule',
   SELECTOR: 'Selector',
   SELECTOR_LIST: 'SelectorList',
   STRING: 'String',
-  STYLE_SHEET: 'StyleSheet',
-  TYPE_SELECTOR: 'TypeSelector',
-  UNICODE_RANGE: 'UnicodeRange',
-  URL: 'Url',
-  VALUE: 'Value',
-  WHITESPACE: 'WhiteSpace'
+  TYPE_SELECTOR: 'TypeSelector'
 };

package/src/js/matcher.js

@@ -16,7 +16,7 @@ const REG_PSEUDO_NTH = /^nth-(?:last-)?(?:child|of-type)$/;
 
 /**
  * collect nth child
- * @param {object} node - element node
+ * @param {object} node - Element node
  * @param {object} opt - options
  * @param {number} opt.a - a
  * @param {number} opt.b - b
@@ -44,8 +44,10 @@ const collectNthChild = (node = {}, opt = {}) => {
     } else {
       let n = 0;
       let nth = b - 1;
-      while (nth < 0) {
-        nth += (++n * a);
+      if (a > 0) {
+        while (nth < 0) {
+          nth += (++n * a);
+        }
       }
       let i = 0;
       while (i < l && nth < l) {
@@ -63,7 +65,7 @@ const collectNthChild = (node = {}, opt = {}) => {
 
 /**
  * collect nth of type
- * @param {object} node - element node
+ * @param {object} node - Element node
  * @param {object} opt - options
  * @param {number} opt.a - a
  * @param {number} opt.b - b
@@ -102,8 +104,10 @@ const collectNthOfType = (node = {}, opt = {}) => {
     // :nth-of-type()
     } else {
       let nth = b - 1;
-      while (nth < 0) {
-        nth += a;
+      if (a > 0) {
+        while (nth < 0) {
+          nth += a;
+        }
       }
       let i = 0;
       let j = 0;
@@ -126,25 +130,41 @@ const collectNthOfType = (node = {}, opt = {}) => {
 
 /**
  * match type selector
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {?object} - matched node
  */
-const matchTypeSelector = (leaf = {}, node = {}) => {
-  const { name: leafName, type: leafType } = leaf;
-  const { localName, nodeType, prefix } = node;
+const matchTypeSelector = (ast = {}, node = {}) => {
+  const { type: astType } = ast;
+  const { localName, nodeType, ownerDocument, prefix } = node;
   let res;
-  if (leafType === TYPE_SELECTOR && nodeType === ELEMENT_NODE) {
-    // namespaced
-    if (/\|/.test(leafName)) {
-      const [leafPrefix, leafLocalName] = leafName.split('|');
-      if (((leafPrefix === '' && !prefix) || // |E
-           (leafPrefix === '*') || // *|E
-           (leafPrefix === prefix)) && // ns|E
-          (leafLocalName === '*' || leafLocalName === localName)) {
-        res = node;
-      }
-    } else if (leafName === '*' || leafName === localName) {
+  if (astType === TYPE_SELECTOR && nodeType === ELEMENT_NODE) {
+    let astName = ast.name;
+    let astPrefix, astNodeName, nodePrefix, nodeName;
+    if (/\|/.test(astName)) {
+      [astPrefix, astNodeName] = astName.split('|');
+    } else {
+      astPrefix = '';
+      astNodeName = astName;
+    }
+    if (ownerDocument?.contentType === 'text/html') {
+      astNodeName = astNodeName.toLowerCase();
+      astName = astName.toLowerCase();
+    }
+    // just in case that the namespaced content is parsed as text/html
+    if (/:/.test(localName)) {
+      [nodePrefix, nodeName] = localName.split(':');
+    } else {
+      nodePrefix = prefix || '';
+      nodeName = localName;
+    }
+    if (astName === '*' || astName === '*|*' || astName === nodeName ||
+        (astName === '|*' && !nodePrefix) ||
+        (astPrefix === '*' && astNodeName === nodeName) ||
+        (astPrefix === '' && !nodePrefix &&
+         (astNodeName === '*' || astNodeName === nodeName)) ||
+        (astPrefix === nodePrefix &&
+         (astNodeName === '*' || astNodeName === nodeName))) {
       res = node;
     }
   }
@@ -153,16 +173,16 @@ const matchTypeSelector = (leaf = {}, node = {}) => {
 
 /**
  * match class selector
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {?object} - matched node
  */
-const matchClassSelector = (leaf = {}, node = {}) => {
-  const { name: leafName, type: leafType } = leaf;
+const matchClassSelector = (ast = {}, node = {}) => {
+  const { name: astName, type: astType } = ast;
   const { classList, nodeType } = node;
   let res;
-  if (leafType === CLASS_SELECTOR && nodeType === ELEMENT_NODE &&
-      classList.contains(leafName)) {
+  if (astType === CLASS_SELECTOR && nodeType === ELEMENT_NODE &&
+      classList.contains(astName)) {
     res = node;
   }
   return res || null;
@@ -170,16 +190,16 @@ const matchClassSelector = (leaf = {}, node = {}) => {
 
 /**
  * match ID selector
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {?object} - matched node
  */
-const matchIdSelector = (leaf = {}, node = {}) => {
-  const { name: leafName, type: leafType } = leaf;
+const matchIdSelector = (ast = {}, node = {}) => {
+  const { name: astName, type: astType } = ast;
   const { id, nodeType } = node;
   let res;
-  if (leafType === ID_SELECTOR && nodeType === ELEMENT_NODE &&
-      leafName === id) {
+  if (astType === ID_SELECTOR && nodeType === ELEMENT_NODE &&
+      astName === id) {
     res = node;
   }
   return res || null;
@@ -187,32 +207,32 @@ const matchIdSelector = (leaf = {}, node = {}) => {
 
 /**
  * match attribute selector
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {?object} - matched node
  */
-const matchAttributeSelector = (leaf = {}, node = {}) => {
+const matchAttributeSelector = (ast = {}, node = {}) => {
   const {
-    flags: leafFlags, matcher: leafMatcher, name: leafName, type: leafType,
-    value: leafValue
-  } = leaf;
+    flags: astFlags, matcher: astMatcher, name: astName, type: astType,
+    value: astValue
+  } = ast;
   const { attributes, nodeType } = node;
   let res;
-  if (leafType === ATTRIBUTE_SELECTOR && nodeType === ELEMENT_NODE &&
+  if (astType === ATTRIBUTE_SELECTOR && nodeType === ELEMENT_NODE &&
       attributes?.length) {
-    const { name: leafAttrName } = leafName;
-    const caseInsensitive = !(leafFlags && /^s$/i.test(leafFlags));
+    const { name: astAttrName } = astName;
+    const caseInsensitive = !(astFlags && /^s$/i.test(astFlags));
     const attrValues = [];
     const l = attributes.length;
     // namespaced
-    if (/\|/.test(leafAttrName)) {
-      const [leafAttrPrefix, leafAttrLocalName] = leafAttrName.split('|');
+    if (/\|/.test(astAttrName)) {
+      const [astAttrPrefix, astAttrLocalName] = astAttrName.split('|');
       let i = 0;
       while (i < l) {
         const { name: itemName, value: itemValue } = attributes.item(i);
-        switch (leafAttrPrefix) {
+        switch (astAttrPrefix) {
           case '':
-            if (leafAttrLocalName === itemName) {
+            if (astAttrLocalName === itemName) {
               if (caseInsensitive) {
                 attrValues.push(itemValue.toLowerCase());
               } else {
@@ -222,14 +242,14 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
             break;
           case '*':
             if (/:/.test(itemName)) {
-              if (itemName.endsWith(`:${leafAttrLocalName}`)) {
+              if (itemName.endsWith(`:${astAttrLocalName}`)) {
                 if (caseInsensitive) {
                   attrValues.push(itemValue.toLowerCase());
                 } else {
                   attrValues.push(itemValue);
                 }
               }
-            } else if (leafAttrLocalName === itemName) {
+            } else if (astAttrLocalName === itemName) {
               if (caseInsensitive) {
                 attrValues.push(itemValue.toLowerCase());
               } else {
@@ -240,8 +260,8 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
           default:
             if (/:/.test(itemName)) {
               const [itemNamePrefix, itemNameLocalName] = itemName.split(':');
-              if (leafAttrPrefix === itemNamePrefix &&
-                  leafAttrLocalName === itemNameLocalName) {
+              if (astAttrPrefix === itemNamePrefix &&
+                  astAttrLocalName === itemNameLocalName) {
                 if (caseInsensitive) {
                   attrValues.push(itemValue.toLowerCase());
                 } else {
@@ -258,14 +278,14 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
         const { name: itemName, value: itemValue } = attributes.item(i);
         if (/:/.test(itemName)) {
           const [, itemNameLocalName] = itemName.split(':');
-          if (leafAttrName === itemNameLocalName) {
+          if (astAttrName === itemNameLocalName) {
             if (caseInsensitive) {
               attrValues.push(itemValue.toLowerCase());
             } else {
               attrValues.push(itemValue);
             }
           }
-        } else if (leafAttrName === itemName) {
+        } else if (astAttrName === itemName) {
           if (caseInsensitive) {
             attrValues.push(itemValue.toLowerCase());
           } else {
@@ -277,23 +297,23 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
     }
     if (attrValues.length) {
       const {
-        name: leafAttrIdentValue, value: leafAttrStringValue
-      } = leafValue || {};
+        name: astAttrIdentValue, value: astAttrStringValue
+      } = astValue || {};
       let attrValue;
-      if (leafAttrIdentValue) {
+      if (astAttrIdentValue) {
         if (caseInsensitive) {
-          attrValue = leafAttrIdentValue.toLowerCase();
+          attrValue = astAttrIdentValue.toLowerCase();
         } else {
-          attrValue = leafAttrIdentValue;
+          attrValue = astAttrIdentValue;
         }
-      } else if (leafAttrStringValue) {
+      } else if (astAttrStringValue) {
         if (caseInsensitive) {
-          attrValue = leafAttrStringValue.toLowerCase();
+          attrValue = astAttrStringValue.toLowerCase();
         } else {
-          attrValue = leafAttrStringValue;
+          attrValue = astAttrStringValue;
         }
       }
-      switch (leafMatcher) {
+      switch (astMatcher) {
         case null:
           res = node;
           break;
@@ -354,7 +374,7 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
           }
           break;
         default:
-          console.warn(`Unknown matcher ${leafMatcher}`);
+          console.warn(`Unknown matcher ${astMatcher}`);
       }
     }
   }
@@ -363,34 +383,34 @@ const matchAttributeSelector = (leaf = {}, node = {}) => {
 
 /**
  * match An+B
- * @param {string} leafName - leaf name
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {string} nthName - nth pseudo class name
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {Array.<object|undefined>} - collection of matched nodes
  */
-const matchAnPlusB = (leafName, leaf = {}, node = {}) => {
+const matchAnPlusB = (nthName, ast = {}, node = {}) => {
   const res = new Set();
-  if (typeof leafName === 'string') {
-    leafName = leafName.trim();
-    if (REG_PSEUDO_NTH.test(leafName)) {
+  if (typeof nthName === 'string') {
+    nthName = nthName.trim();
+    if (REG_PSEUDO_NTH.test(nthName)) {
       const {
         nth: {
           a,
           b,
           name: identName
         },
-        selector: leafSelector,
-        type: leafType
-      } = leaf;
+        selector: astSelector,
+        type: astType
+      } = ast;
       const { nodeType } = node;
-      if (leafType === NTH && nodeType === ELEMENT_NODE) {
+      if (astType === NTH && nodeType === ELEMENT_NODE) {
         /*
         // FIXME:
         // :nth-child(An+B of S)
-        if (leafSelector) {
+        if (astSelector) {
         }
         */
-        if (!leafSelector) {
+        if (!astSelector) {
           const optMap = new Map();
           if (identName) {
             if (identName === 'even') {
@@ -400,7 +420,7 @@ const matchAnPlusB = (leafName, leaf = {}, node = {}) => {
               optMap.set('a', 2);
               optMap.set('b', 1);
             }
-            if (/last/.test(leafName)) {
+            if (/last/.test(nthName)) {
               optMap.set('reverse', true);
             }
           } else {
@@ -414,20 +434,20 @@ const matchAnPlusB = (leafName, leaf = {}, node = {}) => {
             } else {
               optMap.set('b', 0);
             }
-            if (/last/.test(leafName)) {
+            if (/last/.test(nthName)) {
               optMap.set('reverse', true);
             }
           }
           if (optMap.size > 1) {
             const opt = Object.fromEntries(optMap);
-            if (/^nth-(?:last-)?child$/.test(leafName)) {
+            if (/^nth-(?:last-)?child$/.test(nthName)) {
               const arr = collectNthChild(node, opt);
               if (arr.length) {
                 for (const i of arr) {
                   res.add(i);
                 }
               }
-            } else if (/^nth-(?:last-)?of-type$/.test(leafName)) {
+            } else if (/^nth-(?:last-)?of-type$/.test(nthName)) {
               const arr = collectNthOfType(node, opt);
               if (arr.length) {
                 for (const i of arr) {
@@ -446,29 +466,29 @@ const matchAnPlusB = (leafName, leaf = {}, node = {}) => {
 /**
  * match language pseudo class
  * @see https://datatracker.ietf.org/doc/html/rfc4647#section-3.3.1
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @returns {?object} - matched node
  */
-const matchLanguagePseudoClass = (leaf = {}, node = {}) => {
-  const { name: leafName, type: leafType } = leaf;
+const matchLanguagePseudoClass = (ast = {}, node = {}) => {
+  const { name: astName, type: astType } = ast;
   const { lang, nodeType } = node;
   let res;
-  if (leafType === IDENTIFIER && nodeType === ELEMENT_NODE) {
+  if (astType === IDENTIFIER && nodeType === ELEMENT_NODE) {
     // FIXME:
     /*
-    if (leafName === '') {
+    if (astName === '') {
       if (!lang) {
         res = node;
       }
-    } else if (leafName === '*') {
+    } else if (astName === '*') {
     }
     */
-    if (/[A-Za-z\d-]+/.test(leafName)) {
+    if (/[A-Za-z\d-]+/.test(astName)) {
       const codePart = '(?:-[A-Za-z\\d]+)?';
       let reg;
-      if (/-/.test(leafName)) {
-        const [langMain, langSub, ...langRest] = leafName.split('-');
+      if (/-/.test(astName)) {
+        const [langMain, langSub, ...langRest] = astName.split('-');
         const extendedMain = `${langMain}${codePart}`;
         const extendedSub = `-${langSub}${codePart}`;
         let extendedRest = '';
@@ -479,7 +499,7 @@ const matchLanguagePseudoClass = (leaf = {}, node = {}) => {
         }
         reg = new RegExp(`^${extendedMain}${extendedSub}${extendedRest}$`, 'i');
       } else {
-        reg = new RegExp(`^${leafName}${codePart}$`, 'i');
+        reg = new RegExp(`^${astName}${codePart}$`, 'i');
       }
       if (lang) {
         if (reg.test(lang)) {
@@ -502,55 +522,55 @@ const matchLanguagePseudoClass = (leaf = {}, node = {}) => {
 
 /**
  * match pseudo class selector
- * @param {object} leaf - ast leaf
- * @param {object} node - element node
+ * @param {object} ast - AST
+ * @param {object} node - Element node
  * @param {object} [refPoint] - reference point
  * @returns {Array.<object|undefined>} - collection of matched nodes
  */
 const matchPseudoClassSelector = (
-  leaf = {},
+  ast = {},
   node = {},
   refPoint = {}
 ) => {
-  const { children: leafChildren, name: leafName, type: leafType } = leaf;
+  const { children: astChildren, name: astName, type: astType } = ast;
   const { nodeType, ownerDocument } = node;
   const res = new Set();
-  if (leafType === PSEUDO_CLASS_SELECTOR && nodeType === ELEMENT_NODE) {
-    if (Array.isArray(leafChildren)) {
-      const [leafChildAst] = leafChildren;
+  if (astType === PSEUDO_CLASS_SELECTOR && nodeType === ELEMENT_NODE) {
+    if (Array.isArray(astChildren)) {
+      const [astChildAst] = astChildren;
       // :nth-child(), :nth-last-child(), nth-of-type(), :nth-last-of-type()
-      if (REG_PSEUDO_NTH.test(leafName)) {
-        const arr = matchAnPlusB(leafName, leafChildAst, node);
+      if (REG_PSEUDO_NTH.test(astName)) {
+        const arr = matchAnPlusB(astName, astChildAst, node);
         if (arr.length) {
           for (const i of arr) {
             res.add(i);
           }
         }
       } else {
-        switch (leafName) {
+        switch (astName) {
           case 'dir':
-            if (leafChildAst.name === node.dir) {
+            if (astChildAst.name === node.dir) {
               res.add(node);
             }
             break;
           case 'lang':
-            if (matchLanguagePseudoClass(leafChildAst, node)) {
+            if (matchLanguagePseudoClass(astChildAst, node)) {
               res.add(node);
             }
             break;
           case 'current':
           case 'nth-col':
           case 'nth-last-col':
-            console.warn(`Unsupported pseudo class ${leafName}`);
+            console.warn(`Unsupported pseudo class ${astName}`);
             break;
           default:
-            console.warn(`Unknown pseudo class ${leafName}`);
+            console.warn(`Unknown pseudo class ${astName}`);
         }
       }
     } else {
       const root = ownerDocument.documentElement;
       const docURL = new URL(ownerDocument.URL);
-      switch (leafName) {
+      switch (astName) {
         case 'any-link':
         case 'link':
           // FIXME: what about namespaced href? e.g. xlink:href
@@ -576,6 +596,19 @@ const matchPseudoClassSelector = (
             res.add(node);
           }
           break;
+        case 'target-within':
+          if (docURL.hash) {
+            const hash = docURL.hash.replace(/^#/, '');
+            let current = ownerDocument.getElementById(hash);
+            while (current) {
+              if (current === node) {
+                res.add(node);
+                break;
+              }
+              current = current.parentNode;
+            }
+          }
+          break;
         case 'scope':
           if (refPoint?.nodeType === ELEMENT_NODE) {
             if (node === refPoint) {
@@ -590,6 +623,17 @@ const matchPseudoClassSelector = (
             res.add(node);
           }
           break;
+        case 'focus-within': {
+          let current = ownerDocument.activeElement;
+          while (current) {
+            if (current === node) {
+              res.add(node);
+              break;
+            }
+            current = current.parentNode;
+          }
+          break;
+        }
         case 'open':
           if (node.hasAttribute('open')) {
             res.add(node);
@@ -693,7 +737,6 @@ const matchPseudoClassSelector = (
         case 'default':
         case 'empty':
         case 'focus-visible':
-        case 'focus-within':
         case 'fullscreen':
         case 'future':
         case 'hover':
@@ -712,15 +755,14 @@ const matchPseudoClassSelector = (
         case 'read-write':
         case 'seeking':
         case 'stalled':
-        case 'target-within':
         case 'user-invalid':
         case 'user-valid':
         case 'valid':
         case 'volume-locked':
-          console.warn(`Unsupported pseudo class ${leafName}`);
+          console.warn(`Unsupported pseudo class ${astName}`);
           break;
         default:
-          console.warn(`Unknown pseudo class ${leafName}`);
+          console.warn(`Unknown pseudo class ${astName}`);
       }
     }
   }
@@ -751,7 +793,7 @@ class Matcher {
 
   /**
    * create iterator
-   * @param {object} ast - ast
+   * @param {object} ast - AST
    * @param {object} root - root node
    * @returns {object} - iterator
    */
@@ -769,8 +811,8 @@ class Matcher {
 
   /**
    * parse ast and run
-   * @param {object} ast - ast
-   * @param {object} node - element node
+   * @param {object} ast - AST
+   * @param {object} node - Element node
    * @returns {Array.<object|undefined>} - collection of matched nodes
    */
   _parseAst(ast, node) {
@@ -791,8 +833,8 @@ class Matcher {
 
   /**
    * match adjacent leaves
-   * @param {Array.<object>} leaves - array of ast leaves
-   * @param {object} node - element node
+   * @param {Array.<object>} leaves - array of AST leaves
+   * @param {object} node - Element node
    * @returns {?object} - matched node
    */
   _matchAdjacentLeaves(leaves, node) {
@@ -827,8 +869,8 @@ class Matcher {
 
   /**
    * match combinator
-   * @param {Array.<object>} leaves - array of ast leaves
-   * @param {object} prevNode - element node
+   * @param {Array.<object>} leaves - array of AST leaves
+   * @param {object} prevNode - Element node
    * @returns {Array.<object|undefined>} - matched nodes
    */
   _matchCombinator(leaves, prevNode) {
@@ -853,10 +895,10 @@ class Matcher {
         nextNode = iterator.nextNode();
       }
       while (items.length) {
-        const leaf = items.shift();
+        const ast = items.shift();
         if (nodes.size) {
           nodes.forEach(node => {
-            const arr = this._match(leaf, node);
+            const arr = this._match(ast, node);
             if (!arr.length) {
               nodes.delete(node);
             }
@@ -907,8 +949,8 @@ class Matcher {
 
   /**
    * match argument leaf
-   * @param {object} leaf - argument ast leaf
-   * @param {object} node - element node
+   * @param {object} leaf - AST leaf
+   * @param {object} node - Element node
    * @returns {Array.<object|undefined>} - matched nodes
    */
   _matchArgumentLeaf(leaf, node) {
@@ -929,16 +971,16 @@ class Matcher {
 
   /**
    * match logical pseudo class functions - :is(), :has(), :not(), :where()
-   * @param {object} leaf - ast leaf
-   * @param {object} node - element node
+   * @param {object} branch - AST branch
+   * @param {object} node - Element node
    * @returns {?object} - matched node
    */
-  _matchLogicalPseudoFunc(leaf, node) {
-    const ast = walkAst(leaf);
+  _matchLogicalPseudoFunc(branch, node) {
+    const ast = walkAst(branch);
     let res;
     if (ast.length) {
-      const { name: leafName } = leaf;
-      switch (leafName) {
+      const { name: branchName } = branch;
+      switch (branchName) {
         // :has()
         case 'has': {
           let matched;
@@ -1019,7 +1061,7 @@ class Matcher {
   /**
    * match selector
    * @param {Array.<object>} children - selector children
-   * @param {object} node - element node
+   * @param {object} node - Element node
    * @returns {Array.<object|undefined>} - collection of matched nodes
    */
   _matchSelector(children, node) {
@@ -1120,9 +1162,9 @@ class Matcher {
   }
 
   /**
-   * match ast and node
-   * @param {object} [ast] - ast tree
-   * @param {object} [node] - element node
+   * match AST and node
+   * @param {object} ast - AST
+   * @param {object} node - Element node
    * @returns {Array.<object|undefined>} - collection of matched nodes
    */
   _match(ast = this.#ast, node = this.#node) {

package/src/js/parser.js

@@ -22,19 +22,19 @@ const parseSelector = selector => {
 /**
  * walk AST
  * @param {object} ast - AST
- * @returns {Array.<object|undefined>} - array of selectors
+ * @returns {Array.<object|undefined>} - collection of AST branches
  */
 const walkAst = (ast = {}) => {
   const selectors = new Set();
   const opt = {
-    enter: leaf => {
-      if (leaf.type === SELECTOR) {
-        selectors.add(leaf.children);
+    enter: branch => {
+      if (branch.type === SELECTOR) {
+        selectors.add(branch.children);
       }
     },
-    leave: leaf => {
+    leave: branch => {
       let skip;
-      if (leaf.type === SELECTOR) {
+      if (branch.type === SELECTOR) {
         skip = walkAst.skip;
       }
       return skip;

package/types/js/constant.d.ts

@@ -1,41 +1,13 @@
 export const AN_PLUS_B: string;
-export const AT_RULE: string;
-export const AT_RULE_PRELUDE: string;
 export const ATTRIBUTE_SELECTOR: string;
-export const BLOCK: string;
-export const BRACKETS: string;
-export const CDC: string;
-export const CDO: string;
 export const CLASS_SELECTOR: string;
 export const COMBINATOR: string;
-export const COMMENT: string;
-export const DECLARATION: string;
-export const DECLARATION_LIST: string;
-export const DIMENSION: string;
-export const FUNCTION: string;
-export const HASH: string;
 export const ID_SELECTOR: string;
 export const IDENTIFIER: string;
-export const MEDIA_FEATURE: string;
-export const MEDIA_QUERY: string;
-export const MEDIA_QUERY_LIST: string;
-export const NESTING_SELECTOR: string;
 export const NTH: string;
-export const NUMBER: string;
-export const OPERATOR: string;
-export const PARENTHESES: string;
-export const PERCENTAGE: string;
 export const PSEUDO_CLASS_SELECTOR: string;
-export const PSEUDO_ELEMENT_SELECTOR: string;
-export const RATIO: string;
 export const RAW: string;
-export const RULE: string;
 export const SELECTOR: string;
 export const SELECTOR_LIST: string;
 export const STRING: string;
-export const STYLE_SHEET: string;
 export const TYPE_SELECTOR: string;
-export const UNICODE_RANGE: string;
-export const URL: string;
-export const VALUE: string;
-export const WHITESPACE: string;

package/types/js/matcher.d.ts

@@ -5,7 +5,7 @@ export class Matcher {
     _matchAdjacentLeaves(leaves: Array<object>, node: object): object | null;
     _matchCombinator(leaves: Array<object>, prevNode: object): Array<object | undefined>;
     _matchArgumentLeaf(leaf: object, node: object): Array<object | undefined>;
-    _matchLogicalPseudoFunc(leaf: object, node: object): object | null;
+    _matchLogicalPseudoFunc(branch: object, node: object): object | null;
     _matchSelector(children: Array<object>, node: object): Array<object | undefined>;
     _match(ast?: object, node?: object): Array<object | undefined>;
     matches(): boolean;
@@ -24,10 +24,10 @@ export function collectNthOfType(node?: object, opt?: {
     b: number;
     reverse?: boolean;
 }): Array<object | undefined>;
-export function matchAnPlusB(leafName: string, leaf?: object, node?: object): Array<object | undefined>;
-export function matchAttributeSelector(leaf?: object, node?: object): object | null;
-export function matchClassSelector(leaf?: object, node?: object): object | null;
-export function matchIdSelector(leaf?: object, node?: object): object | null;
-export function matchLanguagePseudoClass(leaf?: object, node?: object): object | null;
-export function matchPseudoClassSelector(leaf?: object, node?: object, refPoint?: object): Array<object | undefined>;
-export function matchTypeSelector(leaf?: object, node?: object): object | null;
+export function matchAnPlusB(nthName: string, ast?: object, node?: object): Array<object | undefined>;
+export function matchAttributeSelector(ast?: object, node?: object): object | null;
+export function matchClassSelector(ast?: object, node?: object): object | null;
+export function matchIdSelector(ast?: object, node?: object): object | null;
+export function matchLanguagePseudoClass(ast?: object, node?: object): object | null;
+export function matchPseudoClassSelector(ast?: object, node?: object, refPoint?: object): Array<object | undefined>;
+export function matchTypeSelector(ast?: object, node?: object): object | null;