@reteps/tree-sitter-htmlmustache 0.8.1 → 0.9.1

package/cli/out/main.js

@@ -525,11 +525,16 @@ var import_node_path = __toESM(require("node:path"));
 // cli/src/wasm.ts
 var path = __toESM(require("node:path"));
 var import_web_tree_sitter = require("web-tree-sitter");
+
+// src/core/grammar.ts
+var GRAMMAR_WASM_FILENAME = "tree-sitter-htmlmustache.wasm";
+
+// cli/src/wasm.ts
 var parser;
 async function initializeParser() {
   await import_web_tree_sitter.Parser.init();
   parser = new import_web_tree_sitter.Parser();
-  const wasmPath = path.resolve(__dirname, "..", "..", "tree-sitter-htmlmustache.wasm");
+  const wasmPath = path.resolve(__dirname, "..", "..", GRAMMAR_WASM_FILENAME);
   const language = await import_web_tree_sitter.Language.load(wasmPath);
   parser.setLanguage(language);
 }
@@ -545,7 +550,7 @@ function parseDocument(source) {
 var fs = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 
-// lsp/server/src/ruleMetadata.ts
+// src/core/ruleMetadata.ts
 var RULES = [
   {
     name: "nestedDuplicateSections",
@@ -598,7 +603,7 @@ var RULE_DEFAULTS = Object.fromEntries(
   RULES.map((r2) => [r2.name, r2.defaultSeverity])
 );
 
-// lsp/server/src/configFile.ts
+// src/core/configSchema.ts
 var VALID_CSS_DISPLAY_VALUES = /* @__PURE__ */ new Set([
   "block",
   "inline",
@@ -648,7 +653,6 @@ function parseRuleEntry(key, value) {
   if (!options) return { severity };
   return { severity, ...options };
 }
-var CONFIG_FILENAME = ".htmlmustache.jsonc";
 function parseJsonc(text2) {
   let result = "";
   let i2 = 0;
@@ -687,21 +691,6 @@ function parseJsonc(text2) {
   result = result.replace(/,\s*([}\]])/g, "$1");
   return JSON.parse(result);
 }
-function findConfigFile(startDir) {
-  let dir = path2.resolve(startDir);
-  const root = path2.parse(dir).root;
-  while (true) {
-    const candidate = path2.join(dir, CONFIG_FILENAME);
-    try {
-      fs.accessSync(candidate, fs.constants.R_OK);
-      return candidate;
-    } catch {
-    }
-    const parent = path2.dirname(dir);
-    if (parent === dir || dir === root) return null;
-    dir = parent;
-  }
-}
 var VALID_INDENT_MODES = /* @__PURE__ */ new Set(["never", "always", "attribute"]);
 function parseCustomTagArray(arr) {
   if (!Array.isArray(arr)) return [];
@@ -801,6 +790,24 @@ function validateConfig(raw) {
   }
   return config;
 }
+
+// lsp/server/src/configFile.ts
+var CONFIG_FILENAME = ".htmlmustache.jsonc";
+function findConfigFile(startDir) {
+  let dir = path2.resolve(startDir);
+  const root = path2.parse(dir).root;
+  while (true) {
+    const candidate = path2.join(dir, CONFIG_FILENAME);
+    try {
+      fs.accessSync(candidate, fs.constants.R_OK);
+      return candidate;
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir || dir === root) return null;
+    dir = parent;
+  }
+}
 function loadConfigFileForPath(filePath) {
   const dir = path2.dirname(path2.resolve(filePath));
   const configPath = findConfigFile(dir);
@@ -814,7 +821,7 @@ function loadConfigFileForPath(filePath) {
   }
 }
 
-// lsp/server/src/nodeHelpers.ts
+// src/core/nodeHelpers.ts
 var MUSTACHE_SECTION_TYPES = /* @__PURE__ */ new Set([
   "mustache_section",
   "mustache_inverted_section"
@@ -878,7 +885,7 @@ function getPartialName(node) {
   return child ? child.text.trim() : null;
 }
 
-// lsp/server/src/htmlBalanceChecker.ts
+// src/core/htmlBalanceChecker.ts
 function getTagNameLower(element) {
   return getTagName(element)?.toLowerCase() ?? null;
 }
@@ -1175,7 +1182,7 @@ function checkHtmlBalance(rootNode) {
   return allErrors;
 }
 
-// lsp/server/src/mustacheChecks.ts
+// src/core/mustacheChecks.ts
 function checkNestedSameNameSections(rootNode) {
   const errors = [];
   function visit(node, ancestors) {
@@ -1834,7 +1841,7 @@ function m(e2, { recursive: t2 = true, list: s2 = true } = {}) {
   return c2;
 }
 
-// lsp/server/src/selectorMatcher.ts
+// src/core/selectorMatcher.ts
 var MUSTACHE_KIND_PSEUDO = /* @__PURE__ */ new Set([
   "m-section",
   "m-inverted",
@@ -1932,13 +1939,85 @@ function parseSelector(raw) {
   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);
+    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 l2 of lefts) for (const r2 of rights) {
+        out.push({ ...ast, left: l2, right: r2 });
+      }
+      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);
@@ -1956,6 +2035,8 @@ function mapCombinator(c2) {
   const trimmed = c2.trim();
   if (trimmed === "") return "descendant";
   if (trimmed === ">") return "child";
+  if (trimmed === "+") return "adjacent-sibling";
+  if (trimmed === "~") return "general-sibling";
   return null;
 }
 function segmentFromCompound(ast) {
@@ -1966,6 +2047,7 @@ function segmentFromCompound(ast) {
   let rootOnly = false;
   const attributes = [];
   const descendantChecks = [];
+  const selfNegations = [];
   const forbidChange = (requested) => {
     if (kind === void 0) return false;
     if (kind === requested) return false;
@@ -2019,7 +2101,7 @@ function segmentFromCompound(ast) {
           break;
         }
         if (token.name === "not") {
-          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks)) return null;
+          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks, selfNegations)) return null;
           break;
         }
         if (token.name === "root") {
@@ -2041,7 +2123,7 @@ function segmentFromCompound(ast) {
   }
   const isHtml = kind === "html";
   const finalAttrs = isHtml ? attributes : [];
-  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, combinator: "descendant" };
+  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, selfNegations, combinator: "descendant" };
 }
 function mustacheKindFromMarker(name) {
   switch (name) {
@@ -2106,7 +2188,7 @@ function classConstraint(token, negated) {
 function idConstraint(token, negated) {
   return { name: "id", op: "=", value: token.name, negated };
 }
-function applyNegatedSubtree(subtree, attributes, descendantChecks) {
+function applyNegatedSubtree(subtree, attributes, descendantChecks, selfNegations) {
   if (!subtree) return false;
   if (subtree.type === "attribute") {
     const c2 = attributeConstraint(subtree, true);
@@ -2123,9 +2205,14 @@ function applyNegatedSubtree(subtree, attributes, descendantChecks) {
     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 });
+    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;
@@ -2225,11 +2312,20 @@ function checkDescendants(node, checks) {
   return true;
 }
 function hasDescendantMatch(node, selector) {
-  for (const child of node.children) {
-    if (matchSelector(child, selector).length > 0) return true;
+  for (let i2 = 0; i2 < node.children.length; i2++) {
+    if (matchSelector(node.children[i2], selector, node.children, i2).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;
@@ -2239,51 +2335,73 @@ function matchesName(actual, segment) {
 function nodeMatchesSegment(node, segment, rootNode) {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
-    return checkDescendants(node, segment.descendantChecks);
-  }
-  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 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);
       }
-      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) {
+      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 i2 = cursor.indexInSiblings - 1; i2 >= 0; i2--) {
+      const sib = cursor.siblings[i2];
+      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: i2
+      };
+      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 (childCombinator === "child") {
-    for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
-      const entry = ancestors[a2];
+  if (stepCombinator === "child") {
+    for (let a2 = cursor.ancestors.length - 1; a2 >= 0; a2--) {
+      const entry = cursor.ancestors[a2];
       if (entry.kind !== ancestorKind) {
         if (ancestorKind === "root" && entry.kind === "html") return false;
         continue;
@@ -2291,22 +2409,35 @@ function checkAncestors(ancestors, segments, segIdx, childCombinator) {
       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);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
+      const newCursor = {
+        ancestors: cursor.ancestors.slice(0, a2),
+        siblings: entry.siblings,
+        indexInSiblings: entry.indexInSiblings
+      };
+      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
-  for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
-    const entry = ancestors[a2];
+  for (let a2 = cursor.ancestors.length - 1; a2 >= 0; a2--) {
+    const entry = cursor.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;
-    }
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
+    const newCursor = {
+      ancestors: cursor.ancestors.slice(0, a2),
+      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";
@@ -2340,12 +2471,13 @@ function getReportNode(node, rootNode) {
   }
   return node;
 }
-function matchAlternative(rootNode, segments) {
+function matchAlternative(rootNode, segments, rootSiblings, rootIndexInSiblings) {
   const results = [];
   const lastSegment = segments[segments.length - 1];
-  function walk(node, ancestors) {
+  function walk(node, ancestors, siblings, indexInSiblings) {
     if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      if (segments.length === 1 || checkAncestors(ancestors, segments, segments.length - 2, lastSegment.combinator)) {
+      const cursor = { ancestors, siblings, indexInSiblings };
+      if (segments.length === 1 || checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)) {
         results.push(getReportNode(node, rootNode));
       }
     }
@@ -2354,19 +2486,28 @@ function matchAlternative(rootNode, segments) {
     if (ancestorKind !== null) {
       const name = ancestorKind === "html" ? getTagName(node)?.toLowerCase() : getSectionName(node)?.toLowerCase();
       if (name) {
-        newAncestors = [...ancestors, { kind: ancestorKind, name, node }];
+        newAncestors = [...ancestors, { kind: ancestorKind, name, node, siblings, indexInSiblings }];
       }
     }
-    for (const child of node.children) walk(child, newAncestors);
+    for (let i2 = 0; i2 < node.children.length; i2++) {
+      walk(node.children[i2], newAncestors, node.children, i2);
+    }
   }
-  walk(rootNode, [{ kind: "root", name: "", node: rootNode }]);
+  const rootEntry = {
+    kind: "root",
+    name: "",
+    node: rootNode,
+    siblings: rootSiblings,
+    indexInSiblings: rootIndexInSiblings
+  };
+  walk(rootNode, [rootEntry], rootSiblings, rootIndexInSiblings);
   return results;
 }
-function matchSelector(rootNode, selector) {
+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)) {
+    for (const node of matchAlternative(rootNode, alt, siblings, indexInSiblings)) {
       if (!seen.has(node)) {
         seen.add(node);
         allResults.push(node);
@@ -2376,7 +2517,15 @@ function matchSelector(rootNode, selector) {
   return allResults;
 }
 
-// lsp/server/src/collectErrors.ts
+// 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",
@@ -2507,7 +2656,7 @@ function collectErrors(tree, rules, customTagNames, customRules) {
       if (disabledRules.has(rule.id)) continue;
       const severity = rule.severity ?? "error";
       if (severity === "off") continue;
-      const parsed = parseSelector(rule.selector);
+      const parsed = parseSelectorCached(rule.selector);
       if (!parsed) continue;
       const matches = matchSelector(tree.rootNode, parsed);
       for (const node of matches) {
@@ -2520,20 +2669,32 @@ function collectErrors(tree, rules, customTagNames, customRules) {
   );
 }
 
+// src/core/diagnostic.ts
+function toFix(r2) {
+  return { range: [r2.startIndex, r2.endIndex], newText: r2.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
+  };
+}
+
 // cli/src/check.ts
 function collectErrors2(tree, file, rules, customTagNames, customRules) {
   const errors = collectErrors(tree, rules, customTagNames, customRules);
   return errors.map((error) => ({
     file,
-    line: error.node.startPosition.row + 1,
-    column: error.node.startPosition.column + 1,
-    endLine: error.node.endPosition.row + 1,
-    endColumn: error.node.endPosition.column + 1,
-    message: error.message,
     nodeText: error.node.text,
-    severity: error.severity,
-    fix: error.fix,
-    fixDescription: error.fixDescription
+    ...toDiagnostic(error)
   }));
 }
 function formatError(error, source) {
@@ -2645,8 +2806,9 @@ function resolveFiles(cliPatterns) {
 function applyFixes(source, errors) {
   const replacements = [];
   for (const error of errors) {
-    if (error.fix) {
-      replacements.push(...error.fix);
+    if (!error.fix) continue;
+    for (const edit of error.fix) {
+      replacements.push({ startIndex: edit.range[0], endIndex: edit.range[1], newText: edit.newText });
     }
   }
   if (replacements.length === 0) return source;
@@ -2974,7 +3136,7 @@ function getWellformedEdit(textEdit) {
   return textEdit;
 }
 
-// lsp/server/src/formatting/printer.ts
+// src/core/formatting/printer.ts
 function print(doc, options) {
   const output = [];
   const state = { indentLevel: 0, mode: "break", groupModes: /* @__PURE__ */ new Map() };
@@ -3124,7 +3286,7 @@ function makeIndent(level, options) {
   return options.indentUnit.repeat(level);
 }
 
-// lsp/server/src/formatting/ir.ts
+// src/core/formatting/ir.ts
 var hardline = { type: "hardline" };
 var softline = { type: "softline" };
 var line = { type: "line" };
@@ -3176,7 +3338,7 @@ function isLine(doc) {
   return typeof doc === "object" && doc.type === "line";
 }
 
-// lsp/server/src/formatting/utils.ts
+// src/core/formatting/utils.ts
 function normalizeText(text2) {
   return text2.split("\n").map((line2) => line2.replace(/[ \t]+/g, " ").trim()).filter((line2, i2, arr) => line2 || i2 > 0 && i2 < arr.length - 1).join("\n");
 }
@@ -3252,7 +3414,7 @@ function getIgnoreDirective(node) {
   return null;
 }
 
-// lsp/server/src/customCodeTags.ts
+// src/core/customCodeTags.ts
 function isCodeTag(config) {
   return !!(config.languageAttribute || config.languageDefault);
 }
@@ -3281,7 +3443,7 @@ function getAttributeValue(node, attrName) {
   return null;
 }
 
-// lsp/server/src/formatting/classifier.ts
+// src/core/formatting/classifier.ts
 var EMPTY_MAP = /* @__PURE__ */ new Map();
 var CSS_DISPLAY_MAP = {
   // Block elements
@@ -3583,7 +3745,7 @@ function shouldTreatAsBlock(node, index, nodes, customTags = EMPTY_MAP) {
   return isHtmlEl && !shouldHtmlElementStayInline(node, index, nodes, customTags) || isMustacheSec && !isInTextFlow(node, index, nodes) || isBlockLevel(node, customTags) && !isInTextFlow(node, index, nodes);
 }
 
-// lsp/server/src/formatting/formatters.ts
+// src/core/formatting/formatters.ts
 function isAttributeTruthy(value) {
   if (value === null || value === "" || value === "false" || value === "0") {
     return false;
@@ -4475,46 +4637,12 @@ function trimDoc(doc) {
   return doc;
 }
 
-// lsp/server/src/formatting/editorconfig.ts
-var import_editorconfig = require("editorconfig");
-var import_url = require("url");
-function getEditorConfigOptions(uri) {
-  try {
-    if (!uri.startsWith("file://")) {
-      return {};
-    }
-    const filePath = (0, import_url.fileURLToPath)(uri);
-    const config = (0, import_editorconfig.parseSync)(filePath);
-    const result = {};
-    if (config.indent_style === "space") {
-      result.insertSpaces = true;
-    } else if (config.indent_style === "tab") {
-      result.insertSpaces = false;
-    }
-    if (typeof config.indent_size === "number") {
-      result.tabSize = config.indent_size;
-    } else if (config.indent_size === "tab" && typeof config.tab_width === "number") {
-      result.tabSize = config.tab_width;
-    }
-    return result;
-  } catch {
-    return {};
-  }
-}
-function mergeOptions(lspOptions, uri, configFile) {
-  let tabSize = lspOptions.tabSize;
-  let insertSpaces = lspOptions.insertSpaces;
-  if (configFile?.indentSize !== void 0) tabSize = configFile.indentSize;
-  const ec = getEditorConfigOptions(uri);
-  if (ec.tabSize !== void 0) tabSize = ec.tabSize;
-  if (ec.insertSpaces !== void 0) insertSpaces = ec.insertSpaces;
-  return { tabSize, insertSpaces };
-}
+// src/core/formatting/mergeOptions.ts
 function createIndentUnit(options) {
   return options.insertSpaces ? " ".repeat(options.tabSize) : "	";
 }
 
-// lsp/server/src/formatting/index.ts
+// src/core/formatting/index.ts
 function buildCustomTagMap(customTags) {
   if (!customTags || customTags.length === 0) return void 0;
   const map = /* @__PURE__ */ new Map();
@@ -4524,12 +4652,9 @@ function buildCustomTagMap(customTags) {
   return map;
 }
 function formatDocument2(tree, document, options, params = {}) {
-  const { printWidth = 80, embeddedFormatted, mustacheSpaces, noBreakDelimiters, configFile } = params;
-  const mergedOptions = mergeOptions(options, document.uri, configFile);
-  const indentUnit = createIndentUnit(mergedOptions);
-  if (tree.rootNode.hasError) {
-    return [];
-  }
+  const { printWidth = 80, embeddedFormatted, mustacheSpaces, noBreakDelimiters } = params;
+  const indentUnit = createIndentUnit(options);
+  if (tree.rootNode.hasError) return [];
   const customTagMap = buildCustomTagMap(params.customTags);
   const context = {
     document,
@@ -4547,7 +4672,7 @@ function formatDocument2(tree, document, options, params = {}) {
   return [{ range: fullRange, newText: formatted }];
 }
 
-// lsp/server/src/embeddedRegions.ts
+// src/core/embeddedRegions.ts
 function getEmbeddedLanguageId(node) {
   if (node.type === "html_style_element") {
     return "css";
@@ -4600,6 +4725,62 @@ function collectEmbeddedRegions(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 parser2 = LANGUAGE_TO_PRETTIER_PARSER[region.languageId];
+      if (!parser2) return;
+      try {
+        const formatted = await prettier.format(region.content, {
+          parser: parser2,
+          tabWidth: options.tabSize,
+          useTabs: !options.insertSpaces
+        });
+        result.set(region.startIndex, formatted);
+      } catch {
+      }
+    })
+  );
+  return result;
+}
+
+// lsp/server/src/formatting/editorconfig.ts
+var import_editorconfig = require("editorconfig");
+var import_url = require("url");
+function getEditorConfigOptions(uri) {
+  try {
+    if (!uri.startsWith("file://")) {
+      return {};
+    }
+    const filePath = (0, import_url.fileURLToPath)(uri);
+    const config = (0, import_editorconfig.parseSync)(filePath);
+    const result = {};
+    if (config.indent_style === "space") {
+      result.insertSpaces = true;
+    } else if (config.indent_style === "tab") {
+      result.insertSpaces = false;
+    }
+    if (typeof config.indent_size === "number") {
+      result.tabSize = config.indent_size;
+    } else if (config.indent_size === "tab" && typeof config.tab_width === "number") {
+      result.tabSize = config.tab_width;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
 // cli/src/format.ts
 var USAGE2 = `Usage: htmlmustache format [options] [patterns...]
 
@@ -4703,15 +4884,9 @@ function resolveSettings(flags, filePath) {
     printWidth,
     mustacheSpaces,
     noBreakDelimiters,
-    customTags,
-    configFile
+    customTags
   };
 }
-var LANGUAGE_TO_PRETTIER_PARSER = {
-  javascript: "babel",
-  typescript: "typescript",
-  css: "css"
-};
 var prettierModule;
 async function getPrettier() {
   if (prettierModule !== void 0) return prettierModule;
@@ -4723,32 +4898,9 @@ async function getPrettier() {
     return null;
   }
 }
-async function formatEmbeddedRegions(tree, options) {
-  const result = /* @__PURE__ */ new Map();
-  const prettier = await getPrettier();
-  if (!prettier) return result;
-  const regions = collectEmbeddedRegions(tree.rootNode);
-  if (regions.length === 0) return result;
-  await Promise.all(
-    regions.map(async (region) => {
-      const parser2 = LANGUAGE_TO_PRETTIER_PARSER[region.languageId];
-      if (!parser2) return;
-      try {
-        const formatted = await prettier.format(region.content, {
-          parser: parser2,
-          tabWidth: options.tabSize,
-          useTabs: !options.insertSpaces
-        });
-        result.set(region.startIndex, formatted);
-      } catch {
-      }
-    })
-  );
-  return result;
-}
 async function formatSource(source, options, params = {}) {
   const tree = parseDocument(source);
-  const embeddedFormatted = await formatEmbeddedRegions(tree, options);
+  const embeddedFormatted = await formatEmbeddedRegions(tree.rootNode, options, await getPrettier());
   const document = TextDocument.create("file:///stdin", "htmlmustache", 1, source);
   const edits = formatDocument2(tree, document, options, {
     ...params,