@asamuzakjp/dom-selector 5.2.2 → 5.3.1

package/src/js/constant.js

@@ -3,28 +3,23 @@
  */
 
 /* string */
-export const AN_PLUS_B = 'AnPlusB';
+export const ATTR_SELECTOR = 'AttributeSelector';
+export const CLASS_SELECTOR = 'ClassSelector';
 export const COMBINATOR = 'Combinator';
 export const EMPTY = '__EMPTY__';
-export const IDENTIFIER = 'Identifier';
+export const IDENT = 'Identifier';
+export const ID_SELECTOR = 'IdSelector';
 export const NOT_SUPPORTED_ERR = 'NotSupportedError';
 export const NTH = 'Nth';
-export const RAW = 'Raw';
+export const PS_CLASS_SELECTOR = 'PseudoClassSelector';
+export const PS_ELEMENT_SELECTOR = 'PseudoElementSelector';
 export const SELECTOR = 'Selector';
-export const SELECTOR_ATTR = 'AttributeSelector';
-export const SELECTOR_CLASS = 'ClassSelector';
-export const SELECTOR_ID = 'IdSelector';
-export const SELECTOR_LIST = 'SelectorList';
-export const SELECTOR_PSEUDO_CLASS = 'PseudoClassSelector';
-export const SELECTOR_PSEUDO_ELEMENT = 'PseudoElementSelector';
-export const SELECTOR_TYPE = 'TypeSelector';
-export const STRING = 'String';
 export const SYNTAX_ERR = 'SyntaxError';
 export const TARGET_ALL = 'all';
 export const TARGET_FIRST = 'first';
 export const TARGET_LINEAL = 'lineal';
 export const TARGET_SELF = 'self';
-export const U_FFFD = '\uFFFD';
+export const TYPE_SELECTOR = 'TypeSelector';
 
 /* numeric */
 export const BIT_01 = 1;
@@ -34,9 +29,9 @@ export const BIT_08 = 8;
 export const BIT_16 = 0x10;
 export const BIT_32 = 0x20;
 export const BIT_FFFF = 0xFFFF;
-export const BIT_HYPHEN = 0x2D;
 export const DUO = 2;
 export const HEX = 16;
+export const HYPHEN = 0x2D;
 export const TYPE_FROM = 8;
 export const TYPE_TO = -1;
 
@@ -61,7 +56,7 @@ export const ALPHA_NUM = '[A-Z\\d]+';
 export const CHILD_IDX = '(?:first|last|only)-(?:child|of-type)';
 export const DIGIT = '(?:0|[1-9]\\d*)';
 export const LANG_PART = `(?:-${ALPHA_NUM})*`;
-export const PSEUDO_CLASSES =
+export const PSEUDO_CLASS =
   `(?:any-)?link|${CHILD_IDX}|checked|empty|indeterminate|root|target|visited`;
 export const ANB =
   `[+-]?(?:${DIGIT}n?|n)|(?:[+-]?${DIGIT})?n\\s*[+-]\\s*${DIGIT}`;
@@ -95,35 +90,6 @@ export const LOGICAL_COMPOUND =
   `${KEY_IS_NOT}\\(\\s*${COMPOUND_A}(?:\\s*,\\s*${COMPOUND_A})*\\s*\\)`;
 
 /* regexp */
