@reteps/tree-sitter-htmlmustache 0.0.35 → 0.0.37

package/README.md

@@ -135,6 +135,47 @@ echo '<div><p>hi</p></div>' | htmlmustache format --stdin
 | `--print-width N`   | Max line width (default: 80)                     |
 | `--mustache-spaces` | Add spaces inside mustache delimiters            |
 
+## Format Ignore
+
+Skip formatting for specific regions using ignore directives. Both HTML and Mustache comment forms are supported.
+
+### Ignore Next Node
+
+Place a comment immediately before the element to preserve its original formatting:
+
+```html
+<!-- htmlmustache-ignore -->
+<div   class="a"   id="b"  >
+  manually   formatted
+</div>
+```
+
+```html
+{{! htmlmustache-ignore }}
+<table><tr><td>compact</td><td>table</td></tr></table>
+```
+
+Only the immediately following sibling node is ignored. Subsequent nodes are formatted normally.
+
+### Ignore Region
+
+Wrap a region in start/end comments to preserve everything between them:
+
+```html
+<!-- htmlmustache-ignore-start -->
+<div   class="a"  >content</div>
+<p>  kept   as-is  </p>
+<!-- htmlmustache-ignore-end -->
+```
+
+```html
+{{! htmlmustache-ignore-start }}
+{{#items}}<li>{{name}}</li>{{/items}}
+{{! htmlmustache-ignore-end }}
+```
+
+If `ignore-start` has no matching `ignore-end`, all remaining siblings in the current scope are preserved as raw text.
+
 ## Configuration
 
 ### `.htmlmustache.jsonc`

package/cli/out/main.js

@@ -2387,15 +2387,16 @@ function normalizeMustacheWhitespace(raw, addSpaces) {
       const first = lines[0].trimStart();
       const last = lines[lines.length - 1].trimEnd();
       if (lines.length === 1) {
-        return `{{${prefix}${space}${first}${space}}}`;
+        return `{{${prefix} ${first} }}`;
       }
       const middle = lines.slice(1, -1);
-      return `{{${prefix}${space}${first}
+      return `{{${prefix} ${first}
 ${middle.join("\n")}
-${last}${space}}}`;
+${last} }}`;
     }
     const trimmed = inner.trim();
-    return `{{${prefix}${space}${trimmed}${space}}}`;
+    const s = prefix === "!" ? " " : space;
+    return `{{${prefix}${s}${trimmed}${s}}}`;
   }
   const plainMatch = raw.match(/^\{\{([\s\S]*)\}\}$/);
   if (plainMatch) {
@@ -2409,6 +2410,28 @@ function normalizeMustacheWhitespaceAll(raw, addSpaces) {
     return normalizeMustacheWhitespace(match, addSpaces);
   });
 }
+function getIgnoreDirective(node) {
+  if (node.type !== "html_comment" && node.type !== "mustache_comment") {
+    return null;
+  }
+  let inner = null;
+  if (node.type === "html_comment") {
+    const match = node.text.match(/^<!--([\s\S]*)-->$/);
+    if (match) {
+      inner = match[1].trim();
+    }
+  } else {
+    const match = node.text.match(/^\{\{!([\s\S]*)\}\}$/);
+    if (match) {
+      inner = match[1].trim();
+    }
+  }
+  if (!inner) return null;
+  if (inner === "htmlmustache-ignore") return "ignore";
+  if (inner === "htmlmustache-ignore-start") return "ignore-start";
+  if (inner === "htmlmustache-ignore-end") return "ignore-end";
+  return null;
+}
 
 // lsp/server/src/formatting/classifier.ts
 var customCodeTags = /* @__PURE__ */ new Set();
@@ -2622,14 +2645,16 @@ function hasImplicitEndTagsRecursive(node) {
   if (node.type === "html_element") {
     let hasStartTag = false;
     let hasEndTag = false;
+    let hasContentChildren = false;
     for (let i = 0; i < node.childCount; i++) {
       const child = node.child(i);
       if (!child) continue;
       if (child.type === "html_start_tag") hasStartTag = true;
-      if (child.type === "html_end_tag") hasEndTag = true;
-      if (child.type === "html_forced_end_tag") return true;
+      else if (child.type === "html_end_tag") hasEndTag = true;
+      else if (child.type === "html_forced_end_tag") return true;
+      else if (!child.type.startsWith("_")) hasContentChildren = true;
     }
-    if (hasStartTag && !hasEndTag) return true;
+    if (hasStartTag && !hasEndTag && hasContentChildren) return true;
   }
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
@@ -2900,8 +2925,16 @@ function formatHtmlElement(node, context) {
       }
     }
   } else if (!isBlock && !hasHtmlElementChildren) {
+    let prevEnd = startTag ? startTag.endIndex : -1;
     for (const child of contentNodes) {
+      if (prevEnd >= 0 && child.startIndex > prevEnd) {
+        const gap = context.document.getText().slice(prevEnd, child.startIndex);
+        if (/\s/.test(gap)) {
+          parts.push(text(" "));
+        }
+      }
       parts.push(formatNode(child, context));
+      prevEnd = child.endIndex;
     }
   } else {
     const formattedContent = formatBlockChildren(contentNodes, context);
@@ -3002,7 +3035,29 @@ function formatScriptStyleElement(node, context) {
             parts.push(text(child.text));
           }
         } else {
-          parts.push(text(child.text));
+          const dedented = dedentContent(child.text);
+          if (dedented.length > 0) {
+            const contentLines = dedented.split("\n");
+            if (contentLines.length === 1) {
+              parts.push(text(contentLines[0]));
+            } else {
+              const lineDocs = [];
+              for (let j = 0; j < contentLines.length; j++) {
+                if (j > 0) {
+                  if (contentLines[j] === "") {
+                    lineDocs.push("\n");
+                  } else {
+                    lineDocs.push(hardline);
+                  }
+                }
+                if (contentLines[j] !== "") {
+                  lineDocs.push(text(contentLines[j]));
+                }
+              }
+              parts.push(indent(concat([hardline, ...lineDocs])));
+              parts.push(hardline);
+            }
+          }
         }
       }
     }
