@asamuzakjp/dom-selector 0.19.4 → 0.19.6

package/package.json

@@ -21,26 +21,26 @@
   "dependencies": {
     "css-tree": "^2.3.1",
     "is-potential-custom-element-name": "^1.0.1",
-    "xpath": "^0.0.32"
+    "xpath": "^0.0.33"
   },
   "devDependencies": {
-    "@types/css-tree": "^2.3.1",
+    "@types/css-tree": "^2.3.2",
     "benchmark": "^2.1.4",
-    "c8": "^8.0.0",
-    "chai": "^4.3.7",
+    "c8": "^8.0.1",
+    "chai": "^4.3.8",
     "css2xpath": "^0.0.3",
-    "eslint": "^8.44.0",
+    "eslint": "^8.50.0",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-jsdoc": "^46.4.3",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jsdoc": "^46.8.2",
     "eslint-plugin-regexp": "^1.15.0",
-    "eslint-plugin-unicorn": "^47.0.0",
+    "eslint-plugin-unicorn": "^48.0.1",
     "jsdom": "^22.1.0",
-    "linkedom": "^0.14.26",
+    "linkedom": "^0.15.3",
     "mocha": "^10.2.0",
     "nwsapi": "^2.2.7",
-    "sinon": "^15.2.0",
-    "typescript": "^5.1.6"
+    "sinon": "^16.0.0",
+    "typescript": "^5.2.2"
   },
   "scripts": {
     "bench": "node benchmark/benchmark.js",
@@ -49,5 +49,5 @@
     "test": "c8 --reporter=text mocha --exit test/**/*.test.js",
     "tsc": "npx tsc"
   },
-  "version": "0.19.4"
+  "version": "0.19.6"
 }

package/src/js/constant.js

@@ -8,6 +8,7 @@ export const CLASS_SELECTOR = 'ClassSelector';
 export const COMBINATOR = 'Combinator';
 export const ID_SELECTOR = 'IdSelector';
 export const IDENTIFIER = 'Identifier';
+export const NOT_SUPPORTED_ERR = 'NotSupportedError';
 export const NTH = 'Nth';
 export const PSEUDO_CLASS_SELECTOR = 'PseudoClassSelector';
 export const PSEUDO_ELEMENT_SELECTOR = 'PseudoElementSelector';
@@ -15,4 +16,5 @@ export const RAW = 'Raw';
 export const SELECTOR = 'Selector';
 export const SELECTOR_LIST = 'SelectorList';
 export const STRING = 'String';
+export const SYNTAX_ERR = 'SyntaxError';
 export const TYPE_SELECTOR = 'TypeSelector';

package/src/js/matcher.js

@@ -10,7 +10,8 @@ import { generateCSS, parseSelector, walkAST } from './parser.js';
 /* constants */
 import {
   ATTRIBUTE_SELECTOR, CLASS_SELECTOR, COMBINATOR, ID_SELECTOR,
-  PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, TYPE_SELECTOR
+  NOT_SUPPORTED_ERR, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR,
+  SYNTAX_ERR, TYPE_SELECTOR
 } from './constant.js';
 const BIT_ATTRIBUTE_SELECTOR = 16;
 const BIT_CLASS_SELECTOR = 2;
@@ -26,6 +27,10 @@ const DOCUMENT_POSITION_PRECEDING = 2;
 const ELEMENT_NODE = 1;
 const FILTER_SHOW_ELEMENT = 1;
 const TEXT_NODE = 3;
+const TYPE_ALL = 'all';
+const TYPE_FIRST = 'first';
+const TYPE_LINEAL = 'lineal';
+const TYPE_SELF = 'self';
 
 /* regexp */
 const DIR_VALUE = /^(?:auto|ltr|rtl)$/;
