@reteps/tree-sitter-htmlmustache 0.0.31 → 0.0.34

package/cli/out/main.js

@@ -0,0 +1,3613 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/color-name/index.js
+var require_color_name = __commonJS({
+  "node_modules/color-name/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      "aliceblue": [240, 248, 255],
+      "antiquewhite": [250, 235, 215],
+      "aqua": [0, 255, 255],
+      "aquamarine": [127, 255, 212],
+      "azure": [240, 255, 255],
+      "beige": [245, 245, 220],
+      "bisque": [255, 228, 196],
+      "black": [0, 0, 0],
+      "blanchedalmond": [255, 235, 205],
+      "blue": [0, 0, 255],
+      "blueviolet": [138, 43, 226],
+      "brown": [165, 42, 42],
+      "burlywood": [222, 184, 135],
+      "cadetblue": [95, 158, 160],
+      "chartreuse": [127, 255, 0],
+      "chocolate": [210, 105, 30],
+      "coral": [255, 127, 80],
+      "cornflowerblue": [100, 149, 237],
+      "cornsilk": [255, 248, 220],
+      "crimson": [220, 20, 60],
+      "cyan": [0, 255, 255],
+      "darkblue": [0, 0, 139],
+      "darkcyan": [0, 139, 139],
+      "darkgoldenrod": [184, 134, 11],
+      "darkgray": [169, 169, 169],
+      "darkgreen": [0, 100, 0],
+      "darkgrey": [169, 169, 169],
+      "darkkhaki": [189, 183, 107],
+      "darkmagenta": [139, 0, 139],
+      "darkolivegreen": [85, 107, 47],
+      "darkorange": [255, 140, 0],
+      "darkorchid": [153, 50, 204],
+      "darkred": [139, 0, 0],
+      "darksalmon": [233, 150, 122],
+      "darkseagreen": [143, 188, 143],
+      "darkslateblue": [72, 61, 139],
+      "darkslategray": [47, 79, 79],
+      "darkslategrey": [47, 79, 79],
+      "darkturquoise": [0, 206, 209],
+      "darkviolet": [148, 0, 211],
+      "deeppink": [255, 20, 147],
+      "deepskyblue": [0, 191, 255],
+      "dimgray": [105, 105, 105],
+      "dimgrey": [105, 105, 105],
+      "dodgerblue": [30, 144, 255],
+      "firebrick": [178, 34, 34],
+      "floralwhite": [255, 250, 240],
+      "forestgreen": [34, 139, 34],
+      "fuchsia": [255, 0, 255],
+      "gainsboro": [220, 220, 220],
+      "ghostwhite": [248, 248, 255],
+      "gold": [255, 215, 0],
+      "goldenrod": [218, 165, 32],
+      "gray": [128, 128, 128],
+      "green": [0, 128, 0],
+      "greenyellow": [173, 255, 47],
+      "grey": [128, 128, 128],
+      "honeydew": [240, 255, 240],
+      "hotpink": [255, 105, 180],
+      "indianred": [205, 92, 92],
+      "indigo": [75, 0, 130],
+      "ivory": [255, 255, 240],
+      "khaki": [240, 230, 140],
+      "lavender": [230, 230, 250],
+      "lavenderblush": [255, 240, 245],
+      "lawngreen": [124, 252, 0],
+      "lemonchiffon": [255, 250, 205],
+      "lightblue": [173, 216, 230],
+      "lightcoral": [240, 128, 128],
+      "lightcyan": [224, 255, 255],
+      "lightgoldenrodyellow": [250, 250, 210],
+      "lightgray": [211, 211, 211],
+      "lightgreen": [144, 238, 144],
+      "lightgrey": [211, 211, 211],
+      "lightpink": [255, 182, 193],
+      "lightsalmon": [255, 160, 122],
+      "lightseagreen": [32, 178, 170],
+      "lightskyblue": [135, 206, 250],
+      "lightslategray": [119, 136, 153],
+      "lightslategrey": [119, 136, 153],
+      "lightsteelblue": [176, 196, 222],
+      "lightyellow": [255, 255, 224],
+      "lime": [0, 255, 0],
+      "limegreen": [50, 205, 50],
+      "linen": [250, 240, 230],
+      "magenta": [255, 0, 255],
+      "maroon": [128, 0, 0],
+      "mediumaquamarine": [102, 205, 170],
+      "mediumblue": [0, 0, 205],
+      "mediumorchid": [186, 85, 211],
+      "mediumpurple": [147, 112, 219],
+      "mediumseagreen": [60, 179, 113],
+      "mediumslateblue": [123, 104, 238],
+      "mediumspringgreen": [0, 250, 154],
+      "mediumturquoise": [72, 209, 204],
+      "mediumvioletred": [199, 21, 133],
+      "midnightblue": [25, 25, 112],
+      "mintcream": [245, 255, 250],
+      "mistyrose": [255, 228, 225],
+      "moccasin": [255, 228, 181],
+      "navajowhite": [255, 222, 173],
+      "navy": [0, 0, 128],
+      "oldlace": [253, 245, 230],
+      "olive": [128, 128, 0],
+      "olivedrab": [107, 142, 35],
+      "orange": [255, 165, 0],
+      "orangered": [255, 69, 0],
+      "orchid": [218, 112, 214],
+      "palegoldenrod": [238, 232, 170],
+      "palegreen": [152, 251, 152],
+      "paleturquoise": [175, 238, 238],
+      "palevioletred": [219, 112, 147],
+      "papayawhip": [255, 239, 213],
+      "peachpuff": [255, 218, 185],
+      "peru": [205, 133, 63],
+      "pink": [255, 192, 203],
+      "plum": [221, 160, 221],
+      "powderblue": [176, 224, 230],
+      "purple": [128, 0, 128],
+      "rebeccapurple": [102, 51, 153],
+      "red": [255, 0, 0],
+      "rosybrown": [188, 143, 143],
+      "royalblue": [65, 105, 225],
+      "saddlebrown": [139, 69, 19],
+      "salmon": [250, 128, 114],
+      "sandybrown": [244, 164, 96],
+      "seagreen": [46, 139, 87],
+      "seashell": [255, 245, 238],
+      "sienna": [160, 82, 45],
+      "silver": [192, 192, 192],
+      "skyblue": [135, 206, 235],
+      "slateblue": [106, 90, 205],
+      "slategray": [112, 128, 144],
+      "slategrey": [112, 128, 144],
+      "snow": [255, 250, 250],
+      "springgreen": [0, 255, 127],
+      "steelblue": [70, 130, 180],
+      "tan": [210, 180, 140],
+      "teal": [0, 128, 128],
+      "thistle": [216, 191, 216],
+      "tomato": [255, 99, 71],
+      "turquoise": [64, 224, 208],
+      "violet": [238, 130, 238],
+      "wheat": [245, 222, 179],
+      "white": [255, 255, 255],
+      "whitesmoke": [245, 245, 245],
+      "yellow": [255, 255, 0],
+      "yellowgreen": [154, 205, 50]
+    };
+  }
+});
+
+// node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+  "node_modules/color-convert/conversions.js"(exports2, module2) {
+    var cssKeywords = require_color_name();
+    var reverseKeywords = {};
+    for (const key of Object.keys(cssKeywords)) {
+      reverseKeywords[cssKeywords[key]] = key;
+    }
+    var convert = {
+      rgb: { channels: 3, labels: "rgb" },
+      hsl: { channels: 3, labels: "hsl" },
+      hsv: { channels: 3, labels: "hsv" },
+      hwb: { channels: 3, labels: "hwb" },
+      cmyk: { channels: 4, labels: "cmyk" },
+      xyz: { channels: 3, labels: "xyz" },
+      lab: { channels: 3, labels: "lab" },
+      lch: { channels: 3, labels: "lch" },
+      hex: { channels: 1, labels: ["hex"] },
+      keyword: { channels: 1, labels: ["keyword"] },
+      ansi16: { channels: 1, labels: ["ansi16"] },
+      ansi256: { channels: 1, labels: ["ansi256"] },
+      hcg: { channels: 3, labels: ["h", "c", "g"] },
+      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+      gray: { channels: 1, labels: ["gray"] }
+    };
+    module2.exports = convert;
+    for (const model of Object.keys(convert)) {
+      if (!("channels" in convert[model])) {
+        throw new Error("missing channels property: " + model);
+      }
+      if (!("labels" in convert[model])) {
+        throw new Error("missing channel labels property: " + model);
+      }
+      if (convert[model].labels.length !== convert[model].channels) {
+        throw new Error("channel and label counts mismatch: " + model);
+      }
+      const { channels, labels } = convert[model];
+      delete convert[model].channels;
+      delete convert[model].labels;
+      Object.defineProperty(convert[model], "channels", { value: channels });
+      Object.defineProperty(convert[model], "labels", { value: labels });
+    }
+    convert.rgb.hsl = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const min = Math.min(r, g, b);
+      const max = Math.max(r, g, b);
+      const delta = max - min;
+      let h;
+      let s;
+      if (max === min) {
+        h = 0;
+      } else if (r === max) {
+        h = (g - b) / delta;
+      } else if (g === max) {
+        h = 2 + (b - r) / delta;
+      } else if (b === max) {
+        h = 4 + (r - g) / delta;
+      }
+      h = Math.min(h * 60, 360);
+      if (h < 0) {
+        h += 360;
+      }
+      const l = (min + max) / 2;
+      if (max === min) {
+        s = 0;
+      } else if (l <= 0.5) {
+        s = delta / (max + min);
+      } else {
+        s = delta / (2 - max - min);
+      }
+      return [h, s * 100, l * 100];
+    };
+    convert.rgb.hsv = function(rgb) {
+      let rdif;
+      let gdif;
+      let bdif;
+      let h;
+      let s;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const v = Math.max(r, g, b);
+      const diff = v - Math.min(r, g, b);
+      const diffc = function(c) {
+        return (v - c) / 6 / diff + 1 / 2;
+      };
+      if (diff === 0) {
+        h = 0;
+        s = 0;
+      } else {
+        s = diff / v;
+        rdif = diffc(r);
+        gdif = diffc(g);
+        bdif = diffc(b);
+        if (r === v) {
+          h = bdif - gdif;
+        } else if (g === v) {
+          h = 1 / 3 + rdif - bdif;
+        } else if (b === v) {
+          h = 2 / 3 + gdif - rdif;
+        }
+        if (h < 0) {
+          h += 1;
+        } else if (h > 1) {
+          h -= 1;
+        }
+      }
+      return [
+        h * 360,
+        s * 100,
+        v * 100
+      ];
+    };
+    convert.rgb.hwb = function(rgb) {
+      const r = rgb[0];
+      const g = rgb[1];
+      let b = rgb[2];
+      const h = convert.rgb.hsl(rgb)[0];
+      const w = 1 / 255 * Math.min(r, Math.min(g, b));
+      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+      return [h, w * 100, b * 100];
+    };
+    convert.rgb.cmyk = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const k = Math.min(1 - r, 1 - g, 1 - b);
+      const c = (1 - r - k) / (1 - k) || 0;
+      const m = (1 - g - k) / (1 - k) || 0;
+      const y = (1 - b - k) / (1 - k) || 0;
+      return [c * 100, m * 100, y * 100, k * 100];
+    };
+    function comparativeDistance(x, y) {
+      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+    }
+    convert.rgb.keyword = function(rgb) {
+      const reversed = reverseKeywords[rgb];
+      if (reversed) {
+        return reversed;
+      }
+      let currentClosestDistance = Infinity;
+      let currentClosestKeyword;
+      for (const keyword of Object.keys(cssKeywords)) {
+        const value = cssKeywords[keyword];
+        const distance = comparativeDistance(rgb, value);
+        if (distance < currentClosestDistance) {
+          currentClosestDistance = distance;
+          currentClosestKeyword = keyword;
+        }
+      }
+      return currentClosestKeyword;
+    };
+    convert.keyword.rgb = function(keyword) {
+      return cssKeywords[keyword];
+    };
+    convert.rgb.xyz = function(rgb) {
+      let r = rgb[0] / 255;
+      let g = rgb[1] / 255;
+      let b = rgb[2] / 255;
+      r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+      g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+      b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+      const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+      const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z * 100];
+    };
+    convert.rgb.lab = function(rgb) {
+      const xyz = convert.rgb.xyz(rgb);
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.hsl.rgb = function(hsl) {
+      const h = hsl[0] / 360;
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      let t2;
+      let t3;
+      let val;
+      if (s === 0) {
+        val = l * 255;
+        return [val, val, val];
+      }
+      if (l < 0.5) {
+        t2 = l * (1 + s);
+      } else {
+        t2 = l + s - l * s;
+      }
+      const t1 = 2 * l - t2;
+      const rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++) {
+        t3 = h + 1 / 3 * -(i - 1);
+        if (t3 < 0) {
+          t3++;
+        }
+        if (t3 > 1) {
+          t3--;
+        }
+        if (6 * t3 < 1) {
+          val = t1 + (t2 - t1) * 6 * t3;
+        } else if (2 * t3 < 1) {
+          val = t2;
+        } else if (3 * t3 < 2) {
+          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+        } else {
+          val = t1;
+        }
+        rgb[i] = val * 255;
+      }
+      return rgb;
+    };
+    convert.hsl.hsv = function(hsl) {
+      const h = hsl[0];
+      let s = hsl[1] / 100;
+      let l = hsl[2] / 100;
+      let smin = s;
+      const lmin = Math.max(l, 0.01);
+      l *= 2;
+      s *= l <= 1 ? l : 2 - l;
+      smin *= lmin <= 1 ? lmin : 2 - lmin;
+      const v = (l + s) / 2;
+      const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+      return [h, sv * 100, v * 100];
+    };
+    convert.hsv.rgb = function(hsv) {
+      const h = hsv[0] / 60;
+      const s = hsv[1] / 100;
+      let v = hsv[2] / 100;
+      const hi = Math.floor(h) % 6;
+      const f = h - Math.floor(h);
+      const p = 255 * v * (1 - s);
+      const q = 255 * v * (1 - s * f);
+      const t = 255 * v * (1 - s * (1 - f));
+      v *= 255;
+      switch (hi) {
+        case 0:
+          return [v, t, p];
+        case 1:
+          return [q, v, p];
+        case 2:
+          return [p, v, t];
+        case 3:
+          return [p, q, v];
+        case 4:
+          return [t, p, v];
+        case 5:
+          return [v, p, q];
+      }
+    };
+    convert.hsv.hsl = function(hsv) {
+      const h = hsv[0];
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const vmin = Math.max(v, 0.01);
+      let sl;
+      let l;
+      l = (2 - s) * v;
+      const lmin = (2 - s) * vmin;
+      sl = s * vmin;
+      sl /= lmin <= 1 ? lmin : 2 - lmin;
+      sl = sl || 0;
+      l /= 2;
+      return [h, sl * 100, l * 100];
+    };
+    convert.hwb.rgb = function(hwb) {
+      const h = hwb[0] / 360;
+      let wh = hwb[1] / 100;
+      let bl = hwb[2] / 100;
+      const ratio = wh + bl;
+      let f;
+      if (ratio > 1) {
+        wh /= ratio;
+        bl /= ratio;
+      }
+      const i = Math.floor(6 * h);
+      const v = 1 - bl;
+      f = 6 * h - i;
+      if ((i & 1) !== 0) {
+        f = 1 - f;
+      }
+      const n = wh + f * (v - wh);
+      let r;
+      let g;
+      let b;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r = v;
+          g = n;
+          b = wh;
+          break;
+        case 1:
+          r = n;
+          g = v;
+          b = wh;
+          break;
+        case 2:
+          r = wh;
+          g = v;
+          b = n;
+          break;
+        case 3:
+          r = wh;
+          g = n;
+          b = v;
+          break;
+        case 4:
+          r = n;
+          g = wh;
+          b = v;
+          break;
+        case 5:
+          r = v;
+          g = wh;
+          b = n;
+          break;
+      }
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.cmyk.rgb = function(cmyk) {
+      const c = cmyk[0] / 100;
+      const m = cmyk[1] / 100;
+      const y = cmyk[2] / 100;
+      const k = cmyk[3] / 100;
+      const r = 1 - Math.min(1, c * (1 - k) + k);
+      const g = 1 - Math.min(1, m * (1 - k) + k);
+      const b = 1 - Math.min(1, y * (1 - k) + k);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.rgb = function(xyz) {
+      const x = xyz[0] / 100;
+      const y = xyz[1] / 100;
+      const z = xyz[2] / 100;
+      let r;
+      let g;
+      let b;
+      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+      b = x * 0.0557 + y * -0.204 + z * 1.057;
+      r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+      g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+      b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
+      r = Math.min(Math.max(0, r), 1);
+      g = Math.min(Math.max(0, g), 1);
+      b = Math.min(Math.max(0, b), 1);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.lab = function(xyz) {
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.lab.xyz = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let x;
+      let y;
+      let z;
+      y = (l + 16) / 116;
+      x = a / 500 + y;
+      z = y - b / 200;
+      const y2 = y ** 3;
+      const x2 = x ** 3;
+      const z2 = z ** 3;
+      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+      x *= 95.047;
+      y *= 100;
+      z *= 108.883;
+      return [x, y, z];
+    };
+    convert.lab.lch = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let h;
+      const hr = Math.atan2(b, a);
+      h = hr * 360 / 2 / Math.PI;
+      if (h < 0) {
+        h += 360;
+      }
+      const c = Math.sqrt(a * a + b * b);
+      return [l, c, h];
+    };
+    convert.lch.lab = function(lch) {
+      const l = lch[0];
+      const c = lch[1];
+      const h = lch[2];
+      const hr = h / 360 * 2 * Math.PI;
+      const a = c * Math.cos(hr);
+      const b = c * Math.sin(hr);
+      return [l, a, b];
+    };
+    convert.rgb.ansi16 = function(args, saturation = null) {
+      const [r, g, b] = args;
+      let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
+      value = Math.round(value / 50);
+      if (value === 0) {
+        return 30;
+      }
+      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+      if (value === 2) {
+        ansi += 60;
+      }
+      return ansi;
+    };
+    convert.hsv.ansi16 = function(args) {
+      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+    };
+    convert.rgb.ansi256 = function(args) {
+      const r = args[0];
+      const g = args[1];
+      const b = args[2];
+      if (r === g && g === b) {
+        if (r < 8) {
+          return 16;
+        }
+        if (r > 248) {
+          return 231;
+        }
+        return Math.round((r - 8) / 247 * 24) + 232;
+      }
+      const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+      return ansi;
+    };
+    convert.ansi16.rgb = function(args) {
+      let color = args % 10;
+      if (color === 0 || color === 7) {
+        if (args > 50) {
+          color += 3.5;
+        }
+        color = color / 10.5 * 255;
+        return [color, color, color];
+      }
+      const mult = (~~(args > 50) + 1) * 0.5;
+      const r = (color & 1) * mult * 255;
+      const g = (color >> 1 & 1) * mult * 255;
+      const b = (color >> 2 & 1) * mult * 255;
+      return [r, g, b];
+    };
+    convert.ansi256.rgb = function(args) {
+      if (args >= 232) {
+        const c = (args - 232) * 10 + 8;
+        return [c, c, c];
+      }
+      args -= 16;
+      let rem;
+      const r = Math.floor(args / 36) / 5 * 255;
+      const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+      const b = rem % 6 / 5 * 255;
+      return [r, g, b];
+    };
+    convert.rgb.hex = function(args) {
+      const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.hex.rgb = function(args) {
+      const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      if (!match) {
+        return [0, 0, 0];
+      }
+      let colorString = match[0];
+      if (match[0].length === 3) {
+        colorString = colorString.split("").map((char) => {
+          return char + char;
+        }).join("");
+      }
+      const integer = parseInt(colorString, 16);
+      const r = integer >> 16 & 255;
+      const g = integer >> 8 & 255;
+      const b = integer & 255;
+      return [r, g, b];
+    };
+    convert.rgb.hcg = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const max = Math.max(Math.max(r, g), b);
+      const min = Math.min(Math.min(r, g), b);
+      const chroma = max - min;
+      let grayscale;
+      let hue;
+      if (chroma < 1) {
+        grayscale = min / (1 - chroma);
+      } else {
+        grayscale = 0;
+      }
+      if (chroma <= 0) {
+        hue = 0;
+      } else if (max === r) {
+        hue = (g - b) / chroma % 6;
+      } else if (max === g) {
+        hue = 2 + (b - r) / chroma;
+      } else {
+        hue = 4 + (r - g) / chroma;
+      }
+      hue /= 6;
+      hue %= 1;
+      return [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert.hsl.hcg = function(hsl) {
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+      let f = 0;
+      if (c < 1) {
+        f = (l - 0.5 * c) / (1 - c);
+      }
+      return [hsl[0], c * 100, f * 100];
+    };
+    convert.hsv.hcg = function(hsv) {
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const c = s * v;
+      let f = 0;
+      if (c < 1) {
+        f = (v - c) / (1 - c);
+      }
+      return [hsv[0], c * 100, f * 100];
+    };
+    convert.hcg.rgb = function(hcg) {
+      const h = hcg[0] / 360;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      if (c === 0) {
+        return [g * 255, g * 255, g * 255];
+      }
+      const pure = [0, 0, 0];
+      const hi = h % 1 * 6;
+      const v = hi % 1;
+      const w = 1 - v;
+      let mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1;
+          pure[1] = v;
+          pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w;
+          pure[1] = 1;
+          pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0;
+          pure[1] = 1;
+          pure[2] = v;
+          break;
+        case 3:
+          pure[0] = 0;
+          pure[1] = w;
+          pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v;
+          pure[1] = 0;
+          pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1;
+          pure[1] = 0;
+          pure[2] = w;
+      }
+      mg = (1 - c) * g;
+      return [
+        (c * pure[0] + mg) * 255,
+        (c * pure[1] + mg) * 255,
+        (c * pure[2] + mg) * 255
+      ];
+    };
+    convert.hcg.hsv = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      let f = 0;
+      if (v > 0) {
+        f = c / v;
+      }
+      return [hcg[0], f * 100, v * 100];
+    };
+    convert.hcg.hsl = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const l = g * (1 - c) + 0.5 * c;
+      let s = 0;
+      if (l > 0 && l < 0.5) {
+        s = c / (2 * l);
+      } else if (l >= 0.5 && l < 1) {
+        s = c / (2 * (1 - l));
+      }
+      return [hcg[0], s * 100, l * 100];
+    };
+    convert.hcg.hwb = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      return [hcg[0], (v - c) * 100, (1 - v) * 100];
+    };
+    convert.hwb.hcg = function(hwb) {
+      const w = hwb[1] / 100;
+      const b = hwb[2] / 100;
+      const v = 1 - b;
+      const c = v - w;
+      let g = 0;
+      if (c < 1) {
+        g = (v - c) / (1 - c);
+      }
+      return [hwb[0], c * 100, g * 100];
+    };
+    convert.apple.rgb = function(apple) {
+      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+    };
+    convert.rgb.apple = function(rgb) {
+      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+    };
+    convert.gray.rgb = function(args) {
+      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+    };
+    convert.gray.hsl = function(args) {
+      return [0, 0, args[0]];
+    };
+    convert.gray.hsv = convert.gray.hsl;
+    convert.gray.hwb = function(gray) {
+      return [0, 100, gray[0]];
+    };
+    convert.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
+    };
+    convert.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
+    };
+    convert.gray.hex = function(gray) {
+      const val = Math.round(gray[0] / 100 * 255) & 255;
+      const integer = (val << 16) + (val << 8) + val;
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.rgb.gray = function(rgb) {
+      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+      return [val / 255 * 100];
+    };
+  }
+});
+
+// node_modules/color-convert/route.js
+var require_route = __commonJS({
+  "node_modules/color-convert/route.js"(exports2, module2) {
+    var conversions = require_conversions();
+    function buildGraph() {
+      const graph = {};
+      const models = Object.keys(conversions);
+      for (let len = models.length, i = 0; i < len; i++) {
+        graph[models[i]] = {
+          // http://jsperf.com/1-vs-infinity
+          // micro-opt, but this is simple.
+          distance: -1,
+          parent: null
+        };
+      }
+      return graph;
+    }
+    function deriveBFS(fromModel) {
+      const graph = buildGraph();
+      const queue = [fromModel];
+      graph[fromModel].distance = 0;
+      while (queue.length) {
+        const current = queue.pop();
+        const adjacents = Object.keys(conversions[current]);
+        for (let len = adjacents.length, i = 0; i < len; i++) {
+          const adjacent = adjacents[i];
+          const node = graph[adjacent];
+          if (node.distance === -1) {
+            node.distance = graph[current].distance + 1;
+            node.parent = current;
+            queue.unshift(adjacent);
+          }
+        }
+      }
+      return graph;
+    }
+    function link(from, to) {
+      return function(args) {
+        return to(from(args));
+      };
+    }
+    function wrapConversion(toModel, graph) {
+      const path5 = [graph[toModel].parent, toModel];
+      let fn = conversions[graph[toModel].parent][toModel];
+      let cur = graph[toModel].parent;
+      while (graph[cur].parent) {
+        path5.unshift(graph[cur].parent);
+        fn = link(conversions[graph[cur].parent][cur], fn);
+        cur = graph[cur].parent;
+      }
+      fn.conversion = path5;
+      return fn;
+    }
+    module2.exports = function(fromModel) {
+      const graph = deriveBFS(fromModel);
+      const conversion = {};
+      const models = Object.keys(graph);
+      for (let len = models.length, i = 0; i < len; i++) {
+        const toModel = models[i];
+        const node = graph[toModel];
+        if (node.parent === null) {
+          continue;
+        }
+        conversion[toModel] = wrapConversion(toModel, graph);
+      }
+      return conversion;
+    };
+  }
+});
+
+// node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+  "node_modules/color-convert/index.js"(exports2, module2) {
+    var conversions = require_conversions();
+    var route = require_route();
+    var convert = {};
+    var models = Object.keys(conversions);
+    function wrapRaw(fn) {
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args = arg0;
+        }
+        return fn(args);
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    function wrapRounded(fn) {
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args = arg0;
+        }
+        const result = fn(args);
+        if (typeof result === "object") {
+          for (let len = result.length, i = 0; i < len; i++) {
+            result[i] = Math.round(result[i]);
+          }
+        }
+        return result;
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    models.forEach((fromModel) => {
+      convert[fromModel] = {};
+      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+      const routes = route(fromModel);
+      const routeModels = Object.keys(routes);
+      routeModels.forEach((toModel) => {
+        const fn = routes[toModel];
+        convert[fromModel][toModel] = wrapRounded(fn);
+        convert[fromModel][toModel].raw = wrapRaw(fn);
+      });
+    });
+    module2.exports = convert;
+  }
+});
+
+// node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+  "node_modules/ansi-styles/index.js"(exports2, module2) {
+    "use strict";
+    var wrapAnsi16 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${code + offset}m`;
+    };
+    var wrapAnsi256 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    var wrapAnsi16m = (fn, offset) => (...args) => {
+      const rgb = fn(...args);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    var ansi2ansi = (n) => n;
+    var rgb2rgb = (r, g, b) => [r, g, b];
+    var setLazyProperty = (object, property, get) => {
+      Object.defineProperty(object, property, {
+        get: () => {
+          const value = get();
+          Object.defineProperty(object, property, {
+            value,
+            enumerable: true,
+            configurable: true
+          });
+          return value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    var colorConvert;
+    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+      if (colorConvert === void 0) {
+        colorConvert = require_color_convert();
+      }
+      const offset = isBackground ? 10 : 0;
+      const styles = {};
+      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+        if (sourceSpace === targetSpace) {
+          styles[name] = wrap(identity, offset);
+        } else if (typeof suite === "object") {
+          styles[name] = wrap(suite[targetSpace], offset);
+        }
+      }
+      return styles;
+    };
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group2] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group2)) {
+          styles[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group2[styleName] = styles[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+          value: group2,
+          enumerable: false
+        });
+      }
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+      setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+      return styles;
+    }
+    Object.defineProperty(module2, "exports", {
+      enumerable: true,
+      get: assembleStyles
+    });
+  }
+});
+
+// node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "node_modules/has-flag/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "node_modules/supports-color/index.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var tty = require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// node_modules/chalk/source/util.js
+var require_util = __commonJS({
+  "node_modules/chalk/source/util.js"(exports2, module2) {
+    "use strict";
+    var stringReplaceAll = (string, substring, replacer) => {
+      let index = string.indexOf(substring);
+      if (index === -1) {
+        return string;
+      }
+      const substringLength = substring.length;
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+        endIndex = index + substringLength;
+        index = string.indexOf(substring, endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        const gotCR = string[index - 1] === "\r";
+        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+        endIndex = index + 1;
+        index = string.indexOf("\n", endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    module2.exports = {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    };
+  }
+});
+
+// node_modules/chalk/source/templates.js
+var require_templates = __commonJS({
+  "node_modules/chalk/source/templates.js"(exports2, module2) {
+    "use strict";
+    var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+    var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+    var ESCAPES = /* @__PURE__ */ new Map([
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["b", "\b"],
+      ["f", "\f"],
+      ["v", "\v"],
+      ["0", "\0"],
+      ["\\", "\\"],
+      ["e", "\x1B"],
+      ["a", "\x07"]
+    ]);
+    function unescape(c) {
+      const u = c[0] === "u";
+      const bracket = c[1] === "{";
+      if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
+        return String.fromCharCode(parseInt(c.slice(1), 16));
+      }
+      if (u && bracket) {
+        return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+      }
+      return ESCAPES.get(c) || c;
+    }
+    function parseArguments(name, arguments_) {
+      const results = [];
+      const chunks = arguments_.trim().split(/\s*,\s*/g);
+      let matches;
+      for (const chunk of chunks) {
+        const number = Number(chunk);
+        if (!Number.isNaN(number)) {
+          results.push(number);
+        } else if (matches = chunk.match(STRING_REGEX)) {
+          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+        } else {
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+        }
+      }
+      return results;
+    }
+    function parseStyle(style) {
+      STYLE_REGEX.lastIndex = 0;
+      const results = [];
+      let matches;
+      while ((matches = STYLE_REGEX.exec(style)) !== null) {
+        const name = matches[1];
+        if (matches[2]) {
+          const args = parseArguments(name, matches[2]);
+          results.push([name].concat(args));
+        } else {
+          results.push([name]);
+        }
+      }
+      return results;
+    }
+    function buildStyle(chalk4, styles) {
+      const enabled = {};
+      for (const layer of styles) {
+        for (const style of layer.styles) {
+          enabled[style[0]] = layer.inverse ? null : style.slice(1);
+        }
+      }
+      let current = chalk4;
+      for (const [styleName, styles2] of Object.entries(enabled)) {
+        if (!Array.isArray(styles2)) {
+          continue;
+        }
+        if (!(styleName in current)) {
+          throw new Error(`Unknown Chalk style: ${styleName}`);
+        }
+        current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
+      }
+      return current;
+    }
+    module2.exports = (chalk4, temporary) => {
+      const styles = [];
+      const chunks = [];
+      let chunk = [];
+      temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+        if (escapeCharacter) {
+          chunk.push(unescape(escapeCharacter));
+        } else if (style) {
+          const string = chunk.join("");
+          chunk = [];
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk4, styles)(string));
+          styles.push({ inverse, styles: parseStyle(style) });
+        } else if (close) {
+          if (styles.length === 0) {
+            throw new Error("Found extraneous } in Chalk template literal");
+          }
+          chunks.push(buildStyle(chalk4, styles)(chunk.join("")));
+          chunk = [];
+          styles.pop();
+        } else {
+          chunk.push(character);
+        }
+      });
+      chunks.push(chunk.join(""));
+      if (styles.length > 0) {
+        const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMessage);
+      }
+      return chunks.join("");
+    };
+  }
+});
+
+// node_modules/chalk/source/index.js
+var require_source = __commonJS({
+  "node_modules/chalk/source/index.js"(exports2, module2) {
+    "use strict";
+    var ansiStyles = require_ansi_styles();
+    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+    var {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    } = require_util();
+    var { isArray } = Array;
+    var levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    var styles = /* @__PURE__ */ Object.create(null);
+    var applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    var ChalkClass = class {
+      constructor(options) {
+        return chalkFactory(options);
+      }
+    };
+    var chalkFactory = (options) => {
+      const chalk5 = {};
+      applyOptions(chalk5, options);
+      chalk5.template = (...arguments_) => chalkTag(chalk5.template, ...arguments_);
+      Object.setPrototypeOf(chalk5, Chalk.prototype);
+      Object.setPrototypeOf(chalk5.template, chalk5);
+      chalk5.template.constructor = () => {
+        throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+      };
+      chalk5.template.Instance = ChalkClass;
+      return chalk5.template;
+    };
+    function Chalk(options) {
+      return chalkFactory(options);
+    }
+    for (const [styleName, style] of Object.entries(ansiStyles)) {
+      styles[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles.visible = {
+      get() {
+        const builder = createBuilder(this, this._styler, true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+    for (const model of usedModels) {
+      styles[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    for (const model of usedModels) {
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    var proto = Object.defineProperties(() => {
+    }, {
+      ...styles,
+      level: {
+        enumerable: true,
+        get() {
+          return this._generator.level;
+        },
+        set(level) {
+          this._generator.level = level;
+        }
+      }
+    });
+    var createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    var createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => {
+        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+          return applyStyle(builder, chalkTag(builder, ...arguments_));
+        }
+        return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      };
+      Object.setPrototypeOf(builder, proto);
+      builder._generator = self;
+      builder._styler = _styler;
+      builder._isEmpty = _isEmpty;
+      return builder;
+    };
+    var applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self._isEmpty ? "" : string;
+      }
+      let styler = self._styler;
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.indexOf("\x1B") !== -1) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    var template;
+    var chalkTag = (chalk5, ...strings) => {
+      const [firstString] = strings;
+      if (!isArray(firstString) || !isArray(firstString.raw)) {
+        return strings.join(" ");
+      }
+      const arguments_ = strings.slice(1);
+      const parts = [firstString.raw[0]];
+      for (let i = 1; i < firstString.length; i++) {
+        parts.push(
+          String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
+          String(firstString.raw[i])
+        );
+      }
+      if (template === void 0) {
+        template = require_templates();
+      }
+      return template(chalk5, parts.join(""));
+    };
+    Object.defineProperties(Chalk.prototype, styles);
+    var chalk4 = Chalk();
+    chalk4.supportsColor = stdoutColor;
+    chalk4.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk4.stderr.supportsColor = stderrColor;
+    module2.exports = chalk4;
+  }
+});
+
+// cli/src/main.ts
+var import_chalk3 = __toESM(require_source());
+
+// cli/src/check.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_chalk = __toESM(require_source());
+function loadParser() {
+  let Parser2;
+  try {
+    Parser2 = require("tree-sitter");
+  } catch {
+    console.error(
+      import_chalk.default.red("Error: tree-sitter is not installed.\n") + "Install it with: npm install tree-sitter"
+    );
+    process.exit(1);
+  }
+  let language;
+  try {
+    language = require(import_node_path.default.resolve(__dirname, "..", ".."));
+  } catch {
+    console.error(
+      import_chalk.default.red("Error: could not load tree-sitter-htmlmustache bindings.\n") + 'Run "npm install" in the tree-sitter-htmlmustache root first.'
+    );
+    process.exit(1);
+  }
+  const parser2 = new Parser2();
+  parser2.setLanguage(language);
+  return parser2;
+}
+function errorMessageForNode(nodeType, node) {
+  if (nodeType === "mustache_erroneous_section_end" || nodeType === "mustache_erroneous_inverted_section_end") {
+    const tagNameNode = node.children.find((c) => c.type === "mustache_erroneous_tag_name");
+    return `Mismatched mustache section: {{/${tagNameNode?.text || "?"}}}`;
+  }
+  if (nodeType === "html_erroneous_end_tag") {
+    const tagNameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
+    return `Mismatched HTML end tag: </${tagNameNode?.text || "?"}>`;
+  }
+  if (nodeType === "ERROR") {
+    return "Syntax error";
+  }
+  return `Missing ${nodeType}`;
+}
+var ERROR_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ERROR",
+  "mustache_erroneous_section_end",
+  "mustache_erroneous_inverted_section_end",
+  "html_erroneous_end_tag"
+]);
+function collectErrors(tree, file) {
+  const errors = [];
+  const cursor = tree.walk();
+  function visit() {
+    const node = cursor.currentNode;
+    const nodeType = cursor.nodeType;
+    if (ERROR_NODE_TYPES.has(nodeType) || cursor.nodeIsMissing) {
+      errors.push({
+        file,
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        message: errorMessageForNode(nodeType, node),
+        nodeText: node.text
+      });
+      if (nodeType === "ERROR") return;
+    }
+    if (cursor.gotoFirstChild()) {
+      do {
+        visit();
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+  }
+  visit();
+  return errors;
+}
+function formatError(error, source) {
+  const lines = source.split("\n");
+  const errorLine = error.line - 1;
+  const header = import_chalk.default.bold(`${error.file}:${error.line}:${error.column}`) + " " + import_chalk.default.red("error") + ": " + error.message;
+  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 outputLines = [header];
+  outputLines.push(import_chalk.default.dim(" ".repeat(gutterWidth) + " |"));
+  for (let i = contextStart; i <= contextEnd; i++) {
+    const lineNum = i + 1;
+    outputLines.push(import_chalk.default.dim(`${pad(lineNum)} |`) + " " + lines[i]);
+  }
+  const lastErrorLineIdx = error.endLine - 1;
+  const lastLine = lines[lastErrorLineIdx] || "";
+  let underlineStart;
+  let underlineEnd;
+  if (error.line === error.endLine) {
+    underlineStart = error.column - 1;
+    underlineEnd = error.endColumn - 1;
+  } else {
+    underlineStart = 0;
+    underlineEnd = lastLine.length;
+  }
+  const underlineLength = Math.max(1, underlineEnd - underlineStart);
+  const underline = " ".repeat(underlineStart) + "^".repeat(underlineLength) + " " + error.message;
+  outputLines.push(import_chalk.default.dim(" ".repeat(gutterWidth) + " |") + " " + import_chalk.default.red(underline));
+  return outputLines.join("\n");
+}
+function formatSummary(totalErrors, filesWithErrors, totalFiles) {
+  if (totalErrors === 0) {
+    return import_chalk.default.green(`No errors found (${totalFiles} ${totalFiles === 1 ? "file" : "files"} checked)`);
+  }
+  const errStr = totalErrors === 1 ? "error" : "errors";
+  const errFileStr = filesWithErrors === 1 ? "file" : "files";
+  const totalStr = totalFiles === 1 ? "file" : "files";
+  return import_chalk.default.red(`${totalErrors} ${errStr} in ${filesWithErrors} ${errFileStr}`) + ` (${totalFiles} ${totalStr} checked)`;
+}
+function expandGlobs(patterns) {
+  const files = /* @__PURE__ */ new Set();
+  const cwd = process.cwd();
+  for (const pattern of patterns) {
+    if (!pattern.includes("*") && !pattern.includes("?")) {
+      const resolved = import_node_path.default.resolve(cwd, pattern);
+      if (import_node_fs.default.existsSync(resolved)) {
+        files.add(resolved);
+      }
+    } else {
+      for (const match of import_node_fs.default.globSync(pattern, { cwd })) {
+        files.add(import_node_path.default.resolve(cwd, match));
+      }
+    }
+  }
+  return [...files].sort();
+}
+var USAGE = `Usage: htmlmustache check <patterns...>
+
+Check HTML Mustache templates for errors.
+
+Arguments:
+  patterns  One or more glob patterns (e.g. '**/*.mustache' '**/*.hbs')
+
+Options:
+  --help    Show this help message
+
+Examples:
+  htmlmustache check '**/*.mustache'
+  htmlmustache check 'templates/**/*.hbs' 'partials/**/*.mustache'`;
+function run(args) {
+  if (args[0] === "check") {
+    args = args.slice(1);
+  }
+  if (args.includes("--help") || args.length === 0) {
+    console.log(USAGE);
+    return args.includes("--help") ? 0 : 1;
+  }
+  const files = expandGlobs(args);
+  if (files.length === 0) {
+    console.error(import_chalk.default.yellow("No files matched the given patterns:"));
+    for (const arg of args) {
+      console.error(import_chalk.default.yellow(`  ${arg}`));
+    }
+    return 1;
+  }
+  const parser2 = loadParser();
+  let totalErrors = 0;
+  let filesWithErrors = 0;
+  const cwd = process.cwd();
+  const errorOutput = [];
+  for (const file of files) {
+    const displayPath = import_node_path.default.relative(cwd, file) || file;
+    const source = import_node_fs.default.readFileSync(file, "utf-8");
+    const tree = parser2.parse(source);
+    const errors = collectErrors(tree, displayPath);
+    if (errors.length > 0) {
+      filesWithErrors++;
+      totalErrors += errors.length;
+      for (const error of errors) {
+        errorOutput.push(formatError(error, source));
+      }
+    }
+    console.log(errors.length > 0 ? import_chalk.default.red(displayPath) : import_chalk.default.dim(displayPath));
+  }
+  if (errorOutput.length > 0) {
+    console.log();
+    for (const output of errorOutput) {
+      console.log(output);
+      console.log();
+    }
+  }
+  console.log(formatSummary(totalErrors, filesWithErrors, files.length));
+  return totalErrors > 0 ? 1 : 0;
+}
+
+// cli/src/format.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_chalk2 = __toESM(require_source());
+
+// node_modules/vscode-languageserver-textdocument/lib/esm/main.js
+var FullTextDocument = class _FullTextDocument {
+  constructor(uri, languageId, version, content) {
+    this._uri = uri;
+    this._languageId = languageId;
+    this._version = version;
+    this._content = content;
+    this._lineOffsets = void 0;
+  }
+  get uri() {
+    return this._uri;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get version() {
+    return this._version;
+  }
+  getText(range) {
+    if (range) {
+      const start = this.offsetAt(range.start);
+      const end = this.offsetAt(range.end);
+      return this._content.substring(start, end);
+    }
+    return this._content;
+  }
+  update(changes, version) {
+    for (const change of changes) {
+      if (_FullTextDocument.isIncremental(change)) {
+        const range = getWellformedRange(change.range);
+        const startOffset = this.offsetAt(range.start);
+        const endOffset = this.offsetAt(range.end);
+        this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
+        const startLine = Math.max(range.start.line, 0);
+        const endLine = Math.max(range.end.line, 0);
+        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];
+          }
+        } else {
+          if (addedLineOffsets.length < 1e4) {
+            lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
+          } else {
+            this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
+          }
+        }
+        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;
+          }
+        }
+      } else if (_FullTextDocument.isFull(change)) {
+        this._content = change.text;
+        this._lineOffsets = void 0;
+      } else {
+        throw new Error("Unknown change event received");
+      }
+    }
+    this._version = version;
+  }
+  getLineOffsets() {
+    if (this._lineOffsets === void 0) {
+      this._lineOffsets = computeLineOffsets(this._content, true);
+    }
+    return this._lineOffsets;
+  }
+  positionAt(offset) {
+    offset = Math.max(Math.min(offset, this._content.length), 0);
+    const lineOffsets = this.getLineOffsets();
+    let low = 0, high = lineOffsets.length;
+    if (high === 0) {
+      return { line: 0, character: offset };
+    }
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (lineOffsets[mid] > offset) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    const line2 = low - 1;
+    offset = this.ensureBeforeEOL(offset, lineOffsets[line2]);
+    return { line: line2, character: offset - lineOffsets[line2] };
+  }
+  offsetAt(position) {
+    const lineOffsets = this.getLineOffsets();
+    if (position.line >= lineOffsets.length) {
+      return this._content.length;
+    } else if (position.line < 0) {
+      return 0;
+    }
+    const lineOffset = lineOffsets[position.line];
+    if (position.character <= 0) {
+      return lineOffset;
+    }
+    const nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+    const offset = Math.min(lineOffset + position.character, nextLineOffset);
+    return this.ensureBeforeEOL(offset, lineOffset);
+  }
+  ensureBeforeEOL(offset, lineOffset) {
+    while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {
+      offset--;
+    }
+    return offset;
+  }
+  get lineCount() {
+    return this.getLineOffsets().length;
+  }
+  static isIncremental(event) {
+    const candidate = event;
+    return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
+  }
+  static isFull(event) {
+    const candidate = event;
+    return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
+  }
+};
+var TextDocument;
+(function(TextDocument2) {
+  function create(uri, languageId, version, content) {
+    return new FullTextDocument(uri, languageId, version, content);
+  }
+  TextDocument2.create = create;
+  function update(document, changes, version) {
+    if (document instanceof FullTextDocument) {
+      document.update(changes, version);
+      return document;
+    } else {
+      throw new Error("TextDocument.update: document must be created by TextDocument.create");
+    }
+  }
+  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;
+      if (diff === 0) {
+        return a.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);
+      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);
+      }
+      lastModifiedOffset = document.offsetAt(e.range.end);
+    }
+    spans.push(text2.substr(lastModifiedOffset));
+    return spans.join("");
+  }
+  TextDocument2.applyEdits = applyEdits;
+})(TextDocument || (TextDocument = {}));
+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);
+  mergeSort(left, compare);
+  mergeSort(right, compare);
+  let leftIdx = 0;
+  let rightIdx = 0;
+  let i = 0;
+  while (leftIdx < left.length && rightIdx < right.length) {
+    const ret = compare(left[leftIdx], right[rightIdx]);
+    if (ret <= 0) {
+      data[i++] = left[leftIdx++];
+    } else {
+      data[i++] = right[rightIdx++];
+    }
+  }
+  while (leftIdx < left.length) {
+    data[i++] = left[leftIdx++];
+  }
+  while (rightIdx < right.length) {
+    data[i++] = 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);
+    if (isEOL(ch)) {
+      if (ch === 13 && i + 1 < text2.length && text2.charCodeAt(i + 1) === 10) {
+        i++;
+      }
+      result.push(textOffset + i + 1);
+    }
+  }
+  return result;
+}
+function isEOL(char) {
+  return char === 13 || char === 10;
+}
+function getWellformedRange(range) {
+  const start = range.start;
+  const end = range.end;
+  if (start.line > end.line || start.line === end.line && start.character > end.character) {
+    return { start: end, end: start };
+  }
+  return range;
+}
+function getWellformedEdit(textEdit) {
+  const range = getWellformedRange(textEdit.range);
+  if (range !== textEdit.range) {
+    return { newText: textEdit.newText, range };
+  }
+  return textEdit;
+}
+
+// lsp/server/src/formatting/printer.ts
+function print(doc, options) {
+  const output = [];
+  const state = { indentLevel: 0, mode: "break" };
+  printDoc(doc, state, output, options);
+  return output.join("");
+}
+function currentColumn(output) {
+  let col = 0;
+  for (let i = output.length - 1; i >= 0; i--) {
+    const chunk = output[i];
+    const nlIndex = chunk.lastIndexOf("\n");
+    if (nlIndex !== -1) {
+      col += chunk.length - nlIndex - 1;
+      return col;
+    }
+    col += chunk.length;
+  }
+  return col;
+}
+function containsBreakParent(doc) {
+  if (typeof doc === "string") return false;
+  switch (doc.type) {
+    case "breakParent":
+      return true;
+    case "concat":
+      return doc.parts.some(containsBreakParent);
+    case "indent":
+      return containsBreakParent(doc.contents);
+    case "group":
+      return containsBreakParent(doc.contents);
+    case "fill":
+      return doc.parts.some(containsBreakParent);
+    case "ifBreak":
+      return containsBreakParent(doc.breakContents) || containsBreakParent(doc.flatContents);
+    default:
+      return false;
+  }
+}
+function printDoc(doc, state, output, options) {
+  if (typeof doc === "string") {
+    output.push(doc);
+    return;
+  }
+  switch (doc.type) {
+    case "concat":
+      for (const part of doc.parts) {
+        printDoc(part, state, output, options);
+      }
+      break;
+    case "indent":
+      state.indentLevel++;
+      printDoc(doc.contents, state, output, options);
+      state.indentLevel--;
+      break;
+    case "hardline":
+      output.push("\n");
+      output.push(makeIndent(state.indentLevel, options));
+      break;
+    case "softline":
+      if (state.mode === "break") {
+        output.push("\n");
+        output.push(makeIndent(state.indentLevel, options));
+      }
+      break;
+    case "line":
+      if (state.mode === "break") {
+        output.push("\n");
+        output.push(makeIndent(state.indentLevel, options));
+      } else {
+        output.push(" ");
+      }
+      break;
+    case "group": {
+      if (doc.break || containsBreakParent(doc.contents)) {
+        const prevMode = state.mode;
+        state.mode = "break";
+        printDoc(doc.contents, state, output, options);
+        state.mode = prevMode;
+      } else {
+        const flatOutput = [];
+        const flatState = { ...state, mode: "flat" };
+        printDoc(doc.contents, flatState, flatOutput, options);
+        const flatContent = flatOutput.join("");
+        const printWidth = options.printWidth ?? 80;
+        const col = currentColumn(output);
+        if (!flatContent.includes("\n") && col + flatContent.length <= printWidth) {
+          output.push(flatContent);
+        } else {
+          const prevMode = state.mode;
+          state.mode = "break";
+          printDoc(doc.contents, state, output, options);
+          state.mode = prevMode;
+        }
+      }
+      break;
+    }
+    case "fill":
+      printFill(doc.parts, state, output, options);
+      break;
+    case "ifBreak":
+      if (state.mode === "break") {
+        printDoc(doc.breakContents, state, output, options);
+      } else {
+        printDoc(doc.flatContents, state, output, options);
+      }
+      break;
+    case "breakParent":
+      state.mode = "break";
+      break;
+  }
+}
+function printFill(parts, state, output, options) {
+  if (parts.length === 0) return;
+  const printWidth = options.printWidth ?? 80;
+  for (let i = 0; i < parts.length; i++) {
+    const content = parts[i];
+    const separator = i + 1 < parts.length ? parts[i + 1] : null;
+    printDoc(content, state, output, options);
+    if (separator === null) break;
+    const nextContent = i + 2 < parts.length ? parts[i + 2] : null;
+    if (nextContent !== null) {
+      const testOutput = [];
+      const flatState = { ...state, mode: "flat" };
+      printDoc(separator, flatState, testOutput, options);
+      printDoc(nextContent, flatState, testOutput, options);
+      const testStr = testOutput.join("");
+      const col = currentColumn(output);
+      if (!testStr.includes("\n") && col + testStr.length <= printWidth) {
+        const sepOutput = [];
+        printDoc(separator, flatState, sepOutput, options);
+        output.push(sepOutput.join(""));
+      } else {
+        printDoc(separator, { ...state, mode: "break" }, output, options);
+      }
+    } else {
+      printDoc(separator, state, output, options);
+    }
+    i++;
+  }
+}
+function makeIndent(level, options) {
+  return options.indentUnit.repeat(level);
+}
+
+// lsp/server/src/formatting/ir.ts
+var hardline = { type: "hardline" };
+var softline = { type: "softline" };
+var line = { type: "line" };
+var empty = "";
+function text(value) {
+  return value;
+}
+function concat(parts) {
+  const flattened = [];
+  for (const part of parts) {
+    if (part === "") continue;
+    if (typeof part === "object" && part.type === "concat") {
+      flattened.push(...part.parts);
+    } else {
+      flattened.push(part);
+    }
+  }
+  if (flattened.length === 0) return "";
+  if (flattened.length === 1) return flattened[0];
+  return { type: "concat", parts: flattened };
+}
+function indent(contents) {
+  if (contents === "") return "";
+  return { type: "indent", contents };
+}
+function group(contents, shouldBreak = false) {
+  if (contents === "") return "";
+  return { type: "group", contents, break: shouldBreak || void 0 };
+}
+function ifBreak(breakContents, flatContents) {
+  return { type: "ifBreak", breakContents, flatContents };
+}
+function fill(parts) {
+  const filtered = parts.filter((p) => p !== "");
+  if (filtered.length === 0) return "";
+  if (filtered.length === 1) return filtered[0];
+  return { type: "fill", parts: filtered };
+}
+function isLine(doc) {
+  return typeof doc === "object" && doc.type === "line";
+}
+
+// lsp/server/src/formatting/utils.ts
+function getTagName(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_start_tag" || child.type === "html_self_closing_tag") {
+      for (let j = 0; j < child.childCount; j++) {
+        const tagChild = child.child(j);
+        if (tagChild && tagChild.type === "html_tag_name") {
+          return tagChild.text;
+        }
+      }
+    }
+  }
+  return null;
+}
+function normalizeText(text2) {
+  return text2.split("\n").map((line2) => line2.replace(/[ \t]+/g, " ").trim()).filter((line2, i, arr) => line2 || i > 0 && i < arr.length - 1).join("\n");
+}
+function getVisibleChildren(node) {
+  const children = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && !child.type.startsWith("_")) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function normalizeMustacheWhitespace(raw, addSpaces) {
+  const space = addSpaces ? " " : "";
+  const tripleMatch = raw.match(/^\{\{\{([\s\S]*)\}\}\}$/);
+  if (tripleMatch) {
+    const inner = tripleMatch[1].trim();
+    return `{{{${space}${inner}${space}}}}`;
+  }
+  const prefixedMatch = raw.match(/^\{\{([#/^!>])([\s\S]*)\}\}$/);
+  if (prefixedMatch) {
+    const prefix = prefixedMatch[1];
+    const inner = prefixedMatch[2];
+    if (prefix === "!" && inner.includes("\n")) {
+      const lines = inner.split("\n");
+      const first = lines[0].trimStart();
+      const last = lines[lines.length - 1].trimEnd();
+      if (lines.length === 1) {
+        return `{{${prefix}${space}${first}${space}}}`;
+      }
+      const middle = lines.slice(1, -1);
+      return `{{${prefix}${space}${first}
+${middle.join("\n")}
+${last}${space}}}`;
+    }
+    const trimmed = inner.trim();
+    return `{{${prefix}${space}${trimmed}${space}}}`;
+  }
+  const plainMatch = raw.match(/^\{\{([\s\S]*)\}\}$/);
+  if (plainMatch) {
+    const inner = plainMatch[1].trim();
+    return `{{${space}${inner}${space}}}`;
+  }
+  return raw;
+}
+function normalizeMustacheWhitespaceAll(raw, addSpaces) {
+  return raw.replace(/\{\{\{[\s\S]*?\}\}\}|\{\{[\s\S]*?\}\}/g, (match) => {
+    return normalizeMustacheWhitespace(match, addSpaces);
+  });
+}
+
+// lsp/server/src/formatting/classifier.ts
+var customCodeTags = /* @__PURE__ */ new Set();
+function setCustomCodeTags(tags) {
+  customCodeTags = new Set(tags.map((t) => t.toLowerCase()));
+}
+var CSS_DISPLAY_MAP = {
+  // Block elements
+  address: "block",
+  article: "block",
+  aside: "block",
+  blockquote: "block",
+  body: "block",
+  center: "block",
+  dd: "block",
+  details: "block",
+  dialog: "block",
+  dir: "block",
+  div: "block",
+  dl: "block",
+  dt: "block",
+  fieldset: "block",
+  figcaption: "block",
+  figure: "block",
+  footer: "block",
+  form: "block",
+  h1: "block",
+  h2: "block",
+  h3: "block",
+  h4: "block",
+  h5: "block",
+  h6: "block",
+  header: "block",
+  hgroup: "block",
+  hr: "block",
+  html: "block",
+  legend: "block",
+  listing: "block",
+  main: "block",
+  menu: "block",
+  nav: "block",
+  ol: "block",
+  p: "block",
+  plaintext: "block",
+  pre: "block",
+  search: "block",
+  section: "block",
+  summary: "block",
+  ul: "block",
+  xmp: "block",
+  // List items
+  li: "list-item",
+  // Table elements
+  table: "table",
+  caption: "table-caption",
+  colgroup: "table-column-group",
+  col: "table-column",
+  thead: "table-header-group",
+  tbody: "table-row-group",
+  tfoot: "table-footer-group",
+  tr: "table-row",
+  td: "table-cell",
+  th: "table-cell",
+  // Inline-block elements
+  button: "inline-block",
+  img: "inline-block",
+  input: "inline-block",
+  select: "inline-block",
+  textarea: "inline-block",
+  video: "inline-block",
+  audio: "inline-block",
+  canvas: "inline-block",
+  embed: "inline-block",
+  iframe: "inline-block",
+  object: "inline-block",
+  // None
+  head: "none",
+  link: "none",
+  meta: "none",
+  script: "none",
+  style: "none",
+  title: "none",
+  template: "none",
+  // Ruby
+  ruby: "ruby",
+  rb: "ruby-base",
+  rt: "ruby-text",
+  rp: "none"
+};
+var PRESERVE_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+  "pre",
+  "code",
+  "textarea",
+  "script",
+  "style"
+]);
+function getCSSDisplay(node) {
+  const type = node.type;
+  if (type === "html_element") {
+    const tagName = getTagName(node);
+    if (tagName) {
+      if (customCodeTags.has(tagName.toLowerCase())) {
+        return "block";
+      }
+      return CSS_DISPLAY_MAP[tagName.toLowerCase()] ?? "inline";
+    }
+    return "block";
+  }
+  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+    return "block";
+  }
+  if (type === "mustache_section" || type === "mustache_inverted_section") {
+    return hasBlockContent(node) ? "block" : "inline";
+  }
+  return "inline";
+}
+function isWhitespaceInsensitive(display) {
+  switch (display) {
+    case "block":
+    case "list-item":
+    case "table":
+    case "table-row":
+    case "table-row-group":
+    case "table-header-group":
+    case "table-footer-group":
+    case "table-column":
+    case "table-column-group":
+    case "table-caption":
+    case "table-cell":
+    case "none":
+      return true;
+    default:
+      return false;
+  }
+}
+function isBlockLevel(node) {
+  const type = node.type;
+  if (type === "mustache_section" || type === "mustache_inverted_section") {
+    return hasBlockContent(node);
+  }
+  if (type === "html_element") {
+    const display = getCSSDisplay(node);
+    return isWhitespaceInsensitive(display);
+  }
+  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+    return true;
+  }
+  return false;
+}
+function shouldPreserveContent(node) {
+  const type = node.type;
+  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+    return true;
+  }
+  if (type === "html_element") {
+    const tagName = getTagName(node);
+    if (!tagName) return false;
+    const lower = tagName.toLowerCase();
+    return PRESERVE_CONTENT_ELEMENTS.has(lower) || customCodeTags.has(lower);
+  }
+  return false;
+}
+function hasBlockContent(sectionNode) {
+  const contentNodes = getContentNodes(sectionNode);
+  if (hasImplicitEndTags(contentNodes)) {
+    return true;
+  }
+  for (const node of contentNodes) {
+    if (isBlockLevelContent(node)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isBlockLevelContent(node) {
+  const type = node.type;
+  if (type === "html_element") {
+    return true;
+  }
+  if (type === "html_script_element" || type === "html_style_element" || type === "html_raw_element") {
+    return true;
+  }
+  if (type === "mustache_section" || type === "mustache_inverted_section") {
+    return hasBlockContent(node);
+  }
+  return false;
+}
+function getContentNodes(sectionNode) {
+  const isInverted = sectionNode.type === "mustache_inverted_section";
+  const beginType = isInverted ? "mustache_inverted_section_begin" : "mustache_section_begin";
+  const endType = isInverted ? "mustache_inverted_section_end" : "mustache_section_end";
+  const contentNodes = [];
+  for (let i = 0; i < sectionNode.childCount; i++) {
+    const child = sectionNode.child(i);
+    if (!child) continue;
+    if (child.type !== beginType && child.type !== endType && child.type !== "mustache_erroneous_section_end" && child.type !== "mustache_erroneous_inverted_section_end" && !child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  return contentNodes;
+}
+function hasImplicitEndTags(nodes) {
+  for (const node of nodes) {
+    if (hasImplicitEndTagsRecursive(node)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasImplicitEndTagsRecursive(node) {
+  if (node.type === "html_element") {
+    let hasStartTag = false;
+    let hasEndTag = false;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === "html_start_tag") hasStartTag = true;
+      if (child.type === "html_end_tag") hasEndTag = true;
+      if (child.type === "html_forced_end_tag") return true;
+    }
+    if (hasStartTag && !hasEndTag) return true;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && hasImplicitEndTagsRecursive(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isInTextFlow(node, index, nodes) {
+  if (index > 0) {
+    const prev = nodes[index - 1];
+    if (prev.type === "text" && prev.text.trim().length > 0) {
+      return true;
+    }
+  }
+  if (index < nodes.length - 1) {
+    const next = nodes[index + 1];
+    if (next.type === "text" && next.text.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldHtmlElementStayInline(node, index, nodes) {
+  if (node.type !== "html_element") {
+    return false;
+  }
+  if (isInTextFlow(node, index, nodes)) {
+    return true;
+  }
+  if (index > 0) {
+    const prev = nodes[index - 1];
+    if (prev.type === "html_element" && isInTextFlow(prev, index - 1, nodes)) {
+      return true;
+    }
+  }
+  if (index < nodes.length - 1) {
+    const next = nodes[index + 1];
+    if (next.type === "html_element" && isInTextFlow(next, index + 1, nodes)) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldTreatAsBlock(node, index, nodes) {
+  const isHtmlElement = node.type === "html_element" || node.type === "html_script_element" || node.type === "html_style_element" || node.type === "html_raw_element";
+  const isMustacheSection = node.type === "mustache_section" || node.type === "mustache_inverted_section";
+  return isHtmlElement && !shouldHtmlElementStayInline(node, index, nodes) || isMustacheSection && !isInTextFlow(node, index, nodes) || isBlockLevel(node) && !isInTextFlow(node, index, nodes);
+}
+
+// lsp/server/src/customCodeTags.ts
+var VALID_INDENT_MODES = /* @__PURE__ */ new Set(["never", "always", "attribute"]);
+function parseCustomCodeTagSettings(tags) {
+  const tagNames = [];
+  const configs = [];
+  for (const tag of tags) {
+    if (tag && typeof tag === "object" && "name" in tag && typeof tag.name === "string") {
+      const t = tag;
+      const config = { name: t.name };
+      if (typeof t.languageAttribute === "string") config.languageAttribute = t.languageAttribute;
+      if (t.languageMap && typeof t.languageMap === "object") config.languageMap = t.languageMap;
+      if (typeof t.languageDefault === "string") config.languageDefault = t.languageDefault;
+      if (typeof t.indent === "string" && VALID_INDENT_MODES.has(t.indent)) {
+        config.indent = t.indent;
+      }
+      if (typeof t.indentAttribute === "string") config.indentAttribute = t.indentAttribute;
+      tagNames.push(config.name);
+      configs.push(config);
+    }
+  }
+  return { tagNames, configs };
+}
+function getAttributeValue(node, attrName) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === "html_start_tag") {
+      for (let j = 0; j < child.childCount; j++) {
+        const attr = child.child(j);
+        if (attr?.type === "html_attribute") {
+          let name = "";
+          let value = "";
+          for (let k = 0; k < attr.childCount; k++) {
+            const part = attr.child(k);
+            if (part?.type === "html_attribute_name") name = part.text.toLowerCase();
+            if (part?.type === "html_quoted_attribute_value") value = part.text.replace(/^["']|["']$/g, "");
+            if (part?.type === "html_attribute_value") value = part.text;
+          }
+          if (name === attrName.toLowerCase()) {
+            return value;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// lsp/server/src/formatting/formatters.ts
+function isAttributeTruthy(value) {
+  if (value === null || value === "" || value === "false" || value === "0") {
+    return false;
+  }
+  return true;
+}
+function dedentContent(rawContent) {
+  const lines = rawContent.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return "";
+  let minIndent = Infinity;
+  for (const l of lines) {
+    if (l.trim() === "") continue;
+    const match = l.match(/^(\s*)/);
+    if (match && match[1].length < minIndent) {
+      minIndent = match[1].length;
+    }
+  }
+  if (minIndent === Infinity) minIndent = 0;
+  return lines.map((l) => l.trim() === "" ? "" : l.slice(minIndent)).join("\n");
+}
+function resolveIndentMode(node, config) {
+  const mode = config.indent ?? "never";
+  if (mode === "never") return false;
+  if (mode === "always") return true;
+  if (!config.indentAttribute) return false;
+  const value = getAttributeValue(node, config.indentAttribute);
+  return isAttributeTruthy(value);
+}
+function getTagNameFromStartTag(startTag) {
+  for (let i = 0; i < startTag.childCount; i++) {
+    const child = startTag.child(i);
+    if (child?.type === "html_tag_name") return child.text.toLowerCase();
+  }
+  return null;
+}
+function mustacheText(raw, context) {
+  if (context.mustacheSpaces !== void 0) {
+    return normalizeMustacheWhitespace(raw, context.mustacheSpaces);
+  }
+  return raw;
+}
+function formatDocument(node, context) {
+  const children = getVisibleChildren(node);
+  const content = formatBlockChildren(children, context);
+  return concat([content, hardline]);
+}
+function formatNode(node, context, forceInline = false) {
+  const type = node.type;
+  switch (type) {
+    case "document":
+      return formatDocument(node, context);
+    case "html_element":
+      return formatHtmlElement(node, context);
+    case "html_script_element":
+    case "html_style_element":
+    case "html_raw_element":
+      return formatScriptStyleElement(node, context);
+    case "mustache_section":
+    case "mustache_inverted_section":
+      if (forceInline) {
+        if (context.mustacheSpaces !== void 0) {
+          return text(normalizeMustacheWhitespaceAll(node.text, context.mustacheSpaces));
+        }
+        return text(node.text);
+      }
+      return formatMustacheSection(node, context);
+    case "mustache_interpolation":
+    case "mustache_triple":
+    case "mustache_partial":
+    case "mustache_comment":
+      return text(mustacheText(node.text, context));
+    case "html_comment":
+    case "html_doctype":
+    case "html_entity":
+    case "html_erroneous_end_tag":
+      return text(node.text);
+    case "text":
+      return formatText(node);
+    default:
+      return text(node.text);
+  }
+}
+function formatText(node) {
+  return text(normalizeText(node.text));
+}
+function formatHtmlElement(node, context) {
+  const display = getCSSDisplay(node);
+  const isBlock = isWhitespaceInsensitive(display);
+  const preserveContent = shouldPreserveContent(node);
+  const selfClosing = node.childCount === 1 && node.child(0)?.type === "html_self_closing_tag";
+  if (selfClosing) {
+    const tag = node.child(0);
+    return formatStartTag(tag, context);
+  }
+  let startTag = null;
+  let endTag = null;
+  let hasRealEndTag = false;
+  const contentNodes = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_start_tag") {
+      startTag = child;
+    } else if (child.type === "html_end_tag") {
+      endTag = child;
+      hasRealEndTag = true;
+    } else if (child.type === "html_forced_end_tag") {
+      endTag = child;
+    } else if (!child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  const parts = [];
+  if (startTag) {
+    parts.push(formatStartTag(startTag, context));
+  }
+  const hasHtmlElementChildren = contentNodes.some(
+    (child) => child.type === "html_element" || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element" || isBlockLevel(child)
+  );
+  if (preserveContent) {
+    const tagNameLower = startTag ? getTagNameFromStartTag(startTag) : null;
+    const tagConfig = tagNameLower ? context.customCodeTagConfigs?.get(tagNameLower) : void 0;
+    const shouldIndent = tagConfig ? resolveIndentMode(node, tagConfig) : false;
+    if (shouldIndent && startTag && endTag) {
+      const rawContent = context.document.getText().slice(
+        startTag.endIndex,
+        endTag.startIndex
+      );
+      const dedented = dedentContent(rawContent);
+      if (dedented.length > 0) {
+        const contentLines = dedented.split("\n");
+        const lineDocs = [];
+        for (let j = 0; j < contentLines.length; j++) {
+          if (j > 0) {
+            if (contentLines[j] === "") {
+              lineDocs.push("\n");
+            } else {
+              lineDocs.push(hardline);
+            }
+          }
+          if (contentLines[j] !== "") {
+            lineDocs.push(text(contentLines[j]));
+          }
+        }
+        parts.push(indent(concat([hardline, ...lineDocs])));
+        parts.push(hardline);
+      }
+    } else if (startTag && endTag) {
+      const rawContent = context.document.getText().slice(
+        startTag.endIndex,
+        endTag.startIndex
+      );
+      const trailingMatch = isBlock ? rawContent.match(/\n[\t ]*$/) : null;
+      if (trailingMatch) {
+        parts.push(text(rawContent.slice(0, -trailingMatch[0].length)));
+        parts.push(hardline);
+      } else {
+        parts.push(text(rawContent));
+      }
+    } else {
+      for (const child of contentNodes) {
+        parts.push(text(child.text));
+      }
+    }
+  } else if (!isBlock && !hasHtmlElementChildren) {
+    for (const child of contentNodes) {
+      parts.push(formatNode(child, context));
+    }
+  } else {
+    const formattedContent = formatBlockChildren(contentNodes, context);
+    const hasContent = hasDocContent(formattedContent);
+    if (hasContent) {
+      const hasBlockChildren = contentNodes.some((child, i) => {
+        if (!shouldTreatAsBlock(child, i, contentNodes)) {
+          return false;
+        }
+        const childDisplay = getCSSDisplay(child);
+        return isWhitespaceInsensitive(childDisplay) || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element";
+      });
+      if (isBlock && !hasBlockChildren) {
+        const doc = group(
+          concat([
+            indent(concat([softline, formattedContent])),
+            softline
+          ])
+        );
+        parts.push(doc);
+        if (!hasRealEndTag && endTag) {
+          parts.pop();
+          parts.push(
+            group(
+              concat([
+                indent(concat([softline, formattedContent]))
+              ])
+            )
+          );
+        }
+      } else {
+        parts.push(indent(concat([hardline, formattedContent])));
+        if (hasRealEndTag) {
+          parts.push(hardline);
+        }
+      }
+    } else if (contentNodes.length === 0 && hasRealEndTag) {
+      parts.push(hardline);
+    }
+  }
+  if (endTag) {
+    parts.push(formatEndTag(endTag));
+  }
+  return concat(parts);
+}
+function formatScriptStyleElement(node, context) {
+  const parts = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_start_tag") {
+      parts.push(formatStartTag(child, context));
+    } else if (child.type === "html_end_tag") {
+      parts.push(formatEndTag(child));
+    } else if (child.type === "html_raw_text") {
+      const formatted = context.embeddedFormatted?.get(child.startIndex);
+      if (formatted !== void 0) {
+        const trimmed = formatted.replace(/^\n+/, "").replace(/\n+$/, "");
+        if (trimmed.length === 0) {
+        } else {
+          const lines = trimmed.split("\n");
+          const lineDocs = [];
+          for (let j = 0; j < lines.length; j++) {
+            if (j > 0) {
+              lineDocs.push(hardline);
+            }
+            lineDocs.push(text(lines[j]));
+          }
+          parts.push(indent(concat([hardline, ...lineDocs])));
+          parts.push(hardline);
+        }
+      } else {
+        if (node.type === "html_raw_element") {
+          const startTagNode = node.child(0);
+          const tagNameLower = startTagNode?.type === "html_start_tag" ? getTagNameFromStartTag(startTagNode) : null;
+          const tagConfig = tagNameLower ? context.customCodeTagConfigs?.get(tagNameLower) : void 0;
+          if (tagConfig && resolveIndentMode(node, tagConfig)) {
+            const dedented = dedentContent(child.text);
+            if (dedented.length > 0) {
+              const contentLines = dedented.split("\n");
+              const lineDocs = [];
+              for (let j = 0; j < contentLines.length; j++) {
+                if (j > 0) {
+                  if (contentLines[j] === "") {
+                    lineDocs.push("\n");
+                  } else {
+                    lineDocs.push(hardline);
+                  }
+                }
+                if (contentLines[j] !== "") {
+                  lineDocs.push(text(contentLines[j]));
+                }
+              }
+              parts.push(indent(concat([hardline, ...lineDocs])));
+              parts.push(hardline);
+            }
+          } else {
+            parts.push(text(child.text));
+          }
+        } else {
+          parts.push(text(child.text));
+        }
+      }
+    }
+  }
+  return concat(parts);
+}
+function formatMustacheSection(node, context) {
+  const isInverted = node.type === "mustache_inverted_section";
+  const beginType = isInverted ? "mustache_inverted_section_begin" : "mustache_section_begin";
+  const endType = isInverted ? "mustache_inverted_section_end" : "mustache_section_end";
+  let beginNode = null;
+  let endNode = null;
+  const contentNodes = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === beginType) {
+      beginNode = child;
+    } else if (child.type === endType || child.type === "mustache_erroneous_section_end" || child.type === "mustache_erroneous_inverted_section_end") {
+      endNode = child;
+    } else if (!child.type.startsWith("_")) {
+      contentNodes.push(child);
+    }
+  }
+  const parts = [];
+  if (beginNode) {
+    parts.push(text(mustacheText(beginNode.text, context)));
+  }
+  const hasImplicit = hasImplicitEndTags(contentNodes);
+  const formattedContent = formatBlockChildren(contentNodes, context);
+  const hasContent = hasDocContent(formattedContent);
+  if (hasContent) {
+    if (hasImplicit) {
+      parts.push(hardline);
+      parts.push(formattedContent);
+      parts.push(hardline);
+    } else {
+      const hasBlockChildren = contentNodes.some((child, i) => {
+        if (!shouldTreatAsBlock(child, i, contentNodes)) {
+          return false;
+        }
+        const childDisplay = getCSSDisplay(child);
+        return isWhitespaceInsensitive(childDisplay) || child.type === "html_script_element" || child.type === "html_style_element" || child.type === "html_raw_element";
+      });
+      if (!hasBlockChildren) {
+        parts.push(indent(concat([softline, formattedContent])));
+        parts.push(softline);
+      } else {
+        parts.push(indent(concat([hardline, formattedContent])));
+        parts.push(hardline);
+      }
+    }
+  }
+  if (endNode) {
+    parts.push(text(mustacheText(endNode.text, context)));
+  }
+  return group(concat(parts));
+}
+function formatStartTag(node, context) {
+  let tagNameText = "";
+  const attrs = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_tag_name") {
+      tagNameText = child.text;
+    } else if (child.type === "html_attribute") {
+      attrs.push(formatAttribute(child, context));
+    } else if (child.type === "mustache_attribute") {
+      if (context?.mustacheSpaces !== void 0) {
+        attrs.push(text(normalizeMustacheWhitespaceAll(child.text, context.mustacheSpaces)));
+      } else {
+        attrs.push(text(child.text));
+      }
+    } else if (child.type === "mustache_interpolation" || child.type === "mustache_triple") {
+      attrs.push(text(context ? mustacheText(child.text, context) : child.text));
+    }
+  }
+  const isSelfClosing = node.type === "html_self_closing_tag";
+  const closingBracket = isSelfClosing ? " />" : ">";
+  if (attrs.length === 0) {
+    return text("<" + tagNameText + closingBracket);
+  }
+  const attrParts = [];
+  for (let i = 0; i < attrs.length; i++) {
+    if (i > 0) {
+      attrParts.push(line);
+    }
+    attrParts.push(attrs[i]);
+  }
+  return group(
+    concat([
+      text("<"),
+      text(tagNameText),
+      indent(concat([line, concat(attrParts)])),
+      ifBreak(concat([hardline, text(closingBracket)]), text(closingBracket))
+    ])
+  );
+}
+function formatEndTag(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "html_tag_name") {
+      return text("</" + child.text + ">");
+    }
+  }
+  return text(node.text);
+}
+function formatAttribute(node, context) {
+  const parts = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "html_attribute_name") {
+      parts.push(text(child.text));
+    } else if (child.type === "html_attribute_value") {
+      parts.push(text("="));
+      parts.push(text(child.text));
+    } else if (child.type === "html_quoted_attribute_value") {
+      parts.push(text("="));
+      if (context?.mustacheSpaces !== void 0) {
+        parts.push(text(normalizeMustacheWhitespaceAll(child.text, context.mustacheSpaces)));
+      } else {
+        parts.push(text(child.text));
+      }
+    } else if (child.type === "mustache_interpolation") {
+      parts.push(text("="));
+      parts.push(text(context ? mustacheText(child.text, context) : child.text));
+    }
+  }
+  return concat(parts);
+}
+function textWords(str) {
+  const words = str.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0) return [];
+  const parts = [words[0]];
+  for (let i = 1; i < words.length; i++) {
+    parts.push(line);
+    parts.push(words[i]);
+  }
+  return parts;
+}
+function inlineContentToFill(parts) {
+  if (parts.length === 0) return empty;
+  if (parts.length === 1) return parts[0];
+  const fillParts = [];
+  for (const item of parts) {
+    if (isLine(item)) {
+      if (fillParts.length > 0 && !isLine(fillParts[fillParts.length - 1])) {
+        fillParts.push(item);
+      }
+    } else {
+      const lastIdx = fillParts.length - 1;
+      if (lastIdx >= 0 && !isLine(fillParts[lastIdx])) {
+        fillParts[lastIdx] = concat([fillParts[lastIdx], item]);
+      } else if (typeof item === "string" && /^[,.:;!?)\]]/.test(item) && lastIdx >= 0 && isLine(fillParts[lastIdx])) {
+        fillParts.pop();
+        if (fillParts.length > 0) {
+          fillParts[fillParts.length - 1] = concat([
+            fillParts[fillParts.length - 1],
+            item
+          ]);
+        } else {
+          fillParts.push(item);
+        }
+      } else {
+        fillParts.push(item);
+      }
+    }
+  }
+  if (fillParts.length > 0 && isLine(fillParts[fillParts.length - 1])) {
+    fillParts.pop();
+  }
+  return fill(fillParts);
+}
+function formatBlockChildren(nodes, context) {
+  const lines = [];
+  let currentLine = [];
+  let lastNodeEnd = -1;
+  let pendingBlankLine = false;
+  let blankLineBeforeCurrentLine = false;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const treatAsBlock = shouldTreatAsBlock(node, i, nodes);
+    if (lastNodeEnd >= 0 && node.startIndex > lastNodeEnd) {
+      const gap = context.document.getText().slice(lastNodeEnd, node.startIndex);
+      const prevNode = nodes[i - 1];
+      const prevTreatAsBlock = shouldTreatAsBlock(prevNode, i - 1, nodes);
+      const newlineCount = (gap.match(/\n/g) || []).length;
+      if (newlineCount >= 2) {
+        pendingBlankLine = true;
+      }
+      if (!prevTreatAsBlock && !treatAsBlock) {
+        if (/\s/.test(gap)) {
+          currentLine.push(line);
+        }
+      }
+    }
+    if (treatAsBlock) {
+      if (currentLine.length > 0) {
+        const lineContent = trimDoc(inlineContentToFill(currentLine));
+        if (hasDocContent(lineContent)) {
+          lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+        }
+        currentLine = [];
+        blankLineBeforeCurrentLine = false;
+      }
+      lines.push({ doc: formatNode(node, context), blankLineBefore: pendingBlankLine });
+      pendingBlankLine = false;
+    } else if (node.type === "html_comment" || node.type === "mustache_comment") {
+      const isMultiline = node.startPosition.row !== node.endPosition.row;
+      if (isMultiline) {
+        if (currentLine.length > 0) {
+          const lineContent = trimDoc(inlineContentToFill(currentLine));
+          if (hasDocContent(lineContent)) {
+            lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+          }
+          currentLine = [];
+          blankLineBeforeCurrentLine = false;
+        }
+        const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+        lines.push({ doc: text(commentText), blankLineBefore: pendingBlankLine });
+        pendingBlankLine = false;
+      } else {
+        if (currentLine.length === 0) {
+          blankLineBeforeCurrentLine = pendingBlankLine;
+          pendingBlankLine = false;
+        }
+        const commentText = node.type === "mustache_comment" ? mustacheText(node.text, context) : node.text;
+        currentLine.push(text(commentText));
+      }
+    } else {
+      if (currentLine.length === 0) {
+        blankLineBeforeCurrentLine = pendingBlankLine;
+        pendingBlankLine = false;
+      }
+      const forceInline = isInTextFlow(node, i, nodes);
+      const formatted = formatNode(node, context, forceInline);
+      if (typeof formatted === "string" && formatted.includes("\n")) {
+        const contentLines = formatted.split("\n");
+        const isTextNode = node.type === "text";
+        if (isTextNode) {
+          for (let j = 0; j < contentLines.length; j++) {
+            const trimmed = contentLines[j].trim();
+            if (!trimmed) {
+              if (currentLine.length > 0) {
+                const lineContent = trimDoc(inlineContentToFill(currentLine));
+                if (hasDocContent(lineContent)) {
+                  lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+                  blankLineBeforeCurrentLine = false;
+                }
+                currentLine = [];
+              }
+              pendingBlankLine = true;
+            } else {
+              if (currentLine.length === 0) {
+                blankLineBeforeCurrentLine = pendingBlankLine;
+                pendingBlankLine = false;
+              }
+              if (j > 0 && currentLine.length > 0) {
+                currentLine.push(line);
+              }
+              currentLine.push(...textWords(trimmed));
+            }
+          }
+        } else {
+          const firstTrimmed = contentLines[0].trim();
+          if (firstTrimmed) {
+            currentLine.push(firstTrimmed);
+          }
+          if (currentLine.length > 0) {
+            const lineContent = trimDoc(inlineContentToFill(currentLine));
+            if (hasDocContent(lineContent)) {
+              lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+              blankLineBeforeCurrentLine = pendingBlankLine;
+              pendingBlankLine = false;
+            }
+            currentLine = [];
+          }
+          let sawBlankLine = false;
+          for (let j = 1; j < contentLines.length - 1; j++) {
+            const trimmed = contentLines[j].trim();
+            if (trimmed) {
+              lines.push({ doc: text(trimmed), blankLineBefore: blankLineBeforeCurrentLine || sawBlankLine });
+              blankLineBeforeCurrentLine = false;
+              sawBlankLine = false;
+            } else {
+              sawBlankLine = true;
+            }
+          }
+          if (contentLines.length > 1) {
+            const lastTrimmed = contentLines[contentLines.length - 1].trim();
+            if (lastTrimmed) {
+              blankLineBeforeCurrentLine = sawBlankLine;
+              sawBlankLine = false;
+              currentLine = [lastTrimmed];
+            }
+            if (sawBlankLine) {
+              pendingBlankLine = true;
+            }
+          }
+        }
+      } else {
+        if (node.type === "text" && typeof formatted === "string") {
+          currentLine.push(...textWords(formatted));
+        } else {
+          currentLine.push(formatted);
+        }
+      }
+    }
+    lastNodeEnd = node.endIndex;
+  }
+  if (currentLine.length > 0) {
+    const lineContent = trimDoc(inlineContentToFill(currentLine));
+    if (hasDocContent(lineContent)) {
+      lines.push({ doc: lineContent, blankLineBefore: blankLineBeforeCurrentLine });
+    }
+  }
+  if (lines.length === 0) {
+    return empty;
+  }
+  const parts = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) {
+      if (lines[i].blankLineBefore) {
+        parts.push("\n");
+      }
+      parts.push(hardline);
+    }
+    parts.push(lines[i].doc);
+  }
+  return concat(parts);
+}
+function hasDocContent(doc) {
+  if (typeof doc === "string") {
+    return doc.trim().length > 0;
+  }
+  if (doc.type === "concat") {
+    return doc.parts.some(hasDocContent);
+  }
+  if (doc.type === "indent") {
+    return hasDocContent(doc.contents);
+  }
+  if (doc.type === "group") {
+    return hasDocContent(doc.contents);
+  }
+  if (doc.type === "fill") {
+    return doc.parts.some(hasDocContent);
+  }
+  if (doc.type === "ifBreak") {
+    return hasDocContent(doc.breakContents) || hasDocContent(doc.flatContents);
+  }
+  return false;
+}
+function trimDoc(doc) {
+  if (typeof doc === "string") {
+    return doc.trim();
+  }
+  return doc;
+}
+
+// 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 };
+}
+function createIndentUnit(options) {
+  return options.insertSpaces ? " ".repeat(options.tabSize) : "	";
+}
+
+// lsp/server/src/formatting/index.ts
+function formatDocument2(tree, document, options, params = {}) {
+  const { customCodeTags: customCodeTags2, printWidth = 80, embeddedFormatted, mustacheSpaces, customCodeTagConfigs, configFile } = params;
+  const mergedOptions = mergeOptions(options, document.uri, configFile);
+  const indentUnit = createIndentUnit(mergedOptions);
+  if (customCodeTags2) {
+    setCustomCodeTags(customCodeTags2);
+  }
+  const configMap = buildConfigMap(customCodeTagConfigs);
+  const context = {
+    document,
+    customCodeTags: customCodeTags2 ? new Set(customCodeTags2.map((t) => t.toLowerCase())) : void 0,
+    customCodeTagConfigs: configMap,
+    embeddedFormatted,
+    mustacheSpaces
+  };
+  const doc = formatDocument(tree.rootNode, context);
+  const formatted = print(doc, { indentUnit, printWidth });
+  const fullRange = {
+    start: { line: 0, character: 0 },
+    end: document.positionAt(document.getText().length)
+  };
+  return [{ range: fullRange, newText: formatted }];
+}
+function buildConfigMap(configs) {
+  if (!configs || configs.length === 0) return void 0;
+  const map = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    map.set(config.name.toLowerCase(), config);
+  }
+  return map;
+}
+
+// lsp/server/src/configFile.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var CONFIG_FILENAME = ".htmlmustache.jsonc";
+function parseJsonc(text2) {
+  let result = "";
+  let i = 0;
+  while (i < text2.length) {
+    if (text2[i] === '"') {
+      result += '"';
+      i++;
+      while (i < text2.length && text2[i] !== '"') {
+        if (text2[i] === "\\") {
+          result += text2[i] + (text2[i + 1] ?? "");
+          i += 2;
+        } else {
+          result += text2[i];
+          i++;
+        }
+      }
+      if (i < text2.length) {
+        result += '"';
+        i++;
+      }
+      continue;
+    }
+    if (text2[i] === "/" && text2[i + 1] === "/") {
+      while (i < text2.length && text2[i] !== "\n") i++;
+      continue;
+    }
+    if (text2[i] === "/" && text2[i + 1] === "*") {
+      i += 2;
+      while (i < text2.length && !(text2[i] === "*" && text2[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    result += text2[i];
+    i++;
+  }
+  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 {
+      fs2.accessSync(candidate, fs2.constants.R_OK);
+      return candidate;
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir || dir === root) return null;
+    dir = parent;
+  }
+}
+var VALID_INDENT_MODES2 = /* @__PURE__ */ new Set(["never", "always", "attribute"]);
+function validateConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const obj = raw;
+  const config = {};
+  if (typeof obj.printWidth === "number" && obj.printWidth > 0) {
+    config.printWidth = obj.printWidth;
+  }
+  if (typeof obj.indentSize === "number" && obj.indentSize > 0) {
+    config.indentSize = obj.indentSize;
+  }
+  if (typeof obj.mustacheSpaces === "boolean") {
+    config.mustacheSpaces = obj.mustacheSpaces;
+  }
+  if (Array.isArray(obj.customCodeTags)) {
+    const tags = [];
+    for (const entry of obj.customCodeTags) {
+      if (entry && typeof entry === "object" && "name" in entry) {
+        const e = entry;
+        if (typeof e.name !== "string" || e.name.length === 0) continue;
+        const tag = { name: e.name };
+        if (typeof e.languageAttribute === "string") tag.languageAttribute = e.languageAttribute;
+        if (e.languageMap && typeof e.languageMap === "object" && !Array.isArray(e.languageMap)) {
+          tag.languageMap = e.languageMap;
+        }
+        if (typeof e.languageDefault === "string") tag.languageDefault = e.languageDefault;
+        if (typeof e.indent === "string" && VALID_INDENT_MODES2.has(e.indent)) {
+          tag.indent = e.indent;
+        }
+        if (typeof e.indentAttribute === "string") tag.indentAttribute = e.indentAttribute;
+        tags.push(tag);
+      }
+    }
+    if (tags.length > 0) config.customCodeTags = tags;
+  }
+  return config;
+}
+function loadConfigFileForPath(filePath) {
+  const dir = path2.dirname(path2.resolve(filePath));
+  const configPath = findConfigFile(dir);
+  if (!configPath) return null;
+  try {
+    const text2 = fs2.readFileSync(configPath, "utf-8");
+    const raw = parseJsonc(text2);
+    return validateConfig(raw);
+  } catch {
+    return null;
+  }
+}
+
+// cli/src/wasm.ts
+var path3 = __toESM(require("node:path"));
+var import_web_tree_sitter = require("web-tree-sitter");
+var parser;
+async function initializeParser() {
+  await import_web_tree_sitter.Parser.init();
+  parser = new import_web_tree_sitter.Parser();
+  const wasmPath = path3.resolve(__dirname, "..", "..", "tree-sitter-htmlmustache.wasm");
+  const language = await import_web_tree_sitter.Language.load(wasmPath);
+  parser.setLanguage(language);
+}
+function parseDocument(source) {
+  const tree = parser.parse(source);
+  if (!tree) {
+    throw new Error("Failed to parse document");
+  }
+  return tree;
+}
+
+// cli/src/format.ts
+var USAGE2 = `Usage: htmlmustache format [options] <patterns...>
+
+Format HTML Mustache templates.
+
+Arguments:
+  patterns          One or more glob patterns (e.g. '**/*.mustache')
+
+Options:
+  --write           Modify files in-place (default: print to stdout)
+  --check           Exit 1 if any files would change (for CI)
+  --stdin           Read from stdin, write to stdout
+  --indent-size N   Spaces per indent level (default: 2)
+  --print-width N   Max line width (default: 80)
+  --mustache-spaces Add spaces inside mustache delimiters
+  --help            Show this help message
+
+Examples:
+  htmlmustache format --write '**/*.mustache'
+  htmlmustache format --check 'templates/**/*.hbs'
+  echo '<div><p>hi</p></div>' | htmlmustache format --stdin`;
+function parseFlags(args) {
+  const flags = {
+    write: false,
+    check: false,
+    stdin: false,
+    indentSize: void 0,
+    printWidth: void 0,
+    mustacheSpaces: void 0,
+    patterns: []
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "--write":
+        flags.write = true;
+        break;
+      case "--check":
+        flags.check = true;
+        break;
+      case "--stdin":
+        flags.stdin = true;
+        break;
+      case "--indent-size":
+        i++;
+        flags.indentSize = parseInt(args[i], 10);
+        if (isNaN(flags.indentSize)) {
+          console.error(import_chalk2.default.red("Error: --indent-size requires a number"));
+          process.exit(1);
+        }
+        break;
+      case "--print-width":
+        i++;
+        flags.printWidth = parseInt(args[i], 10);
+        if (isNaN(flags.printWidth)) {
+          console.error(import_chalk2.default.red("Error: --print-width requires a number"));
+          process.exit(1);
+        }
+        break;
+      case "--mustache-spaces":
+        flags.mustacheSpaces = true;
+        break;
+      default:
+        flags.patterns.push(arg);
+        break;
+    }
+    i++;
+  }
+  return flags;
+}
+function resolveSettings(flags, filePath) {
+  let tabSize = 2;
+  let insertSpaces = true;
+  let printWidth = 80;
+  let mustacheSpaces = false;
+  let customCodeTags2;
+  let customCodeTagConfigs;
+  const configFile = filePath ? loadConfigFileForPath(filePath) : null;
+  if (configFile) {
+    if (configFile.indentSize !== void 0) tabSize = configFile.indentSize;
+    if (configFile.printWidth !== void 0) printWidth = configFile.printWidth;
+    if (configFile.mustacheSpaces !== void 0) mustacheSpaces = configFile.mustacheSpaces;
+    if (configFile.customCodeTags && configFile.customCodeTags.length > 0) {
+      const parsed = parseCustomCodeTagSettings(configFile.customCodeTags);
+      customCodeTags2 = parsed.tagNames;
+      customCodeTagConfigs = parsed.configs;
+    }
+  }
+  if (filePath) {
+    const uri = (0, import_node_url.pathToFileURL)(filePath).href;
+    const ecOptions = getEditorConfigOptions(uri);
+    if (ecOptions.tabSize !== void 0) tabSize = ecOptions.tabSize;
+    if (ecOptions.insertSpaces !== void 0) insertSpaces = ecOptions.insertSpaces;
+  }
+  if (flags.indentSize !== void 0) tabSize = flags.indentSize;
+  if (flags.printWidth !== void 0) printWidth = flags.printWidth;
+  if (flags.mustacheSpaces !== void 0) mustacheSpaces = flags.mustacheSpaces;
+  return {
+    options: { tabSize, insertSpaces },
+    printWidth,
+    mustacheSpaces,
+    customCodeTags: customCodeTags2,
+    customCodeTagConfigs,
+    configFile
+  };
+}
+function formatSource(source, options, params = {}) {
+  const tree = parseDocument(source);
+  const document = TextDocument.create("file:///stdin", "htmlmustache", 1, source);
+  const edits = formatDocument2(tree, document, options, params);
+  if (edits.length === 0) return source;
+  return edits[0].newText;
+}
+async function run2(args) {
+  if (args[0] === "format") {
+    args = args.slice(1);
+  }
+  if (args.includes("--help")) {
+    console.log(USAGE2);
+    return 0;
+  }
+  const flags = parseFlags(args);
+  if (!flags.stdin && flags.patterns.length === 0) {
+    console.log(USAGE2);
+    return 1;
+  }
+  await initializeParser();
+  if (flags.stdin) {
+    const { options, ...params } = resolveSettings(flags);
+    const source = import_node_fs2.default.readFileSync(0, "utf-8");
+    const formatted = formatSource(source, options, params);
+    process.stdout.write(formatted);
+    return 0;
+  }
+  const files = expandGlobs(flags.patterns);
+  if (files.length === 0) {
+    console.error(import_chalk2.default.yellow("No files matched the given patterns:"));
+    for (const pattern of flags.patterns) {
+      console.error(import_chalk2.default.yellow(`  ${pattern}`));
+    }
+    return 1;
+  }
+  const cwd = process.cwd();
+  let changedCount = 0;
+  for (const file of files) {
+    const displayPath = import_node_path2.default.relative(cwd, file) || file;
+    const source = import_node_fs2.default.readFileSync(file, "utf-8");
+    const { options, ...params } = resolveSettings(flags, file);
+    const formatted = formatSource(source, options, params);
+    const changed = formatted !== source;
+    if (changed) changedCount++;
+    if (flags.check) {
+      console.log(changed ? import_chalk2.default.red(displayPath) : import_chalk2.default.dim(displayPath));
+    } else if (flags.write) {
+      if (changed) {
+        import_node_fs2.default.writeFileSync(file, formatted);
+      }
+      console.log(changed ? import_chalk2.default.green(displayPath) : import_chalk2.default.dim(displayPath));
+    } else {
+      process.stdout.write(formatted);
+    }
+  }
+  if (flags.check && changedCount > 0) {
+    console.log(
+      import_chalk2.default.red(`
+${changedCount} ${changedCount === 1 ? "file" : "files"} would be reformatted`)
+    );
+    return 1;
+  }
+  if (flags.check) {
+    console.log(import_chalk2.default.green(`All ${files.length} ${files.length === 1 ? "file" : "files"} already formatted`));
+  }
+  return 0;
+}
+
+// cli/src/main.ts
+var USAGE3 = `Usage: htmlmustache <command> [options]
+
+Commands:
+  check   Check templates for parse errors
+  format  Format templates
+
+Run 'htmlmustache <command> --help' for command-specific help.`;
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "check":
+      process.exit(run(args));
+      break;
+    case "format":
+      process.exit(await run2(args));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(USAGE3);
+      process.exit(command ? 0 : 1);
+      break;
+    default:
+      console.error(import_chalk3.default.red(`Unknown command: ${command}`));
+      console.error('Run "htmlmustache --help" for usage.');
+      process.exit(1);
+  }
+}
+main();