@asamuzakjp/dom-selector 0.2.2 → 0.4.1

package/README.md

@@ -23,7 +23,7 @@ npm i @asamuzakjp/dom-selector
 ```javascript
 const {
   matches, closest, querySelector, querySelectorAll
-} = require('dom-selector');
+} = require('@asamuzakjp/dom-selector');
 ```
 
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->

package/package.json

@@ -19,7 +19,7 @@
   "types": "types/index.d.ts",
   "dependencies": {
     "@types/css-tree": "^2.3.1",
-    "@types/node": "^20.1.0",
+    "@types/node": "^20.1.1",
     "css-tree": "^2.3.1"
   },
   "devDependencies": {
@@ -27,8 +27,8 @@
     "chai": "^4.3.7",
     "eslint": "^8.40.0",
     "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-jsdoc": "^43.2.0",
-    "eslint-plugin-regexp": "^1.14.0",
+    "eslint-plugin-jsdoc": "^44.1.0",
+    "eslint-plugin-regexp": "^1.15.0",
     "eslint-plugin-unicorn": "^47.0.0",
     "jsdom": "^22.0.0",
     "mocha": "^10.2.0",
@@ -41,5 +41,5 @@
     "test": "c8 --reporter=text mocha --exit test/**/*.test.js",
     "tsc": "npx tsc"
   },
-  "version": "0.2.2"
+  "version": "0.4.1"
 }

package/src/js/matcher.js

@@ -999,6 +999,11 @@ class Matcher {
               firstItem = items.shift();
               itemLeaves.push(item, firstItem);
             }
