@reteps/tree-sitter-htmlmustache 0.7.3 → 0.8.0

package/cli/out/main.js

@@ -542,8 +542,8 @@ function parseDocument(source) {
 }
 
 // lsp/server/src/configFile.ts
-var fs = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
 
 // lsp/server/src/ruleMetadata.ts
 var RULES = [
@@ -586,11 +586,16 @@ var RULES = [
     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 KNOWN_RULE_NAMES = new Set(RULES.map((r2) => r2.name));
 var RULE_DEFAULTS = Object.fromEntries(
-  RULES.map((r) => [r.name, r.defaultSeverity])
+  RULES.map((r2) => [r2.name, r2.defaultSeverity])
 );
 
 // lsp/server/src/configFile.ts
@@ -614,41 +619,70 @@ var VALID_CSS_DISPLAY_VALUES = /* @__PURE__ */ new Set([
   "none"
 ]);
 var VALID_RULE_SEVERITIES = /* @__PURE__ */ new Set(["error", "warning", "off"]);
+function parseElementContentTooLongOptions(raw) {
+  if (!Array.isArray(raw.elements)) return null;
+  const elements = [];
+  for (const entry of raw.elements) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const e2 = entry;
+    if (typeof e2.tag !== "string" || e2.tag.length === 0) continue;
+    if (typeof e2.maxBytes !== "number" || !Number.isFinite(e2.maxBytes) || e2.maxBytes < 0) continue;
+    elements.push({ tag: e2.tag, maxBytes: e2.maxBytes });
+  }
+  return { elements };
+}
+var OPTION_PARSERS = {
+  elementContentTooLong: parseElementContentTooLongOptions
+};
+function parseRuleEntry(key, value) {
+  if (typeof value === "string") {
+    return VALID_RULE_SEVERITIES.has(value) ? value : null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const obj = value;
+  if (typeof obj.severity !== "string" || !VALID_RULE_SEVERITIES.has(obj.severity)) return null;
+  const severity = obj.severity;
+  const parser2 = OPTION_PARSERS[key];
+  if (!parser2) return { severity };
+  const options = parser2(obj);
+  if (!options) return { severity };
+  return { severity, ...options };
+}
 var CONFIG_FILENAME = ".htmlmustache.jsonc";
 function parseJsonc(text2) {
   let result = "";
-  let i = 0;
-  while (i < text2.length) {
-    if (text2[i] === '"') {
+  let i2 = 0;
+  while (i2 < text2.length) {
+    if (text2[i2] === '"') {
       result += '"';
-      i++;
-      while (i < text2.length && text2[i] !== '"') {
-        if (text2[i] === "\\") {
-          result += text2[i] + (text2[i + 1] ?? "");
-          i += 2;
+      i2++;
+      while (i2 < text2.length && text2[i2] !== '"') {
+        if (text2[i2] === "\\") {
+          result += text2[i2] + (text2[i2 + 1] ?? "");
+          i2 += 2;
         } else {
-          result += text2[i];
-          i++;
+          result += text2[i2];
+          i2++;
         }
       }
-      if (i < text2.length) {
+      if (i2 < text2.length) {
         result += '"';
-        i++;
+        i2++;
       }
       continue;
     }
-    if (text2[i] === "/" && text2[i + 1] === "/") {
-      while (i < text2.length && text2[i] !== "\n") i++;
+    if (text2[i2] === "/" && text2[i2 + 1] === "/") {
+      while (i2 < text2.length && text2[i2] !== "\n") i2++;
       continue;
     }
-    if (text2[i] === "/" && text2[i + 1] === "*") {
-      i += 2;
-      while (i < text2.length && !(text2[i] === "*" && text2[i + 1] === "/")) i++;
-      i += 2;
+    if (text2[i2] === "/" && text2[i2 + 1] === "*") {
+      i2 += 2;
+      while (i2 < text2.length && !(text2[i2] === "*" && text2[i2 + 1] === "/")) i2++;
+      i2 += 2;
       continue;
     }
-    result += text2[i];
-    i++;
+    result += text2[i2];
+    i2++;
   }
   result = result.replace(/,\s*([}\]])/g, "$1");
   return JSON.parse(result);
@@ -674,21 +708,21 @@ function parseCustomTagArray(arr) {
   const tags = [];
   for (const entry of arr) {
     if (entry && typeof entry === "object" && "name" in entry) {
-      const e = entry;
-      if (typeof e.name !== "string" || e.name.length === 0) continue;
-      const tag = { name: e.name };
-      if (typeof e.display === "string" && VALID_CSS_DISPLAY_VALUES.has(e.display)) {
-        tag.display = e.display;
+      const e2 = entry;
+      if (typeof e2.name !== "string" || e2.name.length === 0) continue;
+      const tag = { name: e2.name };
+      if (typeof e2.display === "string" && VALID_CSS_DISPLAY_VALUES.has(e2.display)) {
+        tag.display = e2.display;
       }
-      if (typeof e.languageAttribute === "string") tag.languageAttribute = e.languageAttribute;
-      if (e.languageMap && typeof e.languageMap === "object" && !Array.isArray(e.languageMap)) {
-        tag.languageMap = e.languageMap;
+      if (typeof e2.languageAttribute === "string") tag.languageAttribute = e2.languageAttribute;
+      if (e2.languageMap && typeof e2.languageMap === "object" && !Array.isArray(e2.languageMap)) {
+        tag.languageMap = e2.languageMap;
       }
-      if (typeof e.languageDefault === "string") tag.languageDefault = e.languageDefault;
-      if (typeof e.indent === "string" && VALID_INDENT_MODES.has(e.indent)) {
-        tag.indent = e.indent;
+      if (typeof e2.languageDefault === "string") tag.languageDefault = e2.languageDefault;
+      if (typeof e2.indent === "string" && VALID_INDENT_MODES.has(e2.indent)) {
+        tag.indent = e2.indent;
       }
-      if (typeof e.indentAttribute === "string") tag.indentAttribute = e.indentAttribute;
+      if (typeof e2.indentAttribute === "string") tag.indentAttribute = e2.indentAttribute;
       tags.push(tag);
     }
   }
@@ -717,11 +751,11 @@ function validateConfig(raw) {
     if (items.length > 0) config.noBreakDelimiters = items;
   }
   if (Array.isArray(obj.include)) {
-    const items = obj.include.filter((s) => typeof s === "string" && s.length > 0);
+    const items = obj.include.filter((s2) => typeof s2 === "string" && s2.length > 0);
     if (items.length > 0) config.include = items;
   }
   if (Array.isArray(obj.exclude)) {
-    const items = obj.exclude.filter((s) => typeof s === "string" && s.length > 0);
+    const items = obj.exclude.filter((s2) => typeof s2 === "string" && s2.length > 0);
     if (items.length > 0) config.exclude = items;
   }
   const parsedCodeTags = parseCustomTagArray(obj.customCodeTags);
@@ -741,10 +775,11 @@ function validateConfig(raw) {
     const rules = {};
     let hasRules = false;
     for (const [key, value] of Object.entries(rawRules)) {
-      if (KNOWN_RULE_NAMES.has(key) && typeof value === "string" && VALID_RULE_SEVERITIES.has(value)) {
-        rules[key] = value;
-        hasRules = true;
-      }
+      if (!KNOWN_RULE_NAMES.has(key)) continue;
+      const entry = parseRuleEntry(key, value);
+      if (entry === null) continue;
+      rules[key] = entry;
+      hasRules = true;
     }
     if (hasRules) config.rules = rules;
   }
@@ -752,13 +787,13 @@ function validateConfig(raw) {
     const rules = [];
     for (const entry of obj.customRules) {
       if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
-      const e = entry;
-      if (typeof e.id !== "string" || e.id.length === 0) continue;
-      if (typeof e.selector !== "string" || e.selector.length === 0) continue;
-      if (typeof e.message !== "string" || e.message.length === 0) continue;
-      const rule = { id: e.id, selector: e.selector, message: e.message };
-      if (typeof e.severity === "string" && VALID_RULE_SEVERITIES.has(e.severity)) {
-        rule.severity = e.severity;
+      const e2 = entry;
+      if (typeof e2.id !== "string" || e2.id.length === 0) continue;
+      if (typeof e2.selector !== "string" || e2.selector.length === 0) continue;
+      if (typeof e2.message !== "string" || e2.message.length === 0) continue;
+      const rule = { id: e2.id, selector: e2.selector, message: e2.message };
+      if (typeof e2.severity === "string" && VALID_RULE_SEVERITIES.has(e2.severity)) {
+        rule.severity = e2.severity;
       }
       rules.push(rule);
     }
@@ -807,7 +842,7 @@ function isHtmlElementType(node) {
 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");
+      const tagNameNode = child.children.find((c2) => c2.type === "html_tag_name");
       if (tagNameNode) return tagNameNode.text;
     }
   }
@@ -815,16 +850,33 @@ function getTagName(node) {
 }
 function getSectionName(node) {
   const beginNode = node.children.find(
-    (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+    (c2) => c2.type === "mustache_section_begin" || c2.type === "mustache_inverted_section_begin"
   );
   if (!beginNode) return null;
-  const tagNameNode = beginNode.children.find((c) => c.type === "mustache_tag_name");
+  const tagNameNode = beginNode.children.find((c2) => c2.type === "mustache_tag_name");
   return tagNameNode?.text ?? null;
 }
 function getErroneousEndTagName(node) {
-  const nameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
+  const nameNode = node.children.find((c2) => c2.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((c2) => c2.type === "mustache_comment_content");
+  return child ? child.text.trim() : null;
+}
+function getPartialName(node) {
+  const child = node.children.find((c2) => c2.type === "mustache_partial_content");
+  return child ? child.text.trim() : null;
+}
 
 // lsp/server/src/htmlBalanceChecker.ts
 function getTagNameLower(element) {
@@ -834,7 +886,7 @@ function getErroneousEndTagNameLower(node) {
   return getErroneousEndTagName(node)?.toLowerCase() ?? null;
 }
 function hasForcedEndTag(element) {
-  return element.children.some((c) => c.type === "html_forced_end_tag");
+  return element.children.some((c2) => c2.type === "html_forced_end_tag");
 }
 function extractFromNodes(nodes) {
   const items = [];
@@ -846,13 +898,13 @@ function extractFromNodes(nodes) {
 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"
+      (c2) => c2.type !== "html_start_tag" && c2.type !== "html_end_tag" && c2.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");
+        const startTag = node.children.find((c2) => c2.type === "html_start_tag");
         items.push({ type: "open", tagName, node: startTag ?? node });
       }
       items.push(...extractFromNodes(contentChildren));
@@ -874,7 +926,7 @@ function extractFromNode(node) {
     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"
+        (c2) => c2.type !== "mustache_section_begin" && c2.type !== "mustache_section_end" && c2.type !== "mustache_erroneous_section_end"
       );
       return [
         {
@@ -891,7 +943,7 @@ function extractFromNode(node) {
     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"
+        (c2) => c2.type !== "mustache_inverted_section_begin" && c2.type !== "mustache_inverted_section_end" && c2.type !== "mustache_erroneous_inverted_section_end"
       );
       return [
         {
@@ -909,17 +961,17 @@ function extractFromNode(node) {
 function mergeAdjacentForks(items) {
   if (items.length === 0) return items;
   const result = [];
-  let i = 0;
-  while (i < items.length) {
-    const item = items[i];
+  let i2 = 0;
+  while (i2 < items.length) {
+    const item = items[i2];
     if (item.type !== "fork") {
       result.push(item);
-      i++;
+      i2++;
       continue;
     }
     const truthy = [...item.truthy];
     const falsy = [...item.falsy];
-    let j = i + 1;
+    let j = i2 + 1;
     while (j < items.length) {
       const next = items[j];
       if (next.type !== "fork" || next.sectionName !== item.sectionName) break;
@@ -933,7 +985,7 @@ function mergeAdjacentForks(items) {
       truthy: mergeAdjacentForks(truthy),
       falsy: mergeAdjacentForks(falsy)
     });
-    i = j;
+    i2 = j;
   }
   return result;
 }
@@ -1074,12 +1126,12 @@ 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");
+      const hasEndTag = node.children.some((c2) => c2.type === "html_end_tag");
+      const hasForcedEnd = node.children.some((c2) => c2.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");
+          const startTag = node.children.find((c2) => c2.type === "html_start_tag");
           errors.push({
             node: startTag ?? node,
             message: `Unclosed HTML tag: <${tagName}>`
@@ -1107,8 +1159,8 @@ function checkHtmlBalance(rootNode) {
   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);
+    for (let i2 = 0; i2 < sectionNames.length; i2++) {
+      assignment.set(sectionNames[i2], (mask & 1 << i2) !== 0);
     }
     const events = flattenPath(items, assignment);
     const condition = formatCondition(assignment);
@@ -1132,7 +1184,7 @@ function checkNestedSameNameSections(rootNode) {
       if (name) {
         if (ancestors.has(name)) {
           const beginNode = node.children.find(
-            (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+            (c2) => c2.type === "mustache_section_begin" || c2.type === "mustache_inverted_section_begin"
           );
           errors.push({
             node: beginNode ?? node,
@@ -1158,7 +1210,7 @@ function checkUnquotedMustacheAttributes(rootNode) {
   const errors = [];
   function visit(node) {
     if (node.type === "html_attribute") {
-      const mustacheNode = node.children.find((c) => c.type === "mustache_interpolation");
+      const mustacheNode = node.children.find((c2) => c2.type === "mustache_interpolation");
       if (mustacheNode) {
         errors.push({
           node: mustacheNode,
@@ -1184,9 +1236,9 @@ 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];
+    for (let i2 = 0; i2 < children.length - 1; i2++) {
+      const current = children[i2];
+      const next = children[i2 + 1];
       if (!isMustacheSection(current) || current.type !== next.type) {
         continue;
       }
@@ -1197,12 +1249,12 @@ function checkConsecutiveSameNameSections(rootNode, sourceText) {
       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);
+      const currentEndTag = current.children.find((c2) => c2.type === endTagType);
+      const nextBeginTag = next.children.find((c2) => c2.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"
+        (c2) => c2.type === "mustache_section_begin" || c2.type === "mustache_inverted_section_begin"
       );
       errors.push({
         node: nextBeginNode ?? next,
@@ -1252,7 +1304,7 @@ 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 tagNameNode = node.children.find((c2) => c2.type === "html_tag_name");
       const tagName = tagNameNode?.text.toLowerCase();
       if (tagName && !VOID_ELEMENTS2.has(tagName)) {
         errors.push({
@@ -1275,8 +1327,8 @@ function checkSelfClosingNonVoidTags(rootNode) {
   visit(rootNode);
   return errors;
 }
-function areMutuallyExclusive(a, b) {
-  for (const ac of a) {
+function areMutuallyExclusive(a2, b) {
+  for (const ac of a2) {
     for (const bc of b) {
       if (ac.name === bc.name && ac.inverted !== bc.inverted) {
         return true;
@@ -1285,11 +1337,11 @@ function areMutuallyExclusive(a, b) {
   }
   return false;
 }
-function formatConditionClause(a, b) {
+function formatConditionClause(a2, b) {
   const seen = /* @__PURE__ */ new Map();
-  for (const c of [...a, ...b]) {
-    if (!seen.has(c.name)) {
-      seen.set(c.name, c.inverted);
+  for (const c2 of [...a2, ...b]) {
+    if (!seen.has(c2.name)) {
+      seen.set(c2.name, c2.inverted);
     }
   }
   if (seen.size === 0) return "";
@@ -1302,12 +1354,12 @@ function formatConditionClause(a, b) {
 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");
+      const nameNode = child.children.find((c2) => c2.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));
+      const section = child.children.find((c2) => isMustacheSection(c2));
       if (section) {
         const name = getSectionName(section);
         if (name) {
@@ -1528,15 +1580,15 @@ var KNOWN_HTML_TAGS = /* @__PURE__ */ new Set([
 ]);
 function checkUnrecognizedHtmlTags(rootNode, customTagNames) {
   const errors = [];
-  const customSet = customTagNames ? new Set(customTagNames.map((n) => n.toLowerCase())) : void 0;
+  const customSet = customTagNames ? new Set(customTagNames.map((n2) => n2.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 tagNameNode = node.type === "html_self_closing_tag" ? node.children.find((c2) => c2.type === "html_tag_name") : node.children.find((c2) => c2.type === "html_start_tag")?.children.find((c2) => c2.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");
+      const tagNameNode = node.children.find((c2) => c2.type === "html_tag_name");
       if (tagNameNode) {
         const tagName = tagNameNode.text.toLowerCase();
         if (!KNOWN_HTML_TAGS.has(tagName) && !customSet?.has(tagName)) {
@@ -1573,19 +1625,19 @@ function checkDuplicateAttributes(rootNode) {
       }
       for (const [, group2] of groups) {
         if (group2.length < 2) continue;
-        for (let i = 1; i < group2.length; i++) {
+        for (let i2 = 1; i2 < group2.length; i2++) {
           let conflictIdx = -1;
-          for (let j = 0; j < i; j++) {
-            if (!areMutuallyExclusive(group2[i].conditions, group2[j].conditions)) {
+          for (let j = 0; j < i2; j++) {
+            if (!areMutuallyExclusive(group2[i2].conditions, group2[j].conditions)) {
               conflictIdx = j;
               break;
             }
           }
           if (conflictIdx >= 0) {
-            const clause = formatConditionClause(group2[conflictIdx].conditions, group2[i].conditions);
+            const clause = formatConditionClause(group2[conflictIdx].conditions, group2[i2].conditions);
             errors.push({
-              node: group2[i].nameNode,
-              message: `Duplicate attribute "${group2[i].nameNode.text}"${clause}`
+              node: group2[i2].nameNode,
+              message: `Duplicate attribute "${group2[i2].nameNode.text}"${clause}`
             });
           }
         }
@@ -1599,264 +1651,685 @@ function checkDuplicateAttributes(rootNode) {
   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((c2) => c2.type === "html_start_tag");
+      const endTag = node.children.find((c2) => c2.type === "html_end_tag");
+      const tagNameNode = startTag?.children.find((c2) => c2.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;
+}
 
-// lsp/server/src/selectorMatcher.ts
-function isNameChar(ch) {
-  return /[a-zA-Z0-9\-_]/.test(ch);
+// node_modules/parsel-js/dist/parsel.min.js
+var e = { 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 };
+var t = /* @__PURE__ */ new Set(["combinator", "comma"]);
+var n = /* @__PURE__ */ new Set(["not", "is", "where", "has", "matches", "-moz-any", "-webkit-any", "nth-child", "nth-last-child"]);
+var s = /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/;
+var r = { "nth-child": s, "nth-last-child": s };
+var o = (t2) => {
+  switch (t2) {
+    case "pseudo-element":
+    case "pseudo-class":
+      return new RegExp(e[t2].source.replace("(?<argument>\xB6*)", "(?<argument>.*)"), "gu");
+    default:
+      return e[t2];
+  }
+};
+function c(e2, t2) {
+  let n2 = 0, s2 = "";
+  for (; t2 < e2.length; t2++) {
+    const r2 = e2[t2];
+    switch (r2) {
+      case "(":
+        ++n2;
+        break;
+      case ")":
+        --n2;
+    }
+    if (s2 += r2, 0 === n2) return s2;
+  }
+  return s2;
+}
+function i(n2, s2 = e) {
+  if (!n2) return [];
+  const r2 = [n2];
+  for (const [e2, t2] of Object.entries(s2)) for (let n3 = 0; n3 < r2.length; n3++) {
+    const s3 = r2[n3];
+    if ("string" != typeof s3) continue;
+    t2.lastIndex = 0;
+    const o3 = t2.exec(s3);
+    if (!o3) continue;
+    const c2 = o3.index - 1, i2 = [], a2 = o3[0], l2 = s3.slice(0, c2 + 1);
+    l2 && i2.push(l2), i2.push({ ...o3.groups, type: e2, content: a2 });
+    const u2 = s3.slice(c2 + a2.length + 1);
+    u2 && i2.push(u2), r2.splice(n3, 1, ...i2);
+  }
+  let o2 = 0;
+  for (const e2 of r2) switch (typeof e2) {
+    case "string":
+      throw new Error(`Unexpected sequence ${e2} found at index ${o2}`);
+    case "object":
+      o2 += e2.content.length, e2.pos = [o2 - e2.content.length, o2], t.has(e2.type) && (e2.content = e2.content.trim() || " ");
+  }
+  return r2;
+}
+var a = /(['"])([^\\\n]*?)\1/g;
+var l = /\\./g;
+function u(t2, n2 = e) {
+  if ("" === (t2 = t2.trim())) return [];
+  const s2 = [];
+  t2 = (t2 = t2.replace(l, ((e2, t3) => (s2.push({ value: e2, offset: t3 }), "\uE000".repeat(e2.length))))).replace(a, ((e2, t3, n3, r3) => (s2.push({ value: e2, offset: r3 }), `${t3}${"\uE001".repeat(n3.length)}${t3}`)));
+  {
+    let e2, n3 = 0;
+    for (; (e2 = t2.indexOf("(", n3)) > -1; ) {
+      const r3 = c(t2, e2);
+      s2.push({ value: r3, offset: e2 }), t2 = `${t2.substring(0, e2)}(${"\xB6".repeat(r3.length - 2)})${t2.substring(e2 + r3.length)}`, n3 = e2 + r3.length;
+    }
+  }
+  const r2 = i(t2, n2), u2 = /* @__PURE__ */ new Set();
+  for (const e2 of s2.reverse()) for (const t3 of r2) {
+    const { offset: n3, value: s3 } = e2;
+    if (!(t3.pos[0] <= n3 && n3 + s3.length <= t3.pos[1])) continue;
+    const { content: r3 } = t3, o2 = n3 - t3.pos[0];
+    t3.content = r3.slice(0, o2) + s3 + r3.slice(o2 + s3.length), t3.content !== r3 && u2.add(t3);
+  }
+  for (const e2 of u2) {
+    const t3 = o(e2.type);
+    if (!t3) throw new Error(`Unknown token type: ${e2.type}`);
+    t3.lastIndex = 0;
+    const n3 = t3.exec(e2.content);
+    if (!n3) throw new Error(`Unable to parse content for ${e2.type}: ${e2.content}`);
+    Object.assign(e2, n3.groups);
+  }
+  return r2;
+}
+function f(e2, { list: t2 = true } = {}) {
+  if (t2 && e2.find(((e3) => "comma" === e3.type))) {
+    const t3 = [], n2 = [];
+    for (let s2 = 0; s2 < e2.length; s2++) if ("comma" === e2[s2].type) {
+      if (0 === n2.length) throw new Error("Incorrect comma at " + s2);
+      t3.push(f(n2, { list: false })), n2.length = 0;
+    } else n2.push(e2[s2]);
+    if (0 === n2.length) throw new Error("Trailing comma");
+    return t3.push(f(n2, { list: false })), { type: "list", list: t3 };
+  }
+  for (let t3 = e2.length - 1; t3 >= 0; t3--) {
+    let n2 = e2[t3];
+    if ("combinator" === n2.type) {
+      let s2 = e2.slice(0, t3), r2 = e2.slice(t3 + 1);
+      return 0 === s2.length ? { type: "relative", combinator: n2.content, right: f(r2) } : { type: "complex", combinator: n2.content, left: f(s2), right: f(r2) };
+    }
+  }
+  switch (e2.length) {
+    case 0:
+      throw new Error("Could not build AST.");
+    case 1:
+      return e2[0];
+    default:
+      return { type: "compound", list: [...e2] };
+  }
 }
-function parseAttributes(raw, pos) {
-  const attrs = [];
-  while (pos.i < raw.length) {
-    if (raw[pos.i] === ":") {
-      if (raw.slice(pos.i, pos.i + 6).toLowerCase() !== ":not([") return attrs;
-      pos.i += 6;
-      const attr = parseOneAttribute(raw, pos, true);
-      if (!attr) return attrs;
-      if (raw[pos.i] !== "]" || raw[pos.i + 1] !== ")") return attrs;
-      pos.i += 2;
-      attrs.push(attr);
-    } else if (raw[pos.i] === "[") {
-      pos.i++;
-      const attr = parseOneAttribute(raw, pos, false);
-      if (!attr) return attrs;
-      if (raw[pos.i] !== "]") return attrs;
-      pos.i++;
-      attrs.push(attr);
-    } else {
+function* p(e2, t2) {
+  switch (e2.type) {
+    case "list":
+      for (let t3 of e2.list) yield* p(t3, e2);
+      break;
+    case "complex":
+      yield* p(e2.left, e2), yield* p(e2.right, e2);
+      break;
+    case "relative":
+      yield* p(e2.right, e2);
+      break;
+    case "compound":
+      yield* e2.list.map(((t3) => [t3, e2]));
       break;
+    default:
+      yield [e2, t2];
+  }
+}
+function m(e2, { recursive: t2 = true, list: s2 = true } = {}) {
+  const o2 = u(e2);
+  if (!o2) return;
+  const c2 = f(o2, { list: s2 });
+  if (!t2) return c2;
+  for (const [e3] of p(c2)) {
+    if ("pseudo-class" !== e3.type || !e3.argument) continue;
+    if (!n.has(e3.name)) continue;
+    let t3 = e3.argument;
+    const s3 = r[e3.name];
+    if (s3) {
+      const n2 = s3.exec(t3);
+      if (!n2) continue;
+      Object.assign(e3, n2.groups), t3 = n2.groups.subtree;
     }
+    t3 && Object.assign(e3, { subtree: m(t3, { recursive: true, list: true }) });
   }
-  return attrs;
+  return c2;
 }
-function parseOneAttribute(raw, pos, negated) {
-  let name = "";
-  while (pos.i < raw.length && isNameChar(raw[pos.i])) {
-    name += raw[pos.i];
-    pos.i++;
-  }
-  if (name.length === 0) return null;
-  let value;
-  if (raw[pos.i] === "=") {
-    pos.i++;
-    value = "";
-    if (raw[pos.i] === '"' || raw[pos.i] === "'") {
-      const quote = raw[pos.i];
-      pos.i++;
-      while (pos.i < raw.length && raw[pos.i] !== quote) {
-        value += raw[pos.i];
-        pos.i++;
+
+// lsp/server/src/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 i2 = 0;
+  const len = raw.length;
+  while (i2 < len) {
+    const ch = raw[i2];
+    if (ch === '"' || ch === "'") {
+      out += ch;
+      i2++;
+      while (i2 < len && raw[i2] !== ch) {
+        if (raw[i2] === "\\" && i2 + 1 < len) {
+          out += raw[i2] + raw[i2 + 1];
+          i2 += 2;
+        } else {
+          out += raw[i2];
+          i2++;
+        }
       }
-      if (pos.i < raw.length) pos.i++;
-    } else {
-      while (pos.i < raw.length && raw[pos.i] !== "]") {
-        value += raw[pos.i];
-        pos.i++;
+      if (i2 < len) {
+        out += raw[i2];
+        i2++;
+      }
+      continue;
+    }
+    if (ch !== "{" || raw[i2 + 1] !== "{") {
+      out += ch;
+      i2++;
+      continue;
+    }
+    if (raw[i2 + 2] === "{") {
+      const end2 = raw.indexOf("}}}", i2 + 3);
+      if (end2 < 0) return null;
+      const inner = raw.slice(i2 + 3, end2).trim();
+      if (inner.length === 0) return null;
+      out += `:m-raw(${inner})`;
+      i2 = end2 + 3;
+      continue;
+    }
+    const end = raw.indexOf("}}", i2 + 2);
+    if (end < 0) return null;
+    const body = raw.slice(i2 + 2, end);
+    i2 = 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 path5 = body.trim();
+        if (path5.length === 0) return null;
+        out += `:m-variable(${path5})`;
+        break;
       }
     }
   }
-  return { name: name.toLowerCase(), value, negated };
+  return out;
 }
 function parseSelector(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return null;
-  const parts = trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  if (parts.length === 0) return null;
-  const alternatives = [];
-  for (const part of parts) {
-    const alt = parseSingleSelector(part);
-    if (!alt) return null;
-    alternatives.push(alt);
-  }
-  return { alternatives };
-}
-function parseSingleSelector(raw) {
-  const segments = [];
-  let i = 0;
-  let nextCombinator = "descendant";
-  while (i < raw.length) {
-    while (i < raw.length && raw[i] === " ") i++;
-    if (i >= raw.length) break;
-    if (raw[i] === ">") {
-      if (segments.length === 0) return null;
-      nextCombinator = "child";
-      i++;
-      while (i < raw.length && raw[i] === " ") i++;
-      if (i >= raw.length) return null;
-      continue;
-    }
-    const pos = { i };
-    const segment = parseOneSegment(raw, pos);
-    if (!segment) return null;
-    i = pos.i;
-    segment.combinator = nextCombinator;
-    nextCombinator = "descendant";
-    segments.push(segment);
+  if (typeof raw !== "string" || raw.trim() === "") return null;
+  const preprocessed = preprocessMustacheLiterals(raw);
+  if (preprocessed === null) return null;
+  let ast;
+  try {
+    ast = m(preprocessed);
+  } catch {
+    return null;
   }
-  if (segments.length === 0) return null;
-  return { segments };
+  if (!ast) return null;
+  const tops = ast.type === "list" ? ast.list : [ast];
+  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 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 parseOneSegment(raw, pos) {
+function mapCombinator(c2) {
+  const trimmed = c2.trim();
+  if (trimmed === "") return "descendant";
+  if (trimmed === ">") return "child";
+  return null;
+}
+function segmentFromCompound(ast) {
+  const tokens = ast.type === "compound" ? ast.list : [ast];
   let kind;
-  let name;
-  if (raw[pos.i] === "#") {
-    kind = "mustache";
-    pos.i++;
-    name = "";
-    while (pos.i < raw.length && isNameChar(raw[pos.i])) {
-      name += raw[pos.i];
-      pos.i++;
-    }
-    if (name.length === 0) name = null;
-    else name = name.toLowerCase();
-    return { kind, name, attributes: [], combinator: "descendant" };
-  }
-  if (raw[pos.i] === "*") {
-    kind = "html";
-    name = null;
-    pos.i++;
-    const attrs2 = parseAttributes(raw, pos);
-    return { kind, name, attributes: attrs2, combinator: "descendant" };
+  let name = null;
+  let pathRegex;
+  const attributes = [];
+  const descendantChecks = [];
+  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 c2 = attributeConstraint(token, false);
+        if (!c2) return null;
+        attributes.push(c2);
+        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)) return null;
+          break;
+        }
+        return null;
+      }
+      default:
+        return null;
+    }
   }
-  if (raw[pos.i] === "[" || raw[pos.i] === ":") {
+  if (kind === void 0) {
     kind = "html";
-    name = null;
-    const attrs2 = parseAttributes(raw, pos);
-    if (attrs2.length === 0) return null;
-    return { kind, name, attributes: attrs2, combinator: "descendant" };
-  }
-  if (!isNameChar(raw[pos.i])) return null;
-  kind = "html";
-  name = "";
-  while (pos.i < raw.length && isNameChar(raw[pos.i])) {
-    name += raw[pos.i];
-    pos.i++;
-  }
-  name = name.toLowerCase();
-  const attrs = parseAttributes(raw, pos);
-  return { kind, name, attributes: attrs, combinator: "descendant" };
-}
-function getNodeAttributes(node) {
+  }
+  const isHtml = kind === "html";
+  const finalAttrs = isHtml ? attributes : [];
+  return { kind, name, pathRegex, attributes: finalAttrs, descendantChecks, 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) {
+  if (!subtree) return false;
+  if (subtree.type === "attribute") {
+    const c2 = attributeConstraint(subtree, true);
+    if (!c2) return false;
+    attributes.push(c2);
+    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 sel = subtreeToSelector(subtree.subtree);
+    if (!sel) return false;
+    descendantChecks.push({ selector: sel, negated: true });
+    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"
+    (c2) => c2.type === "html_start_tag" || c2.type === "html_self_closing_tag"
   );
   if (!startTag) return [];
   const attrs = [];
   for (const child of startTag.children) {
-    if (child.type === "html_attribute") {
-      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 (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 });
     }
+    if (attrName) attrs.push({ name: attrName, value: attrValue });
   }
   return attrs;
 }
+function matchesAttributeValue(has, c2) {
+  if (has === void 0 || c2.value === void 0) return false;
+  const v = c2.value;
+  if (v === "") return false;
+  switch (c2.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 = getNodeAttributes(node);
-  for (const constraint of constraints) {
-    const found = nodeAttrs.find((a) => a.name === constraint.name);
-    if (constraint.negated) {
-      if (found) return false;
-    } else if (constraint.value !== void 0) {
-      if (!found || found.value !== constraint.value) return false;
-    } else {
+  const nodeAttrs = getHtmlAttributes(node);
+  for (const c2 of constraints) {
+    const found = nodeAttrs.find((a2) => a2.name === c2.name);
+    if (c2.negated) {
+      if (!found) continue;
+      if (c2.value === void 0) return false;
+      if (matchesAttributeValue(found.value, c2)) return false;
+      continue;
+    }
+    if (c2.value === void 0) {
       if (!found) return false;
+      continue;
     }
+    if (!found || !matchesAttributeValue(found.value, c2)) return false;
   }
   return true;
 }
-function nodeMatchesSegment(node, segment) {
-  if (segment.kind === "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);
-  }
-  if (!MUSTACHE_SECTION_TYPES.has(node.type)) return false;
-  if (segment.name !== null) {
-    const sectionName = getSectionName(node)?.toLowerCase();
-    if (sectionName !== segment.name) return false;
+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 (const child of node.children) {
+    if (matchSelector(child, selector).length > 0) return true;
+  }
+  return false;
+}
+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) {
+  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);
+  }
+}
 function checkAncestors(ancestors, segments, segIdx, childCombinator) {
   if (segIdx < 0) return true;
   const segment = segments[segIdx];
+  const ancestorKind = ancestorKindForSegment(segment);
+  if (ancestorKind === null) return false;
   if (childCombinator === "child") {
-    for (let a = ancestors.length - 1; a >= 0; a--) {
-      const entry = ancestors[a];
-      if (entry.kind !== segment.kind) continue;
-      if (segment.name !== null && entry.name !== segment.name) return false;
-      if (segment.kind === "html" && segment.attributes.length > 0) {
-        if (!checkAttributes(entry.node, segment.attributes)) return false;
-      }
-      return checkAncestors(ancestors.slice(0, a), segments, segIdx - 1, segment.combinator);
+    for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
+      const entry = ancestors[a2];
+      if (entry.kind !== ancestorKind) 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;
+      return checkAncestors(ancestors.slice(0, a2), segments, segIdx - 1, segment.combinator);
     }
     return false;
   }
-  for (let a = ancestors.length - 1; a >= 0; a--) {
-    const entry = ancestors[a];
-    if (entry.kind !== segment.kind) continue;
-    if (segment.name !== null && entry.name !== segment.name) continue;
-    if (segment.kind === "html" && segment.attributes.length > 0) {
-      if (!checkAttributes(entry.node, segment.attributes)) continue;
-    }
-    if (checkAncestors(ancestors.slice(0, a), segments, segIdx - 1, segment.combinator)) {
+  for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
+    const entry = ancestors[a2];
+    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 (checkAncestors(ancestors.slice(0, a2), segments, segIdx - 1, segment.combinator)) {
       return true;
     }
   }
   return false;
 }
+function ancestorKindForSegment(segment) {
+  if (segment.kind === "html") return "html";
+  if (segment.kind === "section") return "section";
+  if (segment.kind === "inverted") return "inverted";
+  return null;
+}
 function getReportNode(node) {
   if (HTML_ELEMENT_TYPES.has(node.type)) {
     const startTag = node.children.find(
-      (c) => c.type === "html_start_tag" || c.type === "html_self_closing_tag"
+      (c2) => c2.type === "html_start_tag" || c2.type === "html_self_closing_tag"
     );
     return startTag ?? node;
   }
-  if (MUSTACHE_SECTION_TYPES.has(node.type)) {
+  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"
+      (c2) => c2.type === "mustache_section_begin" || c2.type === "mustache_inverted_section_begin"
     );
     return begin ?? node;
   }
   return node;
 }
-function matchAlternative(rootNode, alt) {
+function matchAlternative(rootNode, segments) {
   const results = [];
-  const lastSegment = alt.segments[alt.segments.length - 1];
+  const lastSegment = segments[segments.length - 1];
   function walk(node, ancestors) {
     if (nodeMatchesSegment(node, lastSegment)) {
-      if (alt.segments.length === 1 || checkAncestors(ancestors, alt.segments, alt.segments.length - 2, lastSegment.combinator)) {
+      if (segments.length === 1 || checkAncestors(ancestors, segments, segments.length - 2, lastSegment.combinator)) {
         results.push(getReportNode(node));
       }
     }
     let newAncestors = ancestors;
-    if (HTML_ELEMENT_TYPES.has(node.type)) {
-      const tagName = getTagName(node)?.toLowerCase();
-      if (tagName) {
-        newAncestors = [...ancestors, { kind: "html", name: tagName, node }];
-      }
-    } else if (MUSTACHE_SECTION_TYPES.has(node.type)) {
-      const sectionName = getSectionName(node)?.toLowerCase();
-      if (sectionName) {
-        newAncestors = [...ancestors, { kind: "mustache", name: sectionName, node }];
+    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 }];
       }
     }
-    for (const child of node.children) {
-      walk(child, newAncestors);
-    }
+    for (const child of node.children) walk(child, newAncestors);
   }
   walk(rootNode, []);
   return results;
@@ -1864,7 +2337,7 @@ function matchAlternative(rootNode, alt) {
 function matchSelector(rootNode, selector) {
   const allResults = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const alt of selector.alternatives) {
+  for (const alt of selector) {
     for (const node of matchAlternative(rootNode, alt)) {
       if (!seen.has(node)) {
         seen.add(node);
@@ -1883,7 +2356,7 @@ var ERROR_NODE_TYPES = /* @__PURE__ */ new Set([
 ]);
 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");
+    const tagNameNode = node.children.find((c2) => c2.type === "mustache_erroneous_tag_name");
     return `Mismatched mustache section: {{/${tagNameNode?.text || "?"}}}`;
   }
   if (nodeType === "ERROR") {
@@ -1891,8 +2364,17 @@ function errorMessageForNode(nodeType, node) {
   }
   return `Missing ${nodeType}`;
 }
-function resolveRuleSeverity(rules, ruleName) {
-  return rules?.[ruleName] ?? RULE_DEFAULTS[ruleName] ?? "off";
+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;
@@ -1954,7 +2436,7 @@ function collectErrors(tree, rules, customTagNames, customRules) {
   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 customRuleIds = customRules ? new Set(customRules.map((r2) => r2.id)) : void 0;
   const disabledRules = collectDisabledRules(tree.rootNode, customRuleIds);
   const effectiveRules = { ...rules };
   for (const rule of disabledRules) {
@@ -1969,12 +2451,19 @@ function collectErrors(tree, rules, customTagNames, customRules) {
     { 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: "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 = resolveRuleSeverity(effectiveRules, rule);
+    const { severity, entry } = resolveRuleConfig(effectiveRules, rule);
     if (severity === "off") continue;
-    for (const error of getErrors()) {
+    for (const error of getErrors(entry)) {
       errors.push({
         node: error.node,
         message: error.message,
@@ -1999,7 +2488,7 @@ function collectErrors(tree, rules, customTagNames, customRules) {
     }
   }
   return errors.filter(
-    (e) => !(e.message.includes("HTML comment found") && parseDisableDirective(e.node, customRuleIds) !== null)
+    (e2) => !(e2.message.includes("HTML comment found") && parseDisableDirective(e2.node, customRuleIds) !== null)
   );
 }
 
@@ -2029,12 +2518,12 @@ function formatError(error, source) {
   const contextStart = Math.max(0, errorLine - 2);
   const contextEnd = Math.min(lines.length - 1, error.endLine - 1);
   const gutterWidth = String(contextEnd + 1).length;
-  const pad = (n) => String(n).padStart(gutterWidth);
+  const pad = (n2) => String(n2).padStart(gutterWidth);
   const outputLines = [header];
   outputLines.push(source_default.dim(" ".repeat(gutterWidth) + " |"));
-  for (let i = contextStart; i <= contextEnd; i++) {
-    const lineNum = i + 1;
-    outputLines.push(source_default.dim(`${pad(lineNum)} |`) + " " + lines[i]);
+  for (let i2 = contextStart; i2 <= contextEnd; i2++) {
+    const lineNum = i2 + 1;
+    outputLines.push(source_default.dim(`${pad(lineNum)} |`) + " " + lines[i2]);
   }
   const lastErrorLineIdx = error.endLine - 1;
   const lastLine = lines[lastErrorLineIdx] || "";
@@ -2108,7 +2597,7 @@ function resolveFiles(cliPatterns) {
     return { files: [], config };
   }
   let files = expandGlobs(patterns);
-  files = files.filter((f) => !DEFAULT_EXCLUDE_SEGMENTS.some((seg) => f.includes(seg)));
+  files = files.filter((f2) => !DEFAULT_EXCLUDE_SEGMENTS.some((seg) => f2.includes(seg)));
   if (config?.exclude && config.exclude.length > 0) {
     const cwd = process.cwd();
     const excludeSet = /* @__PURE__ */ new Set();
@@ -2121,7 +2610,7 @@ function resolveFiles(cliPatterns) {
         }
       }
     }
-    files = files.filter((f) => !excludeSet.has(f));
+    files = files.filter((f2) => !excludeSet.has(f2));
   }
   return { files, config };
 }
@@ -2133,13 +2622,13 @@ function applyFixes(source, errors) {
     }
   }
   if (replacements.length === 0) return source;
-  replacements.sort((a, b) => b.startIndex - a.startIndex);
+  replacements.sort((a2, b) => b.startIndex - a2.startIndex);
   let result = source;
   let minIndex = Infinity;
-  for (const r of replacements) {
-    if (r.endIndex > minIndex) continue;
-    result = result.slice(0, r.startIndex) + r.newText + result.slice(r.endIndex);
-    minIndex = r.startIndex;
+  for (const r2 of replacements) {
+    if (r2.endIndex > minIndex) continue;
+    result = result.slice(0, r2.startIndex) + r2.newText + result.slice(r2.endIndex);
+    minIndex = r2.startIndex;
   }
   return result;
 }
@@ -2168,7 +2657,7 @@ async function run(args) {
     return 0;
   }
   const fixMode = args.includes("--fix");
-  const patterns = args.filter((a) => a !== "--fix");
+  const patterns = args.filter((a2) => a2 !== "--fix");
   const { files, config } = resolveFiles(patterns);
   if (files.length === 0) {
     if (patterns.length === 0 && (!config?.include || config.include.length === 0)) {
@@ -2177,8 +2666,8 @@ async function run(args) {
     }
     const displayPatterns = patterns.length > 0 ? patterns : config?.include ?? [];
     console.error(source_default.yellow("No files matched the given patterns:"));
-    for (const p of displayPatterns) {
-      console.error(source_default.yellow(`  ${p}`));
+    for (const p2 of displayPatterns) {
+      console.error(source_default.yellow(`  ${p2}`));
     }
     return 1;
   }
@@ -2189,7 +2678,7 @@ async function run(args) {
   const cwd = process.cwd();
   const errorOutput = [];
   const rules = config?.rules;
-  const customTagNames = config?.customTags?.map((t) => t.name);
+  const customTagNames = config?.customTags?.map((t2) => t2.name);
   const customRules = config?.customRules;
   for (const file of files) {
     const displayPath = import_node_path.default.relative(cwd, file) || file;
@@ -2205,8 +2694,8 @@ async function run(args) {
     }
     const tree = parseDocument(source);
     const errors = collectErrors2(tree, displayPath, rules, customTagNames, customRules);
-    const fileErrors = errors.filter((e) => e.severity !== "warning");
-    const fileWarnings = errors.filter((e) => e.severity === "warning");
+    const fileErrors = errors.filter((e2) => e2.severity !== "warning");
+    const fileWarnings = errors.filter((e2) => e2.severity === "warning");
     if (errors.length > 0) {
       filesWithErrors++;
       totalErrors += fileErrors.length;
@@ -2271,8 +2760,8 @@ var FullTextDocument = class _FullTextDocument {
         let lineOffsets = this._lineOffsets;
         const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
         if (endLine - startLine === addedLineOffsets.length) {
-          for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
-            lineOffsets[i + startLine + 1] = addedLineOffsets[i];
+          for (let i2 = 0, len = addedLineOffsets.length; i2 < len; i2++) {
+            lineOffsets[i2 + startLine + 1] = addedLineOffsets[i2];
           }
         } else {
           if (addedLineOffsets.length < 1e4) {
@@ -2283,8 +2772,8 @@ var FullTextDocument = class _FullTextDocument {
         }
         const diff = change.text.length - (endOffset - startOffset);
         if (diff !== 0) {
-          for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
-            lineOffsets[i] = lineOffsets[i] + diff;
+          for (let i2 = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i2 < len; i2++) {
+            lineOffsets[i2] = lineOffsets[i2] + diff;
           }
         }
       } else if (_FullTextDocument.isFull(change)) {
@@ -2371,26 +2860,26 @@ var TextDocument;
   TextDocument2.update = update;
   function applyEdits(document, edits) {
     const text2 = document.getText();
-    const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
-      const diff = a.range.start.line - b.range.start.line;
+    const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a2, b) => {
+      const diff = a2.range.start.line - b.range.start.line;
       if (diff === 0) {
-        return a.range.start.character - b.range.start.character;
+        return a2.range.start.character - b.range.start.character;
       }
       return diff;
     });
     let lastModifiedOffset = 0;
     const spans = [];
-    for (const e of sortedEdits) {
-      const startOffset = document.offsetAt(e.range.start);
+    for (const e2 of sortedEdits) {
+      const startOffset = document.offsetAt(e2.range.start);
       if (startOffset < lastModifiedOffset) {
         throw new Error("Overlapping edit");
       } else if (startOffset > lastModifiedOffset) {
         spans.push(text2.substring(lastModifiedOffset, startOffset));
       }
-      if (e.newText.length) {
-        spans.push(e.newText);
+      if (e2.newText.length) {
+        spans.push(e2.newText);
       }
-      lastModifiedOffset = document.offsetAt(e.range.end);
+      lastModifiedOffset = document.offsetAt(e2.range.end);
     }
     spans.push(text2.substr(lastModifiedOffset));
     return spans.join("");
@@ -2401,39 +2890,39 @@ function mergeSort(data, compare) {
   if (data.length <= 1) {
     return data;
   }
-  const p = data.length / 2 | 0;
-  const left = data.slice(0, p);
-  const right = data.slice(p);
+  const p2 = data.length / 2 | 0;
+  const left = data.slice(0, p2);
+  const right = data.slice(p2);
   mergeSort(left, compare);
   mergeSort(right, compare);
   let leftIdx = 0;
   let rightIdx = 0;
-  let i = 0;
+  let i2 = 0;
   while (leftIdx < left.length && rightIdx < right.length) {
     const ret = compare(left[leftIdx], right[rightIdx]);
     if (ret <= 0) {
-      data[i++] = left[leftIdx++];
+      data[i2++] = left[leftIdx++];
     } else {
-      data[i++] = right[rightIdx++];
+      data[i2++] = right[rightIdx++];
     }
   }
   while (leftIdx < left.length) {
-    data[i++] = left[leftIdx++];
+    data[i2++] = left[leftIdx++];
   }
   while (rightIdx < right.length) {
-    data[i++] = right[rightIdx++];
+    data[i2++] = right[rightIdx++];
   }
   return data;
 }
 function computeLineOffsets(text2, isAtLineStart, textOffset = 0) {
   const result = isAtLineStart ? [textOffset] : [];
-  for (let i = 0; i < text2.length; i++) {
-    const ch = text2.charCodeAt(i);
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    const ch = text2.charCodeAt(i2);
     if (isEOL(ch)) {
-      if (ch === 13 && i + 1 < text2.length && text2.charCodeAt(i + 1) === 10) {
-        i++;
+      if (ch === 13 && i2 + 1 < text2.length && text2.charCodeAt(i2 + 1) === 10) {
+        i2++;
       }
-      result.push(textOffset + i + 1);
+      result.push(textOffset + i2 + 1);
     }
   }
   return result;
@@ -2466,8 +2955,8 @@ function print(doc, options) {
 }
 function currentColumn(output) {
   let col = 0;
-  for (let i = output.length - 1; i >= 0; i--) {
-    const chunk = output[i];
+  for (let i2 = output.length - 1; i2 >= 0; i2--) {
+    const chunk = output[i2];
     const nlIndex = chunk.lastIndexOf("\n");
     if (nlIndex !== -1) {
       col += chunk.length - nlIndex - 1;
@@ -2577,12 +3066,12 @@ function printDoc(doc, state, output, options) {
 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;
+  for (let i2 = 0; i2 < parts.length; i2++) {
+    const content = parts[i2];
+    const separator = i2 + 1 < parts.length ? parts[i2 + 1] : null;
     printDoc(content, state, output, options);
     if (separator === null) break;
-    const nextContent = i + 2 < parts.length ? parts[i + 2] : null;
+    const nextContent = i2 + 2 < parts.length ? parts[i2 + 2] : null;
     if (nextContent !== null) {
       const testOutput = [];
       const flatState = { ...state, mode: "flat" };
@@ -2600,7 +3089,7 @@ function printFill(parts, state, output, options) {
     } else {
       printDoc(separator, state, output, options);
     }
-    i++;
+    i2++;
   }
 }
 function makeIndent(level, options) {
@@ -2633,10 +3122,10 @@ function indent(contents) {
   if (contents === "") return "";
   return { type: "indent", contents };
 }
-function indentN(contents, n) {
-  if (n <= 0 || contents === "") return contents;
+function indentN(contents, n2) {
+  if (n2 <= 0 || contents === "") return contents;
   let result = contents;
-  for (let i = 0; i < n; i++) {
+  for (let i2 = 0; i2 < n2; i2++) {
     result = indent(result);
   }
   return result;
@@ -2650,7 +3139,7 @@ function ifBreak(breakContents, flatContents, options) {
   return { type: "ifBreak", breakContents, flatContents, groupId: options?.groupId };
 }
 function fill(parts) {
-  const filtered = parts.filter((p) => p !== "");
+  const filtered = parts.filter((p2) => p2 !== "");
   if (filtered.length === 0) return "";
   if (filtered.length === 1) return filtered[0];
   return { type: "fill", parts: filtered };
@@ -2661,12 +3150,12 @@ function isLine(doc) {
 
 // lsp/server/src/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");
+  return text2.split("\n").map((line2) => line2.replace(/[ \t]+/g, " ").trim()).filter((line2, i2, arr) => line2 || i2 > 0 && i2 < arr.length - 1).join("\n");
 }
 function getVisibleChildren(node) {
   const children = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (child && !child.type.startsWith("_")) {
       children.push(child);
     }
@@ -2697,8 +3186,8 @@ ${middle.join("\n")}
 ${last} }}`;
     }
     const trimmed = inner.trim();
-    const s = prefix === "!" ? " " : space;
-    return `{{${prefix}${s}${trimmed}${s}}}`;
+    const s2 = prefix === "!" ? " " : space;
+    return `{{${prefix}${s2}${trimmed}${s2}}}`;
   }
   const plainMatch = raw.match(/^\{\{([\s\S]*)\}\}$/);
   if (plainMatch) {
@@ -2740,8 +3229,8 @@ 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);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (child?.type === "html_start_tag") {
       for (let j = 0; j < child.childCount; j++) {
         const attr = child.child(j);
@@ -2958,8 +3447,8 @@ function getContentNodes(sectionNode) {
   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);
+  for (let i2 = 0; i2 < sectionNode.childCount; i2++) {
+    const child = sectionNode.child(i2);
     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);
@@ -2980,8 +3469,8 @@ function hasImplicitEndTagsRecursive(node) {
     let hasStartTag = false;
     let hasEndTag = false;
     let hasContentChildren = false;
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
+    for (let i2 = 0; i2 < node.childCount; i2++) {
+      const child = node.child(i2);
       if (!child) continue;
       if (child.type === "html_start_tag") hasStartTag = true;
       else if (child.type === "html_end_tag") hasEndTag = true;
@@ -2990,8 +3479,8 @@ function hasImplicitEndTagsRecursive(node) {
     }
     if (hasStartTag && !hasEndTag && hasContentChildren) return true;
   }
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (child && hasImplicitEndTagsRecursive(child)) {
       return true;
     }
@@ -3018,16 +3507,16 @@ function isInTextFlow(node, index, nodes) {
   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;
+  for (let i2 = index - 1; i2 >= 0; i2--) {
+    const n2 = nodes[i2];
+    if (n2.type === "text" && n2.text.trim().length === 0) continue;
+    if (isInlineContentNode(n2)) 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;
+  for (let i2 = index + 1; i2 < nodes.length; i2++) {
+    const n2 = nodes[i2];
+    if (n2.type === "text" && n2.text.trim().length === 0) continue;
+    if (isInlineContentNode(n2)) return true;
     break;
   }
   return false;
@@ -3083,15 +3572,15 @@ function dedentContent(rawContent) {
   }
   if (lines.length === 0) return "";
   let minIndent = Infinity;
-  for (const l of lines) {
-    if (l.trim() === "") continue;
-    const match = l.match(/^(\s*)/);
+  for (const l2 of lines) {
+    if (l2.trim() === "") continue;
+    const match = l2.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");
+  return lines.map((l2) => l2.trim() === "" ? "" : l2.slice(minIndent)).join("\n");
 }
 function resolveIndentMode(node, config) {
   const mode = config.indent ?? "never";
@@ -3102,8 +3591,8 @@ function resolveIndentMode(node, config) {
   return isAttributeTruthy(value);
 }
 function getTagNameFromStartTag(startTag) {
-  for (let i = 0; i < startTag.childCount; i++) {
-    const child = startTag.child(i);
+  for (let i2 = 0; i2 < startTag.childCount; i2++) {
+    const child = startTag.child(i2);
     if (child?.type === "html_tag_name") return child.text.toLowerCase();
   }
   return null;
@@ -3172,8 +3661,8 @@ function formatHtmlElement(node, context, forceInline = false) {
   let endTag = null;
   let hasRealEndTag = false;
   const contentNodes = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (!child) continue;
     if (child.type === "html_start_tag") {
       startTag = child;
@@ -3273,8 +3762,8 @@ function formatHtmlElement(node, context, forceInline = false) {
     const formattedContent = formatBlockChildren(contentNodes, context);
     const hasContent = hasDocContent(formattedContent);
     if (hasContent) {
-      const hasBlockChildren = contentNodes.some((child, i) => {
-        if (!shouldTreatAsBlock(child, i, contentNodes, tags)) {
+      const hasBlockChildren = contentNodes.some((child, i2) => {
+        if (!shouldTreatAsBlock(child, i2, contentNodes, tags)) {
           return false;
         }
         const childDisplay = getCSSDisplay(child, tags);
@@ -3330,8 +3819,8 @@ function formatHtmlElement(node, context, forceInline = false) {
 }
 function formatScriptStyleElement(node, context) {
   const parts = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (!child) continue;
     if (child.type === "html_start_tag") {
       parts.push(formatStartTag(child, context));
@@ -3415,8 +3904,8 @@ function formatMustacheSection(node, context) {
   let beginNode = null;
   let endNode = null;
   const contentNodes = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (!child) continue;
     if (child.type === beginType) {
       beginNode = child;
@@ -3431,7 +3920,7 @@ function formatMustacheSection(node, context) {
     parts.push(text(mustacheText(beginNode.text, context)));
   }
   const hasImplicit = hasImplicitEndTags(contentNodes);
-  const erroneousCount = contentNodes.filter((n) => n.type === "html_erroneous_end_tag").length;
+  const erroneousCount = contentNodes.filter((n2) => n2.type === "html_erroneous_end_tag").length;
   const hasStaircase = !hasImplicit && erroneousCount > 0;
   if (hasStaircase) {
     let virtualDepth = erroneousCount - 1;
@@ -3485,8 +3974,8 @@ function formatMustacheSection(node, context) {
         parts.push(formattedContent);
         parts.push(hardline);
       } else {
-        const hasBlockChildren = contentNodes.some((child, i) => {
-          if (!shouldTreatAsBlock(child, i, contentNodes, context.customTags)) {
+        const hasBlockChildren = contentNodes.some((child, i2) => {
+          if (!shouldTreatAsBlock(child, i2, contentNodes, context.customTags)) {
             return false;
           }
           const childDisplay = getCSSDisplay(child, context.customTags);
@@ -3508,8 +3997,8 @@ function formatMustacheSection(node, context) {
   return group(concat(parts));
 }
 function startTagHasAttributes(startTag) {
-  for (let i = 0; i < startTag.childCount; i++) {
-    const child = startTag.child(i);
+  for (let i2 = 0; i2 < startTag.childCount; i2++) {
+    const child = startTag.child(i2);
     if (!child) continue;
     if (child.type === "html_attribute" || child.type === "mustache_attribute" || child.type === "mustache_interpolation" || child.type === "mustache_triple") {
       return true;
@@ -3520,8 +4009,8 @@ function startTagHasAttributes(startTag) {
 function formatStartTag(node, context, bare = false) {
   let tagNameText = "";
   const attrs = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (!child) continue;
     if (child.type === "html_tag_name") {
       tagNameText = child.text;
@@ -3543,11 +4032,11 @@ function formatStartTag(node, context, bare = false) {
     return text("<" + tagNameText + closingBracket);
   }
   const attrParts = [];
-  for (let i = 0; i < attrs.length; i++) {
-    if (i > 0) {
+  for (let i2 = 0; i2 < attrs.length; i2++) {
+    if (i2 > 0) {
       attrParts.push(line);
     }
-    attrParts.push(attrs[i]);
+    attrParts.push(attrs[i2]);
   }
   const breakClosingBracket = isSelfClosing ? "/>" : ">";
   const inner = concat([
@@ -3559,8 +4048,8 @@ function formatStartTag(node, context, bare = false) {
   return bare ? inner : group(inner);
 }
 function formatEndTag(node) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (child && child.type === "html_tag_name") {
       return text("</" + child.text + ">");
     }
@@ -3569,8 +4058,8 @@ function formatEndTag(node) {
 }
 function formatAttribute(node, context) {
   const parts = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (!child) continue;
     if (child.type === "html_attribute_name") {
       parts.push(text(child.text));
@@ -3595,21 +4084,21 @@ 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++) {
+  for (let i2 = 1; i2 < words.length; i2++) {
     parts.push(line);
-    parts.push(words[i]);
+    parts.push(words[i2]);
   }
   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)
+    (a2, b) => Math.max(b.start.length, b.end.length) - Math.max(a2.start.length, a2.end.length)
   );
   const result = [...parts];
   let activeDelimiter = null;
-  for (let i = 0; i < result.length; i++) {
-    const part = result[i];
+  for (let i2 = 0; i2 < result.length; i2++) {
+    const part = result[i2];
     if (typeof part === "string") {
       if (activeDelimiter === null) {
         for (const delim of sorted) {
@@ -3630,7 +4119,7 @@ function collapseDelimitedRegions(parts, delimiters) {
         }
       }
     } else if (activeDelimiter !== null && isLine(part)) {
-      result[i] = " ";
+      result[i2] = " ";
     }
   }
   return result;
@@ -3682,8 +4171,8 @@ function formatBlockChildren(nodes, context) {
     const parts2 = noBreakDelims ? collapseDelimitedRegions(currentLine, noBreakDelims) : currentLine;
     return inlineContentToFill(parts2);
   }
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
+  for (let i2 = 0; i2 < nodes.length; i2++) {
+    const node = nodes[i2];
     if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd && !inIgnoreRegion) {
       const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
       const newlineCount = (gap.match(/\n/g) || []).length;
@@ -3756,10 +4245,10 @@ function formatBlockChildren(nodes, context) {
       lastNodeEnd = node.endIndex;
       continue;
     }
-    const treatAsBlock = shouldTreatAsBlock(node, i, nodes, context.customTags);
+    const treatAsBlock = shouldTreatAsBlock(node, i2, nodes, context.customTags);
     if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
-      const prevNode = nodes[i - 1];
-      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes, context.customTags);
+      const prevNode = nodes[i2 - 1];
+      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i2 - 1, nodes, context.customTags);
       if (!prevTreatAsBlock && !treatAsBlock) {
         const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
         if (/\s/.test(gap)) {
@@ -3780,7 +4269,7 @@ function formatBlockChildren(nodes, context) {
       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;
+      const isOnOwnLine = i2 > 0 && node.startPosition.row > nodes[i2 - 1].endPosition.row;
       if (isMultiline || isOnOwnLine) {
         if (currentLine.length > 0) {
           const lineContent = trimDoc(flushCurrentLine());
@@ -3806,7 +4295,7 @@ function formatBlockChildren(nodes, context) {
         blankLineBeforeCurrentLine = pendingBlankLine;
         pendingBlankLine = false;
       }
-      const forceInline = isInTextFlow(node, i, nodes);
+      const forceInline = isInTextFlow(node, i2, nodes);
       const formatted = formatNode(node, context, forceInline);
       if (typeof formatted === "string" && formatted.includes("\n")) {
         const contentLines = formatted.split("\n");
@@ -3915,18 +4404,18 @@ function formatBlockChildren(nodes, context) {
     return empty;
   }
   const parts = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (i > 0) {
-      if (lines[i].blankLineBefore) {
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    if (i2 > 0) {
+      if (lines[i2].blankLineBefore) {
         parts.push("\n");
       }
-      if (lines[i].rawLine) {
+      if (lines[i2].rawLine) {
         parts.push("\n");
       } else {
         parts.push(hardline);
       }
     }
-    parts.push(lines[i].doc);
+    parts.push(lines[i2].doc);
   }
   return concat(parts);
 }
@@ -4035,8 +4524,8 @@ function getEmbeddedLanguageId(node) {
   if (node.type === "html_style_element") {
     return "css";
   }
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
     if (child?.type === "html_start_tag") {
       for (let j = 0; j < child.childCount; j++) {
         const attr = child.child(j);
@@ -4062,8 +4551,8 @@ 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);
+      for (let i2 = 0; i2 < node.childCount; i2++) {
+        const child = node.child(i2);
         if (child?.type === "html_raw_text") {
           regions.push({
             startIndex: child.startIndex,
@@ -4074,8 +4563,8 @@ function collectEmbeddedRegions(rootNode) {
       }
       return;
     }
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
+    for (let i2 = 0; i2 < node.childCount; i2++) {
+      const child = node.child(i2);
       if (child) walk(child);
     }
   };
@@ -4115,9 +4604,9 @@ function parseFlags(args) {
     mustacheSpaces: void 0,
     patterns: []
   };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
+  let i2 = 0;
+  while (i2 < args.length) {
+    const arg = args[i2];
     switch (arg) {
       case "--write":
         flags.write = true;
@@ -4129,16 +4618,16 @@ function parseFlags(args) {
         flags.stdin = true;
         break;
       case "--indent-size":
-        i++;
-        flags.indentSize = parseInt(args[i], 10);
+        i2++;
+        flags.indentSize = parseInt(args[i2], 10);
         if (isNaN(flags.indentSize)) {
           console.error(source_default.red("Error: --indent-size requires a number"));
           process.exit(1);
         }
         break;
       case "--print-width":
-        i++;
-        flags.printWidth = parseInt(args[i], 10);
+        i2++;
+        flags.printWidth = parseInt(args[i2], 10);
         if (isNaN(flags.printWidth)) {
           console.error(source_default.red("Error: --print-width requires a number"));
           process.exit(1);
@@ -4151,7 +4640,7 @@ function parseFlags(args) {
         flags.patterns.push(arg);
         break;
     }
-    i++;
+    i2++;
   }
   return flags;
 }