@asamuzakjp/dom-selector 2.0.3-a.2 → 2.0.3-a.4

package/src/js/finder.js

@@ -64,11 +64,11 @@ export class Finder {
   /* private fields */
   #ast;
   #cache;
-  #clones;
   #document;
   #finder;
   #node;
   #nodes;
+  #results;
   #root;
   #selector;
   #shadow;
@@ -114,7 +114,7 @@ export class Finder {
    * @param {object} node - Document, DocumentFragment, Element node
    * @param {string} selector - CSS selector
    * @param {object} opt - options
-   * @returns {void}
+   * @returns {object} - node
    */
   _setup(node, selector, opt = {}) {
     const { warn } = opt;
@@ -124,7 +124,8 @@ export class Finder {
     this.#shadow = isInShadowTree(node);
     this.#selector = selector;
     [this.#ast, this.#nodes] = this._correspond(selector);
-    this.#clones = new WeakMap();
+    this.#results = new WeakMap();
+    return this.#node;
   }
 
   /**
@@ -1686,15 +1687,61 @@ export class Finder {
    */
   _matchLeaves(leaves, node, opt) {
     let bool;
-    for (const leaf of leaves) {
-      bool = this._matchSelector(leaf, node, opt).has(node);
-      if (!bool) {
-        break;
+    if (this.#results.has(leaves)) {
+      const result = this.#results.get(leaves);
+      if (result.has(node)) {
+        bool = result.get(node);
+      } else {
+        for (const leaf of leaves) {
+          bool = this._matchSelector(leaf, node, opt).has(node);
+          if (!bool) {
+            break;
+          }
+        }
+        result.set(node, bool);
+        this.#results.set(leaves, result);
       }
+    } else {
+      for (const leaf of leaves) {
+        bool = this._matchSelector(leaf, node, opt).has(node);
+        if (!bool) {
+          break;
+        }
+      }
+      const result = new WeakMap();
+      result.set(node, bool);
+      this.#results.set(leaves, result);
     }
     return !!bool;
   }
 
+  /**
+   * match HTML collection
+   * @param {object} items - HTML collection
+   * @param {object} opt - options
+   * @returns {Set.<object>} - matched nodes
+   */
+  _matchHTMLCollection(items, opt = {}) {
+    const { compound, filterLeaves } = opt;
+    let nodes = new Set();
+    const l = items.length;
+    if (l) {
+      if (compound) {
+        for (let i = 0; i < l; i++) {
+          const item = items[i];
+          const bool = this._matchLeaves(filterLeaves, item, opt);
+          if (bool) {
+            nodes.add(item);
+          }
+        }
+      } else {
+        const arr = [].slice.call(items);
+        nodes = new Set(arr);
+      }
+    }
+    return nodes;
+  }
+
   /**
    * find descendant nodes
    * @private
@@ -1734,42 +1781,20 @@ export class Finder {
         }
         case SELECTOR_CLASS: {
           const items = baseNode.getElementsByClassName(leafName);
-          const l = items.length;
-          if (l) {
-            if (compound) {
-              for (let i = 0; i < l; i++) {
-                const item = items[i];
-                const bool = this._matchLeaves(filterLeaves, item, opt);
-                if (bool) {
-                  nodes.add(item);
-                }
-              }
-            } else {
-              const arr = [].slice.call(items);
-              nodes = new Set(arr);
-            }
-          }
+          nodes = this._matchHTMLCollection(items, {
+            compound,
+            filterLeaves
+          });
           break;
         }
         case SELECTOR_TYPE: {
           if (this.#document.contentType === 'text/html' &&
               !/[*|]/.test(leafName)) {
             const items = baseNode.getElementsByTagName(leafName);
-            const l = items.length;
-            if (l) {
-              if (compound) {
-                for (let i = 0; i < l; i++) {
-                  const item = items[i];
-                  const bool = this._matchLeaves(filterLeaves, item, opt);
-                  if (bool) {
-                    nodes.add(item);
-                  }
-                }
-              } else {
-                const arr = [].slice.call(items);
-                nodes = new Set(arr);
-              }
-            }
+            nodes = this._matchHTMLCollection(items, {
+              compound,
+              filterLeaves
+            });
           } else {
             pending = true;
           }
@@ -1969,6 +1994,126 @@ export class Finder {
     return matchedNode ?? null;
   }
 
+  /**
+   * match self
+   * @private
+   * @param {Array} leaves - AST leaves
+   * @returns {Array} - [nodes, filtered]
+   */
+  _matchSelf(leaves) {
+    const nodes = [];
+    let filtered = false;
+    const bool = this._matchLeaves(leaves, this.#node);
+    if (bool) {
+      nodes.push(this.#node);
+      filtered = true;
+    }
+    return [nodes, filtered];
+  }
+
+  /**
+   * find lineal
+   * @private
+   * @param {Array} leaf - AST leaf
+   * @param {object} opt - options
+   * @returns {Array} - [nodes, filtered]
+   */
+  _findLineal(leaf, opt = {}) {
+    const { complex, compound } = opt;
+    const nodes = [];
+    let filtered = false;
+    let bool = this._matchLeaves([leaf], this.#node);
+    if (bool && !complex && !compound) {
+      nodes.push(this.#node);
+      filtered = true;
+    } else {
+      if (bool) {
+        nodes.push(this.#node);
+        if (!compound) {
+          filtered = true;
+        }
+      }
+      let refNode = this.#node.parentNode;
+      while (refNode) {
+        bool = this._matchLeaves([leaf], refNode);
+        if (bool) {
+          nodes.push(refNode);
+          if (!compound) {
+            filtered = true;
+          }
+        }
+        if (refNode.parentNode) {
+          refNode = refNode.parentNode;
+        } else {
+          break;
+        }
+      }
+    }
+    return [nodes, filtered];
+  }
+
+  /**
+   * find first
+   * @private
+   * @param {Array} leaves - AST leaves
+   * @returns {Array} - [nodes, filtered]
+   */
+  _findFirst(leaves) {
+    const nodes = [];
+    let filtered = false;
+    const node = this._findNode(leaves, {
+      node: this.#node
+    });
+    if (node) {
+      nodes.push(node);
+      filtered = true;
+    }
+    return [nodes, filtered];
+  }
+
+  /**
+   * find from HTML collection
+   * @private
+   * @param {object} items - HTML collection
+   * @param {Array} nodes - nodes
+   * @param {object} opt - options
+   * @param {boolean} [opt.compound] - compound selector
+   * @param {Array} [opt.filterLeaves] - filter leaves
+   * @returns {Array} - [nodes, filtered]
+   */
+  _findFromHTMLCollection(items, nodes = [], opt = {}) {
+    const { compound, filterLeaves } = opt;
+    let filtered = false;
+    const l = items.length;
+    if (l) {
+      if (this.#node.nodeType === ELEMENT_NODE) {
+        for (let i = 0; i < l; i++) {
+          const node = items[i];
+          if (node === this.#node || isInclusive(node, this.#node)) {
+            if (compound) {
+              const bool = this._matchLeaves(filterLeaves, node, {
+                warn: this.#warn
+              });
+              if (bool) {
+                nodes.push(node);
+                filtered = true;
+              }
+            } else {
+              nodes.push(node);
+              filtered = true;
+            }
+          }
+        }
+      } else {
+        nodes = [].slice.call(items);
+        if (!compound) {
+          filtered = true;
+        }
+      }
+    }
+    return [nodes, filtered];
+  }
+
   /**
    * find entry nodes
    * @private
@@ -1986,167 +2131,105 @@ export class Finder {
     let nodes = [];
     let filtered = false;
     let pending = false;
-    if (targetType === TARGET_SELF) {
-      const bool = this._matchLeaves(leaves, this.#node, {
-        warn: this.#warn
-      });
-      if (bool) {
-        nodes.push(this.#node);
-        filtered = true;
-      }
-    } else if (targetType === TARGET_LINEAL) {
-      let refNode = this.#node;
-      while (refNode) {
-        const bool = this._matchLeaves(leaves, refNode, {
+    switch (leafType) {
+      case SELECTOR_PSEUDO_ELEMENT: {
+        matchPseudoElementSelector(leafName, {
           warn: this.#warn
         });
-        if (bool) {
-          nodes.push(refNode);
-          filtered = true;
-          if (!complex) {
-            break;
-          }
-        }
-        refNode = refNode.parentNode;
+        break;
       }
-    } else {
-      switch (leafType) {
-        case SELECTOR_PSEUDO_ELEMENT: {
-          matchPseudoElementSelector(leafName, {
-            warn: this.#warn
+      case SELECTOR_ID: {
+        if (targetType === TARGET_SELF) {
+          [nodes, filtered] = this._matchSelf(leaves);
+        } else if (targetType === TARGET_LINEAL) {
+          [nodes, filtered] = this._findLineal(leaf, {
+            complex,
+            compound
           });
-          break;
-        }
-        case SELECTOR_ID: {
-          if (targetType === TARGET_FIRST &&
-              this.#root.nodeType !== ELEMENT_NODE) {
-            const node = this.#root.getElementById(leafName);
-            if (node) {
-              if (compound) {
-                const bool = this._matchLeaves(filterLeaves, node, {
-                  warn: this.#warn
-                });
-                if (bool) {
-                  nodes.push(node);
-                }
-              } else {
+        } else if (targetType === TARGET_FIRST &&
+                   this.#root.nodeType !== ELEMENT_NODE) {
+          const node = this.#root.getElementById(leafName);
+          if (node) {
+            if (compound) {
+              const bool = this._matchLeaves(filterLeaves, node, {
+                warn: this.#warn
+              });
+              if (bool) {
                 nodes.push(node);
+                filtered = true;
               }
-              filtered = true;
-            }
-          } else {
-            pending = true;
-          }
-          break;
-        }
-        case SELECTOR_CLASS: {
-          if (targetType === TARGET_FIRST) {
-            const node = this._findNode(leaves, {
-              node: this.#node
-            });
-            if (node) {
+            } else {
               nodes.push(node);
               filtered = true;
             }
-          } else if (this.#root.nodeType === DOCUMENT_NODE) {
-            const items = this.#root.getElementsByClassName(leafName);
-            const l = items.length;
-            if (l) {
-              if (this.#node.nodeType === ELEMENT_NODE) {
-                for (let i = 0; i < l; i++) {
-                  const node = items[i];
-                  if (node === this.#node || isInclusive(node, this.#node)) {
-                    if (compound) {
-                      const bool = this._matchLeaves(filterLeaves, node, {
-                        warn: this.#warn
-                      });
-                      if (bool) {
-                        nodes.push(node);
-                        filtered = true;
-                      }
-                    } else {
-                      nodes.push(node);
-                      filtered = true;
-                    }
-                  }
-                }
-              } else {
-                nodes = [].slice.call(items);
-                if (!compound) {
-                  filtered = true;
-                }
-              }
-            }
-          } else {
-            pending = true;
           }
-          break;
+        } else {
+          pending = true;
         }
-        case SELECTOR_TYPE: {
-          if (targetType === TARGET_FIRST) {
-            const node = this._findNode(leaves, {
-              node: this.#node
-            });
-            if (node) {
-              nodes.push(node);
-              filtered = true;
-            }
-          } else if (this.#document.contentType === 'text/html' &&
-                     this.#root.nodeType === DOCUMENT_NODE &&
-                     !/[*|]/.test(leafName)) {
-            const items = this.#root.getElementsByTagName(leafName);
-            const l = items.length;
-            if (l) {
-              if (this.#node.nodeType === ELEMENT_NODE) {
-                for (let i = 0; i < l; i++) {
-                  const node = items[i];
-                  if (node === this.#node || isInclusive(node, this.#node)) {
-                    if (compound) {
-                      const bool = this._matchLeaves(filterLeaves, node, {
-                        warn: this.#warn
-                      });
-                      if (bool) {
-                        nodes.push(node);
-                        filtered = true;
-                      }
-                    } else {
-                      nodes.push(node);
-                      filtered = true;
-                    }
-                  }
-                }
-              } else {
-                nodes = [].slice.call(items);
-                if (!compound) {
-                  filtered = true;
-                }
-              }
-            }
-          } else {
-            pending = true;
-          }
-          break;
+        break;
+      }
+      case SELECTOR_CLASS: {
+        if (targetType === TARGET_SELF) {
+          [nodes, filtered] = this._matchSelf(leaves);
+        } else if (targetType === TARGET_LINEAL) {
+          [nodes, filtered] = this._findLineal(leaf, {
+            complex,
+            compound
+          });
+        } else if (targetType === TARGET_FIRST) {
+          [nodes, filtered] = this._findFirst(leaves);
+        } else if (this.#root.nodeType === DOCUMENT_NODE) {
+          const items = this.#root.getElementsByClassName(leafName);
+          [nodes, filtered] = this._findFromHTMLCollection(items, nodes, {
+            compound,
+            filterLeaves
+          });
+        } else {
+          pending = true;
         }
-        default: {
-          if (REG_SHADOW_HOST.test(leafName)) {
-            if (this.#shadow &&
-                this.#node.nodeType === DOCUMENT_FRAGMENT_NODE) {
-              const node = this._matchShadowHostPseudoClass(leaf, this.#node);
-              if (node) {
-                nodes.push(node);
-              }
-            }
-          } else if (targetType === TARGET_FIRST) {
-            const node = this._findNode(leaves, {
-              node: this.#node
-            });
+        break;
+      }
+      case SELECTOR_TYPE: {
+        if (targetType === TARGET_SELF) {
+          [nodes, filtered] = this._matchSelf(leaves);
+        } else if (targetType === TARGET_LINEAL) {
+          [nodes, filtered] = this._findLineal(leaf, {
+            complex,
+            compound
+          });
+        } else if (this.#document.contentType === 'text/html' &&
+                   this.#root.nodeType === DOCUMENT_NODE &&
+                   !/[*|]/.test(leafName)) {
+          const items = this.#root.getElementsByTagName(leafName);
+          [nodes, filtered] = this._findFromHTMLCollection(items, nodes, {
+            compound,
+            filterLeaves
+          });
+        } else {
+          pending = true;
+        }
+        break;
+      }
+      default: {
+        if (targetType !== TARGET_LINEAL && REG_SHADOW_HOST.test(leafName)) {
+          if (this.#shadow &&
+              this.#node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+            const node = this._matchShadowHostPseudoClass(leaf, this.#node);
             if (node) {
               nodes.push(node);
-              filtered = true;
             }
-          } else {
-            pending = true;
           }
+        } else if (targetType === TARGET_SELF) {
+          [nodes, filtered] = this._matchSelf(leaves);
+        } else if (targetType === TARGET_LINEAL) {
+          [nodes, filtered] = this._findLineal(leaf, {
+            complex,
+            compound
+          });
+        } else if (targetType === TARGET_FIRST) {
+          [nodes, filtered] = this._findFirst(leaves);
+        } else {
+          pending = true;
         }
       }
     }
@@ -2613,15 +2696,21 @@ export class Finder {
    * @returns {Set.<object>} - collection of matched nodes
    */
   _find(targetType, node, selector, opt) {
-    this._setup(node, selector, opt);
-    if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
-      this.#tree = this.#document.createTreeWalker(this.#root, WALKER_FILTER);
-      this.#finder = this.#document.createTreeWalker(this.#node, WALKER_FILTER);
-      this.#sort = false;
-    // TARGET_SELF, TARGET_LINEAL
-    } else if (node.nodeType !== ELEMENT_NODE) {
-      const msg = `Unexpected node ${node.nodeName}`;
-      throw new TypeError(msg);
+    node = this._setup(node, selector, opt);
+    switch (targetType) {
+      case TARGET_ALL:
+      case TARGET_FIRST: {
+        this.#tree = this.#document.createTreeWalker(this.#root, WALKER_FILTER);
+        this.#finder = this.#document.createTreeWalker(node, WALKER_FILTER);
+        this.#sort = false;
+        break;
+      }
+      default: {
+        if (node.nodeType !== ELEMENT_NODE) {
+          const msg = `Unexpected node ${node.nodeName}`;
+          throw new TypeError(msg);
+        }
+      }
     }
     this._collectNodes(targetType);
     const nodes = this._matchNodes(targetType);
@@ -2665,7 +2754,11 @@ export class Finder {
           res = refNode;
           break;
         }
-        refNode = refNode.parentNode;
+        if (refNode.parentNode) {
+          refNode = refNode.parentNode;
+        } else {
+          break;
+        }
       }
     } catch (e) {
       this._onError(e);

package/src/js/matcher.js

@@ -288,6 +288,7 @@ export const _matchTypeSelector = (ast, node, opt = {}) => {
     nodeLocalName = localName;
   }
   let res;
+  const namespaceDeclared = isNamespaceDeclared(astPrefix, node);
   if (astPrefix === '' && nodePrefix === '') {
     if (namespaceURI === null &&
         (astLocalName === '*' || astLocalName === nodeLocalName)) {
@@ -298,7 +299,6 @@ export const _matchTypeSelector = (ast, node, opt = {}) => {
       res = node;
     }
   } else if (astPrefix && nodePrefix) {
-    const namespaceDeclared = isNamespaceDeclared(nodePrefix, node);
     if (astPrefix === nodePrefix) {
       if (namespaceDeclared) {
         if (astLocalName === '*' || astLocalName === nodeLocalName) {
@@ -309,6 +309,9 @@ export const _matchTypeSelector = (ast, node, opt = {}) => {
         throw new DOMException(msg, SYNTAX_ERR);
       }
     }
+  } else if (astPrefix && !forgive && !namespaceDeclared) {
+    const msg = `Undeclared namespace ${astPrefix}`;
+    throw new DOMException(msg, SYNTAX_ERR);
   }
   return res ?? null;
 };

package/types/js/finder.d.ts

@@ -14,9 +14,14 @@ export class Finder {
     private _matchShadowHostPseudoClass;
     private _matchSelector;
     private _matchLeaves;
+    _matchHTMLCollection(items: object, opt?: object): Set<object>;
     private _findDescendantNodes;
     private _matchCombinator;
     private _findNode;
+    private _matchSelf;
+    private _findLineal;
+    private _findFirst;
+    private _findFromHTMLCollection;
     private _findEntryNodes;
     private _getEntryTwig;
     private _collectNodes;