+            if (firstItem.type === PSEUDO_CLASS_SELECTOR &&
+                firstItem.name === 'has') {
+              matched = false;
+              break;
+            }
             const arr = this._matchCombinator(itemLeaves, node);
             if (arr.length) {
               matched = true;
@@ -1019,6 +1024,12 @@ class Matcher {
           let matched;
           for (const items of ast) {
             const item = items.shift();
+            // NOTE: according to MDN, :not() can not contain :not()
+            // but spec says nothing about that?
+            if (item.type === PSEUDO_CLASS_SELECTOR && item.name === 'not') {
+              matched = true;
+              break;
+            }
             const arr = this._matchArgumentLeaf(item, node);
             if (arr.length) {
               matched = true;
@@ -1081,81 +1092,94 @@ class Matcher {
       }
       const iterator = this._createIterator(iteratorLeaf, node);
       let nextNode = iterator.nextNode();
-      while (nextNode) {
-        const [...items] = children;
-        if (items.length) {
-          if (items.length === 1) {
-            const item = items.shift();
-            const { name: itemName, type: itemType } = item;
-            if (itemType === PSEUDO_CLASS_SELECTOR &&
-                REG_PSEUDO_FUNC.test(itemName)) {
-              nextNode = this._matchLogicalPseudoFunc(item, nextNode);
-              if (nextNode) {
-                res.add(nextNode);
-                nextNode = null;
-              }
-            } else {
-              const arr = this._match(item, nextNode);
-              if (arr.length) {
-                for (const i of arr) {
-                  res.add(i);
-                }
-              }
-            }
-          } else {
-            do {
+      if (nextNode) {
+        while (nextNode) {
+          const [...items] = children;
+          if (items.length) {
+            if (items.length === 1) {
               const item = items.shift();
               const { name: itemName, type: itemType } = item;
               if (itemType === PSEUDO_CLASS_SELECTOR &&
                   REG_PSEUDO_FUNC.test(itemName)) {
                 nextNode = this._matchLogicalPseudoFunc(item, nextNode);
-              } else if (itemType === COMBINATOR) {
-                const leaves = [];
-                leaves.push(item);
-                while (items.length) {
-                  const [nextItem] = items;
-                  if (nextItem.type === COMBINATOR ||
-                      (nextItem.type === PSEUDO_CLASS_SELECTOR &&
-                       REG_PSEUDO_NTH.test(nextItem.name)) ||
-                      (nextItem.type === PSEUDO_CLASS_SELECTOR &&
-                       REG_PSEUDO_FUNC.test(nextItem.name))) {
-                    break;
-                  } else {
-                    leaves.push(items.shift());
+                if (nextNode) {
+                  res.add(nextNode);
+                  nextNode = null;
+                }
+              } else {
+                const arr = this._match(item, nextNode);
+                if (arr.length) {
+                  for (const i of arr) {
+                    res.add(i);
                   }
                 }
-                const arr = this._matchCombinator(leaves, nextNode);
-                if (!arr.length || arr.length === 1) {
-                  [nextNode] = arr;
-                } else {
-                  if (items.length) {
-                    for (const i of arr) {
-                      const a = this._matchSelector(items, i);
-                      if (a.length) {
-                        for (const j of a) {
-                          res.add(j);
-                        }
-                      }
+              }
+            } else {
+              do {
+                const item = items.shift();
+                const { name: itemName, type: itemType } = item;
+                if (itemType === PSEUDO_CLASS_SELECTOR &&
+                    REG_PSEUDO_FUNC.test(itemName)) {
+                  nextNode = this._matchLogicalPseudoFunc(item, nextNode);
+                } else if (itemType === COMBINATOR) {
+                  const leaves = [];
+                  leaves.push(item);
+                  while (items.length) {
+                    const [nextItem] = items;
+                    if (nextItem.type === COMBINATOR ||
+                        (nextItem.type === PSEUDO_CLASS_SELECTOR &&
+                         REG_PSEUDO_NTH.test(nextItem.name)) ||
+                        (nextItem.type === PSEUDO_CLASS_SELECTOR &&
+                         REG_PSEUDO_FUNC.test(nextItem.name))) {
+                      break;
+                    } else {
+                      leaves.push(items.shift());
                     }
+                  }
+                  const arr = this._matchCombinator(leaves, nextNode);
+                  if (!arr.length || arr.length === 1) {
+                    [nextNode] = arr;
                   } else {
-                    for (const i of arr) {
-                      res.add(i);
+                    if (items.length) {
+                      for (const i of arr) {
+                        const a = this._matchSelector(items, i);
+                        if (a.length) {
+                          for (const j of a) {
+                            res.add(j);
+                          }
+                        }
+                      }
+                    } else {
+                      for (const i of arr) {
+                        res.add(i);
+                      }
                     }
+                    nextNode = null;
                   }
-                  nextNode = null;
+                } else {
+                  [nextNode] = this._match(item, nextNode);
                 }
-              } else {
-                [nextNode] = this._match(item, nextNode);
+              } while (items.length && nextNode);
+              if (nextNode) {
+                res.add(nextNode);
               }
-            } while (items.length && nextNode);
-            if (nextNode) {
-              res.add(nextNode);
             }
+          } else if (nextNode) {
+            res.add(nextNode);
           }
-        } else if (nextNode) {
-          res.add(nextNode);
+          nextNode = iterator.nextNode();
+        }
+      } else if (firstChild.type === PSEUDO_CLASS_SELECTOR &&
+                 REG_PSEUDO_FUNC.test(firstChild.name) &&
+                 node.nodeType === ELEMENT_NODE) {
+        nextNode = node;
+        while (nextNode) {
+          nextNode = this._matchLogicalPseudoFunc(firstChild, nextNode);
+          if (nextNode) {
+            res.add(nextNode);
+          }
+          nextNode = nextNode.nextElementSibling;
         }
-        nextNode = iterator.nextNode();
       }
     }
     return [...res];
@@ -1263,7 +1287,12 @@ class Matcher {
     const arr = this._match(this.#ast, this.#node);
     let res;
     if (arr.length) {
-      [res] = arr;
+      const [i, j] = arr;
+      if (i !== this.#node) {
+        res = i;
+      } else if (j) {
+        res = j;
+      }
     }
     return res || null;
   }
@@ -1278,7 +1307,9 @@ class Matcher {
     const res = new Set();
     if (arr.length) {
       for (const i of arr) {
-        res.add(i);
+        if (i !== this.#node) {
+          res.add(i);
+        }
       }
     }
     return [...res];