@@ -3184,18 +3239,89 @@ function formatBlockChildren(nodes, context) {
   let lastNodeEnd = -1;
   let pendingBlankLine = false;
   let blankLineBeforeCurrentLine = false;
+  let ignoreNext = false;
+  let inIgnoreRegion = false;
+  let ignoreRegionStartIndex = -1;
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
-    const treatAsBlock = shouldTreatAsBlock(node, i, nodes);
-    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
+    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd && !inIgnoreRegion) {
       const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
-      const prevNode = nodes[i - 1];
-      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes);
       const newlineCount = (gap.match(/\n/g) || []).length;
       if (newlineCount >= 2) {
         pendingBlankLine = true;
       }
+    }
+    const directive = getIgnoreDirective(node);
+    if (directive === "ignore-end" && inIgnoreRegion) {
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      const rawText = context.document.getText().slice(ignoreRegionStartIndex, node.startIndex).replace(/^\n/, "").replace(/\n$/, "");
+      if (rawText.length > 0) {
+        lines.push({ doc: text(rawText), blankLineBefore: false });
+      }
+      const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+      lines.push({ doc: text(commentText), blankLineBefore: false });
+      inIgnoreRegion = false;
+      ignoreRegionStartIndex = -1;
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+    if (inIgnoreRegion) {
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+    if (directive === "ignore-start") {
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+      lines.push({ doc: text(commentText), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+      inIgnoreRegion = true;
+      ignoreRegionStartIndex = node.endIndex;
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+    if (directive === "ignore") {
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+      lines.push({ doc: text(commentText), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+      ignoreNext = true;
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+    if (ignoreNext) {
+      lines.push({ doc: text(node.text), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+      ignoreNext = false;
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+    const treatAsBlock = shouldTreatAsBlock(node, i, nodes);
+    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
+      const prevNode = nodes[i - 1];
+      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes);
       if (!prevTreatAsBlock && !treatAsBlock) {
+        const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
         if (/\s/.test(gap)) {
           currentLine.push(line);
         }
@@ -3315,6 +3441,13 @@ function formatBlockChildren(nodes, context) {
     }
     lastNodeEnd = node.endIndex;
   }
+  if (inIgnoreRegion && nodes.length > 0) {
+    const lastNode = nodes[nodes.length - 1];
+    const rawText = context.document.getText().slice(ignoreRegionStartIndex, lastNode.endIndex).replace(/^\n/, "");
+    if (rawText.length > 0) {
+      lines.push({ doc: text(rawText), blankLineBefore: false });
+    }
+  }
   if (currentLine.length > 0) {
     const lineContent = trimDoc(inlineContentToFill(currentLine));
     if (hasDocContent(lineContent)) {
@@ -3411,6 +3544,9 @@ function formatDocument2(tree, document, options, params = {}) {
   if (customCodeTags2) {
     setCustomCodeTags(customCodeTags2);
   }
+  if (tree.rootNode.hasError) {
+    return [];
+  }
   const configMap = buildConfigMap(customCodeTagConfigs);
   const context = {
     document,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -40,11 +40,16 @@
     "vscode-languageserver-textdocument": "^1.0.12",
     "web-tree-sitter": "^0.25.0"
   },
-  "optionalDependencies": {
+  "peerDependencies": {
     "node-addon-api": "^8.2.2",
     "node-gyp-build": "^4.8.2",
     "tree-sitter": "^0.25.0"
   },
+  "peerDependenciesMeta": {
+    "node-addon-api": { "optional": true },
+    "node-gyp-build": { "optional": true },
+    "tree-sitter": { "optional": true }
+  },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/node": "^22.19.11",

package/src/scanner.c

@@ -516,6 +516,12 @@ static bool scan_mustache_end_tag_html_implicit_end_tag(Scanner *scanner, TSLexe
     if (scanner->mustache_tags.size > 0) {
         MustacheTag *current_mustache_tag = array_back(&scanner->mustache_tags);
         if (scanner->tags.size > current_mustache_tag->html_tag_stack_size) {
+            Tag *top_tag = array_back(&scanner->tags);
+            // Void elements don't cross mustache boundaries — let the normal
+            // implicit end handler close them instead of forcing closure.
+            if (tag_is_void(top_tag)) {
+                return false;
+            }
             pop_html_tag(scanner);
             lexer->result_symbol = MUSTACHE_END_TAG_HTML_IMPLICIT_END_TAG;
             return true;