@jasonshimmy/custom-elements-runtime 3.2.0 → 3.3.0

package/dist/template-compiler-Cs5axmn4.js

@@ -0,0 +1,3236 @@
+import { r as Y, t as I } from "./logger-L25axmB-.js";
+import { a as yt, i as z, n as mt, o as Ce, r as G } from "./namespace-helpers-BucDdgz_.js";
+import { B as Be, D as ot, E as K, F as Z, G as gt, K as bt, M as F, N as Pe, O as Ge, P as Fe, W as Et, X as be, c as Je, j as P, q as vt, t as Ze, w as St, z as O } from "./hooks-_3xP4G2N.js";
+import { a as Xe, d as Ee, f as kt, i as Ct, n as _t, r as At, u as Le } from "./css-utils-CC43BbEy.js";
+import { resetWhenCounter as Ye } from "./custom-elements-runtime.directives.es.js";
+import { getTransitionStyleSheet as Tt } from "./custom-elements-runtime.transitions.es.js";
+function wt(e, i, n) {
+  if (n)
+    for (const [s, r] of Object.entries(n)) {
+      let o, t = {};
+      if (Array.isArray(r) ? (o = r[0], t = r[1] || {}) : o = r, i.set(s, {
+        callback: o,
+        options: t,
+        oldValue: K(e, s)
+      }), t.immediate) try {
+        const a = K(e, s);
+        o(a, void 0, e);
+      } catch (a) {
+        I(`Error in immediate watcher for "${s}":`, a);
+      }
+    }
+}
+function Lt(e, i, n, s) {
+  const r = (t, a) => {
+    if (t === a) return !0;
+    if (typeof t != typeof a || typeof t != "object" || t === null || a === null) return !1;
+    if (Array.isArray(t) && Array.isArray(a))
+      return t.length !== a.length ? !1 : t.every((y, S) => r(y, a[S]));
+    const h = t, d = a, m = Object.keys(h || {}), b = Object.keys(d || {});
+    return m.length !== b.length ? !1 : m.every((y) => r(h[y], d[y]));
+  }, o = i.get(n);
+  if (o && !r(s, o.oldValue)) try {
+    o.callback(s, o.oldValue, e), o.oldValue = s;
+  } catch (t) {
+    I(`Error in watcher for "${n}":`, t);
+  }
+  for (const [t, a] of i.entries()) if (a.options.deep && n.startsWith(t + ".")) try {
+    const h = K(e, t);
+    r(h, a.oldValue) || (a.callback(h, a.oldValue, e), a.oldValue = h);
+  } catch (h) {
+    I(`Error in deep watcher for "${t}":`, h);
+  }
+}
+function Ie(e, i) {
+  return i === Boolean ? e === "" || e === "true" : i === Number ? Number(e) : e;
+}
+function Nt(e, i, n) {
+  if (i)
+    for (const s in i) {
+      const r = i[s], o = Z(s), t = e.getAttribute(o);
+      if (r.type === Function && typeof e[s] == "function") n[s] = e[s];
+      else if (t !== null) n[s] = Ie(t, r.type);
+      else if (typeof e[s] < "u") try {
+        const a = e[s];
+        if (r.type === String && a && typeof a == "object") try {
+          n[s] = Ie(String(a), r.type);
+        } catch {
+          n[s] = a;
+        }
+        else r.type === Boolean && typeof a == "boolean" || r.type === Number && typeof a == "number" || r.type === Function && typeof a == "function" ? n[s] = a : n[s] = Ie(String(a), r.type);
+      } catch {
+        n[s] = e[s];
+      }
+      else "default" in r && r.default !== void 0 && (n[s] = r.default);
+    }
+}
+function Mt(e, i, n) {
+  if (!i.props) {
+    try {
+      const s = n?._hookCallbacks?.props || {}, r = Array.from(/* @__PURE__ */ new Set([...Object.keys(e || {}), ...Object.keys(s || {})]));
+      for (const o of r) {
+        if (typeof o != "string" || o.startsWith("_")) continue;
+        const t = Object.getOwnPropertyDescriptor(n, o);
+        if (!(!Object.prototype.hasOwnProperty.call(s, o) && t && (t.get || t.set || !t.configurable)))
+          try {
+            Object.defineProperty(n, o, {
+              enumerable: !0,
+              configurable: !0,
+              get() {
+                try {
+                  const a = Z(o), h = e.getAttribute(a);
+                  if (h !== null) return h;
+                  const d = e[o];
+                  let m;
+                  return O(d) || d && typeof d == "object" && "value" in d && !(typeof Node < "u" && d instanceof Node) ? m = d.value : m = d, m;
+                } catch {
+                  return e[o];
+                }
+              }
+            });
+          } catch {
+          }
+      }
+    } catch {
+    }
+    return;
+  }
+  Nt(e, i.props, n);
+}
+function Qe(e, i, n, s) {
+  e.onConnected && !n && (e.onConnected(i), s(!0));
+}
+function $t(e, i, n, s, r, o, t, a) {
+  e.onDisconnected && e.onDisconnected(i), n.forEach((h) => h()), s(), r(), o(!1), t(null), a(!1);
+}
+function jt(e, i, n, s, r) {
+  e.onAttributeChanged && e.onAttributeChanged(i, n, s, r);
+}
+var J = class {
+  static cleanupFunctions = /* @__PURE__ */ new WeakMap();
+  static addListener(e, i, n, s) {
+    e.addEventListener(i, n, s);
+    const o = {
+      event: i,
+      handler: n,
+      wrapper: n,
+      options: s,
+      cleanup: () => e.removeEventListener(i, n, s),
+      addedAt: Date.now()
+    };
+    this.cleanupFunctions.has(e) || this.cleanupFunctions.set(e, []), this.cleanupFunctions.get(e).push(o);
+  }
+  static removeListener(e, i, n, s) {
+    e.removeEventListener(i, n, s);
+    const r = this.cleanupFunctions.get(e);
+    if (r)
+      for (let o = 0; o < r.length; o++) {
+        const t = r[o];
+        if (t.event === i && t.handler === n) {
+          r.splice(o, 1), r.length === 0 && this.cleanupFunctions.delete(e);
+          return;
+        }
+      }
+  }
+  static cleanup(e) {
+    const i = this.cleanupFunctions.get(e);
+    i && (i.forEach((n) => {
+      try {
+        n.cleanup();
+      } catch {
+      }
+    }), this.cleanupFunctions.delete(e));
+  }
+  static cleanupAll() {
+    this.cleanupFunctions = /* @__PURE__ */ new WeakMap();
+  }
+  static hasListeners(e) {
+    const i = this.cleanupFunctions.get(e);
+    return !!(i && i.length > 0);
+  }
+  static getListenerCount(e) {
+    const i = this.cleanupFunctions.get(e);
+    return i ? i.length : 0;
+  }
+  static getListenerInfo(e) {
+    const i = this.cleanupFunctions.get(e);
+    return i ? i.map((n) => ({
+      event: n.event,
+      handler: n.handler,
+      wrapper: n.wrapper,
+      options: n.options
+    })) : [];
+  }
+}, at = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(e) {
+    this.maxSize = Math.max(1, e);
+  }
+  get(e) {
+    const i = this.map.get(e);
+    if (i !== void 0)
+      return this.map.delete(e), this.map.set(e, i), i;
+  }
+  set(e, i) {
+    if (this.map.has(e) && this.map.delete(e), this.map.set(e, i), this.map.size > this.maxSize) {
+      const n = this.map.keys().next().value;
+      this.map.delete(n);
+    }
+  }
+  has(e) {
+    return this.map.has(e);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+}, Ot = () => {
+  if (typeof navigator < "u" && "deviceMemory" in navigator) {
+    const e = navigator.deviceMemory;
+    if (e) return Math.min(1e3, Math.max(200, e * 100));
+  }
+  return (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV === "test";
+    } catch {
+      return !1;
+    }
+  })() ? 100 : 500;
+}, Re = new at(Ot()), Pt = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "return",
+  "this",
+  "class",
+  "extends",
+  "import",
+  "export",
+  "from",
+  "as",
+  "async",
+  "await",
+  "yield",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "finally",
+  "let",
+  "const",
+  "var",
+  "function",
+  "NaN",
+  "Infinity"
+]), Ht = class {
+  static cache = new at(1e3);
+  static dangerousPatterns = [
+    /constructor/i,
+    /prototype/i,
+    /__proto__/i,
+    /\bfunction\b/i,
+    /eval/i,
+    /import/i,
+    /require/i,
+    /window/i,
+    /document/i,
+    /global/i,
+    /process/i,
+    /setTimeout/i,
+    /setInterval/i,
+    /fetch/i,
+    /XMLHttpRequest/i
+  ];
+  static evaluate(e, i) {
+    const n = this.cache.get(e);
+    if (n) {
+      if (!n.isSecure) {
+        Y("Blocked cached dangerous expression:", e);
+        return;
+      }
+      return n.evaluator(i);
+    }
+    const s = this.createEvaluator(e);
+    if (this.cache.set(e, s), !s.isSecure) {
+      Y("Blocked dangerous expression:", e);
+      return;
+    }
+    return s.evaluator(i);
+  }
+  static createEvaluator(e) {
+    if (this.hasDangerousPatterns(e)) return {
+      evaluator: () => {
+      },
+      isSecure: !1
+    };
+    if (e.length > 1e3) return {
+      evaluator: () => {
+      },
+      isSecure: !1
+    };
+    try {
+      return {
+        evaluator: this.createSafeEvaluator(e),
+        isSecure: !0
+      };
+    } catch (i) {
+      return Y("Failed to create evaluator for expression:", e, i), {
+        evaluator: () => {
+        },
+        isSecure: !1
+      };
+    }
+  }
+  static hasDangerousPatterns(e) {
+    return this.dangerousPatterns.some((i) => i.test(e));
+  }
+  static createSafeEvaluator(e) {
+    const i = e.trim();
+    if (i.startsWith("{") && i.endsWith("}")) return this.createObjectEvaluator(e);
+    if (/^ctx\.[a-zA-Z0-9_.]+$/.test(e.trim())) {
+      const n = e.trim().slice(4);
+      return (s) => K(s, n);
+    }
+    return e.includes("ctx") || /[+\-*/%<>=&|?:[\]]/.test(e) ? this.createSimpleEvaluator(e) : (n) => K(n, e);
+  }
+  static createObjectEvaluator(e) {
+    const i = e.trim().slice(1, -1), n = this.parseObjectProperties(i);
+    return (s) => {
+      const r = {};
+      for (const { key: o, value: t } of n) try {
+        t.startsWith("ctx.") ? r[o] = K(s, t.slice(4)) : r[o] = this.evaluateSimpleValue(t, s);
+      } catch {
+        r[o] = void 0;
+      }
+      return r;
+    };
+  }
+  static parseObjectProperties(e) {
+    const i = [], n = [];
+    let s = 0, r = null, o = 0;
+    for (let t = 0; t < e.length; t++) {
+      const a = e[t];
+      if (r) {
+        if (a === "\\") {
+          t++;
+          continue;
+        }
+        a === r && (r = null);
+      } else a === '"' || a === "'" ? r = a : a === "(" || a === "[" || a === "{" ? s++ : a === ")" || a === "]" || a === "}" ? s-- : a === "," && s === 0 && (n.push(e.slice(o, t)), o = t + 1);
+    }
+    n.push(e.slice(o));
+    for (const t of n) {
+      let a = -1, h = 0, d = null;
+      for (let S = 0; S < t.length; S++) {
+        const M = t[S];
+        if (d) {
+          if (M === "\\") {
+            S++;
+            continue;
+          }
+          M === d && (d = null);
+        } else if (M === '"' || M === "'") d = M;
+        else if (M === "(" || M === "[" || M === "{") h++;
+        else if (M === ")" || M === "]" || M === "}") h--;
+        else if (M === ":" && h === 0) {
+          a = S;
+          break;
+        }
+      }
+      if (a === -1) continue;
+      const m = t.slice(0, a).trim(), b = t.slice(a + 1).trim(), y = m.replace(/^['"]|['"]$/g, "");
+      i.push({
+        key: y,
+        value: b
+      });
+    }
+    return i;
+  }
+  static createSimpleEvaluator(e) {
+    return (i) => {
+      try {
+        let n = e;
+        const s = [];
+        n = n.replace(/("[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*')/g, (d) => `<<#${s.push(d) - 1}#>>`);
+        const r = n.match(/ctx\.[\w.]+/g) || [];
+        for (const d of r) {
+          const m = K(i, d.slice(4));
+          if (m === void 0) return;
+          const b = s.push(JSON.stringify(m)) - 1;
+          n = n.split(d).join(`<<#${b}#>>`);
+        }
+        const o = n.match(/\b[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+\b/g) || [];
+        for (const d of o) {
+          if (d.startsWith("ctx.")) continue;
+          const m = K(i, d);
+          if (m === void 0) return;
+          const b = s.push(JSON.stringify(m)) - 1;
+          n = n.split(d).join(`<<#${b}#>>`);
+        }
+        const t = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+        let a;
+        const h = /* @__PURE__ */ new Set();
+        for (; (a = t.exec(n)) !== null; ) {
+          const d = a[1];
+          if (Pt.has(d) || /^[0-9]+$/.test(d) || d === "ctx" || h.has(d)) continue;
+          h.add(d);
+          const m = K(i, d);
+          if (m === void 0) return;
+          const b = JSON.stringify(m), y = s.push(b) - 1;
+          d.includes(".") ? n = n.split(d).join(`<<#${y}#>>`) : n = n.replace(new RegExp("\\b" + d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\b", "g"), `<<#${y}#>>`), t.lastIndex = 0;
+        }
+        n = n.replace(/<<#(\d+)#>>/g, (d, m) => s[Number(m)]);
+        try {
+          return this.evaluateBasicExpression(n);
+        } catch {
+          return;
+        }
+      } catch {
+        return;
+      }
+    };
+  }
+  static evaluateBasicExpression(e) {
+    const i = this.tokenize(e);
+    let n = 0;
+    function s() {
+      return i[n];
+    }
+    function r(u) {
+      const p = i[n++];
+      if (u && !p) throw new Error(`Unexpected token EOF, expected ${u}`);
+      if (u && p && p.type !== u && p.value !== u)
+        throw new Error(`Unexpected token ${p.type}/${p.value}, expected ${u}`);
+      return p;
+    }
+    function o() {
+      return S();
+    }
+    function t(u) {
+      if (typeof u == "number") return u;
+      if (u == null) return NaN;
+      if (typeof u == "boolean") return u ? 1 : 0;
+      const p = Number(u);
+      return Number.isNaN(p) ? NaN : p;
+    }
+    function a(u, p) {
+      return typeof u == "string" || typeof p == "string" ? String(u) + String(p) : t(u) + t(p);
+    }
+    function h(u, p) {
+      return t(u) - t(p);
+    }
+    function d(u, p) {
+      return t(u) * t(p);
+    }
+    function m(u, p) {
+      return t(u) / t(p);
+    }
+    function b(u, p) {
+      return t(u) % t(p);
+    }
+    function y(u, p, C) {
+      if (typeof p == "number" && typeof C == "number") switch (u) {
+        case ">":
+          return p > C;
+        case "<":
+          return p < C;
+        case ">=":
+          return p >= C;
+        case "<=":
+          return p <= C;
+        default:
+          return !1;
+      }
+      const c = String(p), v = String(C);
+      switch (u) {
+        case ">":
+          return c > v;
+        case "<":
+          return c < v;
+        case ">=":
+          return c >= v;
+        case "<=":
+          return c <= v;
+        default:
+          return !1;
+      }
+    }
+    function S() {
+      const u = M(), p = s();
+      if (p && p.value === "?") {
+        r("?");
+        const C = o();
+        r(":");
+        const c = o();
+        return u ? C : c;
+      }
+      return u;
+    }
+    function M() {
+      let u = l();
+      for (; ; ) {
+        const p = s();
+        if (!p || p.value !== "||") break;
+        r("OP");
+        const C = l();
+        u = u || C;
+      }
+      return u;
+    }
+    function l() {
+      let u = k();
+      for (; ; ) {
+        const p = s();
+        if (!p || p.value !== "&&") break;
+        r("OP");
+        const C = k();
+        u = u && C;
+      }
+      return u;
+    }
+    function k() {
+      let u = T();
+      for (; ; ) {
+        const p = s();
+        if (!p || ![
+          "==",
+          "!=",
+          "===",
+          "!=="
+        ].includes(p.value)) break;
+        const C = r("OP").value, c = T();
+        switch (C) {
+          case "==":
+            u = u == c;
+            break;
+          case "!=":
+            u = u != c;
+            break;
+          case "===":
+            u = u === c;
+            break;
+          case "!==":
+            u = u !== c;
+            break;
+        }
+      }
+      return u;
+    }
+    function T() {
+      let u = E();
+      for (; ; ) {
+        const p = s();
+        if (!p || ![
+          ">",
+          "<",
+          ">=",
+          "<="
+        ].includes(p.value)) break;
+        const C = r("OP").value, c = E();
+        switch (C) {
+          case ">":
+            u = y(">", u, c);
+            break;
+          case "<":
+            u = y("<", u, c);
+            break;
+          case ">=":
+            u = y(">=", u, c);
+            break;
+          case "<=":
+            u = y("<=", u, c);
+            break;
+        }
+      }
+      return u;
+    }
+    function E() {
+      let u = f();
+      for (; ; ) {
+        const p = s();
+        if (!p || p.value !== "+" && p.value !== "-") break;
+        const C = r("OP").value, c = f();
+        u = C === "+" ? a(u, c) : h(u, c);
+      }
+      return u;
+    }
+    function f() {
+      let u = _();
+      for (; ; ) {
+        const p = s();
+        if (!p || p.value !== "*" && p.value !== "/" && p.value !== "%") break;
+        const C = r("OP").value, c = _();
+        switch (C) {
+          case "*":
+            u = d(u, c);
+            break;
+          case "/":
+            u = m(u, c);
+            break;
+          case "%":
+            u = b(u, c);
+            break;
+        }
+      }
+      return u;
+    }
+    function _() {
+      const u = s();
+      return u && u.value === "!" ? (r("OP"), !_()) : u && u.value === "-" ? (r("OP"), h(0, _())) : g();
+    }
+    function g() {
+      const u = s();
+      if (u) {
+        if (u.type === "NUMBER")
+          return r("NUMBER"), Number(u.value);
+        if (u.type === "STRING")
+          return r("STRING"), u.value.slice(1, -1);
+        if (u.type === "IDENT")
+          return r("IDENT"), u.value === "true" ? !0 : u.value === "false" ? !1 : u.value === "null" ? null : void 0;
+        if (u.value === "[") {
+          r("PUNC");
+          const p = [];
+          for (; ; ) {
+            const C = s();
+            if (!C || C.value === "]") break;
+            p.push(o());
+            const c = s();
+            c && c.value === "," && r("PUNC");
+          }
+          return r("PUNC"), p;
+        }
+        if (u.value === "(") {
+          r("PUNC");
+          const p = o();
+          return r("PUNC"), p;
+        }
+        throw new Error("Unexpected token in expression");
+      }
+    }
+    return o();
+  }
+  static tokenize(e) {
+    const i = [], n = /\s*(=>|===|!==|==|!=|>=|<=|\|\||&&|[()?:,[\]]|\+|-|\*|\/|%|>|<|!|\d+\.?\d*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[a-zA-Z_][a-zA-Z0-9_]*|\S)\s*/g;
+    let s;
+    for (; (s = n.exec(e)) !== null; ) {
+      const r = s[1];
+      r && (/^\d/.test(r) ? i.push({
+        type: "NUMBER",
+        value: r
+      }) : /^"/.test(r) || /^'/.test(r) ? i.push({
+        type: "STRING",
+        value: r
+      }) : /^[a-zA-Z_]/.test(r) ? i.push({
+        type: "IDENT",
+        value: r
+      }) : /^[()?:,[\]]$/.test(r) ? i.push({
+        type: "PUNC",
+        value: r
+      }) : i.push({
+        type: "OP",
+        value: r
+      }));
+    }
+    return i;
+  }
+  static evaluateSimpleValue(e, i) {
+    return e === "true" ? !0 : e === "false" ? !1 : isNaN(Number(e)) ? e.startsWith("ctx.") ? K(i, e.slice(4)) : e.startsWith('"') && e.endsWith('"') || e.startsWith("'") && e.endsWith("'") ? e.slice(1, -1) : e : Number(e);
+  }
+  static clearCache() {
+    this.cache.clear();
+  }
+  static getCacheSize() {
+    return this.cache.size;
+  }
+};
+function Ne(e, i) {
+  return Array.isArray(e) && Array.isArray(i) ? JSON.stringify([...e].sort()) !== JSON.stringify([...i].sort()) : e !== i;
+}
+function et(e, i, n, s, r) {
+  if (e) {
+    const o = i.value;
+    if (r && typeof o == "object" && o !== null) {
+      const t = { ...o };
+      t[r] = n, i.value = t;
+    } else i.value = n;
+  } else Pe(s._state || s, i, n);
+}
+function Me(e, i, n, s) {
+  if (typeof e._requestRender == "function" && e._requestRender(), typeof e._triggerWatchers == "function") {
+    const r = i ? "reactiveState" : n;
+    e._triggerWatchers(r, s);
+  }
+}
+function xt(e, i, n) {
+  const s = `update:${Z(i)}`, r = `update:${i}`, o = new CustomEvent(s, {
+    detail: n,
+    bubbles: !0,
+    cancelable: !0
+  }), t = new CustomEvent(r, {
+    detail: n,
+    bubbles: !0,
+    cancelable: !0
+  });
+  e.dispatchEvent(o), e.dispatchEvent(t);
+}
+function tt(e, i, n, s) {
+  const r = n;
+  if (P(() => {
+    if (typeof e.setAttribute == "function") try {
+      e[i] = r;
+    } catch {
+    }
+    else e[i] = r;
+  }), r == null || typeof r == "string" || typeof r == "number" || typeof r == "boolean") {
+    const o = F(r);
+    o !== null ? P(() => {
+      typeof e.setAttribute == "function" && z(e, Z(i), String(o));
+    }) : P(() => {
+      typeof e.removeAttribute == "function" && G(e, Z(i));
+    });
+  }
+}
+function It(e, i, n, s) {
+  if (e) {
+    const r = i.value;
+    return s && typeof r == "object" && r !== null ? r[s] : r;
+  } else return K(n._state || n, i);
+}
+function _e(e) {
+  return e != null && typeof e == "object" && "value" in e;
+}
+function De(e) {
+  return e != null && typeof e == "object" && "value" in e ? e.value : e;
+}
+function re(e, i, n) {
+  if (!e) return;
+  e.attrs || (e.attrs = {});
+  const s = e.attrs;
+  s[i] = n;
+}
+function X(e) {
+  return e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement;
+}
+function fe(e) {
+  return e != null && typeof e == "object" && "value" in e ? fe(e.value) : !(e != null && typeof e == "object" || e === !1 || e === "false" || e === null || e === void 0 || e === 0);
+}
+function ct(e) {
+  return e.substring(2, 3).toLowerCase() + e.substring(3);
+}
+function ze(e) {
+  return typeof e == "boolean" || e === "true" || e === "false";
+}
+function Rt(e, i, n, s, r, o, t, a) {
+  if (!o) return;
+  const h = i.includes("lazy"), d = i.includes("trim"), m = i.includes("number"), b = () => {
+    if (O(e)) {
+      const E = e.value;
+      return a && t && (t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLSelectElement) && typeof E == "object" && E !== null ? E[a] : E;
+    }
+    return K(o?._state || o, e);
+  }, y = b();
+  let S = "text";
+  t instanceof HTMLInputElement ? S = s?.type || t.type || "text" : t instanceof HTMLSelectElement ? S = "select" : t instanceof HTMLTextAreaElement && (S = "textarea");
+  const M = t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLSelectElement, l = M ? S === "checkbox" || S === "radio" ? "checked" : "value" : a ?? "modelValue";
+  if (S === "checkbox") Array.isArray(y) ? n[l] = y.includes(String(t?.getAttribute("value") ?? s?.value ?? "")) : n[l] = y === (t?.getAttribute("true-value") ?? !0);
+  else if (S === "radio") n[l] = y === (s?.value ?? "");
+  else if (S === "select") if (t && t.hasAttribute("multiple") && t instanceof HTMLSelectElement) {
+    const E = Array.isArray(y) ? y.map(String) : [];
+    queueMicrotask(() => {
+      Array.from(t.options).forEach((f) => {
+        f.selected = E.includes(f.value);
+      });
+    }), n[l] = Array.isArray(y) ? y : [];
+  } else n[l] = y;
+  else if (!M && O(e)) n[l] = e;
+  else {
+    n[l] = y;
+    try {
+      const E = Z(l);
+      s && (s[E] = y);
+    } catch {
+    }
+  }
+  const k = h || S === "checkbox" || S === "radio" || S === "select" ? "change" : "input", T = (E) => {
+    if (E.isComposing || r._isComposing) return;
+    const f = globalThis.process, _ = !!f && f.env?.NODE_ENV === "test" || typeof window < "u" && globalThis.__vitest__;
+    if (E.isTrusted === !1 && !_) return;
+    const g = E.target;
+    if (!g || g._modelUpdating) return;
+    let u = g.value;
+    if (S === "checkbox") {
+      const C = b();
+      if (Array.isArray(C)) {
+        const c = g.getAttribute("value") ?? "", v = Array.from(C);
+        if (g.checked)
+          v.includes(c) || v.push(c);
+        else {
+          const A = v.indexOf(c);
+          A > -1 && v.splice(A, 1);
+        }
+        u = v;
+      } else {
+        const c = g.getAttribute("true-value") ?? !0, v = g.getAttribute("false-value") ?? !1;
+        u = g.checked ? c : v;
+      }
+    } else if (S === "radio") u = g.getAttribute("value") ?? g.value;
+    else if (S === "select" && g.multiple) u = Array.from(g.selectedOptions).map((C) => C.value);
+    else if (d && typeof u == "string" && (u = u.trim()), m) {
+      const C = Number(u);
+      isNaN(C) || (u = C);
+    }
+    const p = b();
+    if (Ne(u, p)) {
+      g._modelUpdating = !0;
+      try {
+        et(O(e), e, u, o, a), Me(o, O(e), e, u), g && xt(g, l, u);
+      } finally {
+        queueMicrotask(() => g._modelUpdating = !1);
+      }
+    }
+  };
+  if (M) {
+    if (r[k]) {
+      const E = r[k];
+      t && J.removeListener(t, k, E);
+    }
+    r[k] = T;
+  } else {
+    const E = `update:${Z(l)}`, f = `update:${l}`;
+    if (r[E]) {
+      const _ = r[E];
+      t && J.removeListener(t, E, _);
+    }
+    if (r[f]) {
+      const _ = r[f];
+      t && J.removeListener(t, f, _);
+    }
+    if (r[E] = (_) => {
+      const g = _.detail;
+      let u = g !== void 0 ? g : void 0;
+      if (u === void 0) {
+        const C = _.target;
+        if (C && typeof C == "object" && "value" in C) try {
+          u = C.value;
+        } catch {
+          u = void 0;
+        }
+      }
+      const p = It(O(e), e, o, a);
+      if (Ne(u, p)) {
+        et(O(e), e, u, o, a), Me(o, O(e), e, u);
+        const C = _.target;
+        C && tt(C, l, O(e) ? e : u, O(e));
+      }
+    }, O(e) && typeof e.value == "object" && e.value !== null) {
+      let _;
+      try {
+        _ = Reflect.ownKeys(e.value);
+      } catch {
+        _ = Object.keys(e.value);
+      }
+      const g = _.filter((p) => typeof p == "string" && !String(p).startsWith("_") && p !== "constructor"), u = new Set(g.map((p) => `update:${Z(p)}`));
+      for (const p of Object.keys(r)) p.startsWith("update:") && p !== E && p !== f && !u.has(p) && (t && J.removeListener(t, p, r[p]), delete r[p]);
+      for (const p of g) {
+        const C = String(p), c = `update:${Z(C)}`, v = `update:${C}`;
+        c !== E && (r[c] && t && (J.removeListener(t, c, r[c]), delete r[c]), r[c] = (A) => {
+          const L = A.detail !== void 0 ? A.detail : A.target?.value;
+          if (!Ne(L, O(e) ? e.value[C] : K(o?._state || o, e))) return;
+          if (O(e)) {
+            const $ = { ...e.value };
+            $[C] = L, e.value = $;
+          } else Pe(o?._state || o, e, L);
+          Me(o, O(e), e, L);
+          const w = A.currentTarget || t || A.target;
+          w && tt(w, l, O(e) ? e : L, O(e));
+        }, r[v] = r[c]);
+      }
+    }
+    r[f] = r[E];
+  }
+  (S === "text" || S === "textarea") && (r.compositionstart = () => r._isComposing = !0, r.compositionend = (E) => {
+    r._isComposing = !1;
+    const f = E.target;
+    f && queueMicrotask(() => {
+      const _ = f.value, g = o?._state || o, u = K(g, e);
+      let p = _;
+      if (d && (p = p.trim()), m) {
+        const C = Number(p);
+        isNaN(C) || (p = C);
+      }
+      if (Ne(p, u)) {
+        f._modelUpdating = !0;
+        try {
+          Pe(g, e, p), Me(o, O(e), e, p);
+        } finally {
+          queueMicrotask(() => f._modelUpdating = !1);
+        }
+      }
+    });
+  });
+}
+function Wt(e, i, n, s, r) {
+  if (typeof e == "object" && e !== null) for (const [o, t] of Object.entries(e)) if (o.startsWith("data-") || o.startsWith("aria-") || o === "class") n[o] = t;
+  else if (o === "disabled" && r && X(r)) {
+    const a = t && typeof t == "object" && "value" in t;
+    (() => {
+      try {
+        return O(t);
+      } catch {
+        return !1;
+      }
+    })() || a ? i[o] = t : n[o] = t;
+  } else i[o] = t;
+  else if (typeof e == "string") {
+    if (!s) return;
+    try {
+      const o = we(e, s);
+      if (typeof o == "object" && o !== null) {
+        for (const [t, a] of Object.entries(o)) if (t.startsWith("data-") || t.startsWith("aria-") || t === "class") n[t] = a;
+        else if (t === "disabled" && r && X(r)) {
+          const h = a && typeof a == "object" && "value" in a;
+          (() => {
+            try {
+              return O(a);
+            } catch {
+              return !1;
+            }
+          })() || h ? i[t] = a : n[t] = a;
+        } else i[t] = a;
+        return;
+      } else {
+        n[e] = o;
+        return;
+      }
+    } catch {
+      n[e] = K(s, e);
+    }
+  }
+}
+function Bt(e, i, n) {
+  let s;
+  if (typeof e == "string") {
+    if (!n) return;
+    s = we(e, n);
+  } else s = e;
+  const r = String(i.style || "");
+  let o = r;
+  if (s) {
+    if (r) {
+      const t = String(r).split(";").map((h) => h.trim()).filter(Boolean), a = t.findIndex((h) => h.startsWith("display:"));
+      a >= 0 && t[a] === "display: none" && (t.splice(a, 1), o = t.length > 0 ? t.join("; ") + ";" : "");
+    }
+  } else if (r) {
+    const t = String(r).split(";").filter(Boolean), a = t.findIndex((h) => h.trim().startsWith("display:"));
+    a >= 0 ? t[a] = "display: none" : t.push("display: none"), o = t.join("; ");
+  } else o = "display: none";
+  o !== r && (o ? i.style = o : i.style = void 0);
+}
+function we(e, i) {
+  return Ht.evaluate(e, i);
+}
+function Dt(e, i, n, s) {
+  let r;
+  if (typeof e == "string") {
+    if (!n) return;
+    r = we(e, n);
+  } else r = e;
+  try {
+    if (r && typeof r == "object") {
+      if (O(r)) r = r.value;
+      else if ("value" in r && typeof r.value < "u") {
+        const d = r.value;
+        d instanceof Node || (r = d);
+      }
+    }
+  } catch {
+  }
+  let o = [];
+  if (typeof r == "string") o = [r];
+  else if (Array.isArray(r)) o = r.filter(Boolean);
+  else if (typeof r == "object" && r !== null)
+    for (const [d, m] of Object.entries(r)) m && o.push(d);
+  const t = o.join(" "), a = s && s.class || i.class || "", h = a ? `${a} ${t}`.trim() : t.trim();
+  h ? i.class = h : i.class = void 0;
+}
+function zt(e, i, n) {
+  let s;
+  if (typeof e == "string") {
+    if (!n) return;
+    s = we(e, n);
+  } else s = e;
+  let r = "";
+  if (typeof s == "string") r = s;
+  else if (s && typeof s == "object") {
+    const t = [];
+    for (const [a, h] of Object.entries(s)) if (h != null && h !== "") {
+      const d = a.replace(/[A-Z]/g, (y) => `-${y.toLowerCase()}`), m = [
+        "width",
+        "height",
+        "top",
+        "right",
+        "bottom",
+        "left",
+        "margin",
+        "margin-top",
+        "margin-right",
+        "margin-bottom",
+        "margin-left",
+        "padding",
+        "padding-top",
+        "padding-right",
+        "padding-bottom",
+        "padding-left",
+        "font-size",
+        "line-height",
+        "border-width",
+        "border-radius",
+        "min-width",
+        "max-width",
+        "min-height",
+        "max-height"
+      ];
+      let b = String(h);
+      typeof h == "number" && m.includes(d) && (b = `${h}px`), t.push(`${d}: ${b}`);
+    }
+    r = t.join("; ") + (t.length > 0 ? ";" : "");
+  }
+  const o = String(i.style || "");
+  i.style = o + (o && !o.endsWith(";") ? "; " : "") + r;
+}
+function Ut(e, i, n) {
+  let s = e;
+  typeof e == "string" && n && (s = we(e, n)), O(s) ? i.reactiveRef = s : i.ref = s;
+}
+function lt(e, i, n, s) {
+  const r = {}, o = { ...s || {} }, t = {};
+  for (const [a, h] of Object.entries(e)) {
+    const { value: d, modifiers: m, arg: b } = h;
+    if (a === "model" || a.startsWith("model:")) {
+      const y = a.split(":");
+      Rt(d, m, r, o, t, i, n, y.length > 1 ? y[1] : b);
+      continue;
+    }
+    switch (a) {
+      case "bind":
+        Wt(d, r, o, i, n);
+        break;
+      case "show":
+        Bt(d, o, i);
+        break;
+      case "class":
+        Dt(d, o, i, s);
+        break;
+      case "style":
+        zt(d, o, i);
+        break;
+      case "ref":
+        Ut(d, r, i);
+        break;
+      case "when":
+        break;
+    }
+  }
+  try {
+    if (Object.prototype.hasOwnProperty.call(r, "disabled") && n && X(n)) {
+      const a = r.disabled, h = a && typeof a == "object" && "value" in a;
+      let d = !1;
+      try {
+        d = O(a);
+      } catch {
+        d = !1;
+      }
+      !h && !d && (o.disabled = a, delete r.disabled);
+    }
+  } catch {
+  }
+  return {
+    props: r,
+    attrs: o,
+    listeners: t
+  };
+}
+function pe(e) {
+  return e ? e.split(/\s+/).filter(Boolean) : [];
+}
+function de(e, i) {
+  if (i.length === 0) return;
+  const n = i.filter((s) => s && !e.classList.contains(s));
+  n.length > 0 && e.classList.add(...n);
+}
+function ue(e, i) {
+  if (i.length === 0) return;
+  const n = i.filter(Boolean);
+  n.length > 0 && e.classList.remove(...n);
+}
+function Kt(e) {
+  const i = window.getComputedStyle(e), n = i.transitionDuration || "0s", s = i.transitionDelay || "0s", r = (o) => {
+    const t = parseFloat(o);
+    return o.includes("ms") ? t : t * 1e3;
+  };
+  return r(n) + r(s);
+}
+function ft(e, i) {
+  return new Promise((n) => {
+    const s = i ?? Kt(e);
+    if (s <= 0) {
+      n();
+      return;
+    }
+    let r = !1;
+    const o = () => {
+      r || (r = !0, e.removeEventListener("transitionend", t), e.removeEventListener("transitioncancel", t), n());
+    }, t = () => o();
+    e.addEventListener("transitionend", t), e.addEventListener("transitioncancel", t), setTimeout(o, s + 50);
+  });
+}
+async function ve(e, i) {
+  const { classes: n, hooks: s, css: r, duration: o } = i;
+  if (s?.onBeforeEnter) try {
+    s.onBeforeEnter(e);
+  } catch (b) {
+    I("Transition onBeforeEnter error:", b);
+  }
+  if (!r)
+    return s?.onEnter ? new Promise((b) => {
+      const y = s.onEnter;
+      typeof y == "function" ? y(e, () => {
+        if (s?.onAfterEnter) try {
+          s.onAfterEnter(e);
+        } catch (S) {
+          I("Transition onAfterEnter error:", S);
+        }
+        b();
+      }) : b();
+    }) : void 0;
+  const t = pe(n?.enterFrom), a = pe(n?.enterActive), h = pe(n?.enterTo);
+  de(e, t), e.offsetHeight, de(e, a), e.offsetHeight;
+  let d;
+  if (s?.onEnter) {
+    const b = new Promise((y) => {
+      d = y;
+    });
+    try {
+      const y = s.onEnter;
+      typeof y == "function" && y(e, () => {
+        d && d();
+      });
+    } catch (y) {
+      I("Transition onEnter error:", y);
+    }
+    d && await b;
+  }
+  await new Promise((b) => requestAnimationFrame(() => b())), e.offsetHeight, ue(e, t), de(e, h), e.offsetHeight, await new Promise((b) => requestAnimationFrame(() => b()));
+  let m;
+  if (typeof o == "number" ? m = o : o && typeof o == "object" && "enter" in o && (m = o.enter), await ft(e, m), ue(e, a), s?.onAfterEnter) try {
+    s.onAfterEnter(e);
+  } catch (b) {
+    I("Transition onAfterEnter error:", b);
+  }
+}
+async function We(e, i) {
+  const { classes: n, hooks: s, css: r, duration: o } = i;
+  if (s?.onBeforeLeave) try {
+    s.onBeforeLeave(e);
+  } catch (b) {
+    I("Transition onBeforeLeave error:", b);
+  }
+  if (!r)
+    return s?.onLeave ? new Promise((b) => {
+      const y = s.onLeave;
+      typeof y == "function" ? y(e, () => {
+        if (s?.onAfterLeave) try {
+          s.onAfterLeave(e);
+        } catch (S) {
+          I("Transition onAfterLeave error:", S);
+        }
+        b();
+      }) : b();
+    }) : void 0;
+  const t = pe(n?.leaveFrom), a = pe(n?.leaveActive), h = pe(n?.leaveTo);
+  de(e, t), e.offsetHeight, de(e, a);
+  let d;
+  if (s?.onLeave) {
+    const b = new Promise((y) => {
+      d = y;
+    });
+    try {
+      const y = s.onLeave;
+      typeof y == "function" && y(e, () => {
+        d && d();
+      });
+    } catch (y) {
+      I("Transition onLeave error:", y);
+    }
+    d && await b;
+  }
+  await new Promise((b) => requestAnimationFrame(() => b())), ue(e, t), de(e, h);
+  let m;
+  if (typeof o == "number" ? m = o : o && typeof o == "object" && "leave" in o && (m = o.leave), await ft(e, m), ue(e, a), ue(e, h), ue(e, t), s?.onAfterLeave) try {
+    s.onAfterLeave(e);
+  } catch (b) {
+    I("Transition onAfterLeave error:", b);
+  }
+}
+var ut = /* @__PURE__ */ new WeakMap(), pt = /* @__PURE__ */ new WeakMap();
+function $e(e) {
+  if (!e) return;
+  const i = ut.get(e);
+  if (i !== void 0) return i;
+  try {
+    const n = e;
+    if (n && n.key != null) return String(n.key);
+  } catch {
+  }
+  if (e instanceof Element) {
+    const n = e.getAttribute("data-anchor-key");
+    if (n) return n;
+  }
+}
+function q(e, i) {
+  try {
+    ut.set(e, i);
+  } catch {
+  }
+  try {
+    e.key = i;
+  } catch {
+  }
+  try {
+    if (e instanceof Element) {
+      const n = F(i);
+      n !== null && z(e, "data-anchor-key", n);
+    }
+  } catch {
+  }
+}
+function Ft(e) {
+  if (!e) return;
+  const i = pt.get(e);
+  if (i !== void 0) return i;
+  try {
+    const n = e;
+    if (n && n._transitionGroup != null) return n._transitionGroup;
+  } catch {
+  }
+}
+function qt(e, i) {
+  try {
+    pt.set(e, i);
+  } catch {
+  }
+  try {
+    e._transitionGroup = i;
+  } catch {
+  }
+}
+var Oe = /* @__PURE__ */ new WeakMap();
+function le(e, i) {
+  if (i) {
+    if (e instanceof Element) {
+      J.cleanup(e);
+      const n = [];
+      for (const s in i) i[s] === e && n.push(s);
+      for (const s of n) delete i[s];
+    }
+    if (e.hasChildNodes()) {
+      const n = e.childNodes;
+      for (let s = n.length - 1; s >= 0; s--) le(n[s], i);
+    }
+  }
+}
+function Se(e, i, n) {
+  if (typeof e == "string") return;
+  const s = e.props?.reactiveRef ?? (e.props?.props && e.props.props.reactiveRef), r = e.props?.ref ?? (e.props?.props && e.props.props.ref);
+  if (s) try {
+    if (O(s) || typeof s == "object" && "value" in s) s.value = i;
+    else if (typeof s == "function") s(i);
+    else if (typeof s == "string" && n) try {
+      const o = String(s);
+      n[o] = i;
+    } catch {
+    }
+  } catch {
+  }
+  else if (r && n) try {
+    const o = String(r);
+    n[o] = i;
+  } catch {
+  }
+}
+function Ue(e, i) {
+  if (Array.isArray(e)) {
+    const o = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Map();
+    return e.map((a) => {
+      if (!a || typeof a != "object") return a;
+      let h = a.props?.key ?? a.key;
+      if (!h) {
+        const b = a.tag || "node", y = [
+          a.props?.attrs?.id,
+          a.props?.attrs?.name,
+          a.props?.attrs?.["data-key"],
+          a.props?.props?.id,
+          a.props?.props?.name,
+          a.props?.props?.dataKey,
+          a.props?.props?.["data-key"]
+        ].find((S) => S != null) ?? "";
+        h = y ? `${i}:${b}:${y}` : `${i}:${b}`;
+      }
+      let d = h;
+      if (o.has(d)) {
+        const b = (t.get(d) ?? 1) + 1;
+        t.set(d, b), d = `${h}#${b}`;
+      }
+      t.set(h, (t.get(h) ?? 0) + 1), o.add(d);
+      let m = a.children;
+      return Array.isArray(m) && (m = Ue(m, d)), {
+        ...a,
+        key: d,
+        children: m
+      };
+    });
+  }
+  const n = e, s = n.props?.key ?? n.key ?? i;
+  let r = n.children;
+  return Array.isArray(r) && (r = Ue(r, s)), {
+    ...n,
+    key: s,
+    children: r
+  };
+}
+function nt(e, i, n, s) {
+  const r = n.directives ?? {}, o = n.attrs ? { ...n.attrs } : {}, t = lt(r, s, e, o), a = {
+    ...i.props || {},
+    ...n.props || {},
+    ...t.props || {}
+  }, h = {
+    ...o || {},
+    ...t.attrs || {}
+  }, d = i.props ?? {}, m = a, b = !!(n?.isCustomElement ?? i?.isCustomElement ?? !1);
+  let y = !1;
+  const S = /* @__PURE__ */ new Set();
+  for (const f in d) S.add(f);
+  for (const f in m) S.add(f);
+  for (const f of S) {
+    const _ = d[f], g = m[f];
+    let u = _, p = g;
+    if (P(() => {
+      O(_) ? u = _.peek() : _e(_) && (u = _.value);
+    }), P(() => {
+      O(g) ? p = g.peek() : _e(g) && (p = g.value);
+    }), !(_ === g && u === p))
+      if (y = !0, f === "value" && (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement)) {
+        const C = De(g), c = C == null ? "" : String(C);
+        e.value !== c && (e.value = c);
+      } else if (f === "checked" && e instanceof HTMLInputElement) e.checked = !!De(g);
+      else if (f.startsWith("on") && typeof g == "function") {
+        const C = ct(f);
+        typeof _ == "function" && J.removeListener(e, C, _), typeof g == "function" && J.addListener(e, C, g);
+        try {
+          if (C && C.startsWith("update:")) {
+            const c = C.split(":", 2)[1], v = m[c];
+            let A = [];
+            try {
+              if (O(v)) {
+                const w = v.value;
+                A = w && typeof w == "object" ? Object.keys(w) : [];
+              } else v && typeof v == "object" && (A = Object.keys(v));
+            } catch {
+              A = [];
+            }
+            const L = A.filter((w) => typeof w == "string" && !w.startsWith("_") && w !== "constructor");
+            for (const w of L) {
+              const $ = `update:${w}`, W = (N) => {
+                const D = N.detail !== void 0 ? N.detail : N.target instanceof HTMLInputElement || N.target instanceof HTMLTextAreaElement || N.target instanceof HTMLSelectElement ? N.target.value : void 0, x = {
+                  ...O(v) ? v.value || {} : m[c] || {},
+                  [w]: D
+                };
+                try {
+                  typeof g == "function" && g({ detail: x });
+                } catch {
+                }
+              };
+              P(() => {
+                J.addListener(e, $, W);
+              });
+            }
+          }
+        } catch {
+        }
+      } else if (g == null) G(e, f);
+      else {
+        const C = n?.isCustomElement ?? i?.isCustomElement ?? !1;
+        if (C || f in e) try {
+          e[f] = g, f === "disabled" && g === !1 && !C && X(e) && G(e, "disabled");
+        } catch {
+        }
+        else g === !1 && G(e, f);
+      }
+  }
+  const M = t.listeners ?? {}, l = Oe.get(e) ?? {};
+  for (const [f, _] of Object.entries(l)) J.removeListener(e, f, _);
+  for (const [f, _] of Object.entries(M)) J.addListener(e, f, _);
+  Object.keys(M).length > 0 ? Oe.set(e, M) : Oe.delete(e);
+  const k = { ...i.attrs ?? {} }, T = h, E = t && t.attrs || {};
+  if (Object.prototype.hasOwnProperty.call(E, "class") && typeof e.getAttribute == "function") {
+    const f = e.getAttribute("class");
+    f !== null && (k.class = f);
+  }
+  if (Object.prototype.hasOwnProperty.call(E, "style") && typeof e.getAttribute == "function") {
+    const f = e.getAttribute("style");
+    f !== null && (k.style = f);
+  }
+  try {
+    if (Object.prototype.hasOwnProperty.call(E, "class") && E.class === void 0 && typeof e.getAttribute == "function") {
+      const f = e.getAttribute("class");
+      f !== null && (k.class = f);
+    }
+    if (Object.prototype.hasOwnProperty.call(E, "style") && E.style === void 0 && typeof e.getAttribute == "function") {
+      const f = e.getAttribute("style");
+      f !== null && (k.style = f);
+    }
+    try {
+      if (typeof e.getAttribute == "function") {
+        const f = e.getAttribute("class");
+        try {
+          e instanceof HTMLInputElement && e.type === "text" && f !== null && f !== k.class && (k.class = f);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  } catch {
+  }
+  for (const f in {
+    ...k,
+    ...T
+  }) {
+    const _ = k[f], g = T[f];
+    let u = _, p = g;
+    if (O(_) && (u = _.peek()), O(g) && (p = g.peek()), u !== p)
+      if (y = !0, p == null || p === !1)
+        P(() => {
+          G(e, f);
+        }), re(i, f, void 0), f === "value" && (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement ? P(() => {
+          e.value = "";
+        }) : e instanceof HTMLSelectElement ? P(() => {
+          e.value = "";
+        }) : e instanceof HTMLProgressElement && P(() => {
+          e.value = 0;
+        })), f === "checked" && e instanceof HTMLInputElement && P(() => {
+          e.checked = !1;
+        }), f === "disabled" && X(e) && P(() => {
+          (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = !1);
+        });
+      else {
+        if (f === "value") {
+          if (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement) {
+            P(() => {
+              e.value = p ?? "";
+            });
+            continue;
+          } else if (e instanceof HTMLSelectElement) {
+            P(() => {
+              e.value = p ?? "";
+            });
+            continue;
+          } else if (e instanceof HTMLProgressElement) {
+            P(() => {
+              e.value = Number(p);
+            });
+            continue;
+          }
+        }
+        if (f === "checked" && e instanceof HTMLInputElement) {
+          P(() => {
+            e.checked = !!p;
+          });
+          continue;
+        }
+        if (f === "style") {
+          const c = F(p);
+          c !== null && z(e, f, String(c)), re(i, f, p);
+          continue;
+        }
+        if (f === "class") {
+          const c = F(p);
+          c !== null && z(e, f, String(c)), re(i, f, p);
+          continue;
+        }
+        if (f === "disabled" && X(e)) {
+          P(() => {
+            const c = fe(p);
+            (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = c);
+          }), fe(p) ? P(() => {
+            z(e, f, "");
+          }) : P(() => {
+            G(e, f);
+          });
+          continue;
+        }
+        const C = e.namespaceURI === "http://www.w3.org/2000/svg";
+        if (b && !C && f.includes("-")) if (ot(f)) {
+          const c = F(g ?? p);
+          if (c !== null) {
+            try {
+              z(e, f, String(c));
+            } catch {
+            }
+            re(i, f, p);
+          }
+        } else {
+          const c = Fe(f);
+          try {
+            const v = e;
+            v[c] = O(g) ? g : p, re(i, f, p);
+          } catch {
+            const v = F(g ?? p);
+            v !== null && z(e, f, String(v));
+          }
+        }
+        else if (!C && f in e) try {
+          const c = e;
+          c[f] = O(g) ? g : p, re(i, f, p);
+        } catch {
+          const c = F(p);
+          c !== null && (z(e, f, String(c)), re(i, f, p));
+        }
+        else {
+          const c = F(p);
+          c !== null && (z(e, f, String(c)), re(i, f, p));
+        }
+      }
+  }
+  try {
+    if (X(e)) {
+      const f = a.disabled;
+      let _;
+      try {
+        const u = Object.prototype.hasOwnProperty.call(t.props || {}, "disabled"), p = f && typeof f == "object" && "value" in f;
+        let C = !1;
+        P(() => {
+          C = !!O(f);
+        });
+        const c = ze(f);
+        C || p || u || c ? _ = f : _ = h.disabled;
+      } catch {
+        _ = h.disabled;
+      }
+      const g = fe(_);
+      P(() => {
+        (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = g);
+      }), g ? P(() => {
+        z(e, "disabled", "");
+      }) : P(() => {
+        G(e, "disabled");
+      });
+    }
+  } catch {
+  }
+  if (b && y) {
+    const f = e;
+    P(() => {
+      f._applyProps?.(f._cfg);
+    }), P(() => {
+      typeof f.requestRender == "function" ? f.requestRender() : typeof f._render == "function" && f._render?.(f._cfg);
+    });
+  }
+}
+function V(e, i, n, s = null) {
+  if (typeof e == "string") return document.createTextNode(e);
+  if (e.tag === "#text") {
+    const l = document.createTextNode(typeof e.children == "string" ? e.children : "");
+    return e.key != null && q(l, e.key), l;
+  }
+  if (e.tag === "#raw") {
+    const l = typeof e.children == "string" ? e.children : "";
+    return Y("[#raw] Inserting unsanitized HTML. Ensure the content is trusted or sanitized before use — unsanitized input can lead to XSS vulnerabilities."), document.createRange().createContextualFragment(l);
+  }
+  if (e.tag === "#anchor") {
+    const l = e, k = Array.isArray(l.children) ? l.children : [], T = document.createTextNode(""), E = document.createTextNode("");
+    l.key != null && (q(T, `${l.key}:start`), q(E, `${l.key}:end`)), l._startNode = T, l._endNode = E;
+    const f = document.createDocumentFragment();
+    f.appendChild(T);
+    for (const _ of k) {
+      const g = V(_, i, n, s);
+      if (l.key != null && g instanceof Element && !g.hasAttribute("data-anchor-key")) {
+        const u = _;
+        u && typeof u == "object" && u.key != null || q(g, String(l.key));
+      }
+      f.appendChild(g);
+    }
+    return f.appendChild(E), f;
+  }
+  const r = e && typeof e == "object" && e.props && e.props.attrs ? e.props.attrs : void 0, o = (r && typeof r.xmlns == "string" ? String(r.xmlns) : void 0) ?? s ?? mt[e.tag] ?? null, t = o ? document.createElementNS(o, e.tag) : document.createElement(e.tag);
+  e.key != null && q(t, e.key), e.props && e.props?._transitionGroup && qt(t, e.props?._transitionGroup);
+  const { props: a = {}, attrs: h = {}, directives: d = {} } = e.props ?? {}, m = lt(d, i, t instanceof HTMLElement ? t : void 0, h), b = {
+    ...a,
+    ...m.props
+  }, y = {
+    ...h,
+    ...m.attrs
+  };
+  try {
+    const l = F((y && y.class) ?? (b && b.class) ?? (e.props && e.props.attrs && e.props.attrs.class) ?? (e.props && e.props.props && e.props.props.class));
+    if (l !== null) {
+      const k = String(l).trim();
+      k && z(t, "class", k);
+    }
+  } catch {
+  }
+  try {
+    if (b.disabled !== void 0 && t && X(t)) {
+      const l = b.disabled, k = l && typeof l == "object" && "value" in l;
+      let T = !1;
+      try {
+        T = O(l);
+      } catch {
+        T = !1;
+      }
+      !k && !T && P(() => {
+        y.disabled = l, delete b.disabled;
+      });
+    }
+  } catch {
+  }
+  const S = t.namespaceURI === "http://www.w3.org/2000/svg";
+  for (const l in y) {
+    const k = y[l];
+    if (typeof l != "string" || /\[object Object\]/.test(l)) continue;
+    const T = De(k);
+    if (typeof T == "boolean") T ? z(t, l, "") : P(() => {
+      G(t, l);
+    });
+    else if (T != null) {
+      if (l === "disabled" && X(t)) {
+        const E = b.disabled, f = fe(ze(E) ? E : T);
+        P(() => {
+          t.disabled = f;
+        }), f ? P(() => {
+          z(t, l, "");
+        }) : P(() => {
+          G(t, l);
+        });
+        continue;
+      }
+      if (!S && l === "value" && (t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLSelectElement || t instanceof HTMLProgressElement)) try {
+        t instanceof HTMLProgressElement ? t.value = Number(T) : t.value = String(T ?? "");
+      } catch {
+        const E = F(T);
+        E !== null && z(t, l, String(E));
+      }
+      else if (!S && l === "checked" && t instanceof HTMLInputElement) try {
+        t.checked = !!T;
+      } catch {
+        const E = F(T);
+        E !== null && z(t, l, String(E));
+      }
+      else if (!S && l in t) try {
+        t[l] = T, l === "disabled" && T === !1 && X(t) && G(t, "disabled"), re(e.props, l, T);
+      } catch {
+        const E = F(T);
+        E !== null && z(t, l, String(E));
+      }
+      else if ((e.props?.isCustomElement ?? !1) && !S && l.includes("-")) {
+        const E = Fe(l);
+        try {
+          t[E] = T;
+        } catch {
+          const f = F(T);
+          f !== null && z(t, l, String(f));
+        }
+      } else {
+        const E = F(T);
+        E !== null && z(t, l, String(E));
+      }
+    }
+  }
+  for (const l in b) {
+    const k = b[l];
+    if (!(typeof l != "string" || /\[object Object\]/.test(l)))
+      if (l === "value" && (t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLSelectElement)) {
+        const T = typeof k == "object" && k !== null && _e(k) ? k.value : k;
+        P(() => {
+          t.value = String(T ?? "");
+        });
+      } else if (l.startsWith("on") && typeof k == "function") {
+        const T = ct(l), E = T.includes(":") ? (() => {
+          const f = T.split(":"), _ = f[1];
+          if (_.includes("-")) {
+            const g = _.split("-").map((u, p) => p === 0 ? u : u.charAt(0).toUpperCase() + u.slice(1)).join("");
+            return `${f[0]}:${g}`;
+          } else {
+            const g = _.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+            return `${f[0]}:${g}`;
+          }
+        })() : T;
+        m.listeners && (m.listeners[T] || m.listeners[E]) || J.addListener(t, T, k);
+      } else {
+        if (l.startsWith("on") && k === void 0) continue;
+        if (k == null || k === !1) G(t, l);
+        else {
+          const T = e.props?.isCustomElement ?? !1, E = typeof k == "object" && k !== null && O(k) ? k : _e(k) && typeof k.value < "u" ? k.value : k;
+          if (l === "class" || l === "style") {
+            try {
+              const f = F(E);
+              f !== null && z(t, l, String(f));
+            } catch {
+            }
+            continue;
+          }
+          if (T || l in t) try {
+            const f = typeof k == "object" && k !== null && O(k) ? k : _e(k) ? k.value : k;
+            if (l === "disabled" && X(t)) {
+              const _ = fe(b.disabled !== void 0 ? b.disabled : f);
+              P(() => {
+                t.disabled = _;
+              }), _ ? P(() => {
+                z(t, l, "");
+              }) : P(() => {
+                G(t, l);
+              });
+              continue;
+            }
+            try {
+              if (typeof t[l] == "boolean") {
+                let _ = f;
+                typeof f == "string" ? f === "false" ? _ = !1 : f === "true" ? _ = !0 : _ = !!f && f !== "" : _ = !!f, t[l] = _;
+              } else t[l] = f;
+            } catch {
+              t[l] = f;
+            }
+          } catch {
+          }
+        }
+      }
+  }
+  const M = m.listeners ?? {};
+  for (const [l, k] of Object.entries(M)) J.addListener(t, l, k);
+  Object.keys(M).length > 0 && Oe.set(t, M), Se({
+    ...e,
+    props: {
+      ...e.props,
+      ...m.props
+    }
+  }, t, n);
+  try {
+    const l = t;
+    if (typeof l._applyProps == "function") try {
+      l._applyProps(l._cfg);
+    } catch {
+    }
+    typeof l.requestRender == "function" ? l.requestRender() : typeof l._render == "function" && l._render(l._cfg);
+  } catch {
+  }
+  if (Array.isArray(e.children)) {
+    const l = e.tag === "foreignObject" && o === "http://www.w3.org/2000/svg" ? null : t.namespaceURI ?? null;
+    for (const k of e.children) t.appendChild(V(k, i, n, l));
+  } else typeof e.children == "string" && (t.textContent = e.children);
+  try {
+    if (t instanceof HTMLSelectElement && y && Object.prototype.hasOwnProperty.call(y, "value")) try {
+      t.value = String(y.value ?? "");
+    } catch {
+    }
+  } catch {
+  }
+  try {
+    if (X(t)) {
+      const l = b.disabled, k = y.disabled, T = l && typeof l == "object" && "value" in l;
+      let E = !1;
+      try {
+        E = !!O(l);
+      } catch {
+        E = !1;
+      }
+      const f = fe(E || T || ze(l) ? l : k);
+      P(() => {
+        t.disabled = f;
+      }), f ? P(() => {
+        z(t, "disabled", "");
+      }) : P(() => {
+        G(t, "disabled");
+      });
+    }
+  } catch {
+  }
+  return t;
+}
+function Vt(e, i, n, s, r) {
+  if (typeof n == "string") {
+    e.textContent !== n && (e.textContent = n);
+    return;
+  }
+  if (!Array.isArray(n)) return;
+  const o = e.childNodes, t = [];
+  for (let l = 0; l < o.length; l++) t.push(o[l]);
+  const a = Array.isArray(i) ? i : [], h = Ft(e);
+  if (h) {
+    const l = (E) => {
+      if (typeof E == "string") return E.startsWith("each-") ? E.substring(5) : E;
+      if (typeof E == "number") return String(E);
+    }, k = [], T = [];
+    for (const E of n) if (E && E.tag === "#anchor") {
+      const f = Array.isArray(E.children) ? E.children : [];
+      for (const _ of f) {
+        const g = l(_.key ?? E.key ?? "unknown");
+        k.push({
+          ..._,
+          key: g
+        });
+      }
+    } else E && k.push({
+      ...E,
+      key: l(E.key)
+    });
+    for (const E of a) if (E && E.tag === "#anchor") {
+      const f = Array.isArray(E.children) ? E.children : [];
+      for (const _ of f) {
+        const g = l(_.key ?? E.key ?? "unknown");
+        T.push({
+          ..._,
+          key: g
+        });
+      }
+    } else E && T.push({
+      ...E,
+      key: l(E.key)
+    });
+    if (k.some((E) => E && E.key != null) || T.some((E) => E && E.key != null)) {
+      const E = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
+      for (const c of T) if (c && c.key != null) {
+        const v = String(c.key);
+        E.set(v, c);
+      }
+      for (let c = 0; c < t.length; c++) {
+        const v = t[c];
+        let A = $e(v);
+        if (A = l(A), A != null && v instanceof Element && v.nodeType === Node.ELEMENT_NODE) {
+          let L = typeof A == "string" && A.includes(":") ? A.substring(0, A.lastIndexOf(":")) : A;
+          L = String(L), f.set(L, v);
+        }
+      }
+      const _ = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map(), u = t.length > 0;
+      if (h.moveClass && u) for (let c = 0; c < t.length; c++) {
+        const v = t[c];
+        if (v instanceof HTMLElement && v.parentElement) {
+          const A = v.getBoundingClientRect();
+          g.set(v, A);
+        }
+      }
+      const p = [];
+      for (const c of k) {
+        let v = c.key;
+        if (v == null) continue;
+        v = String(v);
+        const A = E.get(v);
+        let L = f.get(v);
+        if (L && A) {
+          const w = ke(L, A, c, s);
+          _.add(L), q(w, String(v)), p.push({
+            node: w,
+            key: v,
+            newVNode: c,
+            oldVNode: A,
+            isNew: !1
+          });
+        } else {
+          L = V(c, s, void 0, e instanceof Element ? e.namespaceURI ?? null : null), q(L, String(v)), e.appendChild(L);
+          const w = u || h.appear === !0;
+          L instanceof HTMLElement && w && ve(L, h).catch(($) => {
+            I("Enter transition error:", $);
+          }), p.push({
+            node: L,
+            key: v,
+            newVNode: c,
+            isNew: !0
+          });
+        }
+      }
+      const C = [];
+      for (let c = 0; c < t.length; c++) {
+        const v = t[c], A = $e(v);
+        if (!_.has(v) && A != null && v instanceof HTMLElement) {
+          const L = We(v, h).then(() => {
+            e.contains(v) && e.removeChild(v);
+          }).catch((w) => {
+            I("Leave transition error:", w), e.contains(v) && e.removeChild(v);
+          });
+          C.push(L);
+        }
+      }
+      if (C.length === 0) {
+        let c = e.firstChild;
+        for (const { node: v } of p)
+          v !== c && e.insertBefore(v, c), c = v.nextSibling;
+        if (h.moveClass && g.size > 0) {
+          const v = [];
+          for (const { node: A, isNew: L } of p) if (!L && A instanceof HTMLElement) {
+            const w = g.get(A);
+            if (w) {
+              const $ = A.getBoundingClientRect(), W = w.left - $.left, N = w.top - $.top;
+              if (W !== 0 || N !== 0) {
+                const D = h.moveClass.split(/\s+/).filter((x) => x);
+                v.push({
+                  node: A,
+                  deltaX: W,
+                  deltaY: N,
+                  moveClasses: D
+                });
+              }
+            }
+          }
+          if (v.length > 0) {
+            for (const { node: A, deltaX: L, deltaY: w } of v)
+              A.style.transform = `translate(${L}px, ${w}px)`, A.style.transitionProperty = "none";
+            e.offsetHeight, requestAnimationFrame(() => {
+              requestAnimationFrame(() => {
+                for (const { node: A, moveClasses: L } of v) for (const w of L) A.classList.add(w);
+                requestAnimationFrame(() => {
+                  const A = h.moveClass || "", L = A.match(/duration-(\d+)/), w = L ? `${L[1]}ms` : "300ms", $ = A.match(/ease-(out|in|in-out|linear)/), W = $ ? `ease-${$[1]}` : "ease-out";
+                  for (const { node: N } of v) N.style.transition = `transform ${w} ${W}`;
+                  requestAnimationFrame(() => {
+                    for (const { node: N, moveClasses: D } of v) {
+                      N.style.removeProperty("transform");
+                      const x = () => {
+                        for (const Q of D) N.classList.remove(Q);
+                        N.style.removeProperty("transition"), N.removeEventListener("transitionend", x), N.removeEventListener("transitioncancel", x);
+                      };
+                      N.addEventListener("transitionend", x, { once: !0 }), N.addEventListener("transitioncancel", x, { once: !0 });
+                    }
+                  });
+                });
+              });
+            });
+          }
+        }
+      }
+      return;
+    }
+  }
+  const d = /* @__PURE__ */ new Map();
+  for (const l of a) l && l.key != null && d.set(l.key, l);
+  const m = /* @__PURE__ */ new Map();
+  for (let l = 0; l < t.length; l++) {
+    const k = t[l], T = $e(k);
+    T != null && m.set(T, k);
+  }
+  const b = /* @__PURE__ */ new Set();
+  let y = e.firstChild;
+  function S(l, k) {
+    let T = l;
+    for (; T && (b.add(T), T !== k); )
+      T = T.nextSibling;
+  }
+  function M(l, k, T, E, f, _ = !0) {
+    const g = [];
+    let u = l.nextSibling;
+    for (; u && u !== k; )
+      g.push(u), u = u.nextSibling;
+    const p = Array.isArray(T) ? T : [];
+    if (E.some((C) => C && C.key != null) || p.some((C) => C && C.key != null)) {
+      const C = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+      for (const w of p) w && w.key != null && C.set(w.key, w);
+      for (const w of g) {
+        const $ = $e(w);
+        $ != null && c.set($, w);
+      }
+      const v = f && f.state === "visible" && p.length === 0 && E.length > 0, A = /* @__PURE__ */ new Set();
+      let L = l.nextSibling;
+      for (const w of E) {
+        if (typeof w == "object" && w.tag === "#anchor") {
+          const W = w.key, N = `${W}:start`, D = `${W}:end`, x = c.get(N), Q = c.get(D), H = Array.isArray(w.children) ? w.children : [], j = C.get(W);
+          let B, R;
+          if (x && Q && e.contains(x))
+            B = x, R = Q, M(B, R, j?.children, H);
+          else {
+            B = document.createTextNode(""), R = document.createTextNode(""), q(B, N), q(R, D), e.insertBefore(B, L);
+            for (const He of H) {
+              const U = V(He, s, void 0, e instanceof Element ? e.namespaceURI ?? null : null);
+              e.insertBefore(U, L), A.add(U);
+            }
+            e.insertBefore(R, L);
+          }
+          let ee = B;
+          for (; ee && (A.add(ee), ee !== R); )
+            ee = ee.nextSibling;
+          w._startNode = B, w._endNode = R, L = R.nextSibling;
+          continue;
+        }
+        let $;
+        if (w.key != null && c.has(w.key)) {
+          const W = C.get(w.key);
+          $ = ke(c.get(w.key), W, w, s), A.add($), f && $ instanceof HTMLElement && v && f.appear && ve($, f).catch((N) => {
+            I("Transition enter error (appear):", N);
+          }), $ !== L && e.contains($) && e.insertBefore($, L);
+        } else
+          $ = V(w, s, void 0, e instanceof Element ? e.namespaceURI ?? null : null), e.insertBefore($, L), A.add($), f && $ instanceof HTMLElement && _ && ve($, f).catch((W) => {
+            I("Transition enter error:", W);
+          });
+        L = $.nextSibling;
+      }
+      for (const w of g) !A.has(w) && e.contains(w) && (f && w instanceof HTMLElement && _ ? We(w, f).then(() => {
+        e.contains(w) && e.removeChild(w);
+      }).catch(($) => {
+        I("Transition leave error:", $), e.contains(w) && e.removeChild(w);
+      }) : e.removeChild(w));
+    } else {
+      const C = Math.min(p.length, E.length);
+      for (let c = 0; c < C; c++) {
+        const v = p[c], A = E[c], L = ke(g[c], v, A, s);
+        L !== g[c] && (e.insertBefore(L, g[c]), e.removeChild(g[c]));
+      }
+      for (let c = C; c < E.length; c++) {
+        const v = V(E[c], s, void 0, e instanceof Element ? e.namespaceURI ?? null : null);
+        e.insertBefore(v, k), f && v instanceof HTMLElement && _ && ve(v, f).catch((A) => {
+          I("Transition enter error:", A);
+        });
+      }
+      for (let c = C; c < g.length; c++) {
+        const v = g[c];
+        f && v instanceof HTMLElement && _ ? We(v, f).then(() => {
+          e.contains(v) && e.removeChild(v);
+        }).catch((A) => {
+          I("Transition leave error:", A), e.contains(v) && e.removeChild(v);
+        }) : e.removeChild(v);
+      }
+    }
+  }
+  for (const l of n) {
+    let k;
+    if (l.tag === "#anchor") {
+      const T = l.key, E = `${T}:start`, f = `${T}:end`;
+      let _ = m.get(E), g = m.get(f);
+      const u = Array.isArray(l.children) ? l.children : [];
+      if (_ || (_ = document.createTextNode(""), q(_, E)), g || (g = document.createTextNode(""), q(g, f)), l._startNode = _, l._endNode = g, !e.contains(_) || !e.contains(g)) {
+        e.insertBefore(_, y);
+        const p = l._transition, C = !(p && p.state === "visible" && u.length > 0) || p.appear;
+        for (const c of u) {
+          const v = V(c, s, r, e instanceof Element ? e.namespaceURI ?? null : null);
+          e.insertBefore(v, y), p && v instanceof HTMLElement && C && ve(v, p).catch((A) => {
+            I("Transition enter error:", A);
+          });
+        }
+        e.insertBefore(g, y);
+      } else {
+        const p = l._transition, C = d.get(T)._transition, c = C && C.state !== p?.state, v = p && p.state === "visible" && u.length > 0 && !c, A = c || !v || p?.appear === !0;
+        M(_, g, d.get(T)?.children, u, p, A);
+      }
+      S(_, g), y = g.nextSibling;
+      continue;
+    }
+    if (l.key != null && m.has(l.key)) {
+      const T = d.get(l.key);
+      k = ke(m.get(l.key), T, l, s, r), b.add(k), k !== y && e.contains(k) && (y && !e.contains(y) && (y = null), e.insertBefore(k, y));
+    } else
+      k = V(l, s, r, e instanceof Element ? e.namespaceURI ?? null : null), y && !e.contains(y) && (y = null), e.insertBefore(k, y), b.add(k);
+    y = k.nextSibling;
+  }
+  for (let l = 0; l < t.length; l++) {
+    const k = t[l];
+    !b.has(k) && e.contains(k) && (le(k, r), e.removeChild(k));
+  }
+}
+function ke(e, i, n, s, r) {
+  if (i && typeof i != "string" && i.props?.ref && r && le(e, r), i === n) return e;
+  if (typeof n == "string") {
+    if (e.nodeType === Node.TEXT_NODE)
+      return e.textContent !== n && (e.textContent = n), e;
+    {
+      const t = document.createTextNode(n);
+      return e.parentNode?.replaceChild(t, e), t;
+    }
+  }
+  if (n && typeof n != "string" && n.tag === "#anchor") {
+    const t = n, a = Array.isArray(t.children) ? t.children : [], h = t._startNode ?? document.createTextNode(""), d = t._endNode ?? document.createTextNode("");
+    t.key != null && (q(h, `${t.key}:start`), q(d, `${t.key}:end`)), t._startNode = h, t._endNode = d;
+    const m = document.createDocumentFragment();
+    m.appendChild(h);
+    for (const b of a) {
+      const y = V(b, s, r, e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null);
+      m.appendChild(y);
+    }
+    return m.appendChild(d), e.parentNode?.replaceChild(m, e), h;
+  }
+  if (!n) {
+    le(e, r);
+    const t = document.createComment("removed");
+    return e.parentNode?.replaceChild(t, e), t;
+  }
+  if (!i || typeof i == "string") {
+    le(e, r);
+    const t = V(n, s, r, e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null);
+    return Se(n, t, r), e.parentNode?.replaceChild(t, e), t;
+  }
+  if (n.tag === "#anchor") {
+    const t = Array.isArray(n.children) ? n.children : [], a = n._startNode ?? document.createTextNode(""), h = n._endNode ?? document.createTextNode("");
+    n.key != null && (q(a, `${n.key}:start`), q(h, `${n.key}:end`)), n._startNode = a, n._endNode = h;
+    const d = document.createDocumentFragment();
+    d.appendChild(a);
+    for (const m of t) d.appendChild(V(m, s, r, e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null));
+    return d.appendChild(h), e.parentNode?.replaceChild(d, e), a;
+  }
+  if (typeof i != "string" && typeof n != "string" && i.tag === n.tag && i.key === n.key) {
+    const t = e;
+    return nt(t, i.props || {}, n.props || {}, s), Vt(t, i.children, n.children, s, r), Se(n, t, r), t;
+  }
+  if (typeof i != "string" && typeof n != "string" && i.tag === n.tag && (i.tag && String(i.tag).includes("-") || n.props && n.props.isCustomElement || i.props && i.props.isCustomElement))
+    try {
+      const t = e;
+      return nt(t, i.props || {}, n.props || {}, s), Se(n, t, r), t;
+    } catch {
+    }
+  le(e, r);
+  const o = V(n, s, r, e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null);
+  return Se(n, o, r), e.parentNode?.replaceChild(o, e), o;
+}
+function Gt(e, i, n, s) {
+  let r;
+  Array.isArray(i) ? i.length === 1 ? (r = i[0], r && typeof r == "object" && r.key == null && (r = {
+    ...r,
+    key: "__root__"
+  })) : r = {
+    tag: "div",
+    key: "__root__",
+    children: i
+  } : (r = i, r && typeof r == "object" && r.key == null && (r = {
+    ...r,
+    key: "__root__"
+  })), r && typeof r == "object" && r.tag === "#anchor" && (r = {
+    tag: "div",
+    key: "__anchor_root__",
+    props: { attrs: {
+      "data-anchor-block-root": "",
+      key: "__anchor_root__"
+    } },
+    children: [r]
+  }), r = Ue(r, String(r.key ?? "root"));
+  const o = e._prevVNode ?? null, t = e._prevDom ?? e.firstChild ?? null;
+  let a;
+  o && t ? typeof o != "string" && typeof r != "string" && o.tag === r.tag && o.key === r.key ? a = ke(t, o, r, n, s) : (a = V(r, n, s, e.host instanceof Element ? e.host.namespaceURI ?? null : null), e.replaceChild(a, t)) : (a = V(r, n, s, e.host instanceof Element ? e.host.namespaceURI ?? null : null), e.firstChild ? e.replaceChild(a, e.firstChild) : e.appendChild(a));
+  const h = [];
+  for (let d = 0; d < e.childNodes.length; d++) {
+    const m = e.childNodes[d];
+    m !== a && m.nodeName !== "STYLE" && (le(m, s), h.push(m));
+  }
+  h.forEach((d) => e.removeChild(d)), e._prevVNode = r && typeof r == "object" && r.props ? {
+    ...r,
+    props: {
+      ...r.props,
+      attrs: r.props.attrs ? { ...r.props.attrs } : void 0,
+      props: r.props.props ? { ...r.props.props } : void 0
+    }
+  } : r, e._prevDom = a;
+}
+var Ae = [], rt = /* @__PURE__ */ new WeakMap(), he = /* @__PURE__ */ new WeakMap();
+function Jt(e, i) {
+  he.has(e) || he.set(e, /* @__PURE__ */ new Set()), he.get(e).add(i);
+}
+function Zt(e, i) {
+  const n = he.get(e);
+  n && (n.delete(i), n.size === 0 && he.delete(e));
+}
+function Xt(e, i, n, s, r, o, t, a) {
+  if (e) {
+    Ae.push(n);
+    try {
+      const h = i.render(n);
+      if (h instanceof Promise) {
+        o(!0);
+        const d = e.host.isConnected, m = e, b = m._asyncRenderToken = (m._asyncRenderToken ?? 0) + 1;
+        h.then((y) => {
+          d && !e.host.isConnected || m._asyncRenderToken === b && (o(!1), t(null), st(e, y, n, s, r), a(e.innerHTML));
+        }).catch((y) => {
+          if (d && !e.host.isConnected || m._asyncRenderToken !== b) return;
+          o(!1);
+          const S = y instanceof Error ? y : new Error(String(y));
+          I(`[${e.host.tagName.toLowerCase()}] Async render error:`, S), t(S);
+        });
+        return;
+      }
+      st(e, h, n, s, r), a(e.innerHTML);
+    } catch (h) {
+      const d = h instanceof Error ? h : new Error(String(h));
+      I(`[${e.host.tagName.toLowerCase()}] Render error:`, d), t(d);
+    } finally {
+      Ae.pop();
+    }
+  }
+}
+function st(e, i, n, s, r) {
+  e && (Gt(e, Array.isArray(i) ? i : [i], n, s), r(e.innerHTML));
+}
+function Yt(e, i, n, s, r, o, t) {
+  o !== null && clearTimeout(o);
+  const a = Date.now() - i < 16, { isVitest: h, isCypress: d, isTest: m } = vt(), b = (h || m) && !d;
+  if (a) {
+    const M = n + 1;
+    r(M);
+    const l = m ? 50 : 10, k = m ? 100 : 25, T = b ? 12 : 50;
+    if (M === l && !m) Y(`⚠️ Component rendering frequently. Performance may be impacted.
+Common causes:
+• State updates during render cycle
+• Event handlers with immediate function calls
+• Missing effect dependencies`);
+    else if (M === k && !m) Y(`⚠️ Component is re-rendering rapidly. Applying throttling.
+This might indicate:
+• Event handler calling function immediately: @click="\${fn()}" should be @click="\${fn}"
+• State modification during render
+• Missing dependencies in computed/watch`);
+    else if (M >= T) {
+      I(`🛑 Infinite render loop detected. Stopping to prevent browser freeze.
+Possible causes:
+• State updates triggering immediate re-renders
+• Computed values changing during evaluation
+• Circular dependencies in reactive system`), t(null);
+      return;
+    }
+  } else r(0);
+  let y = 0;
+  m || (n >= 40 ? y = 500 : n >= 25 ? y = 100 : n >= 15 && (y = 16));
+  const S = () => {
+    s(Date.now());
+    try {
+      e();
+    } catch (M) {
+      I("Error during render execution:", M);
+    } finally {
+      t(null);
+    }
+  };
+  y > 0 ? t(setTimeout(S, y)) : m ? S() : (t({}), queueMicrotask(S));
+}
+function Qt(e, i) {
+  let n = i;
+  try {
+    const s = he.get(e);
+    if (s?.size) for (const r of s) try {
+      const o = r.lastHtmlStringForJitCSS;
+      o?.trim() && (n += `
+` + o);
+    } catch {
+    }
+    else {
+      const r = e.querySelectorAll("*");
+      for (const o of r) try {
+        const t = o.lastHtmlStringForJitCSS;
+        t?.trim() && (n += `
+` + t);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return n;
+}
+function en(e) {
+  return "adoptedStyleSheets" in e && typeof CSSStyleSheet < "u" && "replaceSync" in CSSStyleSheet.prototype;
+}
+function it(e, i) {
+  let n = e.querySelector("style[data-cer-runtime]");
+  n || (n = document.createElement("style"), z(n, "data-cer-runtime", "true"), e.appendChild(n));
+  try {
+    n.textContent = i;
+  } catch {
+  }
+}
+function tn(e, i, n, s, r) {
+  if (!e) return;
+  const o = Qt(e, n);
+  if (rt.get(e) === o) return;
+  rt.set(e, o);
+  const t = At(e) ? Ct(o) : "", a = _t(), h = i._computedStyle, d = en(e), m = Tt();
+  let b = "";
+  if (!d) try {
+    m?.cssRules && (b = Array.from(m.cssRules).map((S) => S.cssText).join(`
+`));
+  } catch {
+    b = "";
+  }
+  if (!t?.trim() && !h && !a) {
+    if (r(null), d) e.adoptedStyleSheets = [Le(), m];
+    else {
+      it(e, Ee(`${Ee(Xe)}
+${b}`));
+      try {
+        e.adoptedStyleSheets = [Le(), m];
+      } catch {
+      }
+    }
+    return;
+  }
+  let y = "";
+  if (h && (y += h + `
+`), t && (y += t + `
+`), y = kt(y), y = Ee(y), d) {
+    let S = s;
+    S || (S = new CSSStyleSheet());
+    try {
+      S.replaceSync(y);
+      const M = [Le(), m];
+      a && M.push(a), M.push(S), e.adoptedStyleSheets = M, r(S);
+      return;
+    } catch {
+    }
+  }
+  it(e, Ee(`${Ee(Xe)}
+${b}
+${y}`));
+  try {
+    const S = [Le(), m];
+    if (a && S.push(a), typeof CSSStyleSheet < "u") try {
+      const M = new CSSStyleSheet();
+      M.replaceSync(y), S.push(M);
+    } catch {
+      S.push({
+        cssRules: [],
+        replaceSync: () => {
+        }
+      });
+    }
+    e.adoptedStyleSheets = S;
+  } catch {
+  }
+  r(null);
+}
+function nn(e, i) {
+  if (!i.render) throw new Error("Component must have a render function");
+  return typeof window > "u" ? class {
+    constructor() {
+    }
+  } : class extends HTMLElement {
+    context;
+    _refs = {};
+    _listeners = [];
+    _watchers = /* @__PURE__ */ new Map();
+    _renderTimeoutId = null;
+    _mounted = !1;
+    _hasError = !1;
+    _initializing = !0;
+    _componentId;
+    _styleSheet = null;
+    _lastHtmlStringForJitCSS = "";
+    get lastHtmlStringForJitCSS() {
+      return this._lastHtmlStringForJitCSS;
+    }
+    get hasError() {
+      return this._hasError;
+    }
+    get isLoading() {
+      return this._templateLoading;
+    }
+    get lastError() {
+      return this._templateError;
+    }
+    _cfg;
+    _lastRenderTime = 0;
+    _renderCount = 0;
+    _templateLoading = !1;
+    _templateError = null;
+    constructor() {
+      super(), this.shadowRoot || this.attachShadow({ mode: "open" }), this._cfg = Ce.get(e) || i, this._componentId = `${e}-${crypto.randomUUID()}`;
+      const n = this._initContext(i), s = (o, t, a) => {
+        Object.defineProperty(o, t, {
+          value: a,
+          writable: !1,
+          enumerable: !1,
+          configurable: !1
+        });
+      };
+      s(n, "refs", this._refs), s(n, "requestRender", () => this.requestRender()), s(n, "_requestRender", () => this._requestRender()), s(n, "_componentId", this._componentId), s(n, "_triggerWatchers", (o, t) => this._triggerWatchers(o, t)), this.context = n, P(() => {
+        s(n, "_host", this);
+      }), s(this.context, "emit", (o, t, a) => {
+        const h = {
+          detail: t,
+          bubbles: !0,
+          composed: !0,
+          ...a || {}
+        }, d = new CustomEvent(o, h);
+        this.dispatchEvent(d);
+        const m = o.indexOf(":");
+        if (m > 0) {
+          const b = o.substring(0, m), y = o.substring(m + 1), S = y.includes("-") ? `${b}:${y.split("-").map((M, l) => l === 0 ? M : M.charAt(0).toUpperCase() + M.slice(1)).join("")}` : `${b}:${y.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`;
+          S !== o && P(() => {
+            this.dispatchEvent(new CustomEvent(S, h));
+          });
+        }
+        return !d.defaultPrevented;
+      });
+      const r = Ce.get(e) || i;
+      for (const o in r) {
+        const t = r[o];
+        typeof t == "function" && (this.context[o] = (...a) => t(...a, this.context));
+      }
+      if (r.props) for (const o in r.props) {
+        let t = this[o];
+        Object.defineProperty(this, o, {
+          get() {
+            return t;
+          },
+          set(a) {
+            const h = t;
+            t = a, this.context[o] = a, this._initializing || (this._applyProps(r), h !== a && this._requestRender());
+          },
+          enumerable: !0,
+          configurable: !0
+        });
+      }
+      this._initializing = !1, this._initWatchers(r), this._applyProps(r), this._render(r);
+    }
+    connectedCallback() {
+      this._runLogicWithinErrorBoundary(i, () => {
+        const n = this.getRootNode();
+        n && n !== document && "host" in n && Jt(n, this);
+        const s = this.getAttribute("data-cer-hydrate");
+        if (s !== "none") {
+          if (s === "idle") {
+            const r = () => this._hydrateNow(i);
+            typeof requestIdleCallback < "u" ? requestIdleCallback(r) : setTimeout(r, 200);
+            return;
+          }
+          if (s === "visible") {
+            new IntersectionObserver((r, o) => {
+              r.some((t) => t.isIntersecting) && (o.disconnect(), this._hydrateNow(i));
+            }, {
+              rootMargin: "0px",
+              threshold: 0
+            }).observe(this);
+            return;
+          }
+          this._applyProps(i), this._requestRender(), Qe(i, this.context, this._mounted, (r) => {
+            this._mounted = r;
+          });
+        }
+      });
+    }
+    _hydrateNow(n) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        this._applyProps(n), this._requestRender(), Qe(n, this.context, this._mounted, (s) => {
+          this._mounted = s;
+        });
+      });
+    }
+    disconnectedCallback() {
+      this._runLogicWithinErrorBoundary(i, () => {
+        const n = this.getRootNode();
+        n && n !== document && "host" in n && Zt(n, this), $t(i, this.context, this._listeners, () => {
+          this._listeners = [];
+        }, () => {
+          this._watchers.clear();
+        }, (s) => {
+          this._templateLoading = s;
+        }, (s) => {
+          this._templateError = s;
+        }, (s) => {
+          this._mounted = s;
+        }), Be.cleanup(this._componentId);
+      });
+    }
+    attributeChangedCallback(n, s, r) {
+      this._runLogicWithinErrorBoundary(i, () => {
+        this._applyProps(i), s !== r && this._requestRender(), jt(i, n, s, r, this.context);
+      });
+    }
+    static get observedAttributes() {
+      return i.props ? Object.keys(i.props).map(Z) : [];
+    }
+    _render(n) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        Xt(this.shadowRoot, n, this.context, this._refs, (s) => {
+          this._lastHtmlStringForJitCSS = s, typeof this.onHtmlStringUpdate == "function" && this?.onHtmlStringUpdate?.(s);
+        }, (s) => {
+          this._templateLoading = s, this?.onLoadingStateChange?.(s);
+        }, (s) => {
+          this._templateError = s, this?.onErrorStateChange?.(s);
+        }, (s) => this._applyStyle(n, s));
+      });
+    }
+    requestRender() {
+      this._requestRender();
+    }
+    _requestRender() {
+      this._runLogicWithinErrorBoundary(this._cfg, () => {
+        be(() => {
+          Yt(() => this._render(this._cfg), this._lastRenderTime, this._renderCount, (n) => {
+            this._lastRenderTime = n;
+          }, (n) => {
+            this._renderCount = n;
+          }, this._renderTimeoutId, (n) => {
+            this._renderTimeoutId = n;
+          });
+        }, this._componentId);
+      });
+    }
+    _applyStyle(n, s) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        tn(this.shadowRoot, this.context, s, this._styleSheet, (r) => {
+          this._styleSheet = r;
+        });
+      });
+    }
+    _runLogicWithinErrorBoundary(n, s) {
+      try {
+        s(), this._hasError = !1;
+      } catch (r) {
+        this._hasError = !0;
+        try {
+          const o = this.tagName?.toLowerCase?.() || "<unknown>", t = this._componentId || "<unknown-id>", a = {};
+          if (n && n.props) for (const h of Object.keys(n.props)) try {
+            const d = this.context[h];
+            d instanceof Node ? a[h] = `[DOM Node: ${d.nodeName}]` : typeof d == "object" && d !== null ? a[h] = Object.keys(d).length > 5 ? `[object(${Object.keys(d).length} keys)]` : d : a[h] = d;
+          } catch {
+            a[h] = "[unreadable]";
+          }
+          I(`Error rendering component <${o}> (id=${t}):`, r), I("Component props snapshot:", a), Y("Common causes: accessing properties of null/undefined inside template interpolations; expensive or throwing expressions inside templates that evaluate eagerly. Fixes: use optional chaining (obj?.prop), guard with ternary, or use the runtime lazy overload: when(cond, () => html`...`).");
+        } catch {
+        }
+        if (n.onError && n.onError(r, this.context), this.tagName.toLowerCase() !== "cer-error-boundary") {
+          let o = this.parentElement;
+          if (!o) {
+            const t = this.getRootNode();
+            t instanceof ShadowRoot && (o = t.host.parentElement);
+          }
+          for (; o; ) {
+            if (o.tagName.toLowerCase() === "cer-error-boundary") {
+              o._cerHandleChildError?.(r);
+              break;
+            }
+            let t = o.parentElement;
+            if (!t) {
+              const a = o.getRootNode();
+              a instanceof ShadowRoot && (t = a.host.parentElement);
+            }
+            o = t;
+          }
+        }
+      }
+    }
+    _initContext(n) {
+      try {
+        let r = function(o, t = "") {
+          if (Array.isArray(o)) return new Proxy(o, {
+            get(a, h, d) {
+              const m = Reflect.get(a, h, d);
+              return typeof m == "function" && typeof h == "string" && [
+                "push",
+                "pop",
+                "shift",
+                "unshift",
+                "splice",
+                "sort",
+                "reverse"
+              ].includes(h) ? function(...b) {
+                const y = m.apply(a, b);
+                if (!s._initializing) {
+                  const S = t || "root";
+                  s._triggerWatchers(S, a), be(() => s._render(n), s._componentId);
+                }
+                return y;
+              } : m;
+            },
+            set(a, h, d) {
+              if (a[String(h)] = d, !s._initializing) {
+                const m = t ? `${t}.${String(h)}` : String(h);
+                s._triggerWatchers(m, d), be(() => s._render(n), s._componentId);
+              }
+              return !0;
+            },
+            deleteProperty(a, h) {
+              if (delete a[String(h)], !s._initializing) {
+                const d = t ? `${t}.${String(h)}` : String(h);
+                s._triggerWatchers(d, void 0), be(() => s._render(n), s._componentId);
+              }
+              return !0;
+            }
+          });
+          if (o && typeof o == "object") {
+            if (O(o)) return o;
+            for (const a in o) {
+              const h = t ? `${t}.${a}` : a;
+              o[a] = r(o[a], h);
+            }
+            return new Proxy(o, {
+              set(a, h, d) {
+                const m = t ? `${t}.${String(h)}` : String(h);
+                return a[String(h)] = r(d, m), s._initializing || (s._triggerWatchers(m, a[String(h)]), be(() => s._render(n), s._componentId)), !0;
+              },
+              get(a, h, d) {
+                return Reflect.get(a, h, d);
+              }
+            });
+          }
+          return o;
+        };
+        const s = this;
+        return r({ ...n.props ? Object.fromEntries(Object.entries(n.props).map(([o, t]) => [o, t.default])) : {} });
+      } catch {
+        return {};
+      }
+    }
+    _initWatchers(n) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        wt(this.context, this._watchers, {});
+      });
+    }
+    _triggerWatchers(n, s) {
+      Lt(this.context, this._watchers, n, s);
+    }
+    _applyProps(n) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        Mt(this, n, this.context);
+      });
+    }
+  };
+}
+function je(e, i, n, s) {
+  for (const r of n) try {
+    r(...s);
+  } catch (o) {
+    I(`[${e}] Error in ${i} lifecycle hook:`, o);
+  }
+}
+function yn(e, i, n) {
+  yt();
+  let s = Z(e);
+  s.includes("-") || (s = `cer-${s}`);
+  const r = {}, o = {
+    props: {},
+    hydrate: n?.hydrate,
+    onConnected: (t) => {
+      if (r.onConnected) try {
+        r.onConnected(t);
+      } catch (a) {
+        I(`[${s}] Error in onConnected lifecycle hook:`, a);
+      }
+    },
+    onDisconnected: (t) => {
+      if (r.onDisconnected) try {
+        r.onDisconnected(t);
+      } catch (a) {
+        I(`[${s}] Error in onDisconnected lifecycle hook:`, a);
+      }
+    },
+    onAttributeChanged: (t, a, h, d) => {
+      if (r.onAttributeChanged) try {
+        r.onAttributeChanged(t, a, h, d);
+      } catch (m) {
+        I(`[${s}] Error in onAttributeChanged lifecycle hook:`, m);
+      }
+    },
+    onError: (t, a) => {
+      if (r.onError && t) try {
+        r.onError(t, a);
+      } catch (h) {
+        I(`[${s}] Error in onError handler (the error handler itself threw):`, h);
+      }
+    },
+    render: (t) => {
+      const a = t, h = a._componentId || `${s}-${crypto.randomUUID()}`;
+      Be.setCurrentComponent(h, () => {
+        t.requestRender && t.requestRender();
+      });
+      try {
+        Object.defineProperty(t, "_hookCallbacks", {
+          value: {},
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }), Object.defineProperty(t, "_computedStyle", {
+          value: void 0,
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }), Je(t), Ye();
+        let d;
+        try {
+          d = i();
+        } catch (m) {
+          try {
+            const b = a._hookCallbacks?.onError;
+            if (Array.isArray(b)) for (const y of b) try {
+              y(m);
+            } catch {
+            }
+            else if (typeof b == "function") try {
+              b(m);
+            } catch {
+            }
+          } catch {
+          }
+          try {
+            const b = a._host;
+            if (b?.parentElement) {
+              let y = b.parentElement;
+              for (; y; ) {
+                if (y.tagName.toLowerCase() === "cer-error-boundary") {
+                  y._cerHandleChildError?.(m);
+                  break;
+                }
+                let S = y.parentElement;
+                if (!S) {
+                  const M = y.getRootNode();
+                  typeof ShadowRoot < "u" && M instanceof ShadowRoot && (S = M.host.parentElement);
+                }
+                y = S;
+              }
+            }
+          } catch {
+          }
+          throw m;
+        }
+        if (d == null) throw new Error(`[${s}] Component render function did not return a value. Make sure your component returns an html\`...\` template.`);
+        if (a._hookCallbacks) {
+          const m = a._hookCallbacks;
+          if (m.onConnected) {
+            const b = m.onConnected;
+            r.onConnected = (y) => {
+              je(s, "useOnConnected", b, [y]);
+            };
+          }
+          if (m.onDisconnected) {
+            const b = m.onDisconnected;
+            r.onDisconnected = (y) => {
+              je(s, "useOnDisconnected", b, [y]);
+            };
+          }
+          if (m.onAttributeChanged) {
+            const b = m.onAttributeChanged;
+            r.onAttributeChanged = (y, S, M, l) => {
+              je(s, "useOnAttributeChanged", b, [
+                y,
+                S,
+                M,
+                l
+              ]);
+            };
+          }
+          if (m.onError) {
+            const b = m.onError;
+            r.onError = (y) => {
+              je(s, "useOnError", b, [y]);
+            };
+          }
+          if (m.props && !Object.keys(o.props ?? {}).length) {
+            const b = m.props;
+            o.props = Object.fromEntries(Object.entries(b).map(([y, S]) => [y, {
+              type: typeof S == "boolean" ? Boolean : typeof S == "number" ? Number : typeof S == "string" ? String : Function,
+              default: S
+            }])), Ce.set(s, o);
+          }
+        }
+        return d;
+      } finally {
+        Ze(), Be.clearCurrentComponent();
+      }
+    }
+  };
+  if (Ce.set(s, o), typeof window < "u") {
+    try {
+      const t = {
+        _hookCallbacks: {},
+        requestRender: () => {
+        },
+        emit: () => !0
+      };
+      Je(t), Et(), Ye();
+      try {
+        i();
+      } catch (a) {
+        try {
+          const h = t?._hookCallbacks?.onError;
+          if (Array.isArray(h)) for (const d of h) try {
+            d(a);
+          } catch {
+          }
+          else if (typeof h == "function") try {
+            h(a);
+          } catch {
+          }
+          I(`Error during component discovery render <${s}>:`, a), Y("Error occurred during initial component discovery render. Consider guarding expensive expressions or using lazy factories for directives like when().");
+        } catch {
+        }
+        throw a;
+      } finally {
+        gt(), Ze();
+      }
+      if (t._hookCallbacks?.props) {
+        const a = t._hookCallbacks.props;
+        o.props = Object.fromEntries(Object.entries(a).map(([h, d]) => [h, {
+          type: typeof d == "boolean" ? Boolean : typeof d == "number" ? Number : typeof d == "string" ? String : Function,
+          default: d
+        }])), Ce.set(s, o);
+      }
+    } catch (t) {
+      Y(`[${s}] Failed to register component. Check your component definition for errors.`, t);
+    }
+    typeof customElements < "u" && !customElements.get(s) && customElements.define(s, nn(s, o));
+  }
+}
+function se(e, i = {}, n, s) {
+  return {
+    tag: e,
+    key: s ?? i.key,
+    props: i,
+    children: n
+  };
+}
+function Te(e) {
+  return !!e && typeof e == "object" && (e.type === "AnchorBlock" || e.tag === "#anchor");
+}
+function ce(e) {
+  return typeof e == "object" && e !== null && "tag" in e && !Te(e);
+}
+function rn(e, i) {
+  return e.key != null ? e : {
+    ...e,
+    key: i
+  };
+}
+function sn(e, i) {
+  if (e == null) {
+    Y(`⚠️ Event handler for '@${i}' is ${e}. This will prevent the event from working. Use a function reference instead: @${i}="\${functionName}"`);
+    return;
+  }
+  typeof e != "function" && Y(`🚨 Potential infinite loop detected! Event handler for '@${i}' appears to be the result of a function call (${typeof e}) instead of a function reference. Change @${i}="\${functionName()}" to @${i}="\${functionName}" to pass the function reference instead of calling it immediately.`), e === void 0 && typeof e != "function" && Y(`💡 Tip: If your event handler function returns undefined, make sure you're passing the function reference, not calling it. Use @${i}="\${fn}" not @${i}="\${fn()}"`);
+}
+function on(e, i = [], n = {}) {
+  const s = {}, r = {}, o = {}, t = [], a = /([:@#]?)([a-zA-Z0-9-:.]+)(?:\s*=\s*("([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'|([^\s>]+)))?/g;
+  let h;
+  for (; h = a.exec(e); ) {
+    const d = h[1], m = h[2];
+    let b = "";
+    for (let T = 3; T < h.length; T++) if (h[T] !== void 0) {
+      b = h[T];
+      break;
+    }
+    b.length >= 2 && (b[0] === '"' && b[b.length - 1] === '"' || b[0] === "'" && b[b.length - 1] === "'") && (b = b.slice(1, -1));
+    const y = !/=/.test(h[0]), S = b.match(/^{{(\d+)}}$/), M = !S && /{{(\d+)}}/.test(b);
+    let l = y ? !0 : S ? i[Number(S[1])] ?? null : M ? b.replace(/{{(\d+)}}/g, (T, E) => String(i[Number(E)] ?? "")) : b;
+    !S && !M && (l === "true" ? l = !0 : l === "false" ? l = !1 : l === "null" ? l = null : isNaN(Number(l)) || (l = Number(l)));
+    const k = [
+      "model",
+      "bind",
+      "show",
+      "class",
+      "style",
+      "ref",
+      "when"
+    ];
+    if (d === ":") {
+      const [T, E] = m.split(":"), [f, ..._] = T.split(".");
+      if (k.includes(f)) {
+        const g = [..._], u = f === "model" && E ? `model:${E}` : f;
+        o[u] = {
+          value: l,
+          modifiers: g,
+          arg: E
+        };
+      } else if (m === "disabled") {
+        let g = l;
+        g && O(g) && (g = g.value);
+        const u = typeof g;
+        if (g === "" || u === "boolean" || u === "string" && (g === "true" || g === "false") || g == null || u === "number") s[m] = g;
+        else {
+          let p = l;
+          p && O(p) && (p = p.value), r[m] = p;
+        }
+        t.push(m);
+      } else {
+        let g = l;
+        g && O(g) && (g = g.value), r[m] = g, t.push(m);
+      }
+    } else if (d === "@") {
+      const [T, ...E] = m.split("."), f = E;
+      sn(l, T);
+      const _ = typeof l == "function" ? l : typeof n[l] == "function" ? n[l] : void 0;
+      if (_) {
+        const g = (p) => {
+          if (f.includes("prevent") && p.preventDefault(), f.includes("stop") && p.stopPropagation(), !(f.includes("self") && p.target !== p.currentTarget))
+            return f.includes("once") && p.currentTarget?.removeEventListener(T, g), _(p);
+        }, u = "on" + T.charAt(0).toUpperCase() + T.slice(1);
+        s[u] = g;
+      }
+    } else m === "ref" ? s.ref = l : r[m] = l;
+  }
+  return {
+    props: s,
+    attrs: r,
+    directives: o,
+    bound: t
+  };
+}
+function Ke(e) {
+  if (!ce(e) || Te(e)) return e;
+  const i = e.props?.directives;
+  if (i && i.when) {
+    const n = i.when.value, s = O(n) ? n.value : n, r = { ...i };
+    delete r.when;
+    const o = { ...e.props };
+    Object.keys(r).length > 0 ? o.directives = r : delete o.directives;
+    const t = {
+      ...e,
+      props: o
+    };
+    return Array.isArray(t.children) && (t.children = t.children.map((a) => typeof a == "object" && a !== null ? Ke(a) : a)), {
+      tag: "#anchor",
+      key: e.key != null ? `when-${e.key}` : `when-${e.tag}`,
+      children: s ? [t] : []
+    };
+  }
+  if (Array.isArray(e.children)) {
+    const n = e.children.map((s) => typeof s == "object" && s !== null ? Ke(s) : s);
+    return {
+      ...e,
+      children: n
+    };
+  }
+  return e;
+}
+function an(e, i, n) {
+  const s = Ae.length > 0 ? Ae[Ae.length - 1] : void 0, r = n ?? s, o = !n && i.length === 0, t = o ? e.join("<!--TEMPLATE_DELIM-->") : null;
+  if (o && t) {
+    const c = Re.get(t);
+    if (c) return c;
+  }
+  function a(c, v) {
+    return se("#text", {}, c, v);
+  }
+  function h(c, v, A = !1) {
+    let L = typeof c == "string" ? St(c) : c;
+    return !A && typeof L == "string" && /[\r\n]/.test(L) && (L = L.replace(/\s+/g, " ")), se("#text", {}, L, v);
+  }
+  let d = "";
+  for (let c = 0; c < e.length; c++)
+    d += e[c], c < i.length && (d += `{{${c}}}`);
+  const m = /<!--[\s\S]*?-->|<\/?([a-zA-Z0-9-]+)((?:\s+[^\s=>/]+(?:\s*=\s*(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s>]+))?)*)\s*\/?>|{{(\d+)}}|([^<]+)/g, b = [];
+  let y, S = [], M = null, l = {}, k, T = 0;
+  const E = [], f = /* @__PURE__ */ new Set([
+    "pre",
+    "code",
+    "textarea",
+    "script",
+    "style"
+  ]);
+  function _() {
+    if (M && f.has(M.toLowerCase())) return !0;
+    for (const c of b) if (f.has(c.tag.toLowerCase())) return !0;
+    return !1;
+  }
+  function g(c) {
+    if (!c || typeof c != "object" || Te(c)) return;
+    const v = c, A = l;
+    if (v.props || v.attrs) {
+      const L = v;
+      L.props && (A.props || (A.props = {}), Object.assign(A.props, L.props)), L.attrs && (A.attrs || (A.attrs = {}), Object.keys(L.attrs).forEach((w) => {
+        if (w === "style" && A.attrs.style) {
+          const $ = String(A.attrs.style).replace(/;?\s*$/, ""), W = String(L.attrs.style).replace(/^;?\s*/, "");
+          A.attrs.style = $ + "; " + W;
+        } else if (w === "class" && A.attrs.class) {
+          const $ = String(A.attrs.class).trim().split(/\s+/).filter(Boolean), W = String(L.attrs.class).trim().split(/\s+/).filter(Boolean), N = [.../* @__PURE__ */ new Set([...$, ...W])];
+          A.attrs.class = N.join(" ");
+        } else A.attrs[w] = L.attrs[w];
+      }));
+    } else
+      A.props || (A.props = {}), Object.assign(A.props, v);
+  }
+  function u(c, v) {
+    const A = M ? S : E;
+    if (Te(c)) {
+      const L = c.key ?? v, w = c.children;
+      A.push({
+        ...c,
+        key: L,
+        children: w
+      });
+      return;
+    }
+    if (ce(c)) {
+      A.push(rn(c, void 0));
+      return;
+    }
+    if (Array.isArray(c)) {
+      if (c.length === 0) return;
+      for (let L = 0; L < c.length; L++) {
+        const w = c[L];
+        Te(w) || ce(w) || Array.isArray(w) ? u(w, `${v}-${L}`) : w !== null && typeof w == "object" ? Ge(w) ? A.push(se("#raw", {}, w.__rawHTML, `${v}-${L}`)) : g(w) : A.push(a(String(w), `${v}-${L}`));
+      }
+      return;
+    }
+    if (c !== null && typeof c == "object") {
+      if (Ge(c)) {
+        const L = c.__rawHTML ?? "";
+        A.push(se("#raw", {}, L, v));
+        return;
+      }
+      g(c);
+      return;
+    }
+    A.push(a(String(c), v));
+  }
+  const p = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  for (; y = m.exec(d); )
+    if (!(y[0].startsWith("<!--") && y[0].endsWith("-->"))) {
+      if (y[1]) {
+        const c = y[1], v = y[0][1] === "/", A = y[0][y[0].length - 2] === "/" || p.has(c), { props: L, attrs: w, directives: $, bound: W } = on(y[2] || "", i, r ?? {}), N = {
+          props: {},
+          attrs: {}
+        };
+        for (const D in L) N.props[D] = L[D];
+        for (const D in w) N.attrs[D] = w[D];
+        N.attrs && Object.prototype.hasOwnProperty.call(N.attrs, "key") && !(N.props && Object.prototype.hasOwnProperty.call(N.props, "key")) && P(() => {
+          N.props.key = N.attrs.key;
+        });
+        try {
+          const D = {
+            input: [
+              "value",
+              "checked",
+              "readonly",
+              "required",
+              "placeholder",
+              "maxlength",
+              "minlength"
+            ],
+            textarea: [
+              "value",
+              "readonly",
+              "required",
+              "placeholder",
+              "maxlength",
+              "minlength"
+            ],
+            select: [
+              "value",
+              "required",
+              "multiple"
+            ],
+            option: ["selected", "value"],
+            video: [
+              "muted",
+              "autoplay",
+              "controls",
+              "loop",
+              "playsinline"
+            ],
+            audio: [
+              "muted",
+              "autoplay",
+              "controls",
+              "loop"
+            ],
+            img: [
+              "src",
+              "alt",
+              "width",
+              "height"
+            ],
+            button: [
+              "type",
+              "name",
+              "value",
+              "autofocus",
+              "form"
+            ]
+          }, x = c.toLowerCase(), Q = D[x] ?? [];
+          if (N.attrs) {
+            for (const H of Q) if (W && W.includes(H) && H in N.attrs && !(N.props && H in N.props)) {
+              let j = N.attrs[H];
+              if (j && O(j))
+                j = j.value, N.props[H] = j, delete N.attrs[H];
+              else if (j && typeof j == "object" && "value" in j && !(j instanceof Node)) try {
+                const B = j.value;
+                N.props[H] = (x === "select" || x === "option") && H === "value" ? String(B) : B, delete N.attrs[H];
+              } catch {
+              }
+              else {
+                const B = typeof j;
+                if (H === "disabled")
+                  (j === "" || B === "boolean" || B === "string" && (j === "true" || j === "false") || j == null || B === "number") && (N.props[H] = j, delete N.attrs[H]);
+                else if (j === "" || B === "string" || B === "number" || B === "boolean" || j == null) {
+                  const R = (x === "select" || x === "option") && H === "value" ? String(j) : j;
+                  N.props[H] = R, delete N.attrs[H];
+                }
+              }
+            }
+          }
+          if (c.includes("-") || r?.__customElements?.has?.(c)) {
+            if (N.isCustomElement = !0, W && N.attrs) {
+              const H = /* @__PURE__ */ new Set([
+                "id",
+                "name",
+                "data-key",
+                "key"
+              ]);
+              for (const j of W) if (j in N.attrs && !(N.props && j in N.props)) {
+                const B = j.includes("-") ? Fe(j) : j, R = N.attrs[j];
+                if (N.props[B] = R, H.has(j) || ot(j)) try {
+                  const ee = F(N.attrs[j]);
+                  ee === null ? delete N.attrs[j] : N.attrs[j] = ee;
+                } catch {
+                  delete N.attrs[j];
+                }
+                else delete N.attrs[j];
+              }
+            }
+            try {
+              if (N.attrs && !(N.props && "modelValue" in N.props)) {
+                const H = N.attrs["model-value"] ?? N.attrs.modelValue;
+                typeof H < "u" && (N.props.modelValue = H);
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        if ($ && Object.keys($).some((D) => D === "model" || D.startsWith("model:"))) try {
+          const x = globalThis[/* @__PURE__ */ Symbol.for("cer.registry")], Q = !!(x && typeof x.has == "function" && x.has(c)), H = r, j = !!(H && (H.__customElements instanceof Set && H.__customElements.has(c) || Array.isArray(H.__isCustomElements) && H.__isCustomElements.includes(c)));
+          if (c.includes("-") || j || Q) for (const R of Object.keys($)) {
+            if (R !== "model" && !R.startsWith("model:")) continue;
+            const ee = $[R], He = ee.arg ?? (R.includes(":") ? R.split(":", 2)[1] : void 0), U = ee.value, xe = He ?? "modelValue", qe = K, dt = Pe, ye = r?._state || r;
+            let ne;
+            if (typeof U == "string" && ye) ne = qe(ye, U);
+            else if (ne = U, O(U)) try {
+              U.value;
+            } catch {
+            }
+            N.props[xe] = ne;
+            try {
+              const ie = Z(xe);
+              N.attrs || (N.attrs = {}), ne != null && (typeof ne == "string" || typeof ne == "number" || typeof ne == "boolean") && (N.attrs[ie] = ne);
+            } catch {
+            }
+            N.isCustomElement = !0;
+            const Ve = `update:${Z(xe)}`.replace(/-([a-z])/g, (ie, te) => te.toUpperCase()), ht = "on" + Ve.charAt(0).toUpperCase() + Ve.slice(1);
+            N.props[ht] = function(ie) {
+              const te = ie.detail !== void 0 ? ie.detail : ie.target ? ie.target.value : void 0;
+              if (ye)
+                if (U && O(U)) {
+                  const oe = U.value;
+                  if (Array.isArray(te) && Array.isArray(oe) ? JSON.stringify([...te].sort()) !== JSON.stringify([...oe].sort()) : te !== oe) {
+                    U.value = te;
+                    try {
+                      const ae = r;
+                      if (ae) {
+                        const me = ae.requestRender, ge = ae._requestRender;
+                        typeof me == "function" ? me() : typeof ge == "function" && ge();
+                      }
+                    } catch {
+                    }
+                  }
+                } else {
+                  const oe = qe(ye || {}, typeof U == "string" ? U : String(U));
+                  if (Array.isArray(te) && Array.isArray(oe) ? JSON.stringify([...te].sort()) !== JSON.stringify([...oe].sort()) : te !== oe) {
+                    dt(ye || {}, typeof U == "string" ? U : String(U), te);
+                    try {
+                      const ae = r;
+                      if (ae) {
+                        const me = ae.requestRender, ge = ae._requestRender;
+                        typeof me == "function" ? me() : typeof ge == "function" && ge();
+                      }
+                    } catch {
+                    }
+                  }
+                }
+            }, delete $[R];
+          }
+        } catch {
+        }
+        if (Object.keys($).length > 0 && (N.directives = { ...$ }), v) {
+          const D = S.some((j) => typeof j == "object" && j.tag !== "#text");
+          let x = S;
+          if (D && S.length > 0) {
+            let j = 0;
+            for (; j < S.length; ) {
+              const R = S[j];
+              if (!ce(R) || R.tag !== "#text" || typeof R.children != "string" || R.children.trim() !== "") break;
+              j++;
+            }
+            let B = S.length - 1;
+            for (; B >= 0; ) {
+              const R = S[B];
+              if (!ce(R) || R.tag !== "#text" || typeof R.children != "string" || R.children.trim() !== "") break;
+              B--;
+            }
+            j === 0 && B === S.length - 1 ? x = S : j > B ? x = [] : x = S.slice(j, B + 1);
+          }
+          const Q = se(M, l, x.length === 1 && ce(x[0]) && x[0].tag === "#text" ? typeof x[0].children == "string" ? x[0].children : "" : x.length ? x : void 0, k), H = b.pop();
+          H ? (M = H.tag, l = H.props, k = H.key, S = H.children, S.push(Q)) : (E.push(Q), M = null, l = {}, k = void 0, S = []);
+        } else A ? M ? S.push(se(c, N, void 0, void 0)) : E.push(se(c, N, void 0, void 0)) : (M && b.push({
+          tag: M,
+          props: l,
+          children: S,
+          key: k
+        }), M = c, l = N, S = []);
+      } else if (typeof y[3] < "u") {
+        const c = Number(y[3]), v = i[c];
+        u(v, `interp-${c}`);
+      } else if (y[4]) {
+        const c = y[4], v = M ? S : E, A = c.split(/({{\d+}})/);
+        for (const L of A) {
+          if (!L) continue;
+          const w = L.match(/^{{(\d+)}}$/);
+          if (w) {
+            const $ = Number(w[1]), W = i[$];
+            u(W, `interp-${$}`);
+          } else {
+            const $ = `text-${T++}`, W = _();
+            v.push(h(L, $, W));
+          }
+        }
+      }
+    }
+  const C = E.filter((c) => ce(c) && c.tag === "#text" ? typeof c.children == "string" && c.children.trim() !== "" : !0).map((c) => Ke(c));
+  if (C.length === 1) {
+    const c = C[0];
+    return o && t && Re.set(t, c), c;
+  } else if (C.length > 1) {
+    const c = C;
+    return o && t && Re.set(t, c), c;
+  }
+  return se("div", {}, "", "fallback-root");
+}
+function mn(e, ...i) {
+  if (bt()) return [];
+  const n = i[i.length - 1];
+  return an(e, i, typeof n == "object" && n && !Array.isArray(n) ? n : void 0);
+}
+export {
+  yn as n,
+  Gt as r,
+  mn as t
+};
+
+//# sourceMappingURL=template-compiler-Cs5axmn4.js.map