@b4moss/hyogen-md 0.10.0

package/dist/index.js

@@ -0,0 +1,3109 @@
+import { stat as te, readFile as Ee, mkdir as qe, writeFile as Pe } from "node:fs/promises";
+import u from "node:path";
+import { existsSync as we, statSync as Ve } from "node:fs";
+import { parse as Ke } from "yaml";
+import Ye from "fast-glob";
+import Ge from "picomatch";
+function b(...t) {
+  const e = {};
+  for (const n of t)
+    n != null && Object.assign(e, n);
+  return e;
+}
+const Xe = { 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}" }, Je = { 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})' }, Qe = { 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" }, ne = {
+  errors: Xe,
+  warnings: Je,
+  warningReasons: Qe
+}, et = ne.errors, tt = ne.warnings;
+function Te(t, e) {
+  return t === void 0 ? "" : t.replace(/\{([^}]+)\}/g, (n, r) => {
+    if (e === void 0 || !(r in e))
+      return n;
+    const i = e[r];
+    return i == null ? "" : String(i);
+  });
+}
+function nt(t, e) {
+  return Te(et[t], e);
+}
+function O(t, e) {
+  return Te(tt[t], e);
+}
+function d(t) {
+  const e = t.message ?? nt(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 rt(t) {
+  return t instanceof Error && t.name === "HyogenError" && "code" in t && typeof t.code == "string";
+}
+function it(t = {}) {
+  const { from: e, via: n = "include" } = t;
+  return async (r) => {
+    try {
+      if (!(await te(r)).isFile())
+        throw d({
+          code: "load_failed",
+          path: e,
+          details: {
+            path: r,
+            reason: "not a file"
+          }
+        });
+      return await Ee(r, "utf8");
+    } catch (i) {
+      if (rt(i))
+        throw i;
+      const s = i;
+      throw s.code === "ENOENT" ? d({
+        code: "file_not_found",
+        path: e,
+        details: {
+          path: r,
+          from: e ?? r,
+          via: n
+        }
+      }) : d({
+        code: "load_failed",
+        path: e,
+        details: {
+          path: r,
+          reason: s.message ?? "unknown load error"
+        }
+      });
+    }
+  };
+}
+function j(t) {
+  return /^https?:\/\//i.test(t);
+}
+function st(t) {
+  return t instanceof Error && t.name === "HyogenError" && "code" in t && typeof t.code == "string";
+}
+function $e(t = {}) {
+  const { from: e, via: n = "include" } = t, r = it(t);
+  return async (i) => {
+    if (!j(i))
+      return r(i);
+    try {
+      const s = await fetch(i);
+      if (!s.ok)
+        throw s.status === 404 ? d({
+          code: "file_not_found",
+          path: e,
+          details: {
+            path: i,
+            from: e ?? i,
+            via: n
+          }
+        }) : d({
+          code: "load_failed",
+          path: e,
+          details: {
+            path: i,
+            reason: `HTTP ${s.status}`
+          }
+        });
+      return await s.text();
+    } catch (s) {
+      if (st(s))
+        throw s;
+      const o = s instanceof Error ? s.message : "unknown fetch error";
+      throw d({
+        code: "load_failed",
+        path: e,
+        details: {
+          path: i,
+          reason: o
+        }
+      });
+    }
+  };
+}
+const ot = ".doc_root";
+function z(t) {
+  let e;
+  for (we(t) ? e = Ve(t).isFile() ? u.dirname(t) : u.resolve(t) : e = u.dirname(u.resolve(t)); ; ) {
+    const n = u.join(e, ot);
+    if (we(n))
+      return e;
+    const r = u.dirname(e);
+    if (r === e)
+      return;
+    e = r;
+  }
+}
+async function at(t, e) {
+  if (typeof t == "string")
+    return {
+      source: t,
+      rootDir: e?.root
+    };
+  const n = u.resolve(t.path);
+  let r;
+  try {
+    r = await te(n);
+  } catch (a) {
+    const c = a;
+    throw c.code === "ENOENT" ? d({
+      code: "file_not_found",
+      path: n,
+      details: {
+        path: n,
+        from: n,
+        via: "include"
+      }
+    }) : d({
+      code: "load_failed",
+      path: n,
+      details: {
+        path: n,
+        reason: c.message ?? "unknown load error"
+      }
+    });
+  }
+  if (!r.isFile())
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: { message: "path is not a file" }
+    });
+  let i;
+  try {
+    i = await Ee(n, "utf8");
+  } catch (a) {
+    throw d({
+      code: "load_failed",
+      path: n,
+      details: {
+        path: n,
+        reason: a.message ?? "unknown load error"
+      }
+    });
+  }
+  const s = z(n), o = e?.root ?? s;
+  return {
+    source: i,
+    rootDir: o,
+    entryPath: n,
+    constrainToRoot: s !== void 0
+  };
+}
+class Ae {
+  components = /* @__PURE__ */ new Map();
+  register(e, n, r) {
+    if (this.components.has(e.alias))
+      throw d({
+        code: "duplicate_component_alias",
+        path: r ?? e.definedAt,
+        details: { alias: e.alias }
+      });
+    if (n.includes(e.alias))
+      throw d({
+        code: "alias_collision",
+        path: r ?? 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 xe = 64 * 1024;
+function U(t, e) {
+  if (!t.startsWith("---"))
+    return { context: {}, body: t };
+  const n = t.indexOf(`
+`);
+  if (n === -1)
+    return { context: {}, body: t };
+  const r = t.indexOf(`
+---`, n);
+  if (r === -1)
+    return { context: {}, body: t };
+  const i = t.slice(n + 1, r), s = Buffer.byteLength(i, "utf8");
+  if (s > xe)
+    throw d({
+      code: "frontmatter_too_large",
+      path: e,
+      details: {
+        size: s,
+        limit: xe
+      }
+    });
+  if (i.trim().length === 0)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty front matter" }
+    });
+  let o;
+  try {
+    const h = Ke(i);
+    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 d({
+      code: "parse_error",
+      path: e,
+      details: {
+        message: h instanceof Error ? h.message : "invalid YAML front matter"
+      }
+    });
+  }
+  const a = r + 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: `---
+${i}
+---`
+  };
+}
+const ct = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array"
+]);
+function ht(t, e) {
+  const n = t.props;
+  if (n === void 0)
+    return {};
+  if (typeof n != "object" || n === null || Array.isArray(n))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "props must be a YAML mapping" }
+    });
+  const r = {};
+  for (const [i, s] of Object.entries(n)) {
+    if (typeof s != "object" || s === null || Array.isArray(s)) {
+      r[i] = {};
+      continue;
+    }
+    const o = s, a = {};
+    if ("type" in o && o.type !== void 0) {
+      const c = String(o.type);
+      ct.has(c) ? a.type = c : a.type = void 0;
+    }
+    "isRequired" in o && (a.isRequired = !!o.isRequired), "default" in o && (a.default = o.default), r[i] = a;
+  }
+  return r;
+}
+function lt(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 dt(t, e) {
+  return e === "array" ? Array.isArray(t) : e === "object" ? typeof t == "object" && t !== null && !Array.isArray(t) : typeof t === e;
+}
+function K(t, e) {
+  return {
+    code: t,
+    message: O(t, e),
+    details: e
+  };
+}
+function pt(t, e, n) {
+  const r = [], i = {}, s = 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 && r.push(
+      K("prop_missing", {
+        prop: o,
+        component: n
+      })
+    ), h = void 0)), c && h !== void 0 && h !== null) {
+      const l = a.type ?? lt(h);
+      l && !dt(h, l) && (r.push(
+        K("prop_type_mismatch", {
+          prop: o,
+          component: n,
+          expected: l,
+          actual: typeof h
+        })
+      ), h = void 0);
+    }
+    i[o] = h;
+  }
+  for (const o of Object.keys(t))
+    s.has(o) || (Object.keys(e).length > 0 ? r.push(
+      K("prop_unknown", {
+        prop: o,
+        component: n
+      })
+    ) : i[o] = t[o]);
+  return { values: i, warnings: r };
+}
+function ut(t, e) {
+  const n = u.relative(e, t);
+  return n === "" || !n.startsWith("..") && !u.isAbsolute(n);
+}
+function ft(t, e, n) {
+  const r = u.resolve(e), i = u.resolve(t);
+  if (!ut(i, r))
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: { message: "path resolves outside root directory" }
+    });
+}
+function re(t, e = {}) {
+  const { rootDir: n, fromPath: r, documentPath: i, constrainToRoot: s = !1, hyogenPath: o = !1 } = e;
+  if (t.length === 0)
+    throw d({
+      code: "parse_error",
+      path: i,
+      details: { message: "empty template path" }
+    });
+  let a;
+  if (t.startsWith("/"))
+    if (n)
+      a = u.resolve(n, t.slice(1));
+    else {
+      if (o)
+        throw d({
+          code: "parse_error",
+          path: i,
+          details: { message: "root-relative paths require a doc root" }
+        });
+      if (u.isAbsolute(t))
+        a = u.resolve(t);
+      else
+        throw d({
+          code: "parse_error",
+          path: i,
+          details: { message: "root-relative paths require a doc root" }
+        });
+    }
+  else if (t.startsWith("./") || t.startsWith("../"))
+    if (r)
+      a = u.resolve(u.dirname(r), t);
+    else if (n)
+      a = u.resolve(n, t);
+    else
+      throw d({
+        code: "parse_error",
+        path: i,
+        details: { message: "root is required for relative template paths" }
+      });
+  else if (u.isAbsolute(t))
+    a = u.resolve(t);
+  else if (n)
+    a = u.resolve(n, t);
+  else
+    throw d({
+      code: "parse_error",
+      path: i,
+      details: { message: "root is required for relative template paths" }
+    });
+  return n && s && ft(a, n, i), a;
+}
+async function mt(t) {
+  const e = t.registry.get(t.alias);
+  if (!e)
+    throw d({
+      code: "parse_error",
+      path: t.path,
+      details: {
+        message: `unregistered component: ${t.alias}`
+      }
+    });
+  const n = j(e.componentPath) ? e.componentPath : re(e.componentPath, {
+    rootDir: t.rootDir,
+    fromPath: e.definedAt,
+    documentPath: t.path,
+    constrainToRoot: t.constrainToRoot,
+    hyogenPath: !0
+  }), r = await t.loader(n), { context: i, body: s } = U(r, n), o = ht(i, n), { values: a, warnings: c } = pt(
+    t.props,
+    o,
+    t.alias
+  );
+  t.warnings.push(...c);
+  const { props: h, ...l } = i, p = b(
+    t.parentContext,
+    l,
+    a
+  ), g = (await me(s, {
+    context: p,
+    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 d({
+      code: "component_multiline_output",
+      path: n,
+      details: { alias: t.alias }
+    });
+  return g;
+}
+const gt = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor",
+  "__defineGetter__"
+]);
+function wt(t) {
+  return gt.has(t);
+}
+function ke(t, e) {
+  if (wt(t))
+    throw d({
+      code: "forbidden_property_access",
+      path: e,
+      details: { property: t }
+    });
+}
+function R(t) {
+  return !t;
+}
+function xt(t, e) {
+  if (t != null && typeof t == "object")
+    return t[e];
+}
+function kt(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 R(e) ? e : n;
+    case "||":
+      return R(e) ? n : e;
+    default:
+      return;
+  }
+}
+async function k(t, e) {
+  const { context: n, path: r } = e;
+  switch (t.type) {
+    case "literal":
+      return t.value;
+    case "identifier":
+      return ke(t.name, r), n[t.name];
+    case "member": {
+      ke(t.property, r);
+      const i = await k(t.object, e);
+      return xt(i, t.property);
+    }
+    case "default": {
+      const i = await k(t.left, e);
+      return R(i) ? k(t.right, e) : i;
+    }
+    case "unary": {
+      const i = await k(t.operand, e);
+      return t.op === "!" ? !i : void 0;
+    }
+    case "binary": {
+      if (t.op === "&&") {
+        const o = await k(t.left, e);
+        return R(o) ? o : k(t.right, e);
+      }
+      if (t.op === "||") {
+        const o = await k(t.left, e);
+        return R(o) ? k(t.right, e) : o;
+      }
+      const i = await k(t.left, e), s = await k(t.right, e);
+      return kt(t.op, i, s);
+    }
+    case "call": {
+      if (!e.registry || !e.loader || !e.visitStack)
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `function calls are not allowed: ${t.callee}()`
+          }
+        });
+      if (!e.registry.has(t.callee))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `unregistered component: ${t.callee}`
+          }
+        });
+      const i = {};
+      for (const [s, o] of Object.entries(t.args))
+        i[s] = await k(o, e);
+      return mt({
+        alias: t.callee,
+        props: i,
+        parentContext: e.parentContext ?? n,
+        registry: e.registry,
+        loader: e.loader,
+        rootDir: e.rootDir,
+        path: r,
+        warnings: e.warnings ?? [],
+        visitStack: e.visitStack,
+        preserveHgComments: e.preserveHgComments,
+        constrainToRoot: e.constrainToRoot
+      });
+    }
+    case "method": {
+      if (t.method !== "toLocaleString")
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: { message: `unsupported method: ${t.method}()` }
+        });
+      const i = await k(t.object, e);
+      return i == null || typeof i.toLocaleString != "function" ? void 0 : i.toLocaleString(
+        ...t.args
+      );
+    }
+    case "ternary": {
+      const i = await k(t.condition, e);
+      return R(i) ? k(t.alternate, e) : k(t.consequent, e);
+    }
+    case "template": {
+      let i = "";
+      for (const s of t.parts)
+        if (typeof s == "string")
+          i += s;
+        else {
+          const o = await k(s, e);
+          o != null && (i += String(o));
+        }
+      return i;
+    }
+    default:
+      return;
+  }
+}
+function Y(t) {
+  return /[A-Za-z_$]/.test(t);
+}
+function yt(t) {
+  return /[A-Za-z0-9_$]/.test(t);
+}
+function S(t, e, n = {}) {
+  const r = t.trim();
+  if (r.length === 0)
+    throw m(e, "empty expression");
+  const i = new bt(r, e, n), s = i.parseExpression();
+  if (i.skipWhitespace(), i.hasMore())
+    throw m(e, `unexpected token at position ${i.position}`);
+  return s;
+}
+function m(t, e) {
+  throw d({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+class bt {
+  constructor(e, n, r = {}) {
+    this.input = e, this.path = n, this.allowCalls = r.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 m(this.path, "expected ':' in ternary expression");
+    this.index++;
+    const r = this.parseTernary();
+    return { type: "ternary", condition: e, consequent: n, alternate: r };
+  }
+  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 r = this.parseAdditive();
+      e = { type: "binary", op: n, left: e, right: r };
+    }
+    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 r = this.parseMultiplicative();
+      e = { type: "binary", op: n, left: e, right: r };
+    }
+    return e;
+  }
+  parseMultiplicative() {
+    let e = this.parseUnary();
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.peek();
+      if (n !== "*" && n !== "/")
+        break;
+      this.index++;
+      const r = this.parseUnary();
+      e = { type: "binary", op: n, left: e, right: r };
+    }
+    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 m(this.path, "expected property name after '.'");
+    if (this.skipWhitespace(), this.peek() === "(") {
+      if (n !== "toLocaleString")
+        throw m(this.path, `unsupported method: ${n}()`);
+      this.index++;
+      const r = this.parseMethodArgs();
+      return { type: "method", object: e, method: n, args: r };
+    }
+    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 m(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 m(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 (Y(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 m(
+            this.path,
+            "component calls are not allowed in template literals"
+          );
+        this.index++;
+        const r = this.parseCallArgs();
+        return { type: "call", callee: n, args: r };
+      }
+      if (this.peek() === "[")
+        throw m(this.path, "bracket access is not allowed");
+      return { type: "identifier", name: n };
+    }
+    throw m(this.path, `unexpected character '${e}'`);
+  }
+  parseTemplateLiteral() {
+    this.index++;
+    const e = [];
+    let n = "";
+    for (; this.index < this.input.length; ) {
+      const r = this.input[this.index];
+      if (r === "`")
+        return this.index++, e.push(n), { type: "template", parts: e };
+      if (r === "\\") {
+        if (this.index++, this.index >= this.input.length)
+          throw m(this.path, "unterminated template literal escape");
+        n += this.input[this.index], this.index++;
+        continue;
+      }
+      if (r === "$" && this.input[this.index + 1] === "{") {
+        e.push(n), n = "", this.index += 2;
+        const i = this.readTemplateExpression(), s = S(i, this.path, {
+          allowCalls: !1
+        });
+        e.push(s);
+        continue;
+      }
+      n += r, this.index++;
+    }
+    throw m(this.path, "unterminated template literal");
+  }
+  readTemplateExpression() {
+    let e = 1;
+    const n = this.index;
+    let r = null;
+    for (; this.index < this.input.length; ) {
+      const i = this.input[this.index];
+      if (r) {
+        if (i === "\\") {
+          this.index += 2;
+          continue;
+        }
+        i === r && (r = null), this.index++;
+        continue;
+      }
+      if (i === '"' || i === "'" || i === "`") {
+        r = i, this.index++;
+        continue;
+      }
+      if (i === "{") {
+        e++, this.index++;
+        continue;
+      }
+      if (i === "}") {
+        if (e--, e === 0) {
+          const s = this.input.slice(n, this.index);
+          return this.index++, s;
+        }
+        this.index++;
+        continue;
+      }
+      this.index++;
+    }
+    throw m(this.path, "unterminated template expression");
+  }
+  parseCallArgs() {
+    if (this.skipWhitespace(), this.peek() === ")")
+      return this.index++, {};
+    if (this.peek() !== "{")
+      throw m(this.path, "expected object literal");
+    this.index++, this.skipWhitespace();
+    const e = {};
+    if (this.peek() === "}") {
+      if (this.index++, this.skipWhitespace(), this.peek() !== ")")
+        throw m(this.path, "expected ')' after call arguments");
+      return this.index++, e;
+    }
+    for (; ; ) {
+      this.skipWhitespace();
+      const n = this.readIdentifier();
+      if (!n)
+        throw m(this.path, "expected property name in object literal");
+      if (this.skipWhitespace(), this.peek() !== ":")
+        throw m(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 m(this.path, "expected ',' or '}' in object literal");
+    }
+    if (this.skipWhitespace(), this.peek() !== ")")
+      throw m(this.path, "expected ')' after call arguments");
+    return this.index++, e;
+  }
+  parseObjectLiteral() {
+    if (this.peek() !== "{")
+      throw m(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 m(this.path, "expected property name in object literal");
+      if (this.skipWhitespace(), this.peek() !== ":")
+        throw m(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 m(this.path, "expected ',' or '}' in object literal");
+    }
+    return e;
+  }
+  parseArrayLiteral() {
+    if (this.peek() !== "[")
+      throw m(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 m(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 (Y(e)) {
+      const n = this.readIdentifier();
+      if (n === "true") return !0;
+      if (n === "false") return !1;
+      if (n === "null") return null;
+      throw m(this.path, "object literal values must be literals");
+    }
+    throw m(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 (!Y(this.peek()))
+      return "";
+    for (this.index++; this.index < this.input.length && yt(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 r = this.input[this.index];
+      if (r === e)
+        return this.index++, n;
+      if (r === "\\") {
+        if (this.index++, this.index >= this.input.length)
+          throw m(this.path, "unterminated string escape");
+        const i = this.input[this.index];
+        n += i, this.index++;
+        continue;
+      }
+      n += r, this.index++;
+    }
+    throw m(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), r = Number(n);
+    if (Number.isNaN(r))
+      throw m(this.path, `invalid number '${n}'`);
+    return r;
+  }
+}
+async function Re(t, e, n = {}) {
+  const r = n.path;
+  let i = "", s = 0;
+  for (; s < t.length; ) {
+    const o = t.indexOf("{", s);
+    if (o === -1) {
+      i += t.slice(s);
+      break;
+    }
+    i += t.slice(s, 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) {
+      i += "{", s = o + 1;
+      continue;
+    }
+    const h = a ? 3 : 2, l = a ? "}}}" : "}}", p = t.indexOf(l, o + h);
+    if (p === -1)
+      throw d({
+        code: "parse_error",
+        path: r,
+        details: { message: "unclosed expression" }
+      });
+    const f = t.slice(o + h, p).trim(), g = S(f, r), w = await k(g, {
+      ...n,
+      context: e,
+      path: r,
+      parentContext: n.parentContext ?? e
+    });
+    i += w == null ? "" : String(w), s = p + l.length;
+  }
+  return i;
+}
+function vt(t, e) {
+  let n = 0, r = 0;
+  for (; r < t.length; ) {
+    const i = t.indexOf(e, r);
+    if (i === -1)
+      break;
+    n++, r = i + e.length;
+  }
+  return n;
+}
+function ie(t) {
+  const e = t.includes("@hg"), n = t.includes("@endhg"), r = vt(t, "@@");
+  return e && n ? r > 0 ? "mixed" : "hg" : r >= 2 && !e && !n ? "at-at" : (e || n) && r > 0 ? "mixed" : e && !n || r === 1 && !n ? "unclosed" : "none";
+}
+function se(t) {
+  return t.replace(/@endhg/g, "").replace(/@hg/g, "").replace(/@@/g, "");
+}
+function oe(t, e) {
+  let n = 0, r = !1;
+  for (; n < e; ) {
+    const i = t.indexOf("```", n);
+    if (i === -1 || i >= e)
+      break;
+    r = !r, n = i + 3;
+  }
+  return r;
+}
+function C(t) {
+  const e = [];
+  let n = 0;
+  for (; n < t.length; ) {
+    const r = t.indexOf("<!--", n);
+    if (r === -1)
+      break;
+    if (oe(t, r)) {
+      n = r + 4;
+      continue;
+    }
+    const i = t.indexOf("-->", r + 4);
+    if (i === -1)
+      break;
+    const s = t.slice(r, i + 3), o = s.slice(4, s.length - 3), a = ie(o);
+    (a === "hg" || a === "at-at") && e.push({
+      start: r,
+      end: i + 3,
+      inner: o,
+      raw: s
+    }), n = i + 3;
+  }
+  return e;
+}
+function ae(t) {
+  let e = 0;
+  for (; e < t.length; ) {
+    const n = t.indexOf("<!--", e);
+    if (n === -1)
+      return !1;
+    if (oe(t, n)) {
+      e = n + 4;
+      continue;
+    }
+    const r = t.indexOf("-->", n + 4);
+    if (r === -1)
+      return !1;
+    const i = t.slice(n + 4, r), s = ie(i);
+    if (s === "unclosed" || s === "mixed")
+      return !0;
+    e = r + 3;
+  }
+  return !1;
+}
+function ce(t) {
+  let e = 0;
+  for (; e < t.length; ) {
+    const n = t.indexOf("<!--", e);
+    if (n === -1)
+      return null;
+    if (oe(t, n)) {
+      e = n + 4;
+      continue;
+    }
+    const r = t.indexOf("-->", n + 4);
+    if (r === -1)
+      return null;
+    const i = t.slice(n + 4, r), s = ie(i);
+    if (s === "mixed")
+      return "mixed @hg and @@ markers are not allowed";
+    if (s === "unclosed")
+      return "unclosed hyogen block (missing closing marker)";
+    e = r + 3;
+  }
+  return null;
+}
+function W(t) {
+  return se(t).trim().split(/\r?\n/).map((n) => n.trim()).filter((n) => n.length > 0);
+}
+const _t = /^(if\s+.+|else\s+if\s+.+|else|endif|each\s+[A-Za-z_$][A-Za-z0-9_$]*\s+in\s+.+|endeach)$/i;
+function he(t) {
+  return _t.test(t.trim());
+}
+function G(t, e) {
+  throw d({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function St(t, e) {
+  let n = t;
+  const r = /^<!--([\s\S]*?)-->$/.exec(t.trim());
+  r && (n = r[1]);
+  const i = W(n);
+  if (i.length !== 1)
+    return null;
+  const s = i[0];
+  if (/^include\s+/i.test(s) || /^component\s+/i.test(s) || /^const\s+/i.test(s) || /^let\s+/i.test(s) || /^[A-Za-z_$][A-Za-z0-9_$]*\s*=/.test(s))
+    return null;
+  if (s === "else")
+    return { kind: "else" };
+  if (s === "endif")
+    return { kind: "endif" };
+  if (s === "endeach")
+    return { kind: "endeach" };
+  if (/^IF\b/.test(s) || /^ELSE\b/.test(s) || /^ENDIF\b/.test(s))
+    throw G(e, "control keywords must be lowercase");
+  const o = /^else\s+if\s+(.+)$/.exec(s);
+  if (o)
+    return {
+      kind: "else_if",
+      expr: S(o[1], e)
+    };
+  const a = /^if\s+(.+)$/.exec(s);
+  if (a)
+    return {
+      kind: "if",
+      expr: S(a[1], e)
+    };
+  const c = /^each\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+in\s+(.+)$/.exec(s);
+  if (c)
+    return {
+      kind: "each",
+      item: c[1],
+      expr: S(c[2], e)
+    };
+  if (s === "if")
+    throw G(e, "if requires an expression");
+  if (/^each\s+/.test(s))
+    throw G(e, "invalid each directive");
+  return null;
+}
+function M(t) {
+  return { start: t.start, end: t.end, raw: t.raw };
+}
+function _(t, e) {
+  throw d({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function Ct(t, e) {
+  const n = [];
+  for (const r of C(t)) {
+    const i = St(r.inner, e);
+    i && n.push({
+      start: r.start,
+      end: r.end,
+      raw: r.raw,
+      opener: i
+    });
+  }
+  return n;
+}
+function Me(t) {
+  return t.kind === "if" || t.kind === "each";
+}
+function Wt(t, e) {
+  const n = Ct(t, e);
+  if (n.length === 0)
+    return t.length > 0 ? [{ kind: "text", content: t }] : [];
+  const { nodes: r, nextIndex: i } = N(t, n, 0, n.length, e);
+  if (i < n.length) {
+    const s = n[i];
+    if (s.opener.kind === "endif")
+      throw _(e, "endif without matching if");
+    if (s.opener.kind === "endeach")
+      throw _(e, "endeach without matching each");
+    if (s.opener.kind === "else" || s.opener.kind === "else_if")
+      throw _(e, "else without matching if");
+  }
+  return r;
+}
+function N(t, e, n, r, i, s = 0, o) {
+  const a = o ?? t.length, c = [];
+  let h = s, l = n;
+  for (; l < r; ) {
+    const p = e[l];
+    if (p.start >= a)
+      break;
+    if (p.end <= s) {
+      l++;
+      continue;
+    }
+    if (p.start > h && c.push({
+      kind: "text",
+      content: t.slice(h, p.start)
+    }), p.opener.kind === "if") {
+      const f = Et(t, e, l, r, i);
+      c.push(f.node), h = f.endPos, l = f.nextIndex;
+      continue;
+    }
+    if (p.opener.kind === "each") {
+      const f = Tt(t, e, l, r, i);
+      c.push(f.node), h = f.endPos, l = f.nextIndex;
+      continue;
+    }
+    if (p.opener.kind === "else" || p.opener.kind === "else_if")
+      throw _(i, "else without matching if");
+    if (p.opener.kind === "endif")
+      throw _(i, "endif without matching if");
+    if (p.opener.kind === "endeach")
+      throw _(i, "endeach without matching each");
+    l++;
+  }
+  return h < a && c.push({ kind: "text", content: t.slice(h, a) }), { nodes: c, nextIndex: l };
+}
+function Et(t, e, n, r, i) {
+  const s = e[n];
+  if (s.opener.kind !== "if")
+    throw _(i, "expected if");
+  const o = [];
+  let a = n, c = s.end, h = 0;
+  for (; a < r; ) {
+    const l = e[a];
+    if (a === n) {
+      if (l.opener.kind !== "if")
+        throw _(i, "expected if");
+      o.push({
+        kind: "if",
+        expr: l.opener.expr,
+        opener: M(l),
+        body: []
+      }), a++;
+      continue;
+    }
+    if (Me(l.opener)) {
+      h++, a++;
+      continue;
+    }
+    if (l.opener.kind === "endif") {
+      if (h === 0)
+        return o[o.length - 1].body = N(
+          t,
+          e,
+          n + 1,
+          a,
+          i,
+          c,
+          l.start
+        ).nodes, {
+          node: { kind: "if", branches: o, closer: M(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 = N(
+          t,
+          e,
+          n + 1,
+          a,
+          i,
+          c,
+          l.start
+        ).nodes, o.push({
+          kind: "else_if",
+          expr: l.opener.expr,
+          opener: M(l),
+          body: []
+        }), c = l.end, a++;
+        continue;
+      }
+      if (l.opener.kind === "else") {
+        o[o.length - 1].body = N(
+          t,
+          e,
+          n + 1,
+          a,
+          i,
+          c,
+          l.start
+        ).nodes, o.push({
+          kind: "else",
+          opener: M(l),
+          body: []
+        }), c = l.end, a++;
+        continue;
+      }
+    }
+    a++;
+  }
+  throw _(i, "unclosed if block (missing endif)");
+}
+function Tt(t, e, n, r, i) {
+  const s = e[n];
+  if (s.opener.kind !== "each")
+    throw _(i, "expected each");
+  let o = n + 1;
+  const a = s.end;
+  let c = 0;
+  for (; o < r; ) {
+    const h = e[o];
+    if (Me(h.opener)) {
+      c++, o++;
+      continue;
+    }
+    if (h.opener.kind === "endeach") {
+      if (c === 0) {
+        const l = N(
+          t,
+          e,
+          n + 1,
+          o,
+          i,
+          a,
+          h.start
+        ).nodes;
+        return {
+          node: {
+            kind: "each",
+            item: s.opener.item,
+            expr: s.opener.expr,
+            opener: M(s),
+            body: l,
+            closer: M(h)
+          },
+          nextIndex: o + 1,
+          endPos: h.end
+        };
+      }
+      c--, o++;
+      continue;
+    }
+    if (h.opener.kind === "endif") {
+      c--, o++;
+      continue;
+    }
+    o++;
+  }
+  throw _(i, "unclosed each block (missing endeach)");
+}
+const ye = 20;
+class $t {
+  depth = 0;
+  get currentDepth() {
+    return this.depth;
+  }
+  enter() {
+    return this.depth >= ye ? { exceeded: !0, limit: ye } : (this.depth++, { exceeded: !1, depth: this.depth });
+  }
+  exit() {
+    this.depth > 0 && this.depth--;
+  }
+}
+function At(t) {
+  return !!t;
+}
+function Rt(t) {
+  return t != null && typeof t[Symbol.iterator] == "function";
+}
+function Oe(t) {
+  return {
+    code: "nest_limit_exceeded",
+    message: "structure nest limit exceeded",
+    path: t,
+    details: { limit: 20 }
+  };
+}
+function le(t) {
+  return t.startsWith(`
+`) ? t.slice(1) : t;
+}
+async function Mt(t, e) {
+  const n = e.path, r = e.warnings ?? [], i = Wt(t, n), s = new $t();
+  return de(i, e, s, r);
+}
+async function de(t, e, n, r) {
+  const i = e.preserveHgComments === !0;
+  let s = "", o = !1;
+  for (const a of t) {
+    let c = await Ot(a, e, n, r);
+    o && (c = le(c)), s += c, o = !i && (a.kind === "if" || a.kind === "each");
+  }
+  return s;
+}
+async function Ot(t, e, n, r) {
+  switch (t.kind) {
+    case "text":
+      return t.content;
+    case "if":
+      return Lt(t, e, n, r);
+    case "each":
+      return Dt(t, e, n, r);
+    default:
+      return "";
+  }
+}
+async function Lt(t, e, n, r) {
+  if (n.enter().exceeded)
+    return r.push(Oe(e.path)), "";
+  try {
+    let s = -1;
+    for (let c = 0; c < t.branches.length; c++) {
+      const h = t.branches[c];
+      if (h.kind === "else") {
+        s = c;
+        break;
+      }
+      const l = await k(h.expr, e);
+      if (At(l)) {
+        s = 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 === s) {
+        let l = await de(h.body, e, n, r);
+        o || (l = le(l)), a += l;
+      }
+    }
+    return o && (a += t.closer.raw), a;
+  } finally {
+    n.exit();
+  }
+}
+async function Dt(t, e, n, r) {
+  if (n.enter().exceeded)
+    return r.push(Oe(e.path)), "";
+  try {
+    const s = await k(t.expr, e);
+    if (!Rt(s))
+      return "";
+    const o = e.preserveHgComments === !0;
+    let a = "";
+    for (const c of s) {
+      const h = { ...e.context, [t.item]: c };
+      o && (a += t.opener.raw);
+      let l = await de(t.body, {
+        ...e,
+        context: h
+      }, n, r);
+      o || (l = le(l));
+      const p = await Re(l, h, {
+        path: e.path,
+        registry: e.registry,
+        loader: e.loader,
+        rootDir: e.rootDir,
+        warnings: r,
+        visitStack: e.visitStack,
+        parentContext: e.parentContext ?? e.context,
+        preserveHgComments: e.preserveHgComments,
+        constrainToRoot: e.constrainToRoot
+      });
+      a += p, o && (a += t.closer.raw);
+    }
+    return a;
+  } finally {
+    n.exit();
+  }
+}
+function J(t, e, n, r, i = !1, s = !1) {
+  return j(e) ? e : re(e, {
+    rootDir: t,
+    fromPath: r,
+    documentPath: n,
+    constrainToRoot: i,
+    hyogenPath: s
+  });
+}
+function Le(t) {
+  let e = 0;
+  for (let n = t.length - 1; n >= 0 && t[n] === `
+`; n--)
+    e++;
+  return e;
+}
+function De(t) {
+  let e = 0;
+  for (; e < t.length && t[e] === `
+`; )
+    e++;
+  return e;
+}
+function L(t, e) {
+  const n = Le(t), r = De(e), i = Math.max(n, r);
+  return t.slice(0, t.length - n) + `
+`.repeat(i) + e.slice(r);
+}
+function pe(t, e) {
+  const n = Le(t), r = De(e);
+  return n + r - Math.max(n, r);
+}
+function be(t, e, n) {
+  const r = t.indexOf(e);
+  if (r < 0)
+    return t;
+  const i = t.slice(0, r), s = t.slice(r + e.length);
+  return L(L(i, n), s);
+}
+async function Nt(t) {
+  let e = t.source;
+  for (const n of t.directives) {
+    const r = J(
+      t.root,
+      n.path,
+      t.path,
+      t.path,
+      t.constrainToRoot,
+      !0
+    );
+    if (t.visitStack) {
+      const i = t.visitStack.check(r);
+      if (i.circular) {
+        t.warnings?.push({
+          code: "circular_include",
+          message: O("circular_include", {
+            path: r,
+            from: i.from,
+            via: "include"
+          }),
+          path: t.path,
+          details: {
+            path: r,
+            from: i.from,
+            via: "include"
+          }
+        }), e = be(e, n.marker, "");
+        continue;
+      }
+      t.visitStack.push(r);
+    }
+    try {
+      const i = await t.loader(r), s = await on(i, {
+        context: t.context,
+        loader: t.loader,
+        root: t.root,
+        path: r,
+        preserveFrontMatter: t.preserveFrontMatter,
+        preserveHgComments: t.preserveHgComments,
+        visitStack: t.visitStack,
+        warnings: t.warnings,
+        registry: t.registry
+      }), o = t.preserveHgComments && n.raw ? `${n.raw}
+${s}` : s;
+      e = be(e, n.marker, o);
+    } finally {
+      t.visitStack?.pop();
+    }
+  }
+  return e;
+}
+class Ne {
+  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 Ht(t, e, n = {}) {
+  const { path: r, constBindings: i = /* @__PURE__ */ new Set() } = n, s = await k(t.expr, { context: e, path: r });
+  switch (t.kind) {
+    case "const": {
+      if (i.has(t.name))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      e[t.name] = s, i.add(t.name);
+      break;
+    }
+    case "let": {
+      e[t.name] = s;
+      break;
+    }
+    case "assign": {
+      if (i.has(t.name))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `assignment to undeclared variable: ${t.name}`
+          }
+        });
+      e[t.name] = s;
+      break;
+    }
+  }
+}
+function ve(t) {
+  return !t;
+}
+async function D(t, e, n = {}) {
+  const { path: r, constBindings: i = /* @__PURE__ */ new Set(), onUpdate: s } = n;
+  switch (t.kind) {
+    case "const":
+    case "let":
+    case "assign": {
+      await Ht(t, e, { path: r, constBindings: i }), s?.(t.name);
+      return;
+    }
+    case "update": {
+      if (i.has(t.name))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw d({
+          code: "parse_error",
+          path: r,
+          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, s?.(t.name);
+      return;
+    }
+    case "compound_assign": {
+      if (i.has(t.name))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `cannot reassign const binding: ${t.name}`
+          }
+        });
+      if (!(t.name in e))
+        throw d({
+          code: "parse_error",
+          path: r,
+          details: {
+            message: `assignment to undeclared variable: ${t.name}`
+          }
+        });
+      const o = await k(t.expr, { context: e, path: r }), 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, s?.(t.name);
+      return;
+    }
+    case "for": {
+      for (t.init && await D(t.init, e, n); ; ) {
+        const o = await k(t.cond, {
+          context: e,
+          path: r
+        });
+        if (ve(o))
+          break;
+        for (const a of t.body)
+          await D(a, e, n);
+        t.update && await D(t.update, e, n);
+      }
+      return;
+    }
+    case "do_while": {
+      do {
+        for (const a of t.body)
+          await D(a, e, n);
+        const o = await k(t.cond, {
+          context: e,
+          path: r
+        });
+        if (ve(o))
+          break;
+      } while (!0);
+      return;
+    }
+  }
+}
+async function _e(t, e, n = {}) {
+  for (const r of t)
+    await D(r, e, n);
+}
+const jt = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "endif",
+  "const",
+  "let",
+  "for",
+  "do",
+  "while",
+  "each",
+  "endeach",
+  "block",
+  "endblock",
+  "extend",
+  "include",
+  "component",
+  "as"
+]);
+function He(t) {
+  return jt.has(t);
+}
+function ue(t) {
+  let e = "", n = 0, r = null;
+  for (; n < t.length; ) {
+    const i = t[n];
+    if (r) {
+      if (e += i, i === "\\" && n + 1 < t.length) {
+        e += t[++n], n++;
+        continue;
+      }
+      i === r && (r = null), n++;
+      continue;
+    }
+    if (i === '"' || i === "'" || i === "`") {
+      r = i, e += i, n++;
+      continue;
+    }
+    if (t.startsWith("//", n)) {
+      for (; n < t.length && t[n] !== `
+`; )
+        n++;
+      continue;
+    }
+    if (t.startsWith("/*", n)) {
+      const s = t.indexOf("*/", n + 2);
+      if (s === -1)
+        break;
+      n = s + 2;
+      continue;
+    }
+    e += i, n++;
+  }
+  return e;
+}
+function x(t, e) {
+  throw d({
+    code: "parse_error",
+    path: t,
+    details: { message: e }
+  });
+}
+function Se(t, e) {
+  const n = ue(t).trim();
+  if (n.length === 0)
+    throw x(e, "empty statement block");
+  const r = new fe(n, e), i = r.parseStatementList();
+  if (r.skipWhitespace(), r.hasMore())
+    throw x(
+      e,
+      `unexpected token at position ${r.position}`
+    );
+  if (i.length === 0)
+    throw x(e, "empty statement block");
+  return i;
+}
+function I(t) {
+  const e = ue(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 fe {
+  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 x(
+        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 x(this.path, "expected statement");
+    if (this.assertAssignableName(n), this.skipWhitespace(), this.match("++") || this.match("--")) {
+      const i = this.input.slice(this.index - 2, this.index);
+      return { kind: "update", name: n, op: i, position: "postfix" };
+    }
+    const r = this.readCompoundOp();
+    if (r) {
+      const i = this.readExpressionSourceUntilTerminator();
+      return {
+        kind: "compound_assign",
+        name: n,
+        op: r,
+        expr: S(i, this.path)
+      };
+    }
+    if (this.match("=")) {
+      if (this.peek() === "=")
+        throw x(this.path, "unexpected '==' in assignment");
+      const i = this.readExpressionSourceUntilTerminator();
+      return {
+        kind: "assign",
+        name: n,
+        expr: S(i, this.path)
+      };
+    }
+    throw x(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 x(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 x(this.path, `expected identifier after ${e}`);
+    if (this.assertAssignableName(n), this.skipWhitespace(), !this.match("="))
+      throw x(this.path, `expected '=' in ${e} declaration`);
+    const r = this.readExpressionSourceUntilTerminator();
+    return {
+      kind: e,
+      name: n,
+      expr: S(r, this.path)
+    };
+  }
+  parseFor() {
+    if (this.skipWhitespace(), !this.match("("))
+      throw x(this.path, "expected '(' after for");
+    const e = this.readBalanced(")"), n = Ft(e);
+    if (n.length !== 3)
+      throw x(
+        this.path,
+        "for…of / for…in are not allowed; use for (init; cond; update)"
+      );
+    const [r, i, s] = n;
+    if (i.trim().length === 0)
+      throw x(this.path, "for loop condition cannot be empty");
+    if (/^\s*[A-Za-z_$][A-Za-z0-9_$]*\s+(of|in)\s+/.test(r))
+      throw x(
+        this.path,
+        "for…of / for…in are not allowed; use for (init; cond; update)"
+      );
+    const o = r.trim().length === 0 ? null : this.parseClauseStatement(r.trim()), a = S(i.trim(), this.path), c = s.trim().length === 0 ? null : this.parseClauseStatement(s.trim());
+    if (this.skipWhitespace(), !this.match("{"))
+      throw x(this.path, "expected '{' after for (...)");
+    const h = this.parseStatementList();
+    if (this.skipWhitespace(), !this.match("}"))
+      throw x(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 x(this.path, "expected '{' after do");
+    const e = this.parseStatementList();
+    if (this.skipWhitespace(), !this.match("}"))
+      throw x(this.path, "expected '}' to close do body");
+    if (this.skipWhitespace(), !this.matchWord("while"))
+      throw x(this.path, "expected 'while' after do body");
+    if (this.skipWhitespace(), !this.match("("))
+      throw x(this.path, "expected '(' after while");
+    const n = this.readBalanced(")");
+    if (n.trim().length === 0)
+      throw x(this.path, "do…while condition cannot be empty");
+    const r = S(n.trim(), this.path);
+    return { kind: "do_while", body: e, cond: r };
+  }
+  parseClauseStatement(e) {
+    const n = new fe(e, this.path), r = n.parseSimpleStatement();
+    if (n.skipWhitespace(), n.hasMore())
+      throw x(
+        this.path,
+        `unexpected token in for clause at position ${n.position}`
+      );
+    return r;
+  }
+  assertAssignableName(e) {
+    if (He(e))
+      throw x(
+        this.path,
+        `reserved word cannot be used as identifier: ${e}`
+      );
+  }
+  readExpressionSourceUntilTerminator() {
+    this.skipWhitespace();
+    const e = this.index;
+    let n = 0, r = 0, i = 0, s = null;
+    for (; this.index < this.input.length; ) {
+      const a = this.input[this.index];
+      if (s) {
+        if (a === "\\") {
+          this.index += 2;
+          continue;
+        }
+        a === s && (s = null), this.index++;
+        continue;
+      }
+      if (a === '"' || a === "'" || a === "`") {
+        s = a, this.index++;
+        continue;
+      }
+      if (a === "(" && n++, a === ")" && (n = Math.max(0, n - 1)), a === "{" && r++, a === "}") {
+        if (r === 0 && n === 0 && i === 0)
+          break;
+        r = Math.max(0, r - 1);
+      }
+      if (a === "[" && i++, a === "]" && (i = Math.max(0, i - 1)), (a === ";" || a === `
+`) && n === 0 && r === 0 && i === 0)
+        break;
+      this.index++;
+    }
+    const o = this.input.slice(e, this.index).trim();
+    if (o.length === 0)
+      throw x(this.path, "expected expression");
+    return o;
+  }
+  readBalanced(e) {
+    const n = e === ")" ? "(" : "{";
+    let r = 1;
+    const i = this.index;
+    let s = null;
+    for (; this.index < this.input.length; ) {
+      const o = this.input[this.index];
+      if (s) {
+        if (o === "\\") {
+          this.index += 2;
+          continue;
+        }
+        o === s && (s = null), this.index++;
+        continue;
+      }
+      if (o === '"' || o === "'" || o === "`") {
+        s = o, this.index++;
+        continue;
+      }
+      if (o === n) {
+        r++, this.index++;
+        continue;
+      }
+      if (o === e) {
+        if (r--, r === 0) {
+          const a = this.input.slice(i, this.index);
+          return this.index++, a;
+        }
+        this.index++;
+        continue;
+      }
+      this.index++;
+    }
+    throw x(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 Ft(t) {
+  const e = [];
+  let n = "", r = 0, i = null;
+  for (let s = 0; s < t.length; s++) {
+    const o = t[s];
+    if (i) {
+      if (n += o, o === "\\" && s + 1 < t.length) {
+        n += t[++s];
+        continue;
+      }
+      o === i && (i = null);
+      continue;
+    }
+    if (o === '"' || o === "'" || o === "`") {
+      i = o, n += o;
+      continue;
+    }
+    if (o === "(" || o === "[" || o === "{") {
+      r++, n += o;
+      continue;
+    }
+    if (o === ")" || o === "]" || o === "}") {
+      r = Math.max(0, r - 1), n += o;
+      continue;
+    }
+    if (o === ";" && r === 0) {
+      e.push(n), n = "";
+      continue;
+    }
+    n += o;
+  }
+  return e.push(n), e;
+}
+function H(t, e) {
+  const n = t.trim();
+  if (!/^extend\b/i.test(n)) return null;
+  if (!/^extend\s+/i.test(n))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "missing extend path" }
+    });
+  const r = /^extend\s+(\S+)\s*$/.exec(n);
+  if (!r)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid extend directive" }
+    });
+  const i = r[1];
+  if (i.length === 0)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid extend path" }
+    });
+  return { path: i };
+}
+function Bt(t, e) {
+  const n = W(t);
+  if (n.length === 0) return null;
+  const r = n[0], i = H(r, e);
+  if (!i) return null;
+  for (const s of n.slice(1))
+    if (/^extend\s+/i.test(s))
+      throw d({
+        code: "parse_error",
+        path: e,
+        details: { message: "extend must be the first line of extend block" }
+      });
+  return {
+    path: i.path,
+    declarationsSource: n.slice(1).join(`
+`)
+  };
+}
+async function It(t, e = {}) {
+  const n = e.path, r = e.context ?? {};
+  if (ae(t))
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: {
+        message: ce(t) ?? "unclosed hyogen block (missing closing marker)"
+      }
+    });
+  const i = C(t);
+  if (i.length === 0)
+    return { source: t, context: r, declarationUpdates: {} };
+  const s = /* @__PURE__ */ new Set(), o = {}, a = (l) => {
+    o[l] = r[l];
+  };
+  let c = t, h = 0;
+  for (const l of i) {
+    const p = W(l.inner);
+    if (p.length === 1 && he(p[0]) || p.length === 1 && /^include\s+/i.test(p[0]) || p.length === 1 && /^component\s+/i.test(p[0]))
+      continue;
+    const f = Bt(l.inner, n);
+    if (f) {
+      if (f.declarationsSource.trim().length > 0) {
+        const Z = Se(
+          f.declarationsSource,
+          n
+        );
+        await _e(Z, r, {
+          path: n,
+          constBindings: s,
+          onUpdate: a
+        });
+      }
+      const v = l.start - h, E = l.end - h, T = `<!--@hg
+extend ${f.path}
+@endhg-->`;
+      c = c.slice(0, v) + T + c.slice(E), h += l.raw.length - T.length;
+      continue;
+    }
+    const g = p.join(`
+`);
+    if (!I(g)) {
+      if (p.length === 1)
+        continue;
+      throw d({
+        code: "parse_error",
+        path: n,
+        details: { message: `unsupported hyogen directive: ${p[0]}` }
+      });
+    }
+    const w = Se(g, n);
+    await _e(w, r, {
+      path: n,
+      constBindings: s,
+      onUpdate: a
+    });
+    const y = l.start - h, A = l.end - h, F = c.slice(0, y), $ = c.slice(A);
+    c = L(F, $), h += l.raw.length + pe(F, $);
+  }
+  return { source: c, context: r, declarationUpdates: o };
+}
+const zt = /^component\s+(\S+)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*$/;
+function je(t, e) {
+  const n = se(t).trim();
+  if (n.length === 0)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty hyogen block" }
+    });
+  const r = n.split(/\r?\n/).map((a) => a.trim()).filter((a) => a.length > 0);
+  if (r.length !== 1)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: {
+        message: "hyogen block must contain a single component directive"
+      }
+    });
+  const i = r[0];
+  if (/^include\s+/i.test(i))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "include and component cannot coexist in one block" }
+    });
+  const s = zt.exec(i);
+  if (!s)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: `unsupported component directive: ${i}` }
+    });
+  const o = s[1];
+  if (o.length === 0)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty component path" }
+    });
+  return {
+    kind: "component",
+    path: o,
+    alias: s[2]
+  };
+}
+function Fe(t, e) {
+  const n = se(t).trim();
+  if (n.length === 0)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "empty hyogen block" }
+    });
+  const r = n.split(/\r?\n/).map((o) => o.trim()).filter((o) => o.length > 0);
+  if (r.length !== 1)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "hyogen block must contain a single include directive" }
+    });
+  const i = r[0], s = /^include\s+(\S+)\s*$/.exec(i);
+  if (s)
+    return { kind: "include", path: s[1] };
+  throw d({
+    code: "parse_error",
+    path: e,
+    details: { message: `unsupported hyogen directive: ${i}` }
+  });
+}
+function Q(t) {
+  const e = ue(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 Ut = "\0HYOGEN_INCLUDE_";
+function Zt(t) {
+  return `${Ut}${t}\0`;
+}
+function qt(t, e) {
+  const n = W(t);
+  if (n.length === 1 && he(n[0]))
+    return { kind: "control" };
+  if (n.length === 1 && (Q(n[0]) || I(n[0])))
+    return null;
+  if (n.length !== 1)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "hyogen block must contain a single directive" }
+    });
+  const r = n[0];
+  if (/^include\s+/i.test(r) && /\bcomponent\s+/i.test(r))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "include and component cannot coexist in one block" }
+    });
+  if (/^include\s+/i.test(r))
+    return Fe(t, e);
+  if (/^component\s+/i.test(r))
+    return je(t, e);
+  if (r === "endblock" || /^block\s+/.test(r) || /^extend\s+/.test(r))
+    return null;
+  throw d({
+    code: "parse_error",
+    path: e,
+    details: { message: `unsupported hyogen directive: ${r}` }
+  });
+}
+function Pt(t, e = {}) {
+  const n = e.path;
+  if (ae(t))
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: {
+        message: ce(t) ?? "unclosed hyogen block (missing closing marker)"
+      }
+    });
+  const r = C(t);
+  if (r.length === 0)
+    return { source: t, directives: [] };
+  const i = [];
+  let s = t, o = 0, a = 0;
+  for (const c of r) {
+    const h = qt(c.inner, n);
+    if (!h || h.kind === "control")
+      continue;
+    const l = c.start - o, p = 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 = s.slice(0, l), w = s.slice(p);
+      s = L(g, w), o += c.raw.length + pe(g, w);
+      continue;
+    }
+    const f = Zt(a++);
+    i.push({ ...h, marker: f, raw: c.raw }), s = s.slice(0, l) + f + s.slice(p), o += c.raw.length - f.length;
+  }
+  return { source: s, directives: i };
+}
+function Vt(t, e) {
+  return !e.preserveFrontMatter || !e.rawFrontMatter ? t : t.length === 0 ? `${e.rawFrontMatter}
+` : `${e.rawFrontMatter}
+${t}`;
+}
+function Kt(t, e = !1) {
+  if (e)
+    return t;
+  const n = C(t);
+  if (n.length === 0)
+    return t;
+  let r = t, i = 0;
+  for (const s of n) {
+    const o = s.start - i, a = s.end - i, c = r.slice(0, o), h = r.slice(a);
+    r = L(c, h), i += s.raw.length + pe(c, h);
+  }
+  return r;
+}
+const Yt = /^block\s+([A-Za-z_$][A-Za-z0-9_$]*)$/;
+function Gt(t, e) {
+  const n = t.trim();
+  if (n === "endblock")
+    return { kind: "endblock" };
+  const r = Yt.exec(n);
+  if (!r)
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: "invalid block directive" }
+    });
+  const i = r[1];
+  if (He(i))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: `reserved word cannot be used as block name: ${i}` }
+    });
+  return { kind: "block", name: i };
+}
+function Ce(t, e) {
+  const { path: n, mode: r, hasExtend: i = !1 } = e, s = C(t);
+  if (s.length === 0) return [];
+  const o = [], a = [], c = /* @__PURE__ */ new Set();
+  for (const h of s) {
+    const l = W(h.inner);
+    if (l.length !== 1) continue;
+    const p = l[0];
+    if (!(p === "endblock" || p.startsWith("block "))) continue;
+    if (r === "child" && !i)
+      throw d({
+        code: "parse_error",
+        path: n,
+        details: { message: "orphan block without extend" }
+      });
+    const g = Gt(p, n);
+    if (g.kind === "endblock") {
+      const w = a.pop();
+      if (!w)
+        throw d({
+          code: "parse_error",
+          path: n,
+          details: { message: "endblock without matching block opener" }
+        });
+      const y = t.slice(w.openerEnd, h.start);
+      o.push({
+        name: w.name,
+        body: y,
+        start: w.start,
+        end: h.end
+      });
+      continue;
+    }
+    if (a.length > 0)
+      throw d({
+        code: "parse_error",
+        path: n,
+        details: { message: "nested block structures are not supported" }
+      });
+    if (c.has(g.name))
+      throw d({
+        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 d({
+      code: "parse_error",
+      path: n,
+      details: { message: "missing endblock" }
+    });
+  return o;
+}
+function We(t) {
+  const e = C(t), n = [];
+  for (const r of e) {
+    const i = W(r.inner);
+    if (i.length === 0) continue;
+    const s = H(i[0]);
+    s && n.push({ path: s.path, start: r.start });
+  }
+  return n;
+}
+function Xt(t) {
+  const e = C(t);
+  for (const n of e) {
+    const r = W(n.inner);
+    if (r.length !== 1) continue;
+    const i = r[0];
+    if (i === "endblock" || i.startsWith("block ")) return !0;
+  }
+  return !1;
+}
+function X(t) {
+  return t.map((e) => e.body).join("");
+}
+function Jt(t, e, n) {
+  const r = [...e].sort((o, a) => o.start - a.start), i = [];
+  let s = 0;
+  for (const o of r)
+    i.push(t.slice(s, o.start)), i.push(n.get(o.name) ?? o.body), s = o.end;
+  return i.push(t.slice(s)), i.reduce((o, a) => L(o, a));
+}
+function Qt(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 en(t, e) {
+  const {
+    path: n,
+    context: r,
+    declarationUpdates: i,
+    loader: s,
+    root: o,
+    constrainToRoot: a,
+    visitStack: c,
+    warnings: h,
+    inComponent: l = !1
+  } = e, p = We(t);
+  if (p.length === 0) {
+    if (Xt(t))
+      throw d({
+        code: "parse_error",
+        path: n,
+        details: { message: "orphan block without extend" }
+      });
+    return { source: t, context: b(r, i) };
+  }
+  const g = C(t)[0];
+  if (!g)
+    return { source: t, context: b(r, i) };
+  if (!s)
+    throw new Error("loader is required when processing extend directives");
+  const w = W(g.inner);
+  if (!(w.length > 0 ? H(w[0]) : null))
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: { message: "extend must be the first hyogen block" }
+    });
+  if (p.length > 1)
+    throw d({
+      code: "parse_error",
+      path: n,
+      details: { message: "multiple extend directives are not supported" }
+    });
+  const A = Ce(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: X(A),
+      context: b(r, i)
+    };
+  const F = p[0].path, $ = n, v = J(
+    o,
+    F,
+    n,
+    n,
+    a,
+    !0
+  );
+  $ && c.push($);
+  try {
+    const E = $ ? c.check(v) : { circular: !1 };
+    if (E.circular)
+      return h?.push({
+        code: "circular_include",
+        message: O("circular_include", {
+          path: v,
+          from: E.from,
+          via: "extend"
+        }),
+        path: n,
+        details: { path: v, from: E.from, via: "extend" }
+      }), {
+        source: X(A),
+        context: b(r, i)
+      };
+    c.push(v);
+    try {
+      const T = await s(v);
+      if (T === void 0)
+        throw new Error("loader returned undefined");
+      const { context: Z, body: q } = U(
+        T,
+        v
+      ), ge = We(q);
+      if (ge.length > 0) {
+        const B = ge[0].path, P = J(
+          o,
+          B,
+          v,
+          v,
+          a,
+          !0
+        ), V = c.check(P);
+        if (V.circular)
+          return h?.push({
+            code: "circular_include",
+            message: O("circular_include", {
+              path: P,
+              from: V.from,
+              via: "extend"
+            }),
+            path: n,
+            details: { path: P, from: V.from, via: "extend" }
+          }), {
+            source: X(A),
+            context: b(r, i)
+          };
+        throw d({
+          code: "parse_error",
+          path: v,
+          details: { message: "layout extend is not supported" }
+        });
+      }
+      const Ie = Ce(q, {
+        path: v,
+        mode: "layout"
+      }), ze = new Map(
+        A.map((B) => [B.name, B.body])
+      ), Ue = Jt(
+        q,
+        Ie,
+        ze
+      ), Ze = b(
+        r,
+        Z,
+        i
+      );
+      return { source: Ue, context: Ze };
+    } finally {
+      c.pop();
+    }
+  } catch (E) {
+    const T = Qt(E);
+    throw T.adjusted ? T.errorToThrow : E;
+  } finally {
+    $ && c.pop();
+  }
+}
+const tn = ne.warningReasons, nn = [
+  {
+    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 rn(t) {
+  return tn[t] ?? t;
+}
+function ee(t, e, n, r) {
+  if (typeof t == "string") {
+    for (const i of nn)
+      i.test(t) && n.push({
+        code: "suspicious_context_value",
+        message: O("suspicious_context_value", {
+          key: e,
+          reason: rn(i.reason)
+        }),
+        path: r,
+        details: { key: e, reason: i.reason }
+      });
+    return;
+  }
+  if (t != null) {
+    if (Array.isArray(t)) {
+      for (let i = 0; i < t.length; i++)
+        ee(t[i], `${e}[${i}]`, n, r);
+      return;
+    }
+    if (typeof t == "object")
+      for (const [i, s] of Object.entries(
+        t
+      )) {
+        const o = e.length > 0 ? `${e}.${i}` : i;
+        ee(s, o, n, r);
+      }
+  }
+}
+function sn(t, e, n) {
+  for (const [r, i] of Object.entries(t))
+    ee(i, r, e, n);
+}
+async function me(t, e) {
+  const n = e.path, r = e.context, i = e.registry ?? new Ae(), s = e.warnings ?? [], o = e.visitStack ?? new Ne(), {
+    source: a,
+    declarationUpdates: c
+  } = await It(t, { path: n, context: { ...r } });
+  sn(
+    b(r, c ?? {}),
+    s,
+    n
+  );
+  const h = await en(a, {
+    path: n,
+    context: r,
+    declarationUpdates: c ?? {},
+    loader: e.loader,
+    root: e.root,
+    constrainToRoot: e.constrainToRoot,
+    visitStack: o,
+    warnings: s,
+    inComponent: e.inComponent ?? !1
+  }), { source: l, context: p } = h, { source: f, directives: g } = Pt(l, {
+    path: n,
+    registry: i,
+    context: p
+  }), w = e.loader;
+  if (g.length > 0 && !w)
+    throw new Error("loader is required when processing include directives");
+  let y = f;
+  return g.length > 0 && w && (y = await Nt({
+    source: f,
+    directives: g,
+    context: p,
+    loader: w,
+    root: e.root,
+    path: n,
+    preserveFrontMatter: e.preserveFrontMatter,
+    preserveHgComments: e.preserveHgComments,
+    visitStack: o,
+    warnings: s,
+    registry: i,
+    constrainToRoot: e.constrainToRoot
+  })), y = await Mt(y, {
+    context: p,
+    path: n,
+    registry: i,
+    loader: w,
+    rootDir: e.root,
+    warnings: s,
+    visitStack: o,
+    parentContext: p,
+    preserveHgComments: e.preserveHgComments,
+    constrainToRoot: e.constrainToRoot
+  }), y = await Re(y, p, {
+    path: n,
+    registry: i,
+    loader: w,
+    rootDir: e.root,
+    warnings: s,
+    visitStack: o,
+    parentContext: p,
+    preserveHgComments: e.preserveHgComments,
+    constrainToRoot: e.constrainToRoot
+  }), y = Kt(y, e.preserveHgComments), y;
+}
+async function Be(t, e = {}) {
+  const n = e.path, r = b(e.context), i = e.registry ?? new Ae(), s = e.warnings ?? [], o = e.visitStack ?? new Ne(), { context: a, body: c, rawFrontMatter: h } = U(
+    t,
+    n
+  ), l = b(r, a);
+  let p = await me(c, {
+    ...e,
+    context: l,
+    registry: i,
+    warnings: s,
+    visitStack: o
+  });
+  return p = Vt(p, {
+    preserveFrontMatter: e.preserveFrontMatter,
+    rawFrontMatter: h
+  }), {
+    markdown: p,
+    warnings: s
+  };
+}
+async function on(t, e) {
+  const n = e.path, { context: r, body: i } = U(t, n), s = b(e.context, r);
+  return me(i, {
+    ...e,
+    context: s,
+    preserveFrontMatter: !1
+  });
+}
+async function an(t, e, n) {
+  const r = b(e, n?.serverContext), i = n?.loader ?? $e(), s = await at(t, { root: n?.root });
+  return Be(s.source, {
+    context: r,
+    loader: i,
+    root: s.rootDir ?? n?.root,
+    path: s.entryPath ?? n?.path,
+    constrainToRoot: s.constrainToRoot,
+    preserveFrontMatter: n?.preserveFrontMatter,
+    preserveHgComments: n?.preserveHgComments
+  });
+}
+async function _n(t, e, n) {
+  if (n != null && "serverContext" in n && n.serverContext != null)
+    throw d({
+      code: "server_context_on_client"
+    });
+  const r = n?.loader;
+  if (!r)
+    throw d({
+      code: "parse_error",
+      details: { message: "loader is required for renderClient" }
+    });
+  let i, s;
+  typeof t == "string" ? i = t : (s = t.path, i = await r(t.path));
+  const o = b(e);
+  return Be(i, {
+    context: o,
+    loader: r,
+    root: n?.root,
+    path: s ?? n?.path,
+    preserveFrontMatter: n?.preserveFrontMatter,
+    preserveHgComments: n?.preserveHgComments,
+    constrainToRoot: n?.constrainToRoot
+  });
+}
+function cn(t, e) {
+  if (ae(t))
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: {
+        message: ce(t) ?? "unclosed hyogen block (missing closing marker)"
+      }
+    });
+  const n = [], r = C(t);
+  for (const i of r) {
+    const s = W(i.inner);
+    if (s.length === 0)
+      throw d({
+        code: "parse_error",
+        path: e,
+        details: { message: "empty hyogen block" }
+      });
+    if (s.length === 1 && he(s[0]) || s.length === 1 && (Q(s[0]) || I(s[0])))
+      continue;
+    const o = s[0];
+    if (o === "endblock" || /^block\s+/.test(o))
+      continue;
+    const a = H(o, e);
+    if (a) {
+      n.push({ kind: "extend", path: a.path });
+      continue;
+    }
+    if (s.length !== 1) {
+      const c = s.join(`
+`);
+      if (I(c) || s.every(
+        (l) => Q(l) || H(l) !== null
+      ))
+        continue;
+      throw d({
+        code: "parse_error",
+        path: e,
+        details: { message: "hyogen block must contain a single directive" }
+      });
+    }
+    if (/^include\s+/i.test(o)) {
+      const c = Fe(i.inner, e);
+      n.push({ kind: "include", path: c.path });
+      continue;
+    }
+    if (/^component\s+/i.test(o)) {
+      const c = je(i.inner, e);
+      n.push({ kind: "component", path: c.path });
+      continue;
+    }
+    throw d({
+      code: "parse_error",
+      path: e,
+      details: { message: `unsupported hyogen directive: ${o}` }
+    });
+  }
+  return n;
+}
+function hn(t, e, n) {
+  return j(t) ? t : re(t, {
+    rootDir: n.root,
+    fromPath: e,
+    documentPath: e,
+    constrainToRoot: n.constrainToRoot,
+    hyogenPath: !0
+  });
+}
+async function ln(t, e, n = {}) {
+  const r = t.map(
+    (l) => j(l) ? l : u.resolve(l)
+  ), i = new Set(r), s = /* @__PURE__ */ new Set(), o = [], a = [...r];
+  for (; a.length > 0; ) {
+    const l = a.shift();
+    if (s.has(l))
+      continue;
+    s.add(l);
+    const p = await e(l), f = cn(p, l);
+    for (const g of f) {
+      const w = hn(g.path, l, n);
+      o.push({ from: l, to: w, kind: g.kind }), s.has(w) || a.push(w);
+    }
+  }
+  const c = [...s], h = c.filter((l) => !i.has(l));
+  return {
+    entries: r,
+    dependencies: h,
+    nodes: c,
+    edges: o
+  };
+}
+function dn(t) {
+  return t.replace(/\\/g, "/").split("/").filter((r) => r.length > 0).some((r) => r.startsWith("_"));
+}
+function pn(t) {
+  return Ge.scan(t).isGlob;
+}
+function un(t) {
+  return t.root ? u.resolve(t.root) : t.cwd ? u.resolve(t.cwd) : z(process.cwd()) ?? process.cwd();
+}
+async function fn(t, e = {}) {
+  const n = Array.isArray(t) ? t : [t], r = un(e), i = e.includeUnderscoreEntries === !0, s = /* @__PURE__ */ new Map();
+  for (const o of n) {
+    if (!pn(o)) {
+      const c = u.isAbsolute(o) ? u.resolve(o) : u.resolve(r, o);
+      try {
+        if (!(await te(c)).isFile())
+          throw d({
+            code: "file_not_found",
+            path: c,
+            details: {
+              path: c,
+              from: c,
+              via: "include"
+            }
+          });
+      } catch (l) {
+        throw l instanceof Error && "code" in l && l.code === "file_not_found" ? l : l.code === "ENOENT" ? d({
+          code: "file_not_found",
+          path: c,
+          details: {
+            path: c,
+            from: c,
+            via: "include"
+          }
+        }) : l;
+      }
+      const h = u.relative(r, c).replace(/\\/g, "/");
+      s.set(h, c);
+      continue;
+    }
+    const a = await Ye(o, {
+      cwd: r,
+      absolute: !0,
+      onlyFiles: !0,
+      dot: !1
+    });
+    for (const c of a) {
+      const h = u.relative(r, c).replace(/\\/g, "/");
+      !i && dn(h) || s.set(h, u.resolve(c));
+    }
+  }
+  return [...s.values()];
+}
+function mn(t) {
+  return t instanceof Error && t.name === "HyogenError" && "code" in t && typeof t.code == "string";
+}
+function gn(t, e) {
+  if (t)
+    return u.resolve(t);
+  for (const n of e) {
+    const r = z(n);
+    if (r)
+      return r;
+  }
+  return e.length > 0 ? u.dirname(u.resolve(e[0])) : process.cwd();
+}
+async function Sn(t) {
+  const e = await fn(t.input, {
+    root: t.root,
+    includeUnderscoreEntries: t.includeUnderscoreEntries
+  }), n = gn(t.root, e), r = t.loader ?? $e(), i = z(n) !== void 0;
+  e.length > 0 && await ln(e, r, {
+    root: n,
+    constrainToRoot: i
+  });
+  const s = [], o = [];
+  for (const a of e) {
+    const c = u.resolve(a), h = u.relative(n, c).replace(/\\/g, "/"), l = await an(
+      { path: c },
+      t.context,
+      {
+        loader: r,
+        root: n,
+        serverContext: t.serverContext,
+        preserveFrontMatter: t.preserveFrontMatter,
+        preserveHgComments: t.preserveHgComments
+      }
+    ), p = u.join(t.outDir, h);
+    try {
+      await qe(u.dirname(p), { recursive: !0 }), await Pe(p, l.markdown, "utf8");
+    } catch (f) {
+      if (mn(f))
+        throw f;
+      const g = f instanceof Error ? f.message : "unknown write error";
+      throw d({
+        code: "load_failed",
+        path: p,
+        details: {
+          path: p,
+          reason: g
+        }
+      });
+    }
+    s.push({ path: h, markdown: l.markdown }), o.push(...l.warnings);
+  }
+  return { files: s, warnings: o };
+}
+function Cn(t, e) {
+  const n = [`[hyogen:${t}] ${e.code}`], r = {};
+  if (e.details)
+    for (const [i, s] of Object.entries(e.details))
+      s !== void 0 && (r[i] = s);
+  r.path === void 0 && e.path !== void 0 && (r.path = e.path);
+  for (const [i, s] of Object.entries(r))
+    n.push(`  ${i}: ${String(s)}`);
+  return n.join(`
+`);
+}
+export {
+  Sn as build,
+  it as createFsLoader,
+  d as createHyogenError,
+  $e as createNodeLoader,
+  Cn as formatDiagnosticLog,
+  nt as formatMessage,
+  j as isRemotePath,
+  _n as renderClient,
+  an as renderServer
+};
+//# sourceMappingURL=index.js.map