@@ -48,7 +53,9 @@ const WHITESPACE = /^[\n\r\f]/;
 export const isContentEditable = (node = {}) => {
   let res;
   if (node.nodeType === ELEMENT_NODE) {
-    if (node.ownerDocument.designMode === 'on') {
+    if (typeof node.isContentEditable === 'boolean') {
+      res = node.isContentEditable;
+    } else if (node.ownerDocument.designMode === 'on') {
       res = true;
     } else if (node.hasAttribute('contenteditable')) {
       const attr = node.getAttribute('contenteditable');
@@ -176,14 +183,14 @@ export const parseASTName = (name, node) => {
       [astPrefix, astNodeName] = name.split('|');
       if (astPrefix && astPrefix !== '*' &&
           node && !isNamespaceDeclared(astPrefix, node)) {
-        throw new DOMException(`invalid selector ${name}`, 'SyntaxError');
+        throw new DOMException(`invalid selector ${name}`, SYNTAX_ERR);
       }
     } else {
       astPrefix = '*';
       astNodeName = name;
     }
   } else {
-    throw new DOMException(`invalid selector ${name}`, 'SyntaxError');
+    throw new DOMException(`invalid selector ${name}`, SYNTAX_ERR);
   }
   return {
     astNodeName,
@@ -249,7 +256,7 @@ export class Matcher {
     this.#selector = selector;
     this.#sort = !!sort;
     this.#warn = !!warn;
-    this._prepare(selector);
+    [this.#list, this.#matrix] = this._prepare(selector);
   }
 
   /**
@@ -259,7 +266,7 @@ export class Matcher {
    * @returns {void}
    */
   _onError(e) {
-    if (e instanceof DOMException && e.name === 'NotSupportedError') {
+    if (e instanceof DOMException && e.name === NOT_SUPPORTED_ERR) {
       if (this.#warn) {
         console.warn(e.message);
       }
@@ -354,8 +361,8 @@ export class Matcher {
   _prepare(selector = this.#selector) {
     const ast = parseSelector(selector);
     const branches = walkAST(ast).values();
-    this.#list = [];
-    this.#matrix = [];
+    const list = [];
+    const matrix = [];
     let i = 0;
     for (const branchItem of branches) {
       const [...items] = branchItem;
@@ -368,7 +375,7 @@ export class Matcher {
             const [nextItem] = items;
             if (nextItem.type === COMBINATOR) {
               const msg = `invalid combinator, ${item.name}${nextItem.name}`;
-              throw new DOMException(msg, 'SyntaxError');
+              throw new DOMException(msg, SYNTAX_ERR);
             }
             branch.push({
               combo: item,
@@ -391,19 +398,19 @@ export class Matcher {
         }
       }
       const branchLen = branch.length;
-      this.#matrix[i] = [];
+      matrix[i] = [];
       for (let j = 0; j < branchLen; j++) {
-        this.#matrix[i][j] = new Set();
+        matrix[i][j] = new Set();
       }
-      this.#list.push({
+      list.push({
         branch,
         skip: false
       });
       i++;
     }
     return [
-      this.#list,
-      this.#matrix
+      list,
+      matrix
     ];
   }
 
@@ -655,11 +662,11 @@ export class Matcher {
                    (!inputType ||
                     /^(?:(?:emai|te|ur)l|search|text)$/.test(inputType))))) {
         throw new DOMException('Unsupported pseudo-class :dir()',
-          'NotSupportedError');
+          NOT_SUPPORTED_ERR);
       // FIXME:
       } else if (nodeDir === 'auto' || (localName === 'bdi' && !nodeDir)) {
         throw new DOMException('Unsupported pseudo-class :dir()',
-          'NotSupportedError');
+          NOT_SUPPORTED_ERR);
       } else if (!nodeDir) {
         let parent = node.parentNode;
         while (parent) {
@@ -863,10 +870,10 @@ export class Matcher {
           case 'nth-col':
           case 'nth-last-col':
             throw new DOMException(`Unsupported pseudo-class :${astName}()`,
-              'NotSupportedError');
+              NOT_SUPPORTED_ERR);
           default:
             throw new DOMException(`Unknown pseudo-class :${astName}()`,
-              'SyntaxError');
+              SYNTAX_ERR);
         }
       }
     } else {
@@ -1172,7 +1179,7 @@ export class Matcher {
             // FIXME:
             if (isMultiple) {
               throw new DOMException(`Unsupported pseudo-class :${astName}`,
-                'NotSupportedError');
+                NOT_SUPPORTED_ERR);
             } else {
               const firstOpt = parentNode.firstElementChild;
               const defaultOpt = new Set();
@@ -1382,7 +1389,7 @@ export class Matcher {
         case 'first-letter':
         case 'first-line': {
           throw new DOMException(`Unsupported pseudo-element ::${astName}`,
-            'NotSupportedError');
+            NOT_SUPPORTED_ERR);
         }
         case 'active':
         case 'autofill':
@@ -1406,11 +1413,11 @@ export class Matcher {
         case 'volume-locked':
         case '-webkit-autofill': {
           throw new DOMException(`Unsupported pseudo-class :${astName}`,
-            'NotSupportedError');
+            NOT_SUPPORTED_ERR);
         }
         default: {
           throw new DOMException(`Unknown pseudo-class :${astName}`,
-            'SyntaxError');
+            SYNTAX_ERR);
         }
       }
     }
@@ -1428,7 +1435,7 @@ export class Matcher {
       flags: astFlags, matcher: astMatcher, name: astName, value: astValue
     } = ast;
     if (typeof astFlags === 'string' && !/^[is]$/i.test(astFlags)) {
-      throw new DOMException('invalid attribute selector', 'SyntaxError');
+      throw new DOMException('invalid attribute selector', SYNTAX_ERR);
     }
     const { attributes } = node;
     let res;
@@ -1650,13 +1657,15 @@ export class Matcher {
 
   /**
    * match pseudo-element selector
-   * NOTE: throws DOMException
    * @param {object} ast - AST
    * @param {object} node - Element node
+   * @throws {DOMException}
    * @returns {void}
    */
   _matchPseudoElementSelector(ast, node) {
     const astName = unescapeSelector(ast.name);
+    let msg;
+    let type;
     switch (astName) {
       case 'after':
       case 'backdrop':
@@ -1672,14 +1681,16 @@ export class Matcher {
       case 'selection':
       case 'slotted':
       case 'target-text': {
-        throw new DOMException(`Unsupported pseudo-element ::${astName}`,
-          'NotSupportedError');
+        msg = `Unsupported pseudo-element ::${astName}`;
+        type = NOT_SUPPORTED_ERR;
+        break;
       }
       default: {
-        throw new DOMException(`Unknown pseudo-element ::${astName}`,
-          'SyntaxError');
+        msg = `Unknown pseudo-element ::${astName}`;
+        type = SYNTAX_ERR;
       }
     }
+    throw new DOMException(msg, type);
   }
 
   /**
@@ -1972,10 +1983,10 @@ export class Matcher {
   /**
    * find nodes
    * @param {object} twig - twig
-   * @param {string} range - target range
+   * @param {string} targetType - target type
    * @returns {object} - result
    */
-  _findNodes(twig, range) {
+  _findNodes(twig, targetType) {
     const { leaves: [leaf, ...items] } = twig;
     const len = items.length;
     const { type: leafType } = leaf;
@@ -1986,12 +1997,12 @@ export class Matcher {
     switch (leafType) {
       case ID_SELECTOR: {
         let node;
-        if (range === 'self') {
+        if (targetType === TYPE_SELF) {
           const bool = this._matchLeaves([leaf], this.#node);
           if (bool) {
             node = this.#node;
           }
-        } else if (range === 'lineal') {
+        } else if (targetType === TYPE_LINEAL) {
           let refNode = this.#node;
           while (refNode) {
             const bool = this._matchLeaves([leaf], refNode);
@@ -2020,12 +2031,12 @@ export class Matcher {
       }
       case CLASS_SELECTOR: {
         const arr = [];
-        if (range === 'self') {
+        if (targetType === TYPE_SELF) {
           if (this.#node.nodeType === ELEMENT_NODE &&
               this.#node.classList.contains(leafName)) {
             arr.push(this.#node);
           }
-        } else if (range === 'lineal') {
+        } else if (targetType === TYPE_LINEAL) {
           let refNode = this.#node;
           while (refNode) {
             if (refNode.nodeType === ELEMENT_NODE) {
@@ -2038,15 +2049,13 @@ export class Matcher {
             }
           }
         } else if (root.nodeType === DOCUMENT_FRAGMENT_NODE) {
-          const walker = document.createTreeWalker(root, FILTER_SHOW_ELEMENT);
-          let nextNode = walker.firstChild();
-          while (nextNode) {
-            if (nextNode.classList.contains(leafName)) {
-              arr.push(nextNode);
+          const iterator = [...root.children].values();
+          for (const node of iterator) {
+            if (node.classList.contains(leafName)) {
+              arr.push(node);
             }
-            const a = [...nextNode.getElementsByClassName(leafName)];
+            const a = [...node.getElementsByClassName(leafName)];
             arr.push(...a);
-            nextNode = walker.nextSibling();
           }
         } else {
           if (root.nodeType === ELEMENT_NODE &&
@@ -2072,64 +2081,62 @@ export class Matcher {
         break;
       }
       case TYPE_SELECTOR: {
-        if (document.contentType !== 'text/html' || /[*|]/.test(leafName)) {
+        const arr = [];
+        if (targetType === TYPE_SELF) {
+          const bool = this.#node.nodeType === ELEMENT_NODE &&
+                       this._matchLeaves([leaf], this.#node);
+          if (bool) {
+            arr.push(this.#node);
+          }
+        } else if (targetType === TYPE_LINEAL) {
+          let refNode = this.#node;
+          while (refNode) {
+            if (refNode.nodeType === ELEMENT_NODE) {
+              const bool = this._matchLeaves([leaf], refNode);
+              if (bool) {
+                arr.push(refNode);
+              }
+              refNode = refNode.parentNode;
+            } else {
+              break;
+            }
+          }
+        } else if (document.contentType !== 'text/html' ||
+                   /[*|]/.test(leafName)) {
           pending = true;
         } else {
           const tagName = leafName.toLowerCase();
-          const arr = [];
-          if (range === 'self') {
-            const bool = this.#node.nodeType === ELEMENT_NODE &&
-                         this._matchLeaves([leaf], this.#node);
-            if (bool) {
-              arr.push(this.#node);
-            }
-          } else if (range === 'lineal') {
-            let refNode = this.#node;
-            while (refNode) {
-              if (refNode.nodeType === ELEMENT_NODE) {
-                const bool = this._matchLeaves([leaf], refNode);
-                if (bool) {
-                  arr.push(refNode);
-                }
-                refNode = refNode.parentNode;
-              } else {
-                break;
-              }
-            }
-          } else if (root.nodeType === DOCUMENT_NODE) {
+          if (root.nodeType === DOCUMENT_NODE) {
             const a = xpath.select(`//*[local-name()='${tagName}']`, root);
             arr.push(...a);
           } else if (root.nodeType === DOCUMENT_FRAGMENT_NODE) {
-            const walker = document.createTreeWalker(root, FILTER_SHOW_ELEMENT);
-            let nextNode = walker.firstChild();
-            while (nextNode) {
-              if (nextNode.localName === tagName) {
-                arr.push(nextNode);
+            const iterator = [...root.children].values();
+            for (const node of iterator) {
+              if (node.localName === tagName) {
+                arr.push(node);
               }
-              const a = [...nextNode.getElementsByTagName(leafName)];
+              const a = [...node.getElementsByTagName(leafName)];
               arr.push(...a);
-              nextNode = walker.nextSibling();
             }
-          } else {
-            if (root.nodeType === ELEMENT_NODE &&
-                root.localName === tagName) {
+          } else if (root.nodeType === ELEMENT_NODE) {
+            if (root.localName === tagName) {
               arr.push(root);
             }
             const a = [...root.getElementsByTagName(leafName)];
             arr.push(...a);
           }
-          if (arr.length) {
-            if (len) {
-              const iterator = arr.values();
-              for (const node of iterator) {
-                const bool = this._matchLeaves(items, node);
-                if (bool) {
-                  nodes.add(node);
-                }
+        }
+        if (arr.length) {
+          if (len) {
+            const iterator = arr.values();
+            for (const node of iterator) {
+              const bool = this._matchLeaves(items, node);
+              if (bool) {
+                nodes.add(node);
               }
-            } else {
-              nodes = new Set(arr);
             }
+          } else {
+            nodes = new Set(arr);
           }
         }
         break;
@@ -2139,12 +2146,12 @@ export class Matcher {
       }
       default: {
         const arr = [];
-        if (range === 'self') {
+        if (targetType === TYPE_SELF) {
           const bool = this._matchLeaves([leaf], this.#node);
           if (bool) {
             arr.push(this.#node);
           }
-        } else if (range === 'lineal') {
+        } else if (targetType === TYPE_LINEAL) {
           let refNode = this.#node;
           while (refNode) {
             const bool = this._matchLeaves([leaf], refNode); ;
@@ -2179,10 +2186,10 @@ export class Matcher {
 
   /**
    * collect nodes
-   * @param {string} range - target range
+   * @param {string} targetType - target type
    * @returns {Array} - matrix
    */
-  _collectNodes(range) {
+  _collectNodes(targetType) {
     const pendingItems = new Set();
     const listIterator = this.#list.values();
     let i = 0;
@@ -2190,11 +2197,11 @@ export class Matcher {
       const { branch } = list;
       const branchLen = branch.length;
       const lastIndex = branchLen - 1;
-      if (range === 'all') {
+      if (targetType === TYPE_ALL) {
         for (let j = 0; j < branchLen; j++) {
           const twig = branch[j];
           const { nodes, pending } =
-            this._findNodes(twig, j === lastIndex ? range : null);
+            this._findNodes(twig, j === lastIndex ? targetType : null);
           if (nodes.size) {
             this.#matrix[i][j] = nodes;
           } else if (pending) {
@@ -2209,7 +2216,7 @@ export class Matcher {
         }
       } else {
         const twig = branch[lastIndex];
-        const { nodes, pending } = this._findNodes(twig, range);
+        const { nodes, pending } = this._findNodes(twig, targetType);
         if (nodes.size) {
           this.#matrix[i][lastIndex] = nodes;
         } else if (pending) {
@@ -2230,18 +2237,7 @@ export class Matcher {
       let nextNode = iterator.nextNode();
       while (nextNode) {
         let bool;
-        if (range === 'self') {
-          bool = nextNode === this.#node;
-        } else if (range === 'lineal') {
-          let refNode = this.#node;
-          while (refNode) {
-            bool = nextNode === refNode;
-            if (bool) {
-              break;
-            }
-            refNode = refNode.parentNode;
-          }
-        } else if (/^(?:all|first)$/.test(range)) {
+        if (targetType === TYPE_ALL || targetType === TYPE_FIRST) {
           if (this.#node.nodeType === ELEMENT_NODE) {
             bool = isDescendant(nextNode, this.#node);
           } else {
@@ -2270,10 +2266,10 @@ export class Matcher {
 
   /**
    * match nodes
-   * @param {string} range - target range
+   * @param {string} targetType - target type
    * @returns {object} - collection of matched nodes
    */
-  _matchNodes(range) {
+  _matchNodes(targetType) {
     const [...branches] = this.#list;
     const l = branches.length;
     let nodes = new Set();
@@ -2286,7 +2282,7 @@ export class Matcher {
         const lastIndex = branchLen - 1;
         if (lastIndex === 0) {
           const matched = this.#matrix[i][0];
-          if (/^(?:all|first)$/.test(range) &&
+          if ((targetType === TYPE_ALL || targetType === TYPE_FIRST) &&
               this.#node.nodeType === ELEMENT_NODE) {
             for (const node of matched) {
               if (isDescendant(node, this.#node)) {
@@ -2296,7 +2292,7 @@ export class Matcher {
           } else {
             nodes = matched;
           }
-        } else if (range === 'all') {
+        } else if (targetType === TYPE_ALL) {
           let { combo } = branch[0];
           let prevNodes = this.#matrix[i][0];
           for (let j = 1; j < branchLen; j++) {
@@ -2339,7 +2335,7 @@ export class Matcher {
               }
               if (matched.size) {
                 if (j === 0) {
-                  if (range === 'first' &&
+                  if (targetType === TYPE_FIRST &&
                       this.#node.nodeType === ELEMENT_NODE) {
                     if (isDescendant(node, this.#node)) {
                       nodes.add(node);
@@ -2368,12 +2364,12 @@ export class Matcher {
 
   /**
    * find matched nodes
-   * @param {string} range - target range
+   * @param {string} targetType - target type
    * @returns {object} - collection of matched nodes
    */
-  _find(range) {
-    this._collectNodes(range);
-    const nodes = this._matchNodes(range);
+  _find(targetType) {
+    this._collectNodes(targetType);
+    const nodes = this._matchNodes(targetType);
     return nodes;
   }
 
@@ -2407,7 +2403,7 @@ export class Matcher {
   matches() {
     let res;
     try {
-      const nodes = this._find('self');
+      const nodes = this._find(TYPE_SELF);
       res = nodes.has(this.#node);
     } catch (e) {
       this._onError(e);
@@ -2422,7 +2418,7 @@ export class Matcher {
   closest() {
     let res;
     try {
-      const nodes = this._find('lineal');
+      const nodes = this._find(TYPE_LINEAL);
       let node = this.#node;
       while (node) {
         if (nodes.has(node)) {
@@ -2444,7 +2440,7 @@ export class Matcher {
   querySelector() {
     let res;
     try {
-      const nodes = this._find('first');
+      const nodes = this._find(TYPE_FIRST);
       nodes.delete(this.#node);
       if (nodes.size) {
         [res] = this._sortNodes(nodes);
@@ -2463,7 +2459,7 @@ export class Matcher {
   querySelectorAll() {
     const res = [];
     try {
-      const nodes = this._find('all');
+      const nodes = this._find(TYPE_ALL);
       nodes.delete(this.#node);
       if (nodes.size > 1 && this.#sort) {
         res.push(...this._sortNodes(nodes));

package/src/js/parser.js

@@ -6,7 +6,7 @@
 import { findAll, parse, toPlainObject, walk } from 'css-tree';
 
 /* constants */
-import { PSEUDO_CLASS_SELECTOR, SELECTOR } from './constant.js';
+import { PSEUDO_CLASS_SELECTOR, SELECTOR, SYNTAX_ERR } from './constant.js';
 const CODE_POINT_UNIT = parseInt('10000', 16);
 const HEX = 16;
 const PAIR = 2;
@@ -54,7 +54,7 @@ export const preprocess = (...args) => {
     selector = Object.prototype.toString.call(selector)
       .slice(TYPE_FROM, TYPE_TO).toLowerCase();
   } else {
-    throw new DOMException(`invalid selector ${selector}`, 'SyntaxError');
+    throw new DOMException(`invalid selector ${selector}`, SYNTAX_ERR);
   }
   return selector;
 };
@@ -68,7 +68,7 @@ export const parseSelector = selector => {
   selector = preprocess(selector);
   // invalid selectors
   if (selector === '' || /^\s*>/.test(selector) || /,\s*$/.test(selector)) {
-    throw new DOMException(`invalid selector ${selector}`, 'SyntaxError');
+    throw new DOMException(`invalid selector ${selector}`, SYNTAX_ERR);
   }
   let res;
   try {
@@ -83,7 +83,7 @@ export const parseSelector = selector => {
     } else if (e.message === '")" is expected' && !selector.endsWith(')')) {
       res = parseSelector(`${selector})`);
     } else {
-      throw new DOMException(e.message, 'SyntaxError');
+      throw new DOMException(e.message, SYNTAX_ERR);
     }
   }
   return res;