@b4moss/hyogen-md 0.10.0

package/dist/client.js

@@ -0,0 +1,2930 @@
+import { parse as Ne } from "yaml";
+const He = { file_not_found: "File not found: {path} (referenced from {from} via {via})", frontmatter_too_large: "Front matter exceeds size limit in {path} ({size} bytes, limit {limit})", duplicate_component_alias: 'Duplicate component alias "{alias}" in {path}', alias_collision: 'Component alias "{alias}" collides with an existing binding in {path}', forbidden_property_access: 'Forbidden property access "{property}" in {path}', parse_error: "Parse error in {path}: {message}", component_multiline_output: 'Component "{alias}" returned multiline output (single line required)', server_context_on_client: "serverContext is not allowed with renderClient", load_failed: "Failed to load {path}: {reason}" }, Pe = { circular_include: "Circular reference detected; skipped {path} (referenced from {from} via {via})", nest_limit_exceeded: "Nesting limit exceeded ({limit}); skipped block in {path}", extend_in_component: "extend is not allowed inside a component; skipped in {path}", prop_type_mismatch: 'Prop "{prop}" type mismatch in component "{component}"; expected {expected}, got {actual}', prop_missing: 'Required prop "{prop}" is missing for component "{component}"', prop_unknown: 'Unknown prop "{prop}" passed to component "{component}"; ignored', suspicious_context_value: 'Suspicious value in context key "{key}" ({reason})' }, Fe = { contains_html_script_tag: "contains HTML script tag", contains_event_handler: "contains inline event handler", contains_dangerous_scheme: "contains dangerous URL scheme", contains_embed_tag: "contains embeddable HTML tag", contains_meta_refresh: "contains meta refresh" }, J = {
+  errors: He,
+  warnings: Pe,
+  warningReasons: Fe
+}, Ie = J.errors, ze = J.warnings;
+function we(t, e) {
+  return t === void 0 ? "" : t.replace(/\{([^}]+)\}/g, (n, i) => {
+    if (e === void 0 || !(i in e))
+      return n;
+    const s = e[i];
+    return s == null ? "" : String(s);
+  });
+}
+function Ue(t, e) {
+  return we(Ie[t], e);
+}
+function O(t, e) {
+  return we(ze[t], e);
+}
+function u(t) {
+  const e = t.message ?? Ue(t.code, t.details), n = new Error(e);
+  return n.name = "HyogenError", n.code = t.code, n.message = e, n.path = t.path, n.details = t.details, n;
+}
+function _(...t) {
+  const e = {};
+  for (const n of t)
+    n != null && Object.assign(e, n);
+  return e;
+}
+class be {
+  components = /* @__PURE__ */ new Map();
+  register(e, n, i) {
+    if (this.components.has(e.alias))
+      throw u({
+        code: "duplicate_component_alias",
+        path: i ?? e.definedAt,
+        details: { alias: e.alias }
+      });
+    if (n.includes(e.alias))
+      throw u({
+        code: "alias_collision",
+        path: i ?? e.definedAt,
+        details: { alias: e.alias }
+      });
+    this.components.set(e.alias, e);
+  }
+  get(e) {
+    return this.components.get(e);
+  }
+  has(e) {
+    return this.components.has(e);
+  }
+}
+const le = 64 * 1024;
+function H(t, e) {
+  if (!t.startsWith("---"))
+    return { context: {}, body: t };
+  const n = t.indexOf(`
+`);
+  if (n === -1)
+    return { context: {}, body: t };
+  const i = t.indexOf(`
+---`, n);
+  if (i === -1)
+    return { context: {}, body: t };
+  const s = t.slice(n + 1, i), r = Buffer.byteLength(s, "utf8");
+  if (r > le)
+    throw u({
+      code: "frontmatter_too_large",
+      path: e,
+      details: {
+        size: r,
+        limit: le
+      }
+    });
+  if (s.trim().length === 0)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty front matter" }
+    });
+  let o;
+  try {
+    const h = Ne(s);
+    if (h == null)
+      o = {};
+    else if (typeof h == "object" && !Array.isArray(h))
+      o = h;
+    else
+      throw new Error("front matter must be a YAML mapping");
+  } catch (h) {
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: {
+        message: h instanceof Error ? h.message : "invalid YAML front matter"
+      }
+    });
+  }
+  const a = i + 4;
+  let c = t.slice(a);
+  return c.startsWith(`
+`) ? c = c.slice(1) : c.startsWith(`\r
+`) && (c = c.slice(2)), {
+    context: o,
+    body: c,
+    rawFrontMatter: `---
+${s}
+---`
+  };
+}
+const Ze = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array"
+]);
+function qe(t, e) {
+  const n = t.props;
+  if (n === void 0)
+    return {};
+  if (typeof n != "object" || n === null || Array.isArray(n))
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "props must be a YAML mapping" }
+    });
+  const i = {};
+  for (const [s, r] of Object.entries(n)) {
+    if (typeof r != "object" || r === null || Array.isArray(r)) {
+      i[s] = {};
+      continue;
+    }
+    const o = r, a = {};
+    if ("type" in o && o.type !== void 0) {
+      const c = String(o.type);
+      Ze.has(c) ? a.type = c : a.type = void 0;
+    }
+    "isRequired" in o && (a.isRequired = !!o.isRequired), "default" in o && (a.default = o.default), i[s] = a;
+  }
+  return i;
+}
+function Ve(t) {
+  if (t != null) {
+    if (typeof t == "string") return "string";
+    if (typeof t == "number") return "number";
+    if (typeof t == "boolean") return "boolean";
+    if (Array.isArray(t)) return "array";
+    if (typeof t == "object") return "object";
+  }
+}
+function Ke(t, e) {
+  return e === "array" ? Array.isArray(t) : e === "object" ? typeof t == "object" && t !== null && !Array.isArray(t) : typeof t === e;
+}
+function U(t, e) {
+  return {
+    code: t,
+    message: O(t, e),
+    details: e
+  };
+}
+function Ye(t, e, n) {
+  const i = [], s = {}, r = new Set(Object.keys(e));
+  for (const [o, a] of Object.entries(e)) {
+    const c = Object.prototype.hasOwnProperty.call(t, o);
+    let h = c ? t[o] : void 0;
+    if (c || (a.default !== void 0 ? h = a.default : (a.isRequired && i.push(
+      U("prop_missing", {
+        prop: o,
+        component: n
+      })
+    ), h = void 0)), c && h !== void 0 && h !== null) {
+      const l = a.type ?? Ve(h);
+      l && !Ke(h, l) && (i.push(
+        U("prop_type_mismatch", {
+          prop: o,
+          component: n,
+          expected: l,
+          actual: typeof h
+        })
+      ), h = void 0);
+    }
+    s[o] = h;
+  }
+  for (const o of Object.keys(t))
+    r.has(o) || (Object.keys(e).length > 0 ? i.push(
+      U("prop_unknown", {
+        prop: o,
+        component: n
+      })
+    ) : s[o] = t[o]);
+  return { values: s, warnings: i };
+}
+function ye(t) {
+  return /^https?:\/\//i.test(t);
+}
+function Ge(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var Z, he;
+function Je() {
+  if (he) return Z;
+  he = 1;
+  function t(s) {
+    if (typeof s != "string")
+      throw new TypeError("Path must be a string. Received " + JSON.stringify(s));
+  }
+  function e(s, r) {
+    for (var o = "", a = 0, c = -1, h = 0, l, d = 0; d <= s.length; ++d) {
+      if (d < s.length)
+        l = s.charCodeAt(d);
+      else {
+        if (l === 47)
+          break;
+        l = 47;
+      }
+      if (l === 47) {
+        if (!(c === d - 1 || h === 1)) if (c !== d - 1 && h === 2) {
+          if (o.length < 2 || a !== 2 || o.charCodeAt(o.length - 1) !== 46 || o.charCodeAt(o.length - 2) !== 46) {
+            if (o.length > 2) {
+              var f = o.lastIndexOf("/");
+              if (f !== o.length - 1) {
+                f === -1 ? (o = "", a = 0) : (o = o.slice(0, f), a = o.length - 1 - o.lastIndexOf("/")), c = d, h = 0;
+                continue;
+              }
+            } else if (o.length === 2 || o.length === 1) {
+              o = "", a = 0, c = d, h = 0;
+              continue;
+            }
+          }
+          r && (o.length > 0 ? o += "/.." : o = "..", a = 2);
+        } else
+          o.length > 0 ? o += "/" + s.slice(c + 1, d) : o = s.slice(c + 1, d), a = d - c - 1;
+        c = d, h = 0;
+      } else l === 46 && h !== -1 ? ++h : h = -1;
+    }
+    return o;
+  }
+  function n(s, r) {
+    var o = r.dir || r.root, a = r.base || (r.name || "") + (r.ext || "");
+    return o ? o === r.root ? o + a : o + s + a : a;
+  }
+  var i = {
+    // path.resolve([from ...], to)
+    resolve: function() {
+      for (var r = "", o = !1, a, c = arguments.length - 1; c >= -1 && !o; c--) {
+        var h;
+        c >= 0 ? h = arguments[c] : (a === void 0 && (a = process.cwd()), h = a), t(h), h.length !== 0 && (r = h + "/" + r, o = h.charCodeAt(0) === 47);
+      }
+      return r = e(r, !o), o ? r.length > 0 ? "/" + r : "/" : r.length > 0 ? r : ".";
+    },
+    normalize: function(r) {
+      if (t(r), r.length === 0) return ".";
+      var o = r.charCodeAt(0) === 47, a = r.charCodeAt(r.length - 1) === 47;
+      return r = e(r, !o), r.length === 0 && !o && (r = "."), r.length > 0 && a && (r += "/"), o ? "/" + r : r;
+    },
+    isAbsolute: function(r) {
+      return t(r), r.length > 0 && r.charCodeAt(0) === 47;
+    },
+    join: function() {
+      if (arguments.length === 0)
+        return ".";
+      for (var r, o = 0; o < arguments.length; ++o) {
+        var a = arguments[o];
+        t(a), a.length > 0 && (r === void 0 ? r = a : r += "/" + a);
+      }
+      return r === void 0 ? "." : i.normalize(r);
+    },
+    relative: function(r, o) {
+      if (t(r), t(o), r === o || (r = i.resolve(r), o = i.resolve(o), r === o)) return "";
+      for (var a = 1; a < r.length && r.charCodeAt(a) === 47; ++a)
+        ;
+      for (var c = r.length, h = c - a, l = 1; l < o.length && o.charCodeAt(l) === 47; ++l)
+        ;
+      for (var d = o.length, f = d - l, g = h < f ? h : f, m = -1, p = 0; p <= g; ++p) {
+        if (p === g) {
+          if (f > g) {
+            if (o.charCodeAt(l + p) === 47)
+              return o.slice(l + p + 1);
+            if (p === 0)
+              return o.slice(l + p);
+          } else h > g && (r.charCodeAt(a + p) === 47 ? m = p : p === 0 && (m = 0));
+          break;
+        }
+        var A = r.charCodeAt(a + p), L = o.charCodeAt(l + p);
+        if (A !== L)
+          break;
+        A === 47 && (m = p);
+      }
+      var b = "";
+      for (p = a + m + 1; p <= c; ++p)
+        (p === c || r.charCodeAt(p) === 47) && (b.length === 0 ? b += ".." : b += "/..");
+      return b.length > 0 ? b + o.slice(l + m) : (l += m, o.charCodeAt(l) === 47 && ++l, o.slice(l));
+    },
+    _makeLong: function(r) {
+      return r;
+    },
+    dirname: function(r) {
+      if (t(r), r.length === 0) return ".";
+      for (var o = r.charCodeAt(0), a = o === 47, c = -1, h = !0, l = r.length - 1; l >= 1; --l)
+        if (o = r.charCodeAt(l), o === 47) {
+          if (!h) {
+            c = l;
+            break;
+          }
+        } else
+          h = !1;
+      return c === -1 ? a ? "/" : "." : a && c === 1 ? "//" : r.slice(0, c);
+    },
+    basename: function(r, o) {
+      if (o !== void 0 && typeof o != "string") throw new TypeError('"ext" argument must be a string');
+      t(r);
+      var a = 0, c = -1, h = !0, l;
+      if (o !== void 0 && o.length > 0 && o.length <= r.length) {
+        if (o.length === r.length && o === r) return "";
+        var d = o.length - 1, f = -1;
+        for (l = r.length - 1; l >= 0; --l) {
+          var g = r.charCodeAt(l);
+          if (g === 47) {
+            if (!h) {
+              a = l + 1;
+              break;
+            }
+          } else
+            f === -1 && (h = !1, f = l + 1), d >= 0 && (g === o.charCodeAt(d) ? --d === -1 && (c = l) : (d = -1, c = f));
+        }
+        return a === c ? c = f : c === -1 && (c = r.length), r.slice(a, c);
+      } else {
+        for (l = r.length - 1; l >= 0; --l)
+          if (r.charCodeAt(l) === 47) {
+            if (!h) {
+              a = l + 1;
+              break;
+            }
+          } else c === -1 && (h = !1, c = l + 1);
+        return c === -1 ? "" : r.slice(a, c);
+      }
+    },
+    extname: function(r) {
+      t(r);
+      for (var o = -1, a = 0, c = -1, h = !0, l = 0, d = r.length - 1; d >= 0; --d) {
+        var f = r.charCodeAt(d);
+        if (f === 47) {
+          if (!h) {
+            a = d + 1;
+            break;
+          }
+          continue;
+        }
+        c === -1 && (h = !1, c = d + 1), f === 46 ? o === -1 ? o = d : l !== 1 && (l = 1) : o !== -1 && (l = -1);
+      }
+      return o === -1 || c === -1 || // We saw a non-dot character immediately before the dot
+      l === 0 || // The (right-most) trimmed path component is exactly '..'
+      l === 1 && o === c - 1 && o === a + 1 ? "" : r.slice(o, c);
+    },
+    format: function(r) {
+      if (r === null || typeof r != "object")
+        throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof r);
+      return n("/", r);
+    },
+    parse: function(r) {
+      t(r);
+      var o = { root: "", dir: "", base: "", ext: "", name: "" };
+      if (r.length === 0) return o;
+      var a = r.charCodeAt(0), c = a === 47, h;
+      c ? (o.root = "/", h = 1) : h = 0;
+      for (var l = -1, d = 0, f = -1, g = !0, m = r.length - 1, p = 0; m >= h; --m) {
+        if (a = r.charCodeAt(m), a === 47) {
+          if (!g) {
+            d = m + 1;
+            break;
+          }
+          continue;
+        }
+        f === -1 && (g = !1, f = m + 1), a === 46 ? l === -1 ? l = m : p !== 1 && (p = 1) : l !== -1 && (p = -1);
+      }
+      return l === -1 || f === -1 || // We saw a non-dot character immediately before the dot
+      p === 0 || // The (right-most) trimmed path component is exactly '..'
+      p === 1 && l === f - 1 && l === d + 1 ? f !== -1 && (d === 0 && c ? o.base = o.name = r.slice(1, f) : o.base = o.name = r.slice(d, f)) : (d === 0 && c ? (o.name = r.slice(1, l), o.base = r.slice(1, f)) : (o.name = r.slice(d, l), o.base = r.slice(d, f)), o.ext = r.slice(l, f)), d > 0 ? o.dir = r.slice(0, d - 1) : c && (o.dir = "/"), o;
+    },
+    sep: "/",
+    delimiter: ":",
+    win32: null,
+    posix: null
+  };
+  return i.posix = i, Z = i, Z;
+}
+var Xe = Je();
+const y = /* @__PURE__ */ Ge(Xe);
+function Qe(t, e) {
+  const n = y.relative(e, t);
+  return n === "" || !n.startsWith("..") && !y.isAbsolute(n);
+}
+function et(t, e, n) {
+  const i = y.resolve(e), s = y.resolve(t);
+  if (!Qe(s, i))
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: { message: "path resolves outside root directory" }
+    });
+}
+function ve(t, e = {}) {
+  const { rootDir: n, fromPath: i, documentPath: s, constrainToRoot: r = !1, hyogenPath: o = !1 } = e;
+  if (t.length === 0)
+    throw u({
+      code: "parse_error",
+      path: s,
+      details: { message: "empty template path" }
+    });
+  let a;
+  if (t.startsWith("/"))
+    if (n)
+      a = y.resolve(n, t.slice(1));
+    else {
+      if (o)
+        throw u({
+          code: "parse_error",
+          path: s,
+          details: { message: "root-relative paths require a doc root" }
+        });
+      if (y.isAbsolute(t))
+        a = y.resolve(t);
+      else
+        throw u({
+          code: "parse_error",
+          path: s,
+          details: { message: "root-relative paths require a doc root" }
+        });
+    }
+  else if (t.startsWith("./") || t.startsWith("../"))
+    if (i)
+      a = y.resolve(y.dirname(i), t);
+    else if (n)
+      a = y.resolve(n, t);
+    else
+      throw u({
+        code: "parse_error",
+        path: s,
+        details: { message: "root is required for relative template paths" }
+      });
+  else if (y.isAbsolute(t))
+    a = y.resolve(t);
+  else if (n)
+    a = y.resolve(n, t);
+  else
+    throw u({
+      code: "parse_error",
+      path: s,
+      details: { message: "root is required for relative template paths" }
+    });
+  return n && r && et(a, n, s), a;
+}
+async function tt(t) {
+  const e = t.registry.get(t.alias);
+  if (!e)
+    throw u({
+      code: "parse_error",
+      path: t.path,
+      details: {
+        message: `unregistered component: ${t.alias}`
+      }
+    });
+  const n = ye(e.componentPath) ? e.componentPath : ve(e.componentPath, {
+    rootDir: t.rootDir,
+    fromPath: e.definedAt,
+    documentPath: t.path,
+    constrainToRoot: t.constrainToRoot,
+    hyogenPath: !0
+  }), i = await t.loader(n), { context: s, body: r } = H(i, n), o = qe(s, n), { values: a, warnings: c } = Ye(
+    t.props,
+    o,
+    t.alias
+  );
+  t.warnings.push(...c);
+  const { props: h, ...l } = s, d = _(
+    t.parentContext,
+    l,
+    a
+  ), g = (await ae(r, {
+    context: d,
+    loader: t.loader,
+    root: t.rootDir,
+    path: n,
+    registry: t.registry,
+    warnings: t.warnings,
+    visitStack: t.visitStack,
+    inComponent: !0,
+    preserveFrontMatter: !1,
+    preserveHgComments: t.preserveHgComments,
+    constrainToRoot: t.constrainToRoot
+  })).trim();
+  if (g.includes(`
+`))
+    throw u({
+      code: "component_multiline_output",
+      path: n,
+      details: { alias: t.alias }
+    });
+  return g;
+}
+const nt = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor",
+  "__defineGetter__"
+]);
+function it(t) {
+  return nt.has(t);
+}
+function de(t, e) {
+  if (it(t))
+    throw u({
+      code: "forbidden_property_access",
+      path: e,
+      details: { property: t }
+    });
+}
+function M(t) {
+  return !t;
+}
+function rt(t, e) {
+  if (t != null && typeof t == "object")
+    return t[e];
+}
+function st(t, e, n) {
+  switch (t) {
+    case "+":
+      return e + n;
+    case "-":
+      return e - n;
+    case "*":
+      return e * n;
+    case "/":
+      return e / n;
+    case "===":
+      return e === n;
+    case "!==":
+      return e !== n;
+    case "==":
+      return e == n;
+    case "!=":
+      return e != n;
+    case ">=":
+      return e >= n;
+    case "<=":
+      return e <= n;
+    case ">":
+      return e > n;
+    case "<":
+      return e < n;
+    case "&&":
+      return M(e) ? e : n;
+    case "||":
+      return M(e) ? n : e;
+    default:
+      return;
+  }
+}
+async function w(t, e) {
+  const { context: n, path: i } = e;
+  switch (t.type) {
+    case "literal":
+      return t.value;
+    case "identifier":
+      return de(t.name, i), n[t.name];
+    case "member": {
+      de(t.property, i);
+      const s = await w(t.object, e);
+      return rt(s, t.property);
+    }
+    case "default": {
+      const s = await w(t.left, e);
+      return M(s) ? w(t.right, e) : s;
+    }
+    case "unary": {
+      const s = await w(t.operand, e);
+      return t.op === "!" ? !s : void 0;
+    }
+    case "binary": {
+      if (t.op === "&&") {
+        const o = await w(t.left, e);
+        return M(o) ? o : w(t.right, e);
+      }
+      if (t.op === "||") {
+        const o = await w(t.left, e);
+        return M(o) ? w(t.right, e) : o;
+      }
+      const s = await w(t.left, e), r = await w(t.right, e);
+      return st(t.op, s, r);
+    }
+    case "call": {
+      if (!e.registry || !e.loader || !e.visitStack)
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `function calls are not allowed: ${t.callee}()`
+          }
+        });
+      if (!e.registry.has(t.callee))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `unregistered component: ${t.callee}`
+          }
+        });
+      const s = {};
+      for (const [r, o] of Object.entries(t.args))
+        s[r] = await w(o, e);
+      return tt({
+        alias: t.callee,
+        props: s,
+        parentContext: e.parentContext ?? n,
+        registry: e.registry,
+        loader: e.loader,
+        rootDir: e.rootDir,
+        path: i,
+        warnings: e.warnings ?? [],
+        visitStack: e.visitStack,
+        preserveHgComments: e.preserveHgComments,
+        constrainToRoot: e.constrainToRoot
+      });
+    }
+    case "method": {
+      if (t.method !== "toLocaleString")
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: { message: `unsupported method: ${t.method}()` }
+        });
+      const s = await w(t.object, e);
+      return s == null || typeof s.toLocaleString != "function" ? void 0 : s.toLocaleString(
+        ...t.args
+      );
+    }
+    case "ternary": {
+      const s = await w(t.condition, e);
+      return M(s) ? w(t.alternate, e) : w(t.consequent, e);
+    }
+    case "template": {
+      let s = "";
+      for (const r of t.parts)
+        if (typeof r == "string")
+          s += r;
+        else {
+          const o = await w(r, e);
+          o != null && (s += String(o));
+        }
+      return s;
+    }
+    default:
+      return;
+  }
+}
+function q(t) {
+  return /[A-Za-z_$]/.test(t);
+}
+function ot(t) {
+  return /[A-Za-z0-9_$]/.test(t);
+}
+function C(t, e, n = {}) {
+  const i = t.trim();
+  if (i.length === 0)
+    throw x(e, "empty expression");
+  const s = new at(i, e, n), r = s.parseExpression();
+  if (s.skipWhitespace(), s.hasMore())
+    throw x(e, `unexpected token at position ${s.position}`);
+  return r;
+}
+function x(t, e) {
+  throw u({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+class at {
+  constructor(e, n, i = {}) {
+    this.input = e, this.path = n, this.allowCalls = i.allowCalls !== !1;
+  }
+  input;
+  path;
+  index = 0;
+  allowCalls;
+  get position() {
+    return this.index;
+  }
+  hasMore() {
+    return this.skipWhitespace(), this.index < this.input.length;
+  }
+  skipWhitespace() {
+    for (; this.index < this.input.length && /\s/.test(this.input[this.index]); )
+      this.index++;
+  }
+  parseExpression() {
+    return this.parsePipe();
+  }
+  parsePipe() {
+    let e = this.parseTernary();
+    for (; this.skipWhitespace(), !(this.peek() !== "|" || this.input[this.index + 1] === "|"); ) {
+      this.index++;
+      const n = this.parseTernary();
+      e = { type: "default", left: e, right: n };
+    }
+    return e;
+  }
+  parseTernary() {
+    const e = this.parseLogicalOr();
+    if (this.skipWhitespace(), this.peek() !== "?")
+      return e;
+    this.index++;
+    const n = this.parseTernary();
+    if (this.skipWhitespace(), this.peek() !== ":")
+      throw x(this.path, "expected ':' in ternary expression");
+    this.index++;
+    const i = this.parseTernary();
+    return { type: "ternary", condition: e, consequent: n, alternate: i };
+  }
+  parseLogicalOr() {
+    let e = this.parseLogicalAnd();
+    for (; this.skipWhitespace(), !!this.match("||"); ) {
+      const n = this.parseLogicalAnd();
+      e = { type: "binary", op: "||", left: e, right: n };
+    }
+    return e;
+  }
+  parseLogicalAnd() {
+    let e = this.parseComparison();
+    for (; this.skipWhitespace(), !!this.match("&&"); ) {
+      const n = this.parseComparison();
+      e = { type: "binary", op: "&&", left: e, right: n };
+    }
+    return e;
+  }
+  parseComparison() {
+    let e = this.parseAdditive();
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.readComparisonOp();
+      if (!n)
+        break;
+      const i = this.parseAdditive();
+      e = { type: "binary", op: n, left: e, right: i };
+    }
+    return e;
+  }
+  readComparisonOp() {
+    const e = [
+      "===",
+      "!==",
+      "==",
+      "!=",
+      ">=",
+      "<=",
+      ">",
+      "<"
+    ];
+    for (const n of e)
+      if (this.input.startsWith(n, this.index))
+        return this.index += n.length, n;
+    return null;
+  }
+  parseAdditive() {
+    let e = this.parseMultiplicative();
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.peek();
+      if (n !== "+" && n !== "-")
+        break;
+      this.index++;
+      const i = this.parseMultiplicative();
+      e = { type: "binary", op: n, left: e, right: i };
+    }
+    return e;
+  }
+  parseMultiplicative() {
+    let e = this.parseUnary();
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.peek();
+      if (n !== "*" && n !== "/")
+        break;
+      this.index++;
+      const i = this.parseUnary();
+      e = { type: "binary", op: n, left: e, right: i };
+    }
+    return e;
+  }
+  parseUnary() {
+    return this.skipWhitespace(), this.peek() === "!" ? (this.index++, { type: "unary", op: "!", operand: this.parseUnary() }) : this.parsePostfix();
+  }
+  parsePostfix() {
+    let e = this.parsePrimary();
+    for (; ; ) {
+      if (this.skipWhitespace(), this.peek() === ".") {
+        this.index++, e = this.parseAfterDot(e);
+        continue;
+      }
+      break;
+    }
+    return e;
+  }
+  parseAfterDot(e) {
+    this.skipWhitespace();
+    const n = this.readIdentifier();
+    if (!n)
+      throw x(this.path, "expected property name after '.'");
+    if (this.skipWhitespace(), this.peek() === "(") {
+      if (n !== "toLocaleString")
+        throw x(this.path, `unsupported method: ${n}()`);
+      this.index++;
+      const i = this.parseMethodArgs();
+      return { type: "method", object: e, method: n, args: i };
+    }
+    return { type: "member", object: e, property: n };
+  }
+  parseMethodArgs() {
+    this.skipWhitespace();
+    const e = [];
+    if (this.peek() === ")")
+      return this.index++, e;
+    for (e.push(this.parseLiteralValue()), this.skipWhitespace(); this.peek() === ","; )
+      this.index++, e.push(this.parseLiteralValue()), this.skipWhitespace();
+    if (this.peek() !== ")")
+      throw x(this.path, "expected ')' after method arguments");
+    return this.index++, e;
+  }
+  parsePrimary() {
+    this.skipWhitespace();
+    const e = this.peek();
+    if (e === "(") {
+      this.index++;
+      const n = this.parseExpression();
+      if (this.skipWhitespace(), this.peek() !== ")")
+        throw x(this.path, "expected ')'");
+      return this.index++, n;
+    }
+    if (e === "`")
+      return this.parseTemplateLiteral();
+    if (e === '"' || e === "'")
+      return { type: "literal", value: this.readString() };
+    if (e === "-" || e >= "0" && e <= "9")
+      return { type: "literal", value: this.readNumber() };
+    if (e === "{")
+      return { type: "literal", value: this.parseObjectLiteral() };
+    if (e === "[")
+      return { type: "literal", value: this.parseArrayLiteral() };
+    if (q(e)) {
+      const n = this.readIdentifier();
+      if (n === "true" || n === "false" || n === "null" || n === "undefined")
+        return { type: "literal", value: n === "true" ? !0 : n === "false" ? !1 : n === "null" ? null : void 0 };
+      if (this.skipWhitespace(), this.peek() === "(") {
+        if (!this.allowCalls)
+          throw x(
+            this.path,
+            "component calls are not allowed in template literals"
+          );
+        this.index++;
+        const i = this.parseCallArgs();
+        return { type: "call", callee: n, args: i };
+      }
+      if (this.peek() === "[")
+        throw x(this.path, "bracket access is not allowed");
+      return { type: "identifier", name: n };
+    }
+    throw x(this.path, `unexpected character '${e}'`);
+  }
+  parseTemplateLiteral() {
+    this.index++;
+    const e = [];
+    let n = "";
+    for (; this.index < this.input.length; ) {
+      const i = this.input[this.index];
+      if (i === "`")
+        return this.index++, e.push(n), { type: "template", parts: e };
+      if (i === "\\") {
+        if (this.index++, this.index >= this.input.length)
+          throw x(this.path, "unterminated template literal escape");
+        n += this.input[this.index], this.index++;
+        continue;
+      }
+      if (i === "$" && this.input[this.index + 1] === "{") {
+        e.push(n), n = "", this.index += 2;
+        const s = this.readTemplateExpression(), r = C(s, this.path, {
+          allowCalls: !1
+        });
+        e.push(r);
+        continue;
+      }
+      n += i, this.index++;
+    }
+    throw x(this.path, "unterminated template literal");
+  }
+  readTemplateExpression() {
+    let e = 1;
+    const n = this.index;
+    let i = null;
+    for (; this.index < this.input.length; ) {
+      const s = this.input[this.index];
+      if (i) {
+        if (s === "\\") {
+          this.index += 2;
+          continue;
+        }
+        s === i && (i = null), this.index++;
+        continue;
+      }
+      if (s === '"' || s === "'" || s === "`") {
+        i = s, this.index++;
+        continue;
+      }
+      if (s === "{") {
+        e++, this.index++;
+        continue;
+      }
+      if (s === "}") {
+        if (e--, e === 0) {
+          const r = this.input.slice(n, this.index);
+          return this.index++, r;
+        }
+        this.index++;
+        continue;
+      }
+      this.index++;
+    }
+    throw x(this.path, "unterminated template expression");
+  }
+  parseCallArgs() {
+    if (this.skipWhitespace(), this.peek() === ")")
+      return this.index++, {};
+    if (this.peek() !== "{")
+      throw x(this.path, "expected object literal");
+    this.index++, this.skipWhitespace();
+    const e = {};
+    if (this.peek() === "}") {
+      if (this.index++, this.skipWhitespace(), this.peek() !== ")")
+        throw x(this.path, "expected ')' after call arguments");
+      return this.index++, e;
+    }
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.readIdentifier();
+      if (!n)
+        throw x(this.path, "expected property name in object literal");
+      if (this.skipWhitespace(), this.peek() !== ":")
+        throw x(this.path, "expected ':' in object literal");
+      if (this.index++, this.skipWhitespace(), e[n] = this.parseTernary(), this.skipWhitespace(), this.peek() === "}") {
+        this.index++;
+        break;
+      }
+      if (this.peek() === ",") {
+        if (this.index++, this.skipWhitespace(), this.peek() === "}") {
+          this.index++;
+          break;
+        }
+        continue;
+      }
+      throw x(this.path, "expected ',' or '}' in object literal");
+    }
+    if (this.skipWhitespace(), this.peek() !== ")")
+      throw x(this.path, "expected ')' after call arguments");
+    return this.index++, e;
+  }
+  parseObjectLiteral() {
+    if (this.peek() !== "{")
+      throw x(this.path, "expected object literal");
+    this.index++, this.skipWhitespace();
+    const e = {};
+    if (this.peek() === "}")
+      return this.index++, e;
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.readIdentifier();
+      if (!n)
+        throw x(this.path, "expected property name in object literal");
+      if (this.skipWhitespace(), this.peek() !== ":")
+        throw x(this.path, "expected ':' in object literal");
+      if (this.index++, this.skipWhitespace(), e[n] = this.parseLiteralValue(), this.skipWhitespace(), this.peek() === "}") {
+        this.index++;
+        break;
+      }
+      if (this.peek() === ",") {
+        if (this.index++, this.skipWhitespace(), this.peek() === "}") {
+          this.index++;
+          break;
+        }
+      } else
+        throw x(this.path, "expected ',' or '}' in object literal");
+    }
+    return e;
+  }
+  parseArrayLiteral() {
+    if (this.peek() !== "[")
+      throw x(this.path, "expected array literal");
+    this.index++, this.skipWhitespace();
+    const e = [];
+    if (this.peek() === "]")
+      return this.index++, e;
+    for (; ; ) {
+      if (this.skipWhitespace(), e.push(this.parseLiteralValue()), this.skipWhitespace(), this.peek() === "]") {
+        this.index++;
+        break;
+      }
+      if (this.peek() === ",") {
+        if (this.index++, this.skipWhitespace(), this.peek() === "]") {
+          this.index++;
+          break;
+        }
+      } else
+        throw x(this.path, "expected ',' or ']' in array literal");
+    }
+    return e;
+  }
+  parseLiteralValue() {
+    this.skipWhitespace();
+    const e = this.peek();
+    if (e === '"' || e === "'")
+      return this.readString();
+    if (e === "-" || e >= "0" && e <= "9")
+      return this.readNumber();
+    if (e === "{")
+      return this.parseObjectLiteral();
+    if (e === "[")
+      return this.parseArrayLiteral();
+    if (q(e)) {
+      const n = this.readIdentifier();
+      if (n === "true") return !0;
+      if (n === "false") return !1;
+      if (n === "null") return null;
+      throw x(this.path, "object literal values must be literals");
+    }
+    throw x(this.path, "object literal values must be literals");
+  }
+  match(e) {
+    return this.skipWhitespace(), this.input.startsWith(e, this.index) ? (this.index += e.length, !0) : !1;
+  }
+  peek() {
+    return this.input[this.index] ?? "";
+  }
+  readIdentifier() {
+    this.skipWhitespace();
+    const e = this.index;
+    if (!q(this.peek()))
+      return "";
+    for (this.index++; this.index < this.input.length && ot(this.peek()); )
+      this.index++;
+    return this.input.slice(e, this.index);
+  }
+  readString() {
+    const e = this.peek();
+    this.index++;
+    let n = "";
+    for (; this.index < this.input.length; ) {
+      const i = this.input[this.index];
+      if (i === e)
+        return this.index++, n;
+      if (i === "\\") {
+        if (this.index++, this.index >= this.input.length)
+          throw x(this.path, "unterminated string escape");
+        const s = this.input[this.index];
+        n += s, this.index++;
+        continue;
+      }
+      n += i, this.index++;
+    }
+    throw x(this.path, "unterminated string literal");
+  }
+  readNumber() {
+    const e = this.index;
+    for (this.peek() === "-" && this.index++; this.index < this.input.length && /[0-9.]/.test(this.peek()); )
+      this.index++;
+    const n = this.input.slice(e, this.index), i = Number(n);
+    if (Number.isNaN(i))
+      throw x(this.path, `invalid number '${n}'`);
+    return i;
+  }
+}
+async function _e(t, e, n = {}) {
+  const i = n.path;
+  let s = "", r = 0;
+  for (; r < t.length; ) {
+    const o = t.indexOf("{", r);
+    if (o === -1) {
+      s += t.slice(r);
+      break;
+    }
+    s += t.slice(r, o);
+    const a = t[o + 1] === "{" && t[o + 2] === "{" && (o === 0 || t[o - 1] !== "\\");
+    if (!(!a && t[o + 1] === "{" && (o === 0 || t[o - 1] !== "\\")) && !a) {
+      s += "{", r = o + 1;
+      continue;
+    }
+    const h = a ? 3 : 2, l = a ? "}}}" : "}}", d = t.indexOf(l, o + h);
+    if (d === -1)
+      throw u({
+        code: "parse_error",
+        path: i,
+        details: { message: "unclosed expression" }
+      });
+    const f = t.slice(o + h, d).trim(), g = C(f, i), m = await w(g, {
+      ...n,
+      context: e,
+      path: i,
+      parentContext: n.parentContext ?? e
+    });
+    s += m == null ? "" : String(m), r = d + l.length;
+  }
+  return s;
+}
+function ct(t, e) {
+  let n = 0, i = 0;
+  for (; i < t.length; ) {
+    const s = t.indexOf(e, i);
+    if (s === -1)
+      break;
+    n++, i = s + e.length;
+  }
+  return n;
+}
+function X(t) {
+  const e = t.includes("@hg"), n = t.includes("@endhg"), i = ct(t, "@@");
+  return e && n ? i > 0 ? "mixed" : "hg" : i >= 2 && !e && !n ? "at-at" : (e || n) && i > 0 ? "mixed" : e && !n || i === 1 && !n ? "unclosed" : "none";
+}
+function Q(t) {
+  return t.replace(/@endhg/g, "").replace(/@hg/g, "").replace(/@@/g, "");
+}
+function ee(t, e) {
+  let n = 0, i = !1;
+  for (; n < e; ) {
+    const s = t.indexOf("```", n);
+    if (s === -1 || s >= e)
+      break;
+    i = !i, n = s + 3;
+  }
+  return i;
+}
+function T(t) {
+  const e = [];
+  let n = 0;
+  for (; n < t.length; ) {
+    const i = t.indexOf("<!--", n);
+    if (i === -1)
+      break;
+    if (ee(t, i)) {
+      n = i + 4;
+      continue;
+    }
+    const s = t.indexOf("-->", i + 4);
+    if (s === -1)
+      break;
+    const r = t.slice(i, s + 3), o = r.slice(4, r.length - 3), a = X(o);
+    (a === "hg" || a === "at-at") && e.push({
+      start: i,
+      end: s + 3,
+      inner: o,
+      raw: r
+    }), n = s + 3;
+  }
+  return e;
+}
+function Se(t) {
+  let e = 0;
+  for (; e < t.length; ) {
+    const n = t.indexOf("<!--", e);
+    if (n === -1)
+      return !1;
+    if (ee(t, n)) {
+      e = n + 4;
+      continue;
+    }
+    const i = t.indexOf("-->", n + 4);
+    if (i === -1)
+      return !1;
+    const s = t.slice(n + 4, i), r = X(s);
+    if (r === "unclosed" || r === "mixed")
+      return !0;
+    e = i + 3;
+  }
+  return !1;
+}
+function Ce(t) {
+  let e = 0;
+  for (; e < t.length; ) {
+    const n = t.indexOf("<!--", e);
+    if (n === -1)
+      return null;
+    if (ee(t, n)) {
+      e = n + 4;
+      continue;
+    }
+    const i = t.indexOf("-->", n + 4);
+    if (i === -1)
+      return null;
+    const s = t.slice(n + 4, i), r = X(s);
+    if (r === "mixed")
+      return "mixed @hg and @@ markers are not allowed";
+    if (r === "unclosed")
+      return "unclosed hyogen block (missing closing marker)";
+    e = i + 3;
+  }
+  return null;
+}
+function E(t) {
+  return Q(t).trim().split(/\r?\n/).map((n) => n.trim()).filter((n) => n.length > 0);
+}
+const lt = /^(if\s+.+|else\s+if\s+.+|else|endif|each\s+[A-Za-z_$][A-Za-z0-9_$]*\s+in\s+.+|endeach)$/i;
+function Ae(t) {
+  return lt.test(t.trim());
+}
+function V(t, e) {
+  throw u({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function ht(t, e) {
+  let n = t;
+  const i = /^<!--([\s\S]*?)-->$/.exec(t.trim());
+  i && (n = i[1]);
+  const s = E(n);
+  if (s.length !== 1)
+    return null;
+  const r = s[0];
+  if (/^include\s+/i.test(r) || /^component\s+/i.test(r) || /^const\s+/i.test(r) || /^let\s+/i.test(r) || /^[A-Za-z_$][A-Za-z0-9_$]*\s*=/.test(r))
+    return null;
+  if (r === "else")
+    return { kind: "else" };
+  if (r === "endif")
+    return { kind: "endif" };
+  if (r === "endeach")
+    return { kind: "endeach" };
+  if (/^IF\b/.test(r) || /^ELSE\b/.test(r) || /^ENDIF\b/.test(r))
+    throw V(e, "control keywords must be lowercase");
+  const o = /^else\s+if\s+(.+)$/.exec(r);
+  if (o)
+    return {
+      kind: "else_if",
+      expr: C(o[1], e)
+    };
+  const a = /^if\s+(.+)$/.exec(r);
+  if (a)
+    return {
+      kind: "if",
+      expr: C(a[1], e)
+    };
+  const c = /^each\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+in\s+(.+)$/.exec(r);
+  if (c)
+    return {
+      kind: "each",
+      item: c[1],
+      expr: C(c[2], e)
+    };
+  if (r === "if")
+    throw V(e, "if requires an expression");
+  if (/^each\s+/.test(r))
+    throw V(e, "invalid each directive");
+  return null;
+}
+function R(t) {
+  return { start: t.start, end: t.end, raw: t.raw };
+}
+function S(t, e) {
+  throw u({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function dt(t, e) {
+  const n = [];
+  for (const i of T(t)) {
+    const s = ht(i.inner, e);
+    s && n.push({
+      start: i.start,
+      end: i.end,
+      raw: i.raw,
+      opener: s
+    });
+  }
+  return n;
+}
+function We(t) {
+  return t.kind === "if" || t.kind === "each";
+}
+function ut(t, e) {
+  const n = dt(t, e);
+  if (n.length === 0)
+    return t.length > 0 ? [{ kind: "text", content: t }] : [];
+  const { nodes: i, nextIndex: s } = j(t, n, 0, n.length, e);
+  if (s < n.length) {
+    const r = n[s];
+    if (r.opener.kind === "endif")
+      throw S(e, "endif without matching if");
+    if (r.opener.kind === "endeach")
+      throw S(e, "endeach without matching each");
+    if (r.opener.kind === "else" || r.opener.kind === "else_if")
+      throw S(e, "else without matching if");
+  }
+  return i;
+}
+function j(t, e, n, i, s, r = 0, o) {
+  const a = o ?? t.length, c = [];
+  let h = r, l = n;
+  for (; l < i; ) {
+    const d = e[l];
+    if (d.start >= a)
+      break;
+    if (d.end <= r) {
+      l++;
+      continue;
+    }
+    if (d.start > h && c.push({
+      kind: "text",
+      content: t.slice(h, d.start)
+    }), d.opener.kind === "if") {
+      const f = ft(t, e, l, i, s);
+      c.push(f.node), h = f.endPos, l = f.nextIndex;
+      continue;
+    }
+    if (d.opener.kind === "each") {
+      const f = pt(t, e, l, i, s);
+      c.push(f.node), h = f.endPos, l = f.nextIndex;
+      continue;
+    }
+    if (d.opener.kind === "else" || d.opener.kind === "else_if")
+      throw S(s, "else without matching if");
+    if (d.opener.kind === "endif")
+      throw S(s, "endif without matching if");
+    if (d.opener.kind === "endeach")
+      throw S(s, "endeach without matching each");
+    l++;
+  }
+  return h < a && c.push({ kind: "text", content: t.slice(h, a) }), { nodes: c, nextIndex: l };
+}
+function ft(t, e, n, i, s) {
+  const r = e[n];
+  if (r.opener.kind !== "if")
+    throw S(s, "expected if");
+  const o = [];
+  let a = n, c = r.end, h = 0;
+  for (; a < i; ) {
+    const l = e[a];
+    if (a === n) {
+      if (l.opener.kind !== "if")
+        throw S(s, "expected if");
+      o.push({
+        kind: "if",
+        expr: l.opener.expr,
+        opener: R(l),
+        body: []
+      }), a++;
+      continue;
+    }
+    if (We(l.opener)) {
+      h++, a++;
+      continue;
+    }
+    if (l.opener.kind === "endif") {
+      if (h === 0)
+        return o[o.length - 1].body = j(
+          t,
+          e,
+          n + 1,
+          a,
+          s,
+          c,
+          l.start
+        ).nodes, {
+          node: { kind: "if", branches: o, closer: R(l) },
+          nextIndex: a + 1,
+          endPos: l.end
+        };
+      h--, a++;
+      continue;
+    }
+    if (l.opener.kind === "endeach") {
+      h--, a++;
+      continue;
+    }
+    if (h === 0) {
+      if (l.opener.kind === "else_if") {
+        o[o.length - 1].body = j(
+          t,
+          e,
+          n + 1,
+          a,
+          s,
+          c,
+          l.start
+        ).nodes, o.push({
+          kind: "else_if",
+          expr: l.opener.expr,
+          opener: R(l),
+          body: []
+        }), c = l.end, a++;
+        continue;
+      }
+      if (l.opener.kind === "else") {
+        o[o.length - 1].body = j(
+          t,
+          e,
+          n + 1,
+          a,
+          s,
+          c,
+          l.start
+        ).nodes, o.push({
+          kind: "else",
+          opener: R(l),
+          body: []
+        }), c = l.end, a++;
+        continue;
+      }
+    }
+    a++;
+  }
+  throw S(s, "unclosed if block (missing endif)");
+}
+function pt(t, e, n, i, s) {
+  const r = e[n];
+  if (r.opener.kind !== "each")
+    throw S(s, "expected each");
+  let o = n + 1;
+  const a = r.end;
+  let c = 0;
+  for (; o < i; ) {
+    const h = e[o];
+    if (We(h.opener)) {
+      c++, o++;
+      continue;
+    }
+    if (h.opener.kind === "endeach") {
+      if (c === 0) {
+        const l = j(
+          t,
+          e,
+          n + 1,
+          o,
+          s,
+          a,
+          h.start
+        ).nodes;
+        return {
+          node: {
+            kind: "each",
+            item: r.opener.item,
+            expr: r.opener.expr,
+            opener: R(r),
+            body: l,
+            closer: R(h)
+          },
+          nextIndex: o + 1,
+          endPos: h.end
+        };
+      }
+      c--, o++;
+      continue;
+    }
+    if (h.opener.kind === "endif") {
+      c--, o++;
+      continue;
+    }
+    o++;
+  }
+  throw S(s, "unclosed each block (missing endeach)");
+}
+const ue = 20;
+class mt {
+  depth = 0;
+  get currentDepth() {
+    return this.depth;
+  }
+  enter() {
+    return this.depth >= ue ? { exceeded: !0, limit: ue } : (this.depth++, { exceeded: !1, depth: this.depth });
+  }
+  exit() {
+    this.depth > 0 && this.depth--;
+  }
+}
+function gt(t) {
+  return !!t;
+}
+function xt(t) {
+  return t != null && typeof t[Symbol.iterator] == "function";
+}
+function $e(t) {
+  return {
+    code: "nest_limit_exceeded",
+    message: "structure nest limit exceeded",
+    path: t,
+    details: { limit: 20 }
+  };
+}
+function te(t) {
+  return t.startsWith(`
+`) ? t.slice(1) : t;
+}
+async function kt(t, e) {
+  const n = e.path, i = e.warnings ?? [], s = ut(t, n), r = new mt();
+  return ne(s, e, r, i);
+}
+async function ne(t, e, n, i) {
+  const s = e.preserveHgComments === !0;
+  let r = "", o = !1;
+  for (const a of t) {
+    let c = await wt(a, e, n, i);
+    o && (c = te(c)), r += c, o = !s && (a.kind === "if" || a.kind === "each");
+  }
+  return r;
+}
+async function wt(t, e, n, i) {
+  switch (t.kind) {
+    case "text":
+      return t.content;
+    case "if":
+      return bt(t, e, n, i);
+    case "each":
+      return yt(t, e, n, i);
+    default:
+      return "";
+  }
+}
+async function bt(t, e, n, i) {
+  if (n.enter().exceeded)
+    return i.push($e(e.path)), "";
+  try {
+    let r = -1;
+    for (let c = 0; c < t.branches.length; c++) {
+      const h = t.branches[c];
+      if (h.kind === "else") {
+        r = c;
+        break;
+      }
+      const l = await w(h.expr, e);
+      if (gt(l)) {
+        r = c;
+        break;
+      }
+    }
+    const o = e.preserveHgComments === !0;
+    let a = "";
+    for (let c = 0; c < t.branches.length; c++) {
+      const h = t.branches[c];
+      if (o && (a += h.opener.raw), c === r) {
+        let l = await ne(h.body, e, n, i);
+        o || (l = te(l)), a += l;
+      }
+    }
+    return o && (a += t.closer.raw), a;
+  } finally {
+    n.exit();
+  }
+}
+async function yt(t, e, n, i) {
+  if (n.enter().exceeded)
+    return i.push($e(e.path)), "";
+  try {
+    const r = await w(t.expr, e);
+    if (!xt(r))
+      return "";
+    const o = e.preserveHgComments === !0;
+    let a = "";
+    for (const c of r) {
+      const h = { ...e.context, [t.item]: c };
+      o && (a += t.opener.raw);
+      let l = await ne(t.body, {
+        ...e,
+        context: h
+      }, n, i);
+      o || (l = te(l));
+      const d = await _e(l, h, {
+        path: e.path,
+        registry: e.registry,
+        loader: e.loader,
+        rootDir: e.rootDir,
+        warnings: i,
+        visitStack: e.visitStack,
+        parentContext: e.parentContext ?? e.context,
+        preserveHgComments: e.preserveHgComments,
+        constrainToRoot: e.constrainToRoot
+      });
+      a += d, o && (a += t.closer.raw);
+    }
+    return a;
+  } finally {
+    n.exit();
+  }
+}
+function Y(t, e, n, i, s = !1, r = !1) {
+  return ye(e) ? e : ve(e, {
+    rootDir: t,
+    fromPath: i,
+    documentPath: n,
+    constrainToRoot: s,
+    hyogenPath: r
+  });
+}
+function Te(t) {
+  let e = 0;
+  for (let n = t.length - 1; n >= 0 && t[n] === `
+`; n--)
+    e++;
+  return e;
+}
+function Ee(t) {
+  let e = 0;
+  for (; e < t.length && t[e] === `
+`; )
+    e++;
+  return e;
+}
+function D(t, e) {
+  const n = Te(t), i = Ee(e), s = Math.max(n, i);
+  return t.slice(0, t.length - n) + `
+`.repeat(s) + e.slice(i);
+}
+function ie(t, e) {
+  const n = Te(t), i = Ee(e);
+  return n + i - Math.max(n, i);
+}
+function fe(t, e, n) {
+  const i = t.indexOf(e);
+  if (i < 0)
+    return t;
+  const s = t.slice(0, i), r = t.slice(i + e.length);
+  return D(D(s, n), r);
+}
+async function vt(t) {
+  let e = t.source;
+  for (const n of t.directives) {
+    const i = Y(
+      t.root,
+      n.path,
+      t.path,
+      t.path,
+      t.constrainToRoot,
+      !0
+    );
+    if (t.visitStack) {
+      const s = t.visitStack.check(i);
+      if (s.circular) {
+        t.warnings?.push({
+          code: "circular_include",
+          message: O("circular_include", {
+            path: i,
+            from: s.from,
+            via: "include"
+          }),
+          path: t.path,
+          details: {
+            path: i,
+            from: s.from,
+            via: "include"
+          }
+        }), e = fe(e, n.marker, "");
+        continue;
+      }
+      t.visitStack.push(i);
+    }
+    try {
+      const s = await t.loader(i), r = await Yt(s, {
+        context: t.context,
+        loader: t.loader,
+        root: t.root,
+        path: i,
+        preserveFrontMatter: t.preserveFrontMatter,
+        preserveHgComments: t.preserveHgComments,
+        visitStack: t.visitStack,
+        warnings: t.warnings,
+        registry: t.registry
+      }), o = t.preserveHgComments && n.raw ? `${n.raw}
+${r}` : r;
+      e = fe(e, n.marker, o);
+    } finally {
+      t.visitStack?.pop();
+    }
+  }
+  return e;
+}
+class Le {
+  stack = [];
+  check(e) {
+    return e.length === 0 ? { circular: !1 } : this.stack.indexOf(e) !== -1 ? {
+      circular: !0,
+      path: e,
+      from: this.stack[this.stack.length - 1] ?? e
+    } : { circular: !1 };
+  }
+  push(e) {
+    this.stack.push(e);
+  }
+  pop() {
+    this.stack.pop();
+  }
+}
+async function _t(t, e, n = {}) {
+  const { path: i, constBindings: s = /* @__PURE__ */ new Set() } = n, r = await w(t.expr, { context: e, path: i });
+  switch (t.kind) {
+    case "const": {
+      if (s.has(t.name))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      e[t.name] = r, s.add(t.name);
+      break;
+    }
+    case "let": {
+      e[t.name] = r;
+      break;
+    }
+    case "assign": {
+      if (s.has(t.name))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `assignment to undeclared variable: ${t.name}`
+          }
+        });
+      e[t.name] = r;
+      break;
+    }
+  }
+}
+function pe(t) {
+  return !t;
+}
+async function B(t, e, n = {}) {
+  const { path: i, constBindings: s = /* @__PURE__ */ new Set(), onUpdate: r } = n;
+  switch (t.kind) {
+    case "const":
+    case "let":
+    case "assign": {
+      await _t(t, e, { path: i, constBindings: s }), r?.(t.name);
+      return;
+    }
+    case "update": {
+      if (s.has(t.name))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `assignment to undeclared variable: ${t.name}`
+          }
+        });
+      const o = Number(e[t.name]), a = t.op === "++" ? o + 1 : o - 1;
+      e[t.name] = a, r?.(t.name);
+      return;
+    }
+    case "compound_assign": {
+      if (s.has(t.name))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw u({
+          code: "parse_error",
+          path: i,
+          details: {
+            message: `assignment to undeclared variable: ${t.name}`
+          }
+        });
+      const o = await w(t.expr, { context: e, path: i }), a = Number(e[t.name]), c = Number(o);
+      let h;
+      switch (t.op) {
+        case "+=":
+          h = a + c;
+          break;
+        case "-=":
+          h = a - c;
+          break;
+        case "*=":
+          h = a * c;
+          break;
+        case "/=":
+          h = a / c;
+          break;
+      }
+      e[t.name] = h, r?.(t.name);
+      return;
+    }
+    case "for": {
+      for (t.init && await B(t.init, e, n); ; ) {
+        const o = await w(t.cond, {
+          context: e,
+          path: i
+        });
+        if (pe(o))
+          break;
+        for (const a of t.body)
+          await B(a, e, n);
+        t.update && await B(t.update, e, n);
+      }
+      return;
+    }
+    case "do_while": {
+      do {
+        for (const a of t.body)
+          await B(a, e, n);
+        const o = await w(t.cond, {
+          context: e,
+          path: i
+        });
+        if (pe(o))
+          break;
+      } while (!0);
+      return;
+    }
+  }
+}
+async function me(t, e, n = {}) {
+  for (const i of t)
+    await B(i, e, n);
+}
+const St = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "endif",
+  "const",
+  "let",
+  "for",
+  "do",
+  "while",
+  "each",
+  "endeach",
+  "block",
+  "endblock",
+  "extend",
+  "include",
+  "component",
+  "as"
+]);
+function Me(t) {
+  return St.has(t);
+}
+function re(t) {
+  let e = "", n = 0, i = null;
+  for (; n < t.length; ) {
+    const s = t[n];
+    if (i) {
+      if (e += s, s === "\\" && n + 1 < t.length) {
+        e += t[++n], n++;
+        continue;
+      }
+      s === i && (i = null), n++;
+      continue;
+    }
+    if (s === '"' || s === "'" || s === "`") {
+      i = s, e += s, n++;
+      continue;
+    }
+    if (t.startsWith("//", n)) {
+      for (; n < t.length && t[n] !== `
+`; )
+        n++;
+      continue;
+    }
+    if (t.startsWith("/*", n)) {
+      const r = t.indexOf("*/", n + 2);
+      if (r === -1)
+        break;
+      n = r + 2;
+      continue;
+    }
+    e += s, n++;
+  }
+  return e;
+}
+function k(t, e) {
+  throw u({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function ge(t, e) {
+  const n = re(t).trim();
+  if (n.length === 0)
+    throw k(e, "empty statement block");
+  const i = new se(n, e), s = i.parseStatementList();
+  if (i.skipWhitespace(), i.hasMore())
+    throw k(
+      e,
+      `unexpected token at position ${i.position}`
+    );
+  if (s.length === 0)
+    throw k(e, "empty statement block");
+  return s;
+}
+function Re(t) {
+  const e = re(t).trim();
+  return e.length === 0 ? !1 : /^const\s+/.test(e) || /^let\s+/.test(e) || /^for\s*\(/.test(e) || /^do\b/.test(e) || /^(\+\+|--)/.test(e) || /^[A-Za-z_$][A-Za-z0-9_$]*\s*(\+\+|--|[+\-*/]=|=)/.test(e);
+}
+class se {
+  constructor(e, n) {
+    this.input = e, this.path = n;
+  }
+  input;
+  path;
+  index = 0;
+  get position() {
+    return this.index;
+  }
+  hasMore() {
+    return this.skipWhitespace(), this.index < this.input.length;
+  }
+  skipWhitespace() {
+    for (; this.index < this.input.length && /\s/.test(this.input[this.index]); )
+      this.index++;
+  }
+  parseStatementList() {
+    const e = [];
+    for (; this.hasMore() && this.peek() !== "}"; )
+      e.push(this.parseStatement()), this.skipOptionalSemicolon();
+    return e;
+  }
+  parseStatement() {
+    if (this.skipWhitespace(), this.matchWord("for"))
+      return this.parseFor();
+    if (this.matchWord("do"))
+      return this.parseDoWhile();
+    if (this.matchWord("while"))
+      throw k(
+        this.path,
+        "bare while loops are not allowed (use do…while)"
+      );
+    return this.parseSimpleStatement();
+  }
+  parseSimpleStatement() {
+    this.skipWhitespace();
+    const e = this.readPrefixUpdate();
+    if (e)
+      return e;
+    if (this.matchWord("const"))
+      return this.parseBindingDeclaration("const");
+    if (this.matchWord("let"))
+      return this.parseBindingDeclaration("let");
+    const n = this.readIdentifier();
+    if (!n)
+      throw k(this.path, "expected statement");
+    if (this.assertAssignableName(n), this.skipWhitespace(), this.match("++") || this.match("--")) {
+      const s = this.input.slice(this.index - 2, this.index);
+      return { kind: "update", name: n, op: s, position: "postfix" };
+    }
+    const i = this.readCompoundOp();
+    if (i) {
+      const s = this.readExpressionSourceUntilTerminator();
+      return {
+        kind: "compound_assign",
+        name: n,
+        op: i,
+        expr: C(s, this.path)
+      };
+    }
+    if (this.match("=")) {
+      if (this.peek() === "=")
+        throw k(this.path, "unexpected '==' in assignment");
+      const s = this.readExpressionSourceUntilTerminator();
+      return {
+        kind: "assign",
+        name: n,
+        expr: C(s, this.path)
+      };
+    }
+    throw k(this.path, `invalid statement starting with: ${n}`);
+  }
+  readPrefixUpdate() {
+    if (this.skipWhitespace(), this.match("++") || this.match("--")) {
+      const e = this.input.slice(this.index - 2, this.index), n = this.readIdentifier();
+      if (!n)
+        throw k(this.path, `expected identifier after ${e}`);
+      return this.assertAssignableName(n), { kind: "update", name: n, op: e, position: "prefix" };
+    }
+    return null;
+  }
+  parseBindingDeclaration(e) {
+    const n = this.readIdentifier();
+    if (!n)
+      throw k(this.path, `expected identifier after ${e}`);
+    if (this.assertAssignableName(n), this.skipWhitespace(), !this.match("="))
+      throw k(this.path, `expected '=' in ${e} declaration`);
+    const i = this.readExpressionSourceUntilTerminator();
+    return {
+      kind: e,
+      name: n,
+      expr: C(i, this.path)
+    };
+  }
+  parseFor() {
+    if (this.skipWhitespace(), !this.match("("))
+      throw k(this.path, "expected '(' after for");
+    const e = this.readBalanced(")"), n = Ct(e);
+    if (n.length !== 3)
+      throw k(
+        this.path,
+        "for…of / for…in are not allowed; use for (init; cond; update)"
+      );
+    const [i, s, r] = n;
+    if (s.trim().length === 0)
+      throw k(this.path, "for loop condition cannot be empty");
+    if (/^\s*[A-Za-z_$][A-Za-z0-9_$]*\s+(of|in)\s+/.test(i))
+      throw k(
+        this.path,
+        "for…of / for…in are not allowed; use for (init; cond; update)"
+      );
+    const o = i.trim().length === 0 ? null : this.parseClauseStatement(i.trim()), a = C(s.trim(), this.path), c = r.trim().length === 0 ? null : this.parseClauseStatement(r.trim());
+    if (this.skipWhitespace(), !this.match("{"))
+      throw k(this.path, "expected '{' after for (...)");
+    const h = this.parseStatementList();
+    if (this.skipWhitespace(), !this.match("}"))
+      throw k(this.path, "expected '}' to close for body");
+    return { kind: "for", init: o, cond: a, update: c, body: h };
+  }
+  parseDoWhile() {
+    if (this.skipWhitespace(), !this.match("{"))
+      throw k(this.path, "expected '{' after do");
+    const e = this.parseStatementList();
+    if (this.skipWhitespace(), !this.match("}"))
+      throw k(this.path, "expected '}' to close do body");
+    if (this.skipWhitespace(), !this.matchWord("while"))
+      throw k(this.path, "expected 'while' after do body");
+    if (this.skipWhitespace(), !this.match("("))
+      throw k(this.path, "expected '(' after while");
+    const n = this.readBalanced(")");
+    if (n.trim().length === 0)
+      throw k(this.path, "do…while condition cannot be empty");
+    const i = C(n.trim(), this.path);
+    return { kind: "do_while", body: e, cond: i };
+  }
+  parseClauseStatement(e) {
+    const n = new se(e, this.path), i = n.parseSimpleStatement();
+    if (n.skipWhitespace(), n.hasMore())
+      throw k(
+        this.path,
+        `unexpected token in for clause at position ${n.position}`
+      );
+    return i;
+  }
+  assertAssignableName(e) {
+    if (Me(e))
+      throw k(
+        this.path,
+        `reserved word cannot be used as identifier: ${e}`
+      );
+  }
+  readExpressionSourceUntilTerminator() {
+    this.skipWhitespace();
+    const e = this.index;
+    let n = 0, i = 0, s = 0, r = null;
+    for (; this.index < this.input.length; ) {
+      const a = this.input[this.index];
+      if (r) {
+        if (a === "\\") {
+          this.index += 2;
+          continue;
+        }
+        a === r && (r = null), this.index++;
+        continue;
+      }
+      if (a === '"' || a === "'" || a === "`") {
+        r = a, this.index++;
+        continue;
+      }
+      if (a === "(" && n++, a === ")" && (n = Math.max(0, n - 1)), a === "{" && i++, a === "}") {
+        if (i === 0 && n === 0 && s === 0)
+          break;
+        i = Math.max(0, i - 1);
+      }
+      if (a === "[" && s++, a === "]" && (s = Math.max(0, s - 1)), (a === ";" || a === `
+`) && n === 0 && i === 0 && s === 0)
+        break;
+      this.index++;
+    }
+    const o = this.input.slice(e, this.index).trim();
+    if (o.length === 0)
+      throw k(this.path, "expected expression");
+    return o;
+  }
+  readBalanced(e) {
+    const n = e === ")" ? "(" : "{";
+    let i = 1;
+    const s = this.index;
+    let r = null;
+    for (; this.index < this.input.length; ) {
+      const o = this.input[this.index];
+      if (r) {
+        if (o === "\\") {
+          this.index += 2;
+          continue;
+        }
+        o === r && (r = null), this.index++;
+        continue;
+      }
+      if (o === '"' || o === "'" || o === "`") {
+        r = o, this.index++;
+        continue;
+      }
+      if (o === n) {
+        i++, this.index++;
+        continue;
+      }
+      if (o === e) {
+        if (i--, i === 0) {
+          const a = this.input.slice(s, this.index);
+          return this.index++, a;
+        }
+        this.index++;
+        continue;
+      }
+      this.index++;
+    }
+    throw k(this.path, `expected '${e}'`);
+  }
+  readCompoundOp() {
+    this.skipWhitespace();
+    const e = ["+=", "-=", "*=", "/="];
+    for (const n of e)
+      if (this.match(n))
+        return n;
+    return null;
+  }
+  skipOptionalSemicolon() {
+    this.skipWhitespace(), this.peek() === ";" && this.index++;
+  }
+  match(e) {
+    return this.skipWhitespace(), this.input.startsWith(e, this.index) ? (this.index += e.length, !0) : !1;
+  }
+  matchWord(e) {
+    if (this.skipWhitespace(), !this.input.startsWith(e, this.index))
+      return !1;
+    const n = this.input[this.index + e.length];
+    return n && /[A-Za-z0-9_$]/.test(n) ? !1 : (this.index += e.length, !0);
+  }
+  peek() {
+    return this.input[this.index] ?? "";
+  }
+  readIdentifier() {
+    this.skipWhitespace();
+    const e = this.index, n = this.peek();
+    if (!/[A-Za-z_$]/.test(n))
+      return "";
+    for (this.index++; this.index < this.input.length && /[A-Za-z0-9_$]/.test(this.input[this.index]); )
+      this.index++;
+    return this.input.slice(e, this.index);
+  }
+}
+function Ct(t) {
+  const e = [];
+  let n = "", i = 0, s = null;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    if (s) {
+      if (n += o, o === "\\" && r + 1 < t.length) {
+        n += t[++r];
+        continue;
+      }
+      o === s && (s = null);
+      continue;
+    }
+    if (o === '"' || o === "'" || o === "`") {
+      s = o, n += o;
+      continue;
+    }
+    if (o === "(" || o === "[" || o === "{") {
+      i++, n += o;
+      continue;
+    }
+    if (o === ")" || o === "]" || o === "}") {
+      i = Math.max(0, i - 1), n += o;
+      continue;
+    }
+    if (o === ";" && i === 0) {
+      e.push(n), n = "";
+      continue;
+    }
+    n += o;
+  }
+  return e.push(n), e;
+}
+function oe(t, e) {
+  const n = t.trim();
+  if (!/^extend\b/i.test(n)) return null;
+  if (!/^extend\s+/i.test(n))
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "missing extend path" }
+    });
+  const i = /^extend\s+(\S+)\s*$/.exec(n);
+  if (!i)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid extend directive" }
+    });
+  const s = i[1];
+  if (s.length === 0)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid extend path" }
+    });
+  return { path: s };
+}
+function At(t, e) {
+  const n = E(t);
+  if (n.length === 0) return null;
+  const i = n[0], s = oe(i, e);
+  if (!s) return null;
+  for (const r of n.slice(1))
+    if (/^extend\s+/i.test(r))
+      throw u({
+        code: "parse_error",
+        path: e,
+        details: { message: "extend must be the first line of extend block" }
+      });
+  return {
+    path: s.path,
+    declarationsSource: n.slice(1).join(`
+`)
+  };
+}
+async function Wt(t, e = {}) {
+  const n = e.path, i = e.context ?? {};
+  if (Se(t))
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: {
+        message: Ce(t) ?? "unclosed hyogen block (missing closing marker)"
+      }
+    });
+  const s = T(t);
+  if (s.length === 0)
+    return { source: t, context: i, declarationUpdates: {} };
+  const r = /* @__PURE__ */ new Set(), o = {}, a = (l) => {
+    o[l] = i[l];
+  };
+  let c = t, h = 0;
+  for (const l of s) {
+    const d = E(l.inner);
+    if (d.length === 1 && Ae(d[0]) || d.length === 1 && /^include\s+/i.test(d[0]) || d.length === 1 && /^component\s+/i.test(d[0]))
+      continue;
+    const f = At(l.inner, n);
+    if (f) {
+      if (f.declarationsSource.trim().length > 0) {
+        const P = ge(
+          f.declarationsSource,
+          n
+        );
+        await me(P, i, {
+          path: n,
+          constBindings: r,
+          onUpdate: a
+        });
+      }
+      const v = l.start - h, W = l.end - h, $ = `<!--@hg
+extend ${f.path}
+@endhg-->`;
+      c = c.slice(0, v) + $ + c.slice(W), h += l.raw.length - $.length;
+      continue;
+    }
+    const g = d.join(`
+`);
+    if (!Re(g)) {
+      if (d.length === 1)
+        continue;
+      throw u({
+        code: "parse_error",
+        path: n,
+        details: { message: `unsupported hyogen directive: ${d[0]}` }
+      });
+    }
+    const m = ge(g, n);
+    await me(m, i, {
+      path: n,
+      constBindings: r,
+      onUpdate: a
+    });
+    const p = l.start - h, A = l.end - h, L = c.slice(0, p), b = c.slice(A);
+    c = D(L, b), h += l.raw.length + ie(L, b);
+  }
+  return { source: c, context: i, declarationUpdates: o };
+}
+const $t = /^component\s+(\S+)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*$/;
+function Tt(t, e) {
+  const n = Q(t).trim();
+  if (n.length === 0)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty hyogen block" }
+    });
+  const i = n.split(/\r?\n/).map((a) => a.trim()).filter((a) => a.length > 0);
+  if (i.length !== 1)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: {
+        message: "hyogen block must contain a single component directive"
+      }
+    });
+  const s = i[0];
+  if (/^include\s+/i.test(s))
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "include and component cannot coexist in one block" }
+    });
+  const r = $t.exec(s);
+  if (!r)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: `unsupported component directive: ${s}` }
+    });
+  const o = r[1];
+  if (o.length === 0)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty component path" }
+    });
+  return {
+    kind: "component",
+    path: o,
+    alias: r[2]
+  };
+}
+function Et(t, e) {
+  const n = Q(t).trim();
+  if (n.length === 0)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty hyogen block" }
+    });
+  const i = n.split(/\r?\n/).map((o) => o.trim()).filter((o) => o.length > 0);
+  if (i.length !== 1)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "hyogen block must contain a single include directive" }
+    });
+  const s = i[0], r = /^include\s+(\S+)\s*$/.exec(s);
+  if (r)
+    return { kind: "include", path: r[1] };
+  throw u({
+    code: "parse_error",
+    path: e,
+    details: { message: `unsupported hyogen directive: ${s}` }
+  });
+}
+function Lt(t) {
+  const e = re(t).trim();
+  return e.length === 0 ? !1 : /^const\s+/.test(e) || /^let\s+/.test(e) || /^[A-Za-z_$][A-Za-z0-9_$]*\s*=/.test(e);
+}
+const Mt = "\0HYOGEN_INCLUDE_";
+function Rt(t) {
+  return `${Mt}${t}\0`;
+}
+function Ot(t, e) {
+  const n = E(t);
+  if (n.length === 1 && Ae(n[0]))
+    return { kind: "control" };
+  if (n.length === 1 && (Lt(n[0]) || Re(n[0])))
+    return null;
+  if (n.length !== 1)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "hyogen block must contain a single directive" }
+    });
+  const i = n[0];
+  if (/^include\s+/i.test(i) && /\bcomponent\s+/i.test(i))
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "include and component cannot coexist in one block" }
+    });
+  if (/^include\s+/i.test(i))
+    return Et(t, e);
+  if (/^component\s+/i.test(i))
+    return Tt(t, e);
+  if (i === "endblock" || /^block\s+/.test(i) || /^extend\s+/.test(i))
+    return null;
+  throw u({
+    code: "parse_error",
+    path: e,
+    details: { message: `unsupported hyogen directive: ${i}` }
+  });
+}
+function Dt(t, e = {}) {
+  const n = e.path;
+  if (Se(t))
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: {
+        message: Ce(t) ?? "unclosed hyogen block (missing closing marker)"
+      }
+    });
+  const i = T(t);
+  if (i.length === 0)
+    return { source: t, directives: [] };
+  const s = [];
+  let r = t, o = 0, a = 0;
+  for (const c of i) {
+    const h = Ot(c.inner, n);
+    if (!h || h.kind === "control")
+      continue;
+    const l = c.start - o, d = c.end - o;
+    if (h.kind === "component") {
+      e.registry && e.registry.register(
+        {
+          alias: h.alias,
+          componentPath: h.path,
+          definedAt: n
+        },
+        Object.keys(e.context ?? {}),
+        n
+      );
+      const g = r.slice(0, l), m = r.slice(d);
+      r = D(g, m), o += c.raw.length + ie(g, m);
+      continue;
+    }
+    const f = Rt(a++);
+    s.push({ ...h, marker: f, raw: c.raw }), r = r.slice(0, l) + f + r.slice(d), o += c.raw.length - f.length;
+  }
+  return { source: r, directives: s };
+}
+function Bt(t, e) {
+  return !e.preserveFrontMatter || !e.rawFrontMatter ? t : t.length === 0 ? `${e.rawFrontMatter}
+` : `${e.rawFrontMatter}
+${t}`;
+}
+function jt(t, e = !1) {
+  if (e)
+    return t;
+  const n = T(t);
+  if (n.length === 0)
+    return t;
+  let i = t, s = 0;
+  for (const r of n) {
+    const o = r.start - s, a = r.end - s, c = i.slice(0, o), h = i.slice(a);
+    i = D(c, h), s += r.raw.length + ie(c, h);
+  }
+  return i;
+}
+const Nt = /^block\s+([A-Za-z_$][A-Za-z0-9_$]*)$/;
+function Ht(t, e) {
+  const n = t.trim();
+  if (n === "endblock")
+    return { kind: "endblock" };
+  const i = Nt.exec(n);
+  if (!i)
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid block directive" }
+    });
+  const s = i[1];
+  if (Me(s))
+    throw u({
+      code: "parse_error",
+      path: e,
+      details: { message: `reserved word cannot be used as block name: ${s}` }
+    });
+  return { kind: "block", name: s };
+}
+function xe(t, e) {
+  const { path: n, mode: i, hasExtend: s = !1 } = e, r = T(t);
+  if (r.length === 0) return [];
+  const o = [], a = [], c = /* @__PURE__ */ new Set();
+  for (const h of r) {
+    const l = E(h.inner);
+    if (l.length !== 1) continue;
+    const d = l[0];
+    if (!(d === "endblock" || d.startsWith("block "))) continue;
+    if (i === "child" && !s)
+      throw u({
+        code: "parse_error",
+        path: n,
+        details: { message: "orphan block without extend" }
+      });
+    const g = Ht(d, n);
+    if (g.kind === "endblock") {
+      const m = a.pop();
+      if (!m)
+        throw u({
+          code: "parse_error",
+          path: n,
+          details: { message: "endblock without matching block opener" }
+        });
+      const p = t.slice(m.openerEnd, h.start);
+      o.push({
+        name: m.name,
+        body: p,
+        start: m.start,
+        end: h.end
+      });
+      continue;
+    }
+    if (a.length > 0)
+      throw u({
+        code: "parse_error",
+        path: n,
+        details: { message: "nested block structures are not supported" }
+      });
+    if (c.has(g.name))
+      throw u({
+        code: "parse_error",
+        path: n,
+        details: { message: `duplicate block: ${g.name}` }
+      });
+    c.add(g.name), a.push({
+      name: g.name,
+      openerEnd: h.end,
+      start: h.start
+    });
+  }
+  if (a.length > 0)
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: { message: "missing endblock" }
+    });
+  return o;
+}
+function ke(t) {
+  const e = T(t), n = [];
+  for (const i of e) {
+    const s = E(i.inner);
+    if (s.length === 0) continue;
+    const r = oe(s[0]);
+    r && n.push({ path: r.path, start: i.start });
+  }
+  return n;
+}
+function Pt(t) {
+  const e = T(t);
+  for (const n of e) {
+    const i = E(n.inner);
+    if (i.length !== 1) continue;
+    const s = i[0];
+    if (s === "endblock" || s.startsWith("block ")) return !0;
+  }
+  return !1;
+}
+function K(t) {
+  return t.map((e) => e.body).join("");
+}
+function Ft(t, e, n) {
+  const i = [...e].sort((o, a) => o.start - a.start), s = [];
+  let r = 0;
+  for (const o of i)
+    s.push(t.slice(r, o.start)), s.push(n.get(o.name) ?? o.body), r = o.end;
+  return s.push(t.slice(r)), s.reduce((o, a) => D(o, a));
+}
+function It(t) {
+  if (t instanceof Error && "code" in t && "details" in t) {
+    const e = t;
+    if (e.code === "file_not_found" && e.details && e.details.via === "include")
+      return e.details.via = "extend", { errorToThrow: e, adjusted: !0 };
+  }
+  return { errorToThrow: t, adjusted: !1 };
+}
+async function zt(t, e) {
+  const {
+    path: n,
+    context: i,
+    declarationUpdates: s,
+    loader: r,
+    root: o,
+    constrainToRoot: a,
+    visitStack: c,
+    warnings: h,
+    inComponent: l = !1
+  } = e, d = ke(t);
+  if (d.length === 0) {
+    if (Pt(t))
+      throw u({
+        code: "parse_error",
+        path: n,
+        details: { message: "orphan block without extend" }
+      });
+    return { source: t, context: _(i, s) };
+  }
+  const g = T(t)[0];
+  if (!g)
+    return { source: t, context: _(i, s) };
+  if (!r)
+    throw new Error("loader is required when processing extend directives");
+  const m = E(g.inner);
+  if (!(m.length > 0 ? oe(m[0]) : null))
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: { message: "extend must be the first hyogen block" }
+    });
+  if (d.length > 1)
+    throw u({
+      code: "parse_error",
+      path: n,
+      details: { message: "multiple extend directives are not supported" }
+    });
+  const A = xe(t, {
+    path: n,
+    mode: "child",
+    hasExtend: !0
+  });
+  if (l)
+    return h?.push({
+      code: "extend_in_component",
+      message: O("extend_in_component", { path: n }),
+      path: n,
+      details: { path: n }
+    }), {
+      source: K(A),
+      context: _(i, s)
+    };
+  const L = d[0].path, b = n, v = Y(
+    o,
+    L,
+    n,
+    n,
+    a,
+    !0
+  );
+  b && c.push(b);
+  try {
+    const W = b ? c.check(v) : { circular: !1 };
+    if (W.circular)
+      return h?.push({
+        code: "circular_include",
+        message: O("circular_include", {
+          path: v,
+          from: W.from,
+          via: "extend"
+        }),
+        path: n,
+        details: { path: v, from: W.from, via: "extend" }
+      }), {
+        source: K(A),
+        context: _(i, s)
+      };
+    c.push(v);
+    try {
+      const $ = await r(v);
+      if ($ === void 0)
+        throw new Error("loader returned undefined");
+      const { context: P, body: F } = H(
+        $,
+        v
+      ), ce = ke(F);
+      if (ce.length > 0) {
+        const N = ce[0].path, I = Y(
+          o,
+          N,
+          v,
+          v,
+          a,
+          !0
+        ), z = c.check(I);
+        if (z.circular)
+          return h?.push({
+            code: "circular_include",
+            message: O("circular_include", {
+              path: I,
+              from: z.from,
+              via: "extend"
+            }),
+            path: n,
+            details: { path: I, from: z.from, via: "extend" }
+          }), {
+            source: K(A),
+            context: _(i, s)
+          };
+        throw u({
+          code: "parse_error",
+          path: v,
+          details: { message: "layout extend is not supported" }
+        });
+      }
+      const Oe = xe(F, {
+        path: v,
+        mode: "layout"
+      }), De = new Map(
+        A.map((N) => [N.name, N.body])
+      ), Be = Ft(
+        F,
+        Oe,
+        De
+      ), je = _(
+        i,
+        P,
+        s
+      );
+      return { source: Be, context: je };
+    } finally {
+      c.pop();
+    }
+  } catch (W) {
+    const $ = It(W);
+    throw $.adjusted ? $.errorToThrow : W;
+  } finally {
+    b && c.pop();
+  }
+}
+const Ut = J.warningReasons, Zt = [
+  {
+    reason: "contains_html_script_tag",
+    test: (t) => /<\/?script\b/i.test(t)
+  },
+  {
+    reason: "contains_event_handler",
+    test: (t) => /\bon(?:error|click|load)\s*=/i.test(t)
+  },
+  {
+    reason: "contains_dangerous_scheme",
+    test: (t) => /(?:javascript|vbscript)\s*:/i.test(t)
+  },
+  {
+    reason: "contains_embed_tag",
+    test: (t) => /<(?:iframe|object|embed)\b/i.test(t)
+  },
+  {
+    reason: "contains_meta_refresh",
+    test: (t) => /<meta\b[^>]*\bhttp-equiv\b/i.test(t)
+  }
+];
+function qt(t) {
+  return Ut[t] ?? t;
+}
+function G(t, e, n, i) {
+  if (typeof t == "string") {
+    for (const s of Zt)
+      s.test(t) && n.push({
+        code: "suspicious_context_value",
+        message: O("suspicious_context_value", {
+          key: e,
+          reason: qt(s.reason)
+        }),
+        path: i,
+        details: { key: e, reason: s.reason }
+      });
+    return;
+  }
+  if (t != null) {
+    if (Array.isArray(t)) {
+      for (let s = 0; s < t.length; s++)
+        G(t[s], `${e}[${s}]`, n, i);
+      return;
+    }
+    if (typeof t == "object")
+      for (const [s, r] of Object.entries(
+        t
+      )) {
+        const o = e.length > 0 ? `${e}.${s}` : s;
+        G(r, o, n, i);
+      }
+  }
+}
+function Vt(t, e, n) {
+  for (const [i, s] of Object.entries(t))
+    G(s, i, e, n);
+}
+async function ae(t, e) {
+  const n = e.path, i = e.context, s = e.registry ?? new be(), r = e.warnings ?? [], o = e.visitStack ?? new Le(), {
+    source: a,
+    declarationUpdates: c
+  } = await Wt(t, { path: n, context: { ...i } });
+  Vt(
+    _(i, c ?? {}),
+    r,
+    n
+  );
+  const h = await zt(a, {
+    path: n,
+    context: i,
+    declarationUpdates: c ?? {},
+    loader: e.loader,
+    root: e.root,
+    constrainToRoot: e.constrainToRoot,
+    visitStack: o,
+    warnings: r,
+    inComponent: e.inComponent ?? !1
+  }), { source: l, context: d } = h, { source: f, directives: g } = Dt(l, {
+    path: n,
+    registry: s,
+    context: d
+  }), m = e.loader;
+  if (g.length > 0 && !m)
+    throw new Error("loader is required when processing include directives");
+  let p = f;
+  return g.length > 0 && m && (p = await vt({
+    source: f,
+    directives: g,
+    context: d,
+    loader: m,
+    root: e.root,
+    path: n,
+    preserveFrontMatter: e.preserveFrontMatter,
+    preserveHgComments: e.preserveHgComments,
+    visitStack: o,
+    warnings: r,
+    registry: s,
+    constrainToRoot: e.constrainToRoot
+  })), p = await kt(p, {
+    context: d,
+    path: n,
+    registry: s,
+    loader: m,
+    rootDir: e.root,
+    warnings: r,
+    visitStack: o,
+    parentContext: d,
+    preserveHgComments: e.preserveHgComments,
+    constrainToRoot: e.constrainToRoot
+  }), p = await _e(p, d, {
+    path: n,
+    registry: s,
+    loader: m,
+    rootDir: e.root,
+    warnings: r,
+    visitStack: o,
+    parentContext: d,
+    preserveHgComments: e.preserveHgComments,
+    constrainToRoot: e.constrainToRoot
+  }), p = jt(p, e.preserveHgComments), p;
+}
+async function Kt(t, e = {}) {
+  const n = e.path, i = _(e.context), s = e.registry ?? new be(), r = e.warnings ?? [], o = e.visitStack ?? new Le(), { context: a, body: c, rawFrontMatter: h } = H(
+    t,
+    n
+  ), l = _(i, a);
+  let d = await ae(c, {
+    ...e,
+    context: l,
+    registry: s,
+    warnings: r,
+    visitStack: o
+  });
+  return d = Bt(d, {
+    preserveFrontMatter: e.preserveFrontMatter,
+    rawFrontMatter: h
+  }), {
+    markdown: d,
+    warnings: r
+  };
+}
+async function Yt(t, e) {
+  const n = e.path, { context: i, body: s } = H(t, n), r = _(e.context, i);
+  return ae(s, {
+    ...e,
+    context: r,
+    preserveFrontMatter: !1
+  });
+}
+async function Jt(t, e, n) {
+  if (n != null && "serverContext" in n && n.serverContext != null)
+    throw u({
+      code: "server_context_on_client"
+    });
+  const i = n?.loader;
+  if (!i)
+    throw u({
+      code: "parse_error",
+      details: { message: "loader is required for renderClient" }
+    });
+  let s, r;
+  typeof t == "string" ? s = t : (r = t.path, s = await i(t.path));
+  const o = _(e);
+  return Kt(s, {
+    context: o,
+    loader: i,
+    root: n?.root,
+    path: r ?? n?.path,
+    preserveFrontMatter: n?.preserveFrontMatter,
+    preserveHgComments: n?.preserveHgComments,
+    constrainToRoot: n?.constrainToRoot
+  });
+}
+function Xt(t, e) {
+  const n = [`[hyogen:${t}] ${e.code}`], i = {};
+  if (e.details)
+    for (const [s, r] of Object.entries(e.details))
+      r !== void 0 && (i[s] = r);
+  i.path === void 0 && e.path !== void 0 && (i.path = e.path);
+  for (const [s, r] of Object.entries(i))
+    n.push(`  ${s}: ${String(r)}`);
+  return n.join(`
+`);
+}
+export {
+  u as createHyogenError,
+  Xt as formatDiagnosticLog,
+  Ue as formatMessage,
+  Jt as renderClient
+};
+//# sourceMappingURL=client.js.map