@reteps/tree-sitter-htmlmustache 0.2.0 → 0.3.0

package/cli/out/main.js

@@ -1715,16 +1715,39 @@ function loadConfigFileForPath(filePath) {
   }
 }
 
-// lsp/server/src/htmlBalanceChecker.ts
-function getTagName(element) {
-  const startTag = element.children.find((c) => c.type === "html_start_tag");
-  if (!startTag) return null;
-  const tagNameNode = startTag.children.find((c) => c.type === "html_tag_name");
-  return tagNameNode?.text?.toLowerCase() ?? null;
+// lsp/server/src/nodeHelpers.ts
+var MUSTACHE_SECTION_TYPES = /* @__PURE__ */ new Set([
+  "mustache_section",
+  "mustache_inverted_section"
+]);
+var RAW_CONTENT_ELEMENT_TYPES = /* @__PURE__ */ new Set([
+  "html_script_element",
+  "html_style_element",
+  "html_raw_element"
+]);
+var HTML_ELEMENT_TYPES = /* @__PURE__ */ new Set([
+  "html_element",
+  "html_script_element",
+  "html_style_element",
+  "html_raw_element"
+]);
+function isMustacheSection(node) {
+  return MUSTACHE_SECTION_TYPES.has(node.type);
 }
-function getErroneousEndTagName(node) {
-  const nameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
-  return nameNode?.text?.toLowerCase() ?? null;
+function isRawContentElement(node) {
+  return RAW_CONTENT_ELEMENT_TYPES.has(node.type);
+}
+function isHtmlElementType(node) {
+  return HTML_ELEMENT_TYPES.has(node.type);
+}
+function getTagName(node) {
+  for (const child of node.children) {
+    if (child.type === "html_start_tag" || child.type === "html_self_closing_tag") {
+      const tagNameNode = child.children.find((c) => c.type === "html_tag_name");
+      if (tagNameNode) return tagNameNode.text;
+    }
+  }
+  return null;
 }
 function getSectionName(node) {
   const beginNode = node.children.find(
@@ -1734,6 +1757,18 @@ function getSectionName(node) {
   const tagNameNode = beginNode.children.find((c) => c.type === "mustache_tag_name");
   return tagNameNode?.text ?? null;
 }
+function getErroneousEndTagName(node) {
+  const nameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
+  return nameNode?.text?.toLowerCase() ?? null;
+}
+
+// lsp/server/src/htmlBalanceChecker.ts
+function getTagNameLower(element) {
+  return getTagName(element)?.toLowerCase() ?? null;
+}
+function getErroneousEndTagNameLower(node) {
+  return getErroneousEndTagName(node)?.toLowerCase() ?? null;
+}
 function hasForcedEndTag(element) {
   return element.children.some((c) => c.type === "html_forced_end_tag");
 }
@@ -1750,7 +1785,7 @@ function extractFromNode(node) {
       (c) => c.type !== "html_start_tag" && c.type !== "html_end_tag" && c.type !== "html_forced_end_tag"
     );
     if (hasForcedEndTag(node)) {
-      const tagName = getTagName(node);
+      const tagName = getTagNameLower(node);
       const items = [];
       if (tagName) {
         const startTag = node.children.find((c) => c.type === "html_start_tag");
@@ -1765,7 +1800,7 @@ function extractFromNode(node) {
     return [];
   }
   if (node.type === "html_erroneous_end_tag") {
-    const tagName = getErroneousEndTagName(node);
+    const tagName = getErroneousEndTagNameLower(node);
     if (tagName) {
       return [{ type: "close", tagName, node }];
     }
@@ -1967,7 +2002,7 @@ function checkUnclosedTags(rootNode) {
       const hasEndTag = node.children.some((c) => c.type === "html_end_tag");
       const hasForcedEnd = node.children.some((c) => c.type === "html_forced_end_tag");
       if (!hasEndTag && !hasForcedEnd) {
-        const tagName = getTagName(node);
+        const tagName = getTagNameLower(node);
         if (tagName && !VOID_ELEMENTS.has(tagName) && !OPTIONAL_END_TAG_ELEMENTS.has(tagName)) {
           const startTag = node.children.find((c) => c.type === "html_start_tag");
           errors.push({
@@ -2017,7 +2052,7 @@ function checkHtmlBalance(rootNode) {
 function checkNestedSameNameSections(rootNode) {
   const errors = [];
   function visit(node, ancestors) {
-    if (node.type === "mustache_section" || node.type === "mustache_inverted_section") {
+    if (isMustacheSection(node)) {
       const name = getSectionName(node);
       if (name) {
         if (ancestors.has(name)) {
@@ -2077,7 +2112,7 @@ function checkConsecutiveSameNameSections(rootNode, sourceText) {
     for (let i = 0; i < children.length - 1; i++) {
       const current = children[i];
       const next = children[i + 1];
-      if (current.type !== "mustache_section" && current.type !== "mustache_inverted_section" || current.type !== next.type) {
+      if (!isMustacheSection(current) || current.type !== next.type) {
         continue;
       }
       const currentName = getSectionName(current);
@@ -2113,8 +2148,152 @@ function checkConsecutiveSameNameSections(rootNode, sourceText) {
   visit(rootNode);
   return errors;
 }
+var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "isindex",
+  "keygen",
+  "link",
+  "menuitem",
+  "meta",
+  "nextid",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function checkSelfClosingNonVoidTags(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_self_closing_tag") {
+      const tagNameNode = node.children.find((c) => c.type === "html_tag_name");
+      const tagName = tagNameNode?.text.toLowerCase();
+      if (tagName && !VOID_ELEMENTS2.has(tagName)) {
+        errors.push({
+          node,
+          message: `Self-closing non-void element: <${tagNameNode.text}/>`,
+          fix: [{
+            startIndex: node.startIndex,
+            endIndex: node.endIndex,
+            newText: node.text.replace(/\s*\/>$/, ">") + `</${tagNameNode.text}>`
+          }],
+          fixDescription: "Replace self-closing syntax with explicit close tag"
+        });
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+function areMutuallyExclusive(a, b) {
+  for (const ac of a) {
+    for (const bc of b) {
+      if (ac.name === bc.name && ac.inverted !== bc.inverted) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatConditionClause(a, b) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of [...a, ...b]) {
+    if (!seen.has(c.name)) {
+      seen.set(c.name, c.inverted);
+    }
+  }
+  if (seen.size === 0) return "";
+  const parts = [];
+  for (const [name, inverted] of seen) {
+    parts.push(`${name} is ${inverted ? "falsy" : "truthy"}`);
+  }
+  return ` (when ${parts.join(", ")})`;
+}
+function collectAttributes(node, conditions, out) {
+  for (const child of node.children) {
+    if (child.type === "html_attribute") {
+      const nameNode = child.children.find((c) => c.type === "html_attribute_name");
+      if (nameNode) {
+        out.push({ nameNode, conditions: [...conditions] });
+      }
+    } else if (child.type === "mustache_attribute") {
+      const section = child.children.find((c) => isMustacheSection(c));
+      if (section) {
+        const name = getSectionName(section);
+        if (name) {
+          const inverted = section.type === "mustache_inverted_section";
+          collectAttributes(section, [...conditions, { name, inverted }], out);
+        }
+      }
+    }
+  }
+}
+function checkDuplicateAttributes(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_start_tag" || node.type === "html_self_closing_tag") {
+      const occurrences = [];
+      collectAttributes(node, [], occurrences);
+      const groups = /* @__PURE__ */ new Map();
+      for (const occ of occurrences) {
+        const key = occ.nameNode.text.toLowerCase();
+        let group2 = groups.get(key);
+        if (!group2) {
+          group2 = [];
+          groups.set(key, group2);
+        }
+        group2.push(occ);
+      }
+      for (const [, group2] of groups) {
+        if (group2.length < 2) continue;
+        for (let i = 1; i < group2.length; i++) {
+          let conflictIdx = -1;
+          for (let j = 0; j < i; j++) {
+            if (!areMutuallyExclusive(group2[i].conditions, group2[j].conditions)) {
+              conflictIdx = j;
+              break;
+            }
+          }
+          if (conflictIdx >= 0) {
+            const clause = formatConditionClause(group2[conflictIdx].conditions, group2[i].conditions);
+            errors.push({
+              node: group2[i].nameNode,
+              message: `Duplicate attribute "${group2[i].nameNode.text}"${clause}`
+            });
+          }
+        }
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
 
-// cli/src/check.ts
+// lsp/server/src/collectErrors.ts
+var ERROR_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ERROR",
+  "mustache_erroneous_section_end",
+  "mustache_erroneous_inverted_section_end"
+]);
 function errorMessageForNode(nodeType, node) {
   if (nodeType === "mustache_erroneous_section_end" || nodeType === "mustache_erroneous_inverted_section_end") {
     const tagNameNode = node.children.find((c) => c.type === "mustache_erroneous_tag_name");
@@ -2125,12 +2304,7 @@ function errorMessageForNode(nodeType, node) {
   }
   return `Missing ${nodeType}`;
 }
-var ERROR_NODE_TYPES = /* @__PURE__ */ new Set([
-  "ERROR",
-  "mustache_erroneous_section_end",
-  "mustache_erroneous_inverted_section_end"
-]);
-function collectErrors(tree, file) {
+function collectErrors(tree) {
   const errors = [];
   const cursor = tree.walk();
   function visit() {
@@ -2138,13 +2312,8 @@ function collectErrors(tree, file) {
     const nodeType = cursor.nodeType;
     if (ERROR_NODE_TYPES.has(nodeType) || cursor.nodeIsMissing) {
       errors.push({
-        file,
-        line: node.startPosition.row + 1,
-        column: node.startPosition.column + 1,
-        endLine: node.endPosition.row + 1,
-        endColumn: node.endPosition.column + 1,
-        message: errorMessageForNode(nodeType, node),
-        nodeText: node.text
+        node,
+        message: errorMessageForNode(nodeType, node)
       });
       if (nodeType === "ERROR") return;
     }
@@ -2156,46 +2325,26 @@ function collectErrors(tree, file) {
     }
   }
   visit();
-  const rootNode = tree.rootNode;
-  const balanceErrors = checkHtmlBalance(rootNode);
+  const balanceErrors = checkHtmlBalance(tree.rootNode);
   for (const error of balanceErrors) {
-    errors.push({
-      file,
-      line: error.node.startPosition.row + 1,
-      column: error.node.startPosition.column + 1,
-      endLine: error.node.endPosition.row + 1,
-      endColumn: error.node.endPosition.column + 1,
-      message: error.message,
-      nodeText: error.node.text
-    });
+    errors.push({ node: error.node, message: error.message });
   }
-  const unclosedErrors = checkUnclosedTags(rootNode);
+  const unclosedErrors = checkUnclosedTags(tree.rootNode);
   for (const error of unclosedErrors) {
-    errors.push({
-      file,
-      line: error.node.startPosition.row + 1,
-      column: error.node.startPosition.column + 1,
-      endLine: error.node.endPosition.row + 1,
-      endColumn: error.node.endPosition.column + 1,
-      message: error.message,
-      nodeText: error.node.text
-    });
+    errors.push({ node: error.node, message: error.message });
   }
-  const sourceText = rootNode.text;
+  const sourceText = tree.rootNode.text;
   const mustacheChecks = [
-    ...checkNestedSameNameSections(rootNode),
-    ...checkUnquotedMustacheAttributes(rootNode),
-    ...checkConsecutiveSameNameSections(rootNode, sourceText)
+    ...checkNestedSameNameSections(tree.rootNode),
+    ...checkUnquotedMustacheAttributes(tree.rootNode),
+    ...checkConsecutiveSameNameSections(tree.rootNode, sourceText),
+    ...checkSelfClosingNonVoidTags(tree.rootNode),
+    ...checkDuplicateAttributes(tree.rootNode)
   ];
   for (const error of mustacheChecks) {
     errors.push({
-      file,
-      line: error.node.startPosition.row + 1,
-      column: error.node.startPosition.column + 1,
-      endLine: error.node.endPosition.row + 1,
-      endColumn: error.node.endPosition.column + 1,
+      node: error.node,
       message: error.message,
-      nodeText: error.node.text,
       severity: error.severity,
       fix: error.fix,
       fixDescription: error.fixDescription
@@ -2203,6 +2352,23 @@ function collectErrors(tree, file) {
   }
   return errors;
 }
+
+// cli/src/check.ts
+function collectErrors2(tree, file) {
+  const errors = collectErrors(tree);
+  return errors.map((error) => ({
+    file,
+    line: error.node.startPosition.row + 1,
+    column: error.node.startPosition.column + 1,
+    endLine: error.node.endPosition.row + 1,
+    endColumn: error.node.endPosition.column + 1,
+    message: error.message,
+    nodeText: error.node.text,
+    severity: error.severity,
+    fix: error.fix,
+    fixDescription: error.fixDescription
+  }));
+}
 function formatError(error, source) {
   const lines = source.split("\n");
   const errorLine = error.line - 1;
@@ -2377,7 +2543,7 @@ async function run(args) {
     let source = import_node_fs.default.readFileSync(file, "utf-8");
     if (fixMode) {
       const tree2 = parseDocument(source);
-      const errors2 = collectErrors(tree2, displayPath);
+      const errors2 = collectErrors2(tree2, displayPath);
       const fixed = applyFixes(source, errors2);
       if (fixed !== source) {
         import_node_fs.default.writeFileSync(file, fixed, "utf-8");
@@ -2385,7 +2551,7 @@ async function run(args) {
       }
     }
     const tree = parseDocument(source);
-    const errors = collectErrors(tree, displayPath);
+    const errors = collectErrors2(tree, displayPath);
     const fileErrors = errors.filter((e) => e.severity !== "warning");
     const fileWarnings = errors.filter((e) => e.severity === "warning");
     if (errors.length > 0) {
@@ -2828,21 +2994,6 @@ function isLine(doc) {
 }
 
 // lsp/server/src/formatting/utils.ts
-function getTagName2(node) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (!child) continue;
-    if (child.type === "html_start_tag" || child.type === "html_self_closing_tag") {
-      for (let j = 0; j < child.childCount; j++) {
-        const tagChild = child.child(j);
-        if (tagChild && tagChild.type === "html_tag_name") {
-          return tagChild.text;
-        }
-      }
-    }
-  }
-  return null;
-}
 function normalizeText(text2) {
   return text2.split("\n").map((line2) => line2.replace(/[ \t]+/g, " ").trim()).filter((line2, i, arr) => line2 || i > 0 && i < arr.length - 1).join("\n");
 }
@@ -2919,10 +3070,7 @@ function getIgnoreDirective(node) {
 }
 
 // lsp/server/src/formatting/classifier.ts
-var customCodeTags = /* @__PURE__ */ new Set();
-function setCustomCodeTags(tags) {
-  customCodeTags = new Set(tags.map((t) => t.toLowerCase()));
-}
+var EMPTY_SET = /* @__PURE__ */ new Set();
 var CSS_DISPLAY_MAP = {
   // Block elements
   address: "block",
@@ -3013,10 +3161,10 @@ var PRESERVE_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
   "script",
   "style"
 ]);
-function getCSSDisplay(node) {
+function getCSSDisplay(node, customCodeTags = EMPTY_SET) {
   const type = node.type;
   if (type === "html_element") {
-    const tagName = getTagName2(node);
+    const tagName = getTagName(node);
     if (tagName) {
       if (customCodeTags.has(tagName.toLowerCase())) {
         return "block";
@@ -3025,11 +3173,11 @@ function getCSSDisplay(node) {
     }
     return "block";
   }
-  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+  if (isRawContentElement(node)) {
     return "block";
   }
-  if (type === "mustache_section" || type === "mustache_inverted_section") {
-    return hasBlockContent(node) ? "block" : "inline";
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customCodeTags) ? "block" : "inline";
   }
   return "inline";
 }
@@ -3052,55 +3200,55 @@ function isWhitespaceInsensitive(display) {
       return false;
   }
 }
-function isBlockLevel(node) {
+function isBlockLevel(node, customCodeTags = EMPTY_SET) {
   const type = node.type;
-  if (type === "mustache_section" || type === "mustache_inverted_section") {
-    return hasBlockContent(node);
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customCodeTags);
   }
   if (type === "html_element") {
-    const display = getCSSDisplay(node);
+    const display = getCSSDisplay(node, customCodeTags);
     return isWhitespaceInsensitive(display);
   }
-  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+  if (isRawContentElement(node)) {
     return true;
   }
   return false;
 }
-function shouldPreserveContent(node) {
+function shouldPreserveContent(node, customCodeTags = EMPTY_SET) {
   const type = node.type;
-  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+  if (isRawContentElement(node)) {
     return true;
   }
   if (type === "html_element") {
-    const tagName = getTagName2(node);
+    const tagName = getTagName(node);
     if (!tagName) return false;
     const lower = tagName.toLowerCase();
     return PRESERVE_CONTENT_ELEMENTS.has(lower) || customCodeTags.has(lower);
   }
   return false;
 }
-function hasBlockContent(sectionNode) {
+function hasBlockContent(sectionNode, customCodeTags = EMPTY_SET) {
   const contentNodes = getContentNodes(sectionNode);
   if (hasImplicitEndTags(contentNodes)) {
     return true;
   }
   for (const node of contentNodes) {
-    if (isBlockLevelContent(node)) {
+    if (isBlockLevelContent(node, customCodeTags)) {
       return true;
     }
   }
   return false;
 }
-function isBlockLevelContent(node) {
+function isBlockLevelContent(node, customCodeTags = EMPTY_SET) {
   const type = node.type;
   if (type === "html_element") {
     return true;
   }
-  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+  if (isRawContentElement(node)) {
     return true;
   }
-  if (type === "mustache_section" || type === "mustache_inverted_section") {
-    return hasBlockContent(node);
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customCodeTags);
   }
   return false;
 }
@@ -3207,10 +3355,10 @@ function shouldHtmlElementStayInline(node, index, nodes) {
   }
   return false;
 }
-function shouldTreatAsBlock(node, index, nodes) {
-  const isHtmlElement = node.type === "html_element" || node.type === "html_script_element" || node.type === "html_style_element" || node.type === "html_raw_element";
-  const isMustacheSection = node.type === "mustache_section" || node.type === "mustache_inverted_section";
-  return isHtmlElement && !shouldHtmlElementStayInline(node, index, nodes) || isMustacheSection && !isInTextFlow(node, index, nodes) || isBlockLevel(node) && !isInTextFlow(node, index, nodes);
+function shouldTreatAsBlock(node, index, nodes, customCodeTags = EMPTY_SET) {
+  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
@@ -3353,9 +3501,10 @@ function formatText(node) {
   return text(normalizeText(node.text));
 }
 function formatHtmlElement(node, context) {
-  const display = getCSSDisplay(node);
+  const tags = context.customCodeTags;
+  const display = getCSSDisplay(node, tags);
   const isBlock = isWhitespaceInsensitive(display);
-  const preserveContent = shouldPreserveContent(node);
+  const preserveContent = shouldPreserveContent(node, tags);
   const selfClosing = node.childCount === 1 && node.child(0)?.type === "html_self_closing_tag";
   if (selfClosing) {
     const tag = node.child(0);
@@ -3384,7 +3533,7 @@ function formatHtmlElement(node, context) {
     parts.push(formatStartTag(startTag, context));
   }
   const hasHtmlElementChildren = contentNodes.some(
-    (child) => child.type === "html_element" || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element" || isBlockLevel(child)
+    (child) => child.type === "html_element" || isRawContentElement(child) || isBlockLevel(child, tags)
   );
   if (preserveContent) {
     const tagNameLower = startTag ? getTagNameFromStartTag(startTag) : null;
@@ -3448,11 +3597,11 @@ function formatHtmlElement(node, context) {
     const hasContent = hasDocContent(formattedContent);
     if (hasContent) {
       const hasBlockChildren = contentNodes.some((child, i) => {
-        if (!shouldTreatAsBlock(child, i, contentNodes)) {
+        if (!shouldTreatAsBlock(child, i, contentNodes, tags)) {
           return false;
         }
-        const childDisplay = getCSSDisplay(child);
-        return isWhitespaceInsensitive(childDisplay) || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element";
+        const childDisplay = getCSSDisplay(child, tags);
+        return isWhitespaceInsensitive(childDisplay) || isRawContentElement(child);
       });
       if (isBlock && !hasBlockChildren) {
         const doc = group(
@@ -3603,11 +3752,11 @@ function formatMustacheSection(node, context) {
       parts.push(hardline);
     } else {
       const hasBlockChildren = contentNodes.some((child, i) => {
-        if (!shouldTreatAsBlock(child, i, contentNodes)) {
+        if (!shouldTreatAsBlock(child, i, contentNodes, context.customCodeTags)) {
           return false;
         }
-        const childDisplay = getCSSDisplay(child);
-        return isWhitespaceInsensitive(childDisplay) || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element";
+        const childDisplay = getCSSDisplay(child, context.customCodeTags);
+        return isWhitespaceInsensitive(childDisplay) || isRawContentElement(child);
       });
       if (!hasBlockChildren) {
         parts.push(indent(concat([softline, formattedContent])));
@@ -3824,10 +3973,10 @@ function formatBlockChildren(nodes, context) {
       lastNodeEnd = node.endIndex;
       continue;
     }
-    const treatAsBlock = shouldTreatAsBlock(node, i, nodes);
+    const treatAsBlock = shouldTreatAsBlock(node, i, nodes, context.customCodeTags);
     if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
       const prevNode = nodes[i - 1];
-      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes);
+      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes, context.customCodeTags);
       if (!prevTreatAsBlock && !treatAsBlock) {
         const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
         if (/\s/.test(gap)) {
@@ -4055,19 +4204,17 @@ function createIndentUnit(options) {
 
 // lsp/server/src/formatting/index.ts
 function formatDocument2(tree, document, options, params = {}) {
-  const { customCodeTags: customCodeTags2, printWidth = 80, embeddedFormatted, mustacheSpaces, customCodeTagConfigs, configFile } = params;
+  const { customCodeTags, printWidth = 80, embeddedFormatted, mustacheSpaces, customCodeTagConfigs, configFile } = params;
   const mergedOptions = mergeOptions(options, document.uri, configFile);
   const indentUnit = createIndentUnit(mergedOptions);
-  if (customCodeTags2) {
-    setCustomCodeTags(customCodeTags2);
-  }
   if (tree.rootNode.hasError) {
     return [];
   }
   const configMap = buildConfigMap(customCodeTagConfigs);
+  const customCodeTagSet = customCodeTags ? new Set(customCodeTags.map((t) => t.toLowerCase())) : void 0;
   const context = {
     document,
-    customCodeTags: customCodeTags2 ? new Set(customCodeTags2.map((t) => t.toLowerCase())) : void 0,
+    customCodeTags: customCodeTagSet,
     customCodeTagConfigs: configMap,
     embeddedFormatted,
     mustacheSpaces
@@ -4166,7 +4313,7 @@ function resolveSettings(flags, filePath) {
   let insertSpaces = true;
   let printWidth = 80;
   let mustacheSpaces = false;
-  let customCodeTags2;
+  let customCodeTags;
   let customCodeTagConfigs;
   const configFile = filePath ? loadConfigFileForPath(filePath) : null;
   if (configFile) {
@@ -4175,7 +4322,7 @@ function resolveSettings(flags, filePath) {
     if (configFile.mustacheSpaces !== void 0) mustacheSpaces = configFile.mustacheSpaces;
     if (configFile.customCodeTags && configFile.customCodeTags.length > 0) {
       const parsed = parseCustomCodeTagSettings(configFile.customCodeTags);
-      customCodeTags2 = parsed.tagNames;
+      customCodeTags = parsed.tagNames;
       customCodeTagConfigs = parsed.configs;
     }
   }
@@ -4192,7 +4339,7 @@ function resolveSettings(flags, filePath) {
     options: { tabSize, insertSpaces },
     printWidth,
     mustacheSpaces,
-    customCodeTags: customCodeTags2,
+    customCodeTags,
     customCodeTagConfigs,
     configFile
   };

package/package.json

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

package/src/scanner.c

@@ -83,7 +83,7 @@ static unsigned serialize(Scanner *scanner, char *buffer) {
     }
 
     memcpy(&buffer[0], &serialized_tag_count, sizeof(serialized_tag_count));
-    // printf("[S] serialized_tag_count: %d\n", serialized_tag_count);
+
     // Mustache tags
     uint16_t m_tag_count =
         scanner->mustache_tags.size > UINT16_MAX ? UINT16_MAX : scanner->mustache_tags.size;
@@ -93,7 +93,6 @@ static unsigned serialize(Scanner *scanner, char *buffer) {
     size += sizeof(m_serialized_tag_count);
     memcpy(&buffer[size], &m_tag_count, sizeof(m_tag_count));
     size += sizeof(m_tag_count);
-    // printf("[S] m_tag_count: %d\n", m_tag_count);
 
     for (; m_serialized_tag_count < m_tag_count; m_serialized_tag_count++) {
         MustacheTag tag = scanner->mustache_tags.contents[m_serialized_tag_count];
@@ -113,12 +112,10 @@ static unsigned serialize(Scanner *scanner, char *buffer) {
     }
 
     memcpy(&buffer[mustache_start_offset], &m_serialized_tag_count, sizeof(m_serialized_tag_count));
-    // printf("[S] m_serialized_tag_count: %d\n", m_serialized_tag_count);
     return size;
 }
 
 static void deserialize(Scanner *scanner, const char *buffer, unsigned length) {
-    // printf("deserialize\n");
     for (unsigned i = 0; i < scanner->tags.size; i++) {
         tag_free(&scanner->tags.contents[i]);
     }
@@ -195,22 +192,12 @@ static void deserialize(Scanner *scanner, const char *buffer, unsigned length) {
     }
 }
 
-static void print_tag_name(String *tag_name) {
-    // printf("tag_size: %d\n", tag->tag_name.size);
-    for (uint32_t i = 0; i < tag_name->size; i++) {
-        printf("%c", tag_name->contents[i]);
-    }
-}
-
 static String scan_html_tag_name(TSLexer *lexer) {
     String tag_name = array_new();
     while (iswalnum(lexer->lookahead) || lexer->lookahead == '-' || lexer->lookahead == ':') {
         array_push(&tag_name, towupper(lexer->lookahead));
         advance(lexer);
     }
-    // printf("tag_name: ");
-    // print_tag_name(&tag_name);
-    // printf("\n");
     return tag_name;
 }
 
@@ -431,8 +418,6 @@ static String scan_mustache_tag_name(Scanner *scanner, TSLexer *lexer) {
     array_push(&tag_name, lexer->lookahead);
     advance(lexer);
   }
-//   print_tag_name(&tag_name);
-//   printf("\n");
   return tag_name;
 }
 
@@ -445,17 +430,7 @@ static bool scan_mustache_start_tag_name(Scanner *scanner, TSLexer *lexer) {
     MustacheTag tag = mustache_tag_new();
     tag.tag_name = tag_name;
     tag.html_tag_stack_size = scanner->tags.size;
-    // printf("pushing tag: ");
-    // print_tag_name(&tag.tag_name);
-    // printf("\n");
     array_push(&scanner->mustache_tags, tag);
-    // printf("--------------------------------\n");
-    // for (unsigned i = 0; i < scanner->mustache_tags.size; i++) {
-    //   printf("\tSTACK (START), tag_name: ");
-    //   print_tag_name(&scanner->mustache_tags.contents[i]);
-    //   printf("\n");
-    // }
-    // printf("--------------------------------\n");
     lexer->result_symbol = MUSTACHE_START_TAG_NAME;
     return true;
 }
@@ -469,23 +444,11 @@ static bool scan_mustache_end_tag_name(Scanner *scanner, TSLexer *lexer) {
   }
 
 
-  // Print whole stack
-//   printf("--------------------------------\n");
-//   printf("num tags: %d\n", scanner->mustache_tags.size);
-//   for (unsigned i = 0; i < scanner->mustache_tags.size; i++) {
-//     printf("\tSTACK (END), tag_name: ");
-//     print_tag_name(&scanner->mustache_tags.contents[i].tag_name);
-//     printf("\n");
-//   }
-//   printf("--------------------------------\n");
   MustacheTag tag = mustache_tag_new();
   tag.tag_name = tag_name;
   if (scanner->mustache_tags.size > 0 && mustache_tag_eq(array_back(&scanner->mustache_tags), &tag)) {
     MustacheTag popped_tag = array_pop(&scanner->mustache_tags);
     mustache_tag_free(&popped_tag);
-    // printf("popped tag (correct): ");
-    // print_tag_name(&popped_tag.tag_name);
-    // printf("\n");
     lexer->result_symbol = MUSTACHE_END_TAG_NAME;
   } else {
     if (scanner->mustache_tags.size > 0) {
@@ -501,7 +464,6 @@ static bool scan_mustache_end_tag_name(Scanner *scanner, TSLexer *lexer) {
 
 static bool scan_mustache_end_tag_html_implicit_end_tag(Scanner *scanner, TSLexer *lexer) {
     lexer->mark_end(lexer);
-    // printf("next char: %c\n", lexer->lookahead);
     if (lexer->lookahead != '{') {
         return false;
     }
@@ -547,7 +509,6 @@ static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols) {
 
 
     if (valid_symbols[MUSTACHE_START_TAG_NAME]) {
-        // printf("MUSTACHE_START_TAG_NAME\n");
         return scan_mustache_start_tag_name(scanner, lexer);
     }