-export const REG_ANCHOR = /^a(?:rea)?$/;
-export const REG_COMPLEX = new RegExp(`${COMBO}${COMPOUND_I}`, 'i');
-export const REG_DESCEND = new RegExp(`${DESCEND}${COMPOUND_I}`, 'i');
-export const REG_DIR = /^(?:ltr|rtl)$/;
-export const REG_FILTER_COMPLEX =
-  new RegExp(`:(?!${PSEUDO_CLASSES}|${N_TH}|${LOGICAL_COMPLEX})`);
-export const REG_FILTER_COMPOUND =
-  new RegExp(`:(?!${PSEUDO_CLASSES}|${N_TH}|${LOGICAL_COMPOUND})`);
-export const REG_FILTER_SIMPLE = new RegExp(`:(?!${PSEUDO_CLASSES}|${N_TH})`);
-export const REG_FORM = /^(?:button|fieldset|form|input|select|textarea)$/;
-export const REG_FORM_CTRL =
-  /^(?:button|fieldset|input|optgroup|option|select|textarea)$/;
-export const REG_FORM_VALID = /^(?:button|form|input|select|textarea)$/;
-export const REG_HEX = /^([\da-f]{1,6}\s?)/i;
-export const REG_INTERACT = /^(?:details|dialog)$/;
-export const REG_INVALID_SELECTOR = /^$|^\s*>|,\s*$/;
-export const REG_LANG = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
-export const REG_LANG_QUOTED = /(:lang\(\s*("[A-Za-z\d\-*]*")\s*\))/;
-export const REG_LOGICAL_EMPTY = /(:(is|where)\(\s*\))/;
-export const REG_LOGICAL_PSEUDO = /^(?:has|is|not|where)$/;
-export const REG_SHADOW_HOST = /^host(?:-context)?$/;
-export const REG_SHADOW_MODE = /^(?:close|open)$/;
-export const REG_SHADOW_PSEUDO = /^part|slotted$/;
-export const REG_TAG_NAME = /[A-Z][\\w-]*/i;
-export const REG_TYPE_CHECK = /^(?:checkbox|radio)$/;
-export const REG_TYPE_INPUT =
+export const REG_LOGICAL = /^(?:has|is|not|where)$/;
+export const REG_INPUT_TYPE =
   /^(?:date(?:time-local)?|email|month|number|password|search|tel|text|time|url|week)$/;
-export const REG_TYPE_RANGE =
-  /^(?:date(?:time-local)?|month|number|range|time|week)$/;
-export const REG_TYPE_RESET = /^(?:button|reset)$/;
-export const REG_TYPE_SUBMIT = /^(?:image|submit)$/;
-export const REG_TYPE_TEXT = /^(?:email|number|password|search|tel|text|url)$/;

package/src/js/finder.js

