Add format ignore directives, void element fixes, and formatter improvements, bump v0.0.37

- Add htmlmustache-ignore / htmlmustache-ignore-start / htmlmustache-ignore-end
  directives to skip formatting for specific nodes or regions
- Fix void elements inside mustache sections being treated as boundary-crossing
  (scanner no longer forces closure; classifier skips void elements)
- Bail out of formatting when tree has parse errors to avoid mangling content
- Re-indent script/style content when nested inside mustache sections
- Preserve space between interpolation and text in inline elements
- Always keep spaces in mustache comments regardless of mustacheSpaces setting

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Peter Stenger

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`

cli/src/format.test.ts

@@ -101,6 +101,54 @@ describe('formatSource', () => {
     });
   });
 
+  describe('script and style in mustache conditionals', () => {
+    it('re-indents script content inside mustache section', () => {
+      const input = [
+        '{{#show}}',
+        '<script>',
+        'const x = 1;',
+        'const y = 2;',
+        '</script>',
+        '{{/show}}',
+      ].join('\n');
+      const result = formatSource(input, defaultOptions);
+      expect(result).toBe(
+        [
+          '{{#show}}',
+          '  <script>',
+          '    const x = 1;',
+          '    const y = 2;',
+          '  </script>',
+          '{{/show}}',
+          '',
+        ].join('\n')
+      );
+    });
+
+    it('re-indents style content inside mustache section', () => {
+      const input = [
+        '{{#show}}',
+        '<style>',
+        '.foo { color: red; }',
+        '.bar { color: blue; }',
+        '</style>',
+        '{{/show}}',
+      ].join('\n');
+      const result = formatSource(input, defaultOptions);
+      expect(result).toBe(
+        [
+          '{{#show}}',
+          '  <style>',
+          '    .foo { color: red; }',
+          '    .bar { color: blue; }',
+          '  </style>',
+          '{{/show}}',
+          '',
+        ].join('\n')
+      );
+    });
+  });
+
   describe('config file integration', () => {
     it('applies config file settings via configFile param', () => {
       const config: HtmlMustacheConfig = { indentSize: 4 };

lsp/package.json

@@ -401,15 +401,17 @@ function hasImplicitEndTagsRecursive(node: SyntaxNode): boolean {
   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; // Explicit implicit end
+      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 there's a start tag but no end tag at all, it's implicit
-    if (hasStartTag && !hasEndTag) return true;
+    // Void elements (start tag only, no content, no end tag) aren't boundary-crossing
+    if (hasStartTag && !hasEndTag && hasContentChildren) return true;
   }
 
   // Check children recursively

lsp/server/src/formatting/classifier.ts

@@ -32,7 +32,7 @@ import {
   getCSSDisplay,
   isWhitespaceInsensitive,
 } from './classifier';
-import { normalizeText, getVisibleChildren, normalizeMustacheWhitespace, normalizeMustacheWhitespaceAll } from './utils';
+import { normalizeText, getVisibleChildren, normalizeMustacheWhitespace, normalizeMustacheWhitespaceAll, getIgnoreDirective } from './utils';
 import type { CustomCodeTagConfig } from '../customCodeTags';
 import { getAttributeValue } from '../customCodeTags';
 
@@ -298,8 +298,18 @@ export function formatHtmlElement(node: SyntaxNode, context: FormatterContext):
     }
   } else if (!isBlock && !hasHtmlElementChildren) {
     // Inline element with only text/interpolation content - keep tight
+    // Preserve whitespace gaps between sibling nodes (e.g. space between
+    // mustache_interpolation and text that tree-sitter puts in the gap)
+    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 {
     // Block element or inline-with-block-children: use hardline + indent
@@ -435,7 +445,32 @@ export function formatScriptStyleElement(
             parts.push(text(child.text));
           }
         } else {
-          parts.push(text(child.text));
+          // Script/style fallback: dedent and re-emit with hardlines so the
+          // printer can apply proper indentation from parent context.
+          const dedented = dedentContent(child.text);
+          if (dedented.length > 0) {
+            const contentLines = dedented.split('\n');
+            if (contentLines.length === 1) {
+              // Single-line content: keep inline
+              parts.push(text(contentLines[0]));
+            } else {
+              const lineDocs: Doc[] = [];
+              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);
+            }
+          }
         }
       }
     }
@@ -716,25 +751,115 @@ export function formatBlockChildren(
   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);
-
-    // Check for whitespace between nodes in original document
-    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
+    // Detect blank lines in gap between nodes (before directive handling)
+    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);
-
-      // Detect blank lines (≥2 newlines) in any gap between nodes
       const newlineCount = (gap.match(/\n/g) || []).length;
       if (newlineCount >= 2) {
         pendingBlankLine = true;
       }
+    }
+
+    const directive = getIgnoreDirective(node);
+
+    // --- Ignore directive handling ---
+
+    // ignore-end: close a region
+    if (directive === 'ignore-end' && inIgnoreRegion) {
+      // Flush any pending inline content
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      // Emit raw text from region start to this comment, trimming boundary newlines
+      const rawText = context.document.getText().slice(ignoreRegionStartIndex, node.startIndex)
+        .replace(/^\n/, '').replace(/\n$/, '');
+      if (rawText.length > 0) {
+        lines.push({ doc: text(rawText), blankLineBefore: false });
+      }
+      // Emit the ignore-end comment itself
+      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;
+    }
+
+    // Inside ignore region: skip (content captured as raw text at ignore-end)
+    if (inIgnoreRegion) {
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+
+    // ignore-start: begin a region
+    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;
+    }
+
+    // ignore (next-node): emit the comment, set flag
+    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;
+    }
+
+    // Ignored next-node: emit raw text, clear flag
+    if (ignoreNext) {
+      lines.push({ doc: text(node.text), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+      ignoreNext = false;
+      lastNodeEnd = node.endIndex;
+      continue;
+    }
+
+    // ignore-end without ignore-start: treat as normal comment (fall through)
+
+    const treatAsBlock = shouldTreatAsBlock(node, i, nodes);
+
+    // Check for whitespace between nodes in original document (inline gap handling)
+    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);
         }
@@ -875,6 +1000,16 @@ export function formatBlockChildren(
     lastNodeEnd = node.endIndex;
   }
 
+  // Handle unterminated ignore region: emit remaining raw text
+  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 });
+    }
+  }
+
   // Flush remaining inline content
   if (currentLine.length > 0) {
     const lineContent = trimDoc(inlineContentToFill(currentLine));

lsp/server/src/formatting/formatters.ts

@@ -71,6 +71,11 @@ export function formatDocument(
     setCustomCodeTags(customCodeTags);
   }
 
+  // Bail out if the tree has parse errors to avoid mangling content
+  if (tree.rootNode.hasError) {
+    return [];
+  }
+
   const configMap = buildConfigMap(customCodeTagConfigs);
   const context: FormatterContext = {
     document,
@@ -109,6 +114,11 @@ export function formatDocumentRange(
     setCustomCodeTags(customCodeTags);
   }
 
+  // Bail out if the tree has parse errors to avoid mangling content
+  if (tree.rootNode.hasError) {
+    return [];
+  }
+
   // Find nodes that overlap with the range
   const startOffset = document.offsetAt(range.start);
   const endOffset = document.offsetAt(range.end);