@threadlabs/looma 0.2.20 → 0.3.1

package/dist/chunk-XDNZIKNI.js

@@ -0,0 +1,2721 @@
+// src/declarative/runtime.js
+var HtmlRuntime = (() => {
+  var Me = Object.defineProperty;
+  var ln = Object.getOwnPropertyDescriptor;
+  var un = Object.getOwnPropertyNames;
+  var fn = Object.prototype.hasOwnProperty;
+  var pn = (e, t) => {
+    for (var n in t) Me(e, n, { get: t[n], enumerable: true });
+  }, mn = (e, t, n, r) => {
+    if (t && typeof t == "object" || typeof t == "function") for (let i of un(t)) !fn.call(e, i) && i !== n && Me(e, i, { get: () => t[i], enumerable: !(r = ln(t, i)) || r.enumerable });
+    return e;
+  };
+  var hn = (e) => mn(Me({}, "__esModule", { value: true }), e);
+  var Ur = {};
+  pn(Ur, { attachComponent: () => ot, attachRegisteredComponent: () => _r, getComponentHost: () => at, inspectInstance: () => Pr, installComponentGraph: () => lr, lowerDocument: () => Or, manageComponentLifecycle: () => Vr, observeDocument: () => qr, registerComponentDefinitions: () => zr, serializeRenderedForm: () => Dr, setControllerModule: () => dn, updateComponentProps: () => cn });
+  var De = class extends Error {
+    diagnostic;
+    constructor(t) {
+      let n = t.source ? `${t.source}: ` : "";
+      super(`${n}${t.code}: ${t.message}`), this.name = "HtmlDiagnosticError", this.diagnostic = Object.freeze({ ...t });
+    }
+  };
+  function y(e, t, n) {
+    throw new De(n === void 0 ? { code: e, message: t } : { code: e, message: t, source: n });
+  }
+  function Q(e) {
+    if (typeof e != "object" || e === null || Object.isFrozen(e)) return e;
+    for (let t of Object.values(e)) Q(t);
+    return Object.freeze(e);
+  }
+  function lt(e) {
+    let t = "", n = true;
+    for (let r of e) r === "-" ? n = true : (t += n ? r.toUpperCase() : r, n = false);
+    return t;
+  }
+  function Y(e) {
+    return e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  }
+  var yn = /* @__PURE__ */ new Set(["string", "boolean", "number", "integer", "null", "absent", "trusted-html", "trusted-script", "function", "unknown"]), ye = class extends SyntaxError {
+    constructor(n, r) {
+      super(`${n} at character ${r + 1}.`);
+      this.position = r;
+      this.name = "TypeSyntaxError";
+    }
+    position;
+  }, je = class {
+    constructor(t) {
+      this.source = t;
+    }
+    source;
+    #e = 0;
+    parse() {
+      let t = this.#n();
+      return this.#d(), this.#e !== this.source.length && this.#l("Unexpected type syntax"), t;
+    }
+    #n() {
+      let t = [this.#t()];
+      for (; this.#s("|"); ) t.push(this.#t());
+      return t.length === 1 ? t[0] : Le(t);
+    }
+    #t() {
+      let t = this.#i();
+      for (; this.#s("?"); ) t = Le([t, { kind: "terminal", name: "null" }, { kind: "terminal", name: "absent" }]);
+      return t;
+    }
+    #i() {
+      if (this.#s("(")) {
+        let r = this.#n();
+        return this.#a(")"), r;
+      }
+      let t = this.#c();
+      if (t !== void 0) return { kind: "keyword", value: t };
+      let n = this.#r();
+      if (n === void 0 && this.#l("Expected a type, keyword, or group"), n === "list" || n === "record") {
+        this.#a("(");
+        let r = this.#n();
+        return this.#a(")"), n === "list" ? { kind: "list", item: r } : { kind: "record", value: r };
+      }
+      return n === "object" ? this.#o() : yn.has(n) ? { kind: "terminal", name: n } : { kind: "keyword", value: n };
+    }
+    #o() {
+      this.#a("("), this.#a("{");
+      let t = [], n = false;
+      for (; !this.#s("}"); ) {
+        if (this.#d(), this.source.startsWith("...", this.#e)) this.#e += 3, n = true;
+        else {
+          let r = this.#c() ?? this.#r();
+          r === void 0 && this.#l("Expected an object field or `...`");
+          let i = this.#s("?");
+          this.#a(":");
+          let o = this.#n();
+          t.some((a) => a.name === r) && this.#l(`Duplicate object field \`${r}\``), t.push({ name: r, type: o, optional: i });
+        }
+        if (this.#s("}")) break;
+        this.#a(","), n && (this.#d(), this.source.startsWith("}", this.#e) || this.#l("The open marker must be last"));
+      }
+      return this.#a(")"), { kind: "object", fields: t, open: n };
+    }
+    #r() {
+      this.#d();
+      let t = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(this.source.slice(this.#e));
+      if (t !== null) return this.#e += t[0].length, t[0];
+    }
+    #c() {
+      this.#d();
+      let t = this.source[this.#e];
+      if (t !== '"' && t !== "'") return;
+      this.#e += 1;
+      let n = "";
+      for (; this.#e < this.source.length; ) {
+        let r = this.source[this.#e++];
+        if (r === t) return n;
+        if (r !== "\\") {
+          n += r;
+          continue;
+        }
+        this.#e >= this.source.length && this.#l("Unterminated escape");
+        let i = this.source[this.#e++];
+        n += { n: `
+`, r: "\r", t: "	", "\\": "\\", '"': '"', "'": "'" }[i] ?? i;
+      }
+      this.#l("Unterminated quoted keyword");
+    }
+    #s(t) {
+      return this.#d(), this.source.startsWith(t, this.#e) ? (this.#e += t.length, true) : false;
+    }
+    #a(t) {
+      this.#s(t) || this.#l(`Expected \`${t}\``);
+    }
+    #d() {
+      for (; /\s/.test(this.source[this.#e] ?? ""); ) this.#e += 1;
+    }
+    #l(t) {
+      throw new ye(t, this.#e);
+    }
+  };
+  function Le(e) {
+    let t = e.flatMap((i) => i.kind === "union" ? i.members : [i]), n = new Map(t.map((i) => [W(i), i])), r = Array.from(n.values());
+    return r.length === 1 ? r[0] : { kind: "union", members: r };
+  }
+  function ge(e) {
+    if (e.trim() === "") throw new ye("A type expression cannot be empty", 0);
+    return Q(new je(e).parse());
+  }
+  function Oe(e) {
+    return typeof e == "object" && e !== null && "kind" in e && ["terminal", "keyword", "union", "list", "record", "object"].includes(String(e.kind));
+  }
+  function be(e) {
+    return Oe(e) ? e : typeof e == "string" ? { kind: "terminal", name: e } : Le(e.enum.map((t) => ({ kind: "keyword", value: t })));
+  }
+  function W(e) {
+    let t = Oe(e) ? e : be(e);
+    switch (t.kind) {
+      case "terminal":
+        return t.name;
+      case "keyword":
+        return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(t.value) ? t.value : JSON.stringify(t.value);
+      case "union":
+        return t.members.map((n) => W(n)).join(" | ");
+      case "list":
+        return `list(${W(t.item)})`;
+      case "record":
+        return `record(${W(t.value)})`;
+      case "object":
+        return `object({ ${[...t.fields.map((n) => `${n.name}${n.optional ? "?" : ""}: ${W(n.type)}`), ...t.open ? ["..."] : []].join(", ")} })`;
+    }
+  }
+  function P(e, t, n) {
+    return { ok: false, issues: [{ reason: e, message: t, path: n }] };
+  }
+  function X(e, t) {
+    return typeof t == "number" ? `${e}[${t}]` : /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(t) ? `${e}.${t}` : `${e}[${JSON.stringify(t)}]`;
+  }
+  function ut(e) {
+    if (typeof e != "object" || e === null || Array.isArray(e)) return false;
+    let t = Object.getPrototypeOf(e);
+    return t === Object.prototype || t === null;
+  }
+  function Pe(e) {
+    if (typeof e != "string") return e;
+    try {
+      return JSON.parse(e);
+    } catch {
+      return /* @__PURE__ */ Symbol.for("html-next.bad-json");
+    }
+  }
+  function gn(e, t) {
+    if (typeof e != "object" || e === null) return false;
+    if (e.kind === t && "value" in e) return true;
+    let n = t === "trusted-html" ? "TrustedHTML" : "TrustedScript";
+    return e.constructor?.name === n || Object.prototype.toString.call(e) === `[object ${n}]`;
+  }
+  function bn(e, t, n) {
+    switch (t) {
+      case "string":
+        return typeof e == "string" ? { ok: true, value: e } : P("typeMismatch", "Must be a string.", n);
+      case "boolean":
+        return typeof e == "boolean" ? { ok: true, value: e } : e === "" || e === "true" ? { ok: true, value: true } : e === "false" ? { ok: true, value: false } : P("typeMismatch", "Must be true or false.", n);
+      case "number":
+      case "integer": {
+        let r = typeof e == "number" ? e : typeof e == "string" && e.trim() !== "" ? Number(e) : Number.NaN;
+        return Number.isFinite(r) ? t === "integer" && !Number.isInteger(r) ? P("typeMismatch", "Must be an integer.", n) : { ok: true, value: r } : P("badInput", `Must be ${t === "integer" ? "an integer" : "a finite number"}.`, n);
+      }
+      case "null":
+        return e === null ? { ok: true, value: null } : P("typeMismatch", "Must be null.", n);
+      case "absent":
+        return e === void 0 ? { ok: true, value: void 0 } : P("typeMismatch", "Must be absent.", n);
+      case "trusted-html":
+      case "trusted-script":
+        return gn(e, t) ? { ok: true, value: e } : P("untrustedValue", `Must be a ${t === "trusted-html" ? "TrustedHTML" : "TrustedScript"} value.`, n);
+      case "function":
+        return typeof e == "function" ? { ok: true, value: e } : P("typeMismatch", "Must be a function supplied through a property.", n);
+      case "unknown":
+        return { ok: true, value: e };
+    }
+  }
+  function ee(e, t, n) {
+    switch (t.kind) {
+      case "terminal":
+        return bn(e, t.name, n);
+      case "keyword":
+        return e === t.value ? { ok: true, value: e } : P("typeMismatch", `Must be ${JSON.stringify(t.value)}.`, n);
+      case "union": {
+        for (let r of t.members) {
+          let i = ee(e, r, n);
+          if (i.ok) return i;
+        }
+        return P("typeMismatch", `Must match ${W(t)}.`, n);
+      }
+      case "list": {
+        let r = Pe(e);
+        if (!Array.isArray(r)) return P("typeMismatch", "Must be a list.", n);
+        let i = [], o = [];
+        return r.forEach((a, s) => {
+          let c = ee(a, t.item, X(n, s));
+          c.ok ? i.push(c.value) : o.push(...c.issues);
+        }), o.length === 0 ? { ok: true, value: i } : { ok: false, issues: o };
+      }
+      case "record": {
+        let r = Pe(e);
+        if (!ut(r)) return P("typeMismatch", "Must be a string-keyed record.", n);
+        let i = {}, o = [];
+        for (let [a, s] of Object.entries(r)) {
+          let c = ee(s, t.value, X(n, a));
+          c.ok ? i[a] = c.value : o.push(...c.issues);
+        }
+        return o.length === 0 ? { ok: true, value: i } : { ok: false, issues: o };
+      }
+      case "object": {
+        let r = Pe(e);
+        if (!ut(r)) return P("typeMismatch", "Must be an object.", n);
+        let i = {}, o = [], a = new Map(t.fields.map((s) => [s.name, s]));
+        for (let s of t.fields) {
+          if (!(s.name in r)) {
+            s.optional || o.push({ reason: "typeMismatch", message: "Required field is absent.", path: X(n, s.name) });
+            continue;
+          }
+          let c = ee(r[s.name], s.type, X(n, s.name));
+          c.ok ? i[s.name] = c.value : o.push(...c.issues);
+        }
+        for (let [s, c] of Object.entries(r)) a.has(s) || (t.open ? i[s] = c : o.push({ reason: "typeMismatch", message: "Field is not declared by this closed object type.", path: X(n, s) }));
+        return o.length === 0 ? { ok: true, value: i } : { ok: false, issues: o };
+      }
+    }
+  }
+  function B(e, t, n = "$") {
+    return ee(e, be(t), n);
+  }
+  function te(e, t) {
+    let n = B(e, t);
+    if (!n.ok) throw new TypeError(n.issues.map((i) => `${i.path}: ${i.message}`).join("; "));
+    let r = be(t);
+    if (r.kind === "terminal" && (r.name === "function" || r.name === "unknown")) throw new TypeError(`The ${r.name} type is property-only and cannot be serialized.`);
+    return r.kind === "list" || r.kind === "record" || r.kind === "object" || r.kind === "union" && typeof n.value == "object" && n.value !== null ? JSON.stringify(n.value) : n.value === null ? "null" : n.value === void 0 ? "" : String(n.value);
+  }
+  function F(e) {
+    let t = be(e);
+    return t.kind === "terminal" ? !["function", "unknown", "trusted-html", "trusted-script"].includes(t.name) : t.kind === "keyword" ? true : t.kind === "union" ? t.members.every(F) : t.kind === "list" ? F(t.item) : t.kind === "record" ? F(t.value) : t.fields.every((n) => F(n.type));
+  }
+  function ft(e) {
+    let t;
+    try {
+      t = ge(e);
+    } catch (n) {
+      y("HC013", n instanceof Error ? n.message : "Invalid prop type expression.");
+    }
+    return t.kind === "terminal" && (t.name === "string" || t.name === "boolean" || t.name === "number") ? t.name : t.kind === "keyword" ? { enum: [t.value] } : t.kind === "union" && t.members.every((n) => n.kind === "keyword") ? { enum: t.members.map((n) => n.value) } : t;
+  }
+  var T = /* @__PURE__ */ Symbol("absent"), re = class extends Error {
+    constructor(n) {
+      super(`\`${n}\` is not declared in scope.`);
+      this.identifier = n;
+      this.name = "UndeclaredName";
+    }
+    identifier;
+  }, Ie = /\s*(?:(<=|>=|!=|\^=|\$=|\*=)|(\d+(?:\.\d*)?|\.\d+)|("(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*')|([A-Za-z_$][A-Za-z0-9_$]*)|([=<>+*/%(),.:{}[\]-])|$)/y, vn = /\\([\s\S])/g, kn = /%s/g, wn = { or: 1, and: 2, "=": 3, "!=": 3, "^=": 3, "$=": 3, "*=": 3, "<": 4, "<=": 4, ">": 4, ">=": 4, "+": 5, "-": 5, "*": 6, "/": 6, "%": 6 };
+  function pt(e) {
+    return wn[e] ?? 0;
+  }
+  function xn(e) {
+    return e === "round" || e === "clamp" || e === "min" || e === "max" || e === "abs" || e === "format";
+  }
+  function En(e) {
+    let t = 0, n = 0, r = "";
+    function i() {
+      Ie.lastIndex = t;
+      let l = Ie.exec(e);
+      if (l === null) {
+        let m = e.slice(t).trimStart()[0];
+        throw m === '"' || m === "'" ? new SyntaxError("Unterminated string literal.") : new SyntaxError(`Unexpected character \`${m}\`.`);
+      }
+      t = Ie.lastIndex, l[1] !== void 0 || l[5] !== void 0 ? (n = 4, r = l[1] ?? l[5]) : l[2] !== void 0 ? (n = 1, r = Number(l[2])) : l[3] !== void 0 ? (n = 2, r = l[3].slice(1, -1).replace(vn, "$1")) : l[4] !== void 0 ? (n = 3, r = l[4]) : (n = 0, r = "");
+    }
+    function o(l) {
+      return r !== l ? false : (i(), true);
+    }
+    function a(l) {
+      if (!o(l)) throw new SyntaxError(`Expected \`${l}\`.`);
+    }
+    function s(l) {
+      let m = c(), f = pt(r);
+      for (; f >= l; ) {
+        let h = r;
+        i(), m = { kind: "binary", op: h, left: m, right: s(f + 1) }, f = pt(r);
+      }
+      return m;
+    }
+    function c() {
+      if (n === 3 && r === "not") return i(), { kind: "unary", op: "not", operand: c() };
+      if (o("-")) return { kind: "unary", op: "-", operand: c() };
+      let l = d();
+      for (; n === 4; ) if (o(".")) {
+        if (n !== 3) throw new SyntaxError("Expected a property name after `.`.");
+        let m = r;
+        i(), l = { kind: "member", object: l, key: m };
+      } else if (o("[")) {
+        let m = s(1);
+        a("]"), l = { kind: "index", object: l, index: m };
+      } else break;
+      return l;
+    }
+    function d() {
+      let l = n, m = r;
+      if (l === 1 || l === 2) return i(), { kind: "literal", value: m };
+      if (l === 4 && m === "(") {
+        i();
+        let f = s(1);
+        return a(")"), f;
+      }
+      if (l === 4 && m === "{") {
+        i();
+        let f = [];
+        if (!o("}")) {
+          do {
+            if (r === "}") break;
+            if (n !== 3 && n !== 2) throw new SyntaxError("Object keys must be identifiers or strings.");
+            let h = r;
+            i(), a(":"), f.push({ key: h, value: s(1) });
+          } while (o(","));
+          a("}");
+        }
+        return { kind: "object", pairs: f };
+      }
+      if (l === 4 && m === "[") {
+        i();
+        let f = [];
+        if (!o("]")) {
+          do {
+            if (r === "]") break;
+            f.push(s(1));
+          } while (o(","));
+          a("]");
+        }
+        return { kind: "array", items: f };
+      }
+      if (l === 3) {
+        let f = m;
+        if (i(), f === "true") return { kind: "literal", value: true };
+        if (f === "false") return { kind: "literal", value: false };
+        if (f === "null") return { kind: "literal", value: null };
+        if (r === "(" && xn(f)) {
+          i();
+          let h = [];
+          if (!o(")")) {
+            do
+              h.push(s(1));
+            while (o(","));
+            a(")");
+          }
+          return { kind: "call", fn: f, args: h };
+        }
+        return { kind: "id", name: f };
+      }
+      throw new SyntaxError("Unexpected end of expression.");
+    }
+    i();
+    let u = s(1);
+    if (n !== 0) throw new SyntaxError("Unexpected trailing input in expression.");
+    return u;
+  }
+  function ne(e) {
+    return e === T || e === null;
+  }
+  function j(e) {
+    if (e === T || e === null || e === false) return false;
+    if (e === true) return true;
+    if (typeof e == "string") return e.length > 0;
+    if (typeof e == "number") return e !== 0 && e === e;
+    if (Array.isArray(e)) return e.length > 0;
+    for (let t in e) if (Object.hasOwn(e, t)) return true;
+    return false;
+  }
+  function ve(e) {
+    return typeof e == "number" && e === e ? e : T;
+  }
+  function A(e, t) {
+    switch (e.kind) {
+      case "literal":
+        return e.value;
+      case "id": {
+        let n = t.get(e.name);
+        if (n === void 0) throw new re(e.name);
+        return n;
+      }
+      case "member": {
+        let n = A(e.object, t);
+        if (ne(n) || typeof n != "object" || Array.isArray(n)) return T;
+        let r = n[e.key];
+        return r === void 0 ? T : r;
+      }
+      case "index": {
+        let n = A(e.object, t), r = A(e.index, t);
+        if (ne(n) || ne(r)) return T;
+        if (Array.isArray(n) && typeof r == "number") {
+          let i = n[r];
+          return i === void 0 ? T : i;
+        }
+        if (typeof n == "object" && typeof r == "string") {
+          let i = n[r];
+          return i === void 0 ? T : i;
+        }
+        return T;
+      }
+      case "unary": {
+        let n = A(e.operand, t);
+        if (e.op === "not") return !j(n);
+        let r = ve(n);
+        return r === T ? T : -r;
+      }
+      case "binary":
+        return Tn(e, t);
+      case "call":
+        return Cn(e, t);
+      case "object": {
+        let n = {};
+        for (let r of e.pairs) n[r.key] = A(r.value, t);
+        return n;
+      }
+      case "array": {
+        let n = [];
+        for (let r of e.items) n.push(A(r, t));
+        return n;
+      }
+    }
+  }
+  function Tn(e, t) {
+    let { op: n } = e;
+    if (n === "and") return j(A(e.left, t)) && j(A(e.right, t));
+    if (n === "or") return j(A(e.left, t)) || j(A(e.right, t));
+    let r = A(e.left, t), i = A(e.right, t);
+    if (n === "=") return r === i;
+    if (n === "!=") return r !== i;
+    if (n === "^=" || n === "$=" || n === "*=") return typeof r != "string" || typeof i != "string" ? T : n === "^=" ? r.startsWith(i) : n === "$=" ? r.endsWith(i) : r.includes(i);
+    let o = ve(r), a = ve(i);
+    if (o === T || a === T) return T;
+    switch (n) {
+      case "<":
+        return o < a;
+      case "<=":
+        return o <= a;
+      case ">":
+        return o > a;
+      case ">=":
+        return o >= a;
+      case "+":
+        return o + a;
+      case "-":
+        return o - a;
+      case "*":
+        return o * a;
+      case "/":
+        return o / a;
+      case "%":
+        return o % a;
+      default:
+        return T;
+    }
+  }
+  function Cn(e, t) {
+    let { args: n, fn: r } = e, i = [];
+    for (let a of n) i.push(A(a, t));
+    if (r === "format") {
+      let a = i[0];
+      if (typeof a != "string") return T;
+      let s = 1;
+      return a.replace(kn, () => s < i.length ? D(i[s++]) : "%s");
+    }
+    for (let a = 0; a < i.length; a += 1) {
+      let s = ve(i[a]);
+      if (s === T) return T;
+      i[a] = s;
+    }
+    let o = i;
+    switch (r) {
+      case "abs":
+        return o.length === 1 ? Math.abs(o[0]) : T;
+      case "round":
+        return o.length === 1 ? Math.round(o[0]) : T;
+      case "min":
+        return o.length > 0 ? Math.min(...o) : T;
+      case "max":
+        return o.length > 0 ? Math.max(...o) : T;
+      case "clamp":
+        return o.length === 3 ? Math.min(Math.max(o[0], o[1]), o[2]) : T;
+      default:
+        return T;
+    }
+  }
+  var mt = /* @__PURE__ */ new Map();
+  function Ve(e) {
+    if (e.kind === "id") return e.name;
+    if (e.kind === "member") {
+      let t = Ve(e.object);
+      return t === void 0 ? void 0 : `${t}.${e.key}`;
+    }
+    if (e.kind === "index" && e.index.kind === "literal") {
+      let t = e.index.value;
+      if (typeof t != "string" && typeof t != "number") return;
+      let n = Ve(e.object);
+      return n === void 0 ? void 0 : `${n}.${t}`;
+    }
+  }
+  function I(e, t) {
+    let n = Ve(e);
+    if (n !== void 0) {
+      t.includes(n) || t.push(n);
+      return;
+    }
+    switch (e.kind) {
+      case "literal":
+        return;
+      case "id":
+        return;
+      case "member":
+        I(e.object, t);
+        return;
+      case "index":
+        I(e.object, t), I(e.index, t);
+        return;
+      case "unary":
+        I(e.operand, t);
+        return;
+      case "binary":
+        I(e.left, t), I(e.right, t);
+        return;
+      case "call":
+        for (let r of e.args) I(r, t);
+        return;
+      case "object":
+        for (let r of e.pairs) I(r.value, t);
+        return;
+      case "array":
+        for (let r of e.items) I(r, t);
+    }
+  }
+  function ze(e, t) {
+    if (e.kind === "id") return t.push(e.name), true;
+    if (e.kind === "member") return ze(e.object, t) ? (t.push(e.key), true) : false;
+    if (e.kind !== "index" || !ze(e.object, t)) return false;
+    let n = e.index, r = n.kind === "literal" ? n.value : void 0;
+    return t.push(typeof r == "string" || typeof r == "number" ? r : { kind: "index", expression: n }), true;
+  }
+  function ke(e) {
+    let t = mt.get(e);
+    if (t !== void 0) return t;
+    let n = En(e), r = [];
+    return I(n, r), r.sort(), t = { source: e, ast: n, dependencies: r }, mt.set(e, t), t;
+  }
+  function _e(e, t) {
+    let n = [];
+    if (!(!ze(ke(e).ast, n) || !t.has(n[0]))) return n;
+  }
+  function ht(e, t) {
+    return A(ke(e).ast, t);
+  }
+  function V(e, t) {
+    return A("ast" in e ? e.ast : e, t);
+  }
+  function D(e) {
+    return ne(e) ? "" : Array.isArray(e) ? e.map(D).join(" ") : typeof e == "object" ? "" : String(e);
+  }
+  function yt(e) {
+    return ne(e) || e === false ? null : e === true ? "" : typeof e == "number" || typeof e == "string" ? String(e) : Array.isArray(e) ? e.map(D).join(" ") : null;
+  }
+  var Rn = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "poster", "data", "xlink:href"]), Sn = /* @__PURE__ */ new Set(["base", "embed", "iframe", "link", "meta", "object", "script", "style", "template"]), Nn = /* @__PURE__ */ new Set(["srcdoc", "style"]);
+  function ie(e) {
+    let t = e.replace(/[\u0000-\u0020\u007f]+/g, "");
+    return /^(?:data|javascript|vbscript):/i.test(t);
+  }
+  function oe(e) {
+    return Rn.has(e.toLowerCase());
+  }
+  function qe(e, t, n) {
+    let r = t.createElement("template");
+    r.innerHTML = e;
+    for (let i of Array.from(r.content.querySelectorAll("*"))) {
+      if (n?.(i), Sn.has(i.localName)) {
+        i.remove();
+        continue;
+      }
+      for (let o of Array.from(i.attributes)) {
+        let a = o.name.toLowerCase();
+        (a.startsWith("on") || Nn.has(a) || oe(a) && ie(o.value)) && i.removeAttribute(o.name);
+      }
+    }
+    return r.content;
+  }
+  var $n = /^(?:if|else-if|else|for|with|value|state|computed|data)$/, An = /^(?:@|v-|#|on:|use:|transition:|animate:)/, Hn = /^(?:innerhtml|outerhtml|srcdoc)$/, Mn = /^(?:base|embed|link|meta|object|script|style)$/;
+  function gt(e) {
+    return $n.test(e);
+  }
+  function Ue(e, t) {
+    return Mn.test(e.toLowerCase()) && y("HT009", `<${e}> is not permitted in rendered component markup.`, t), e;
+  }
+  function We(e, t, n = "") {
+    let r = e.toLowerCase();
+    return (r.startsWith("on") || An.test(r)) && y("HT010", `Literal attribute \`${e}\` uses target-framework directive syntax that is not supported.`, t), r === "srcdoc" && y("HT007", "Literal `srcdoc` is not permitted in a component definition.", t), oe(r) && ie(n) && y("HT007", `Literal \`${e}\` contains an executable URL.`, t), e;
+  }
+  function bt(e, t) {
+    let n = e.toLowerCase();
+    return (n.startsWith("on") || Hn.test(n)) && y("HT007", `Dynamic ${e} requires a future trusted-content type.`, t), e;
+  }
+  function z(e) {
+    return "tagName" in e;
+  }
+  function se(e) {
+    return e.nodeName === "#text";
+  }
+  function S(e) {
+    return "localName" in e ? e.localName : e.tagName;
+  }
+  function we(e) {
+    return "attrs" in e ? e.attrs : e.attributes;
+  }
+  function _(e) {
+    return (S(e) === "template" ? e.content : void 0)?.childNodes ?? e.childNodes;
+  }
+  function ae(e) {
+    return "value" in e ? e.value : "nodeValue" in e ? e.nodeValue ?? "" : "";
+  }
+  function wt(e) {
+    let t = [];
+    for (let n of e) n.nodeName !== "#comment" && (!se(n) || ae(n).trim() !== "") && t.push(n);
+    return t;
+  }
+  function w(e, t) {
+    return "attrs" in e ? e.attrs.find((n) => n.name === t)?.value : e.getAttribute(t) ?? void 0;
+  }
+  function xt(e) {
+    let t = "";
+    for (let n of _(e)) se(n) && (t += ae(n));
+    return t;
+  }
+  function Et(e, t) {
+    let n = [];
+    for (let r of _(e)) z(r) && S(r) === t && n.push(r);
+    return n;
+  }
+  function Tt(e, t) {
+    for (let n of _(e)) {
+      if (!z(n)) continue;
+      let r = S(n);
+      r === "link" && y("HL001", "External definition dependencies require the application-owned graph resolver.", t), Ue(r, t);
+      for (let i of we(n)) /^on(?!:)/i.test(i.name) && We(i.name, t, i.value);
+      Tt(n, t);
+    }
+  }
+  var Dn = /^\$(?:if|each|where|sort|limit|key|with|match|when|else)$/, vt = /^(?:innerhtml|outerhtml|textcontent|innertext|srcdoc)$/, Pn = /^\s*([A-Za-z_$][\w$]*)\s*(?:,\s*([A-Za-z_$][\w$]*)\s*)?\bof\b\s*(.+)$/, kt = /^\s*(.+?)\s+\bas\b\s+([A-Za-z_$][\w$]*)\s*$/, Fe = /^[a-z][a-z0-9-]*$/, jn = /^(?:prevent|stop|self|once|passive|capture|left|middle|right|ctrl|shift|alt|meta|exact|enter|escape|space|tab|up|down)$/, Ke = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
+  function Be(e, ...t) {
+    let n = new Set(e.roots);
+    for (let r of t) r !== void 0 && n.add(r);
+    return { roots: n, writableRoots: e.writableRoots, handlers: e.handlers };
+  }
+  function R(e, t, n) {
+    let r = zn(e, n);
+    return Ln(r, t, n), r;
+  }
+  function Ln(e, t, n) {
+    for (let r of e.dependencies) {
+      let i = r.split(".", 1)[0];
+      t.roots.has(i) || y("HT003", `Expression root \`${i}\` is not declared in this scope.`, n);
+    }
+  }
+  function On(e, t, n) {
+    let r = /* @__PURE__ */ Object.create(null), i = (a, s) => {
+      let c = r[a];
+      c !== void 0 && ("attribute" in c ? !("attribute" in s) || c.attribute !== s.attribute : !("property" in s) || c.property !== s.property) && y("HT004", `Prop \`${a}\` is bound to conflicting targets.`, t), r[a] = s;
+    }, o = (a) => {
+      for (let s of we(a)) if (s.name.startsWith(":")) /^[A-Za-z][A-Za-z0-9_-]*$/.test(s.value) && i(s.value, { attribute: s.name.slice(1).toLowerCase() });
+      else if (s.name.startsWith(".")) {
+        let c = s.name.slice(1).toLowerCase();
+        if (/^[A-Za-z][A-Za-z0-9_-]*$/.test(s.value)) {
+          let d = n.resolveDomProperty(S(a), c) ?? (s.value.toLowerCase() === c ? s.value : c);
+          i(s.value, { property: d });
+        }
+      }
+      for (let s of _(a)) z(s) && S(s) !== "slot" && o(s);
+    };
+    return o(e), r;
+  }
+  function In(e, t, n, r = true) {
+    let i = /* @__PURE__ */ Object.create(null), o = /* @__PURE__ */ Object.create(null);
+    if (e === void 0) return i;
+    let a = Et(e, "prop");
+    a.sort((s, c) => {
+      let d = w(s, "name") ?? "", u = w(c, "name") ?? "";
+      return d < u ? -1 : d > u ? 1 : 0;
+    });
+    for (let s of a) {
+      let c = w(s, "name");
+      (c === void 0 || c === "") && y("HC010", "A <prop> requires a `name` attribute.", n), /^[A-Za-z][A-Za-z0-9_-]*$/.test(c) || y("HC010", `Invalid prop name \`${c}\`.`, n);
+      let d = w(s, "type");
+      (d === void 0 || d === "") && y("HC013", `Prop \`${c}\` requires a \`type\` attribute.`, n);
+      let u = c.toLowerCase(), l = o[u];
+      l !== void 0 && y("HC011", `Props \`${l}\` and \`${c}\` collide after lowercase normalization.`, n), o[u] = c;
+      let m = t[c];
+      m === void 0 && r && y("HC018", `Prop \`${c}\` is declared but never bound in the markup.`, n), m ??= { attribute: c.toLowerCase() };
+      let f = ft(d), h = w(s, "required") !== void 0, p = xt(s).trim();
+      p === "" && y("HC003", `\`props.${c}.description\` must be a non-empty string.`, n), F(f) || y("HC017", `Prop \`${c}\` cannot be written as an HTML attribute; function, unknown, and trusted content types have no text form.`, n);
+      let b = w(s, "default");
+      h && b !== void 0 && y("HC019", `Required prop \`${c}\` cannot also declare a default.`, n);
+      let x = { type: f, required: h, target: m, description: p };
+      if (b !== void 0) {
+        let E = B(b, f);
+        E.ok || y("HC015", `Default for prop \`${c}\` does not satisfy its type.`, n), x.default = E.value;
+      }
+      i[c] = x;
+    }
+    return i;
+  }
+  function Vn(e, t, n, r, i, o, a) {
+    let s = w(e, "component") ?? "";
+    s.trim() === "" && y("HC003", "`component` must be a non-empty string.", o), /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/.test(s) || y("HC005", "The `component` tag must be lowercase and contain a hyphen.", o);
+    let c = w(e, "status") ?? "";
+    /^(?:early|experimental|stable|deprecated)$/.test(c) || y("HC007", "Component `status` is not recognized.", o);
+    let d = w(e, "summary") ?? "";
+    return d.trim() === "" && y("HC003", "`summary` must be a non-empty string.", o), (!/^[a-z][a-z0-9-]*$/.test(n) || r && !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/.test(n)) && y("HC008", "`nativeElement` must be a lowercase HTML element or component tag.", o), { version: 1, name: lt(s), tag: s, status: c, summary: d, nativeElement: n, props: In(t, i, o, a) };
+  }
+  function zn(e, t) {
+    try {
+      return ke(e);
+    } catch {
+      y("HT013", `Malformed expression \`${e}\`.`, t);
+    }
+  }
+  function _n(e, t, n) {
+    let r = [];
+    for (let i of wt(_(e))) {
+      z(i) || y("HC023", "Handler bodies contain declarative step elements only.", n);
+      let o = w(i, "$if"), a = o === void 0 ? void 0 : R(o, t, n);
+      if (S(i) === "set") {
+        let s = w(i, "name") ?? "", c = w(i, ":value"), d = w(i, "value");
+        (s === "" || c === void 0 == (d === void 0)) && y("HC023", "A <set> requires `name` and exactly one of `value` or `:value`.", n), R(s, t, n);
+        let u = _e(s, t.writableRoots);
+        u === void 0 && y("HT005", `Handler write \`${s}\` is not rooted in declared state.`, n);
+        let l = { kind: "set", path: s, writablePath: u, value: R(c ?? JSON.stringify(d), t, n) };
+        a !== void 0 && (l.guard = a), r.push(l);
+        continue;
+      }
+      if (S(i) === "dispatch") {
+        let s = w(i, "event") ?? "";
+        Fe.test(s) || y("HC023", "A <dispatch> requires a valid `event` name.", n);
+        let c = w(i, ":value"), d = w(i, "value");
+        c !== void 0 && d !== void 0 && y("HC023", "A <dispatch> may declare only one of `value` or `:value`.", n);
+        let u = c === void 0 && d === void 0 ? void 0 : R(c ?? JSON.stringify(d), t, n), l = { kind: "dispatch", event: s };
+        u !== void 0 && (l.value = u), a !== void 0 && (l.guard = a), r.push(l);
+        continue;
+      }
+      if (S(i) === "validate" || S(i) === "focus") {
+        let s = w(i, "target") ?? w(i, "ref") ?? w(i, "name") ?? "";
+        Ke.test(s) || y("HC023", `<${S(i)}> requires a valid target reference.`, n);
+        let c = { kind: S(i), target: s };
+        a !== void 0 && (c.guard = a), r.push(c);
+        continue;
+      }
+      y("HC023", `<${S(i)}> is not a recognized handler step.`, n);
+    }
+    return r;
+  }
+  function qn(e, t, n) {
+    let r = [], i = new Set(Object.keys(t.props)), o = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+    if (e === void 0) return { declarations: r, scope: { roots: i, writableRoots: o, handlers: a } };
+    let s = [], c = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+    for (let l of _(e)) {
+      if (!z(l)) continue;
+      let m = l;
+      s.push(m);
+      let f = S(m);
+      /^(?:prop|state|computed|data|handler|event|method)$/.test(f) || y("HC021", `<${f}> is not a recognized definition declaration.`, n);
+      let h = w(m, "name") ?? "";
+      if (h === "" && y("HC010", `A <${f}> requires a \`name\` attribute.`, n), f === "event") {
+        d.has(h) && y("HC020", `Event \`${h}\` is declared more than once.`, n), d.add(h);
+        continue;
+      }
+      c.has(h) && y("HC020", `Declaration \`${h}\` collides in the flat component scope.`, n), c.add(h), i.add(h), f === "state" ? o.add(h) : f === "handler" && a.add(h);
+    }
+    let u = { roots: i, writableRoots: o, handlers: a };
+    for (let l of s) {
+      let m = S(l);
+      if (m === "prop") continue;
+      let f = w(l, "name");
+      if (m === "state") {
+        let h = w(l, ":value"), p = w(l, "value");
+        h !== void 0 && p !== void 0 && y("HC013", `<state name="${f}"> may declare only one of \`value\` or \`:value\`.`, n);
+        let b = h === void 0 && p === void 0 ? void 0 : R(h ?? JSON.stringify(p), u, n), x = { kind: m, name: f };
+        p !== void 0 && (x.value = p), b !== void 0 && (x.expression = b), r.push(x);
+        continue;
+      }
+      if (m === "computed") {
+        let h = w(l, "from");
+        (h === void 0 || h === "") && y("HC013", `<computed name="${f}"> requires a \`from\` expression.`, n), r.push({ kind: m, name: f, expression: R(h, u, n) });
+        continue;
+      }
+      if (m === "data") {
+        let h = w(l, "src"), p = w(l, "type"), b = w(l, "debounce"), x = w(l, "poll"), E = [], v = /* @__PURE__ */ new Set();
+        for (let k of Et(l, "param")) {
+          let C = w(k, "name") ?? "", $ = w(k, ":value");
+          (!Ke.test(C) || $ === void 0) && y("HC024", "A data <param> requires a valid `name` and a `:value` expression.", n), v.has(C) && y("HC024", `Data source \`${f}\` repeats a parameter name.`, n), v.add(C), E.push({ name: C, expression: R($, u, n) });
+        }
+        let g = { kind: m, name: f, parameters: E };
+        h !== void 0 && (g.source = h), p !== void 0 && (g.type = p), b !== void 0 && (g.debounce = b), x !== void 0 && (g.poll = x), r.push(g);
+        continue;
+      }
+      if (m === "event") {
+        r.push({ kind: m, name: f, type: w(l, "type") ?? "object", bubbles: w(l, "bubbles") !== "false", composed: w(l, "composed") !== "false", cancelable: w(l, "cancelable") === "true" });
+        continue;
+      }
+      if (m === "method") {
+        r.push({ kind: m, name: f, exportName: w(l, "export") ?? f, returns: w(l, "returns") ?? "undefined" });
+        continue;
+      }
+      r.push({ kind: "handler", name: f, steps: _n(l, u, n) });
+    }
+    for (let l of r) if (l.kind === "handler") for (let m of l.steps) m.kind === "dispatch" && !d.has(m.event) && y("HC023", `Handler \`${l.name}\` dispatches undeclared component event \`${m.event}\`.`, n);
+    return { declarations: r, scope: u };
+  }
+  function Un(e, t, n, r, i, o) {
+    let a = [];
+    for (let s of e) {
+      if (s.name.startsWith("bind:")) {
+        let c = s.name.slice(5).toLowerCase();
+        (c === "" || vt.test(c)) && y("HT007", `Two-way binding cannot target \`${c || s.name}\`.`, i);
+        let d = R(s.value, r, i), u = _e(s.value, r.writableRoots);
+        u === void 0 && y("HT005", `\`${s.value}\` is not a writable state-rooted path.`, i), a.push({ kind: "attribute", name: c, expression: s.value, expressionPlan: d, twoWay: true, writablePath: u });
+        continue;
+      }
+      if (s.name.startsWith("class:") || s.name.startsWith("style:")) {
+        let c = s.name.startsWith("class:") ? "class" : "style", d = s.name.slice(c.length + 1);
+        (c === "class" ? d !== "" && !/\s/.test(d) : /^(?:--[a-z0-9_-]+|[a-z][a-z0-9-]*)$/.test(d)) || y("HT020", `\`${s.name}\` does not name a valid ${c} binding target.`, i), a.push({ kind: "attribute", name: d, expression: s.value, expressionPlan: R(s.value, r, i), target: c });
+        continue;
+      }
+      if (s.name.startsWith("$")) {
+        let c = s.name.slice(1).toLowerCase();
+        c !== "value" && c !== "html" && y("HT012", `\`$${c}\` is not a known content directive.`, i), a.push({ kind: "directive", name: c, expression: s.value, expressionPlan: R(s.value, r, i) });
+        continue;
+      }
+      if (s.name.startsWith(":")) {
+        let c = s.name.slice(1).toLowerCase();
+        vt.test(c) && y("HT007", `\`:${c}\` cannot bind a raw content sink.`, i);
+        let d = R(s.value, r, i), u = n.props[s.value];
+        u !== void 0 && (!("attribute" in u.target) || u.target.attribute !== c) && y("HT004", `Binding \`:${c}\` does not match prop \`${s.value}\`'s target.`, i), a.push({ kind: "attribute", name: c, expression: s.value, expressionPlan: d });
+        continue;
+      }
+      if (s.name.startsWith(".")) {
+        let c = s.name.slice(1).toLowerCase(), d = R(s.value, r, i), u = n.props[s.value];
+        u !== void 0 && (!("property" in u.target) || u.target.property.toLowerCase() !== c) && y("HT004", `Property binding \`.${c}\` does not match prop \`${s.value}\`'s target.`, i);
+        let l = o.resolveDomProperty(t, c);
+        l === void 0 && y("HP001", `\`${c}\` is not a native property of <${t}>.`, i), bt(l, i), a.push({ kind: "property", key: c, name: l, expression: s.value, expressionPlan: d });
+        continue;
+      }
+      We(s.name, i, s.value), a.push({ kind: "literal", name: s.name, value: s.value });
+    }
+    return a;
+  }
+  function Wn(e, t, n) {
+    if (e === void 0) return;
+    let r = [];
+    for (let i of e) {
+      let [o = "", ...a] = i.name.slice(3).split(".");
+      (!Fe.test(o) || a.some((s) => !Fe.test(s))) && y("HT010", `\`${i.name}\` is not a valid declarative event binding.`, n);
+      for (let s = 0; s < a.length; s += 1) {
+        let c = a[s];
+        a.indexOf(c) !== s && y("HT010", `\`${i.name}\` repeats an event modifier.`, n), jn.test(c) || y("HT010", `\`${i.name}\` contains an unsupported event modifier.`, n);
+      }
+      a.includes("passive") && a.includes("prevent") && y("HT010", `\`${i.name}\` cannot combine passive and prevent.`, n), t.handlers.has(i.value) || y("HT010", `Event binding \`${i.name}\` names undeclared handler \`${i.value}\`.`, n), r.push({ name: o, handler: i.value, modifiers: a });
+    }
+    return r;
+  }
+  function Fn(e, t, n) {
+    if (e !== void 0) return Ke.test(e) || y("HT019", "`$ref` requires a valid non-empty name.", n), t.has(e) && y("HT019", `Reference \`${e}\` is duplicated.`, n), t.add(e), e;
+  }
+  function Bn(e, t, n) {
+    if (e === void 0) return;
+    let r = [], i = [];
+    e.$if !== void 0 && r.push("$if"), e.$each !== void 0 && r.push("$each"), e.$with !== void 0 && r.push("$with"), e.$match !== void 0 && r.push("$match"), e.$when !== void 0 && r.push("$when"), e.$else !== void 0 && r.push("$else"), e.$where !== void 0 && i.push("$where"), e.$sort !== void 0 && i.push("$sort"), e.$limit !== void 0 && i.push("$limit"), e.$key !== void 0 && i.push("$key"), r.length > 1 && y("HT014", `An element carries one structural directive; found ${r.join(", ")}.`, n);
+    let o = e.$each;
+    o === void 0 && i.length > 0 && y("HT014", `${i.join(", ")} may only modify \`$each\`.`, n);
+    let a = e.$if;
+    if (a !== void 0) {
+      let u = a;
+      return { kind: "if", test: u, testPlan: R(u, t, n) };
+    }
+    let s = e.$with;
+    if (s !== void 0) {
+      let u = kt.exec(s);
+      return u === null && y("HT015", "`$with` must be written `expr as name`.", n), { kind: "with", expr: u[1], expressionPlan: R(u[1], t, n), alias: u[2] };
+    }
+    if (o !== void 0) {
+      let u = Pn.exec(o);
+      u === null && y("HT016", "`$each` must be written `item of items` (optionally `item, i of items`).", n);
+      let l = u[1], m = u[2];
+      (t.roots.has(l) || m !== void 0 && t.roots.has(m)) && y("HC020", "Loop locals may not collide with an existing scope name.", n);
+      let f = Be(t, l, m, "loop"), h = { kind: "each", item: l, list: u[3], listPlan: R(u[3], t, n) };
+      m !== void 0 && (h.index = m);
+      let p = e.$where;
+      p !== void 0 && (h.where = p, h.wherePlan = R(p, f, n)), e.$sort !== void 0 && (h.sort = e.$sort);
+      let b = e.$limit;
+      b !== void 0 && (h.limit = b, h.limitPlan = R(b, f, n));
+      let x = e.$key;
+      return x !== void 0 && (h.key = x, h.keyPlan = R(x, f, n)), h;
+    }
+    let c = e.$match;
+    if (c !== void 0) {
+      let u = c.trim();
+      if (u === "") return { kind: "match" };
+      let l = kt.exec(u);
+      return l === null && y("HT017", "`$match` scope must be written `expr as name`.", n), { kind: "match", expr: l[1], expressionPlan: R(l[1], t, n), alias: l[2] };
+    }
+    let d = e.$when;
+    if (d !== void 0) {
+      let u = d;
+      return { kind: "when", test: u, testPlan: R(u, t, n) };
+    }
+    if (e.$else !== void 0) return { kind: "else" };
+  }
+  function Ze(e, t, n, r, i, o) {
+    let a = S(e);
+    gt(a) && y("HT009", `<${a}> is reserved but not supported by this profile.`, r), Ue(a, r);
+    let s, c = [], d, u;
+    for (let v of we(e)) Dn.test(v.name) ? (s ??= {})[v.name] = v.value : v.name === "$ref" ? u = v.value : v.name.startsWith("on:") ? (d ??= []).push(v) : v.name !== "as" && c.push(v);
+    let l = Bn(s, n, r), m = l?.kind === "each" ? Be(n, l.item, l.index, "loop") : l?.kind === "with" || l?.kind === "match" && l.alias !== void 0 ? Be(n, l.alias) : n, f = Un(c, a, t, m, r, o), h = Wn(d, m, r), p = Fn(u, i.refs, r), b = [], x = _(e);
+    for (let v of x) if (v.nodeName !== "#comment") {
+      if (se(v)) {
+        let g = ae(v);
+        g.trim() !== "" && b.push({ kind: "text", value: g });
+        continue;
+      }
+      if (z(v)) {
+        if (S(v) === "slot") {
+          let g = w(v, "name"), k = w(v, ":name");
+          g !== void 0 && k !== void 0 && y("HT008", "A slot cannot declare both `name` and `:name`.", r);
+          for (let M of we(v)) M.name !== "name" && M.name !== ":name" && y("HT008", "A slot has an unsupported attribute.", r);
+          g === void 0 && k === void 0 && (i.defaults += 1, i.defaults > 1 && y("HT008", "A component may declare one default slot.", r)), g !== void 0 && ((g === "" || i.names.has(g)) && y("HT008", `Slot name \`${g}\` is empty or duplicated.`, r), i.names.add(g));
+          let C = [];
+          for (let M of _(v)) if (M.nodeName !== "#comment") if (se(M)) {
+            let he = ae(M);
+            he.trim() !== "" && C.push({ kind: "text", value: he });
+          } else z(M) && C.push(Ze(M, t, m, r, i, o));
+          let O = { dynamic: k !== void 0, required: C.length === 0 };
+          if (g !== void 0 && (O.name = g), i.contracts.push(O), g === void 0 && k === void 0 && C.length === 0) b.push({ kind: "slot" });
+          else {
+            let M = { kind: "slot", fallback: C };
+            g !== void 0 && (M.name = g), k !== void 0 && (M.nameExpression = R(k, m, r)), b.push(M);
+          }
+          continue;
+        }
+        b.push(Ze(v, t, m, r, i, o));
+      }
+    }
+    if (f.some((v) => v.kind === "directive") && b.length > 0 && y("HT006", "A content directive cannot coexist with children.", r), f.some((v) => v.kind === "property" && v.name === "textContent") && b.length > 0 && y("HT006", "A content-replacing property binding cannot coexist with children.", r), l?.kind === "match") {
+      let v = 0;
+      for (let k of b) k.kind === "element" && (v += 1);
+      let g = false;
+      for (let k of b) k.kind === "element" && (v -= 1, k.flow?.kind === "when" ? g && y("HT018", "A `$when` arm may not follow `$else`.", r) : k.flow?.kind === "else" ? (g && y("HT018", "A `$match` has at most one `$else`.", r), g = true, v !== 0 && y("HT018", "`$else` must be the last arm.", r)) : y("HT018", "Every direct child of a `$match` must be a `$when` or `$else` arm.", r));
+    }
+    let E = { kind: "element", name: a, attributes: f, children: b };
+    return l !== void 0 && (E.flow = l), h !== void 0 && (E.events = h), p !== void 0 && (E.ref = p), E;
+  }
+  function Ct(e, t, n) {
+    let r = wt(e);
+    (r.length !== 1 || !z(r[0]) || S(r[0]) !== "template" || w(r[0], "component") === void 0) && y("HS001", "A source must contain exactly one top-level <template component>.", t);
+    let i = r[0], o, a = false, s, c;
+    for (let g of _(i)) {
+      if (g.nodeName === "#comment" || se(g) && ae(g).trim() === "") continue;
+      z(g) || y("HT001", "A component's markup must be exactly one element root.", t);
+      let k = S(g);
+      k === "props" || k === "defs" ? (o !== void 0 && y("HS002", "A component has one optional declaration group, one markup root, and one optional <style>.", t), o = g, a = k === "props", Tt(g, t)) : k === "style" ? (s !== void 0 && y("HS002", "A component has one optional declaration group, one markup root, and one optional <style>.", t), s = g) : c === void 0 ? c = g : y("HT001", "A component's markup must be exactly one element root.", t);
+    }
+    c === void 0 && y("HT001", "A component's markup must be exactly one element root.", t);
+    let d = S(c), u = (w(c, "as") ?? d).split("|");
+    for (let g = u.length - 1; g >= 0; g -= 1) u[g] = u[g].trim(), u[g] === "" && u.splice(g, 1);
+    let l = !n.isNativeElement(d);
+    l && w(c, "as") !== void 0 && y("HT021", "A delegated component root cannot also declare native `as` choices.", t), !l && (u.length === 0 || !u.includes(d) || u.some((g, k) => u.indexOf(g) !== k) || u.some((g) => !n.isNativeElement(g))) && y("HT021", "A polymorphic root must list unique native choices including its markup root.", t);
+    let m = On(c, t, n), f = Vn(i, o, d, l, m, t, a), { declarations: h, scope: p } = qn(a ? void 0 : o, f, t), b = { defaults: 0, names: /* @__PURE__ */ new Set(), contracts: [], refs: /* @__PURE__ */ new Set() }, x = Ze(c, f, p, t, b, n), E = w(i, "controller");
+    E === "" && y("HC022", "A controller specifier cannot be empty.", t);
+    let v = { source: { file: t }, contract: f, template: x, css: s === void 0 ? "" : xt(s).trim(), declarations: h, slots: b.contracts, root: l ? { kind: "component", tag: d } : { kind: "native", element: d, choices: u } };
+    return E !== void 0 && (v.controller = E), Q(v);
+  }
+  var Rt = /* @__PURE__ */ new WeakMap();
+  function Zn(e) {
+    let t = {}, n = {}, r = (i) => {
+      if (i.includes("-")) return false;
+      if (Object.hasOwn(t, i)) return t[i];
+      let o = e.createElement(i), a = e.defaultView?.HTMLUnknownElement, s = a === void 0 ? o.constructor.name !== "HTMLUnknownElement" : !(o instanceof a);
+      return t[i] = s, s;
+    };
+    return { isNativeElement: r, resolveDomProperty(i, o) {
+      if (!r(i)) return;
+      let a = `${i}:${o}`;
+      if (a in n) return n[a] || void 0;
+      let s = e.createElement(i), c = o.toLowerCase();
+      for (; s !== null; ) {
+        for (let d of Object.getOwnPropertyNames(s)) if (d.toLowerCase() === c) return n[a] = d, d;
+        s = Object.getPrototypeOf(s);
+      }
+      n[a] = "";
+    } };
+  }
+  function St(e, t = e.ownerDocument.URL) {
+    (e.localName !== "template" || !e.hasAttribute("component")) && y("HS001", "A browser component carrier must be a <template component>.", t);
+    let n = e.ownerDocument, r = Rt.get(n);
+    return r === void 0 && (r = Zn(n), Rt.set(n, r)), Ct([e], t, r);
+  }
+  function Kn(e, t, n) {
+    let r = /* @__PURE__ */ new Set(), i = e.replace(/\{([A-Za-z_$][A-Za-z0-9_$-]*)\}/g, (a, s) => {
+      r.add(s);
+      let c = n[s];
+      return c == null ? "" : encodeURIComponent(String(c));
+    }), o = new URL(i, t);
+    for (let [a, s] of Object.entries(n)) if (!(r.has(a) || s == null)) if (Array.isArray(s)) for (let c of s) o.searchParams.append(a, String(c));
+    else o.searchParams.set(a, String(s));
+    return o.href;
+  }
+  var xe = class {
+    constructor(t) {
+      this.options = t;
+      this.#e = t.fetch ?? globalThis.fetch.bind(globalThis), this.#n = t.setTimer ?? ((n, r) => setTimeout(n, r)), this.#t = t.clearTimer ?? ((n) => clearTimeout(n));
+    }
+    options;
+    #e;
+    #n;
+    #t;
+    #i = {};
+    #o;
+    #r;
+    #c = 0;
+    #s = false;
+    update(t) {
+      this.#i = { ...t }, this.#s = true, this.#a();
+      let n = ++this.#c, r = () => {
+        this.#l(n);
+      };
+      (this.options.debounce ?? 0) > 0 ? this.#r = this.#n(r, this.options.debounce) : r();
+    }
+    disconnect() {
+      this.#s && (this.#s = false, this.#c += 1, this.#a());
+    }
+    #a() {
+      this.#o?.abort(), this.#o = void 0, this.#r !== void 0 && this.#t(this.#r), this.#r = void 0;
+    }
+    #d(t) {
+      return !this.#s || t !== this.#c;
+    }
+    async #l(t) {
+      if (this.#d(t)) return;
+      let n = new AbortController();
+      this.#o = n;
+      let r = this.options;
+      r.onState({ pending: true, value: null, error: null, ok: false });
+      try {
+        let i = await this.#e(Kn(r.source, r.baseURL, this.#i), { signal: n.signal });
+        if (!i.ok) throw new TypeError(`Request failed with ${i.status}.`);
+        let o = r.type === "text" ? await i.text() : await i.json(), a = r.adapt === void 0 ? o : r.adapt(o);
+        if (this.#d(t)) return;
+        r.onState({ pending: false, value: a, error: null, ok: true });
+      } catch (i) {
+        if (n.signal.aborted || this.#d(t)) return;
+        r.onState({ pending: false, value: null, error: i, ok: false });
+      } finally {
+        this.#o === n && (this.#o = void 0), !this.#d(t) && (r.poll ?? 0) > 0 && (this.#r = this.#n(() => {
+          this.#l(t);
+        }, r.poll));
+      }
+    }
+  };
+  var N, Jn = 0, Nt = 100, Je = /* @__PURE__ */ new WeakMap(), Ee = /* @__PURE__ */ new WeakMap();
+  function $t(e) {
+    let { dependency: t, previousSubscriber: n, nextSubscriber: r } = e;
+    n === void 0 ? t.first = r : n.nextSubscriber = r, r === void 0 ? t.last = n : r.previousSubscriber = n;
+  }
+  function At(e) {
+    if (e.length > 8) return [];
+    for (; e.length > 0; ) e.pop();
+    return e;
+  }
+  var Ge = class {
+    #e = [];
+    #n = [];
+    #t = false;
+    #i = false;
+    enqueue(t) {
+      t.stopped || t.queued || (t.queued = true, this.#e.push(t), !this.#t && !this.#i && (this.#t = true, queueMicrotask(() => {
+        this.#t = false, this.flush();
+      })));
+    }
+    enqueueDependency(t) {
+      if (this.#i || this.#e.length > 0) return false;
+      for (let n = t.first; n !== void 0; n = n.nextSubscriber) {
+        let r = n.effect;
+        if (r.scheduler !== this) {
+          for (let i of this.#e) i.queued = false;
+          return this.#e = [], false;
+        }
+        r.queued || (r.queued = true, this.#e.push(r));
+      }
+      return this.#t || (this.#t = true, queueMicrotask(() => {
+        this.#t = false, this.flush();
+      })), true;
+    }
+    flush() {
+      this.#i || this.#e.length === 0 || this.#o();
+    }
+    #o() {
+      this.#i = true;
+      let t = 0, n, r = 0;
+      try {
+        for (; this.#e.length > 0; ) {
+          if (t += 1, t > Nt) {
+            for (let i of this.#e) i.queued = false;
+            this.#e = [], y("HR006", "A reactive flush exceeded the propagation-depth limit.");
+          }
+          if (n = this.#e, n.length > 1) {
+            let i = 1, o = n[0];
+            for (; i < n.length; ) {
+              let a = n[i];
+              if (o.priority > a.priority || o.priority === a.priority && o.id > a.id) break;
+              o = a, i += 1;
+            }
+            i < n.length && n.sort((a, s) => a.priority - s.priority || a.id - s.id);
+          }
+          this.#e = this.#n, r = 0;
+          do {
+            let i = n[r];
+            if (i.queued = false, r += 1, i.computed === void 0 ? i.execute() : i.computed.refresh(), this.#e.length === 1 && r === n.length && this.#e[0].computed === void 0) {
+              t += 1, t > Nt && (this.#e[0].queued = false, this.#e = [], y("HR006", "A reactive flush exceeded the propagation-depth limit."));
+              let o = this.#e;
+              this.#e = At(n), n = o, r = 0;
+            } else this.#e.length > 0 && this.#r(n, r);
+          } while (r < n.length);
+          this.#n = At(n), n = void 0;
+        }
+      } finally {
+        if (n !== void 0) {
+          for (; r < n.length; ) n[r++].queued = false;
+          this.#n = [];
+        }
+        if (this.#e.length > 0) {
+          for (let i of this.#e) i.queued = false;
+          this.#e = [];
+        }
+        this.#i = false;
+      }
+    }
+    #r(t, n) {
+      if (this.#e.some((r) => r.computed !== void 0)) for (let r = t.length - 1; r >= n; r -= 1) {
+        let i = t[r];
+        i.computed === void 0 && (t.splice(r, 1), this.#e.push(i));
+      }
+    }
+  }, Te = class {
+    constructor(t, n, r, i) {
+      this.scheduler = t;
+      this.run = n;
+      this.priority = r;
+      this.computed = i;
+    }
+    scheduler;
+    run;
+    priority;
+    computed;
+    id = Jn++;
+    dependencies = void 0;
+    stopped = false;
+    paused = false;
+    queued = false;
+    #e = void 0;
+    #n = void 0;
+    execute() {
+      if (this.stopped || this.paused) return;
+      if (this.#n = void 0, this.#e !== void 0) {
+        let n = this.#e;
+        this.#e = void 0, n();
+      }
+      let t = N;
+      N = this;
+      try {
+        let n = this.run();
+        n !== void 0 && (this.#e = n);
+      } finally {
+        N = t;
+        let n = this.#n, r = n === void 0 ? this.dependencies : n.nextDependency;
+        for (n === void 0 ? this.dependencies = void 0 : n.nextDependency = void 0; r !== void 0; ) {
+          let i = r.nextDependency;
+          $t(r), r = i;
+        }
+      }
+    }
+    track(t) {
+      let n = this.#n === void 0 ? this.dependencies : this.#n.nextDependency;
+      if (n?.dependency === t) {
+        this.#n = n;
+        return;
+      }
+      for (let o = this.dependencies; o !== n; o = o?.nextDependency) if (o?.dependency === t) return;
+      let r = { dependency: t, effect: this, nextDependency: n, previousSubscriber: void 0, nextSubscriber: void 0 };
+      this.#n === void 0 ? this.dependencies = r : this.#n.nextDependency = r, this.#n = r;
+      let i = t.first;
+      if (this.computed !== void 0 && i !== void 0) r.nextSubscriber = i, i.previousSubscriber = r, t.first = r;
+      else {
+        let o = t.last;
+        r.previousSubscriber = o, o === void 0 ? t.first = r : o.nextSubscriber = r, t.last = r;
+      }
+    }
+    schedule() {
+      if (this.computed !== void 0) {
+        this.computed.invalidate();
+        return;
+      }
+      this.paused || this.scheduler.enqueue(this);
+    }
+    pause() {
+      this.stopped || this.paused || (this.paused = true, this.#t(), this.#e?.(), this.#e = void 0);
+    }
+    resume() {
+      this.stopped || !this.paused || (this.paused = false, this.execute());
+    }
+    stop() {
+      this.stopped || (this.stopped = true, this.#t(), this.#e?.(), this.#e = void 0);
+    }
+    #t() {
+      let t = this.dependencies;
+      for (; t !== void 0; ) {
+        let n = t.nextDependency;
+        $t(t), t = n;
+      }
+      this.dependencies = void 0, this.#n = void 0;
+    }
+  }, Qe = class {
+    #e = { first: void 0, last: void 0 };
+    #n;
+    constructor(t) {
+      this.#n = t;
+    }
+    get() {
+      return N !== void 0 && N.track(this.#e), this.#n;
+    }
+    set(t) {
+      Object.is(this.#n, t) || (this.#n = t, K(this.#e));
+    }
+    update(t) {
+      this.set(t(this.#n));
+    }
+  }, Ce = class {
+    #e;
+    #n;
+    #t;
+    #i;
+    #o = false;
+    #r = true;
+    #c = false;
+    #s = false;
+    constructor(t, n, r = { first: void 0, last: void 0 }) {
+      this.#e = r, this.#n = n, this.#t = new Te(t, () => this.#l(), 0, this);
+    }
+    get() {
+      return this.#t.paused || this.#t.stopped ? this.#d() : (this.#a(), N !== void 0 && N.track(this.#e), this.#i);
+    }
+    invalidate() {
+      if (!(this.#t.stopped || this.#r)) {
+        this.#r = true;
+        for (let t = this.#e.first; t !== void 0; t = t.nextSubscriber) if (t.effect.computed === void 0) {
+          this.#t.scheduler.enqueue(this.#t);
+          return;
+        }
+        K(this.#e);
+      }
+    }
+    refresh() {
+      this.#a();
+    }
+    pause() {
+      this.#t.stopped || this.#t.paused || (this.#r = true, this.#t.pause());
+    }
+    resume() {
+      this.#t.stopped || !this.#t.paused || (this.#t.paused = false);
+    }
+    stop() {
+      this.#t.stop();
+    }
+    #a() {
+      if (this.#c && y("HR006", "A reactive computed value depends on itself."), !this.#r || this.#t.stopped || this.#t.paused) return;
+      let t = this.#o;
+      this.#t.execute(), t && this.#s && K(this.#e, N?.computed === void 0 ? void 0 : N);
+    }
+    #d() {
+      this.#c && y("HR006", "A reactive computed value depends on itself.");
+      let t = N;
+      this.#c = true, N = void 0;
+      try {
+        return this.#n();
+      } finally {
+        N = t, this.#c = false;
+      }
+    }
+    #l() {
+      this.#c = true, this.#r = false;
+      try {
+        let t = this.#n();
+        this.#s = !this.#o || !Object.is(this.#i, t), this.#i = t, this.#o = true;
+      } catch (t) {
+        throw this.#r = true, t;
+      } finally {
+        this.#c = false;
+      }
+    }
+  };
+  function K(e, t) {
+    let n = e?.first;
+    if (n === void 0) return;
+    let r = n !== e.last;
+    if (!r && n.effect.computed !== void 0) {
+      n.effect !== t && n.effect.computed.invalidate();
+      return;
+    }
+    if (n.effect.computed === void 0) {
+      if (t === void 0 && r && n.effect.scheduler.enqueueDependency(e)) return;
+      for (let i = n; i !== void 0; ) {
+        let o = i.nextSubscriber;
+        i.effect !== t && i.effect.schedule(), i = o;
+      }
+      return;
+    }
+    for (let i = n; i !== void 0; ) {
+      let o = i.nextSubscriber;
+      i.effect !== t && i.effect.schedule(), i = o;
+    }
+  }
+  function Ht(e) {
+    return new Qe(e);
+  }
+  function Mt(e, t) {
+    return new Ce(e, t);
+  }
+  function ce(e, t, n = 1, r = true) {
+    let i = new Te(e, t, n);
+    return r ? i.execute() : i.paused = true, i;
+  }
+  var Re = class e {
+    constructor(t = [], n = new Ge(), r) {
+      this.scheduler = n;
+      this.parent = r;
+      for (let [i, o] of t) this.set(i, o);
+    }
+    scheduler;
+    parent;
+    #e = /* @__PURE__ */ new Map();
+    #n;
+    #t;
+    has(t) {
+      return this.#i(t) !== void 0 || this.parent?.has(t) === true;
+    }
+    get(t) {
+      let n = this.#i(t);
+      return n === void 0 ? this.parent?.get(t) : (N !== void 0 && N.track(n), n.value);
+    }
+    set(t, n) {
+      let r = this.#r(n), i = this.#i(t);
+      if (i === void 0) {
+        i = { value: r, first: void 0, last: void 0 }, this.#e.set(t, i), this.#t = i;
+        return;
+      }
+      Object.is(i.value, r) || (i.value = r, K(i));
+    }
+    defineComputed(t, n) {
+      let r = this.#i(t);
+      r === void 0 && (r = { value: null, first: void 0, last: void 0 }, this.#e.set(t, r), this.#t = r);
+      let i = new Ce(this.scheduler, () => this.#r(n()), r);
+      return r.computed = i, Object.hasOwn(this, "get") || (this.get = this.#o), i;
+    }
+    fork(t = []) {
+      return new e(t, this.scheduler, this);
+    }
+    #i(t) {
+      return t !== this.#n && (this.#n = t, this.#t = this.#e.get(t)), this.#t;
+    }
+    #o(t) {
+      let n = this.#i(t);
+      return n === void 0 ? this.parent?.get(t) : n.computed !== void 0 ? n.computed.get() : (N !== void 0 && N.track(n), n.value);
+    }
+    #r(t) {
+      if (t === null || typeof t != "object") return t;
+      let n = Je.get(t);
+      if (n !== void 0) return n;
+      let r = new Proxy(t, { get: (i, o, a) => {
+        if (N !== void 0) {
+          let s = Ee.get(i);
+          s === void 0 && (s = /* @__PURE__ */ new Map(), Ee.set(i, s));
+          let c = s.get(o);
+          c === void 0 && (c = { first: void 0, last: void 0 }, s.set(o, c)), N.track(c);
+        }
+        return this.#r(Reflect.get(i, o, a));
+      }, set: (i, o, a, s) => {
+        let c = Reflect.get(i, o, s), d = this.#r(a), u = Reflect.set(i, o, d, s);
+        return Object.is(c, d) || K(Ee.get(i)?.get(o)), u;
+      }, deleteProperty: (i, o) => {
+        let a = Reflect.has(i, o), s = Reflect.deleteProperty(i, o);
+        return a && K(Ee.get(i)?.get(o)), s;
+      } });
+      return Je.set(t, r), Je.set(r, r), r;
+    }
+  };
+  var Dt = "data-component", G = "data-component-root", J = "data-slotted", Gn = [[":user-invalid", ":is(:user-invalid, [data-user-invalid])"], [":invalid", ":is(:invalid, [data-invalid])"], [":valid", ":is(:valid, [data-valid])"]], Qn = /* @__PURE__ */ new Set(["container", "document", "layer", "media", "scope", "starting-style", "supports"]), Yn = /* @__PURE__ */ new Set(["has", "is", "not", "where"]);
+  function Ye(e) {
+    return e !== void 0 && /[A-Za-z0-9_-]/.test(e);
+  }
+  function q(e, t) {
+    let n = e[t], r = t + 1;
+    for (; r < e.length; ) if (e[r] === "\\") r += 2;
+    else {
+      if (e[r] === n) return r;
+      r += 1;
+    }
+    return e.length - 1;
+  }
+  function Pt(e, t) {
+    let n = 1, r = 0;
+    for (let i = t + 1; i < e.length; i += 1) {
+      let o = e[i];
+      if (o === '"' || o === "'") {
+        i = q(e, i);
+        continue;
+      }
+      if (o === "/" && e[i + 1] === "*") {
+        let a = e.indexOf("*/", i + 2);
+        if (a === -1) return e.length - 1;
+        i = a + 1;
+        continue;
+      }
+      if (o === "[") r += 1;
+      else if (o === "]") r = Math.max(0, r - 1);
+      else if (r === 0 && o === "(") n += 1;
+      else if (r === 0 && o === ")" && --n === 0) return i;
+    }
+    return e.length - 1;
+  }
+  function jt(e) {
+    let t = [], n = 0, r = 0, i = 0;
+    for (let o = 0; o < e.length; o += 1) {
+      let a = e[o];
+      if (a === '"' || a === "'") o = q(e, o);
+      else if (a === "/" && e[o + 1] === "*") {
+        let s = e.indexOf("*/", o + 2);
+        if (s === -1) break;
+        o = s + 1;
+      } else a === "[" ? i += 1 : a === "]" ? i = Math.max(0, i - 1) : i === 0 && a === "(" ? r += 1 : i === 0 && a === ")" ? r = Math.max(0, r - 1) : i === 0 && r === 0 && a === "," && (t.push(e.slice(n, o)), n = o + 1);
+    }
+    return t.push(e.slice(n)), t;
+  }
+  function Xn(e) {
+    let t = 0, n = 0, r = 0;
+    for (let i = 0; i < e.length; i += 1) {
+      let o = e[i];
+      if (o === '"' || o === "'") i = q(e, i);
+      else if (o === "/" && e[i + 1] === "*") {
+        let a = e.indexOf("*/", i + 2);
+        if (a === -1) return t;
+        i = a + 1;
+      } else if (o === "[") r += 1;
+      else if (o === "]") r = Math.max(0, r - 1);
+      else if (r === 0 && o === "(") n += 1;
+      else if (r === 0 && o === ")") n = Math.max(0, n - 1);
+      else if (r === 0 && n === 0) {
+        if (o === ">" || o === "+" || o === "~") t = i + 1;
+        else if (/\s/.test(o)) {
+          let a = i;
+          for (; a + 1 < e.length && /\s/.test(e[a + 1]); ) a += 1;
+          e[a + 1] !== void 0 && !/[>+~]/.test(e[a + 1]) && (t = a + 1), i = a;
+        }
+      }
+    }
+    for (; t < e.length && /\s/.test(e[t]); ) t += 1;
+    return t;
+  }
+  function er(e) {
+    let t = 0, n = 0;
+    for (let r = 0; r < e.length - 1; r += 1) {
+      let i = e[r];
+      if (i === '"' || i === "'") r = q(e, r);
+      else if (i === "[") n += 1;
+      else if (i === "]") n = Math.max(0, n - 1);
+      else if (n === 0 && i === "(") t += 1;
+      else if (n === 0 && i === ")") t = Math.max(0, t - 1);
+      else if (n === 0 && t === 0 && i === ":" && e[r + 1] === ":") return r;
+    }
+    return e.length;
+  }
+  function tr(e, t) {
+    let n = `:where([${Dt}~="${t}"])`, r = e.search(/\s*$/), i = e.slice(0, r), o = e.slice(r), a = Xn(i), s = i.slice(a);
+    if (s.includes(n)) return e;
+    let c = er(s);
+    return `${i.slice(0, a)}${s.slice(0, c)}${n}${s.slice(c)}${o}`;
+  }
+  function nr(e, t, n, r, i) {
+    let o = "", a = true;
+    for (let s = 0; s < e.length; ) {
+      let c = e[s];
+      if (c === '"' || c === "'") {
+        let d = q(e, s) + 1;
+        o += e.slice(s, d), s = d;
+        continue;
+      }
+      if (c === "/" && e[s + 1] === "*") {
+        let d = e.indexOf("*/", s + 2), u = d === -1 ? e.length : d + 2;
+        o += e.slice(s, u), s = u;
+        continue;
+      }
+      if (c === "[") {
+        let d = s + 1;
+        for (; d < e.length; ) {
+          let u = e[d];
+          if (u === '"' || u === "'") {
+            d = q(e, d) + 1;
+            continue;
+          }
+          if (d += 1, u === "]") break;
+        }
+        o += e.slice(s, d), s = d, a = false;
+        continue;
+      }
+      if (c === ":") {
+        let d = s + 1;
+        for (; Ye(e[d]); ) d += 1;
+        let u = e.slice(s + 1, d).toLowerCase();
+        if (i) {
+          let l = false;
+          for (let [m, f] of Gn) {
+            if (e.startsWith(f, s)) {
+              o += f, s += f.length, a = false, l = true;
+              break;
+            }
+            if (e.startsWith(m, s) && !Ye(e[s + m.length])) {
+              o += f, s += m.length, a = false, l = true;
+              break;
+            }
+          }
+          if (l) continue;
+        }
+        if (u === "scope" && t !== void 0 && n === "attribute") {
+          o += `:is(:where([${G}~="${t}"]), ${t})`, s = d, a = false;
+          continue;
+        }
+        if (e[d] === "(") {
+          let l = Pt(e, d), m = e.slice(d + 1, l), f = Yn.has(u) ? Lt(m, t, n, r, u === "has" && t !== void 0, i) : m;
+          o += `${e.slice(s, d + 1)}${f})`, s = l + 1;
+        } else o += e.slice(s, d), s = d;
+        a = false;
+        continue;
+      }
+      if (a && /[A-Za-z]/.test(c)) {
+        let d = s + 1;
+        for (; Ye(e[d]); ) d += 1;
+        let u = e.slice(s, d), l = u.includes("-") ? `:is(:where([${G}~="${u.toLowerCase()}"]), ${u})` : u;
+        o += n === "scope" && u.toLowerCase() === r?.toLowerCase() ? `:is(${l}, :where(:scope))` : l, s = d, a = false;
+        continue;
+      }
+      o += c, s += 1, c === "," || c === ">" || c === "+" || c === "~" || /\s/.test(c) ? a = true : c !== "|" && (a = false);
+    }
+    return o;
+  }
+  function Lt(e, t, n, r, i, o = false) {
+    return jt(e).map((a) => {
+      let s = /^\s*/.exec(a)[0], c = /\s*$/.exec(a)[0], d = a.slice(s.length, a.length - c.length);
+      if (d === "") return a;
+      let u = nr(d, t, n, r, o);
+      return `${s}${i && t !== void 0 ? tr(u, t) : u}${c}`;
+    }).join(",");
+  }
+  function Xe(e, t) {
+    let n = 1;
+    for (let r = t + 1; r < e.length; r += 1) {
+      let i = e[r];
+      if (i === '"' || i === "'") r = q(e, r);
+      else if (i === "/" && e[r + 1] === "*") {
+        let o = e.indexOf("*/", r + 2);
+        if (o === -1) return e.length - 1;
+        r = o + 1;
+      } else if (i === "{") n += 1;
+      else if (i === "}" && --n === 0) return r;
+    }
+    return e.length - 1;
+  }
+  function Ot(e, t, n, r, i = false) {
+    let o = "", a = 0, s = 0, c = 0;
+    for (let d = 0; d < e.length; d += 1) {
+      let u = e[d];
+      if (u === '"' || u === "'") d = q(e, d);
+      else if (u === "/" && e[d + 1] === "*") {
+        let l = e.indexOf("*/", d + 2);
+        if (l === -1) break;
+        d = l + 1;
+      } else if (u === "(") s += 1;
+      else if (u === ")") s = Math.max(0, s - 1);
+      else if (u === "[") c += 1;
+      else if (u === "]") c = Math.max(0, c - 1);
+      else if (s === 0 && c === 0 && u === ";") o += e.slice(a, d + 1), a = d + 1;
+      else if (s === 0 && c === 0 && u === "{") {
+        let l = Xe(e, d), m = e.slice(a, d), f = e.slice(d + 1, l), h = /^\s*@([\w-]+)/.exec(m)?.[1]?.toLowerCase(), p = h === void 0 ? Lt(m, t, n, r, t !== void 0 && n === "attribute", i) : m, b = h === void 0 || Qn.has(h) ? Ot(f, t, n, r, i) : f;
+        o += `${p}{${b}}`, d = l, a = l + 1;
+      }
+    }
+    return o + e.slice(a);
+  }
+  function rr(e) {
+    let t = "", n = "", r = 0, i = 0, o = 0;
+    for (let a = 0; a < e.length; a += 1) {
+      let s = e[a];
+      if (s === '"' || s === "'") a = q(e, a);
+      else if (s === "/" && e[a + 1] === "*") {
+        let c = e.indexOf("*/", a + 2);
+        if (c === -1) break;
+        a = c + 1;
+      } else if (s === "(") i += 1;
+      else if (s === ")") i = Math.max(0, i - 1);
+      else if (s === "[") o += 1;
+      else if (s === "]") o = Math.max(0, o - 1);
+      else if (i === 0 && o === 0 && s === ";") t += e.slice(r, a + 1), r = a + 1;
+      else if (i === 0 && o === 0 && s === "{") {
+        let c = Xe(e, a), d = e.slice(r, a), u = e.slice(r, c + 1);
+        !/^\s*@/.test(d) && d.includes(":slotted(") ? n += u : t += u, a = c, r = c + 1;
+      }
+    }
+    return { normal: t + e.slice(r), slotted: n };
+  }
+  function ir(e, t) {
+    let n = e.trim();
+    if (n.startsWith(">")) {
+      let i = n.slice(1).trim();
+      return i === "" || i === "*" ? `${t} [${J}]` : `${t} [${J}]:is(${i})`;
+    }
+    let r = `:where([${J}], [${J}] *)`;
+    return n === "" || n === "*" ? `${t} ${r}` : `${t} ${r}:is(${n})`;
+  }
+  function or(e, t) {
+    let n = `[${G}~="${t}"]`, r = /^\s*:scope((?:\[[^\]]*\]|:{1,2}[\w-]+(?:\([^)]*\))?|[.#][\w-]+)*)\s+(?=:slotted\()/.exec(e), i = r ? `${n}${r[1]}` : n, o = r ? e.slice(r[0].length) : e, a = "", s = 0;
+    for (; ; ) {
+      let c = o.indexOf(":slotted(", s);
+      if (c === -1) return a += o.slice(s), a;
+      a += o.slice(s, c);
+      let d = c + 8, u = Pt(o, d);
+      a += ir(o.slice(d + 1, u), i), s = u + 1;
+    }
+  }
+  function sr(e, t) {
+    let n = "", r = 0;
+    for (let i = 0; i < e.length; i += 1) if (e[i] === "{") {
+      let o = Xe(e, i), a = e.slice(r, i), s = e.slice(i + 1, o), c = jt(a).map((d) => or(d, t)).join(",");
+      n += `${c}{${s}}`, i = o, r = o + 1;
+    }
+    return n + e.slice(r);
+  }
+  function Se(e, t, n) {
+    if (e === "") return "";
+    let { normal: r, slotted: i } = rr(e), o = Ot(r, t, "scope", n), a = o.trim() === "" ? "" : `@scope ([${G}~="${t}"]) to (:scope [${G}] > *, [${J}]) {
+${o}
+}`, s = i.trim() === "" ? "" : sr(i, t);
+    return [a, s].filter((c) => c !== "").join(`
+`);
+  }
+  function It(e, t, n) {
+    let r = new Set((e.getAttribute(t) ?? "").split(/\s+/).filter(Boolean));
+    r.add(n), e.setAttribute(t, Array.from(r).join(" "));
+  }
+  function de(e, t) {
+    It(e, Dt, t);
+  }
+  function et(e, t) {
+    de(e, t), It(e, G, t);
+  }
+  function le(e) {
+    e.nodeType === 1 && e.setAttribute(J, "");
+  }
+  var Ne = /* @__PURE__ */ new WeakSet(), nt = /* @__PURE__ */ new WeakMap(), Vt = /* @__PURE__ */ new WeakMap(), ar = /* @__PURE__ */ Symbol.for("@nextwebwg/declarative-components.runtime.v1"), Z = /* @__PURE__ */ Symbol.for("@nextwebwg/declarative-components.lifecycle.v1");
+  function pe(e) {
+    return e[ar] ??= {};
+  }
+  function L(e) {
+    return nt.get(e);
+  }
+  function me(e) {
+    let t = pe(e), n = t.registry;
+    return (n === void 0 || n.root !== e.documentElement) && (n = { root: e.documentElement, definitions: /* @__PURE__ */ new Map(), discoverySelector: void 0 }, t.registry = n), n;
+  }
+  function He(e, t, n) {
+    e.definitions.set(t, n), e.discoverySelector !== void 0 && (e.discoverySelector += `,${t}`);
+  }
+  function cr(e) {
+    return e.discoverySelector ??= ["template[component]", "[data-component-root]", ...Array.from(e.definitions.keys())].join(",");
+  }
+  function dr(e, t) {
+    let n = e.getAttribute("component") ?? "", r = `${e.ownerDocument.URL}#template[component="${n}"][${t + 1}]`;
+    e.hasAttribute("src") && y("HL001", "External definitions require the application-owned graph resolver.", r);
+    let i = St(e, r), o = Array.from(e.content.children).find((a) => a.localName === "style");
+    return { wrapper: e, style: o, definition: i };
+  }
+  function lr(e, t = document) {
+    let n = me(t), r = 0;
+    for (let i of e.nodes.values()) {
+      if (i.shadowedByCustomElement) continue;
+      let o = i.definition.contract.tag;
+      n.definitions.has(o) && y("HR001", `More than one definition declares <${o}>.`);
+      let a = i.definition.css === "" ? void 0 : t.createElement("style");
+      a !== void 0 && (a.textContent = Se(i.definition.css, o, i.definition.template.name), a.dataset.htmlNextComponent = o, t.head.append(a)), He(n, o, { definition: i.definition, style: a }), r += 1;
+    }
+    return r;
+  }
+  function rt(e, t, n = false) {
+    let r = e.type === "boolean" && n && t === "" ? true : t, i = B(r, e.type);
+    if (!i.ok) {
+      let o = i.issues.map((a) => `${a.path}: ${a.message}`).join("; ");
+      y("HR002", `A prop invocation value does not satisfy its declared type. ${o}`);
+    }
+    return i.value;
+  }
+  function Bt(e, t, n) {
+    return n !== void 0 ? rt(t, n) : (t.required && y("HC020", `Required prop \`${e}\` was not provided.`), t.default === void 0 ? T : t.default);
+  }
+  function ur(e, t) {
+    let n = Vt.get(e);
+    if (n === void 0) {
+      let r = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null);
+      for (let o of Object.keys(e.contract.props)) {
+        let a = Y(o);
+        r[a] = o, i[`data-${a}`] = o, a !== o.toLowerCase() && (i[`data-${o.toLowerCase()}`] = o);
+      }
+      n = [r, i], Vt.set(e, n);
+    }
+    return n[t ? 1 : 0];
+  }
+  function fr(e, t, n = false) {
+    let r = t.contract, i = ur(t, n), o = /* @__PURE__ */ Object.create(null), a = [], s;
+    for (let h of Array.from(e.attributes)) {
+      if (h.name.toLowerCase() === "as" && t.root?.kind === "native") {
+        s = h.value.toLowerCase();
+        continue;
+      }
+      let p = i[h.name.toLowerCase()];
+      if (p === void 0) {
+        n || a.push(h);
+        continue;
+      }
+      o[p] = rt(r.props[p], h.value, !n);
+    }
+    let c = t.root?.kind === "native" ? n ? e.localName : s ?? t.root.element : t.template.name;
+    t.root?.kind === "native" && !t.root.choices.includes(c) && y(n ? "HR005" : "HR002", `<${r.tag}> cannot use root <${c}>; expected one of ${t.root.choices.join(", ")}.`);
+    let d = new Set(Object.keys(o).filter((h) => o[h] !== void 0)), u = new Re();
+    for (let [h, p] of Object.entries(r.props)) p.required && o[h] === void 0 && y("HC020", `Required prop \`${h}\` was not provided.`), u.set(h, o[h] !== void 0 ? o[h] : p.default === void 0 ? T : p.default);
+    let l = t.declarations ?? [];
+    for (let h of l) (h.kind === "state" || h.kind === "computed" || h.kind === "data") && u.set(h.name, null);
+    for (let h of l) h.kind === "data" ? u.set(h.name, { pending: true, value: null, error: null, ok: false }) : h.kind === "state" && u.set(h.name, h.expression === void 0 ? null : H(h.expression.source, u));
+    let m = [];
+    for (let h of l) h.kind !== "computed" || h.expression === void 0 || m.push(u.defineComputed(h.name, () => V(h.expression, u)));
+    let f = (() => {
+      try {
+        return new URL(t.source.file, e.ownerDocument.baseURI).href;
+      } catch {
+        return e.ownerDocument.baseURI;
+      }
+    })();
+    for (let h of l) {
+      if (h.kind !== "data" || h.source === void 0) continue;
+      let p = h, b = h.source, x = new xe({ source: b, baseURL: f, ...p.type === void 0 ? {} : { type: p.type }, ...p.debounce === void 0 ? {} : { debounce: Number(p.debounce) }, ...p.poll === void 0 ? {} : { poll: Number(p.poll) }, onState: (E) => u.set(p.name, E) });
+      m.push(ce(u.scheduler, () => {
+        let E = Object.fromEntries(p.parameters.map((v) => [v.name, V(v.expression, u)]));
+        return x.update(E), () => x.disconnect();
+      }, 0));
+    }
+    return { scope: u, passThrough: a, effects: m, rootName: c, explicit: d };
+  }
+  function tt(e, t) {
+    return e.fork(Object.entries(t));
+  }
+  function H(e, t) {
+    try {
+      return ht(e, t);
+    } catch (n) {
+      throw n instanceof re && y("HB001", n.message), n;
+    }
+  }
+  var ue = "http://www.w3.org/2000/svg", zt = /* @__PURE__ */ new Map();
+  function pr(e, t) {
+    if (e.namespaceURI !== ue) return t;
+    let n = zt.get(t);
+    if (n === void 0) {
+      let r = e.ownerDocument.createElement("template");
+      r.innerHTML = `<svg ${t}>`, n = r.content.firstChild.attributes[0]?.name ?? t, zt.set(t, n);
+    }
+    return n;
+  }
+  function Zt(e, t, n) {
+    return t === "svg" || n.namespace === ue ? e.createElementNS(ue, t) : e.createElement(t);
+  }
+  function mr(e, t) {
+    let n = e.namespaceURI === ue && e.localName !== "foreignObject" ? ue : void 0;
+    return n === t.namespace ? t : Object.create(t, { namespace: { value: n, enumerable: true } });
+  }
+  function U(e, t, n, r = 1) {
+    e.effects.push(ce(t.scheduler, n, r));
+  }
+  function Kt(e, t, n) {
+    let [r, ...i] = t;
+    if (typeof r != "string") return;
+    if (i.length === 0) {
+      e.set(r, n);
+      return;
+    }
+    let o = e.get(r);
+    for (let c = 0; c < i.length - 1; c += 1) {
+      let d = i[c], u = typeof d == "object" ? V(d.expression, e) : d;
+      if (typeof u != "string" && typeof u != "number" || o == null) return;
+      o = o[u];
+    }
+    let a = i.at(-1), s = typeof a == "object" ? V(a.expression, e) : a;
+    (typeof s == "string" || typeof s == "number") && o != null && (o[s] = n);
+  }
+  function hr(e) {
+    return e instanceof HTMLInputElement ? e.type === "checkbox" || e.type === "radio" ? e.checked : e.type === "number" || e.type === "range" ? Number.isNaN(e.valueAsNumber) ? null : e.valueAsNumber : e.value : e instanceof HTMLSelectElement ? e.multiple ? Array.from(e.selectedOptions, (t) => t.value) : e.value : e instanceof HTMLTextAreaElement ? e.value : e.value ?? e.getAttribute("value");
+  }
+  function yr(e, t, n) {
+    let r = t.toLowerCase();
+    if (r === "checked" && e instanceof HTMLInputElement) return e.checked = j(n), true;
+    if (r === "value" && e instanceof HTMLSelectElement && e.multiple) {
+      let i = new Set(Array.isArray(n) ? n.map(String) : []);
+      for (let o of Array.from(e.options)) o.selected = i.has(o.value);
+      return true;
+    }
+    return r === "value" && (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement) ? (e.value = n == null ? "" : String(n), true) : false;
+  }
+  function gr(e, t, n, r) {
+    for (let i of e.steps) if (!(i.guard !== void 0 && !j(V(i.guard, n)))) if (i.kind === "set") Kt(n, i.writablePath, V(i.value, n));
+    else if (i.kind === "dispatch") {
+      let o = Jt(r.definition, i.event), a = i.value === void 0 ? void 0 : V(i.value, n);
+      o !== void 0 && a !== void 0 && (B(a, ge(o.type)).ok || y("HR002", `Event \`${i.event}\` detail does not satisfy its declared type.`)), Gt(r.root ?? t, i.event, a, o);
+    } else {
+      let o = r.refs[i.target];
+      i.kind === "focus" ? o?.focus() : o?.reportValidity?.();
+    }
+  }
+  function Jt(e, t) {
+    return (e.declarations ?? []).find((n) => n.kind === "event" && n.name === t);
+  }
+  function Gt(e, t, n, r) {
+    return e.dispatchEvent(new CustomEvent(t, { detail: n, bubbles: r?.bubbles ?? true, composed: r?.composed ?? true, cancelable: r?.cancelable ?? false }));
+  }
+  function br(e, t, n) {
+    if (n.includes("self") && e.target !== t) return false;
+    if (e instanceof MouseEvent) {
+      let i = n.filter((a) => ["left", "middle", "right"].includes(a)), o = { left: 0, middle: 1, right: 2 };
+      if (i.length > 0 && !i.some((a) => e.button === o[a])) return false;
+    }
+    let r = ["ctrl", "shift", "alt", "meta"];
+    for (let i of r) if (n.includes(i) && !e[`${i}Key`]) return false;
+    if (n.includes("exact") && r.some((i) => !n.includes(i) && e[`${i}Key`])) return false;
+    if (e instanceof KeyboardEvent) {
+      let i = n.filter((a) => ["enter", "escape", "space", "tab", "up", "down", "left", "right"].includes(a)), o = { enter: "Enter", escape: "Escape", space: " ", tab: "Tab", up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight" };
+      if (i.length > 0 && !i.some((a) => e.key === o[a])) return false;
+    }
+    return true;
+  }
+  function _t(e, t, n, r) {
+    for (let i of t.events ?? []) {
+      let o = (r.definition.declarations ?? []).find((s) => s.kind === "handler" && s.name === i.handler), a = (s) => {
+        br(s, e, i.modifiers) && (i.modifiers.includes("prevent") && s.preventDefault(), i.modifiers.includes("stop") && s.stopPropagation(), gr(o, e, n, r));
+      };
+      if (i.name === "connect" || i.name === "disconnect") {
+        (i.name === "connect" ? r.connectCallbacks : r.disconnectCallbacks).add(() => a(new Event(i.name)));
+        continue;
+      }
+      U(r, n, () => (e.addEventListener(i.name, a, { capture: i.modifiers.includes("capture"), passive: i.modifiers.includes("passive"), once: i.modifiers.includes("once") }), () => e.removeEventListener(i.name, a, { capture: i.modifiers.includes("capture") })), 2);
+    }
+  }
+  function vr(e, t, n) {
+    t = pr(e, t), n === null || oe(t) && ie(n) ? e.removeAttribute(t) : e.setAttribute(t, n);
+  }
+  function kr(e, t, n, r) {
+    let i = H(t.expression, n);
+    t.name === "value" ? e.textContent = D(i) : e.replaceChildren(qe(D(i), r, (o) => Ne.add(o)));
+  }
+  function wr(e, t, n) {
+    let r = H(e.expression, t);
+    return e.name === "value" ? n.createTextNode(D(r)) : qe(D(r), n, (i) => Ne.add(i));
+  }
+  function xr(e, t) {
+    return typeof e == "number" && typeof t == "number" ? e - t : D(e).localeCompare(D(t));
+  }
+  function Er(e, t, n) {
+    let r = e.slice();
+    if (t.where !== void 0) {
+      let i = t.where;
+      r = r.filter((o) => j(H(i, tt(n, { [t.item]: o }))));
+    }
+    if (t.sort !== void 0) {
+      let i = t.sort.split(",").map((a) => a.trim()).filter((a) => a !== ""), o = (a, s) => a !== null && typeof a == "object" && !Array.isArray(a) ? H(`${t.item}.${s}`, tt(n, { [t.item]: a })) : a;
+      r.sort((a, s) => {
+        for (let c of i) {
+          let d = c.startsWith("-"), u = d ? c.slice(1).trim() : c, l = xr(o(a, u), o(s, u));
+          if (l !== 0) return d ? -l : l;
+        }
+        return 0;
+      });
+    }
+    if (t.limit !== void 0) {
+      let i = H(t.limit, n);
+      typeof i == "number" && (r = r.slice(0, Math.max(0, Math.trunc(i))));
+    }
+    return r;
+  }
+  function Qt(e, t) {
+    let n = t.createDocumentFragment();
+    return n.append(...e), Array.from(n.childNodes);
+  }
+  function Tr(e, t) {
+    let n = e.nextSibling;
+    for (; n !== null && n !== t; ) {
+      let r = n.nextSibling;
+      n.remove(), n = r;
+    }
+  }
+  function Cr(e, t, n, r, i) {
+    if (e.flow?.kind === "each") return $r(e, t, n, r, i);
+    let o = n.createComment("html-next:start"), a = n.createComment("html-next:end"), s = n.createDocumentFragment();
+    s.append(o, a);
+    let c = [];
+    return U(i, t, () => {
+      for (let l of c) l.stop();
+      c = [], Tr(o, a);
+      let d = i.effects.length, u = [];
+      if (e.flow?.kind === "if") {
+        if (j(H(e.flow.test, t))) {
+          let { flow: l, ...m } = e;
+          u = fe(m, t, n, r, i);
+        }
+      } else if (e.flow?.kind === "with") {
+        let l = t.fork([[e.flow.alias, H(e.flow.expr, t)]]), { flow: m, ...f } = e;
+        u = fe(f, l, n, r, i);
+      } else e.flow?.kind === "match" && (u = Ar(e, t, n, i));
+      c = i.effects.slice(d), a.before(...Qt(u, n));
+    }), [s];
+  }
+  function Rr(e, t) {
+    if (e.end.nextSibling === t) return;
+    let n = [], r = e.start;
+    for (; r !== null && (n.push(r), r !== e.end); ) r = r.nextSibling;
+    let i = t.parentNode;
+    if (i === null) return;
+    let o = i.moveBefore;
+    for (let a of n) o === void 0 ? i.insertBefore(a, t) : o.call(i, a, t);
+  }
+  function Sr(e) {
+    for (let n of e.effects) n.stop();
+    let t = e.start;
+    for (; t !== null; ) {
+      let n = t.nextSibling;
+      if (t.parentNode?.removeChild(t), t === e.end) break;
+      t = n;
+    }
+  }
+  function Nr(e) {
+    let t = -1, n = true;
+    for (let s of e) s < 0 || (s < t && (n = false), t = s);
+    if (n) return;
+    let r = [], i = new Int32Array(e.length).fill(-1);
+    for (let s = 0; s < e.length; s += 1) {
+      let c = e[s];
+      if (c < 0) continue;
+      let d = 0, u = r.length;
+      for (; d < u; ) {
+        let l = d + u >>> 1;
+        e[r[l]] < c ? d = l + 1 : u = l;
+      }
+      d > 0 && (i[s] = r[d - 1]), r[d] = s;
+    }
+    let o = new Uint8Array(e.length), a = r.at(-1) ?? -1;
+    for (; a >= 0; ) o[a] = 1, a = i[a];
+    return o;
+  }
+  function $r(e, t, n, r, i) {
+    let o = e.flow, a = n.createComment("html-next:each-start"), s = n.createComment("html-next:each-end"), c = n.createDocumentFragment();
+    c.append(a, s);
+    let d = /* @__PURE__ */ new Map();
+    return U(i, t, () => {
+      let u = H(o.list, t), l = Array.isArray(u) ? Er(u, o, t) : [], m = /* @__PURE__ */ new Map(), f = o.key !== void 0, h = f ? [] : void 0, p;
+      if (f) {
+        p = /* @__PURE__ */ new Map();
+        let v = 0;
+        for (let g of d.keys()) p.set(g, v++);
+      }
+      let b = f ? [] : void 0, { flow: x, ...E } = e;
+      for (let v = 0; v < l.length; v += 1) {
+        let g = l[v], k = { [o.item]: g, loop: { index: v, first: v === 0, last: v === l.length - 1, count: l.length } };
+        o.index !== void 0 && (k[o.index] = v);
+        let C, $ = v;
+        o.key !== void 0 && (C = t.fork(Object.entries(k)), $ = H(o.key, C)), m.has($) && y("HR004", `A keyed list produced duplicate key \`${D($)}\`.`);
+        let O = d.get($);
+        if (O === void 0) {
+          C ??= t.fork(Object.entries(k));
+          let M = i.effects.length, he = Qt(fe(E, C, n, r, i), n), ct = n.createComment("html-next:item-start"), dt = n.createComment("html-next:item-end");
+          s.before(ct, ...he, dt), O = { start: ct, end: dt, scope: C, effects: i.effects.slice(M) };
+        } else O.scope.set(o.item, g), o.index !== void 0 && O.scope.set(o.index, v), O.scope.set("loop", k.loop);
+        m.set($, O), h?.push(O), b?.push(p?.get($) ?? -1);
+      }
+      for (let [v, g] of d) m.has(v) || Sr(g);
+      if (h !== void 0 && b !== void 0) {
+        let v = Nr(b), g = s;
+        for (let k = h.length - 1; k >= 0; k -= 1) {
+          let C = h[k];
+          (b[k] < 0 || v !== void 0 && v[k] !== 1) && Rr(C, g), g = C.start;
+        }
+      }
+      d = m;
+    }), [c];
+  }
+  function Yt(e, t, n, r, i, o) {
+    return e.flow?.kind === "if" || e.flow?.kind === "each" || e.flow?.kind === "with" || e.flow?.kind === "match" ? i.committed && i.frameworkOwned && o !== void 0 ? [o] : Cr(e, t, n, r, i) : fe(e, t, n, r, i, o);
+  }
+  function Ar(e, t, n, r) {
+    let i = e.flow, o = i.expr !== void 0 ? tt(t, { [i.alias]: H(i.expr, t) }) : t, a;
+    for (let l of e.children) if (l.kind === "element") {
+      if (l.flow?.kind === "when" && j(H(l.flow.test, o))) {
+        a = l;
+        break;
+      }
+      if (l.flow?.kind === "else") {
+        a = l;
+        break;
+      }
+    }
+    if (a === void 0) return [];
+    let { flow: s, ...c } = a, d = fe(c, o, n, [], r);
+    if (e.name === "template") return d;
+    let u = Zt(n, e.name, r);
+    for (let l of e.attributes) l.kind === "literal" && u.setAttribute(l.name, l.value);
+    return u.append(...d), de(u, r.definition.contract.tag), [u];
+  }
+  function fe(e, t, n, r, i, o) {
+    let a = e.attributes.find((p) => p.kind === "directive");
+    if (e.name === "template") {
+      if (a !== void 0) {
+        let p = n.createTextNode("");
+        return U(i, t, () => {
+          let b = H(a.expression, t);
+          a.name === "value" && (p.data = D(b));
+        }), a.name === "value" ? [p] : [wr(a, t, n)];
+      }
+      return Xt(e.children, t, n, i);
+    }
+    let s = e === i.definition.template ? i.rootName : e.name;
+    if (i.frameworkOwned && o instanceof Element && o.localName !== s && (o.getAttribute("data-component-root") ?? "").split(/\s+/).includes(e.name)) return [o];
+    if (i.hydrationRanges !== void 0 && !i.frameworkOwned && o instanceof Element && o.localName !== s && (o.getAttribute("data-component-root") ?? "").split(/\s+/).includes(e.name)) {
+      let p = it(o, false), b = (g) => g.kind === "element" ? g.attributes.find((k) => k.kind === "literal" && k.name === "slot")?.value ?? "" : "", x = p?.ranges.filter((g) => !g.fallback) ?? [], E = (g, k) => {
+        let C = 0;
+        for (let $ of g) C += $e($, t, n, i, k[C]).length;
+      };
+      for (let g of x) E(e.children.filter((k) => b(k) === g.slot), g.content);
+      let v = new Set(x.map((g) => g.slot));
+      return E(e.children.filter((g) => !v.has(b(g))), p?.carried ?? []), [o];
+    }
+    let c = o instanceof Element && o.localName === s, d = c ? o : Zt(n, s, i);
+    e === i.definition.template && (i.root = d);
+    let u = c ? Array.from(d.childNodes) : [], l = c && (d instanceof HTMLInputElement || d instanceof HTMLTextAreaElement || d instanceof HTMLSelectElement) ? { value: d.value, focused: d.ownerDocument.activeElement === d, ...d instanceof HTMLInputElement ? { checked: d.checked } : {}, ...d instanceof HTMLInputElement || d instanceof HTMLTextAreaElement ? { selectionStart: d.selectionStart, selectionEnd: d.selectionEnd } : {} } : void 0;
+    e.ref !== void 0 && (i.refs[e.ref] = d);
+    for (let p of r) d.setAttribute(p.name, p.value);
+    for (let p of e.attributes) if (p.kind === "literal") d.setAttribute(p.name, p.value);
+    else if (p.kind === "attribute") {
+      if (U(i, t, () => {
+        let b = H(p.expression, t);
+        p.target === "class" ? d.classList.toggle(p.name, j(b)) : p.target === "style" ? d.style.setProperty(p.name, D(b)) : p.twoWay === true && yr(d, p.name, b) || vr(d, p.name, yt(b));
+      }), p.twoWay === true && p.writablePath !== void 0) {
+        let b = d instanceof HTMLSelectElement || d instanceof HTMLInputElement && ["checkbox", "radio", "file"].includes(d.type) ? "change" : "input", x = () => {
+          d instanceof HTMLInputElement && d.type === "radio" && !d.checked || Kt(t, p.writablePath, hr(d));
+        };
+        U(i, t, () => (d.addEventListener(b, x), () => d.removeEventListener(b, x)), 2);
+      }
+    } else p.kind === "property" && U(i, t, () => {
+      d[p.name] = H(p.expression, t);
+    });
+    if (de(d, i.definition.contract.tag), a !== void 0) return U(i, t, () => kr(d, a, t, n)), _t(d, e, t, i), [d];
+    let m = [], f = 0, h = mr(d, i);
+    for (let p of e.children) {
+      let b = f;
+      if (i.frameworkOwned && p.kind === "element") {
+        let E = u.findIndex((v, g) => g < f ? false : v instanceof Element && (v.localName === p.name || (v.getAttribute("data-component-root") ?? "").split(/\s+/).includes(p.name)));
+        E < 0 && p.flow !== void 0 && (E = u.findIndex((v, g) => g >= f && v instanceof Comment)), E >= 0 && (b = E);
+      }
+      let x = $e(p, t, n, h, u[b]);
+      m.push(...x), f = b + x.length;
+    }
+    if (c && !i.frameworkOwned) {
+      m = m.flatMap((p) => p.nodeType === 11 ? Array.from(p.childNodes) : [p]);
+      for (let p = 0; p < m.length; p += 1) {
+        let b = m[p];
+        d.childNodes[p] !== b && d.insertBefore(b, d.childNodes[p] ?? null);
+      }
+      for (; d.childNodes.length > m.length; ) d.lastChild.remove();
+    } else c || d.append(...m);
+    return l !== void 0 && (d.value = l.value, d instanceof HTMLInputElement && "checked" in l && (d.checked = l.checked), (d instanceof HTMLInputElement || d instanceof HTMLTextAreaElement) && "selectionStart" in l && typeof l.selectionStart == "number" && typeof l.selectionEnd == "number" && (l.focused && d.focus({ preventScroll: true }), d.setSelectionRange(l.selectionStart, l.selectionEnd))), _t(d, e, t, i), [d];
+  }
+  function Xt(e, t, n, r) {
+    let i = [];
+    for (let o of e) i.push(...$e(o, t, n, r));
+    return i;
+  }
+  function Hr(e, t) {
+    return t.projectedSlotNames.get(e) ?? (e instanceof Element ? e.getAttribute("slot") ?? "" : "");
+  }
+  function Mr(e, t, n, r) {
+    let i = e.nameExpression === void 0 ? e.name ?? "" : D(V(e.nameExpression, t)), o = r.projectedNodes.filter((l) => Hr(l, r) === i), a = r.hydrationRanges?.shift();
+    if (a !== void 0) {
+      if (a.fallback) {
+        let l = [], m = 0;
+        for (let f of e.fallback ?? []) {
+          let h = $e(f, t, n, r, a.content[m]);
+          l.push(...h), m += h.length;
+        }
+        return [a.markers[0], ...l, ...a.markers.slice(1)];
+      }
+      for (let l of a.content) le(l);
+      return a.markers.length === 1 ? [a.markers[0]] : [a.markers[0], ...a.content, a.markers[1]];
+    }
+    let s = (l) => `"${l.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")}"`, c = (l, m) => en(n) ? n.createProcessingInstruction(l, m) : n.createComment(`?${l}${m === "" ? "" : ` ${m}`}?`), d = (l, m) => {
+      if (l.length === 0) return [c("marker", `slot=${s(i)}`)];
+      let f = `slot=${s(i)}${m ? ' fallback=""' : ""}`;
+      return [c("start", f), ...l, c("end", "")];
+    };
+    if (o.length === 0) return d(Xt(e.fallback ?? [], t, n, r), true);
+    if (r.committed) {
+      for (let l of o) le(l);
+      return d([...o], false);
+    }
+    let u = n.createComment(`html-next:slot:${i}`);
+    return r.slotInsertions.push({ anchor: u, nodes: o }), d([u], false);
+  }
+  function qt(e) {
+    let t = /* @__PURE__ */ new Map(), n = e.trim(), r = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+    for (; n !== ""; ) {
+      let i = /^([A-Za-z_:][-A-Za-z0-9._:]*)\s*=\s*(?:"([^"<]*)"|'([^'<]*)')(?:\s+|$)/.exec(n);
+      if (i === null || t.has(i[1])) return /* @__PURE__ */ new Map();
+      let o = (i[2] ?? i[3]).replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (a, s) => s.startsWith("#x") ? String.fromCodePoint(parseInt(s.slice(2), 16)) : s.startsWith("#") ? String.fromCodePoint(Number(s.slice(1))) : r[s]);
+      t.set(i[1], o), n = n.slice(i[0].length);
+    }
+    return t;
+  }
+  var Ut = /* @__PURE__ */ new WeakMap();
+  function en(e) {
+    let t = Ut.get(e);
+    if (t === void 0) {
+      let n = e.createElement("div");
+      n.innerHTML = '<?probe x="1"?>', t = n.firstChild?.nodeType === 7, Ut.set(e, t);
+    }
+    return t;
+  }
+  function Wt(e) {
+    if (e.nodeType === 7) {
+      let n = e;
+      return { target: n.target, attributes: qt(n.data) };
+    }
+    if (e.nodeType !== 8 || en(e.ownerDocument)) return;
+    let t = /^\?([A-Za-z][-A-Za-z0-9]*)(?:\s+([\s\S]*?))?\s*\??$/.exec(e.data);
+    return t === null ? void 0 : { target: t[1], attributes: qt(t[2] ?? "") };
+  }
+  function it(e, t = true) {
+    let n = [], r = /* @__PURE__ */ new Set(), i = (s, c) => {
+      for (let d = 0; d < s.length; d += 1) {
+        let u = s[d], l = Wt(u);
+        if (l?.target === "marker" && l.attributes.has("slot")) {
+          c.push({ slot: l.attributes.get("slot"), fallback: false, markers: [u], content: [] });
+          continue;
+        }
+        if (l?.target === "start") {
+          let m = 1, f = [], h;
+          for (d += 1; d < s.length; d += 1) {
+            let p = Wt(s[d]);
+            if (p?.target === "start") m += 1;
+            else if (p?.target === "end" && --m === 0) {
+              h = s[d];
+              break;
+            }
+            f.push(s[d]);
+          }
+          if (l.attributes.has("slot")) {
+            c.push({ slot: l.attributes.get("slot"), fallback: l.attributes.has("fallback"), markers: h ? [u, h] : [u], content: f });
+            for (let p of f) r.add(p);
+          } else i(f, c);
+          continue;
+        }
+        if (u instanceof Element) if (u !== e && u.hasAttribute("data-component-root")) {
+          let m = it(u, false);
+          for (let f of m?.ranges ?? []) i(f.content, c);
+        } else i(Array.from(u.childNodes), c);
+      }
+    };
+    i(Array.from(e.childNodes), n);
+    let o = Array.from(e.children).find((s) => s instanceof HTMLTemplateElement && !s.hasAttribute("data-component") && !r.has(s));
+    if (n.length === 0 && o === void 0) return;
+    let a = [];
+    if (o !== void 0 && t) {
+      for (let s of Array.from(o.content.childNodes)) a.push(e.ownerDocument.adoptNode(s));
+      o.remove();
+    } else o !== void 0 && a.push(...Array.from(o.content.childNodes));
+    return { ranges: n, carried: a };
+  }
+  function Dr(e) {
+    let t = e.cloneNode(true), n = [e, ...Array.from(e.querySelectorAll("*"))], r = [t, ...Array.from(t.querySelectorAll("*"))];
+    return n.forEach((i, o) => {
+      let a = L(i)?.projection;
+      if (a === void 0) return;
+      let s = a.nodes.filter((d) => !i.contains(d));
+      if (s.length === 0) return;
+      let c = t.ownerDocument.createElement("template");
+      for (let d of s) c.content.append(d.cloneNode(true));
+      r[o].append(c);
+    }), t.innerHTML;
+  }
+  function Pr(e) {
+    let t = L(e);
+    if (t === void 0) return;
+    let n = {};
+    for (let o of Object.keys(t.definition.contract.props)) n[o] = t.scope.get(o);
+    let r = {};
+    for (let o of t.projection?.nodes ?? []) {
+      let a = t.projection.slotNames.get(o) ?? (o instanceof Element ? o.getAttribute("slot") ?? "" : "");
+      (r[a] ??= []).push(o instanceof Element ? o.outerHTML.replace(/ data-slotted=""/g, "") : o.textContent ?? "");
+    }
+    let i = Object.fromEntries(Object.entries(r).sort(([o], [a]) => o.localeCompare(a)));
+    return { tag: t.definition.contract.tag, explicit: [...t.explicit].sort(), props: n, slots: i };
+  }
+  function $e(e, t, n, r, i) {
+    if (e.kind === "text") {
+      let o = i instanceof Text ? i : n.createTextNode("");
+      return o.data = e.value, [o];
+    }
+    return e.kind === "slot" ? Mr(e, t, n, r) : Yt(e, t, n, [], r, i);
+  }
+  function jr(e, t) {
+    let n = t.definition.contract.props, r = {}, i = {};
+    for (let [u, l] of Object.entries(n)) {
+      let m = `data-${Y(u)}`;
+      r[m] = u;
+      let f = t.definition.template.attributes.some((h) => h.kind === "attribute" && h.name === m);
+      t.effects.push(ce(t.scope.scheduler, () => {
+        let h = t.scope.get(u);
+        if (!f && !t.explicit.has(u)) return;
+        let p = h === void 0 || h === T || h === null ? null : te(h, l.type);
+        i[m] = p, p === null ? e.removeAttribute(m) : e.setAttribute(m, p);
+      }, 2));
+    }
+    let o = e.ownerDocument.defaultView?.MutationObserver, a = Object.keys(r);
+    if (o === void 0 || a.length === 0) return;
+    let s = new o((u) => {
+      for (let l of u) {
+        let m = l.attributeName;
+        if (m === null) continue;
+        let f = r[m];
+        if (f === void 0) continue;
+        let h = e.getAttribute(m);
+        if (m in i && i[m] === h) {
+          delete i[m];
+          continue;
+        }
+        delete i[m];
+        let p = n[f];
+        h === null ? t.explicit.delete(f) : t.explicit.add(f), t.scope.set(f, h === null ? Bt(f, p, void 0) : rt(p, h, true));
+      }
+    }), c = () => s.observe(e, { attributes: true, attributeFilter: a }), d = () => s.disconnect();
+    t.connectCallbacks.add(c), t.disconnectCallbacks.add(d);
+  }
+  function Lr(e, t) {
+    for (let n of t.definition.declarations ?? []) n.kind === "method" && Object.defineProperty(e, n.name, { configurable: true, enumerable: false, value: (...r) => t.controllerModule === void 0 ? Promise.reject(new TypeError(`Controller method \`${n.name}\` is not ready for <${t.definition.contract.tag}>.`)) : t.controllerModule.then((i) => {
+      let o = i[n.exportName];
+      return typeof o != "function" && y("HJ003", `Controller does not export method \`${n.exportName}\`.`), Reflect.apply(o, void 0, [at(e), ...r]);
+    }) });
+  }
+  function tn(e, t, n, r, i = /* @__PURE__ */ new WeakMap(), o = false) {
+    let a = n && e.contains(e.ownerDocument.activeElement) ? e.ownerDocument.activeElement : null, s = a instanceof HTMLInputElement || a instanceof HTMLTextAreaElement ? [a.selectionStart, a.selectionEnd] : void 0, { scope: c, passThrough: d, effects: u, rootName: l, explicit: m } = fr(e, t, n), f = r, h;
+    if (n && f === void 0) {
+      let g = it(e);
+      if (g !== void 0) {
+        h = g.ranges;
+        let k = [];
+        for (let C of g.ranges) if (!C.fallback) for (let $ of C.content) i.set($, C.slot), k.push($);
+        k.push(...g.carried), f = k;
+      } else ({ projected: f, projectedSlotNames: i } = an(e, t));
+    }
+    let p = n ? f : Array.from(e.childNodes), b = { definition: t, scope: c, refs: {}, effects: u, connectCallbacks: /* @__PURE__ */ new Set(), disconnectCallbacks: /* @__PURE__ */ new Set(), connected: false, explicit: m, frameworkOwned: o, projection: { nodes: n ? f : Array.from(e.childNodes), slotNames: i } }, x = { definition: t, effects: u, refs: b.refs, connectCallbacks: b.connectCallbacks, disconnectCallbacks: b.disconnectCallbacks, projectedNodes: p, projectedSlotNames: i, slotInsertions: [], rootName: l, frameworkOwned: o, committed: n, hydrationRanges: h }, E = Yt(t.template, c, e.ownerDocument, d, x, n ? e : void 0);
+    x.hydrationRanges = void 0;
+    let v = E[0];
+    return n && v !== e && y("HR005", `Server markup for <${t.contract.tag}> has an incompatible root.`), a instanceof HTMLElement && (a.focus({ preventScroll: true }), s !== void 0 && (a instanceof HTMLInputElement || a instanceof HTMLTextAreaElement) && typeof s[0] == "number" && typeof s[1] == "number" && a.setSelectionRange(s[0], s[1])), et(v, t.contract.tag), b.element = v, { invocation: e, nativeRoot: v, context: x, definition: t, instance: b, replace: !n };
+  }
+  function nn(e, t) {
+    t.sort((n, r) => n.invocation.contains(r.invocation) ? -1 : r.invocation.contains(n.invocation) ? 1 : 0);
+    for (let n of t) {
+      for (let r of n.context.slotInsertions) {
+        for (let i of r.nodes) le(i);
+        r.anchor.replaceWith(...r.nodes);
+      }
+      n.replace && n.invocation.replaceWith(n.nativeRoot), n.context.committed = true, nt.set(n.nativeRoot, n.instance), jr(n.nativeRoot, n.instance), Lr(n.nativeRoot, n.instance), st(n.instance);
+    }
+  }
+  function Ft(e, t, n) {
+    e.nodeType === 1 && e.matches(t) && n.add(e);
+    for (let r of e.querySelectorAll(t)) n.add(r);
+  }
+  function rn(e, t) {
+    let n = e.nodeType === 1 ? e : void 0;
+    if (n?.matches("[data-component-root]") === true && t(n), n?.childElementCount !== 0) for (let r of e.querySelectorAll("[data-component-root]")) t(r);
+  }
+  function on(e, t, n) {
+    let r = me(e), i = /* @__PURE__ */ new Set(), o = cr(r);
+    for (let f of t) Ft(f, o, i);
+    let a = [];
+    for (let f of i) f.localName === "template" && f.hasAttribute("component") && !Ne.has(f) && a.push(dr(f, a.length));
+    let s = /* @__PURE__ */ new Map();
+    for (let f of a) {
+      let h = f.definition.contract.tag;
+      (r.definitions.has(h) || s.has(h)) && y("HR001", `More than one definition declares <${h}>.`), s.set(h, f);
+    }
+    let c = [], d = /* @__PURE__ */ new Set(), u = (f, h, p) => {
+      let { definition: b } = f;
+      return Ne.has(h) || e.defaultView?.customElements.get(b.contract.tag) !== void 0 || n?.(h, b, p) === false ? false : (c.push(tn(h, b, p)), true);
+    }, l = (f, h) => {
+      for (let p of h) {
+        let b = f.get(p.localName);
+        if (b !== void 0 && u(b, p, false), !p.hasAttribute("data-component-root")) continue;
+        let x = L(p);
+        if (x !== void 0) {
+          x.frameworkOwned || d.add(p);
+          continue;
+        }
+        let E = false;
+        for (let v of new Set((p.getAttribute("data-component-root") ?? "").split(/\s+/))) {
+          let g = f.get(v);
+          g !== void 0 && u(g, p, true) && (E = true);
+        }
+        E && d.add(p);
+      }
+    };
+    if (l(r.definitions, i), s.size > 0) {
+      let f = ["[data-component-root]", ...Array.from(s.keys())].join(","), h = /* @__PURE__ */ new Set();
+      Ft(e, f, h), l(s, h);
+    }
+    for (let f of a) He(r, f.definition.contract.tag, f), f.style !== void 0 && (f.style.textContent = Se(f.style.textContent ?? "", f.definition.contract.tag, f.definition.template.name), f.wrapper.ownerDocument.head.append(f.style)), f.wrapper.remove();
+    nn(r, c);
+    let m = c.map((f) => f.nativeRoot);
+    for (let f of m) d.add(f);
+    return { lowered: m, roots: Array.from(d) };
+  }
+  function Or(e = document) {
+    return on(e, [e]).lowered.length;
+  }
+  function sn(e, t) {
+    let n = pe(e), r = n.mutationHub;
+    if (r === void 0) {
+      let o = e.defaultView?.MutationObserver;
+      o === void 0 && y("HR003", "Automatic component management requires a browser MutationObserver.");
+      let a = /* @__PURE__ */ new Set(), s = new o((c) => {
+        for (let d of Array.from(a)) d(c);
+      });
+      r = { observer: s, subscribers: a }, n.mutationHub = r, s.observe(e, { childList: true, subtree: true });
+    }
+    r.subscribers.add(t);
+    let i = true;
+    return () => {
+      i && (i = false, r.subscribers.delete(t), r.subscribers.size === 0 && (r.observer.disconnect(), delete n.mutationHub));
+    };
+  }
+  function Ir(e) {
+    let t = pe(e), n = t.lifecycle;
+    if (n !== void 0) return n;
+    let r = 0, i = (s) => {
+      let c = s[Z];
+      c !== void 0 && (s.isConnected && c.disconnect === void 0 ? c.disconnect = c.connect(s) : !s.isConnected && c.disconnect !== void 0 && (c.disconnect(), c.disconnect = void 0));
+    }, o = sn(e, (s) => {
+      let c = [], d = (u) => {
+        if (u.nodeType !== 1) return;
+        let l = u;
+        l[Z] !== void 0 && c.push(l), rn(l, (m) => {
+          m[Z] !== void 0 && c.push(m);
+        });
+      };
+      for (let u of s) {
+        for (let l of u.addedNodes) d(l);
+        for (let l of u.removedNodes) d(l);
+      }
+      for (let u of c) i(u);
+    }), a = { add(s, c) {
+      let d = s, u = d[Z];
+      u !== c && (u?.disconnect?.(), u === void 0 && (r += 1), d[Z] = c, i(s));
+    }, remove(s, c) {
+      let d = s;
+      d[Z] === c && (c.disconnect?.(), delete d[Z], r -= 1, r === 0 && (o(), delete t.lifecycle));
+    } };
+    return t.lifecycle = a, a;
+  }
+  function Vr(e, t, n = {}) {
+    let r = Ir(e.ownerDocument), i = { connect: (a) => ot(a, t, n), disconnect: void 0 };
+    r.add(e, i);
+    let o = false;
+    return () => {
+      o || (o = true, r.remove(e, i));
+    };
+  }
+  function zr(e, t = document) {
+    let n = me(t);
+    for (let r of e) {
+      let i = n.definitions.get(r.contract.tag);
+      if (i !== void 0) {
+        JSON.stringify(i.definition) !== JSON.stringify(r) && y("HR001", `More than one definition declares <${r.contract.tag}>.`);
+        continue;
+      }
+      if (He(n, r.contract.tag, { definition: r, style: void 0 }), r.css !== "") {
+        let o = t.createElement("style");
+        o.dataset.htmlNextPackage = r.contract.tag, o.textContent = Se(r.css, r.contract.tag, r.template.name), t.head.append(o);
+      }
+    }
+  }
+  function an(e, t) {
+    let n = [], r = /* @__PURE__ */ new WeakMap(), i = (o, a) => {
+      let s = a.children.filter((p) => p.kind === "slot"), c = s[0], d = c?.name ?? "", u = s.some((p) => (p.name ?? "") === "") ? "" : d, l = a.children.filter((p) => p.kind === "text").map((p) => p.value), m = 0, f = a.children.filter((p) => p.kind === "element"), h = 0;
+      for (let p of Array.from(o.childNodes)) {
+        if (p instanceof Element) {
+          let b = p.getAttribute("data-component")?.split(/\s+/) ?? [], x = (p.getAttribute("data-component-root") ?? "").split(/\s+/);
+          for (; h < f.length && f[h].name !== p.localName && !x.includes(f[h].name); ) h += 1;
+          let E = f[h], v = E !== void 0 && p.localName !== E.name && x.includes(E.name);
+          !b.includes(t.contract.tag) && !v ? (r.set(p, p.getAttribute("slot") ?? d), le(p), n.push(p)) : (h += 1, E !== void 0 && !v && i(p, E));
+          continue;
+        }
+        if (p instanceof Comment && c !== void 0) {
+          r.set(p, d), n.push(p);
+          continue;
+        }
+        if (p instanceof Text && p.data.trim() !== "") {
+          for (; m < l.length && l[m] !== p.data; ) m += 1;
+          m < l.length ? m += 1 : (r.set(p, u), n.push(p));
+        }
+      }
+    };
+    return i(e, t.template), { projected: n, projectedSlotNames: r };
+  }
+  function ot(e, t, n = {}) {
+    let r = e.ownerDocument, i = me(r), o = i.definitions.get(t.contract.tag);
+    o === void 0 ? He(i, t.contract.tag, { definition: t, style: void 0 }) : JSON.stringify(o.definition) !== JSON.stringify(t) && y("HR001", `More than one definition declares <${t.contract.tag}>.`);
+    let a = L(e);
+    if (a !== void 0 && !a.frameworkOwned && (pe(r).release?.(e), Ae(a), nt.delete(e)), L(e) === void 0) {
+      let { projected: l, projectedSlotNames: m } = an(e, t);
+      de(e, t.contract.tag), et(e, t.contract.tag);
+      for (let [f, h] of Object.entries(t.contract.props)) {
+        let p = n.props?.[f];
+        p != null && e.setAttribute(`data-${Y(f)}`, te(p, h.type));
+      }
+      nn(i, [tn(e, t, true, l, m, true)]);
+    }
+    let c = L(e);
+    c === void 0 && y("HR005", `Could not attach <${t.contract.tag}> to its native root.`), cn(e, n.props ?? {}), st(c);
+    let d, u = false;
+    if (n.controller !== void 0) {
+      let l = Promise.resolve(n.controller);
+      dn(e, l), Promise.resolve(n.controller.default(at(e))).then((m) => {
+        typeof m == "function" && (u ? m() : d = m);
+      });
+    }
+    return () => {
+      u || (u = true, d?.(), Ae(c));
+    };
+  }
+  function cn(e, t) {
+    let n = L(e);
+    if (n !== void 0) for (let [r, i] of Object.entries(t)) {
+      let o = n.definition.contract.props[r];
+      if (o === void 0) continue;
+      let a = `data-${Y(r)}`, s = Bt(r, o, i);
+      i == null ? (n.explicit.delete(r), n.definition.template.attributes.some((d) => d.kind === "attribute" && d.name === a) || e.removeAttribute(a)) : (n.explicit.add(r), e.setAttribute(a, te(i, o.type))), Object.is(n.scope.get(r), s) || n.scope.set(r, s);
+    }
+  }
+  function _r(e, t, n = {}) {
+    let r = me(e.ownerDocument).definitions.get(t);
+    return r === void 0 && y("HR005", `No registered definition declares <${t}>.`), ot(e, r.definition, n);
+  }
+  function st(e) {
+    if (!e.connected) {
+      e.connected = true;
+      for (let t of e.effects) t.resume();
+      for (let t of e.connectCallbacks) t();
+      e.element?.dispatchEvent(new Event("connect"));
+    }
+  }
+  function Ae(e) {
+    if (e.connected) {
+      e.element?.dispatchEvent(new Event("disconnect"));
+      for (let t of e.disconnectCallbacks) t();
+      e.connected = false;
+      for (let t of e.effects) t.pause();
+    }
+  }
+  function at(e) {
+    let t = L(e);
+    if (t === void 0) return;
+    if (t.host !== void 0) return t.host;
+    let n = new Set((t.definition.declarations ?? []).filter((a) => a.kind === "state").map((a) => a.name)), r = new Proxy({}, { get: (a, s) => {
+      if (typeof s != "string") return;
+      let c = t.scope.get(s);
+      return c === T ? void 0 : c;
+    }, set: (a, s, c) => {
+      if (typeof s != "string" || !n.has(s)) throw new TypeError(`Only declared state roots are writable; \`${String(s)}\` is read-only.`);
+      return t.scope.set(s, c), true;
+    }, has: (a, s) => typeof s == "string" && t.scope.has(s) }), i = new Proxy({}, { get: (a, s) => typeof s != "string" ? void 0 : (e instanceof HTMLFormElement ? e : e.querySelector("form"))?.elements.namedItem(s) ?? e.querySelector(`[name="${CSS.escape(s)}"]`) ?? void 0 }), o = { element: e, state: r, refs: t.refs, elements: i, signal(a) {
+      return Ht(a);
+    }, computed(a) {
+      let s = Mt(t.scope.scheduler, a);
+      return t.connected || s.pause(), t.effects.unshift(s), s;
+    }, effect(a) {
+      let s = ce(t.scope.scheduler, a, 2, t.connected);
+      return t.effects.push(s), () => s.stop();
+    }, on(a, s) {
+      if (a === "connect") {
+        let c = s;
+        return t.connectCallbacks.add(c), t.connected && s(), () => t.connectCallbacks.delete(c);
+      }
+      if (a === "disconnect") {
+        let c = s;
+        return t.disconnectCallbacks.add(c), () => t.disconnectCallbacks.delete(c);
+      }
+      return e.addEventListener(a, s), () => e.removeEventListener(a, s);
+    }, dispatch(a, s) {
+      return Gt(e, a, s, Jt(t.definition, a));
+    } };
+    return t.host = Object.freeze(o), t.host;
+  }
+  function dn(e, t) {
+    let n = L(e);
+    n === void 0 && y("HJ003", "A controller can attach only to a lowered component root."), n.controllerModule = t;
+  }
+  function qr(e = document, t = {}) {
+    let n = pe(e);
+    n.observer !== void 0 && y("HR003", "This document is already being observed.");
+    let r = /* @__PURE__ */ new Map(), i = t.onError ?? ((l) => console.error(l)), o = false, a = (l) => {
+      let m = r.get(l);
+      r.delete(l);
+      let f = L(l);
+      f !== void 0 && Ae(f);
+      try {
+        m?.();
+      } catch (h) {
+        i(h);
+      }
+    }, s = (l) => {
+      let m = L(l);
+      if (!(m === void 0 || m.frameworkOwned || r.has(l) || !e.contains(l))) {
+        r.set(l, void 0);
+        try {
+          st(m);
+          let f = t.onConnect?.(l, m.definition);
+          o ? f?.() : r.set(l, f);
+        } catch (f) {
+          i(f);
+        }
+      }
+    }, c = (l) => {
+      if (o) return;
+      let m = [];
+      if (l === void 0) m.push(e);
+      else {
+        let f = [];
+        for (let h of l) {
+          for (let p of h.removedNodes) p.nodeType === 1 && rn(p, (b) => {
+            r.has(b) && f.push(b);
+          });
+          for (let p of h.addedNodes) p.nodeType === 1 && m.push(p);
+        }
+        for (let h of f) e.contains(h) || a(h);
+      }
+      if (m.length > 0) try {
+        for (let f of on(e, m, t.shouldLower).roots) {
+          if (o) break;
+          s(f);
+        }
+      } catch (f) {
+        i(f);
+      }
+    };
+    n.release = (l) => {
+      r.has(l) && a(l);
+    };
+    let d = sn(e, c), u = () => {
+      if (!o) {
+        o = true, d(), delete n.observer, delete n.release;
+        for (let l of r.values()) try {
+          l?.();
+        } catch (m) {
+          i(m);
+        }
+        for (let l of r.keys()) {
+          let m = L(l);
+          m !== void 0 && Ae(m);
+        }
+        r.clear();
+      }
+    };
+    return n.observer = u, c(), u;
+  }
+  return hn(Ur);
+})();
+var { attachComponent, attachRegisteredComponent, getComponentHost, installComponentGraph, lowerDocument, manageComponentLifecycle, observeDocument, registerComponentDefinitions, serializeRenderedForm, setControllerModule, updateComponentProps } = HtmlRuntime;
+
+// src/declarative.ts
+var stateKey = /* @__PURE__ */ Symbol.for("@threadlabs/looma.declarative.v1");
+var stateTarget = globalThis;
+var state = stateTarget[stateKey] ??= {
+  runtime: {
+    attachRegisteredComponent,
+    getComponentHost,
+    manageComponentLifecycle,
+    observeDocument,
+    setControllerModule,
+    updateComponentProps
+  },
+  records: /* @__PURE__ */ new Map(),
+  installedPackages: /* @__PURE__ */ new Set(),
+  stopObservation: void 0,
+  observationScheduled: false
+};
+function connectController(element, tag) {
+  const controller = state.records.get(tag)?.controller;
+  if (!controller?.default) return;
+  state.runtime.setControllerModule(element, Promise.resolve(controller));
+  return controller.default(state.runtime.getComponentHost(element));
+}
+function scheduleObservation() {
+  if (state.observationScheduled || typeof document === "undefined") return;
+  state.observationScheduled = true;
+  queueMicrotask(() => {
+    state.observationScheduled = false;
+    state.stopObservation?.();
+    state.stopObservation = state.runtime.observeDocument(document, {
+      onConnect(element, definition) {
+        return connectController(element, definition.contract.tag);
+      }
+    });
+  });
+}
+function registerLoomaPackage(name, packageRecords, styles) {
+  if (typeof document === "undefined" || state.installedPackages.has(name)) return;
+  state.stopObservation?.();
+  state.stopObservation = void 0;
+  state.installedPackages.add(name);
+  const definitions = document.createElement("div");
+  definitions.hidden = true;
+  definitions.dataset.loomaDefinitions = name;
+  definitions.innerHTML = packageRecords.map(({ source }) => source).join("\n");
+  document.head.append(...Array.from(definitions.children));
+  for (const record of packageRecords) state.records.set(record.tag, record);
+  if (styles !== "") {
+    const style = document.createElement("style");
+    style.dataset.loomaStyles = name;
+    style.textContent = styles;
+    document.head.append(style);
+  }
+  scheduleObservation();
+}
+function attachLoomaComponent(element, definition, tag, props) {
+  if (definition.contract.tag !== tag) {
+    throw new TypeError(`Looma definition ${definition.contract.tag} cannot attach as ${tag}.`);
+  }
+  const controller = state.records.get(tag)?.controller;
+  return state.runtime.attachRegisteredComponent(element, tag, { props, controller });
+}
+function updateComponentProps2(element, props) {
+  (state.runtime.updateComponentProps ?? updateComponentProps)(element, props);
+}
+function controllerFor(tag) {
+  return state.records.get(tag)?.controller;
+}
+function manageComponentLifecycle2(...args) {
+  return state.runtime.manageComponentLifecycle(...args);
+}
+
+export {
+  registerLoomaPackage,
+  attachLoomaComponent,
+  updateComponentProps2 as updateComponentProps,
+  controllerFor,
+  manageComponentLifecycle2 as manageComponentLifecycle
+};