@@ -14,18 +14,26 @@ import {
 
 /* constants */
 import {
-  BIT_01, COMBINATOR, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, ELEMENT_NODE,
-  EMPTY, NOT_SUPPORTED_ERR, REG_ANCHOR, REG_FORM, REG_FORM_CTRL,
-  REG_FORM_VALID, REG_INTERACT, REG_LOGICAL_PSEUDO, REG_SHADOW_HOST,
-  REG_TYPE_CHECK, REG_TYPE_INPUT, REG_TYPE_RANGE, REG_TYPE_RESET,
-  REG_TYPE_SUBMIT, REG_TYPE_TEXT, SELECTOR_ATTR, SELECTOR_CLASS, SELECTOR_ID,
-  SELECTOR_PSEUDO_CLASS, SELECTOR_PSEUDO_ELEMENT, SELECTOR_TYPE, SHOW_ALL,
-  SYNTAX_ERR, TARGET_ALL, TARGET_FIRST, TARGET_LINEAL, TARGET_SELF, TEXT_NODE,
-  WALKER_FILTER
+  ATTR_SELECTOR, BIT_01, CLASS_SELECTOR, COMBINATOR, DOCUMENT_FRAGMENT_NODE,
+  DOCUMENT_NODE, ELEMENT_NODE, EMPTY, ID_SELECTOR, NOT_SUPPORTED_ERR,
+  PS_CLASS_SELECTOR, PS_ELEMENT_SELECTOR, REG_INPUT_TYPE, REG_LOGICAL,
+  SHOW_ALL, SYNTAX_ERR, TARGET_ALL, TARGET_FIRST, TARGET_LINEAL, TARGET_SELF,
+  TEXT_NODE, TYPE_SELECTOR, WALKER_FILTER
 } from './constant.js';
 const DIR_NEXT = 'next';
 const DIR_PREV = 'prev';
 const KEY_TAB = 'Tab';
+const REG_ANCHOR = /^a(?:rea)?$/;
+const REG_FORM_CTRL =
+  /^(?:button|fieldset|input|optgroup|option|select|textarea)$/;
+const REG_FORM_VALID = /^(?:button|form|input|select|textarea)$/;
+const REG_INTERACT = /^(?:details|dialog)$/;
+const REG_SHADOW_HOST = /^host(?:-context)?$/;
+const REG_TYPE_CHECK = /^(?:checkbox|radio)$/;
+const REG_TYPE_RANGE = /^(?:date(?:time-local)?|month|number|range|time|week)$/;
+const REG_TYPE_RESET = /^(?:button|reset)$/;
+const REG_TYPE_SUBMIT = /^(?:image|submit)$/;
+const REG_TYPE_TEXT = /^(?:email|number|password|search|tel|text|url)$/;
 
 /**
  * Finder
@@ -110,6 +118,8 @@ export class Finder {
         } else {
           throw new this.#window.DOMException(e.message, e.name);
         }
+      } else if (e.name in this.#window) {
+        throw new this.#window[e.name](e.message);
       } else {
         throw e;
       }
@@ -222,8 +232,10 @@ export class Finder {
       } catch (e) {
         this.onError(e);
       }
-      const { branches, info: { hasHasPseudoFunc } } = walkAST(cssAst);
-      let invalidate = !!hasHasPseudoFunc;
+      const {
+        branches, info: { hasHasPseudoFunc, hasNthChildOfSelector }
+      } = walkAST(cssAst);
+      let invalidate = !!(hasHasPseudoFunc || hasNthChildOfSelector);
       let descendant = false;
       let i = 0;
       ast = [];
@@ -354,12 +366,9 @@ export class Finder {
       if (this.#astCache.has(selector)) {
         selectorBranches = this.#astCache.get(selector);
       } else {
-        const { branches, info } = walkAST(selector);
+        const { branches } = walkAST(selector);
         selectorBranches = branches;
         this.#astCache.set(selector, selectorBranches);
-        if (info.hasLogicalPseudoFunc) {
-          this.#invalidate = true;
-        }
       }
     }
     if (parentNode) {
@@ -828,7 +837,7 @@ export class Finder {
     } = opt;
     const matched = new Set();
     // :has(), :is(), :not(), :where()
-    if (REG_LOGICAL_PSEUDO.test(astName)) {
+    if (REG_LOGICAL.test(astName)) {
       let astData;
       if (this.#astCache.has(ast)) {
         astData = this.#astCache.get(ast);
@@ -1194,7 +1203,7 @@ export class Finder {
               break;
             }
             case 'input': {
-              if ((!node.type || REG_TYPE_INPUT.test(node.type)) &&
+              if ((!node.type || REG_INPUT_TYPE.test(node.type)) &&
                   (node.readonly || node.hasAttribute('readonly') ||
                    node.disabled || node.hasAttribute('disabled'))) {
                 matched.add(node);
@@ -1219,7 +1228,7 @@ export class Finder {
               break;
             }
             case 'input': {
-              if ((!node.type || REG_TYPE_INPUT.test(node.type)) &&
+              if ((!node.type || REG_INPUT_TYPE.test(node.type)) &&
                   !(node.readonly || node.hasAttribute('readonly') ||
                     node.disabled || node.hasAttribute('disabled'))) {
                 matched.add(node);
@@ -1476,7 +1485,7 @@ export class Finder {
             if (node.hasAttribute('type')) {
               const inputType = node.getAttribute('type');
               if (inputType === 'file' || REG_TYPE_CHECK.test(inputType) ||
-                  REG_TYPE_INPUT.test(inputType)) {
+                  REG_INPUT_TYPE.test(inputType)) {
                 targetNode = node;
               }
             } else {
@@ -1497,7 +1506,7 @@ export class Finder {
             if (node.hasAttribute('type')) {
               const inputType = node.getAttribute('type');
               if (inputType === 'file' || REG_TYPE_CHECK.test(inputType) ||
-                  REG_TYPE_INPUT.test(inputType)) {
+                  REG_INPUT_TYPE.test(inputType)) {
                 targetNode = node;
               }
             } else {
@@ -1767,23 +1776,23 @@ export class Finder {
     }
     if (node.nodeType === ELEMENT_NODE) {
       switch (astType) {
-        case SELECTOR_PSEUDO_ELEMENT: {
+        case PS_ELEMENT_SELECTOR: {
           this.#matcher.matchPseudoElementSelector(astName, opt);
           break;
         }
-        case SELECTOR_ID: {
+        case ID_SELECTOR: {
           if (node.id === astName) {
             matched.add(node);
           }
           break;
         }
-        case SELECTOR_CLASS: {
+        case CLASS_SELECTOR: {
           if (node.classList.contains(astName)) {
             matched.add(node);
           }
           break;
         }
-        case SELECTOR_PSEUDO_CLASS: {
+        case PS_CLASS_SELECTOR: {
           const nodes = this._matchPseudoClassSelector(ast, node, opt);
           return nodes;
         }
@@ -1794,9 +1803,9 @@ export class Finder {
           }
         }
       }
-    } else if (this.#shadow && astType === SELECTOR_PSEUDO_CLASS &&
+    } else if (this.#shadow && astType === PS_CLASS_SELECTOR &&
                node.nodeType === DOCUMENT_FRAGMENT_NODE) {
-      if (astName !== 'has' && REG_LOGICAL_PSEUDO.test(astName)) {
+      if (astName !== 'has' && REG_LOGICAL.test(astName)) {
         const nodes = this._matchPseudoClassSelector(ast, node, opt);
         return nodes;
       } else if (REG_SHADOW_HOST.test(astName)) {
@@ -1831,17 +1840,18 @@ export class Finder {
     }
     if (typeof bool !== 'boolean') {
       let cacheable = true;
-      if (node.nodeType === ELEMENT_NODE && REG_FORM.test(node.localName)) {
+      if (node.nodeType === ELEMENT_NODE &&
+          /^(?:button|fieldset|form|input|select|textarea)$/.test(node.localName)) {
         cacheable = false;
       }
       for (const leaf of leaves) {
         switch (leaf.type) {
-          case SELECTOR_ATTR:
-          case SELECTOR_ID: {
+          case ATTR_SELECTOR:
+          case ID_SELECTOR: {
             cacheable = false;
             break;
           }
-          case SELECTOR_PSEUDO_CLASS: {
+          case PS_CLASS_SELECTOR: {
             if (/^(?:(?:any-)?link|defined|dir)$/.test(leaf.name)) {
               cacheable = false;
             }
@@ -1921,11 +1931,11 @@ export class Finder {
       pending = true;
     } else {
       switch (leafType) {
-        case SELECTOR_PSEUDO_ELEMENT: {
+        case PS_ELEMENT_SELECTOR: {
           this.#matcher.matchPseudoElementSelector(leafName, opt);
           break;
         }
-        case SELECTOR_ID: {
+        case ID_SELECTOR: {
           if (this.#root.nodeType === ELEMENT_NODE) {
             pending = true;
           } else {
@@ -1943,7 +1953,7 @@ export class Finder {
           }
           break;
         }
-        case SELECTOR_CLASS: {
+        case CLASS_SELECTOR: {
           const items = baseNode.getElementsByClassName(leafName);
           nodes = this._matchHTMLCollection(items, {
             compound,
@@ -1951,7 +1961,7 @@ export class Finder {
           });
           break;
         }
-        case SELECTOR_TYPE: {
+        case TYPE_SELECTOR: {
           if (this.#document.contentType === 'text/html' &&
               !/[*|]/.test(leafName)) {
             const items = baseNode.getElementsByTagName(leafName);
@@ -2322,13 +2332,13 @@ export class Finder {
     let filtered = false;
     let pending = false;
     switch (leafType) {
-      case SELECTOR_PSEUDO_ELEMENT: {
+      case PS_ELEMENT_SELECTOR: {
         this.#matcher.matchPseudoElementSelector(leafName, {
           warn: this.#warn
         });
         break;
       }
-      case SELECTOR_ID: {
+      case ID_SELECTOR: {
         if (targetType === TARGET_SELF) {
           [nodes, filtered] = this._matchSelf(leaves);
         } else if (targetType === TARGET_LINEAL) {
@@ -2359,7 +2369,7 @@ export class Finder {
         }
         break;
       }
-      case SELECTOR_CLASS: {
+      case CLASS_SELECTOR: {
         if (targetType === TARGET_SELF) {
           [nodes, filtered] = this._matchSelf(leaves);
         } else if (targetType === TARGET_LINEAL) {
@@ -2383,7 +2393,7 @@ export class Finder {
         }
         break;
       }
-      case SELECTOR_TYPE: {
+      case TYPE_SELECTOR: {
         if (targetType === TARGET_SELF) {
           [nodes, filtered] = this._matchSelf(leaves);
         } else if (targetType === TARGET_LINEAL) {
@@ -2473,19 +2483,19 @@ export class Finder {
               type: lastType
             }]
           } = lastTwig;
-          if (lastType === SELECTOR_PSEUDO_ELEMENT ||
-              lastType === SELECTOR_ID) {
+          if (lastType === PS_ELEMENT_SELECTOR ||
+              lastType === ID_SELECTOR) {
             dir = DIR_PREV;
             twig = lastTwig;
-          } else if (firstType === SELECTOR_PSEUDO_ELEMENT ||
-                     firstType === SELECTOR_ID) {
+          } else if (firstType === PS_ELEMENT_SELECTOR ||
+                     firstType === ID_SELECTOR) {
             dir = DIR_NEXT;
             twig = firstTwig;
           } else if (targetType === TARGET_ALL) {
-            if (firstName === '*' && firstType === SELECTOR_TYPE) {
+            if (firstName === '*' && firstType === TYPE_SELECTOR) {
               dir = DIR_PREV;
               twig = lastTwig;
-            } else if (lastName === '*' && lastType === SELECTOR_TYPE) {
+            } else if (lastName === '*' && lastType === TYPE_SELECTOR) {
               dir = DIR_NEXT;
               twig = firstTwig;
             } else if (branchLen === 2) {
@@ -2501,17 +2511,17 @@ export class Finder {
               dir = DIR_NEXT;
               twig = firstTwig;
             }
-          } else if (lastName === '*' && lastType === SELECTOR_TYPE) {
+          } else if (lastName === '*' && lastType === TYPE_SELECTOR) {
             dir = DIR_NEXT;
             twig = firstTwig;
-          } else if (firstName === '*' && firstType === SELECTOR_TYPE) {
+          } else if (firstName === '*' && firstType === TYPE_SELECTOR) {
             dir = DIR_PREV;
             twig = lastTwig;
           } else {
             let bool;
             for (const { combo, leaves: [leaf] } of branch) {
               const { name: leafName, type: leafType } = leaf;
-              if (leafType === SELECTOR_PSEUDO_CLASS && leafName === 'dir') {
+              if (leafType === PS_CLASS_SELECTOR && leafName === 'dir') {
                 bool = false;
                 break;
               }
@@ -2874,6 +2884,9 @@ export class Finder {
         nodes = new Set(sortNodes(nodes));
       }
     }
+    if (this.#invalidate) {
+      this.#invalidateResults = new WeakMap();
+    }
     return nodes;
   }
 };

package/src/js/matcher.js

@@ -8,8 +8,8 @@ import { getDirectionality, getType, isNamespaceDeclared } from './utility.js';
 
 /* constants */
 import {
-  ALPHA_NUM, ELEMENT_NODE, EMPTY, LANG_PART, NOT_SUPPORTED_ERR, REG_LANG,
-  REG_TAG_NAME, SELECTOR_ATTR, SELECTOR_TYPE, SYNTAX_ERR
+  ALPHA_NUM, ATTR_SELECTOR, ELEMENT_NODE, EMPTY, LANG_PART, NOT_SUPPORTED_ERR,
+  SYNTAX_ERR, TYPE_SELECTOR
 } from './constant.js';
 
 /* Matcher */
@@ -294,7 +294,7 @@ export class Matcher {
       prefix: astPrefix, localName: astLocalName
     } = parseAstName(astName, node);
     if (node.ownerDocument.contentType === 'text/html' &&
-        REG_TAG_NAME.test(localName)) {
+        /[A-Z][\\w-]*/i.test(localName)) {
       astPrefix = astPrefix.toLowerCase();
       astLocalName = astLocalName.toLowerCase();
     }
@@ -393,7 +393,8 @@ export class Matcher {
         }
       }
     } else if (astName) {
-      if (REG_LANG.test(astName)) {
+      const reg = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
+      if (reg.test(astName)) {
         let regExtendedLang;
         if (astName.indexOf('-') > -1) {
           const [langMain, langSub, ...langRest] = astName.split('-');
@@ -462,11 +463,11 @@ export class Matcher {
     }
     let matched;
     switch (ast.type) {
-      case SELECTOR_ATTR: {
+      case ATTR_SELECTOR: {
         matched = this._matchAttributeSelector(ast, node);
         break;
       }
-      case SELECTOR_TYPE: {
+      case TYPE_SELECTOR: {
         matched = this._matchTypeSelector(ast, node, opt ?? {});
         break;
       }

package/src/js/parser.js

@@ -8,12 +8,14 @@ import { getType } from './utility.js';
 
 /* constants */
 import {
-  BIT_01, BIT_02, BIT_04, BIT_08, BIT_16, BIT_32, BIT_FFFF, BIT_HYPHEN,
-  DUO, EMPTY, HEX, NTH, REG_HEX, REG_INVALID_SELECTOR, REG_LANG_QUOTED,
-  REG_LOGICAL_EMPTY, REG_LOGICAL_PSEUDO, REG_SHADOW_PSEUDO, SELECTOR,
-  SELECTOR_ATTR, SELECTOR_CLASS, SELECTOR_ID, SELECTOR_PSEUDO_CLASS,
-  SELECTOR_PSEUDO_ELEMENT, SELECTOR_TYPE, SYNTAX_ERR, U_FFFD
+  ATTR_SELECTOR, BIT_01, BIT_02, BIT_04, BIT_08, BIT_16, BIT_32, BIT_FFFF,
+  CLASS_SELECTOR, DUO, EMPTY, HEX, HYPHEN, ID_SELECTOR, NTH, PS_CLASS_SELECTOR,
+  PS_ELEMENT_SELECTOR, REG_LOGICAL, SELECTOR, SYNTAX_ERR, TYPE_SELECTOR
 } from './constant.js';
+const REG_LANG_QUOTED = /(:lang\(\s*("[A-Za-z\d\-*]*")\s*\))/;
+const REG_LOGICAL_EMPTY = /(:(is|where)\(\s*\))/;
+const REG_SHADOW_PSEUDO = /^part|slotted$/;
+const U_FFFD = '\uFFFD';
 
 /**
  * unescape selector
@@ -29,7 +31,7 @@ export const unescapeSelector = (selector = '') => {
       if (item === '' && i === l - 1) {
         item = U_FFFD;
       } else {
-        const hexExists = REG_HEX.exec(item);
+        const hexExists = /^([\da-f]{1,6}\s?)/i.exec(item);
         if (hexExists) {
           const [, hex] = hexExists;
           let str;
@@ -88,7 +90,7 @@ export const preprocess = (...args) => {
         throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
       }
       const codePoint = postHash.codePointAt(0);
-      if (codePoint === BIT_HYPHEN) {
+      if (codePoint === HYPHEN) {
         if (/^\d$/.test(postHash.substring(1, 2))) {
           throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
         }
@@ -126,7 +128,7 @@ export const preprocess = (...args) => {
 export const parseSelector = selector => {
   selector = preprocess(selector);
   // invalid selectors
-  if (REG_INVALID_SELECTOR.test(selector)) {
+  if (/^$|^\s*>|,\s*$/.test(selector)) {
     throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
   }
   let res;
@@ -191,8 +193,8 @@ export const walkAST = (ast = {}) => {
           branches.add(node.children);
           break;
         }
-        case SELECTOR_PSEUDO_CLASS: {
-          if (REG_LOGICAL_PSEUDO.test(node.name)) {
+        case PS_CLASS_SELECTOR: {
+          if (REG_LOGICAL.test(node.name)) {
             info.set('hasNestedSelector', true);
             info.set('hasLogicalPseudoFunc', true);
             if (node.name === 'has') {
@@ -201,7 +203,7 @@ export const walkAST = (ast = {}) => {
           }
           break;
         }
-        case SELECTOR_PSEUDO_ELEMENT: {
+        case PS_ELEMENT_SELECTOR: {
           if (REG_SHADOW_PSEUDO.test(node.name)) {
             info.set('hasNestedSelector', true);
           }
@@ -210,6 +212,7 @@ export const walkAST = (ast = {}) => {
         case NTH: {
           if (node.selector) {
             info.set('hasNestedSelector', true);
+            info.set('hasNthChildOfSelector', true);
           }
           break;
         }
@@ -221,12 +224,11 @@ export const walkAST = (ast = {}) => {
   if (info.get('hasNestedSelector')) {
     findAll(ast, (node, item, list) => {
       if (list) {
-        if (node.type === SELECTOR_PSEUDO_CLASS &&
-            REG_LOGICAL_PSEUDO.test(node.name)) {
+        if (node.type === PS_CLASS_SELECTOR && REG_LOGICAL.test(node.name)) {
           const itemList = list.filter(i => {
             const { name, type } = i;
             const res =
-              type === SELECTOR_PSEUDO_CLASS && REG_LOGICAL_PSEUDO.test(name);
+              type === PS_CLASS_SELECTOR && REG_LOGICAL.test(name);
             return res;
           });
           for (const { children } of itemList) {
@@ -240,12 +242,12 @@ export const walkAST = (ast = {}) => {
               }
             }
           }
-        } else if (node.type === SELECTOR_PSEUDO_ELEMENT &&
+        } else if (node.type === PS_ELEMENT_SELECTOR &&
                    REG_SHADOW_PSEUDO.test(node.name)) {
           const itemList = list.filter(i => {
             const { name, type } = i;
             const res =
-              type === SELECTOR_PSEUDO_ELEMENT && REG_SHADOW_PSEUDO.test(name);
+              type === PS_ELEMENT_SELECTOR && REG_SHADOW_PSEUDO.test(name);
             return res;
           });
           for (const { children } of itemList) {
@@ -290,12 +292,12 @@ export const sortAST = asts => {
   const arr = [...asts];
   if (arr.length > 1) {
     const order = new Map([
-      [SELECTOR_PSEUDO_ELEMENT, BIT_01],
-      [SELECTOR_ID, BIT_02],
-      [SELECTOR_CLASS, BIT_04],
-      [SELECTOR_TYPE, BIT_08],
-      [SELECTOR_ATTR, BIT_16],
-      [SELECTOR_PSEUDO_CLASS, BIT_32]
+      [PS_ELEMENT_SELECTOR, BIT_01],
+      [ID_SELECTOR, BIT_02],
+      [CLASS_SELECTOR, BIT_04],
+      [TYPE_SELECTOR, BIT_08],
+      [ATTR_SELECTOR, BIT_16],
+      [PS_CLASS_SELECTOR, BIT_32]
     ]);
     arr.sort((a, b) => {
       const { type: typeA } = a;

package/src/js/utility.js

@@ -10,10 +10,15 @@ import isCustomElementName from 'is-potential-custom-element-name';
 /* constants */
 import {
   DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_POSITION_CONTAINS,
-  DOCUMENT_POSITION_PRECEDING, ELEMENT_NODE, REG_DIR, REG_FILTER_COMPLEX,
-  REG_FILTER_COMPOUND, REG_FILTER_SIMPLE, REG_SHADOW_MODE, REG_TYPE_INPUT,
-  TEXT_NODE, TYPE_FROM, TYPE_TO, WALKER_FILTER
+  DOCUMENT_POSITION_PRECEDING, ELEMENT_NODE, N_TH, LOGICAL_COMPLEX,
+  LOGICAL_COMPOUND, PSEUDO_CLASS, REG_INPUT_TYPE, TEXT_NODE, TYPE_FROM,
+  TYPE_TO, WALKER_FILTER
 } from './constant.js';
+const REG_LOGICAL_COMPLEX =
+  new RegExp(`:(?!${PSEUDO_CLASS}|${N_TH}|${LOGICAL_COMPLEX})`);
+const REG_LOGICAL_COMPOUND =
+  new RegExp(`:(?!${PSEUDO_CLASS}|${N_TH}|${LOGICAL_COMPOUND})`);
+const REG_WO_LOGICAL = new RegExp(`:(?!${PSEUDO_CLASS}|${N_TH})`);
 
 /**
  * get type
@@ -171,7 +176,7 @@ export const isInShadowTree = node => {
     while (refNode) {
       const { host, mode, nodeType, parentNode } = refNode;
       if (host && mode && nodeType === DOCUMENT_FRAGMENT_NODE &&
-          REG_SHADOW_MODE.test(mode)) {
+          /^(?:close|open)$/.test(mode)) {
         bool = true;
         break;
       }
@@ -221,7 +226,7 @@ export const getDirectionality = node => {
   if (node.nodeType === ELEMENT_NODE) {
     const { dir: nodeDir, localName, parentNode } = node;
     const { getEmbeddingLevels } = bidiFactory();
-    if (REG_DIR.test(nodeDir)) {
+    if (/^(?:ltr|rtl)$/.test(nodeDir)) {
       res = nodeDir;
     } else if (nodeDir === 'auto') {
       let text;
@@ -253,7 +258,7 @@ export const getDirectionality = node => {
               text = itemTextContent.trim();
             } else if (itemNodeType === ELEMENT_NODE) {
               if (!/^(?:bdi|script|style|textarea)$/.test(itemLocalName) &&
-                  (!itemDir || !REG_DIR.test(itemDir))) {
+                  (!itemDir || !/^(?:ltr|rtl)$/.test(itemDir))) {
                 if (itemLocalName === 'slot') {
                   text = getSlottedTextContent(item);
                 } else {
@@ -394,7 +399,7 @@ export const isFocusVisible = node => {
     const { localName, type } = node;
     switch (localName) {
       case 'input': {
-        if (!type || REG_TYPE_INPUT.test(type)) {
+        if (!type || REG_INPUT_TYPE.test(type)) {
           res = true;
         }
         break;
@@ -596,21 +601,16 @@ export const filterSelector = (selector, opt = {}) => {
   // filter pseudo-classes
   if (selector.includes(':')) {
     const { complex, descend } = opt;
-    let reg;
     if (/:(?:is|not)\(/.test(selector)) {
       if (complex) {
-        reg = REG_FILTER_COMPLEX;
+        return !REG_LOGICAL_COMPLEX.test(selector);
       } else {
-        reg = REG_FILTER_COMPOUND;
+        return !REG_LOGICAL_COMPOUND.test(selector);
       }
-    } else {
-      if (descend) {
-        return false;
-      }
-      reg = REG_FILTER_SIMPLE;
-    }
-    if (reg.test(selector)) {
+    } else if (descend) {
       return false;
+    } else {
+      return !REG_WO_LOGICAL.test(selector);
     }
   }
   return true;