@reteps/tree-sitter-htmlmustache 0.8.1 → 0.9.1

package/browser/out/browser/index.mjs

@@ -0,0 +1,3746 @@
+// src/browser/index.ts
+import { Parser, Language } from "web-tree-sitter";
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+// src/core/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 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(
+    (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+  );
+  if (!beginNode) return null;
+  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;
+}
+function getInterpolationPath(node) {
+  for (const child of node.children) {
+    if (child.type === "mustache_path_expression" || child.type === "mustache_identifier") {
+      return child.text;
+    }
+    if (child.type === ".") return ".";
+  }
+  return null;
+}
+function getCommentContent(node) {
+  const child = node.children.find((c) => c.type === "mustache_comment_content");
+  return child ? child.text.trim() : null;
+}
+function getPartialName(node) {
+  const child = node.children.find((c) => c.type === "mustache_partial_content");
+  return child ? child.text.trim() : null;
+}
+
+// src/core/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");
+}
+function extractFromNodes(nodes) {
+  const items = [];
+  for (const node of nodes) {
+    items.push(...extractFromNode(node));
+  }
+  return items;
+}
+function extractFromNode(node) {
+  if (node.type === "html_element") {
+    const contentChildren = node.children.filter(
+      (c) => c.type !== "html_start_tag" && c.type !== "html_end_tag" && c.type !== "html_forced_end_tag"
+    );
+    if (hasForcedEndTag(node)) {
+      const tagName = getTagNameLower(node);
+      const items = [];
+      if (tagName) {
+        const startTag = node.children.find((c) => c.type === "html_start_tag");
+        items.push({ type: "open", tagName, node: startTag ?? node });
+      }
+      items.push(...extractFromNodes(contentChildren));
+      return items;
+    }
+    return extractFromNodes(contentChildren);
+  }
+  if (node.type === "html_self_closing_tag") {
+    return [];
+  }
+  if (node.type === "html_erroneous_end_tag") {
+    const tagName = getErroneousEndTagNameLower(node);
+    if (tagName) {
+      return [{ type: "close", tagName, node }];
+    }
+    return [];
+  }
+  if (node.type === "mustache_section") {
+    const sectionName = getSectionName(node);
+    if (sectionName) {
+      const contentChildren = node.children.filter(
+        (c) => c.type !== "mustache_section_begin" && c.type !== "mustache_section_end" && c.type !== "mustache_erroneous_section_end"
+      );
+      return [
+        {
+          type: "fork",
+          sectionName,
+          truthy: extractFromNodes(contentChildren),
+          falsy: []
+        }
+      ];
+    }
+    return [];
+  }
+  if (node.type === "mustache_inverted_section") {
+    const sectionName = getSectionName(node);
+    if (sectionName) {
+      const contentChildren = node.children.filter(
+        (c) => c.type !== "mustache_inverted_section_begin" && c.type !== "mustache_inverted_section_end" && c.type !== "mustache_erroneous_inverted_section_end"
+      );
+      return [
+        {
+          type: "fork",
+          sectionName,
+          truthy: [],
+          falsy: extractFromNodes(contentChildren)
+        }
+      ];
+    }
+    return [];
+  }
+  return extractFromNodes(node.children);
+}
+function mergeAdjacentForks(items) {
+  if (items.length === 0) return items;
+  const result = [];
+  let i = 0;
+  while (i < items.length) {
+    const item = items[i];
+    if (item.type !== "fork") {
+      result.push(item);
+      i++;
+      continue;
+    }
+    const truthy = [...item.truthy];
+    const falsy = [...item.falsy];
+    let j = i + 1;
+    while (j < items.length) {
+      const next = items[j];
+      if (next.type !== "fork" || next.sectionName !== item.sectionName) break;
+      truthy.push(...next.truthy);
+      falsy.push(...next.falsy);
+      j++;
+    }
+    result.push({
+      type: "fork",
+      sectionName: item.sectionName,
+      truthy: mergeAdjacentForks(truthy),
+      falsy: mergeAdjacentForks(falsy)
+    });
+    i = j;
+  }
+  return result;
+}
+function isBranchBalanced(items) {
+  const stack = [];
+  for (const item of items) {
+    if (item.type === "fork") {
+      if (!isBranchBalanced(item.truthy) || !isBranchBalanced(item.falsy)) {
+        return false;
+      }
+    } else if (item.type === "open") {
+      stack.push(item.tagName);
+    } else {
+      if (stack.length === 0 || stack[stack.length - 1] !== item.tagName) {
+        return false;
+      }
+      stack.pop();
+    }
+  }
+  return stack.length === 0;
+}
+function collectSectionNames(items) {
+  const names = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (item.type === "fork") {
+      if (!isBranchBalanced(item.truthy) || !isBranchBalanced(item.falsy)) {
+        names.add(item.sectionName);
+      }
+      for (const name of collectSectionNames(item.truthy)) names.add(name);
+      for (const name of collectSectionNames(item.falsy)) names.add(name);
+    }
+  }
+  return names;
+}
+function flattenPath(items, assignment) {
+  const events = [];
+  for (const item of items) {
+    if (item.type === "fork") {
+      const value = assignment.get(item.sectionName) ?? true;
+      const branch = value ? item.truthy : item.falsy;
+      events.push(...flattenPath(branch, assignment));
+    } else {
+      events.push(item);
+    }
+  }
+  return events;
+}
+function formatCondition(assignment) {
+  if (assignment.size === 0) return "";
+  const parts = [];
+  for (const [name, value] of assignment) {
+    parts.push(`${name} is ${value ? "truthy" : "falsy"}`);
+  }
+  return ` (when ${parts.join(", ")})`;
+}
+function validateBalance(events, condition) {
+  const errors = [];
+  const stack = [];
+  for (const event of events) {
+    if (event.type === "open") {
+      stack.push(event);
+    } else {
+      if (stack.length === 0) {
+        errors.push({
+          node: event.node,
+          message: `Mismatched HTML end tag: </${event.tagName}>${condition}`
+        });
+      } else {
+        const top = stack[stack.length - 1];
+        if (top.tagName !== event.tagName) {
+          errors.push({
+            node: event.node,
+            message: `Mismatched HTML end tag: </${event.tagName}>${condition}`
+          });
+        } else {
+          stack.pop();
+        }
+      }
+    }
+  }
+  for (const event of stack) {
+    errors.push({
+      node: event.node,
+      message: `Unclosed HTML tag: <${event.tagName}>${condition}`
+    });
+  }
+  return errors;
+}
+var VOID_ELEMENTS = /* @__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"
+]);
+var OPTIONAL_END_TAG_ELEMENTS = /* @__PURE__ */ new Set([
+  "li",
+  "dt",
+  "dd",
+  "p",
+  "colgroup",
+  "rb",
+  "rt",
+  "rp",
+  "rtc",
+  "optgroup",
+  "option",
+  "tr",
+  "td",
+  "th",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "html",
+  "head",
+  "body"
+]);
+function checkUnclosedTags(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_element") {
+      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 = 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({
+            node: startTag ?? node,
+            message: `Unclosed HTML tag: <${tagName}>`
+          });
+        }
+      }
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+var MAX_SECTION_NAMES = 15;
+function checkHtmlBalance(rootNode) {
+  const rawItems = extractFromNode(rootNode);
+  const items = mergeAdjacentForks(rawItems);
+  const sectionNames = [...collectSectionNames(items)];
+  if (sectionNames.length > MAX_SECTION_NAMES) {
+    return [];
+  }
+  const allErrors = [];
+  const errorNodes = /* @__PURE__ */ new Set();
+  const totalPaths = 1 << sectionNames.length;
+  for (let mask = 0; mask < totalPaths; mask++) {
+    const assignment = /* @__PURE__ */ new Map();
+    for (let i = 0; i < sectionNames.length; i++) {
+      assignment.set(sectionNames[i], (mask & 1 << i) !== 0);
+    }
+    const events = flattenPath(items, assignment);
+    const condition = formatCondition(assignment);
+    const pathErrors = validateBalance(events, condition);
+    for (const error of pathErrors) {
+      if (!errorNodes.has(error.node)) {
+        errorNodes.add(error.node);
+        allErrors.push(error);
+      }
+    }
+  }
+  return allErrors;
+}
+
+// src/core/mustacheChecks.ts
+function checkNestedSameNameSections(rootNode) {
+  const errors = [];
+  function visit(node, ancestors) {
+    if (isMustacheSection(node)) {
+      const name = getSectionName(node);
+      if (name) {
+        if (ancestors.has(name)) {
+          const beginNode = node.children.find(
+            (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+          );
+          errors.push({
+            node: beginNode ?? node,
+            message: `Nested duplicate section: {{#${name}}} is already open in an ancestor`
+          });
+        }
+        const next = new Set(ancestors);
+        next.add(name);
+        for (const child of node.children) {
+          visit(child, next);
+        }
+        return;
+      }
+    }
+    for (const child of node.children) {
+      visit(child, ancestors);
+    }
+  }
+  visit(rootNode, /* @__PURE__ */ new Set());
+  return errors;
+}
+function checkUnquotedMustacheAttributes(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_attribute") {
+      const mustacheNode = node.children.find((c) => c.type === "mustache_interpolation");
+      if (mustacheNode) {
+        errors.push({
+          node: mustacheNode,
+          message: `Unquoted mustache attribute value: ${mustacheNode.text}`,
+          fix: [{
+            startIndex: mustacheNode.startIndex,
+            endIndex: mustacheNode.endIndex,
+            newText: `"${mustacheNode.text}"`
+          }],
+          fixDescription: "Wrap mustache value in quotes"
+        });
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+function checkConsecutiveSameNameSections(rootNode, sourceText) {
+  const errors = [];
+  function visit(node) {
+    const children = node.children;
+    for (let i = 0; i < children.length - 1; i++) {
+      const current = children[i];
+      const next = children[i + 1];
+      if (!isMustacheSection(current) || current.type !== next.type) {
+        continue;
+      }
+      const currentName = getSectionName(current);
+      const nextName = getSectionName(next);
+      if (!currentName || !nextName || currentName !== nextName) continue;
+      const gap = sourceText.slice(current.endIndex, next.startIndex);
+      if (gap.length > 0 && !/^\s*$/.test(gap)) continue;
+      const endTagType = current.type === "mustache_section" ? "mustache_section_end" : "mustache_inverted_section_end";
+      const beginTagType = next.type === "mustache_section" ? "mustache_section_begin" : "mustache_inverted_section_begin";
+      const currentEndTag = current.children.find((c) => c.type === endTagType);
+      const nextBeginTag = next.children.find((c) => c.type === beginTagType);
+      if (!currentEndTag || !nextBeginTag) continue;
+      const sectionTypeStr = current.type === "mustache_section" ? "#" : "^";
+      const nextBeginNode = next.children.find(
+        (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+      );
+      errors.push({
+        node: nextBeginNode ?? next,
+        message: `Consecutive duplicate section: {{${sectionTypeStr}${nextName}}} can be merged with previous {{${sectionTypeStr}${nextName}}}`,
+        severity: "warning",
+        fix: [{
+          startIndex: currentEndTag.startIndex,
+          endIndex: nextBeginTag.endIndex,
+          newText: ""
+        }],
+        fixDescription: "Merge consecutive sections"
+      });
+    }
+    for (const child of children) {
+      visit(child);
+    }
+  }
+  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 checkUnescapedEntities(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "text") {
+      if (node.text === "&") {
+        errors.push({
+          node,
+          message: 'Unescaped "&" in text content \u2014 use &amp; instead',
+          severity: "warning",
+          fix: [{
+            startIndex: node.startIndex,
+            endIndex: node.endIndex,
+            newText: "&amp;"
+          }],
+          fixDescription: "Replace & with &amp;"
+        });
+        return;
+      }
+      if (node.text.includes(">")) {
+        const fixes = [];
+        let searchFrom = 0;
+        const text2 = node.text;
+        while (true) {
+          const idx = text2.indexOf(">", searchFrom);
+          if (idx === -1) break;
+          fixes.push({
+            startIndex: node.startIndex + idx,
+            endIndex: node.startIndex + idx + 1,
+            newText: "&gt;"
+          });
+          searchFrom = idx + 1;
+        }
+        errors.push({
+          node,
+          message: 'Unescaped ">" in text content \u2014 use &gt; instead',
+          severity: "warning",
+          fix: fixes,
+          fixDescription: "Replace > with &gt;"
+        });
+        return;
+      }
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+function checkHtmlComments(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_comment") {
+      const raw = node.text;
+      let content = raw;
+      if (content.startsWith("<!--")) content = content.slice(4);
+      if (content.endsWith("-->")) content = content.slice(0, -3);
+      content = content.trim();
+      errors.push({
+        node,
+        message: `HTML comment found \u2014 use mustache comment {{! ... }} instead`,
+        severity: "warning",
+        fix: [{
+          startIndex: node.startIndex,
+          endIndex: node.endIndex,
+          newText: `{{! ${content} }}`
+        }],
+        fixDescription: "Replace HTML comment with mustache comment"
+      });
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+var KNOWN_HTML_TAGS = /* @__PURE__ */ new Set([
+  // Void elements
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "isindex",
+  "keygen",
+  "link",
+  "menuitem",
+  "meta",
+  "nextid",
+  "param",
+  "source",
+  "track",
+  "wbr",
+  // Non-void elements
+  "a",
+  "abbr",
+  "address",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "html",
+  "i",
+  "iframe",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "main",
+  "map",
+  "mark",
+  "math",
+  "menu",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rb",
+  "rp",
+  "rt",
+  "rtc",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "search",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "u",
+  "ul",
+  "var",
+  "video"
+]);
+function checkUnrecognizedHtmlTags(rootNode, customTagNames) {
+  const errors = [];
+  const customSet = customTagNames ? new Set(customTagNames.map((n) => n.toLowerCase())) : void 0;
+  function visit(node) {
+    if (node.type === "html_element" || node.type === "html_self_closing_tag") {
+      const tagNameNode = node.type === "html_self_closing_tag" ? node.children.find((c) => c.type === "html_tag_name") : node.children.find((c) => c.type === "html_start_tag")?.children.find((c) => c.type === "html_tag_name");
+      const tagName = tagNameNode?.text.toLowerCase();
+      if (tagName === "svg" || tagName === "math") return;
+    }
+    if (node.type === "html_start_tag" || node.type === "html_self_closing_tag") {
+      const tagNameNode = node.children.find((c) => c.type === "html_tag_name");
+      if (tagNameNode) {
+        const tagName = tagNameNode.text.toLowerCase();
+        if (!KNOWN_HTML_TAGS.has(tagName) && !customSet?.has(tagName)) {
+          errors.push({
+            node: tagNameNode,
+            message: `Unrecognized HTML tag: <${tagNameNode.text}>`
+          });
+        }
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+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;
+}
+function checkElementContentTooLong(rootNode, elements) {
+  const errors = [];
+  if (elements.length === 0) return errors;
+  const thresholds = /* @__PURE__ */ new Map();
+  for (const { tag, maxBytes } of elements) {
+    const key = tag.toLowerCase();
+    const existing = thresholds.get(key);
+    if (existing === void 0 || maxBytes < existing) thresholds.set(key, maxBytes);
+  }
+  function visit(node) {
+    if (node.type === "html_element") {
+      const startTag = node.children.find((c) => c.type === "html_start_tag");
+      const endTag = node.children.find((c) => c.type === "html_end_tag");
+      const tagNameNode = startTag?.children.find((c) => c.type === "html_tag_name");
+      const tagName = tagNameNode?.text.toLowerCase();
+      if (tagName && startTag && endTag) {
+        const maxBytes = thresholds.get(tagName);
+        if (maxBytes !== void 0) {
+          const innerBytes = endTag.startIndex - startTag.endIndex;
+          if (innerBytes > maxBytes) {
+            errors.push({
+              node: startTag,
+              message: `<${tagName}> content is ${innerBytes} bytes, exceeds limit of ${maxBytes}`
+            });
+          }
+        }
+      }
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+
+// src/core/ruleMetadata.ts
+var RULES = [
+  {
+    name: "nestedDuplicateSections",
+    defaultSeverity: "error",
+    description: "Flags `{{#name}}` nested inside another `{{#name}}` with the same name"
+  },
+  {
+    name: "unquotedMustacheAttributes",
+    defaultSeverity: "error",
+    description: "Requires quotes around mustache expressions used as attribute values"
+  },
+  {
+    name: "consecutiveDuplicateSections",
+    defaultSeverity: "warning",
+    description: "Warns when adjacent same-name sections can be merged"
+  },
+  {
+    name: "selfClosingNonVoidTags",
+    defaultSeverity: "error",
+    description: "Disallows self-closing syntax on non-void HTML elements (e.g. `<div/>`)"
+  },
+  {
+    name: "duplicateAttributes",
+    defaultSeverity: "error",
+    description: "Detects duplicate HTML attributes on the same element"
+  },
+  {
+    name: "unescapedEntities",
+    defaultSeverity: "warning",
+    description: "Flags unescaped `&` and `>` characters in text content"
+  },
+  {
+    name: "preferMustacheComments",
+    defaultSeverity: "off",
+    description: "Suggests replacing HTML comments with mustache comments"
+  },
+  {
+    name: "unrecognizedHtmlTags",
+    defaultSeverity: "error",
+    description: "Flags HTML tags that are not standard HTML elements or valid custom elements"
+  },
+  {
+    name: "elementContentTooLong",
+    defaultSeverity: "off",
+    description: "Flags configured elements whose inner content exceeds a byte-length threshold (opt-in; requires `elements: [{ tag, maxBytes }]` option)"
+  }
+];
+var KNOWN_RULE_NAMES = new Set(RULES.map((r) => r.name));
+var RULE_DEFAULTS = Object.fromEntries(
+  RULES.map((r) => [r.name, r.defaultSeverity])
+);
+
+// node_modules/parsel-js/dist/parsel.js
+var TOKENS = {
+  attribute: /\[\s*(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(\s(?<caseSensitive>[iIsS]))?\s*)?\]/gu,
+  id: /#(?<name>[-\w\P{ASCII}]+)/gu,
+  class: /\.(?<name>[-\w\P{ASCII}]+)/gu,
+  comma: /\s*,\s*/g,
+  combinator: /\s*[\s>+~]\s*/g,
+  "pseudo-element": /::(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
+  "pseudo-class": /:(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
+  universal: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?\*/gu,
+  type: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)/gu
+  // this must be last
+};
+var TRIM_TOKENS = /* @__PURE__ */ new Set(["combinator", "comma"]);
+var RECURSIVE_PSEUDO_CLASSES = /* @__PURE__ */ new Set([
+  "not",
+  "is",
+  "where",
+  "has",
+  "matches",
+  "-moz-any",
+  "-webkit-any",
+  "nth-child",
+  "nth-last-child"
+]);
+var nthChildRegExp = /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/;
+var RECURSIVE_PSEUDO_CLASSES_ARGS = {
+  "nth-child": nthChildRegExp,
+  "nth-last-child": nthChildRegExp
+};
+var getArgumentPatternByType = (type) => {
+  switch (type) {
+    case "pseudo-element":
+    case "pseudo-class":
+      return new RegExp(TOKENS[type].source.replace("(?<argument>\xB6*)", "(?<argument>.*)"), "gu");
+    default:
+      return TOKENS[type];
+  }
+};
+function gobbleParens(text2, offset) {
+  let nesting = 0;
+  let result = "";
+  for (; offset < text2.length; offset++) {
+    const char = text2[offset];
+    switch (char) {
+      case "(":
+        ++nesting;
+        break;
+      case ")":
+        --nesting;
+        break;
+    }
+    result += char;
+    if (nesting === 0) {
+      return result;
+    }
+  }
+  return result;
+}
+function tokenizeBy(text2, grammar = TOKENS) {
+  if (!text2) {
+    return [];
+  }
+  const tokens = [text2];
+  for (const [type, pattern] of Object.entries(grammar)) {
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (typeof token !== "string") {
+        continue;
+      }
+      pattern.lastIndex = 0;
+      const match = pattern.exec(token);
+      if (!match) {
+        continue;
+      }
+      const from = match.index - 1;
+      const args = [];
+      const content = match[0];
+      const before = token.slice(0, from + 1);
+      if (before) {
+        args.push(before);
+      }
+      args.push({
+        ...match.groups,
+        type,
+        content
+      });
+      const after = token.slice(from + content.length + 1);
+      if (after) {
+        args.push(after);
+      }
+      tokens.splice(i, 1, ...args);
+    }
+  }
+  let offset = 0;
+  for (const token of tokens) {
+    switch (typeof token) {
+      case "string":
+        throw new Error(`Unexpected sequence ${token} found at index ${offset}`);
+      case "object":
+        offset += token.content.length;
+        token.pos = [offset - token.content.length, offset];
+        if (TRIM_TOKENS.has(token.type)) {
+          token.content = token.content.trim() || " ";
+        }
+        break;
+    }
+  }
+  return tokens;
+}
+var STRING_PATTERN = /(['"])([^\\\n]*?)\1/g;
+var ESCAPE_PATTERN = /\\./g;
+function tokenize(selector, grammar = TOKENS) {
+  selector = selector.trim();
+  if (selector === "") {
+    return [];
+  }
+  const replacements = [];
+  selector = selector.replace(ESCAPE_PATTERN, (value, offset) => {
+    replacements.push({ value, offset });
+    return "\uE000".repeat(value.length);
+  });
+  selector = selector.replace(STRING_PATTERN, (value, quote, content, offset) => {
+    replacements.push({ value, offset });
+    return `${quote}${"\uE001".repeat(content.length)}${quote}`;
+  });
+  {
+    let pos = 0;
+    let offset;
+    while ((offset = selector.indexOf("(", pos)) > -1) {
+      const value = gobbleParens(selector, offset);
+      replacements.push({ value, offset });
+      selector = `${selector.substring(0, offset)}(${"\xB6".repeat(value.length - 2)})${selector.substring(offset + value.length)}`;
+      pos = offset + value.length;
+    }
+  }
+  const tokens = tokenizeBy(selector, grammar);
+  const changedTokens = /* @__PURE__ */ new Set();
+  for (const replacement of replacements.reverse()) {
+    for (const token of tokens) {
+      const { offset, value } = replacement;
+      if (!(token.pos[0] <= offset && offset + value.length <= token.pos[1])) {
+        continue;
+      }
+      const { content } = token;
+      const tokenOffset = offset - token.pos[0];
+      token.content = content.slice(0, tokenOffset) + value + content.slice(tokenOffset + value.length);
+      if (token.content !== content) {
+        changedTokens.add(token);
+      }
+    }
+  }
+  for (const token of changedTokens) {
+    const pattern = getArgumentPatternByType(token.type);
+    if (!pattern) {
+      throw new Error(`Unknown token type: ${token.type}`);
+    }
+    pattern.lastIndex = 0;
+    const match = pattern.exec(token.content);
+    if (!match) {
+      throw new Error(`Unable to parse content for ${token.type}: ${token.content}`);
+    }
+    Object.assign(token, match.groups);
+  }
+  return tokens;
+}
+function nestTokens(tokens, { list = true } = {}) {
+  if (list && tokens.find((t) => t.type === "comma")) {
+    const selectors = [];
+    const temp = [];
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i].type === "comma") {
+        if (temp.length === 0) {
+          throw new Error("Incorrect comma at " + i);
+        }
+        selectors.push(nestTokens(temp, { list: false }));
+        temp.length = 0;
+      } else {
+        temp.push(tokens[i]);
+      }
+    }
+    if (temp.length === 0) {
+      throw new Error("Trailing comma");
+    } else {
+      selectors.push(nestTokens(temp, { list: false }));
+    }
+    return { type: "list", list: selectors };
+  }
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    let token = tokens[i];
+    if (token.type === "combinator") {
+      let left = tokens.slice(0, i);
+      let right = tokens.slice(i + 1);
+      if (left.length === 0) {
+        return {
+          type: "relative",
+          combinator: token.content,
+          right: nestTokens(right)
+        };
+      }
+      return {
+        type: "complex",
+        combinator: token.content,
+        left: nestTokens(left),
+        right: nestTokens(right)
+      };
+    }
+  }
+  switch (tokens.length) {
+    case 0:
+      throw new Error("Could not build AST.");
+    case 1:
+      return tokens[0];
+    default:
+      return {
+        type: "compound",
+        list: [...tokens]
+        // clone to avoid pointers messing up the AST
+      };
+  }
+}
+function* flatten(node, parent) {
+  switch (node.type) {
+    case "list":
+      for (let child of node.list) {
+        yield* flatten(child, node);
+      }
+      break;
+    case "complex":
+      yield* flatten(node.left, node);
+      yield* flatten(node.right, node);
+      break;
+    case "relative":
+      yield* flatten(node.right, node);
+      break;
+    case "compound":
+      yield* node.list.map((token) => [token, node]);
+      break;
+    default:
+      yield [node, parent];
+  }
+}
+function parse(selector, { recursive = true, list = true } = {}) {
+  const tokens = tokenize(selector);
+  if (!tokens) {
+    return;
+  }
+  const ast = nestTokens(tokens, { list });
+  if (!recursive) {
+    return ast;
+  }
+  for (const [token] of flatten(ast)) {
+    if (token.type !== "pseudo-class" || !token.argument) {
+      continue;
+    }
+    if (!RECURSIVE_PSEUDO_CLASSES.has(token.name)) {
+      continue;
+    }
+    let argument = token.argument;
+    const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[token.name];
+    if (childArg) {
+      const match = childArg.exec(argument);
+      if (!match) {
+        continue;
+      }
+      Object.assign(token, match.groups);
+      argument = match.groups["subtree"];
+    }
+    if (!argument) {
+      continue;
+    }
+    Object.assign(token, {
+      subtree: parse(argument, {
+        recursive: true,
+        list: true
+      })
+    });
+  }
+  return ast;
+}
+
+// src/core/selectorMatcher.ts
+var MUSTACHE_KIND_PSEUDO = /* @__PURE__ */ new Set([
+  "m-section",
+  "m-inverted",
+  "m-variable",
+  "m-raw",
+  "m-comment",
+  "m-partial"
+]);
+function preprocessMustacheLiterals(raw) {
+  let out = "";
+  let i = 0;
+  const len = raw.length;
+  while (i < len) {
+    const ch = raw[i];
+    if (ch === '"' || ch === "'") {
+      out += ch;
+      i++;
+      while (i < len && raw[i] !== ch) {
+        if (raw[i] === "\\" && i + 1 < len) {
+          out += raw[i] + raw[i + 1];
+          i += 2;
+        } else {
+          out += raw[i];
+          i++;
+        }
+      }
+      if (i < len) {
+        out += raw[i];
+        i++;
+      }
+      continue;
+    }
+    if (ch !== "{" || raw[i + 1] !== "{") {
+      out += ch;
+      i++;
+      continue;
+    }
+    if (raw[i + 2] === "{") {
+      const end2 = raw.indexOf("}}}", i + 3);
+      if (end2 < 0) return null;
+      const inner = raw.slice(i + 3, end2).trim();
+      if (inner.length === 0) return null;
+      out += `:m-raw(${inner})`;
+      i = end2 + 3;
+      continue;
+    }
+    const end = raw.indexOf("}}", i + 2);
+    if (end < 0) return null;
+    const body = raw.slice(i + 2, end);
+    i = end + 2;
+    const sigil = body.trimStart()[0];
+    const content = body.replace(/^\s*[#^!>/]\s*/, "").replace(/^\s+|\s+$/g, "");
+    switch (sigil) {
+      case "#":
+        if (content.length === 0) return null;
+        out += `:m-section(${content})`;
+        break;
+      case "^":
+        if (content.length === 0) return null;
+        out += `:m-inverted(${content})`;
+        break;
+      case "!":
+        if (content.length === 0) return null;
+        out += `:m-comment(${content})`;
+        break;
+      case ">":
+        if (content.length === 0) return null;
+        out += `:m-partial(${content})`;
+        break;
+      case "/":
+        return null;
+      case "=":
+        return null;
+      default: {
+        const path = body.trim();
+        if (path.length === 0) return null;
+        out += `:m-variable(${path})`;
+        break;
+      }
+    }
+  }
+  return out;
+}
+function parseSelector(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") return null;
+  const preprocessed = preprocessMustacheLiterals(raw);
+  if (preprocessed === null) return null;
+  let ast;
+  try {
+    ast = parse(preprocessed);
+  } catch {
+    return null;
+  }
+  if (!ast) return null;
+  const tops = ast.type === "list" ? ast.list : [ast];
+  const alts = [];
+  for (const top of tops) {
+    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);
+    if (!mapped) return false;
+    return collectSegments(ast.left, "descendant", out) && collectSegments(ast.right, mapped, out);
+  }
+  if (ast.type === "list" || ast.type === "relative") return false;
+  const segment = segmentFromCompound(ast);
+  if (!segment) return false;
+  segment.combinator = combinator;
+  out.push(segment);
+  return true;
+}
+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) {
+  const tokens = ast.type === "compound" ? ast.list : [ast];
+  let kind;
+  let name = null;
+  let pathRegex;
+  let rootOnly = false;
+  const attributes = [];
+  const descendantChecks = [];
+  const selfNegations = [];
+  const forbidChange = (requested) => {
+    if (kind === void 0) return false;
+    if (kind === requested) return false;
+    return true;
+  };
+  for (const token of tokens) {
+    switch (token.type) {
+      case "type":
+        if (forbidChange("html")) return null;
+        kind = "html";
+        name = token.name.toLowerCase();
+        break;
+      case "universal":
+        if (forbidChange("html")) return null;
+        kind = "html";
+        name = null;
+        break;
+      case "class":
+        if (forbidChange("html")) return null;
+        kind = "html";
+        attributes.push(classConstraint(token, false));
+        break;
+      case "id":
+        if (forbidChange("html")) return null;
+        kind = "html";
+        attributes.push(idConstraint(token, false));
+        break;
+      case "attribute": {
+        if (forbidChange("html")) return null;
+        if (kind === void 0) kind = "html";
+        const c = attributeConstraint(token, false);
+        if (!c) return null;
+        attributes.push(c);
+        break;
+      }
+      case "pseudo-class": {
+        if (MUSTACHE_KIND_PSEUDO.has(token.name)) {
+          const mustacheKind = mustacheKindFromMarker(token.name);
+          if (mustacheKind === null) return null;
+          if (forbidChange(mustacheKind)) return null;
+          kind = mustacheKind;
+          const glob = parseGlob(token.argument ?? "");
+          name = glob.name;
+          pathRegex = glob.pathRegex;
+          break;
+        }
+        if (token.name === "has") {
+          const sel = subtreeToSelector(token.subtree);
+          if (!sel) return null;
+          descendantChecks.push({ selector: sel, negated: false });
+          break;
+        }
+        if (token.name === "not") {
+          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks, selfNegations)) return null;
+          break;
+        }
+        if (token.name === "root") {
+          rootOnly = true;
+          if (kind === void 0) kind = "html";
+          break;
+        }
+        return null;
+      }
+      default:
+        return null;
+    }
+  }
+  if (kind === void 0) {
+    kind = "html";
+  }
+  if (rootOnly) {
+    if (name !== null || attributes.length > 0 || kind !== "html") return null;
+  }
+  const isHtml = kind === "html";
+  const finalAttrs = isHtml ? attributes : [];
+  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, selfNegations, combinator: "descendant" };
+}
+function mustacheKindFromMarker(name) {
+  switch (name) {
+    case "m-section":
+      return "section";
+    case "m-inverted":
+      return "inverted";
+    case "m-variable":
+      return "variable";
+    case "m-raw":
+      return "raw";
+    case "m-comment":
+      return "comment";
+    case "m-partial":
+      return "partial";
+    default:
+      return null;
+  }
+}
+function parseGlob(arg) {
+  const trimmed = arg.trim();
+  if (trimmed === "" || trimmed === "*") {
+    return { name: null };
+  }
+  if (!trimmed.includes("*")) {
+    return { name: trimmed.toLowerCase() };
+  }
+  const escaped = trimmed.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const pathRegex = new RegExp(`^${escaped}$`, "i");
+  return { name: trimmed.toLowerCase(), pathRegex };
+}
+function attributeConstraint(token, negated) {
+  const name = token.name.toLowerCase();
+  if (token.operator === void 0) {
+    return { name, op: "=", value: void 0, negated };
+  }
+  let op;
+  switch (token.operator) {
+    case "=":
+      op = "=";
+      break;
+    case "^=":
+      op = "^=";
+      break;
+    case "*=":
+      op = "*=";
+      break;
+    case "$=":
+      op = "$=";
+      break;
+    case "~=":
+      op = "~=";
+      break;
+    default:
+      return null;
+  }
+  return { name, op, value: stripQuotes(token.value ?? ""), negated };
+}
+function classConstraint(token, negated) {
+  return { name: "class", op: "~=", value: token.name, negated };
+}
+function idConstraint(token, negated) {
+  return { name: "id", op: "=", value: token.name, negated };
+}
+function applyNegatedSubtree(subtree, attributes, descendantChecks, selfNegations) {
+  if (!subtree) return false;
+  if (subtree.type === "attribute") {
+    const c = attributeConstraint(subtree, true);
+    if (!c) return false;
+    attributes.push(c);
+    return true;
+  }
+  if (subtree.type === "class") {
+    attributes.push(classConstraint(subtree, true));
+    return true;
+  }
+  if (subtree.type === "id") {
+    attributes.push(idConstraint(subtree, true));
+    return true;
+  }
+  if (subtree.type === "pseudo-class" && subtree.name === "has") {
+    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;
+}
+function subtreeToSelector(subtree) {
+  if (!subtree) return null;
+  const tops = subtree.type === "list" ? subtree.list : [subtree];
+  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);
+  }
+  return alts.length > 0 ? alts : null;
+}
+function stripQuotes(raw) {
+  if (raw.length < 2) return raw;
+  const first = raw[0];
+  const last = raw[raw.length - 1];
+  if ((first === '"' || first === "'") && first === last) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+function ancestorKindForNode(node) {
+  if (HTML_ELEMENT_TYPES.has(node.type)) return "html";
+  if (node.type === "mustache_section") return "section";
+  if (node.type === "mustache_inverted_section") return "inverted";
+  return null;
+}
+function getHtmlAttributes(node) {
+  const startTag = node.children.find(
+    (c) => c.type === "html_start_tag" || c.type === "html_self_closing_tag"
+  );
+  if (!startTag) return [];
+  const attrs = [];
+  for (const child of startTag.children) {
+    if (child.type !== "html_attribute") continue;
+    let attrName = "";
+    let attrValue;
+    for (const part of child.children) {
+      if (part.type === "html_attribute_name") {
+        attrName = part.text.toLowerCase();
+      } else if (part.type === "html_quoted_attribute_value") {
+        attrValue = part.text.replace(/^["']|["']$/g, "");
+      } else if (part.type === "html_attribute_value") {
+        attrValue = part.text;
+      }
+    }
+    if (attrName) attrs.push({ name: attrName, value: attrValue });
+  }
+  return attrs;
+}
+function matchesAttributeValue(has, c) {
+  if (has === void 0 || c.value === void 0) return false;
+  const v = c.value;
+  if (v === "") return false;
+  switch (c.op) {
+    case "=":
+      return has === v;
+    case "^=":
+      return has.startsWith(v);
+    case "*=":
+      return has.includes(v);
+    case "$=":
+      return has.endsWith(v);
+    case "~=":
+      return has.split(/\s+/).includes(v);
+  }
+}
+function checkAttributes(node, constraints) {
+  if (constraints.length === 0) return true;
+  const nodeAttrs = getHtmlAttributes(node);
+  for (const c of constraints) {
+    const found = nodeAttrs.find((a) => a.name === c.name);
+    if (c.negated) {
+      if (!found) continue;
+      if (c.value === void 0) return false;
+      if (matchesAttributeValue(found.value, c)) return false;
+      continue;
+    }
+    if (c.value === void 0) {
+      if (!found) return false;
+      continue;
+    }
+    if (!found || !matchesAttributeValue(found.value, c)) return false;
+  }
+  return true;
+}
+function checkDescendants(node, checks) {
+  if (checks.length === 0) return true;
+  for (const check of checks) {
+    const present = hasDescendantMatch(node, check.selector);
+    if (check.negated ? present : !present) return false;
+  }
+  return true;
+}
+function hasDescendantMatch(node, selector) {
+  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;
+  if (segment.pathRegex) return segment.pathRegex.test(actual);
+  return actual === segment.name;
+}
+function nodeMatchesSegment(node, segment, rootNode) {
+  if (segment.rootOnly) {
+    if (node !== rootNode) return false;
+    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 (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;
+      }
+      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;
+      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 = 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 (!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";
+  if (segment.kind === "section") return "section";
+  if (segment.kind === "inverted") return "inverted";
+  return null;
+}
+function getReportNode(node, rootNode) {
+  if (HTML_ELEMENT_TYPES.has(node.type)) {
+    const startTag = node.children.find(
+      (c) => c.type === "html_start_tag" || c.type === "html_self_closing_tag"
+    );
+    return startTag ?? node;
+  }
+  if (node.type === "mustache_section" || node.type === "mustache_inverted_section") {
+    const begin = node.children.find(
+      (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+    );
+    return begin ?? node;
+  }
+  if (rootNode && node === rootNode) {
+    return {
+      type: node.type,
+      text: "",
+      startPosition: node.startPosition,
+      endPosition: { row: node.startPosition.row, column: node.startPosition.column + 1 },
+      startIndex: node.startIndex,
+      endIndex: Math.min(node.startIndex + 1, node.endIndex),
+      children: []
+    };
+  }
+  return node;
+}
+function matchAlternative(rootNode, segments, rootSiblings, rootIndexInSiblings) {
+  const results = [];
+  const lastSegment = segments[segments.length - 1];
+  function walk(node, ancestors, siblings, indexInSiblings) {
+    if (nodeMatchesSegment(node, lastSegment, rootNode)) {
+      const cursor = { ancestors, siblings, indexInSiblings };
+      if (segments.length === 1 || checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)) {
+        results.push(getReportNode(node, rootNode));
+      }
+    }
+    let newAncestors = ancestors;
+    const ancestorKind = ancestorKindForNode(node);
+    if (ancestorKind !== null) {
+      const name = ancestorKind === "html" ? getTagName(node)?.toLowerCase() : getSectionName(node)?.toLowerCase();
+      if (name) {
+        newAncestors = [...ancestors, { kind: ancestorKind, name, node, siblings, indexInSiblings }];
+      }
+    }
+    for (let i = 0; i < node.children.length; i++) {
+      walk(node.children[i], newAncestors, node.children, i);
+    }
+  }
+  const rootEntry = {
+    kind: "root",
+    name: "",
+    node: rootNode,
+    siblings: rootSiblings,
+    indexInSiblings: rootIndexInSiblings
+  };
+  walk(rootNode, [rootEntry], rootSiblings, rootIndexInSiblings);
+  return results;
+}
+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, siblings, indexInSiblings)) {
+      if (!seen.has(node)) {
+        seen.add(node);
+        allResults.push(node);
+      }
+    }
+  }
+  return allResults;
+}
+
+// src/core/collectErrors.ts
+var selectorCache = /* @__PURE__ */ new Map();
+function parseSelectorCached(raw) {
+  const hit = selectorCache.get(raw);
+  if (hit !== void 0) return hit;
+  const parsed = parseSelector(raw);
+  selectorCache.set(raw, parsed);
+  return parsed;
+}
+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");
+    return `Mismatched mustache section: {{/${tagNameNode?.text || "?"}}}`;
+  }
+  if (nodeType === "ERROR") {
+    return "Syntax error";
+  }
+  return `Missing ${nodeType}`;
+}
+function resolveRuleConfig(rules, ruleName) {
+  const entry = rules?.[ruleName];
+  let severity;
+  if (entry === void 0) {
+    severity = RULE_DEFAULTS[ruleName] ?? "off";
+  } else if (typeof entry === "string") {
+    severity = entry;
+  } else {
+    severity = entry.severity;
+  }
+  return { severity, entry };
+}
+function parseDisableDirective(node, customRuleIds) {
+  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;
+  const prefix = "htmlmustache-disable ";
+  if (!inner.startsWith(prefix)) return null;
+  const ruleName = inner.slice(prefix.length).trim();
+  if (KNOWN_RULE_NAMES.has(ruleName)) return ruleName;
+  if (customRuleIds?.has(ruleName)) return ruleName;
+  return null;
+}
+function collectDisabledRules(rootNode, customRuleIds) {
+  const disabled = /* @__PURE__ */ new Set();
+  function walk(node) {
+    const rule = parseDisableDirective(node, customRuleIds);
+    if (rule) {
+      disabled.add(rule);
+      return;
+    }
+    for (const child of node.children) walk(child);
+  }
+  walk(rootNode);
+  return disabled;
+}
+function collectErrors(tree, rules, customTagNames, customRules) {
+  const errors = [];
+  const cursor = tree.walk();
+  function visit() {
+    const node = cursor.currentNode;
+    const nodeType = cursor.nodeType;
+    if (ERROR_NODE_TYPES.has(nodeType) || cursor.nodeIsMissing) {
+      errors.push({
+        node,
+        message: errorMessageForNode(nodeType, node)
+      });
+      if (nodeType === "ERROR") return;
+    }
+    if (cursor.gotoFirstChild()) {
+      do {
+        visit();
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+  }
+  visit();
+  const balanceErrors = checkHtmlBalance(tree.rootNode);
+  for (const error of balanceErrors) {
+    errors.push({ node: error.node, message: error.message });
+  }
+  const unclosedErrors = checkUnclosedTags(tree.rootNode);
+  for (const error of unclosedErrors) {
+    errors.push({ node: error.node, message: error.message });
+  }
+  const customRuleIds = customRules ? new Set(customRules.map((r) => r.id)) : void 0;
+  const disabledRules = collectDisabledRules(tree.rootNode, customRuleIds);
+  const effectiveRules = { ...rules };
+  for (const rule of disabledRules) {
+    effectiveRules[rule] = "off";
+  }
+  const sourceText = tree.rootNode.text;
+  const ruleChecks = [
+    { rule: "nestedDuplicateSections", errors: () => checkNestedSameNameSections(tree.rootNode) },
+    { rule: "unquotedMustacheAttributes", errors: () => checkUnquotedMustacheAttributes(tree.rootNode) },
+    { rule: "consecutiveDuplicateSections", errors: () => checkConsecutiveSameNameSections(tree.rootNode, sourceText) },
+    { rule: "selfClosingNonVoidTags", errors: () => checkSelfClosingNonVoidTags(tree.rootNode) },
+    { rule: "duplicateAttributes", errors: () => checkDuplicateAttributes(tree.rootNode) },
+    { rule: "unescapedEntities", errors: () => checkUnescapedEntities(tree.rootNode) },
+    { rule: "preferMustacheComments", errors: () => checkHtmlComments(tree.rootNode) },
+    { rule: "unrecognizedHtmlTags", errors: () => checkUnrecognizedHtmlTags(tree.rootNode, customTagNames) },
+    {
+      rule: "elementContentTooLong",
+      errors: (entry) => {
+        const elements = (entry && typeof entry === "object" ? entry.elements : void 0) ?? [];
+        return checkElementContentTooLong(tree.rootNode, elements);
+      }
+    }
+  ];
+  for (const { rule, errors: getErrors } of ruleChecks) {
+    const { severity, entry } = resolveRuleConfig(effectiveRules, rule);
+    if (severity === "off") continue;
+    for (const error of getErrors(entry)) {
+      errors.push({
+        node: error.node,
+        message: error.message,
+        severity,
+        fix: error.fix,
+        fixDescription: error.fixDescription,
+        ruleName: rule
+      });
+    }
+  }
+  if (customRules) {
+    for (const rule of customRules) {
+      if (disabledRules.has(rule.id)) continue;
+      const severity = rule.severity ?? "error";
+      if (severity === "off") continue;
+      const parsed = parseSelectorCached(rule.selector);
+      if (!parsed) continue;
+      const matches = matchSelector(tree.rootNode, parsed);
+      for (const node of matches) {
+        errors.push({ node, message: rule.message, severity, ruleName: rule.id });
+      }
+    }
+  }
+  return errors.filter(
+    (e) => !(e.message.includes("HTML comment found") && parseDisableDirective(e.node, customRuleIds) !== null)
+  );
+}
+
+// src/core/formatting/printer.ts
+function print(doc, options) {
+  const output = [];
+  const state = { indentLevel: 0, mode: "break", groupModes: /* @__PURE__ */ new Map() };
+  printDoc(doc, state, output, options);
+  return output.join("");
+}
+function currentColumn(output) {
+  let col = 0;
+  for (let i = output.length - 1; i >= 0; i--) {
+    const chunk = output[i];
+    const nlIndex = chunk.lastIndexOf("\n");
+    if (nlIndex !== -1) {
+      col += chunk.length - nlIndex - 1;
+      return col;
+    }
+    col += chunk.length;
+  }
+  return col;
+}
+function containsBreakParent(doc) {
+  if (typeof doc === "string") return false;
+  switch (doc.type) {
+    case "breakParent":
+      return true;
+    case "concat":
+      return doc.parts.some(containsBreakParent);
+    case "indent":
+      return containsBreakParent(doc.contents);
+    case "group":
+      return containsBreakParent(doc.contents);
+    case "fill":
+      return doc.parts.some(containsBreakParent);
+    case "ifBreak":
+      return containsBreakParent(doc.breakContents) || containsBreakParent(doc.flatContents);
+    default:
+      return false;
+  }
+}
+function printDoc(doc, state, output, options) {
+  if (typeof doc === "string") {
+    output.push(doc);
+    return;
+  }
+  switch (doc.type) {
+    case "concat":
+      for (const part of doc.parts) {
+        printDoc(part, state, output, options);
+      }
+      break;
+    case "indent":
+      state.indentLevel++;
+      printDoc(doc.contents, state, output, options);
+      state.indentLevel--;
+      break;
+    case "hardline":
+      output.push("\n");
+      output.push(makeIndent(state.indentLevel, options));
+      break;
+    case "softline":
+      if (state.mode === "break") {
+        output.push("\n");
+        output.push(makeIndent(state.indentLevel, options));
+      }
+      break;
+    case "line":
+      if (state.mode === "break") {
+        output.push("\n");
+        output.push(makeIndent(state.indentLevel, options));
+      } else {
+        output.push(" ");
+      }
+      break;
+    case "group": {
+      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", 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;
+        }
+      }
+      break;
+    }
+    case "fill":
+      printFill(doc.parts, state, output, options);
+      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;
+  }
+}
+function printFill(parts, state, output, options) {
+  if (parts.length === 0) return;
+  const printWidth = options.printWidth ?? 80;
+  for (let i = 0; i < parts.length; i++) {
+    const content = parts[i];
+    const separator = i + 1 < parts.length ? parts[i + 1] : null;
+    printDoc(content, state, output, options);
+    if (separator === null) break;
+    const nextContent = i + 2 < parts.length ? parts[i + 2] : null;
+    if (nextContent !== null) {
+      const testOutput = [];
+      const flatState = { ...state, mode: "flat" };
+      printDoc(separator, flatState, testOutput, options);
+      printDoc(nextContent, flatState, testOutput, options);
+      const testStr = testOutput.join("");
+      const col = currentColumn(output);
+      if (!testStr.includes("\n") && col + testStr.length <= printWidth) {
+        const sepOutput = [];
+        printDoc(separator, flatState, sepOutput, options);
+        output.push(sepOutput.join(""));
+      } else {
+        printDoc(separator, { ...state, mode: "break" }, output, options);
+      }
+    } else {
+      printDoc(separator, state, output, options);
+    }
+    i++;
+  }
+}
+function makeIndent(level, options) {
+  return options.indentUnit.repeat(level);
+}
+
+// src/core/formatting/ir.ts
+var hardline = { type: "hardline" };
+var softline = { type: "softline" };
+var line = { type: "line" };
+var empty = "";
+function text(value) {
+  return value;
+}
+function concat(parts) {
+  const flattened = [];
+  for (const part of parts) {
+    if (part === "") continue;
+    if (typeof part === "object" && part.type === "concat") {
+      flattened.push(...part.parts);
+    } else {
+      flattened.push(part);
+    }
+  }
+  if (flattened.length === 0) return "";
+  if (flattened.length === 1) return flattened[0];
+  return { type: "concat", parts: flattened };
+}
+function indent(contents) {
+  if (contents === "") return "";
+  return { type: "indent", contents };
+}
+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 "";
+  const shouldBreak = options?.shouldBreak;
+  return { type: "group", contents, break: shouldBreak || void 0, id: options?.id };
+}
+function ifBreak(breakContents, flatContents, options) {
+  return { type: "ifBreak", breakContents, flatContents, groupId: options?.groupId };
+}
+function fill(parts) {
+  const filtered = parts.filter((p) => p !== "");
+  if (filtered.length === 0) return "";
+  if (filtered.length === 1) return filtered[0];
+  return { type: "fill", parts: filtered };
+}
+function isLine(doc) {
+  return typeof doc === "object" && doc.type === "line";
+}
+
+// src/core/formatting/utils.ts
+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");
+}
+function getVisibleChildren(node) {
+  const children = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && !child.type.startsWith("_")) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function normalizeMustacheWhitespace(raw, addSpaces) {
+  const space = addSpaces ? " " : "";
+  const tripleMatch = raw.match(/^\{\{\{([\s\S]*)\}\}\}$/);
+  if (tripleMatch) {
+    const inner = tripleMatch[1].trim();
+    return `{{{${space}${inner}${space}}}}`;
+  }
+  const prefixedMatch = raw.match(/^\{\{([#/^!>])([\s\S]*)\}\}$/);
+  if (prefixedMatch) {
+    const prefix = prefixedMatch[1];
+    const inner = prefixedMatch[2];
+    if (prefix === "!" && inner.includes("\n")) {
+      const lines = inner.split("\n");
+      const first = lines[0].trimStart();
+      const last = lines[lines.length - 1].trimEnd();
+      if (lines.length === 1) {
+        return `{{${prefix} ${first} }}`;
+      }
+      const middle = lines.slice(1, -1);
+      return `{{${prefix} ${first}
+${middle.join("\n")}
+${last} }}`;
+    }
+    const trimmed = inner.trim();
+    const s = prefix === "!" ? " " : space;
+    return `{{${prefix}${s}${trimmed}${s}}}`;
+  }
+  const plainMatch = raw.match(/^\{\{([\s\S]*)\}\}$/);
+  if (plainMatch) {
+    const inner = plainMatch[1].trim();
+    return `{{${space}${inner}${space}}}`;
+  }
+  return raw;
+}
+function normalizeMustacheWhitespaceAll(raw, addSpaces) {
+  return raw.replace(/\{\{\{[\s\S]*?\}\}\}|\{\{[\s\S]*?\}\}/g, (match) => {
+    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;
+}
+
+// src/core/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;
+}
+
+// src/core/formatting/classifier.ts
+var EMPTY_MAP = /* @__PURE__ */ new Map();
+var CSS_DISPLAY_MAP = {
+  // Block elements
+  address: "block",
+  article: "block",
+  aside: "block",
+  blockquote: "block",
+  body: "block",
+  center: "block",
+  dd: "block",
+  details: "block",
+  dialog: "block",
+  dir: "block",
+  div: "block",
+  dl: "block",
+  dt: "block",
+  fieldset: "block",
+  figcaption: "block",
+  figure: "block",
+  footer: "block",
+  form: "block",
+  h1: "block",
+  h2: "block",
+  h3: "block",
+  h4: "block",
+  h5: "block",
+  h6: "block",
+  header: "block",
+  hgroup: "block",
+  hr: "block",
+  html: "block",
+  legend: "block",
+  listing: "block",
+  main: "block",
+  menu: "block",
+  nav: "block",
+  ol: "block",
+  p: "block",
+  plaintext: "block",
+  pre: "block",
+  search: "block",
+  section: "block",
+  summary: "block",
+  ul: "block",
+  xmp: "block",
+  // List items
+  li: "list-item",
+  // Table elements
+  table: "table",
+  caption: "table-caption",
+  colgroup: "table-column-group",
+  col: "table-column",
+  thead: "table-header-group",
+  tbody: "table-row-group",
+  tfoot: "table-footer-group",
+  tr: "table-row",
+  td: "table-cell",
+  th: "table-cell",
+  // Inline-block elements
+  button: "inline-block",
+  img: "inline-block",
+  input: "inline-block",
+  select: "inline-block",
+  textarea: "inline-block",
+  video: "inline-block",
+  audio: "inline-block",
+  canvas: "inline-block",
+  embed: "inline-block",
+  iframe: "inline-block",
+  object: "inline-block",
+  // None
+  head: "none",
+  link: "none",
+  meta: "none",
+  script: "none",
+  style: "none",
+  title: "none",
+  template: "none",
+  // Ruby
+  ruby: "ruby",
+  rb: "ruby-base",
+  rt: "ruby-text",
+  rp: "none"
+};
+var PRESERVE_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+  "pre",
+  "code",
+  "textarea",
+  "script",
+  "style"
+]);
+function getCSSDisplay(node, customTags = EMPTY_MAP) {
+  const type = node.type;
+  if (type === "html_element") {
+    const tagName = getTagName(node);
+    if (tagName) {
+      const lower = tagName.toLowerCase();
+      const config = customTags.get(lower);
+      if (config) {
+        if (config.display) return config.display;
+        if (isCodeTag(config)) return "block";
+        return "inline-block";
+      }
+      return CSS_DISPLAY_MAP[lower] ?? "inline";
+    }
+    return "block";
+  }
+  if (isRawContentElement(node)) {
+    return "block";
+  }
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customTags) ? "block" : "inline";
+  }
+  return "inline";
+}
+function isWhitespaceInsensitive(display) {
+  switch (display) {
+    case "block":
+    case "list-item":
+    case "table":
+    case "table-row":
+    case "table-row-group":
+    case "table-header-group":
+    case "table-footer-group":
+    case "table-column":
+    case "table-column-group":
+    case "table-caption":
+    case "table-cell":
+    case "none":
+      return true;
+    default:
+      return false;
+  }
+}
+function isBlockLevel(node, customTags = EMPTY_MAP) {
+  const type = node.type;
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customTags);
+  }
+  if (type === "html_element") {
+    const display = getCSSDisplay(node, customTags);
+    return isWhitespaceInsensitive(display);
+  }
+  if (isRawContentElement(node)) {
+    return true;
+  }
+  return false;
+}
+function shouldPreserveContent(node, customTags = EMPTY_MAP) {
+  const type = node.type;
+  if (isRawContentElement(node)) {
+    return true;
+  }
+  if (type === "html_element") {
+    const tagName = getTagName(node);
+    if (!tagName) return false;
+    const lower = tagName.toLowerCase();
+    if (PRESERVE_CONTENT_ELEMENTS.has(lower)) return true;
+    const config = customTags.get(lower);
+    if (config && isCodeTag(config)) return true;
+  }
+  return false;
+}
+function hasBlockContent(sectionNode, customTags = EMPTY_MAP) {
+  const contentNodes = getContentNodes(sectionNode);
+  if (hasImplicitEndTags(contentNodes)) {
+    return true;
+  }
+  for (const node of contentNodes) {
+    if (isBlockLevelContent(node, customTags)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isBlockLevelContent(node, customTags = EMPTY_MAP) {
+  const type = node.type;
+  if (type === "html_element") {
+    return true;
+  }
+  if (isRawContentElement(node)) {
+    return true;
+  }
+  if (isMustacheSection(node)) {
+    return hasBlockContent(node, customTags);
+  }
+  return false;
+}
+function getContentNodes(sectionNode) {
+  const isInverted = sectionNode.type === "mustache_inverted_section";
+  const beginType = isInverted ? "mustache_inverted_section_begin" : "mustache_section_begin";
+  const endType = isInverted ? "mustache_inverted_section_end" : "mustache_section_end";
+  const contentNodes = [];
+  for (let i = 0; i < sectionNode.childCount; i++) {
+    const child = sectionNode.child(i);
+    if (!child) continue;
+    if (child.type !== beginType && child.type !== endType && child.type !== "mustache_erroneous_section_end" && child.type !== "mustache_erroneous_inverted_section_end" && !child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  return contentNodes;
+}
+function hasImplicitEndTags(nodes) {
+  for (const node of nodes) {
+    if (hasImplicitEndTagsRecursive(node)) {
+      return true;
+    }
+  }
+  return false;
+}
+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;
+      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 && hasContentChildren) return true;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && hasImplicitEndTagsRecursive(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isInlineContentNode(node) {
+  if (node.type === "text") return node.text.trim().length > 0;
+  return node.type === "mustache_interpolation" || node.type === "mustache_triple" || node.type === "mustache_partial";
+}
+function isInTextFlow(node, index, nodes) {
+  if (index > 0) {
+    const prev = nodes[index - 1];
+    if (prev.type === "text" && prev.text.trim().length > 0) {
+      return true;
+    }
+  }
+  if (index < nodes.length - 1) {
+    const next = nodes[index + 1];
+    if (next.type === "text" && next.text.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasAdjacentInlineContent(index, nodes) {
+  for (let i = index - 1; i >= 0; i--) {
+    const n = nodes[i];
+    if (n.type === "text" && n.text.trim().length === 0) continue;
+    if (isInlineContentNode(n)) return true;
+    break;
+  }
+  for (let i = index + 1; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (n.type === "text" && n.text.trim().length === 0) continue;
+    if (isInlineContentNode(n)) return true;
+    break;
+  }
+  return false;
+}
+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;
+  }
+  if (hasAdjacentInlineContent(index, nodes)) {
+    return true;
+  }
+  if (index > 0) {
+    const prev = nodes[index - 1];
+    if (prev.type === "html_element" && isInTextFlow(prev, index - 1, nodes)) {
+      return true;
+    }
+  }
+  if (index < nodes.length - 1) {
+    const next = nodes[index + 1];
+    if (next.type === "html_element" && isInTextFlow(next, index + 1, nodes)) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldTreatAsBlock(node, index, nodes, customTags = EMPTY_MAP) {
+  const isHtmlEl = isHtmlElementType(node);
+  const isMustacheSec = isMustacheSection(node);
+  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);
+}
+
+// src/core/formatting/formatters.ts
+function isAttributeTruthy(value) {
+  if (value === null || value === "" || value === "false" || value === "0") {
+    return false;
+  }
+  return true;
+}
+function dedentContent(rawContent) {
+  const lines = rawContent.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return "";
+  let minIndent = Infinity;
+  for (const l of lines) {
+    if (l.trim() === "") continue;
+    const match = l.match(/^(\s*)/);
+    if (match && match[1].length < minIndent) {
+      minIndent = match[1].length;
+    }
+  }
+  if (minIndent === Infinity) minIndent = 0;
+  return lines.map((l) => l.trim() === "" ? "" : l.slice(minIndent)).join("\n");
+}
+function resolveIndentMode(node, config) {
+  const mode = config.indent ?? "never";
+  if (mode === "never") return false;
+  if (mode === "always") return true;
+  if (!config.indentAttribute) return false;
+  const value = getAttributeValue(node, config.indentAttribute);
+  return isAttributeTruthy(value);
+}
+function getTagNameFromStartTag(startTag) {
+  for (let i = 0; i < startTag.childCount; i++) {
+    const child = startTag.child(i);
+    if (child?.type === "html_tag_name") return child.text.toLowerCase();
+  }
+  return null;
+}
+function mustacheText(raw, context) {
+  if (context.mustacheSpaces !== void 0) {
+    return normalizeMustacheWhitespace(raw, context.mustacheSpaces);
+  }
+  return raw;
+}
+function formatDocument(node, context) {
+  const children = getVisibleChildren(node);
+  const content = formatBlockChildren(children, context);
+  return concat([content, hardline]);
+}
+function formatNode(node, context, forceInline = false) {
+  const type = node.type;
+  switch (type) {
+    case "document":
+      return formatDocument(node, context);
+    case "html_element":
+      return formatHtmlElement(node, context, forceInline);
+    case "html_script_element":
+    case "html_style_element":
+    case "html_raw_element":
+      return formatScriptStyleElement(node, context);
+    case "mustache_section":
+    case "mustache_inverted_section":
+      if (forceInline) {
+        if (context.mustacheSpaces !== void 0) {
+          return text(normalizeMustacheWhitespaceAll(node.text, context.mustacheSpaces));
+        }
+        return text(node.text);
+      }
+      return formatMustacheSection(node, context);
+    case "mustache_interpolation":
+    case "mustache_triple":
+    case "mustache_partial":
+    case "mustache_comment":
+      return text(mustacheText(node.text, context));
+    case "html_comment":
+    case "html_doctype":
+    case "html_entity":
+    case "html_erroneous_end_tag":
+      return text(node.text);
+    case "text":
+      return formatText(node);
+    default:
+      return text(node.text);
+  }
+}
+function formatText(node) {
+  return text(normalizeText(node.text));
+}
+function formatHtmlElement(node, context, forceInline = false) {
+  const tags = context.customTags;
+  const display = getCSSDisplay(node, tags);
+  const isBlock = isWhitespaceInsensitive(display);
+  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);
+    return formatStartTag(tag, context);
+  }
+  let startTag = null;
+  let endTag = null;
+  let hasRealEndTag = false;
+  const contentNodes = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_start_tag") {
+      startTag = child;
+    } else if (child.type === "html_end_tag") {
+      endTag = child;
+      hasRealEndTag = true;
+    } else if (child.type === "html_forced_end_tag") {
+      endTag = child;
+    } else if (!child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  const parts = [];
+  if (startTag) {
+    parts.push(formatStartTag(startTag, context));
+  }
+  const hasHtmlElementChildren = contentNodes.some(
+    (child) => child.type === "html_element" || isRawContentElement(child) || isBlockLevel(child, tags)
+  );
+  if (preserveContent) {
+    const tagNameLower = startTag ? getTagNameFromStartTag(startTag) : null;
+    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(
+        startTag.endIndex,
+        endTag.startIndex
+      );
+      const dedented = dedentContent(rawContent);
+      if (dedented.length > 0) {
+        const contentLines = dedented.split("\n");
+        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);
+      }
+    } else if (startTag && endTag) {
+      const rawContent = context.document.getText().slice(
+        startTag.endIndex,
+        endTag.startIndex
+      );
+      const trailingMatch = isBlock ? rawContent.match(/\n[\t ]*$/) : null;
+      if (trailingMatch) {
+        parts.push(text(rawContent.slice(0, -trailingMatch[0].length)));
+        parts.push(hardline);
+      } else {
+        parts.push(text(rawContent));
+      }
+    } else {
+      for (const child of contentNodes) {
+        parts.push(text(child.text));
+      }
+    }
+  } else if (!isBlock && (!hasHtmlElementChildren || forceInline && display !== "inline-block" && !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) {
+        const gap = context.document.getText().slice(prevEnd, child.startIndex);
+        if (/\s/.test(gap)) {
+          parts.push(text(" "));
+        }
+      }
+      parts.push(formatNode(child, context, forceInline));
+      prevEnd = child.endIndex;
+    }
+  } else {
+    const formattedContent = formatBlockChildren(contentNodes, context);
+    const hasContent = hasDocContent(formattedContent);
+    if (hasContent) {
+      const hasBlockChildren = contentNodes.some((child, i) => {
+        if (!shouldTreatAsBlock(child, i, contentNodes, tags)) {
+          return false;
+        }
+        const childDisplay = getCSSDisplay(child, tags);
+        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])),
+            softline
+          ])
+        );
+        parts.push(doc);
+        if (!hasRealEndTag && endTag) {
+          parts.pop();
+          parts.push(
+            group(
+              concat([
+                indent(concat([softline, formattedContent]))
+              ])
+            )
+          );
+        }
+      } else {
+        parts.push(indent(concat([hardline, formattedContent])));
+        if (hasRealEndTag) {
+          parts.push(hardline);
+        }
+      }
+    } else if (contentNodes.length === 0 && hasRealEndTag) {
+      parts.push(hardline);
+    }
+  }
+  if (endTag) {
+    parts.push(formatEndTag(endTag));
+  }
+  return concat(parts);
+}
+function formatScriptStyleElement(node, context) {
+  const parts = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_start_tag") {
+      parts.push(formatStartTag(child, context));
+    } else if (child.type === "html_end_tag") {
+      parts.push(formatEndTag(child));
+    } else if (child.type === "html_raw_text") {
+      const formatted = context.embeddedFormatted?.get(child.startIndex);
+      if (formatted !== void 0) {
+        const trimmed = formatted.replace(/^\n+/, "").replace(/\n+$/, "");
+        if (trimmed.length === 0) {
+        } else {
+          const lines = trimmed.split("\n");
+          const lineDocs = [];
+          for (let j = 0; j < lines.length; j++) {
+            if (j > 0) {
+              lineDocs.push(hardline);
+            }
+            lineDocs.push(text(lines[j]));
+          }
+          parts.push(indent(concat([hardline, ...lineDocs])));
+          parts.push(hardline);
+        }
+      } else {
+        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.customTags?.get(tagNameLower) : void 0;
+          if (tagConfig && resolveIndentMode(node, tagConfig)) {
+            const dedented = dedentContent(child.text);
+            if (dedented.length > 0) {
+              const contentLines = dedented.split("\n");
+              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);
+            }
+          } else {
+            parts.push(text(child.text));
+          }
+        } else {
+          const dedented = dedentContent(child.text);
+          if (dedented.length > 0) {
+            const contentLines = dedented.split("\n");
+            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);
+          }
+        }
+      }
+    }
+  }
+  return concat(parts);
+}
+function formatMustacheSection(node, context) {
+  const isInverted = node.type === "mustache_inverted_section";
+  const beginType = isInverted ? "mustache_inverted_section_begin" : "mustache_section_begin";
+  const endType = isInverted ? "mustache_inverted_section_end" : "mustache_section_end";
+  let beginNode = null;
+  let endNode = null;
+  const contentNodes = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === beginType) {
+      beginNode = child;
+    } else if (child.type === endType || child.type === "mustache_erroneous_section_end" || child.type === "mustache_erroneous_inverted_section_end") {
+      endNode = child;
+    } else if (!child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  const parts = [];
+  if (beginNode) {
+    parts.push(text(mustacheText(beginNode.text, context)));
+  }
+  const hasImplicit = hasImplicitEndTags(contentNodes);
+  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;
+        }
+      }
+      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 {
+        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);
+        }
+      }
+    }
+  }
+  if (endNode) {
+    parts.push(text(mustacheText(endNode.text, context)));
+  }
+  return group(concat(parts));
+}
+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++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_tag_name") {
+      tagNameText = child.text;
+    } else if (child.type === "html_attribute") {
+      attrs.push(formatAttribute(child, context));
+    } else if (child.type === "mustache_attribute") {
+      if (context?.mustacheSpaces !== void 0) {
+        attrs.push(text(normalizeMustacheWhitespaceAll(child.text, context.mustacheSpaces)));
+      } else {
+        attrs.push(text(child.text));
+      }
+    } else if (child.type === "mustache_interpolation" || child.type === "mustache_triple") {
+      attrs.push(text(context ? mustacheText(child.text, context) : child.text));
+    }
+  }
+  const isSelfClosing = node.type === "html_self_closing_tag";
+  const closingBracket = isSelfClosing ? " />" : ">";
+  if (attrs.length === 0) {
+    return text("<" + tagNameText + closingBracket);
+  }
+  const attrParts = [];
+  for (let i = 0; i < attrs.length; i++) {
+    if (i > 0) {
+      attrParts.push(line);
+    }
+    attrParts.push(attrs[i]);
+  }
+  const breakClosingBracket = isSelfClosing ? "/>" : ">";
+  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++) {
+    const child = node.child(i);
+    if (child && child.type === "html_tag_name") {
+      return text("</" + child.text + ">");
+    }
+  }
+  return text(node.text);
+}
+function formatAttribute(node, context) {
+  const parts = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_attribute_name") {
+      parts.push(text(child.text));
+    } else if (child.type === "html_attribute_value") {
+      parts.push(text("="));
+      parts.push(text(child.text));
+    } else if (child.type === "html_quoted_attribute_value") {
+      parts.push(text("="));
+      if (context?.mustacheSpaces !== void 0) {
+        parts.push(text(normalizeMustacheWhitespaceAll(child.text, context.mustacheSpaces)));
+      } else {
+        parts.push(text(child.text));
+      }
+    } else if (child.type === "mustache_interpolation") {
+      parts.push(text("="));
+      parts.push(text(context ? mustacheText(child.text, context) : child.text));
+    }
+  }
+  return concat(parts);
+}
+function textWords(str) {
+  const words = str.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0) return [];
+  const parts = [words[0]];
+  for (let i = 1; i < words.length; i++) {
+    parts.push(line);
+    parts.push(words[i]);
+  }
+  return parts;
+}
+function collapseDelimitedRegions(parts, delimiters) {
+  if (delimiters.length === 0) return parts;
+  const sorted = [...delimiters].sort(
+    (a, b) => Math.max(b.start.length, b.end.length) - Math.max(a.start.length, a.end.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 startIdx = part.indexOf(delim.start);
+          if (startIdx >= 0) {
+            const afterOpen = startIdx + delim.start.length;
+            const closeIdx = part.indexOf(delim.end, afterOpen);
+            if (closeIdx >= 0) {
+              continue;
+            }
+            activeDelimiter = delim;
+            break;
+          }
+        }
+      } else {
+        if (part.includes(activeDelimiter.end)) {
+          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];
+  const fillParts = [];
+  for (const item of parts) {
+    if (isLine(item)) {
+      if (fillParts.length > 0 && !isLine(fillParts[fillParts.length - 1])) {
+        fillParts.push(item);
+      }
+    } else {
+      const lastIdx = fillParts.length - 1;
+      if (lastIdx >= 0 && !isLine(fillParts[lastIdx])) {
+        fillParts[lastIdx] = concat([fillParts[lastIdx], item]);
+      } else if (typeof item === "string" && /^[,.:;!?)\]]/.test(item) && lastIdx >= 0 && isLine(fillParts[lastIdx])) {
+        fillParts.pop();
+        if (fillParts.length > 0) {
+          fillParts[fillParts.length - 1] = concat([
+            fillParts[fillParts.length - 1],
+            item
+          ]);
+        } else {
+          fillParts.push(item);
+        }
+      } else {
+        fillParts.push(item);
+      }
+    }
+  }
+  if (fillParts.length > 0 && isLine(fillParts[fillParts.length - 1])) {
+    fillParts.pop();
+  }
+  return fill(fillParts);
+}
+function formatBlockChildren(nodes, context) {
+  const lines = [];
+  let currentLine = [];
+  let lastNodeEnd = -1;
+  let pendingBlankLine = false;
+  let blankLineBeforeCurrentLine = false;
+  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) {
+      const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
+      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(flushCurrentLine());
+        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, rawLine: true });
+      }
+      const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+      lines.push({ doc: text(commentText), blankLineBefore: false, rawLine: true });
+      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(flushCurrentLine());
+        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(flushCurrentLine());
+        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, context.customTags);
+    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
+      const prevNode = nodes[i - 1];
+      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)) {
+          currentLine.push(line);
+        }
+      }
+    }
+    if (treatAsBlock) {
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(flushCurrentLine());
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      lines.push({ doc: formatNode(node, context), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+    } else if (node.type === "html_comment" || node.type === "mustache_comment") {
+      const isMultiline = node.startPosition.row !== node.endPosition.row;
+      const isOnOwnLine = i > 0 && node.startPosition.row > nodes[i - 1].endPosition.row;
+      if (isMultiline || isOnOwnLine) {
+        if (currentLine.length > 0) {
+          const lineContent = trimDoc(flushCurrentLine());
+          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;
+      } else {
+        if (currentLine.length === 0) {
+          blankLineBeforeCurrentLine = pendingBlankLine;
+          pendingBlankLine = false;
+        }
+        const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+        currentLine.push(text(commentText));
+      }
+    } else {
+      if (currentLine.length === 0) {
+        blankLineBeforeCurrentLine = pendingBlankLine;
+        pendingBlankLine = false;
+      }
+      const forceInline = isInTextFlow(node, i, nodes);
+      const formatted = formatNode(node, context, forceInline);
+      if (typeof formatted === "string" && formatted.includes("\n")) {
+        const contentLines = formatted.split("\n");
+        const isTextNode = node.type === "text";
+        if (isTextNode) {
+          for (let j = 0; j < contentLines.length; j++) {
+            const trimmed = contentLines[j].trim();
+            if (!trimmed) {
+              if (currentLine.length > 0) {
+                const lineContent = trimDoc(flushCurrentLine());
+                if (hasDocContent(lineContent)) {
+                  lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+                  blankLineBeforeCurrentLine = false;
+                }
+                currentLine = [];
+              }
+              pendingBlankLine = true;
+            } else {
+              if (currentLine.length === 0) {
+                blankLineBeforeCurrentLine = pendingBlankLine;
+                pendingBlankLine = false;
+              }
+              if (j > 0 && currentLine.length > 0) {
+                currentLine.push(line);
+              }
+              currentLine.push(...textWords(trimmed));
+            }
+          }
+        } else {
+          const firstTrimmed = contentLines[0].trim();
+          if (firstTrimmed) {
+            currentLine.push(firstTrimmed);
+          }
+          if (currentLine.length > 0) {
+            const lineContent = trimDoc(flushCurrentLine());
+            if (hasDocContent(lineContent)) {
+              lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+              blankLineBeforeCurrentLine = pendingBlankLine;
+              pendingBlankLine = false;
+            }
+            currentLine = [];
+          }
+          let sawBlankLine = false;
+          for (let j = 1; j < contentLines.length - 1; j++) {
+            const trimmed = contentLines[j].trim();
+            if (trimmed) {
+              lines.push({ doc: text(trimmed), blankLineBefore: blankLineBeforeCurrentLine || sawBlankLine });
+              blankLineBeforeCurrentLine = false;
+              sawBlankLine = false;
+            } else {
+              sawBlankLine = true;
+            }
+          }
+          if (contentLines.length > 1) {
+            const lastTrimmed = contentLines[contentLines.length - 1].trim();
+            if (lastTrimmed) {
+              blankLineBeforeCurrentLine = sawBlankLine;
+              sawBlankLine = false;
+              currentLine = [lastTrimmed];
+            }
+            if (sawBlankLine) {
+              pendingBlankLine = true;
+            }
+          }
+        }
+      } else {
+        if (node.type === "text" && typeof formatted === "string") {
+          const words = textWords(formatted);
+          if (words.length > 0) {
+            currentLine.push(...words);
+          } else if (node.text.trim() === "" && currentLine.length > 0) {
+            currentLine.push(line);
+          }
+        } else {
+          currentLine.push(formatted);
+        }
+      }
+    }
+    if (node.type === "html_element" && currentLine.length > 0) {
+      const tagName = getTagName(node);
+      if (tagName?.toLowerCase() === "br") {
+        const lineContent = trimDoc(flushCurrentLine());
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+          blankLineBeforeCurrentLine = false;
+        }
+        currentLine = [];
+      }
+    }
+    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, rawLine: true });
+    }
+  }
+  if (currentLine.length > 0) {
+    const lineContent = trimDoc(flushCurrentLine());
+    if (hasDocContent(lineContent)) {
+      lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+    }
+  }
+  if (lines.length === 0) {
+    return empty;
+  }
+  const parts = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) {
+      if (lines[i].blankLineBefore) {
+        parts.push("\n");
+      }
+      if (lines[i].rawLine) {
+        parts.push("\n");
+      } else {
+        parts.push(hardline);
+      }
+    }
+    parts.push(lines[i].doc);
+  }
+  return concat(parts);
+}
+function hasDocContent(doc) {
+  if (typeof doc === "string") {
+    return doc.trim().length > 0;
+  }
+  if (doc.type === "concat") {
+    return doc.parts.some(hasDocContent);
+  }
+  if (doc.type === "indent") {
+    return hasDocContent(doc.contents);
+  }
+  if (doc.type === "group") {
+    return hasDocContent(doc.contents);
+  }
+  if (doc.type === "fill") {
+    return doc.parts.some(hasDocContent);
+  }
+  if (doc.type === "ifBreak") {
+    return hasDocContent(doc.breakContents) || hasDocContent(doc.flatContents);
+  }
+  return false;
+}
+function trimDoc(doc) {
+  if (typeof doc === "string") {
+    return doc.trim();
+  }
+  return doc;
+}
+
+// src/core/formatting/mergeOptions.ts
+function mergeOptions(lspOptions, configFile, overrides) {
+  let tabSize = lspOptions.tabSize;
+  if (configFile?.indentSize !== void 0) tabSize = configFile.indentSize;
+  if (overrides?.tabSize !== void 0) tabSize = overrides.tabSize;
+  const insertSpaces = overrides?.insertSpaces ?? lspOptions.insertSpaces;
+  return { tabSize, insertSpaces };
+}
+function createIndentUnit(options) {
+  return options.insertSpaces ? " ".repeat(options.tabSize) : "	";
+}
+
+// src/core/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 { printWidth = 80, embeddedFormatted, mustacheSpaces, noBreakDelimiters } = params;
+  const indentUnit = createIndentUnit(options);
+  if (tree.rootNode.hasError) return [];
+  const customTagMap = buildCustomTagMap(params.customTags);
+  const context = {
+    document,
+    customTags: customTagMap,
+    embeddedFormatted,
+    mustacheSpaces,
+    noBreakDelimiters
+  };
+  const doc = formatDocument(tree.rootNode, context);
+  const formatted = print(doc, { indentUnit, printWidth });
+  const fullRange = {
+    start: { line: 0, character: 0 },
+    end: document.positionAt(document.getText().length)
+  };
+  return [{ range: fullRange, newText: formatted }];
+}
+
+// src/core/embeddedRegions.ts
+function getEmbeddedLanguageId(node) {
+  if (node.type === "html_style_element") {
+    return "css";
+  }
+  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, "").toLowerCase();
+            if (part?.type === "html_attribute_value") value = part.text.toLowerCase();
+          }
+          if (name === "type" && (value === "text/typescript" || value === "ts")) {
+            return "typescript";
+          }
+        }
+      }
+    }
+  }
+  return "javascript";
+}
+function collectEmbeddedRegions(rootNode) {
+  const regions = [];
+  const walk = (node) => {
+    if (node.type === "html_script_element" || node.type === "html_style_element") {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === "html_raw_text") {
+          regions.push({
+            startIndex: child.startIndex,
+            content: child.text,
+            languageId: getEmbeddedLanguageId(node)
+          });
+        }
+      }
+      return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) walk(child);
+    }
+  };
+  walk(rootNode);
+  return regions;
+}
+
+// src/core/formatting/embedded.ts
+var LANGUAGE_TO_PRETTIER_PARSER = {
+  javascript: "babel",
+  typescript: "typescript",
+  css: "css"
+};
+async function formatEmbeddedRegions(rootNode, options, prettier) {
+  const result = /* @__PURE__ */ new Map();
+  if (!prettier) return result;
+  const regions = collectEmbeddedRegions(rootNode);
+  if (regions.length === 0) return result;
+  await Promise.all(
+    regions.map(async (region) => {
+      const parser = LANGUAGE_TO_PRETTIER_PARSER[region.languageId];
+      if (!parser) return;
+      try {
+        const formatted = await prettier.format(region.content, {
+          parser,
+          tabWidth: options.tabSize,
+          useTabs: !options.insertSpaces
+        });
+        result.set(region.startIndex, formatted);
+      } catch {
+      }
+    })
+  );
+  return result;
+}
+
+// src/core/diagnostic.ts
+function toFix(r) {
+  return { range: [r.startIndex, r.endIndex], newText: r.newText };
+}
+function toDiagnostic(err) {
+  const { node } = err;
+  return {
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column + 1,
+    endLine: node.endPosition.row + 1,
+    endColumn: node.endPosition.column + 1,
+    message: err.message,
+    severity: err.severity ?? "error",
+    ruleName: err.ruleName,
+    fix: err.fix && err.fix.length > 0 ? err.fix.map(toFix) : void 0,
+    fixDescription: err.fixDescription
+  };
+}
+
+// src/core/grammar.ts
+var GRAMMAR_WASM_FILENAME = "tree-sitter-htmlmustache.wasm";
+
+// src/browser/index.ts
+var DEFAULT_CONFIG = { rules: RULE_DEFAULTS };
+var DEFAULT_FORMATTING_OPTIONS = { tabSize: 2, insertSpaces: true };
+function toLocateFile(locateWasm) {
+  return typeof locateWasm === "function" ? (name) => locateWasm(name) : void 0;
+}
+function resolveGrammarUrl(locateWasm) {
+  return typeof locateWasm === "string" ? locateWasm : locateWasm(GRAMMAR_WASM_FILENAME);
+}
+async function createLinter(opts) {
+  const { locateWasm, prettier: factoryPrettier } = opts;
+  const locateFile = toLocateFile(locateWasm);
+  await Parser.init(locateFile ? { locateFile } : void 0);
+  const parser = new Parser();
+  const language = await Language.load(resolveGrammarUrl(locateWasm));
+  parser.setLanguage(language);
+  return {
+    lint(source, config) {
+      const tree = parser.parse(source);
+      if (!tree) throw new Error("Failed to parse document");
+      try {
+        const customTagNames = config?.customTags?.map((t) => t.name);
+        const errors = collectErrors(
+          tree,
+          config?.rules,
+          customTagNames,
+          config?.customRules
+        );
+        return errors.map(toDiagnostic);
+      } finally {
+        tree.delete();
+      }
+    },
+    async format(source, config, callOpts) {
+      const prettier = callOpts?.prettier ?? factoryPrettier;
+      const options = mergeOptions(DEFAULT_FORMATTING_OPTIONS, config ?? null);
+      const tree = parser.parse(source);
+      if (!tree) throw new Error("Failed to parse document");
+      try {
+        const embeddedFormatted = await formatEmbeddedRegions(tree.rootNode, options, prettier);
+        const document = TextDocument.create("file:///input", "htmlmustache", 1, source);
+        const edits = formatDocument2(tree, document, options, {
+          customTags: config?.customTags,
+          printWidth: config?.printWidth,
+          mustacheSpaces: config?.mustacheSpaces,
+          noBreakDelimiters: config?.noBreakDelimiters,
+          embeddedFormatted: embeddedFormatted.size > 0 ? embeddedFormatted : void 0
+        });
+        return edits.length === 0 ? source : edits[0].newText;
+      } finally {
+        tree.delete();
+      }
+    }
+  };
+}
+export {
+  DEFAULT_CONFIG,
+  createLinter
+};
+//# sourceMappingURL=index.mjs.map