@reteps/tree-sitter-htmlmustache 0.9.0 → 0.9.1

package/browser/out/browser/index.mjs

@@ -1307,13 +1307,85 @@ function parseSelector(raw) {
   const tops = ast.type === "list" ? ast.list : [ast];
   const alts = [];
   for (const top of tops) {
-    const segments = [];
-    if (!collectSegments(top, "descendant", segments)) return null;
-    if (segments.length === 0) return null;
-    alts.push(segments);
+    const expanded = expandIs(top);
+    if (expanded === null) return null;
+    for (const exp of expanded) {
+      const segments = [];
+      if (!collectSegments(exp, "descendant", segments)) return null;
+      if (segments.length === 0) return null;
+      alts.push(segments);
+    }
   }
   return alts.length > 0 ? alts : null;
 }
+function expandIs(ast) {
+  switch (ast.type) {
+    case "list": {
+      const out = [];
+      for (const alt of ast.list) {
+        const expanded = expandIs(alt);
+        if (expanded === null) return null;
+        out.push(...expanded);
+      }
+      return out;
+    }
+    case "complex": {
+      const lefts = expandIs(ast.left);
+      if (lefts === null) return null;
+      const rights = expandIs(ast.right);
+      if (rights === null) return null;
+      const out = [];
+      for (const l of lefts) for (const r of rights) {
+        out.push({ ...ast, left: l, right: r });
+      }
+      return out;
+    }
+    case "compound": {
+      if (ast.list.length === 1) {
+        const tok = ast.list[0];
+        if (tok.type === "pseudo-class" && tok.name === "is") {
+          if (!tok.subtree) return null;
+          return expandIs(tok.subtree);
+        }
+      }
+      return expandCompoundWithIs(ast.list);
+    }
+    default:
+      if (ast.type === "pseudo-class" && ast.name === "is") {
+        if (!ast.subtree) return null;
+        return expandIs(ast.subtree);
+      }
+      return [ast];
+  }
+}
+function expandCompoundWithIs(tokens) {
+  let variants = [[]];
+  for (const tok of tokens) {
+    if (tok.type === "pseudo-class" && tok.name === "is") {
+      if (!tok.subtree) return null;
+      const alts = expandIs(tok.subtree);
+      if (alts === null) return null;
+      const next = [];
+      for (const base of variants) {
+        for (const alt of alts) {
+          if (alt.type === "compound") {
+            next.push([...base, ...alt.list]);
+          } else if (alt.type === "complex" || alt.type === "list" || alt.type === "relative") {
+            return null;
+          } else {
+            next.push([...base, alt]);
+          }
+        }
+      }
+      variants = next;
+    } else {
+      variants = variants.map((v) => [...v, tok]);
+    }
+  }
+  return variants.map(
+    (list) => list.length === 1 ? list[0] : { type: "compound", list }
+  );
+}
 function collectSegments(ast, combinator, out) {
   if (ast.type === "complex") {
     const mapped = mapCombinator(ast.combinator);
@@ -1331,6 +1403,8 @@ function mapCombinator(c) {
   const trimmed = c.trim();
   if (trimmed === "") return "descendant";
   if (trimmed === ">") return "child";
+  if (trimmed === "+") return "adjacent-sibling";
+  if (trimmed === "~") return "general-sibling";
   return null;
 }
 function segmentFromCompound(ast) {
@@ -1341,6 +1415,7 @@ function segmentFromCompound(ast) {
   let rootOnly = false;
   const attributes = [];
   const descendantChecks = [];
+  const selfNegations = [];
   const forbidChange = (requested) => {
     if (kind === void 0) return false;
     if (kind === requested) return false;
@@ -1394,7 +1469,7 @@ function segmentFromCompound(ast) {
           break;
         }
         if (token.name === "not") {
-          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks)) return null;
+          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks, selfNegations)) return null;
           break;
         }
         if (token.name === "root") {
@@ -1416,7 +1491,7 @@ function segmentFromCompound(ast) {
   }
   const isHtml = kind === "html";
   const finalAttrs = isHtml ? attributes : [];
-  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, combinator: "descendant" };
+  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, selfNegations, combinator: "descendant" };
 }
 function mustacheKindFromMarker(name) {
   switch (name) {
@@ -1481,7 +1556,7 @@ function classConstraint(token, negated) {
 function idConstraint(token, negated) {
   return { name: "id", op: "=", value: token.name, negated };
 }
-function applyNegatedSubtree(subtree, attributes, descendantChecks) {
+function applyNegatedSubtree(subtree, attributes, descendantChecks, selfNegations) {
   if (!subtree) return false;
   if (subtree.type === "attribute") {
     const c = attributeConstraint(subtree, true);
@@ -1498,9 +1573,14 @@ function applyNegatedSubtree(subtree, attributes, descendantChecks) {
     return true;
   }
   if (subtree.type === "pseudo-class" && subtree.name === "has") {
-    const sel = subtreeToSelector(subtree.subtree);
-    if (!sel) return false;
-    descendantChecks.push({ selector: sel, negated: true });
+    const sel2 = subtreeToSelector(subtree.subtree);
+    if (!sel2) return false;
+    descendantChecks.push({ selector: sel2, negated: true });
+    return true;
+  }
+  const sel = subtreeToSelector(subtree);
+  if (sel) {
+    selfNegations.push(sel);
     return true;
   }
   return false;
@@ -1600,11 +1680,20 @@ function checkDescendants(node, checks) {
   return true;
 }
 function hasDescendantMatch(node, selector) {
-  for (const child of node.children) {
-    if (matchSelector(child, selector).length > 0) return true;
+  for (let i = 0; i < node.children.length; i++) {
+    if (matchSelector(node.children[i], selector, node.children, i).length > 0) return true;
   }
   return false;
 }
+function checkSelfNegations(node, negations, rootNode) {
+  for (const sel of negations) {
+    for (const alt of sel) {
+      if (alt.length !== 1) continue;
+      if (nodeMatchesSegment(node, alt[0], rootNode)) return false;
+    }
+  }
+  return true;
+}
 function matchesName(actual, segment) {
   if (segment.name === null) return true;
   if (actual === null) return false;
@@ -1614,51 +1703,73 @@ function matchesName(actual, segment) {
 function nodeMatchesSegment(node, segment, rootNode) {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
-    return checkDescendants(node, segment.descendantChecks);
-  }
-  switch (segment.kind) {
-    case "html": {
-      if (!HTML_ELEMENT_TYPES.has(node.type)) return false;
-      if (segment.name !== null) {
-        const tagName = getTagName(node)?.toLowerCase();
-        if (tagName !== segment.name) return false;
-      }
-      return checkAttributes(node, segment.attributes) && checkDescendants(node, segment.descendantChecks);
-    }
-    case "section":
-      if (node.type !== "mustache_section") return false;
-      if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "inverted":
-      if (node.type !== "mustache_inverted_section") return false;
-      if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "variable":
-      if (node.type !== "mustache_interpolation") return false;
-      if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "raw":
-      if (node.type !== "mustache_triple") return false;
-      if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "comment":
-      if (node.type !== "mustache_comment") return false;
-      if (!matchesName(getCommentContent(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "partial":
-      if (node.type !== "mustache_partial") return false;
-      if (!matchesName(getPartialName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-  }
-}
-function checkAncestors(ancestors, segments, segIdx, childCombinator) {
+    return checkDescendants(node, segment.descendantChecks) && checkSelfNegations(node, segment.selfNegations, rootNode);
+  }
+  const baseMatches = (() => {
+    switch (segment.kind) {
+      case "html": {
+        if (!HTML_ELEMENT_TYPES.has(node.type)) return false;
+        if (segment.name !== null) {
+          const tagName = getTagName(node)?.toLowerCase();
+          if (tagName !== segment.name) return false;
+        }
+        return checkAttributes(node, segment.attributes) && checkDescendants(node, segment.descendantChecks);
+      }
+      case "section":
+        if (node.type !== "mustache_section") return false;
+        if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "inverted":
+        if (node.type !== "mustache_inverted_section") return false;
+        if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "variable":
+        if (node.type !== "mustache_interpolation") return false;
+        if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "raw":
+        if (node.type !== "mustache_triple") return false;
+        if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "comment":
+        if (node.type !== "mustache_comment") return false;
+        if (!matchesName(getCommentContent(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "partial":
+        if (node.type !== "mustache_partial") return false;
+        if (!matchesName(getPartialName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+    }
+  })();
+  if (!baseMatches) return false;
+  return checkSelfNegations(node, segment.selfNegations, rootNode);
+}
+function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
   if (segIdx < 0) return true;
   const segment = segments[segIdx];
+  if (stepCombinator === "adjacent-sibling" || stepCombinator === "general-sibling") {
+    for (let i = cursor.indexInSiblings - 1; i >= 0; i--) {
+      const sib = cursor.siblings[i];
+      if (!isMatchableNode(sib)) continue;
+      if (!nodeMatchesSegment(sib, segment, rootNode)) {
+        if (stepCombinator === "adjacent-sibling") return false;
+        continue;
+      }
+      const newCursor = {
+        ancestors: cursor.ancestors,
+        siblings: cursor.siblings,
+        indexInSiblings: i
+      };
+      if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+      if (stepCombinator === "adjacent-sibling") return false;
+    }
+    return false;
+  }
   const ancestorKind = ancestorKindForSegment(segment);
   if (ancestorKind === null) return false;
-  if (childCombinator === "child") {
-    for (let a = ancestors.length - 1; a >= 0; a--) {
-      const entry = ancestors[a];
+  if (stepCombinator === "child") {
+    for (let a = cursor.ancestors.length - 1; a >= 0; a--) {
+      const entry = cursor.ancestors[a];
       if (entry.kind !== ancestorKind) {
         if (ancestorKind === "root" && entry.kind === "html") return false;
         continue;
@@ -1666,22 +1777,35 @@ function checkAncestors(ancestors, segments, segIdx, childCombinator) {
       if (!matchesName(entry.name, segment)) return false;
       if (segment.kind === "html" && !checkAttributes(entry.node, segment.attributes)) return false;
       if (!checkDescendants(entry.node, segment.descendantChecks)) return false;
-      return checkAncestors(ancestors.slice(0, a), segments, segIdx - 1, segment.combinator);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
+      const newCursor = {
+        ancestors: cursor.ancestors.slice(0, a),
+        siblings: entry.siblings,
+        indexInSiblings: entry.indexInSiblings
+      };
+      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
-  for (let a = ancestors.length - 1; a >= 0; a--) {
-    const entry = ancestors[a];
+  for (let a = cursor.ancestors.length - 1; a >= 0; a--) {
+    const entry = cursor.ancestors[a];
     if (entry.kind !== ancestorKind) continue;
     if (!matchesName(entry.name, segment)) continue;
     if (segment.kind === "html" && !checkAttributes(entry.node, segment.attributes)) continue;
     if (!checkDescendants(entry.node, segment.descendantChecks)) continue;
-    if (checkAncestors(ancestors.slice(0, a), segments, segIdx - 1, segment.combinator)) {
-      return true;
-    }
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
+    const newCursor = {
+      ancestors: cursor.ancestors.slice(0, a),
+      siblings: entry.siblings,
+      indexInSiblings: entry.indexInSiblings
+    };
+    if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
   }
   return false;
 }
+function isMatchableNode(node) {
+  return HTML_ELEMENT_TYPES.has(node.type) || node.type === "mustache_section" || node.type === "mustache_inverted_section" || node.type === "mustache_interpolation" || node.type === "mustache_triple" || node.type === "mustache_comment" || node.type === "mustache_partial";
+}
 function ancestorKindForSegment(segment) {
   if (segment.rootOnly) return "root";
   if (segment.kind === "html") return "html";
@@ -1715,12 +1839,13 @@ function getReportNode(node, rootNode) {
   }
   return node;
 }
-function matchAlternative(rootNode, segments) {
+function matchAlternative(rootNode, segments, rootSiblings, rootIndexInSiblings) {
   const results = [];
   const lastSegment = segments[segments.length - 1];
-  function walk(node, ancestors) {
+  function walk(node, ancestors, siblings, indexInSiblings) {
     if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      if (segments.length === 1 || checkAncestors(ancestors, segments, segments.length - 2, lastSegment.combinator)) {
+      const cursor = { ancestors, siblings, indexInSiblings };
+      if (segments.length === 1 || checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)) {
         results.push(getReportNode(node, rootNode));
       }
     }
@@ -1729,19 +1854,28 @@ function matchAlternative(rootNode, segments) {
     if (ancestorKind !== null) {
       const name = ancestorKind === "html" ? getTagName(node)?.toLowerCase() : getSectionName(node)?.toLowerCase();
       if (name) {
-        newAncestors = [...ancestors, { kind: ancestorKind, name, node }];
+        newAncestors = [...ancestors, { kind: ancestorKind, name, node, siblings, indexInSiblings }];
       }
     }
-    for (const child of node.children) walk(child, newAncestors);
+    for (let i = 0; i < node.children.length; i++) {
+      walk(node.children[i], newAncestors, node.children, i);
+    }
   }
-  walk(rootNode, [{ kind: "root", name: "", node: rootNode }]);
+  const rootEntry = {
+    kind: "root",
+    name: "",
+    node: rootNode,
+    siblings: rootSiblings,
+    indexInSiblings: rootIndexInSiblings
+  };
+  walk(rootNode, [rootEntry], rootSiblings, rootIndexInSiblings);
   return results;
 }
-function matchSelector(rootNode, selector) {
+function matchSelector(rootNode, selector, siblings = [], indexInSiblings = 0) {
   const allResults = [];
   const seen = /* @__PURE__ */ new Set();
   for (const alt of selector) {
-    for (const node of matchAlternative(rootNode, alt)) {
+    for (const node of matchAlternative(rootNode, alt, siblings, indexInSiblings)) {
       if (!seen.has(node)) {
         seen.add(node);
         allResults.push(node);