@reteps/tree-sitter-htmlmustache 0.4.0 → 0.4.2

package/cli/out/main.js

@@ -544,6 +544,25 @@ function parseDocument(source) {
 // lsp/server/src/configFile.ts
 var fs = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
+var VALID_CSS_DISPLAY_VALUES = /* @__PURE__ */ new Set([
+  "block",
+  "inline",
+  "inline-block",
+  "table-row",
+  "table-cell",
+  "table",
+  "table-row-group",
+  "table-header-group",
+  "table-footer-group",
+  "table-column",
+  "table-column-group",
+  "table-caption",
+  "list-item",
+  "ruby",
+  "ruby-base",
+  "ruby-text",
+  "none"
+]);
 var CONFIG_FILENAME = ".htmlmustache.jsonc";
 function parseJsonc(text2) {
   let result = "";
@@ -599,6 +618,31 @@ function findConfigFile(startDir) {
   }
 }
 var VALID_INDENT_MODES = /* @__PURE__ */ new Set(["never", "always", "attribute"]);
+function parseCustomTagArray(arr) {
+  if (!Array.isArray(arr)) return [];
+  const tags = [];
+  for (const entry of arr) {
+    if (entry && typeof entry === "object" && "name" in entry) {
+      const e = entry;
+      if (typeof e.name !== "string" || e.name.length === 0) continue;
+      const tag = { name: e.name };
+      if (typeof e.display === "string" && VALID_CSS_DISPLAY_VALUES.has(e.display)) {
+        tag.display = e.display;
+      }
+      if (typeof e.languageAttribute === "string") tag.languageAttribute = e.languageAttribute;
+      if (e.languageMap && typeof e.languageMap === "object" && !Array.isArray(e.languageMap)) {
+        tag.languageMap = e.languageMap;
+      }
+      if (typeof e.languageDefault === "string") tag.languageDefault = e.languageDefault;
+      if (typeof e.indent === "string" && VALID_INDENT_MODES.has(e.indent)) {
+        tag.indent = e.indent;
+      }
+      if (typeof e.indentAttribute === "string") tag.indentAttribute = e.indentAttribute;
+      tags.push(tag);
+    }
+  }
+  return tags;
+}
 function validateConfig(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
   const obj = raw;
@@ -612,6 +656,12 @@ function validateConfig(raw) {
   if (typeof obj.mustacheSpaces === "boolean") {
     config.mustacheSpaces = obj.mustacheSpaces;
   }
+  if (Array.isArray(obj.noBreakDelimiters)) {
+    const items = obj.noBreakDelimiters.filter(
+      (s) => typeof s === "string" && s.length > 0
+    );
+    if (items.length > 0) config.noBreakDelimiters = items;
+  }
   if (Array.isArray(obj.include)) {
     const items = obj.include.filter((s) => typeof s === "string" && s.length > 0);
     if (items.length > 0) config.include = items;
@@ -620,26 +670,17 @@ function validateConfig(raw) {
     const items = obj.exclude.filter((s) => typeof s === "string" && s.length > 0);
     if (items.length > 0) config.exclude = items;
   }
-  if (Array.isArray(obj.customCodeTags)) {
-    const tags = [];
-    for (const entry of obj.customCodeTags) {
-      if (entry && typeof entry === "object" && "name" in entry) {
-        const e = entry;
-        if (typeof e.name !== "string" || e.name.length === 0) continue;
-        const tag = { name: e.name };
-        if (typeof e.languageAttribute === "string") tag.languageAttribute = e.languageAttribute;
-        if (e.languageMap && typeof e.languageMap === "object" && !Array.isArray(e.languageMap)) {
-          tag.languageMap = e.languageMap;
-        }
-        if (typeof e.languageDefault === "string") tag.languageDefault = e.languageDefault;
-        if (typeof e.indent === "string" && VALID_INDENT_MODES.has(e.indent)) {
-          tag.indent = e.indent;
-        }
-        if (typeof e.indentAttribute === "string") tag.indentAttribute = e.indentAttribute;
-        tags.push(tag);
-      }
+  const parsedCodeTags = parseCustomTagArray(obj.customCodeTags);
+  const parsedCustomTags = parseCustomTagArray(obj.customTags);
+  if (parsedCodeTags.length > 0 || parsedCustomTags.length > 0) {
+    const mergedMap = /* @__PURE__ */ new Map();
+    for (const tag of parsedCodeTags) {
+      mergedMap.set(tag.name.toLowerCase(), tag);
     }
-    if (tags.length > 0) config.customCodeTags = tags;
+    for (const tag of parsedCustomTags) {
+      mergedMap.set(tag.name.toLowerCase(), tag);
+    }
+    config.customTags = Array.from(mergedMap.values());
   }
   return config;
 }
@@ -1798,7 +1839,7 @@ function getWellformedEdit(textEdit) {
 // lsp/server/src/formatting/printer.ts
 function print(doc, options) {
   const output = [];
-  const state = { indentLevel: 0, mode: "break" };
+  const state = { indentLevel: 0, mode: "break", groupModes: /* @__PURE__ */ new Map() };
   printDoc(doc, state, output, options);
   return output.join("");
 }
@@ -1872,20 +1913,23 @@ function printDoc(doc, state, output, options) {
       if (doc.break || containsBreakParent(doc.contents)) {
         const prevMode = state.mode;
         state.mode = "break";
+        if (doc.id) state.groupModes.set(doc.id, "break");
         printDoc(doc.contents, state, output, options);
         state.mode = prevMode;
       } else {
         const flatOutput = [];
-        const flatState = { ...state, mode: "flat" };
+        const flatState = { ...state, mode: "flat", groupModes: new Map(state.groupModes) };
         printDoc(doc.contents, flatState, flatOutput, options);
         const flatContent = flatOutput.join("");
         const printWidth = options.printWidth ?? 80;
         const col = currentColumn(output);
         if (!flatContent.includes("\n") && col + flatContent.length <= printWidth) {
+          if (doc.id) state.groupModes.set(doc.id, "flat");
           output.push(flatContent);
         } else {
           const prevMode = state.mode;
           state.mode = "break";
+          if (doc.id) state.groupModes.set(doc.id, "break");
           printDoc(doc.contents, state, output, options);
           state.mode = prevMode;
         }
@@ -1895,13 +1939,15 @@ function printDoc(doc, state, output, options) {
     case "fill":
       printFill(doc.parts, state, output, options);
       break;
-    case "ifBreak":
-      if (state.mode === "break") {
+    case "ifBreak": {
+      const effectiveMode = doc.groupId ? state.groupModes.get(doc.groupId) ?? state.mode : state.mode;
+      if (effectiveMode === "break") {
         printDoc(doc.breakContents, state, output, options);
       } else {
         printDoc(doc.flatContents, state, output, options);
       }
       break;
+    }
     case "breakParent":
       state.mode = "break";
       break;
@@ -1966,12 +2012,21 @@ function indent(contents) {
   if (contents === "") return "";
   return { type: "indent", contents };
 }
-function group(contents, shouldBreak = false) {
+function indentN(contents, n) {
+  if (n <= 0 || contents === "") return contents;
+  let result = contents;
+  for (let i = 0; i < n; i++) {
+    result = indent(result);
+  }
+  return result;
+}
+function group(contents, options) {
   if (contents === "") return "";
-  return { type: "group", contents, break: shouldBreak || void 0 };
+  const shouldBreak = options?.shouldBreak;
+  return { type: "group", contents, break: shouldBreak || void 0, id: options?.id };
 }
-function ifBreak(breakContents, flatContents) {
-  return { type: "ifBreak", breakContents, flatContents };
+function ifBreak(breakContents, flatContents, options) {
+  return { type: "ifBreak", breakContents, flatContents, groupId: options?.groupId };
 }
 function fill(parts) {
   const filtered = parts.filter((p) => p !== "");
@@ -2059,8 +2114,37 @@ function getIgnoreDirective(node) {
   return null;
 }
 
+// lsp/server/src/customCodeTags.ts
+function isCodeTag(config) {
+  return !!(config.languageAttribute || config.languageDefault);
+}
+function getAttributeValue(node, attrName) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === "html_start_tag") {
+      for (let j = 0; j < child.childCount; j++) {
+        const attr = child.child(j);
+        if (attr?.type === "html_attribute") {
+          let name = "";
+          let value = "";
+          for (let k = 0; k < attr.childCount; k++) {
+            const part = attr.child(k);
+            if (part?.type === "html_attribute_name") name = part.text.toLowerCase();
+            if (part?.type === "html_quoted_attribute_value") value = part.text.replace(/^["']|["']$/g, "");
+            if (part?.type === "html_attribute_value") value = part.text;
+          }
+          if (name === attrName.toLowerCase()) {
+            return value;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
 // lsp/server/src/formatting/classifier.ts
-var EMPTY_SET = /* @__PURE__ */ new Set();
+var EMPTY_MAP = /* @__PURE__ */ new Map();
 var CSS_DISPLAY_MAP = {
   // Block elements
   address: "block",
@@ -2151,15 +2235,18 @@ var PRESERVE_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
   "script",
   "style"
 ]);
-function getCSSDisplay(node, customCodeTags = EMPTY_SET) {
+function getCSSDisplay(node, customTags = EMPTY_MAP) {
   const type = node.type;
   if (type === "html_element") {
     const tagName = getTagName(node);
     if (tagName) {
-      if (customCodeTags.has(tagName.toLowerCase())) {
-        return "block";
+      const lower = tagName.toLowerCase();
+      const config = customTags.get(lower);
+      if (config) {
+        if (config.display) return config.display;
+        if (isCodeTag(config)) return "block";
       }
-      return CSS_DISPLAY_MAP[tagName.toLowerCase()] ?? "inline";
+      return CSS_DISPLAY_MAP[lower] ?? "inline";
     }
     return "block";
   }
@@ -2167,7 +2254,7 @@ function getCSSDisplay(node, customCodeTags = EMPTY_SET) {
     return "block";
   }
   if (isMustacheSection(node)) {
-    return hasBlockContent(node, customCodeTags) ? "block" : "inline";
+    return hasBlockContent(node, customTags) ? "block" : "inline";
   }
   return "inline";
 }
@@ -2190,13 +2277,13 @@ function isWhitespaceInsensitive(display) {
       return false;
   }
 }
-function isBlockLevel(node, customCodeTags = EMPTY_SET) {
+function isBlockLevel(node, customTags = EMPTY_MAP) {
   const type = node.type;
   if (isMustacheSection(node)) {
-    return hasBlockContent(node, customCodeTags);
+    return hasBlockContent(node, customTags);
   }
   if (type === "html_element") {
-    const display = getCSSDisplay(node, customCodeTags);
+    const display = getCSSDisplay(node, customTags);
     return isWhitespaceInsensitive(display);
   }
   if (isRawContentElement(node)) {
@@ -2204,7 +2291,7 @@ function isBlockLevel(node, customCodeTags = EMPTY_SET) {
   }
   return false;
 }
-function shouldPreserveContent(node, customCodeTags = EMPTY_SET) {
+function shouldPreserveContent(node, customTags = EMPTY_MAP) {
   const type = node.type;
   if (isRawContentElement(node)) {
     return true;
@@ -2213,23 +2300,25 @@ function shouldPreserveContent(node, customCodeTags = EMPTY_SET) {
     const tagName = getTagName(node);
     if (!tagName) return false;
     const lower = tagName.toLowerCase();
-    return PRESERVE_CONTENT_ELEMENTS.has(lower) || customCodeTags.has(lower);
+    if (PRESERVE_CONTENT_ELEMENTS.has(lower)) return true;
+    const config = customTags.get(lower);
+    if (config && isCodeTag(config)) return true;
   }
   return false;
 }
-function hasBlockContent(sectionNode, customCodeTags = EMPTY_SET) {
+function hasBlockContent(sectionNode, customTags = EMPTY_MAP) {
   const contentNodes = getContentNodes(sectionNode);
   if (hasImplicitEndTags(contentNodes)) {
     return true;
   }
   for (const node of contentNodes) {
-    if (isBlockLevelContent(node, customCodeTags)) {
+    if (isBlockLevelContent(node, customTags)) {
       return true;
     }
   }
   return false;
 }
-function isBlockLevelContent(node, customCodeTags = EMPTY_SET) {
+function isBlockLevelContent(node, customTags = EMPTY_MAP) {
   const type = node.type;
   if (type === "html_element") {
     return true;
@@ -2238,7 +2327,7 @@ function isBlockLevelContent(node, customCodeTags = EMPTY_SET) {
     return true;
   }
   if (isMustacheSection(node)) {
-    return hasBlockContent(node, customCodeTags);
+    return hasBlockContent(node, customTags);
   }
   return false;
 }
@@ -2321,10 +2410,13 @@ function hasAdjacentInlineContent(index, nodes) {
   }
   return false;
 }
-function shouldHtmlElementStayInline(node, index, nodes) {
+function shouldHtmlElementStayInline(node, index, nodes, customTags = EMPTY_MAP) {
   if (node.type !== "html_element") {
     return false;
   }
+  if (isWhitespaceInsensitive(getCSSDisplay(node, customTags))) {
+    return false;
+  }
   if (isInTextFlow(node, index, nodes)) {
     return true;
   }
@@ -2345,57 +2437,11 @@ function shouldHtmlElementStayInline(node, index, nodes) {
   }
   return false;
 }
-function shouldTreatAsBlock(node, index, nodes, customCodeTags = EMPTY_SET) {
+function shouldTreatAsBlock(node, index, nodes, customTags = EMPTY_MAP) {
   const isHtmlEl = isHtmlElementType(node);
   const isMustacheSec = isMustacheSection(node);
-  return isHtmlEl && !shouldHtmlElementStayInline(node, index, nodes) || isMustacheSec && !isInTextFlow(node, index, nodes) || isBlockLevel(node, customCodeTags) && !isInTextFlow(node, index, nodes);
-}
-
-// lsp/server/src/customCodeTags.ts
-var VALID_INDENT_MODES2 = /* @__PURE__ */ new Set(["never", "always", "attribute"]);
-function parseCustomCodeTagSettings(tags) {
-  const tagNames = [];
-  const configs = [];
-  for (const tag of tags) {
-    if (tag && typeof tag === "object" && "name" in tag && typeof tag.name === "string") {
-      const t = tag;
-      const config = { name: t.name };
-      if (typeof t.languageAttribute === "string") config.languageAttribute = t.languageAttribute;
-      if (t.languageMap && typeof t.languageMap === "object") config.languageMap = t.languageMap;
-      if (typeof t.languageDefault === "string") config.languageDefault = t.languageDefault;
-      if (typeof t.indent === "string" && VALID_INDENT_MODES2.has(t.indent)) {
-        config.indent = t.indent;
-      }
-      if (typeof t.indentAttribute === "string") config.indentAttribute = t.indentAttribute;
-      tagNames.push(config.name);
-      configs.push(config);
-    }
-  }
-  return { tagNames, configs };
-}
-function getAttributeValue(node, attrName) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child?.type === "html_start_tag") {
-      for (let j = 0; j < child.childCount; j++) {
-        const attr = child.child(j);
-        if (attr?.type === "html_attribute") {
-          let name = "";
-          let value = "";
-          for (let k = 0; k < attr.childCount; k++) {
-            const part = attr.child(k);
-            if (part?.type === "html_attribute_name") name = part.text.toLowerCase();
-            if (part?.type === "html_quoted_attribute_value") value = part.text.replace(/^["']|["']$/g, "");
-            if (part?.type === "html_attribute_value") value = part.text;
-          }
-          if (name === attrName.toLowerCase()) {
-            return value;
-          }
-        }
-      }
-    }
-  }
-  return null;
+  if (node.type === "html_erroneous_end_tag") return true;
+  return isHtmlEl && !shouldHtmlElementStayInline(node, index, nodes, customTags) || isMustacheSec && !isInTextFlow(node, index, nodes) || isBlockLevel(node, customTags) && !isInTextFlow(node, index, nodes);
 }
 
 // lsp/server/src/formatting/formatters.ts
@@ -2457,7 +2503,7 @@ function formatNode(node, context, forceInline = false) {
     case "document":
       return formatDocument(node, context);
     case "html_element":
-      return formatHtmlElement(node, context);
+      return formatHtmlElement(node, context, forceInline);
     case "html_script_element":
     case "html_style_element":
     case "html_raw_element":
@@ -2490,8 +2536,8 @@ function formatNode(node, context, forceInline = false) {
 function formatText(node) {
   return text(normalizeText(node.text));
 }
-function formatHtmlElement(node, context) {
-  const tags = context.customCodeTags;
+function formatHtmlElement(node, context, forceInline = false) {
+  const tags = context.customTags;
   const display = getCSSDisplay(node, tags);
   const isBlock = isWhitespaceInsensitive(display);
   const preserveContent = shouldPreserveContent(node, tags);
@@ -2527,7 +2573,7 @@ function formatHtmlElement(node, context) {
   );
   if (preserveContent) {
     const tagNameLower = startTag ? getTagNameFromStartTag(startTag) : null;
-    const tagConfig = tagNameLower ? context.customCodeTagConfigs?.get(tagNameLower) : void 0;
+    const tagConfig = tagNameLower ? context.customTags?.get(tagNameLower) : void 0;
     const shouldIndent = tagConfig ? resolveIndentMode(node, tagConfig) : false;
     if (shouldIndent && startTag && endTag) {
       const rawContent = context.document.getText().slice(
@@ -2570,7 +2616,26 @@ function formatHtmlElement(node, context) {
         parts.push(text(child.text));
       }
     }
-  } else if (!isBlock && !hasHtmlElementChildren) {
+  } else if (!isBlock && (!hasHtmlElementChildren || forceInline && !contentNodes.some(
+    (child) => isRawContentElement(child) || isBlockLevel(child, tags)
+  ))) {
+    if (!forceInline && startTag && startTagHasAttributes(startTag)) {
+      const formattedContent = formatBlockChildren(contentNodes, context);
+      if (hasDocContent(formattedContent)) {
+        const bareStartTag = formatStartTag(startTag, context, true);
+        const outerParts = [
+          group(bareStartTag),
+          indent(concat([softline, formattedContent]))
+        ];
+        if (hasRealEndTag) {
+          outerParts.push(softline);
+        }
+        if (endTag) {
+          outerParts.push(formatEndTag(endTag));
+        }
+        return group(concat(outerParts));
+      }
+    }
     let prevEnd = startTag ? startTag.endIndex : -1;
     for (const child of contentNodes) {
       if (prevEnd >= 0 && child.startIndex > prevEnd) {
@@ -2579,7 +2644,7 @@ function formatHtmlElement(node, context) {
           parts.push(text(" "));
         }
       }
-      parts.push(formatNode(child, context));
+      parts.push(formatNode(child, context, forceInline));
       prevEnd = child.endIndex;
     }
   } else {
@@ -2594,6 +2659,21 @@ function formatHtmlElement(node, context) {
         return isWhitespaceInsensitive(childDisplay) || isRawContentElement(child);
       });
       if (isBlock && !hasBlockChildren) {
+        const hasAttrs = startTag && startTagHasAttributes(startTag);
+        if (hasAttrs && startTag) {
+          const bareStartTag = formatStartTag(startTag, context, true);
+          const outerParts = [
+            group(bareStartTag),
+            indent(concat([softline, formattedContent]))
+          ];
+          if (hasRealEndTag) {
+            outerParts.push(softline);
+          }
+          if (endTag) {
+            outerParts.push(formatEndTag(endTag));
+          }
+          return group(concat(outerParts));
+        }
         const doc = group(
           concat([
             indent(concat([softline, formattedContent])),
@@ -2656,7 +2736,7 @@ function formatScriptStyleElement(node, context) {
         if (node.type === "html_raw_element") {
           const startTagNode = node.child(0);
           const tagNameLower = startTagNode?.type === "html_start_tag" ? getTagNameFromStartTag(startTagNode) : null;
-          const tagConfig = tagNameLower ? context.customCodeTagConfigs?.get(tagNameLower) : void 0;
+          const tagConfig = tagNameLower ? context.customTags?.get(tagNameLower) : void 0;
           if (tagConfig && resolveIndentMode(node, tagConfig)) {
             const dedented = dedentContent(child.text);
             if (dedented.length > 0) {
@@ -2733,27 +2813,74 @@ function formatMustacheSection(node, context) {
     parts.push(text(mustacheText(beginNode.text, context)));
   }
   const hasImplicit = hasImplicitEndTags(contentNodes);
-  const formattedContent = formatBlockChildren(contentNodes, context);
-  const hasContent = hasDocContent(formattedContent);
-  if (hasContent) {
-    if (hasImplicit) {
-      parts.push(hardline);
-      parts.push(formattedContent);
-      parts.push(hardline);
-    } else {
-      const hasBlockChildren = contentNodes.some((child, i) => {
-        if (!shouldTreatAsBlock(child, i, contentNodes, context.customCodeTags)) {
-          return false;
+  const erroneousCount = contentNodes.filter((n) => n.type === "html_erroneous_end_tag").length;
+  const hasStaircase = !hasImplicit && erroneousCount > 0;
+  if (hasStaircase) {
+    let virtualDepth = erroneousCount - 1;
+    const groupNodes = [];
+    let lastNodeEnd = -1;
+    let pendingBlankLine = false;
+    let groupBlankLine = false;
+    const emitGroup = () => {
+      if (groupNodes.length === 0) return;
+      const formatted = formatBlockChildren(groupNodes, context);
+      if (hasDocContent(formatted)) {
+        if (groupBlankLine) parts.push("\n");
+        const depth = Math.max(0, virtualDepth + 1);
+        parts.push(depth > 0 ? indentN(concat([hardline, formatted]), depth) : concat([hardline, formatted]));
+      }
+      groupNodes.length = 0;
+      groupBlankLine = false;
+    };
+    for (const node2 of contentNodes) {
+      if (lastNodeEnd >= 0 && node2.startIndex > lastNodeEnd) {
+        const gap = context.document.getText().slice(lastNodeEnd, node2.startIndex);
+        if ((gap.match(/\n/g) || []).length >= 2) {
+          pendingBlankLine = true;
         }
-        const childDisplay = getCSSDisplay(child, context.customCodeTags);
-        return isWhitespaceInsensitive(childDisplay) || isRawContentElement(child);
-      });
-      if (!hasBlockChildren) {
-        parts.push(indent(concat([softline, formattedContent])));
-        parts.push(softline);
+      }
+      if (node2.type === "html_erroneous_end_tag") {
+        emitGroup();
+        if (pendingBlankLine) parts.push("\n");
+        pendingBlankLine = false;
+        const formatted = formatNode(node2, context);
+        const depth = Math.max(0, virtualDepth);
+        parts.push(depth > 0 ? indentN(concat([hardline, formatted]), depth) : concat([hardline, formatted]));
+        virtualDepth--;
       } else {
-        parts.push(indent(concat([hardline, formattedContent])));
+        if (groupNodes.length === 0) {
+          groupBlankLine = pendingBlankLine;
+          pendingBlankLine = false;
+        }
+        groupNodes.push(node2);
+      }
+      lastNodeEnd = node2.endIndex;
+    }
+    emitGroup();
+    parts.push(hardline);
+  } else {
+    const formattedContent = formatBlockChildren(contentNodes, context);
+    const hasContent = hasDocContent(formattedContent);
+    if (hasContent) {
+      if (hasImplicit) {
+        parts.push(hardline);
+        parts.push(formattedContent);
         parts.push(hardline);
+      } else {
+        const hasBlockChildren = contentNodes.some((child, i) => {
+          if (!shouldTreatAsBlock(child, i, contentNodes, context.customTags)) {
+            return false;
+          }
+          const childDisplay = getCSSDisplay(child, context.customTags);
+          return isWhitespaceInsensitive(childDisplay) || isRawContentElement(child);
+        });
+        if (!hasBlockChildren) {
+          parts.push(indent(concat([softline, formattedContent])));
+          parts.push(softline);
+        } else {
+          parts.push(indent(concat([hardline, formattedContent])));
+          parts.push(hardline);
+        }
       }
     }
   }
@@ -2762,7 +2889,17 @@ function formatMustacheSection(node, context) {
   }
   return group(concat(parts));
 }
-function formatStartTag(node, context) {
+function startTagHasAttributes(startTag) {
+  for (let i = 0; i < startTag.childCount; i++) {
+    const child = startTag.child(i);
+    if (!child) continue;
+    if (child.type === "html_attribute" || child.type === "mustache_attribute" || child.type === "mustache_interpolation" || child.type === "mustache_triple") {
+      return true;
+    }
+  }
+  return false;
+}
+function formatStartTag(node, context, bare = false) {
   let tagNameText = "";
   const attrs = [];
   for (let i = 0; i < node.childCount; i++) {
@@ -2795,14 +2932,13 @@ function formatStartTag(node, context) {
     attrParts.push(attrs[i]);
   }
   const breakClosingBracket = isSelfClosing ? "/>" : ">";
-  return group(
-    concat([
-      text("<"),
-      text(tagNameText),
-      indent(concat([line, concat(attrParts)])),
-      ifBreak(concat([hardline, text(breakClosingBracket)]), text(closingBracket))
-    ])
-  );
+  const inner = concat([
+    text("<"),
+    text(tagNameText),
+    indent(concat([line, concat(attrParts)])),
+    ifBreak(concat([hardline, text(breakClosingBracket)]), text(closingBracket))
+  ]);
+  return bare ? inner : group(inner);
 }
 function formatEndTag(node) {
   for (let i = 0; i < node.childCount; i++) {
@@ -2847,6 +2983,38 @@ function textWords(str) {
   }
   return parts;
 }
+function collapseDelimitedRegions(parts, delimiters) {
+  if (delimiters.length === 0) return parts;
+  const sorted = [...delimiters].sort((a, b) => b.length - a.length);
+  const result = [...parts];
+  let activeDelimiter = null;
+  for (let i = 0; i < result.length; i++) {
+    const part = result[i];
+    if (typeof part === "string") {
+      if (activeDelimiter === null) {
+        for (const delim of sorted) {
+          const delimIdx = part.indexOf(delim);
+          if (delimIdx >= 0) {
+            const afterOpen = delimIdx + delim.length;
+            const closeIdx = part.indexOf(delim, afterOpen);
+            if (closeIdx >= 0) {
+              continue;
+            }
+            activeDelimiter = delim;
+            break;
+          }
+        }
+      } else {
+        if (part.includes(activeDelimiter)) {
+          activeDelimiter = null;
+        }
+      }
+    } else if (activeDelimiter !== null && isLine(part)) {
+      result[i] = " ";
+    }
+  }
+  return result;
+}
 function inlineContentToFill(parts) {
   if (parts.length === 0) return empty;
   if (parts.length === 1) return parts[0];
@@ -2889,6 +3057,11 @@ function formatBlockChildren(nodes, context) {
   let ignoreNext = false;
   let inIgnoreRegion = false;
   let ignoreRegionStartIndex = -1;
+  const noBreakDelims = context.noBreakDelimiters;
+  function flushCurrentLine() {
+    const parts2 = noBreakDelims ? collapseDelimitedRegions(currentLine, noBreakDelims) : currentLine;
+    return inlineContentToFill(parts2);
+  }
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd && !inIgnoreRegion) {
@@ -2901,7 +3074,7 @@ function formatBlockChildren(nodes, context) {
     const directive = getIgnoreDirective(node);
     if (directive === "ignore-end" && inIgnoreRegion) {
       if (currentLine.length > 0) {
-        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        const lineContent = trimDoc(flushCurrentLine());
         if (hasDocContent(lineContent)) {
           lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
         }
@@ -2925,7 +3098,7 @@ function formatBlockChildren(nodes, context) {
     }
     if (directive === "ignore-start") {
       if (currentLine.length > 0) {
-        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        const lineContent = trimDoc(flushCurrentLine());
         if (hasDocContent(lineContent)) {
           lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
         }
@@ -2942,7 +3115,7 @@ function formatBlockChildren(nodes, context) {
     }
     if (directive === "ignore") {
       if (currentLine.length > 0) {
-        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        const lineContent = trimDoc(flushCurrentLine());
         if (hasDocContent(lineContent)) {
           lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
         }
@@ -2963,10 +3136,10 @@ function formatBlockChildren(nodes, context) {
       lastNodeEnd = node.endIndex;
       continue;
     }
-    const treatAsBlock = shouldTreatAsBlock(node, i, nodes, context.customCodeTags);
+    const treatAsBlock = shouldTreatAsBlock(node, i, nodes, context.customTags);
     if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
       const prevNode = nodes[i - 1];
-      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes, context.customCodeTags);
+      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes, context.customTags);
       if (!prevTreatAsBlock && !treatAsBlock) {
         const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
         if (/\s/.test(gap)) {
@@ -2976,7 +3149,7 @@ function formatBlockChildren(nodes, context) {
     }
     if (treatAsBlock) {
       if (currentLine.length > 0) {
-        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        const lineContent = trimDoc(flushCurrentLine());
         if (hasDocContent(lineContent)) {
           lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
         }
@@ -2989,7 +3162,7 @@ function formatBlockChildren(nodes, context) {
       const isMultiline = node.startPosition.row !== node.endPosition.row;
       if (isMultiline) {
         if (currentLine.length > 0) {
-          const lineContent = trimDoc(inlineContentToFill(currentLine));
+          const lineContent = trimDoc(flushCurrentLine());
           if (hasDocContent(lineContent)) {
             lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
           }
@@ -3022,7 +3195,7 @@ function formatBlockChildren(nodes, context) {
             const trimmed = contentLines[j].trim();
             if (!trimmed) {
               if (currentLine.length > 0) {
-                const lineContent = trimDoc(inlineContentToFill(currentLine));
+                const lineContent = trimDoc(flushCurrentLine());
                 if (hasDocContent(lineContent)) {
                   lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
                   blankLineBeforeCurrentLine = false;
@@ -3047,7 +3220,7 @@ function formatBlockChildren(nodes, context) {
             currentLine.push(firstTrimmed);
           }
           if (currentLine.length > 0) {
-            const lineContent = trimDoc(inlineContentToFill(currentLine));
+            const lineContent = trimDoc(flushCurrentLine());
             if (hasDocContent(lineContent)) {
               lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
               blankLineBeforeCurrentLine = pendingBlankLine;
@@ -3101,7 +3274,7 @@ function formatBlockChildren(nodes, context) {
     }
   }
   if (currentLine.length > 0) {
-    const lineContent = trimDoc(inlineContentToFill(currentLine));
+    const lineContent = trimDoc(flushCurrentLine());
     if (hasDocContent(lineContent)) {
       lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
     }
@@ -3193,21 +3366,28 @@ function createIndentUnit(options) {
 }
 
 // lsp/server/src/formatting/index.ts
+function buildCustomTagMap(customTags) {
+  if (!customTags || customTags.length === 0) return void 0;
+  const map = /* @__PURE__ */ new Map();
+  for (const config of customTags) {
+    map.set(config.name.toLowerCase(), config);
+  }
+  return map;
+}
 function formatDocument2(tree, document, options, params = {}) {
-  const { customCodeTags, printWidth = 80, embeddedFormatted, mustacheSpaces, customCodeTagConfigs, configFile } = params;
+  const { printWidth = 80, embeddedFormatted, mustacheSpaces, noBreakDelimiters, configFile } = params;
   const mergedOptions = mergeOptions(options, document.uri, configFile);
   const indentUnit = createIndentUnit(mergedOptions);
   if (tree.rootNode.hasError) {
     return [];
   }
-  const configMap = buildConfigMap(customCodeTagConfigs);
-  const customCodeTagSet = customCodeTags ? new Set(customCodeTags.map((t) => t.toLowerCase())) : void 0;
+  const customTagMap = buildCustomTagMap(params.customTags);
   const context = {
     document,
-    customCodeTags: customCodeTagSet,
-    customCodeTagConfigs: configMap,
+    customTags: customTagMap,
     embeddedFormatted,
-    mustacheSpaces
+    mustacheSpaces,
+    noBreakDelimiters
   };
   const doc = formatDocument(tree.rootNode, context);
   const formatted = print(doc, { indentUnit, printWidth });
@@ -3217,14 +3397,6 @@ function formatDocument2(tree, document, options, params = {}) {
   };
   return [{ range: fullRange, newText: formatted }];
 }
-function buildConfigMap(configs) {
-  if (!configs || configs.length === 0) return void 0;
-  const map = /* @__PURE__ */ new Map();
-  for (const config of configs) {
-    map.set(config.name.toLowerCase(), config);
-  }
-  return map;
-}
 
 // cli/src/format.ts
 var USAGE2 = `Usage: htmlmustache format [options] [patterns...]
@@ -3303,17 +3475,16 @@ function resolveSettings(flags, filePath) {
   let insertSpaces = true;
   let printWidth = 80;
   let mustacheSpaces = false;
-  let customCodeTags;
-  let customCodeTagConfigs;
+  let customTags;
   const configFile = filePath ? loadConfigFileForPath(filePath) : null;
+  let noBreakDelimiters;
   if (configFile) {
     if (configFile.indentSize !== void 0) tabSize = configFile.indentSize;
     if (configFile.printWidth !== void 0) printWidth = configFile.printWidth;
     if (configFile.mustacheSpaces !== void 0) mustacheSpaces = configFile.mustacheSpaces;
-    if (configFile.customCodeTags && configFile.customCodeTags.length > 0) {
-      const parsed = parseCustomCodeTagSettings(configFile.customCodeTags);
-      customCodeTags = parsed.tagNames;
-      customCodeTagConfigs = parsed.configs;
+    if (configFile.noBreakDelimiters) noBreakDelimiters = configFile.noBreakDelimiters;
+    if (configFile.customTags && configFile.customTags.length > 0) {
+      customTags = configFile.customTags;
     }
   }
   if (filePath) {
@@ -3329,8 +3500,8 @@ function resolveSettings(flags, filePath) {
     options: { tabSize, insertSpaces },
     printWidth,
     mustacheSpaces,
-    customCodeTags,
-    customCodeTagConfigs,
+    noBreakDelimiters,
+    customTags,
     configFile
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",

package/tree-sitter.json

@@ -13,7 +13,7 @@
     }
   ],
   "metadata": {
-    "version": "0.4.0",
+    "version": "0.4.1",
     "license": "MIT",
     "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
     "authors": [