@jasonshimmy/custom-elements-runtime 2.5.1 → 2.5.5

package/dist/template-compiler-CJFwjLCP.js

@@ -0,0 +1,3981 @@
+import { j as K, t as Y, i as M, k as We, m as x, o as F, p as U, q as G, T as Ct, v as Qe, S as kt, x as pt, y as _e, z as ee, A as _t, B as nt, a as rt, C as st, d as At } from "./namespace-helpers-DcD_6_K1.js";
+import { a as V, d as B } from "./logger-BvkEbVM4.js";
+import { j as wt, g as Tt, a as He, b as ye, m as Ae, s as Lt, d as ot } from "./transitions-Di5wW9yc.js";
+const ge = /* @__PURE__ */ new Map(), Ke = /* @__PURE__ */ Symbol.for("cer.registry");
+function Nt() {
+  if (!(typeof window > "u" && typeof document > "u" && typeof navigator > "u"))
+    try {
+      const n = globalThis;
+      if (!n[Ke]) {
+        const t = crypto.randomUUID();
+        n[Ke] = new Map([...ge.entries()]), n[Ke].__realmId = t;
+      }
+    } catch (n) {
+      V("Could not initialize global registry:", n);
+    }
+}
+function Ot(e, n, t) {
+  if (t)
+    for (const [s, r] of Object.entries(t)) {
+      let i, o = {};
+      if (Array.isArray(r) ? (i = r[0], o = r[1] || {}) : i = r, n.set(s, {
+        callback: i,
+        options: o,
+        oldValue: K(e, s)
+      }), o.immediate)
+        try {
+          const c = K(e, s);
+          i(c, void 0, e);
+        } catch (c) {
+          B(`Error in immediate watcher for "${s}":`, c);
+        }
+    }
+}
+function jt(e, n, t, s) {
+  const r = (o, c) => {
+    if (o === c) return !0;
+    if (typeof o != typeof c || typeof o != "object" || o === null || c === null) return !1;
+    if (Array.isArray(o) && Array.isArray(c))
+      return o.length !== c.length ? !1 : o.every((d, C) => r(d, c[C]));
+    const f = o, u = c, m = Object.keys(f || {}), p = Object.keys(u || {});
+    return m.length !== p.length ? !1 : m.every((d) => r(f[d], u[d]));
+  }, i = n.get(t);
+  if (i && !r(s, i.oldValue))
+    try {
+      i.callback(s, i.oldValue, e), i.oldValue = s;
+    } catch (o) {
+      B(`Error in watcher for "${t}":`, o);
+    }
+  for (const [o, c] of n.entries())
+    if (c.options.deep && t.startsWith(o + "."))
+      try {
+        const f = K(e, o);
+        r(f, c.oldValue) || (c.callback(f, c.oldValue, e), c.oldValue = f);
+      } catch (f) {
+        B(`Error in deep watcher for "${o}":`, f);
+      }
+}
+function Fe(e, n) {
+  return n === Boolean ? e === "" || e === "true" : n === Number ? Number(e) : e;
+}
+function Pt(e, n, t) {
+  if (n)
+    for (const s in n) {
+      const r = n[s], i = Y(s), o = e.getAttribute(i);
+      if (r.type === Function && typeof e[s] == "function")
+        t[s] = e[s];
+      else if (o !== null)
+        t[s] = Fe(o, r.type);
+      else if (typeof e[s] < "u")
+        try {
+          const c = e[s];
+          if (r.type === String && c && typeof c == "object")
+            try {
+              t[s] = Fe(String(c), r.type);
+            } catch {
+              t[s] = c;
+            }
+          else r.type === Boolean && typeof c == "boolean" || r.type === Number && typeof c == "number" || r.type === Function && typeof c == "function" ? t[s] = c : t[s] = Fe(String(c), r.type);
+        } catch {
+          t[s] = e[s];
+        }
+      else "default" in r && r.default !== void 0 && (t[s] = r.default);
+    }
+}
+function Mt(e, n, t) {
+  if (!n.props) {
+    try {
+      const s = t?._hookCallbacks?.props || {}, r = Array.from(
+        /* @__PURE__ */ new Set([
+          ...Object.keys(e || {}),
+          ...Object.keys(s || {})
+        ])
+      );
+      for (const i of r) {
+        if (typeof i != "string" || i.startsWith("_")) continue;
+        const o = Object.getOwnPropertyDescriptor(t, i);
+        if (!(!Object.prototype.hasOwnProperty.call(
+          s,
+          i
+        ) && o && (o.get || o.set || !o.configurable)))
+          try {
+            Object.defineProperty(t, i, {
+              enumerable: !0,
+              configurable: !0,
+              get() {
+                try {
+                  const f = Y(i), u = e.getAttribute(f);
+                  if (u !== null)
+                    return u;
+                  const m = e[i];
+                  let p;
+                  return M(m) || m && typeof m == "object" && "value" in m && !(m instanceof Node) ? p = m.value : p = m, p;
+                } catch {
+                  return e[i];
+                }
+              }
+            });
+          } catch {
+          }
+      }
+    } catch {
+    }
+    return;
+  }
+  Pt(e, n.props, t);
+}
+function $t(e, n, t, s) {
+  e.onConnected && !t && (e.onConnected(n), s(!0));
+}
+function xt(e, n, t, s, r, i, o, c) {
+  e.onDisconnected && e.onDisconnected(n), t.forEach((f) => f()), s(), r(), i(!1), o(null), c(!1);
+}
+function Ht(e, n, t, s, r) {
+  e.onAttributeChanged && e.onAttributeChanged(n, t, s, r);
+}
+class ne {
+  static cleanupFunctions = /* @__PURE__ */ new WeakMap();
+  /**
+   * Add an event listener with automatic cleanup tracking
+   */
+  static addListener(n, t, s, r) {
+    n.addEventListener(t, s, r);
+    const o = {
+      event: t,
+      handler: s,
+      wrapper: s,
+      options: r,
+      cleanup: () => n.removeEventListener(t, s, r),
+      addedAt: Date.now()
+    };
+    this.cleanupFunctions.has(n) || this.cleanupFunctions.set(n, []);
+    const c = this.cleanupFunctions.get(n);
+    c.push(o), c.__metaList = c;
+  }
+  /**
+   * Remove a specific event listener
+   */
+  static removeListener(n, t, s, r) {
+    n.removeEventListener(t, s, r);
+    const i = this.cleanupFunctions.get(n);
+    if (i)
+      for (let o = 0; o < i.length; o++) {
+        const c = i[o];
+        if (c.event === t && c.handler === s) {
+          i.splice(o, 1), i.length === 0 && this.cleanupFunctions.delete(n);
+          return;
+        }
+      }
+  }
+  /**
+   * Clean up all event listeners for an element
+   */
+  static cleanup(n) {
+    const t = this.cleanupFunctions.get(n);
+    t && (t.forEach((s) => {
+      try {
+        s.cleanup();
+      } catch {
+      }
+    }), this.cleanupFunctions.delete(n));
+  }
+  /**
+   * Clean up all tracked event listeners (useful for testing)
+   */
+  static cleanupAll() {
+    this.cleanupFunctions = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * Check if an element has any tracked event listeners
+   */
+  static hasListeners(n) {
+    const t = this.cleanupFunctions.get(n);
+    return !!(t && t.length > 0);
+  }
+  /**
+   * Get the number of tracked event listeners for an element
+   */
+  static getListenerCount(n) {
+    const t = this.cleanupFunctions.get(n);
+    return t ? t.length : 0;
+  }
+  /**
+   * Return listener metadata stored for the element (test/debug only)
+   */
+  static getListenerInfo(n) {
+    const t = this.cleanupFunctions.get(n);
+    return t ? t.map((s) => ({
+      event: s.event,
+      handler: s.handler,
+      wrapper: s.wrapper,
+      options: s.options
+    })) : [];
+  }
+}
+class Rt {
+  static cache = /* @__PURE__ */ new Map();
+  static maxCacheSize = 1e3;
+  // Dangerous patterns to block
+  static dangerousPatterns = [
+    /constructor/i,
+    /prototype/i,
+    /__proto__/i,
+    /function/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(n, t) {
+    const s = this.cache.get(n);
+    if (s) {
+      if (!s.isSecure) {
+        V("Blocked cached dangerous expression:", n);
+        return;
+      }
+      try {
+        this.cache.delete(n), this.cache.set(n, s);
+      } catch {
+      }
+      return s.evaluator(t);
+    }
+    const r = this.createEvaluator(n);
+    if (this.cache.size >= this.maxCacheSize) {
+      const i = this.cache.keys().next().value;
+      i && this.cache.delete(i);
+    }
+    if (this.cache.set(n, r), !r.isSecure) {
+      V("Blocked dangerous expression:", n);
+      return;
+    }
+    return r.evaluator(t);
+  }
+  static createEvaluator(n) {
+    if (this.hasDangerousPatterns(n))
+      return { evaluator: () => {
+      }, isSecure: !1 };
+    if (n.length > 1e3)
+      return { evaluator: () => {
+      }, isSecure: !1 };
+    try {
+      return { evaluator: this.createSafeEvaluator(n), isSecure: !0 };
+    } catch (t) {
+      return V("Failed to create evaluator for expression:", n, t), { evaluator: () => {
+      }, isSecure: !1 };
+    }
+  }
+  static hasDangerousPatterns(n) {
+    return this.dangerousPatterns.some((t) => t.test(n));
+  }
+  static createSafeEvaluator(n) {
+    const t = n.trim();
+    if (t.startsWith("{") && t.endsWith("}"))
+      return this.createObjectEvaluator(n);
+    if (/^ctx\.[a-zA-Z0-9_.]+$/.test(n.trim())) {
+      const s = n.trim().slice(4);
+      return (r) => K(r, s);
+    }
+    return n.includes("ctx") || /[+\-*/%<>=&|?:[\]]/.test(n) ? this.createSimpleEvaluator(n) : (s) => K(s, n);
+  }
+  static createObjectEvaluator(n) {
+    const t = n.trim().slice(1, -1), s = this.parseObjectProperties(t);
+    return (r) => {
+      const i = {};
+      for (const { key: o, value: c } of s)
+        try {
+          if (c.startsWith("ctx.")) {
+            const f = c.slice(4);
+            i[o] = K(r, f);
+          } else
+            i[o] = this.evaluateSimpleValue(c, r);
+        } catch {
+          i[o] = void 0;
+        }
+      return i;
+    };
+  }
+  static parseObjectProperties(n) {
+    const t = [], s = n.split(",");
+    for (const r of s) {
+      const i = r.indexOf(":");
+      if (i === -1) continue;
+      const o = r.slice(0, i).trim(), c = r.slice(i + 1).trim(), f = o.replace(/^['"]|['"]$/g, "");
+      t.push({ key: f, value: c });
+    }
+    return t;
+  }
+  static createSimpleEvaluator(n) {
+    return (t) => {
+      try {
+        let s = n;
+        const r = [];
+        s = s.replace(
+          /("[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*')/g,
+          (p) => `<<#${r.push(p) - 1}#>>`
+        );
+        const i = s.match(/ctx\.[\w.]+/g) || [];
+        for (const p of i) {
+          const d = p.slice(4), C = K(t, d);
+          if (C === void 0) return;
+          const T = r.push(JSON.stringify(C)) - 1;
+          s = s.replace(
+            new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+            `<<#${T}#>>`
+          );
+        }
+        const o = /\b[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+\b/g, c = s.match(o) || [];
+        for (const p of c) {
+          if (p.startsWith("ctx.")) continue;
+          const d = K(t, p);
+          if (d === void 0) return;
+          const C = r.push(JSON.stringify(d)) - 1;
+          s = s.replace(
+            new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+            `<<#${C}#>>`
+          );
+        }
+        const f = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+        let u;
+        const m = /* @__PURE__ */ new Set();
+        for (; (u = f.exec(s)) !== null; ) {
+          const p = u[1];
+          if (["true", "false", "null", "undefined"].includes(p) || /^[0-9]+$/.test(p) || p === "ctx" || m.has(p)) continue;
+          m.add(p);
+          const d = K(t, p);
+          if (d === void 0) return;
+          const C = JSON.stringify(d), T = r.push(C) - 1;
+          p.includes(".") ? s = s.replace(
+            new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+            `<<#${T}#>>`
+          ) : s = s.replace(
+            new RegExp(
+              "\\b" + p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\b",
+              "g"
+            ),
+            `<<#${T}#>>`
+          );
+        }
+        s = s.replace(
+          /<<#(\d+)#>>/g,
+          (p, d) => r[Number(d)]
+        );
+        try {
+          return this.evaluateBasicExpression(s);
+        } catch {
+          return;
+        }
+      } catch {
+        return;
+      }
+    };
+  }
+  /**
+   * Evaluate a very small, safe expression grammar without using eval/Function.
+   * Supports: numbers, string literals, true/false, null, arrays, unary !,
+   * arithmetic (+ - * / %), comparisons, logical && and ||, parentheses, and ternary `a ? b : c`.
+   */
+  static evaluateBasicExpression(n) {
+    const t = this.tokenize(n);
+    let s = 0;
+    function r() {
+      return t[s];
+    }
+    function i(y) {
+      const _ = t[s++];
+      if (y && !_)
+        throw new Error(`Unexpected token EOF, expected ${y}`);
+      if (y && _ && _.type !== y && _.value !== y)
+        throw new Error(
+          `Unexpected token ${_.type}/${_.value}, expected ${y}`
+        );
+      return _;
+    }
+    function o() {
+      return T();
+    }
+    function c(y) {
+      if (typeof y == "number") return y;
+      if (y == null) return NaN;
+      if (typeof y == "boolean") return y ? 1 : 0;
+      const _ = Number(y);
+      return Number.isNaN(_) ? NaN : _;
+    }
+    function f(y, _) {
+      return typeof y == "string" || typeof _ == "string" ? String(y) + String(_) : c(y) + c(_);
+    }
+    function u(y, _) {
+      return c(y) - c(_);
+    }
+    function m(y, _) {
+      return c(y) * c(_);
+    }
+    function p(y, _) {
+      return c(y) / c(_);
+    }
+    function d(y, _) {
+      return c(y) % c(_);
+    }
+    function C(y, _, l) {
+      if (typeof _ == "number" && typeof l == "number")
+        switch (y) {
+          case ">":
+            return _ > l;
+          case "<":
+            return _ < l;
+          case ">=":
+            return _ >= l;
+          case "<=":
+            return _ <= l;
+          default:
+            return !1;
+        }
+      const g = String(_), A = String(l);
+      switch (y) {
+        case ">":
+          return g > A;
+        case "<":
+          return g < A;
+        case ">=":
+          return g >= A;
+        case "<=":
+          return g <= A;
+        default:
+          return !1;
+      }
+    }
+    function T() {
+      const y = w(), _ = r();
+      if (_ && _.value === "?") {
+        i("?");
+        const l = o();
+        i(":");
+        const g = o();
+        return y ? l : g;
+      }
+      return y;
+    }
+    function w() {
+      let y = a();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || _.value !== "||") break;
+        i("OP");
+        const l = a();
+        y = y || l;
+      }
+      return y;
+    }
+    function a() {
+      let y = E();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || _.value !== "&&") break;
+        i("OP");
+        const l = E();
+        y = y && l;
+      }
+      return y;
+    }
+    function E() {
+      let y = v();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || !["==", "!=", "===", "!=="].includes(_.value)) break;
+        const l = i("OP").value, g = v();
+        switch (l) {
+          case "==":
+            y = y == g;
+            break;
+          case "!=":
+            y = y != g;
+            break;
+          case "===":
+            y = y === g;
+            break;
+          case "!==":
+            y = y !== g;
+            break;
+        }
+      }
+      return y;
+    }
+    function v() {
+      let y = b();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || ![">", "<", ">=", "<="].includes(_.value)) break;
+        const l = i("OP").value, g = b();
+        switch (l) {
+          case ">":
+            y = C(">", y, g);
+            break;
+          case "<":
+            y = C("<", y, g);
+            break;
+          case ">=":
+            y = C(">=", y, g);
+            break;
+          case "<=":
+            y = C("<=", y, g);
+            break;
+        }
+      }
+      return y;
+    }
+    function b() {
+      let y = h();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || _.value !== "+" && _.value !== "-") break;
+        const l = i("OP").value, g = h();
+        y = l === "+" ? f(y, g) : u(y, g);
+      }
+      return y;
+    }
+    function h() {
+      let y = k();
+      for (; ; ) {
+        const _ = r();
+        if (!_ || _.value !== "*" && _.value !== "/" && _.value !== "%")
+          break;
+        const l = i("OP").value, g = k();
+        switch (l) {
+          case "*":
+            y = m(y, g);
+            break;
+          case "/":
+            y = p(y, g);
+            break;
+          case "%":
+            y = d(y, g);
+            break;
+        }
+      }
+      return y;
+    }
+    function k() {
+      const y = r();
+      if (y && y.value === "!")
+        return i("OP"), !k();
+      if (y && y.value === "-") {
+        i("OP");
+        const _ = k();
+        return u(0, _);
+      }
+      return S();
+    }
+    function S() {
+      const y = r();
+      if (y) {
+        if (y.type === "NUMBER")
+          return i("NUMBER"), Number(y.value);
+        if (y.type === "STRING")
+          return i("STRING"), y.value.slice(1, -1);
+        if (y.type === "IDENT")
+          return i("IDENT"), y.value === "true" ? !0 : y.value === "false" ? !1 : y.value === "null" ? null : void 0;
+        if (y.value === "[") {
+          i("PUNC");
+          const _ = [];
+          for (; ; ) {
+            const l = r();
+            if (!l || l.value === "]") break;
+            _.push(o());
+            const g = r();
+            g && g.value === "," && i("PUNC");
+          }
+          return i("PUNC"), _;
+        }
+        if (y.value === "(") {
+          i("PUNC");
+          const _ = o();
+          return i("PUNC"), _;
+        }
+        throw new Error("Unexpected token in expression");
+      }
+    }
+    return o();
+  }
+  static tokenize(n) {
+    const t = [], s = /\s*(=>|===|!==|==|!=|>=|<=|\|\||&&|[()?:,[\]]|\+|-|\*|\/|%|>|<|!|\d+\.?\d*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[a-zA-Z_][a-zA-Z0-9_]*|\S)\s*/g;
+    let r;
+    for (; (r = s.exec(n)) !== null; ) {
+      const i = r[1];
+      i && (/^\d/.test(i) ? t.push({ type: "NUMBER", value: i }) : /^"/.test(i) || /^'/.test(i) ? t.push({ type: "STRING", value: i }) : /^[a-zA-Z_]/.test(i) ? t.push({ type: "IDENT", value: i }) : /^[()?:,[\]]$/.test(i) ? t.push({ type: "PUNC", value: i }) : t.push({ type: "OP", value: i }));
+    }
+    return t;
+  }
+  static evaluateSimpleValue(n, t) {
+    if (n === "true") return !0;
+    if (n === "false") return !1;
+    if (!isNaN(Number(n))) return Number(n);
+    if (n.startsWith("ctx.")) {
+      const s = n.slice(4);
+      return K(t, s);
+    }
+    return n.startsWith('"') && n.endsWith('"') || n.startsWith("'") && n.endsWith("'") ? n.slice(1, -1) : n;
+  }
+  static clearCache() {
+    this.cache.clear();
+  }
+  static getCacheSize() {
+    return this.cache.size;
+  }
+}
+function Re(e, n) {
+  return Array.isArray(e) && Array.isArray(n) ? JSON.stringify([...e].sort()) !== JSON.stringify([...n].sort()) : e !== n;
+}
+function it(e, n, t, s, r) {
+  if (e) {
+    const i = n.value;
+    if (r && typeof i == "object" && i !== null) {
+      const o = { ...i };
+      o[r] = t, n.value = o;
+    } else
+      n.value = t;
+  } else {
+    const i = s._state || s;
+    We(i, n, t);
+  }
+}
+function Ie(e, n, t, s) {
+  if (typeof e._requestRender == "function" && e._requestRender(), typeof e._triggerWatchers == "function") {
+    const r = n ? "reactiveState" : t;
+    e._triggerWatchers(r, s);
+  }
+}
+function It(e, n, t) {
+  const s = `update:${Y(n)}`, r = `update:${n}`, i = new CustomEvent(s, {
+    detail: t,
+    bubbles: !0,
+    cancelable: !0
+  }), o = new CustomEvent(r, {
+    detail: t,
+    bubbles: !0,
+    cancelable: !0
+  });
+  e.dispatchEvent(i), e.dispatchEvent(o);
+}
+function ct(e, n, t, s) {
+  const r = t;
+  if (x(() => {
+    if (typeof e.setAttribute == "function")
+      try {
+        e[n] = r;
+      } catch {
+      }
+    else
+      e[n] = r;
+  }), r == null || typeof r == "string" || typeof r == "number" || typeof r == "boolean") {
+    const i = F(r);
+    i !== null ? x(() => {
+      typeof e.setAttribute == "function" && U(
+        e,
+        Y(n),
+        String(i)
+      );
+    }) : x(() => {
+      typeof e.removeAttribute == "function" && G(e, Y(n));
+    });
+  }
+}
+function Dt(e, n, t, s) {
+  if (e) {
+    const r = n.value;
+    return s && typeof r == "object" && r !== null ? r[s] : r;
+  } else {
+    const r = t._state || t;
+    return K(r, n);
+  }
+}
+function Ne(e) {
+  return e != null && typeof e == "object" && "value" in e;
+}
+function Ze(e) {
+  return e != null && typeof e == "object" && "value" in e ? e.value : e;
+}
+function oe(e, n, t) {
+  if (!e) return;
+  e.attrs || (e.attrs = {});
+  const s = e.attrs;
+  s[n] = t;
+}
+function Q(e) {
+  return e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement;
+}
+function pe(e) {
+  return e != null && typeof e == "object" && "value" in e ? pe(e.value) : !(e != null && typeof e == "object" || e === !1 || e === "false" || e === null || e === void 0 || e === 0);
+}
+function ht(e) {
+  return e.substring(2, 3).toLowerCase() + e.substring(3);
+}
+function Je(e) {
+  return typeof e == "boolean" || e === "true" || e === "false";
+}
+function Bt(e, n, t, s, r, i, o, c) {
+  if (!i) return;
+  const f = n.includes("lazy"), u = n.includes("trim"), m = n.includes("number"), p = () => {
+    if (M(e)) {
+      const h = e.value;
+      return c && o && (o instanceof HTMLInputElement || o instanceof HTMLTextAreaElement || o instanceof HTMLSelectElement) && typeof h == "object" && h !== null ? h[c] : h;
+    }
+    const b = i?._state || i;
+    return K(b, e);
+  }, d = p();
+  let C = "text";
+  o instanceof HTMLInputElement ? C = s?.type || o.type || "text" : o instanceof HTMLSelectElement ? C = "select" : o instanceof HTMLTextAreaElement && (C = "textarea");
+  const T = o instanceof HTMLInputElement || o instanceof HTMLTextAreaElement || o instanceof HTMLSelectElement, a = T ? C === "checkbox" || C === "radio" ? "checked" : "value" : c ?? "modelValue";
+  if (C === "checkbox")
+    if (Array.isArray(d))
+      t[a] = d.includes(
+        String(o?.getAttribute("value") ?? s?.value ?? "")
+      );
+    else {
+      const b = o?.getAttribute("true-value") ?? !0;
+      t[a] = d === b;
+    }
+  else if (C === "radio")
+    t[a] = d === (s?.value ?? "");
+  else if (C === "select")
+    if (o && o.hasAttribute("multiple") && o instanceof HTMLSelectElement) {
+      const b = Array.isArray(d) ? d.map(String) : [];
+      setTimeout(() => {
+        Array.from(o.options).forEach((h) => {
+          h.selected = b.includes(h.value);
+        });
+      }, 0), t[a] = Array.isArray(d) ? d : [];
+    } else
+      t[a] = d;
+  else {
+    !T && M(e) ? t[a] = e : t[a] = d;
+    try {
+      const b = Y(a);
+      s && (s[b] = d);
+    } catch {
+    }
+  }
+  const E = f || C === "checkbox" || C === "radio" || C === "select" ? "change" : "input", v = (b) => {
+    if (b.isComposing || r._isComposing)
+      return;
+    const h = globalThis.process, k = !!h && h.env?.NODE_ENV === "test" || typeof window < "u" && globalThis.__vitest__;
+    if (b.isTrusted === !1 && !k)
+      return;
+    const S = b.target;
+    if (!S || S._modelUpdating)
+      return;
+    let L = S.value;
+    if (C === "checkbox") {
+      const l = p();
+      if (Array.isArray(l)) {
+        const g = S.getAttribute("value") ?? "", A = Array.from(l);
+        if (S.checked)
+          A.includes(g) || A.push(g);
+        else {
+          const N = A.indexOf(g);
+          N > -1 && A.splice(N, 1);
+        }
+        L = A;
+      } else {
+        const g = S.getAttribute("true-value") ?? !0, A = S.getAttribute("false-value") ?? !1;
+        L = S.checked ? g : A;
+      }
+    } else if (C === "radio")
+      L = S.getAttribute("value") ?? S.value;
+    else if (C === "select" && S.multiple)
+      L = Array.from(S.selectedOptions).map(
+        (l) => l.value
+      );
+    else if (u && typeof L == "string" && (L = L.trim()), m) {
+      const l = Number(L);
+      isNaN(l) || (L = l);
+    }
+    const y = p();
+    if (Re(L, y)) {
+      S._modelUpdating = !0;
+      try {
+        it(M(e), e, L, i, c), Ie(i, M(e), e, L), S && It(S, a, L);
+      } finally {
+        setTimeout(
+          () => S._modelUpdating = !1,
+          0
+        );
+      }
+    }
+  };
+  if (T) {
+    if (r[E]) {
+      const b = r[E];
+      o && ne.removeListener(o, E, b);
+    }
+    r[E] = v;
+  } else {
+    const b = `update:${Y(a)}`, h = `update:${a}`;
+    if (r[b]) {
+      const k = r[b];
+      o && ne.removeListener(o, b, k);
+    }
+    if (r[h]) {
+      const k = r[h];
+      o && ne.removeListener(o, h, k);
+    }
+    if (r[b] = (k) => {
+      const S = k.detail;
+      let L = S !== void 0 ? S : void 0;
+      if (L === void 0) {
+        const l = k.target;
+        if (l && typeof l == "object" && "value" in l)
+          try {
+            L = l.value;
+          } catch {
+            L = void 0;
+          }
+      }
+      const y = Dt(
+        M(e),
+        e,
+        i,
+        c
+      );
+      if (Re(L, y)) {
+        it(M(e), e, L, i, c), Ie(i, M(e), e, L);
+        const l = k.target;
+        l && ct(
+          l,
+          a,
+          M(e) ? e : L,
+          M(e)
+        );
+      }
+    }, M(e) && typeof e.value == "object" && e.value !== null) {
+      let k;
+      try {
+        k = Reflect.ownKeys(e.value);
+      } catch {
+        k = Object.keys(e.value);
+      }
+      const S = k.filter(
+        (L) => typeof L == "string" && !String(L).startsWith("_") && L !== "constructor"
+      );
+      for (const L of S) {
+        const y = String(L), _ = `update:${Y(y)}`, l = `update:${y}`;
+        r[_] || (r[_] = (g) => {
+          const A = g.detail !== void 0 ? g.detail : g.target?.value, N = M(e) ? e.value[y] : K(
+            i?._state || i,
+            e
+          );
+          if (!Re(A, N)) return;
+          if (M(e)) {
+            const D = {
+              ...e.value
+            };
+            D[y] = A, e.value = D;
+          } else
+            We(
+              i?._state || i,
+              e,
+              A
+            );
+          Ie(i, M(e), e, A);
+          const P = g.currentTarget || o || g.target;
+          P && ct(
+            P,
+            a,
+            M(e) ? e : A,
+            M(e)
+          );
+        }, r[l] = r[_]);
+      }
+    }
+    r[h] = r[b];
+  }
+  (C === "text" || C === "textarea") && (r.compositionstart = () => r._isComposing = !0, r.compositionend = (b) => {
+    r._isComposing = !1;
+    const h = b.target;
+    h && setTimeout(() => {
+      const k = h.value, S = i?._state || i, L = K(S, e);
+      let y = k;
+      if (u && (y = y.trim()), m) {
+        const l = Number(y);
+        isNaN(l) || (y = l);
+      }
+      if (Re(y, L)) {
+        h._modelUpdating = !0;
+        try {
+          We(S, e, y), Ie(i, M(e), e, y);
+        } finally {
+          setTimeout(
+            () => h._modelUpdating = !1,
+            0
+          );
+        }
+      }
+    }, 0);
+  });
+}
+function Wt(e, n, t, s, r) {
+  if (typeof e == "object" && e !== null)
+    for (const [i, o] of Object.entries(e))
+      if (i.startsWith("data-") || i.startsWith("aria-") || i === "class")
+        t[i] = o;
+      else if (i === "disabled" && r && Q(r)) {
+        const c = o && typeof o == "object" && "value" in o;
+        (() => {
+          try {
+            return M(o);
+          } catch {
+            return !1;
+          }
+        })() || c ? n[i] = o : t[i] = o;
+      } else
+        n[i] = o;
+  else if (typeof e == "string") {
+    if (!s) return;
+    try {
+      const i = Me(e, s);
+      if (typeof i == "object" && i !== null) {
+        for (const [o, c] of Object.entries(i))
+          if (o.startsWith("data-") || o.startsWith("aria-") || o === "class")
+            t[o] = c;
+          else if (o === "disabled" && r && Q(r)) {
+            const f = c && typeof c == "object" && "value" in c;
+            (() => {
+              try {
+                return M(c);
+              } catch {
+                return !1;
+              }
+            })() || f ? n[o] = c : t[o] = c;
+          } else
+            n[o] = c;
+        return;
+      } else {
+        t[e] = i;
+        return;
+      }
+    } catch {
+      const i = K(
+        s,
+        e
+      );
+      t[e] = i;
+    }
+  }
+}
+function Ut(e, n, t) {
+  let s;
+  if (typeof e == "string") {
+    if (!t) return;
+    s = Me(e, t);
+  } else
+    s = e;
+  const r = String(n.style || "");
+  let i = r;
+  if (s) {
+    if (r) {
+      const o = String(r).split(";").map((f) => f.trim()).filter(Boolean), c = o.findIndex(
+        (f) => f.startsWith("display:")
+      );
+      c >= 0 && o[c] === "display: none" && (o.splice(c, 1), i = o.length > 0 ? o.join("; ") + ";" : "");
+    }
+  } else if (r) {
+    const o = String(r).split(";").filter(Boolean), c = o.findIndex(
+      (f) => f.trim().startsWith("display:")
+    );
+    c >= 0 ? o[c] = "display: none" : o.push("display: none"), i = o.join("; ");
+  } else
+    i = "display: none";
+  i !== r && (i ? n.style = i : n.style = void 0);
+}
+function Me(e, n) {
+  return Rt.evaluate(e, n);
+}
+function zt(e, n, t, s) {
+  let r;
+  if (typeof e == "string") {
+    if (!t) return;
+    r = Me(e, t);
+  } else
+    r = e;
+  try {
+    if (r && typeof r == "object") {
+      if (M(r))
+        r = r.value;
+      else if ("value" in r && typeof r.value < "u") {
+        const u = r.value;
+        u instanceof Node || (r = u);
+      }
+    }
+  } catch {
+  }
+  let i = [];
+  if (typeof r == "string")
+    i = [r];
+  else if (Array.isArray(r))
+    i = r.filter(Boolean);
+  else if (typeof r == "object" && r !== null)
+    for (const [u, m] of Object.entries(r))
+      m && i.push(u);
+  const o = i.join(" "), c = s && s.class || n.class || "", f = c ? `${c} ${o}`.trim() : o.trim();
+  f ? n.class = f : n.class = void 0;
+}
+function Kt(e, n, t) {
+  let s;
+  if (typeof e == "string") {
+    if (!t) return;
+    s = Me(e, t);
+  } else
+    s = e;
+  let r = "";
+  if (typeof s == "string")
+    r = s;
+  else if (s && typeof s == "object") {
+    const o = [];
+    for (const [c, f] of Object.entries(s))
+      if (f != null && f !== "") {
+        const u = c.replace(
+          /[A-Z]/g,
+          (d) => `-${d.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 p = String(f);
+        typeof f == "number" && m.includes(u) && (p = `${f}px`), o.push(`${u}: ${p}`);
+      }
+    r = o.join("; ") + (o.length > 0 ? ";" : "");
+  }
+  const i = String(n.style || "");
+  n.style = i + (i && !i.endsWith(";") ? "; " : "") + r;
+}
+function Ft(e, n, t) {
+  let s = e;
+  typeof e == "string" && t && (s = Me(e, t)), M(s) ? n.reactiveRef = s : n.ref = s;
+}
+function yt(e, n, t, s) {
+  const r = {}, i = { ...s || {} }, o = {};
+  for (const [c, f] of Object.entries(e)) {
+    const { value: u, modifiers: m, arg: p } = f;
+    if (c === "model" || c.startsWith("model:")) {
+      const d = c.split(":"), C = d.length > 1 ? d[1] : p;
+      Bt(
+        u,
+        // Pass the original value (could be string or reactive state object)
+        m,
+        r,
+        i,
+        o,
+        n,
+        t,
+        C
+      );
+      continue;
+    }
+    switch (c) {
+      case "bind":
+        Wt(u, r, i, n, t);
+        break;
+      case "show":
+        Ut(u, i, n);
+        break;
+      case "class":
+        zt(u, i, n, s);
+        break;
+      case "style":
+        Kt(u, i, n);
+        break;
+      case "ref":
+        Ft(u, r, n);
+        break;
+    }
+  }
+  try {
+    if (Object.prototype.hasOwnProperty.call(r, "disabled") && t && Q(t)) {
+      const f = r.disabled, u = f && typeof f == "object" && "value" in f;
+      let m = !1;
+      try {
+        m = M(f);
+      } catch {
+        m = !1;
+      }
+      if (!u && !m)
+        try {
+          i.disabled = f, delete r.disabled;
+          const p = globalThis;
+          p.__VDOM_DISABLED_PROMOTIONS || (p.__VDOM_DISABLED_PROMOTIONS = []), p.__VDOM_DISABLED_PROMOTIONS.push({
+            phase: "bind-directive:postfix-move",
+            location: "attrs",
+            key: "disabled",
+            value: f,
+            time: Date.now(),
+            stack: new Error().stack
+          });
+        } catch {
+        }
+    }
+  } catch {
+  }
+  return { props: r, attrs: i, listeners: o };
+}
+function be(e) {
+  return e ? e.split(/\s+/).filter(Boolean) : [];
+}
+function ve(e, n) {
+  if (n.length === 0) return;
+  const t = n.filter(
+    (s) => s && !e.classList.contains(s)
+  );
+  t.length > 0 && e.classList.add(...t);
+}
+function me(e, n) {
+  if (n.length === 0) return;
+  const t = n.filter(Boolean);
+  t.length > 0 && e.classList.remove(...t);
+}
+let Ve = !1;
+async function Vt(e, n, t = 10) {
+  if (!Ve) {
+    if (!e.isConnected) {
+      V("⚠️ Element not connected to DOM, skipping style wait");
+      return;
+    }
+    for (let s = 0; s < t; s++) {
+      const r = window.getComputedStyle(e), i = r.transform && r.transform !== "", o = r.opacity && r.opacity !== "";
+      if (i || o) {
+        Ve = !0;
+        return;
+      }
+      await new Promise(
+        (c) => requestAnimationFrame(() => c(void 0))
+      );
+    }
+    Ve = !0, V("⚠️ Styles did not load in time for transition, continuing anyway");
+  }
+}
+function qt(e) {
+  const n = window.getComputedStyle(e), t = n.transitionDuration || "0s", s = n.transitionDelay || "0s", r = (i) => {
+    const o = parseFloat(i);
+    return i.includes("ms") ? o : o * 1e3;
+  };
+  return r(t) + r(s);
+}
+function mt(e, n) {
+  return new Promise((t) => {
+    const s = n ?? qt(e);
+    if (s <= 0) {
+      t();
+      return;
+    }
+    let r = !1;
+    const i = () => {
+      r || (r = !0, e.removeEventListener("transitionend", o), e.removeEventListener("transitioncancel", o), t());
+    }, o = () => i();
+    e.addEventListener("transitionend", o), e.addEventListener("transitioncancel", o), setTimeout(i, s + 50);
+  });
+}
+async function we(e, n) {
+  const { classes: t, hooks: s, css: r, duration: i } = n;
+  if (s?.onBeforeEnter)
+    try {
+      s.onBeforeEnter(e);
+    } catch (T) {
+      B("Transition onBeforeEnter error:", T);
+    }
+  if (!r)
+    return s?.onEnter ? new Promise((T) => {
+      const w = s.onEnter;
+      typeof w == "function" ? w(e, () => {
+        if (s?.onAfterEnter)
+          try {
+            s.onAfterEnter(e);
+          } catch (a) {
+            B("Transition onAfterEnter error:", a);
+          }
+        T();
+      }) : T();
+    }) : void 0;
+  const o = be(t?.enterFrom), c = be(t?.enterActive), f = be(t?.enterTo);
+  ve(e, o), e.offsetHeight, ve(e, c), e.offsetHeight;
+  let u;
+  if (s?.onEnter) {
+    const T = new Promise((w) => {
+      u = w;
+    });
+    try {
+      const w = s.onEnter;
+      typeof w == "function" && w(e, () => {
+        u && u();
+      });
+    } catch (w) {
+      B("Transition onEnter error:", w);
+    }
+    u && await T;
+  }
+  await new Promise(
+    (T) => requestAnimationFrame(() => T(void 0))
+  ), e.offsetHeight;
+  const m = window.getComputedStyle(e), p = m.transform, d = m.opacity;
+  me(e, o), p && p !== "none" && (e.style.transform = p), d && d !== "" && (e.style.opacity = d), e.offsetHeight, await new Promise(
+    (T) => requestAnimationFrame(() => T(void 0))
+  ), e.style.transform = "", e.style.opacity = "", ve(e, f), e.offsetHeight, await new Promise(
+    (T) => requestAnimationFrame(() => T(void 0))
+  );
+  let C;
+  if (typeof i == "number" ? C = i : i && typeof i == "object" && "enter" in i && (C = i.enter), await mt(e, C), me(e, c), s?.onAfterEnter)
+    try {
+      s.onAfterEnter(e);
+    } catch (T) {
+      B("Transition onAfterEnter error:", T);
+    }
+}
+async function qe(e, n) {
+  const { classes: t, hooks: s, css: r, duration: i } = n;
+  if (s?.onBeforeLeave)
+    try {
+      s.onBeforeLeave(e);
+    } catch (p) {
+      B("Transition onBeforeLeave error:", p);
+    }
+  if (!r)
+    return s?.onLeave ? new Promise((p) => {
+      const d = s.onLeave;
+      typeof d == "function" ? d(e, () => {
+        if (s?.onAfterLeave)
+          try {
+            s.onAfterLeave(e);
+          } catch (C) {
+            B("Transition onAfterLeave error:", C);
+          }
+        p();
+      }) : p();
+    }) : void 0;
+  const o = be(t?.leaveFrom), c = be(t?.leaveActive), f = be(t?.leaveTo);
+  ve(e, o), e.offsetHeight, ve(e, c);
+  let u;
+  if (s?.onLeave) {
+    const p = new Promise((d) => {
+      u = d;
+    });
+    try {
+      const d = s.onLeave;
+      typeof d == "function" && d(e, () => {
+        u && u();
+      });
+    } catch (d) {
+      B("Transition onLeave error:", d);
+    }
+    u && await p;
+  }
+  await new Promise(
+    (p) => requestAnimationFrame(() => p(void 0))
+  ), await Vt(e, [...o, ...c]), me(e, o), ve(e, f);
+  let m;
+  if (typeof i == "number" ? m = i : i && typeof i == "object" && "leave" in i && (m = i.leave), await mt(e, m), me(e, c), me(e, f), me(e, o), s?.onAfterLeave)
+    try {
+      s.onAfterLeave(e);
+    } catch (p) {
+      B("Transition onAfterLeave error:", p);
+    }
+}
+const gt = /* @__PURE__ */ new WeakMap(), bt = /* @__PURE__ */ new WeakMap();
+function De(e) {
+  if (!e) return;
+  const n = gt.get(e);
+  if (n !== void 0) return n;
+  try {
+    const t = e;
+    if (t && t.key != null) return String(t.key);
+  } catch {
+  }
+  if (e instanceof Element) {
+    const t = e.getAttribute("data-anchor-key");
+    if (t) return t;
+  }
+}
+function Z(e, n) {
+  try {
+    gt.set(e, n);
+  } catch {
+  }
+  try {
+    e.key = n;
+  } catch {
+  }
+  try {
+    if (e instanceof Element) {
+      const t = F(n);
+      t !== null && U(e, "data-anchor-key", t);
+    }
+  } catch {
+  }
+}
+function Gt(e) {
+  if (!e) return;
+  const n = bt.get(e);
+  if (n !== void 0) return n;
+  try {
+    const t = e;
+    if (t && t._transitionGroup != null)
+      return t._transitionGroup;
+  } catch {
+  }
+}
+function Zt(e, n) {
+  try {
+    bt.set(e, n);
+  } catch {
+  }
+  try {
+    e._transitionGroup = n;
+  } catch {
+  }
+}
+function de(e, n) {
+  if (n) {
+    if (e instanceof Element) {
+      ne.cleanup(e);
+      const t = [];
+      for (const s in n)
+        n[s] === e && t.push(s);
+      for (const s of t)
+        delete n[s];
+    }
+    if (e.hasChildNodes()) {
+      const t = e.childNodes;
+      for (let s = t.length - 1; s >= 0; s--)
+        de(t[s], n);
+    }
+  }
+}
+function Te(e, n, t) {
+  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 (M(s) || typeof s == "object" && "value" in s)
+        s.value = n;
+      else if (typeof s == "function")
+        s(n);
+      else if (typeof s == "string" && t)
+        try {
+          const i = String(s);
+          t[i] = n;
+        } catch {
+        }
+    } catch {
+    }
+  else if (r && t)
+    try {
+      const i = String(r);
+      t[i] = n;
+    } catch {
+    }
+}
+function Ye(e, n) {
+  if (Array.isArray(e)) {
+    const i = /* @__PURE__ */ new Set();
+    return e.map((o) => {
+      if (!o || typeof o != "object") return o;
+      let c = o.props?.key ?? o.key;
+      if (!c) {
+        const p = o.tag || "node", C = [
+          // attrs (kebab-case)
+          o.props?.attrs?.id,
+          o.props?.attrs?.name,
+          o.props?.attrs?.["data-key"],
+          // promoted JS props (camelCase or original)
+          o.props?.props?.id,
+          o.props?.props?.name,
+          o.props?.props?.dataKey,
+          o.props?.props?.["data-key"]
+        ].find((T) => T != null) ?? "";
+        c = C ? `${n}:${p}:${C}` : `${n}:${p}`;
+      }
+      let f = c, u = 1;
+      for (; i.has(f); )
+        f = `${c}#${u++}`;
+      i.add(f);
+      let m = o.children;
+      return Array.isArray(m) && (m = Ye(m, f)), { ...o, key: f, children: m };
+    });
+  }
+  const t = e, s = t.props?.key ?? t.key ?? n;
+  let r = t.children;
+  return Array.isArray(r) && (r = Ye(r, s)), { ...t, key: s, children: r };
+}
+function at(e, n, t, s) {
+  const r = t.directives ?? {}, i = t.attrs ? { ...t.attrs } : {}, o = yt(
+    r,
+    s,
+    e,
+    i
+  ), c = {
+    ...n.props || {},
+    ...t.props || {},
+    ...o.props || {}
+  }, f = {
+    ...i || {},
+    ...o.attrs || {}
+  }, u = n.props ?? {}, m = c, p = !!(t?.isCustomElement ?? n?.isCustomElement ?? !1);
+  let d = !1;
+  for (const a in { ...u, ...m }) {
+    const E = u[a], v = m[a];
+    let b = E, h = v;
+    if (x(() => {
+      (M(E) || Ne(E)) && (b = E.value);
+    }), x(() => {
+      (M(v) || Ne(v)) && (h = v.value);
+    }), !(E === v && b === h))
+      if (d = !0, a === "value" && (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement)) {
+        const k = Ze(v), S = k == null ? "" : String(k);
+        e.value !== S && (e.value = S);
+      } else if (a === "checked" && e instanceof HTMLInputElement) {
+        const k = Ze(v);
+        e.checked = !!k;
+      } else if (a.startsWith("on") && typeof v == "function") {
+        const k = ht(a);
+        typeof E == "function" && ne.removeListener(e, k, E), typeof v == "function" && ne.addListener(e, k, v);
+        try {
+          if (k && k.startsWith("update:")) {
+            const S = k.split(":", 2)[1], L = m[S];
+            let y = [];
+            try {
+              if (M(L)) {
+                const l = L.value;
+                y = l && typeof l == "object" ? Object.keys(l) : [];
+              } else L && typeof L == "object" && (y = Object.keys(L));
+            } catch {
+              y = [];
+            }
+            const _ = y.filter(
+              (l) => typeof l == "string" && !l.startsWith("_") && l !== "constructor"
+            );
+            for (const l of _) {
+              const g = `update:${l}`, A = (N) => {
+                const O = N.detail !== void 0 ? N.detail : N.target instanceof HTMLInputElement || N.target instanceof HTMLTextAreaElement || N.target instanceof HTMLSelectElement ? N.target.value : void 0, D = { ...M(L) ? L.value || {} : m[S] || {}, [l]: O };
+                try {
+                  typeof v == "function" && v({
+                    detail: D
+                  });
+                } catch {
+                }
+              };
+              x(() => {
+                ne.addListener(e, g, A);
+              });
+            }
+          }
+        } catch {
+        }
+      } else if (v == null)
+        G(e, a);
+      else {
+        const k = t?.isCustomElement ?? n?.isCustomElement ?? !1;
+        if (k || a in e)
+          try {
+            e[a] = v, a === "disabled" && v === !1 && !k && Q(e) && G(e, "disabled");
+          } catch {
+          }
+        else
+          v === !1 && G(e, a);
+      }
+  }
+  for (const [a, E] of Object.entries(
+    o.listeners || {}
+  )) {
+    ne.addListener(e, a, E);
+    try {
+      const v = e && e.parentElement;
+      v && v !== e && ne.addListener(
+        v,
+        a,
+        E
+      );
+    } catch {
+    }
+  }
+  const C = { ...n.attrs ?? {} }, T = f, w = o && o.attrs || {};
+  if (Object.prototype.hasOwnProperty.call(w, "class") && typeof e.getAttribute == "function") {
+    const a = e.getAttribute("class");
+    a !== null && (C.class = a);
+  }
+  if (Object.prototype.hasOwnProperty.call(w, "style") && typeof e.getAttribute == "function") {
+    const a = e.getAttribute("style");
+    a !== null && (C.style = a);
+  }
+  try {
+    if (Object.prototype.hasOwnProperty.call(w, "class") && w.class === void 0 && typeof e.getAttribute == "function") {
+      const a = e.getAttribute("class");
+      a !== null && (C.class = a);
+    }
+    if (Object.prototype.hasOwnProperty.call(w, "style") && w.style === void 0 && typeof e.getAttribute == "function") {
+      const a = e.getAttribute("style");
+      a !== null && (C.style = a);
+    }
+    try {
+      if (typeof e.getAttribute == "function") {
+        const a = e.getAttribute("class");
+        try {
+          e instanceof HTMLInputElement && e.type === "text" && a !== null && a !== C.class && (C.class = a);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  } catch {
+  }
+  for (const a in { ...C, ...T }) {
+    const E = C[a], v = T[a];
+    let b = E, h = v;
+    if (M(E) && (b = E.value), M(v) && (h = v.value), b !== h)
+      if (d = !0, h == null || h === !1)
+        x(() => {
+          G(e, a);
+        }), oe(n, a, void 0), a === "value" && (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement ? x(() => {
+          e.value = "";
+        }) : e instanceof HTMLSelectElement ? x(() => {
+          e.value = "";
+        }) : e instanceof HTMLProgressElement && x(() => {
+          e.value = 0;
+        })), a === "checked" && e instanceof HTMLInputElement && x(() => {
+          e.checked = !1;
+        }), a === "disabled" && Q(e) && x(() => {
+          (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = !1);
+        });
+      else {
+        if (a === "value") {
+          if (e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement) {
+            x(() => {
+              e.value = h ?? "";
+            });
+            continue;
+          } else if (e instanceof HTMLSelectElement) {
+            x(() => {
+              e.value = h ?? "";
+            });
+            continue;
+          } else if (e instanceof HTMLProgressElement) {
+            x(() => {
+              e.value = Number(h);
+            });
+            continue;
+          }
+        }
+        if (a === "checked" && e instanceof HTMLInputElement) {
+          x(() => {
+            e.checked = !!h;
+          });
+          continue;
+        }
+        if (a === "style") {
+          const S = F(h);
+          S !== null && U(e, a, String(S)), oe(n, a, h);
+          continue;
+        }
+        if (a === "class") {
+          const S = F(h);
+          S !== null && U(e, a, String(S)), oe(n, a, h);
+          continue;
+        }
+        if (a === "disabled" && Q(e)) {
+          x(() => {
+            const S = pe(h);
+            (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = S);
+          }), pe(h) ? x(() => {
+            U(e, a, "");
+          }) : x(() => {
+            G(e, a);
+          });
+          continue;
+        }
+        const k = e.namespaceURI === "http://www.w3.org/2000/svg";
+        if (p && !k && a.includes("-"))
+          if (pt(a)) {
+            const S = F(v ?? h);
+            if (S !== null) {
+              try {
+                U(e, a, String(S));
+              } catch {
+              }
+              oe(n, a, h);
+            }
+          } else {
+            const S = Qe(a);
+            try {
+              const L = e;
+              L[S] = M(v) ? v : h, oe(n, a, h);
+            } catch {
+              const L = F(v ?? h);
+              L !== null && U(e, a, String(L));
+            }
+          }
+        else if (!k && a in e)
+          try {
+            const S = e;
+            S[a] = M(v) ? v : h, oe(n, a, h);
+          } catch {
+            const S = F(h);
+            S !== null && (U(e, a, String(S)), oe(n, a, h));
+          }
+        else {
+          const S = F(h);
+          S !== null && (U(e, a, String(S)), oe(n, a, h));
+        }
+      }
+  }
+  try {
+    if (Q(e)) {
+      const a = c.disabled;
+      let E;
+      try {
+        const b = Object.prototype.hasOwnProperty.call(
+          o.props || {},
+          "disabled"
+        ), h = a && typeof a == "object" && "value" in a;
+        let k = !1;
+        x(() => {
+          k = !!M(a);
+        });
+        const S = Je(a);
+        k || h || b || S ? E = a : E = f.disabled;
+      } catch {
+        E = f.disabled;
+      }
+      const v = pe(E);
+      x(() => {
+        (e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement || e instanceof HTMLButtonElement) && (e.disabled = v);
+      }), v ? x(() => {
+        U(e, "disabled", "");
+      }) : x(() => {
+        G(e, "disabled");
+      });
+    }
+  } catch {
+  }
+  if (p && d) {
+    const a = e;
+    x(() => {
+      a._applyProps?.(a._cfg);
+    }), x(() => {
+      typeof a.requestRender == "function" ? a.requestRender() : typeof a._render == "function" && a._render?.(a._cfg);
+    });
+  }
+}
+function J(e, n, t, s = null) {
+  if (typeof e == "string")
+    return document.createTextNode(e);
+  if (e.tag === "#text") {
+    const a = document.createTextNode(
+      typeof e.children == "string" ? e.children : ""
+    );
+    return e.key != null && Z(a, e.key), a;
+  }
+  if (e.tag === "#raw") {
+    const a = typeof e.children == "string" ? e.children : "";
+    return document.createRange().createContextualFragment(a);
+  }
+  if (e.tag === "#anchor") {
+    const a = e, E = Array.isArray(a.children) ? a.children : [], v = document.createTextNode(""), b = document.createTextNode("");
+    a.key != null && (Z(v, `${a.key}:start`), Z(b, `${a.key}:end`)), a._startNode = v, a._endNode = b;
+    const h = document.createDocumentFragment();
+    h.appendChild(v);
+    for (const k of E) {
+      const S = J(
+        k,
+        n,
+        t,
+        // propagate parent namespace (was previously a boolean)
+        s
+      );
+      if (a.key != null && S instanceof Element && !S.hasAttribute("data-anchor-key")) {
+        const L = k;
+        L && typeof L == "object" && L.key != null || Z(S, String(a.key));
+      }
+      h.appendChild(S);
+    }
+    return h.appendChild(b), h;
+  }
+  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 ?? Ct[e.tag] ?? null, c = o ? document.createElementNS(o, e.tag) : document.createElement(e.tag);
+  e.key != null && Z(c, e.key), e.props && e.props?._transitionGroup && Zt(
+    c,
+    e.props?._transitionGroup
+  );
+  const { props: f = {}, attrs: u = {}, directives: m = {} } = e.props ?? {}, p = yt(
+    m,
+    n,
+    c instanceof HTMLElement ? c : void 0,
+    u
+  ), d = {
+    ...f,
+    ...p.props
+  }, C = {
+    ...u,
+    ...p.attrs
+  };
+  try {
+    const a = (C && C.class) ?? (d && d.class) ?? (e.props && e.props.attrs && e.props.attrs.class) ?? (e.props && e.props.props && e.props.props.class), E = F(a);
+    if (E !== null) {
+      const v = String(E).trim();
+      v && U(c, "class", v);
+    }
+  } catch {
+  }
+  try {
+    if (d.disabled !== void 0 && c && Q(c)) {
+      const a = d.disabled, E = a && typeof a == "object" && "value" in a;
+      let v = !1;
+      try {
+        v = M(a);
+      } catch {
+        v = !1;
+      }
+      !E && !v && x(() => {
+        C.disabled = a, delete d.disabled;
+      });
+    }
+  } catch {
+  }
+  const T = c.namespaceURI === "http://www.w3.org/2000/svg";
+  for (const a in C) {
+    const E = C[a];
+    if (typeof a != "string" || /\[object Object\]/.test(a))
+      continue;
+    const v = Ze(E);
+    if (typeof v == "boolean")
+      v ? U(c, a, "") : x(() => {
+        G(c, a);
+      });
+    else if (v != null) {
+      if (a === "disabled" && Q(c)) {
+        const b = d.disabled, h = Je(b) ? b : v, k = pe(h);
+        x(() => {
+          c.disabled = k;
+        }), k ? x(() => {
+          U(c, a, "");
+        }) : x(() => {
+          G(c, a);
+        });
+        continue;
+      }
+      if (!T && a === "value" && (c instanceof HTMLInputElement || c instanceof HTMLTextAreaElement || c instanceof HTMLSelectElement || c instanceof HTMLProgressElement))
+        try {
+          c instanceof HTMLProgressElement ? c.value = Number(v) : c.value = String(v ?? "");
+        } catch {
+          const b = F(v);
+          b !== null && U(c, a, String(b));
+        }
+      else if (!T && a === "checked" && c instanceof HTMLInputElement)
+        try {
+          c.checked = !!v;
+        } catch {
+          const b = F(v);
+          b !== null && U(c, a, String(b));
+        }
+      else if (!T && a in c)
+        try {
+          c[a] = v, a === "disabled" && v === !1 && Q(c) && G(c, "disabled"), oe(e.props, a, v);
+        } catch {
+          const b = F(v);
+          b !== null && U(c, a, String(b));
+        }
+      else if ((e.props?.isCustomElement ?? !1) && !T && a.includes("-")) {
+        const h = Qe(a);
+        try {
+          c[h] = v;
+        } catch {
+          const k = F(v);
+          k !== null && U(c, a, String(k));
+        }
+      } else {
+        const h = F(v);
+        h !== null && U(c, a, String(h));
+      }
+    }
+  }
+  for (const a in d) {
+    const E = d[a];
+    if (!(typeof a != "string" || /\[object Object\]/.test(a)))
+      if (a === "value" && (c instanceof HTMLInputElement || c instanceof HTMLTextAreaElement || c instanceof HTMLSelectElement)) {
+        const v = typeof E == "object" && E !== null && Ne(E) ? E.value : E;
+        x(() => {
+          c.value = String(v ?? "");
+        });
+      } else if (a.startsWith("on") && typeof E == "function") {
+        const v = ht(a), b = v.includes(":") ? (() => {
+          const h = v.split(":"), k = h[1];
+          if (k.includes("-")) {
+            const S = k.split("-").map(
+              (L, y) => y === 0 ? L : L.charAt(0).toUpperCase() + L.slice(1)
+            ).join("");
+            return `${h[0]}:${S}`;
+          } else {
+            const S = k.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+            return `${h[0]}:${S}`;
+          }
+        })() : v;
+        p.listeners && (p.listeners[v] || p.listeners[b]) || ne.addListener(c, v, E);
+      } else {
+        if (a.startsWith("on") && E === void 0)
+          continue;
+        if (E == null || E === !1)
+          G(c, a);
+        else {
+          const v = e.props?.isCustomElement ?? !1, b = typeof E == "object" && E !== null && M(E) ? E : Ne(E) && typeof E.value < "u" ? E.value : E;
+          if (a === "class" || a === "style") {
+            try {
+              const h = F(b);
+              h !== null && U(c, a, String(h));
+            } catch {
+            }
+            continue;
+          }
+          if (v || a in c)
+            try {
+              const h = typeof E == "object" && E !== null && M(E) ? E : Ne(E) ? E.value : E;
+              if (a === "disabled" && Q(c)) {
+                const k = d.disabled !== void 0 ? d.disabled : h, S = pe(k);
+                x(() => {
+                  c.disabled = S;
+                }), S ? x(() => {
+                  U(c, a, "");
+                }) : x(() => {
+                  G(c, a);
+                });
+                continue;
+              }
+              try {
+                if (typeof c[a] == "boolean") {
+                  let S = h;
+                  typeof h == "string" ? h === "false" ? S = !1 : h === "true" ? S = !0 : S = !!h && h !== "" : S = !!h, c[a] = S;
+                } else
+                  c[a] = h;
+              } catch {
+                c[a] = h;
+              }
+            } catch {
+            }
+        }
+      }
+  }
+  for (const [a, E] of Object.entries(
+    p.listeners || {}
+  ))
+    ne.addListener(c, a, E);
+  const w = {
+    ...e,
+    props: {
+      ...e.props,
+      ...p.props
+    }
+  };
+  Te(w, c, t);
+  try {
+    const a = c;
+    if (typeof a._applyProps == "function")
+      try {
+        a._applyProps(a._cfg);
+      } catch {
+      }
+    typeof a.requestRender == "function" ? a.requestRender() : typeof a._render == "function" && a._render(a._cfg);
+  } catch {
+  }
+  if (Array.isArray(e.children)) {
+    const a = e.tag === "foreignObject" && o === kt ? null : c.namespaceURI ?? null;
+    for (const E of e.children)
+      c.appendChild(J(E, n, t, a));
+  } else typeof e.children == "string" && (c.textContent = e.children);
+  try {
+    if (c instanceof HTMLSelectElement && C && Object.prototype.hasOwnProperty.call(C, "value"))
+      try {
+        c.value = String(C.value ?? "");
+      } catch {
+      }
+  } catch {
+  }
+  try {
+    if (Q(c)) {
+      const a = d.disabled, E = C.disabled, v = a && typeof a == "object" && "value" in a;
+      let b = !1;
+      try {
+        b = !!M(a);
+      } catch {
+        b = !1;
+      }
+      const k = b || v || Je(a) ? a : E, S = pe(k);
+      x(() => {
+        c.disabled = S;
+      }), S ? x(() => {
+        U(c, "disabled", "");
+      }) : x(() => {
+        G(c, "disabled");
+      });
+    }
+  } catch {
+  }
+  return c;
+}
+function Jt(e, n, t, s, r) {
+  if (typeof t == "string") {
+    e.textContent !== t && (e.textContent = t);
+    return;
+  }
+  if (!Array.isArray(t)) return;
+  const i = e.childNodes, o = [];
+  for (let w = 0; w < i.length; w++)
+    o.push(i[w]);
+  const c = Array.isArray(n) ? n : [], f = Gt(e);
+  if (f) {
+    const w = (b) => {
+      if (typeof b == "string")
+        return b.startsWith("each-") ? b.substring(5) : b;
+      if (typeof b == "number") return String(b);
+    }, a = [], E = [];
+    for (const b of t)
+      if (b && b.tag === "#anchor") {
+        const h = Array.isArray(b.children) ? b.children : [];
+        for (const k of h) {
+          const S = w(
+            k.key ?? b.key ?? "unknown"
+          );
+          a.push({ ...k, key: S });
+        }
+      } else b && a.push({ ...b, key: w(b.key) });
+    for (const b of c)
+      if (b && b.tag === "#anchor") {
+        const h = Array.isArray(b.children) ? b.children : [];
+        for (const k of h) {
+          const S = w(
+            k.key ?? b.key ?? "unknown"
+          );
+          E.push({ ...k, key: S });
+        }
+      } else b && E.push({
+        ...b,
+        key: w(b.key)
+      });
+    if (a.some((b) => b && b.key != null) || E.some((b) => b && b.key != null)) {
+      const b = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map();
+      for (const l of E)
+        if (l && l.key != null) {
+          const g = String(l.key);
+          b.set(g, l);
+        }
+      for (let l = 0; l < o.length; l++) {
+        const g = o[l];
+        let A = De(g);
+        if (A = w(A), A != null && g instanceof Element && g.nodeType === Node.ELEMENT_NODE) {
+          let N = typeof A == "string" && A.includes(":") ? A.substring(0, A.lastIndexOf(":")) : A;
+          N = String(N), h.set(N, g);
+        }
+      }
+      const k = /* @__PURE__ */ new Set(), S = /* @__PURE__ */ new Map(), L = o.length > 0;
+      if (f.moveClass && L)
+        for (let l = 0; l < o.length; l++) {
+          const g = o[l];
+          if (g instanceof HTMLElement && g.parentElement) {
+            const A = g.getBoundingClientRect();
+            S.set(g, A);
+          }
+        }
+      const y = [];
+      for (const l of a) {
+        let g = l.key;
+        if (g == null) continue;
+        g = String(g);
+        const A = b.get(g);
+        let N = h.get(g);
+        if (N && A) {
+          const O = Le(N, A, l, s);
+          k.add(N);
+          const P = String(g);
+          Z(O, P), y.push({
+            node: O,
+            key: g,
+            newVNode: l,
+            oldVNode: A,
+            isNew: !1
+          });
+        } else {
+          N = J(
+            l,
+            s,
+            void 0,
+            e instanceof Element ? e.namespaceURI ?? null : null
+          ), Z(N, String(g)), e.appendChild(N);
+          const O = L || f.appear === !0;
+          N instanceof HTMLElement && O && we(N, f).catch((P) => {
+            B("Enter transition error:", P);
+          }), y.push({ node: N, key: g, newVNode: l, isNew: !0 });
+        }
+      }
+      const _ = [];
+      for (let l = 0; l < o.length; l++) {
+        const g = o[l], A = De(g);
+        if (!k.has(g) && A != null && g instanceof HTMLElement) {
+          const O = qe(g, f).then(() => {
+            e.contains(g) && e.removeChild(g);
+          }).catch((P) => {
+            B("Leave transition error:", P), e.contains(g) && e.removeChild(g);
+          });
+          _.push(O);
+        }
+      }
+      if (_.length === 0) {
+        let l = e.firstChild;
+        for (const { node: g } of y)
+          g !== l && e.insertBefore(g, l), l = g.nextSibling;
+        if (f.moveClass && S.size > 0) {
+          const g = [];
+          for (const { node: A, isNew: N } of y)
+            if (!N && A instanceof HTMLElement) {
+              const O = S.get(A);
+              if (O) {
+                const P = A.getBoundingClientRect(), D = O.left - P.left, j = O.top - P.top;
+                if (D !== 0 || j !== 0) {
+                  const z = f.moveClass.split(/\s+/).filter((I) => I);
+                  g.push({ node: A, deltaX: D, deltaY: j, moveClasses: z });
+                }
+              }
+            }
+          if (g.length > 0) {
+            for (const { node: A, deltaX: N, deltaY: O } of g)
+              A.style.transform = `translate(${N}px, ${O}px)`, A.style.transitionProperty = "none";
+            e.offsetHeight, requestAnimationFrame(() => {
+              requestAnimationFrame(() => {
+                for (const { node: A, moveClasses: N } of g)
+                  for (const O of N)
+                    A.classList.add(O);
+                requestAnimationFrame(() => {
+                  const A = f.moveClass || "", N = A.match(/duration-(\d+)/), O = N ? `${N[1]}ms` : "300ms", P = A.match(
+                    /ease-(out|in|in-out|linear)/
+                  ), D = P ? `ease-${P[1]}` : "ease-out";
+                  for (const { node: j } of g)
+                    j.style.transition = `transform ${O} ${D}`;
+                  requestAnimationFrame(() => {
+                    for (const { node: j, moveClasses: z } of g) {
+                      j.style.removeProperty("transform");
+                      const I = () => {
+                        for (const ie of z)
+                          j.classList.remove(ie);
+                        j.style.removeProperty("transition"), j.removeEventListener("transitionend", I), j.removeEventListener("transitioncancel", I);
+                      };
+                      j.addEventListener("transitionend", I, {
+                        once: !0
+                      }), j.addEventListener("transitioncancel", I, {
+                        once: !0
+                      });
+                    }
+                  });
+                });
+              });
+            });
+          }
+        }
+      }
+      return;
+    }
+  }
+  const u = /* @__PURE__ */ new Map();
+  for (const w of c)
+    w && w.key != null && u.set(w.key, w);
+  const m = /* @__PURE__ */ new Map();
+  for (let w = 0; w < o.length; w++) {
+    const a = o[w], E = De(a);
+    E != null && m.set(E, a);
+  }
+  const p = /* @__PURE__ */ new Set();
+  let d = e.firstChild;
+  function C(w, a) {
+    let E = w;
+    for (; E && (p.add(E), E !== a); )
+      E = E.nextSibling;
+  }
+  function T(w, a, E, v, b, h = !0) {
+    const k = [];
+    let S = w.nextSibling;
+    for (; S && S !== a; )
+      k.push(S), S = S.nextSibling;
+    const L = Array.isArray(E) ? E : [];
+    if (v.some((_) => _ && _.key != null) || L.some((_) => _ && _.key != null)) {
+      const _ = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+      for (const O of L)
+        O && O.key != null && _.set(O.key, O);
+      for (const O of k) {
+        const P = De(O);
+        P != null && l.set(P, O);
+      }
+      const g = b && b.state === "visible" && L.length === 0 && v.length > 0, A = /* @__PURE__ */ new Set();
+      let N = w.nextSibling;
+      for (const O of v) {
+        let P;
+        if (O.key != null && l.has(O.key)) {
+          const D = _.get(O.key);
+          P = Le(
+            l.get(O.key),
+            D,
+            O,
+            s
+          ), A.add(P), b && P instanceof HTMLElement && g && b.appear && we(P, b).catch((j) => {
+            B("Transition enter error (appear):", j);
+          }), P !== N && e.contains(P) && e.insertBefore(P, N);
+        } else
+          P = J(
+            O,
+            s,
+            void 0,
+            e instanceof Element ? e.namespaceURI ?? null : null
+          ), e.insertBefore(P, N), A.add(P), b && P instanceof HTMLElement && h && we(P, b).catch((D) => {
+            B("Transition enter error:", D);
+          });
+        N = P.nextSibling;
+      }
+      for (const O of k)
+        !A.has(O) && e.contains(O) && (b && O instanceof HTMLElement && h ? qe(O, b).then(() => {
+          e.contains(O) && e.removeChild(O);
+        }).catch((P) => {
+          B("Transition leave error:", P), e.contains(O) && e.removeChild(O);
+        }) : e.removeChild(O));
+    } else {
+      const _ = Math.min(
+        L.length,
+        v.length
+      );
+      for (let l = 0; l < _; l++) {
+        const g = L[l], A = v[l], N = Le(k[l], g, A, s);
+        N !== k[l] && (e.insertBefore(N, k[l]), e.removeChild(k[l]));
+      }
+      for (let l = _; l < v.length; l++) {
+        const g = J(
+          v[l],
+          s,
+          void 0,
+          e instanceof Element ? e.namespaceURI ?? null : null
+        );
+        e.insertBefore(g, a), b && g instanceof HTMLElement && h && we(g, b).catch((A) => {
+          B("Transition enter error:", A);
+        });
+      }
+      for (let l = _; l < k.length; l++) {
+        const g = k[l];
+        b && g instanceof HTMLElement && h ? qe(g, b).then(() => {
+          e.contains(g) && e.removeChild(g);
+        }).catch((A) => {
+          B("Transition leave error:", A), e.contains(g) && e.removeChild(g);
+        }) : e.removeChild(g);
+      }
+    }
+  }
+  for (const w of t) {
+    let a;
+    if (w.tag === "#anchor") {
+      const E = w.key, v = `${E}:start`, b = `${E}:end`;
+      let h = m.get(v), k = m.get(b);
+      const S = Array.isArray(w.children) ? w.children : [];
+      if (h || (h = document.createTextNode(""), Z(h, v)), k || (k = document.createTextNode(""), Z(k, b)), w._startNode = h, w._endNode = k, !e.contains(h) || !e.contains(k)) {
+        e.insertBefore(h, d);
+        const L = w._transition, _ = !(L && L.state === "visible" && S.length > 0) || L.appear;
+        for (const l of S) {
+          const g = J(
+            l,
+            s,
+            r,
+            e instanceof Element ? e.namespaceURI ?? null : null
+          );
+          e.insertBefore(g, d), L && g instanceof HTMLElement && _ && we(g, L).catch((A) => {
+            B("Transition enter error:", A);
+          });
+        }
+        e.insertBefore(k, d);
+      } else {
+        const L = w._transition, _ = u.get(E)._transition, l = _ && _.state !== L?.state, g = L && L.state === "visible" && S.length > 0 && !l, A = l || !g || L?.appear === !0;
+        T(
+          h,
+          k,
+          u.get(E)?.children,
+          S,
+          L,
+          A
+        );
+      }
+      C(h, k), d = k.nextSibling;
+      continue;
+    }
+    if (w.key != null && m.has(w.key)) {
+      const E = u.get(w.key);
+      a = Le(
+        m.get(w.key),
+        E,
+        w,
+        s,
+        r
+      ), p.add(a), a !== d && e.contains(a) && (d && !e.contains(d) && (d = null), e.insertBefore(a, d));
+    } else
+      a = J(
+        w,
+        s,
+        r,
+        e instanceof Element ? e.namespaceURI ?? null : null
+      ), d && !e.contains(d) && (d = null), e.insertBefore(a, d), p.add(a);
+    d = a.nextSibling;
+  }
+  for (let w = 0; w < o.length; w++) {
+    const a = o[w];
+    !p.has(a) && e.contains(a) && (de(a, r), e.removeChild(a));
+  }
+}
+function Le(e, n, t, s, r) {
+  if (n && typeof n != "string" && n.props?.ref && r && de(e, r), n === t) return e;
+  if (typeof t == "string") {
+    if (e.nodeType === Node.TEXT_NODE)
+      return e.textContent !== t && (e.textContent = t), e;
+    {
+      const o = document.createTextNode(t);
+      return e.parentNode?.replaceChild(o, e), o;
+    }
+  }
+  if (t && typeof t != "string" && t.tag === "#anchor") {
+    const o = t, c = Array.isArray(o.children) ? o.children : [], f = o._startNode ?? document.createTextNode(""), u = o._endNode ?? document.createTextNode("");
+    o.key != null && (Z(f, `${o.key}:start`), Z(u, `${o.key}:end`)), o._startNode = f, o._endNode = u;
+    const m = document.createDocumentFragment();
+    m.appendChild(f);
+    for (const p of c) {
+      const d = J(
+        p,
+        s,
+        r,
+        e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null
+      );
+      m.appendChild(d);
+    }
+    return m.appendChild(u), e.parentNode?.replaceChild(m, e), f;
+  }
+  if (!t) {
+    de(e, r);
+    const o = document.createComment("removed");
+    return e.parentNode?.replaceChild(o, e), o;
+  }
+  if (!n || typeof n == "string") {
+    de(e, r);
+    const o = J(
+      t,
+      s,
+      r,
+      e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null
+    );
+    return Te(t, o, r), e.parentNode?.replaceChild(o, e), o;
+  }
+  if (t.tag === "#anchor") {
+    const o = Array.isArray(t.children) ? t.children : [], c = t._startNode ?? document.createTextNode(""), f = t._endNode ?? document.createTextNode("");
+    t.key != null && (Z(c, `${t.key}:start`), Z(f, `${t.key}:end`)), t._startNode = c, t._endNode = f;
+    const u = document.createDocumentFragment();
+    u.appendChild(c);
+    for (const m of o)
+      u.appendChild(
+        J(
+          m,
+          s,
+          r,
+          e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null
+        )
+      );
+    return u.appendChild(f), e.parentNode?.replaceChild(u, e), c;
+  }
+  if (typeof n != "string" && typeof t != "string" && n.tag === t.tag && n.key === t.key) {
+    const o = e;
+    return at(o, n.props || {}, t.props || {}, s), Jt(o, n.children, t.children, s, r), Te(t, o, r), o;
+  }
+  if (typeof n != "string" && typeof t != "string" && n.tag === t.tag && (n.tag && String(n.tag).includes("-") || t.props && t.props.isCustomElement || n.props && n.props.isCustomElement))
+    try {
+      const c = e;
+      return at(c, n.props || {}, t.props || {}, s), Te(t, c, r), c;
+    } catch {
+    }
+  de(e, r);
+  const i = J(
+    t,
+    s,
+    r,
+    e.parentNode instanceof Element ? e.parentNode.namespaceURI ?? null : null
+  );
+  return Te(t, i, r), e.parentNode?.replaceChild(i, e), i;
+}
+function Yt(e, n, t, s) {
+  let r;
+  Array.isArray(n) ? n.length === 1 ? (r = n[0], r && typeof r == "object" && r.key == null && (r = { ...r, key: "__root__" })) : r = { tag: "div", key: "__root__", children: n } : (r = n, 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 = Ye(r, String(r.key ?? "root"));
+  const i = e._prevVNode ?? null, o = e._prevDom ?? e.firstChild ?? null;
+  let c;
+  i && o ? typeof i != "string" && typeof r != "string" && i.tag === r.tag && i.key === r.key ? c = Le(o, i, r, t, s) : (c = J(
+    r,
+    t,
+    s,
+    e.host instanceof Element ? e.host.namespaceURI ?? null : null
+  ), e.replaceChild(c, o)) : (c = J(
+    r,
+    t,
+    s,
+    e.host instanceof Element ? e.host.namespaceURI ?? null : null
+  ), e.firstChild ? e.replaceChild(c, e.firstChild) : e.appendChild(c));
+  const f = [];
+  for (let m = 0; m < e.childNodes.length; m++) {
+    const p = e.childNodes[m];
+    p !== c && p.nodeName !== "STYLE" && (de(p, s), f.push(p));
+  }
+  f.forEach((m) => e.removeChild(m));
+  const u = 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._prevVNode = u, e._prevDom = c;
+}
+const Oe = [], lt = /* @__PURE__ */ new WeakMap(), Ee = /* @__PURE__ */ new WeakMap();
+function Xt(e, n) {
+  Ee.has(e) || Ee.set(e, /* @__PURE__ */ new Set()), Ee.get(e).add(n);
+}
+function Qt(e, n) {
+  const t = Ee.get(e);
+  t && (t.delete(n), t.size === 0 && Ee.delete(e));
+}
+function en(e, n, t, s, r, i, o, c) {
+  if (e) {
+    Oe.push(t);
+    try {
+      const f = n.render(t);
+      if (f instanceof Promise) {
+        i(!0), f.then((u) => {
+          i(!1), o(null), ft(e, u, t, s, r), c(e.innerHTML);
+        }).catch((u) => {
+          i(!1), o(u instanceof Error ? u : new Error(String(u)));
+        });
+        return;
+      }
+      ft(e, f, t, s, r), c(e.innerHTML);
+    } catch (f) {
+      o(f instanceof Error ? f : new Error(String(f)));
+    } finally {
+      Oe.pop();
+    }
+  }
+}
+function ft(e, n, t, s, r) {
+  if (e)
+    try {
+      Yt(
+        e,
+        Array.isArray(n) ? n : [n],
+        t,
+        s
+      ), r(e.innerHTML);
+    } catch (i) {
+      throw B("Error during VDOM rendering:", i), i;
+    }
+}
+function tn(e, n, t, s, r, i, o) {
+  i !== null && clearTimeout(i);
+  const u = Date.now() - n < 16, m = (() => {
+    try {
+      return typeof window < "u" && !!window.Cypress;
+    } catch {
+      return !1;
+    }
+  })(), p = (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV === "test" && !m;
+    } catch {
+      return !1;
+    }
+  })(), d = p || m;
+  if (u) {
+    const w = t + 1;
+    r(w);
+    const a = d ? 50 : 10, E = d ? 100 : 25, v = p ? 12 : 50;
+    if (w === a && !d)
+      V(
+        `⚠️ 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 (w === E && !d)
+      V(
+        `⚠️ 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 (w >= v) {
+      B(
+        `🛑 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`
+      ), o(null);
+      return;
+    }
+  } else
+    r(0);
+  let C = 0;
+  d || (t >= 40 ? C = 500 : t >= 25 ? C = 100 : t >= 15 && (C = 16));
+  const T = () => {
+    s(Date.now());
+    try {
+      e();
+    } catch (w) {
+      B("Error during render execution:", w);
+    } finally {
+      o(null);
+    }
+  };
+  if (C > 0) {
+    const w = setTimeout(T, C);
+    o(w);
+  } else d ? T() : (o({}), queueMicrotask(T));
+}
+function nn(e, n) {
+  let t = n;
+  try {
+    const s = Ee.get(e);
+    if (s?.size)
+      for (const r of s)
+        try {
+          const i = r.lastHtmlStringForJitCSS;
+          i?.trim() && (t += `
+` + i);
+        } catch {
+        }
+    else {
+      const r = e.querySelectorAll("*");
+      for (const i of r)
+        try {
+          const o = i.lastHtmlStringForJitCSS;
+          o?.trim() && (t += `
+` + o);
+        } catch {
+        }
+    }
+  } catch {
+  }
+  return t;
+}
+function ut(e) {
+  return "adoptedStyleSheets" in e && typeof CSSStyleSheet < "u" && "replaceSync" in CSSStyleSheet.prototype;
+}
+function dt(e, n) {
+  let t = e.querySelector(
+    "style[data-cer-runtime]"
+  );
+  t || (t = document.createElement("style"), U(t, "data-cer-runtime", "true"), e.appendChild(t));
+  try {
+    t.textContent = n;
+  } catch {
+  }
+}
+function rn(e, n, t, s, r) {
+  if (!e) return;
+  const i = nn(e, t);
+  if (lt.get(e) === i)
+    return;
+  lt.set(e, i);
+  const c = wt(i), f = Tt(), u = n._computedStyle;
+  if (!c?.trim() && !u && !f) {
+    if (r(null), ut(e))
+      e.adoptedStyleSheets = [
+        He(),
+        ye()
+      ];
+    else {
+      const E = Ae(ot), v = ye();
+      let b = "";
+      try {
+        v?.cssRules && (b = Array.from(v.cssRules).map((k) => k.cssText).join(`
+`));
+      } catch {
+        b = "";
+      }
+      const h = Ae(`${E}
+${b}`);
+      dt(e, h);
+      try {
+        e.adoptedStyleSheets = [He(), ye()];
+      } catch {
+      }
+    }
+    return;
+  }
+  let m = "";
+  if (u && (m += u + `
+`), c && (m += c + `
+`), m = Lt(m), m = Ae(m), ut(e)) {
+    let a = s;
+    a || (a = new CSSStyleSheet());
+    try {
+      a.replaceSync(m);
+      const E = [He(), ye()];
+      f && E.push(f), E.push(a), e.adoptedStyleSheets = E, r(a);
+      return;
+    } catch {
+    }
+  }
+  const d = Ae(ot), C = ye();
+  let T = "";
+  try {
+    C?.cssRules && (T = Array.from(C.cssRules).map((a) => a.cssText).join(`
+`));
+  } catch {
+    T = "";
+  }
+  const w = Ae(`${d}
+${T}
+${m}`);
+  dt(e, w);
+  try {
+    const a = [
+      He(),
+      ye()
+    ];
+    if (f && a.push(f), typeof CSSStyleSheet < "u")
+      try {
+        const E = new CSSStyleSheet();
+        E.replaceSync(m), a.push(E);
+      } catch {
+        a.push({
+          cssRules: [],
+          replaceSync: () => {
+          }
+        });
+      }
+    e.adoptedStyleSheets = a;
+  } catch {
+  }
+  r(null);
+}
+function sn(e, n) {
+  if (!n.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();
+    /** @internal */
+    _renderTimeoutId = null;
+    _mounted = !1;
+    _hasError = !1;
+    _initializing = !0;
+    _componentId;
+    _styleSheet = null;
+    _lastHtmlStringForJitCSS = "";
+    /**
+     * Returns the last rendered HTML string for JIT CSS.
+     */
+    get lastHtmlStringForJitCSS() {
+      return this._lastHtmlStringForJitCSS;
+    }
+    /**
+     * Returns true if the component is currently loading.
+     */
+    get isLoading() {
+      return this._templateLoading;
+    }
+    /**
+     * Returns the last error thrown during rendering, or null if none.
+     */
+    get lastError() {
+      return this._templateError;
+    }
+    _cfg;
+    _lastRenderTime = 0;
+    _renderCount = 0;
+    _templateLoading = !1;
+    _templateError = null;
+    constructor() {
+      super(), this.attachShadow({ mode: "open" }), this._cfg = ge.get(e) || n, this._componentId = `${e}-${crypto.randomUUID()}`;
+      const t = this._initContext(n), s = (i, o, c) => {
+        Object.defineProperty(i, o, {
+          value: c,
+          writable: !1,
+          enumerable: !1,
+          configurable: !1
+        });
+      };
+      s(t, "refs", this._refs), s(
+        t,
+        "requestRender",
+        () => this.requestRender()
+      ), s(
+        t,
+        "_requestRender",
+        () => this._requestRender()
+      ), s(t, "_componentId", this._componentId), s(
+        t,
+        "_triggerWatchers",
+        (i, o) => this._triggerWatchers(i, o)
+      ), this.context = t, x(() => {
+        s(t, "_host", this);
+      }), s(
+        this.context,
+        "emit",
+        (i, o, c) => {
+          const f = {
+            detail: o,
+            bubbles: !0,
+            composed: !0,
+            ...c || {}
+          }, u = new CustomEvent(i, f);
+          this.dispatchEvent(u);
+          const m = i.indexOf(":");
+          if (m > 0) {
+            const p = i.substring(0, m), d = i.substring(m + 1), C = d.includes("-") ? `${p}:${d.split("-").map(
+              (T, w) => w === 0 ? T : T.charAt(0).toUpperCase() + T.slice(1)
+            ).join("")}` : `${p}:${d.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`;
+            C !== i && x(() => {
+              this.dispatchEvent(new CustomEvent(C, f));
+            });
+          }
+          return !u.defaultPrevented;
+        }
+      );
+      const r = ge.get(e) || n;
+      for (const i in r) {
+        const o = r[i];
+        typeof o == "function" && (this.context[i] = (...c) => o(...c, this.context));
+      }
+      if (r.props)
+        for (const i in r.props) {
+          let o = this[i];
+          Object.defineProperty(this, i, {
+            get() {
+              return o;
+            },
+            set(c) {
+              const f = o;
+              o = c, this.context[i] = c, this._initializing || (this._applyProps(r), f !== c && this._requestRender());
+            },
+            enumerable: !0,
+            configurable: !0
+          });
+        }
+      this._initializing = !1, this._initWatchers(r), this._applyProps(r), this._render(r);
+    }
+    connectedCallback() {
+      this._runLogicWithinErrorBoundary(n, () => {
+        const t = this.getRootNode();
+        t && t !== document && "host" in t && Xt(t, this), this._applyProps(n), this._requestRender(), $t(n, this.context, this._mounted, (s) => {
+          this._mounted = s;
+        });
+      });
+    }
+    disconnectedCallback() {
+      this._runLogicWithinErrorBoundary(n, () => {
+        const t = this.getRootNode();
+        t && t !== document && "host" in t && Qt(t, this), xt(
+          n,
+          this.context,
+          this._listeners,
+          () => {
+            this._listeners = [];
+          },
+          () => {
+            this._watchers.clear();
+          },
+          (s) => {
+            this._templateLoading = s;
+          },
+          (s) => {
+            this._templateError = s;
+          },
+          (s) => {
+            this._mounted = s;
+          }
+        );
+      });
+    }
+    attributeChangedCallback(t, s, r) {
+      this._runLogicWithinErrorBoundary(n, () => {
+        this._applyProps(n), s !== r && this._requestRender(), Ht(n, t, s, r, this.context);
+      });
+    }
+    static get observedAttributes() {
+      return n.props ? Object.keys(n.props).map(Y) : [];
+    }
+    // --- Render ---
+    _render(t) {
+      this._runLogicWithinErrorBoundary(t, () => {
+        en(
+          this.shadowRoot,
+          t,
+          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(t, s)
+        );
+      });
+    }
+    requestRender() {
+      this._requestRender();
+    }
+    _requestRender() {
+      this._runLogicWithinErrorBoundary(this._cfg, () => {
+        _e(() => {
+          tn(
+            () => this._render(this._cfg),
+            this._lastRenderTime,
+            this._renderCount,
+            (t) => {
+              this._lastRenderTime = t;
+            },
+            (t) => {
+              this._renderCount = t;
+            },
+            this._renderTimeoutId,
+            (t) => {
+              this._renderTimeoutId = t;
+            }
+          );
+        }, this._componentId);
+      });
+    }
+    // --- Style ---
+    _applyStyle(t, s) {
+      this._runLogicWithinErrorBoundary(t, () => {
+        rn(
+          this.shadowRoot,
+          this.context,
+          s,
+          this._styleSheet,
+          (r) => {
+            this._styleSheet = r;
+          }
+        );
+      });
+    }
+    // --- Error Boundary function ---
+    _runLogicWithinErrorBoundary(t, s) {
+      this._hasError && (this._hasError = !1);
+      try {
+        s();
+      } catch (r) {
+        this._hasError = !0;
+        try {
+          const i = this.tagName?.toLowerCase?.() || "<unknown>", o = this._componentId || "<unknown-id>", c = {};
+          if (t && t.props)
+            for (const f of Object.keys(t.props))
+              try {
+                const u = this.context[f];
+                u instanceof Node ? c[f] = `[DOM Node: ${u.nodeName}]` : typeof u == "object" && u !== null ? c[f] = Object.keys(u).length > 5 ? `[object(${Object.keys(u).length} keys)]` : u : c[f] = u;
+              } catch {
+                c[f] = "[unreadable]";
+              }
+          B(`Error rendering component <${i}> (id=${o}):`, r), B("Component props snapshot:", c), V(
+            "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 (t.onError && t.onError(r, this.context), this.tagName.toLowerCase() !== "cer-error-boundary") {
+          let i = this.parentElement;
+          if (!i) {
+            const o = this.getRootNode();
+            o instanceof ShadowRoot && (i = o.host.parentElement);
+          }
+          for (; i; ) {
+            if (i.tagName.toLowerCase() === "cer-error-boundary") {
+              i._cerHandleChildError?.(
+                r
+              );
+              break;
+            }
+            let o = i.parentElement;
+            if (!o) {
+              const c = i.getRootNode();
+              c instanceof ShadowRoot && (o = c.host.parentElement);
+            }
+            i = o;
+          }
+        }
+      }
+    }
+    // --- State, props, computed ---
+    _initContext(t) {
+      try {
+        let s = function(i, o = "") {
+          if (Array.isArray(i))
+            return new Proxy(i, {
+              get(c, f, u) {
+                const m = Reflect.get(c, f, u);
+                return typeof m == "function" && typeof f == "string" && [
+                  "push",
+                  "pop",
+                  "shift",
+                  "unshift",
+                  "splice",
+                  "sort",
+                  "reverse"
+                ].includes(f) ? function(...d) {
+                  const C = m.apply(c, d);
+                  if (!r._initializing) {
+                    const T = o || "root";
+                    r._triggerWatchers(T, c), _e(
+                      () => r._render(t),
+                      r._componentId
+                    );
+                  }
+                  return C;
+                } : m;
+              },
+              set(c, f, u) {
+                if (c[String(f)] = u, !r._initializing) {
+                  const m = o ? `${o}.${String(f)}` : String(f);
+                  r._triggerWatchers(m, u), _e(() => r._render(t), r._componentId);
+                }
+                return !0;
+              },
+              deleteProperty(c, f) {
+                if (delete c[String(f)], !r._initializing) {
+                  const u = o ? `${o}.${String(f)}` : String(f);
+                  r._triggerWatchers(u, void 0), _e(() => r._render(t), r._componentId);
+                }
+                return !0;
+              }
+            });
+          if (i && typeof i == "object") {
+            if (M(i))
+              return i;
+            for (const c in i) {
+              const f = o ? `${o}.${c}` : c;
+              i[c] = s(i[c], f);
+            }
+            return new Proxy(i, {
+              set(c, f, u) {
+                const m = o ? `${o}.${String(f)}` : String(f);
+                return c[String(f)] = s(u, m), r._initializing || (r._triggerWatchers(
+                  m,
+                  c[String(f)]
+                ), _e(() => r._render(t), r._componentId)), !0;
+              },
+              get(c, f, u) {
+                return Reflect.get(c, f, u);
+              }
+            });
+          }
+          return i;
+        };
+        const r = this;
+        return s({
+          // For functional components, state is managed by state() function calls
+          // Include prop defaults in initial reactive context so prop updates trigger reactivity
+          ...t.props ? Object.fromEntries(
+            Object.entries(t.props).map(([i, o]) => [
+              i,
+              o.default
+            ])
+          ) : {}
+        });
+      } catch {
+        return {};
+      }
+    }
+    _initWatchers(t) {
+      this._runLogicWithinErrorBoundary(t, () => {
+        Ot(
+          this.context,
+          this._watchers,
+          {}
+          // Watchers are now handled by the watch() function in functional API
+        );
+      });
+    }
+    _triggerWatchers(t, s) {
+      jt(this.context, this._watchers, t, s);
+    }
+    _applyProps(t) {
+      this._runLogicWithinErrorBoundary(t, () => {
+        Mt(this, t, this.context);
+      });
+    }
+  };
+}
+function mn() {
+  return ee();
+}
+let H = null;
+function Ue(e) {
+  H = e;
+}
+function Be() {
+  H = null;
+}
+function gn() {
+  return H;
+}
+function bn() {
+  if (!H)
+    throw new Error("useEmit must be called during component render");
+  if (ee())
+    return () => !1;
+  const e = H.emit;
+  if (typeof e != "function")
+    throw new Error(
+      "useEmit requires an emit function on the component context"
+    );
+  const n = e;
+  return (t, s, r) => n(t, s, r);
+}
+function he(e) {
+  e._hookCallbacks || Object.defineProperty(e, "_hookCallbacks", {
+    value: {},
+    writable: !0,
+    enumerable: !1,
+    configurable: !1
+  });
+}
+function vn(e) {
+  if (!H)
+    throw new Error("useOnConnected must be called during component render");
+  if (ee()) return;
+  he(H);
+  const n = H._hookCallbacks;
+  n.onConnected || (n.onConnected = []), n.onConnected.push(e);
+}
+function En(e) {
+  if (!H)
+    throw new Error("useOnDisconnected must be called during component render");
+  if (ee()) return;
+  he(H);
+  const n = H._hookCallbacks;
+  n.onDisconnected || (n.onDisconnected = []), n.onDisconnected.push(e);
+}
+function Sn(e) {
+  if (!H)
+    throw new Error(
+      "useOnAttributeChanged must be called during component render"
+    );
+  if (ee()) return;
+  he(H);
+  const n = H._hookCallbacks;
+  n.onAttributeChanged || (n.onAttributeChanged = []), n.onAttributeChanged.push(e);
+}
+function Cn(e) {
+  if (!H)
+    throw new Error("useOnError must be called during component render");
+  if (ee()) return;
+  he(H);
+  const n = H._hookCallbacks;
+  n.onError || (n.onError = []), n.onError.push((t) => {
+    try {
+      t instanceof Error ? e(t) : e(new Error(String(t)));
+    } catch {
+    }
+  });
+}
+function kn(e) {
+  if (!H)
+    throw new Error("useProps must be called during component render");
+  he(H);
+  const n = H._hookCallbacks;
+  n.props = {
+    ...n.props || {},
+    ...e
+  };
+  const t = H;
+  try {
+    const r = Object.keys(e || {});
+    for (const i of r) {
+      if (typeof i != "string" || i.startsWith("_")) continue;
+      const o = Object.getOwnPropertyDescriptor(t, i);
+      if (!(o && !o.configurable))
+        try {
+          let f = Object.prototype.hasOwnProperty.call(t, i) ? t[i] : void 0;
+          Object.defineProperty(t, i, {
+            configurable: !0,
+            enumerable: !0,
+            get() {
+              try {
+                const u = t && t._host;
+                if (u) {
+                  const m = Y(i), p = u.getAttribute(m);
+                  if (p !== null) {
+                    const d = typeof e[i];
+                    return d === "boolean" ? p === "" || p === "true" : d === "number" ? Number(p) : p;
+                  }
+                  if (typeof u[i] < "u") {
+                    const d = u[i];
+                    if (M(d) || d && typeof d == "object" && "value" in d && !(d instanceof Node))
+                      return d.value;
+                    const C = typeof e[i];
+                    if (!(C === "string" && d && typeof d == "object"))
+                      return C === "boolean" && typeof d == "string" ? d === "" || d === "true" : d;
+                  }
+                }
+              } catch {
+              }
+              return f;
+            },
+            set(u) {
+              f = u;
+            }
+          });
+        } catch {
+        }
+    }
+  } catch {
+  }
+  return new Proxy({}, {
+    get(r, i) {
+      if (typeof i != "string") return;
+      const o = e[i];
+      try {
+        const f = t && t._host;
+        if (f) {
+          if (f instanceof HTMLElement || typeof f.getAttribute == "function" && typeof f.hasAttribute == "function") {
+            const m = i.replace(/([A-Z])/g, "-$1").toLowerCase(), p = f.getAttribute(m);
+            if (p !== null)
+              return typeof o == "boolean" ? p === "" || p === "true" : typeof o == "number" ? Number(p) : p;
+          }
+          const u = f[i];
+          if (typeof u < "u" && u !== "") {
+            const m = u && typeof u == "object" && "value" in u && !(u instanceof Node);
+            if (!(typeof o == "string" && u && typeof u == "object" && !m && !M(u)))
+              return typeof o == "boolean" && o === !1 && u === "" ? o : M(u) || m ? u.value : typeof o == "boolean" && typeof u == "string" ? u === "true" || u !== "" && u !== "false" : typeof o == "number" && typeof u == "string" && !Number.isNaN(Number(u)) ? Number(u) : u;
+          }
+        }
+      } catch {
+      }
+      const c = t[i];
+      return typeof o == "boolean" && c === "" ? o === !1 ? o : !0 : M(c) || c && typeof c == "object" && "value" in c && !(c instanceof Node) ? c.value : c != null && c !== "" ? typeof o == "boolean" && typeof c == "string" ? c === "true" : typeof o == "number" && typeof c == "string" && !Number.isNaN(Number(c)) ? Number(c) : c : o;
+    },
+    has(r, i) {
+      return typeof i == "string" && (i in t || i in e);
+    },
+    ownKeys() {
+      return Array.from(
+        /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t || {})])
+      );
+    },
+    getOwnPropertyDescriptor() {
+      return { configurable: !0, enumerable: !0 };
+    }
+  });
+}
+function _n(e) {
+  if (!H)
+    throw new Error("useStyle must be called during component render");
+  if (!ee()) {
+    he(H);
+    try {
+      const n = e();
+      Object.defineProperty(H, "_computedStyle", {
+        value: n,
+        writable: !0,
+        enumerable: !1,
+        configurable: !0
+      });
+    } catch (n) {
+      V("Error in useStyle callback:", n), Object.defineProperty(H, "_computedStyle", {
+        value: "",
+        writable: !0,
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+  }
+}
+const je = /* @__PURE__ */ Symbol.for("@cer/provides");
+function An(e, n) {
+  if (!H)
+    throw new Error("provide must be called during component render");
+  if (ee()) return;
+  const t = H;
+  t[je] || Object.defineProperty(t, je, {
+    value: /* @__PURE__ */ new Map(),
+    writable: !1,
+    enumerable: !1,
+    configurable: !0
+  }), t[je].set(e, n);
+}
+function wn(e, n) {
+  if (!H)
+    throw new Error("inject must be called during component render");
+  if (ee()) return n;
+  try {
+    const t = H._host;
+    if (t) {
+      let s = t.parentNode;
+      for (s || (s = t.getRootNode()); s; )
+        if (s instanceof ShadowRoot) {
+          const r = s.host, i = r.context;
+          if (i) {
+            const c = i[je];
+            if (c?.has(e))
+              return c.get(e);
+          }
+          if (s = r.parentNode ?? r.getRootNode(), s === document || s === r) break;
+        } else {
+          if (s instanceof Element) {
+            const o = s.context;
+            if (o) {
+              const c = o[je];
+              if (c?.has(e))
+                return c.get(e);
+            }
+          }
+          const r = s;
+          if (s = s.parentNode ?? s.getRootNode?.(), s === document || s === r) break;
+        }
+    }
+  } catch {
+  }
+  return n;
+}
+function Tn(e) {
+  return (n) => {
+    const t = n ?? H;
+    if (!t)
+      throw new Error(
+        "createComposable: no component context available. Pass a context explicitly or call inside a render function."
+      );
+    const s = H;
+    Ue(t);
+    try {
+      return e();
+    } finally {
+      s ? Ue(s) : Be();
+    }
+  };
+}
+function Ln(e) {
+  if (!H)
+    throw new Error("useExpose must be called during component render");
+  if (ee()) return;
+  he(H);
+  const n = H._hookCallbacks;
+  n.expose = { ...n.expose ?? {}, ...e };
+  const t = H._host;
+  if (t)
+    for (const [s, r] of Object.entries(e))
+      try {
+        t[s] = r;
+      } catch {
+      }
+}
+function Nn() {
+  if (!H)
+    throw new Error("useSlots must be called during component render");
+  if (ee())
+    return { has: () => !1, getNodes: () => [], names: () => [] };
+  const e = H._host;
+  return {
+    /**
+     * Returns true if the named slot (or the default slot when name is
+     * omitted) has at least one slotted child element.
+     */
+    has(n) {
+      return e ? !n || n === "default" ? Array.from(e.children).some((t) => !t.hasAttribute("slot")) : Array.from(e.children).some(
+        (t) => t.getAttribute("slot") === n
+      ) : !1;
+    },
+    /**
+     * Returns all child elements assigned to the named slot (or the default
+     * slot when name is omitted).
+     */
+    getNodes(n) {
+      return e ? !n || n === "default" ? Array.from(e.children).filter(
+        (t) => !t.hasAttribute("slot")
+      ) : Array.from(e.children).filter(
+        (t) => t.getAttribute("slot") === n
+      ) : [];
+    },
+    /** Returns the names of all slots that have content, including 'default'. */
+    names() {
+      if (!e) return [];
+      const n = /* @__PURE__ */ new Set();
+      for (const t of Array.from(e.children)) {
+        const s = t.getAttribute("slot");
+        n.add(s ?? "default");
+      }
+      return Array.from(n);
+    }
+  };
+}
+function On(e, n) {
+  Nt();
+  let t = Y(e);
+  t.includes("-") || (t = `cer-${t}`);
+  const s = {}, r = {
+    // Props are accessed via useProps() hook
+    props: {},
+    // Add lifecycle hooks from the stored functions
+    onConnected: (i) => {
+      if (s.onConnected)
+        try {
+          s.onConnected(i);
+        } catch {
+        }
+    },
+    onDisconnected: (i) => {
+      if (s.onDisconnected)
+        try {
+          s.onDisconnected(i);
+        } catch {
+        }
+    },
+    onAttributeChanged: (i, o, c, f) => {
+      if (s.onAttributeChanged)
+        try {
+          s.onAttributeChanged(i, o, c, f);
+        } catch {
+        }
+    },
+    onError: (i, o) => {
+      if (s.onError && i)
+        try {
+          s.onError(i, o);
+        } catch {
+        }
+    },
+    render: (i) => {
+      const o = i, c = o._componentId || `${t}-${crypto.randomUUID()}`;
+      rt.setCurrentComponent(c, () => {
+        i.requestRender && i.requestRender();
+      });
+      try {
+        Object.defineProperty(i, "_hookCallbacks", {
+          value: {},
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }), Ue(i);
+        let f;
+        try {
+          f = n();
+        } catch (u) {
+          try {
+            const p = o._hookCallbacks?.onError;
+            if (Array.isArray(p))
+              for (const d of p)
+                try {
+                  d(u);
+                } catch {
+                }
+            else if (typeof p == "function")
+              try {
+                p(u);
+              } catch {
+              }
+          } catch {
+          }
+          try {
+            const m = o._host;
+            if (m?.parentElement) {
+              let p = m.parentElement;
+              for (; p; ) {
+                if (p.tagName.toLowerCase() === "cer-error-boundary") {
+                  p._cerHandleChildError?.(
+                    u
+                  );
+                  break;
+                }
+                let d = p.parentElement;
+                if (!d) {
+                  const C = p.getRootNode();
+                  C instanceof ShadowRoot && (d = C.host.parentElement);
+                }
+                p = d;
+              }
+            }
+          } catch {
+          }
+          throw u;
+        }
+        if (o._hookCallbacks) {
+          const u = o._hookCallbacks;
+          if (u.onConnected) {
+            const m = u.onConnected;
+            s.onConnected = (p) => {
+              for (const d of m)
+                try {
+                  d(p);
+                } catch {
+                }
+            };
+          }
+          if (u.onDisconnected) {
+            const m = u.onDisconnected;
+            s.onDisconnected = (p) => {
+              for (const d of m)
+                try {
+                  d(p);
+                } catch {
+                }
+            };
+          }
+          if (u.onAttributeChanged) {
+            const m = u.onAttributeChanged;
+            s.onAttributeChanged = (p, d, C, T) => {
+              for (const w of m)
+                try {
+                  w(p, d, C, T);
+                } catch {
+                }
+            };
+          }
+          if (u.onError) {
+            const m = u.onError;
+            s.onError = (p) => {
+              for (const d of m)
+                try {
+                  d(p);
+                } catch {
+                }
+            };
+          }
+          if (u.props) {
+            const m = u.props;
+            r.props = Object.fromEntries(
+              Object.entries(m).map(([p, d]) => [
+                p,
+                { type: typeof d == "boolean" ? Boolean : typeof d == "number" ? Number : typeof d == "string" ? String : Function, default: d }
+              ])
+            ), ge.set(t, r);
+          }
+        }
+        return f;
+      } finally {
+        Be(), rt.clearCurrentComponent();
+      }
+    }
+  };
+  if (ge.set(t, r), typeof window < "u") {
+    try {
+      const i = {
+        _hookCallbacks: {},
+        requestRender: () => {
+        },
+        emit: () => !0
+      };
+      Ue(i), _t();
+      try {
+        n();
+      } catch (o) {
+        try {
+          const f = i?._hookCallbacks?.onError;
+          if (Array.isArray(f))
+            for (const u of f)
+              try {
+                u(o);
+              } catch {
+              }
+          else if (typeof f == "function")
+            try {
+              f(o);
+            } catch {
+            }
+          B(
+            `Error during component discovery render <${t}>:`,
+            o
+          ), V(
+            "Error occurred during initial component discovery render. Consider guarding expensive expressions or using lazy factories for directives like when()."
+          );
+        } catch {
+        }
+        throw nt(), Be(), o;
+      }
+      if (nt(), Be(), i._hookCallbacks?.props) {
+        const o = i._hookCallbacks.props;
+        r.props = Object.fromEntries(
+          Object.entries(o).map(([c, f]) => [
+            c,
+            { type: typeof f == "boolean" ? Boolean : typeof f == "number" ? Number : typeof f == "string" ? String : Function, default: f }
+          ])
+        ), ge.set(t, r);
+      }
+    } catch {
+    }
+    customElements.get(t) || customElements.define(
+      t,
+      sn(t, r)
+    );
+  }
+}
+function ce(e, n = {}, t, s) {
+  const r = s ?? n.key;
+  return { tag: e, key: r, props: n, children: t };
+}
+function Pe(e) {
+  return !!e && typeof e == "object" && (e.type === "AnchorBlock" || e.tag === "#anchor");
+}
+function ue(e) {
+  return typeof e == "object" && e !== null && "tag" in e && !Pe(e);
+}
+function on(e, n) {
+  return e.key != null ? e : { ...e, key: n };
+}
+class cn {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  accessOrder = /* @__PURE__ */ new Map();
+  accessCounter = 0;
+  constructor(n) {
+    this.maxSize = Math.max(1, n);
+  }
+  get(n) {
+    const t = this.map.get(n);
+    if (t !== void 0)
+      return this.accessOrder.set(n, ++this.accessCounter), t;
+  }
+  set(n, t) {
+    const s = this.map.has(n);
+    this.map.set(n, t), this.accessOrder.set(n, ++this.accessCounter), !s && this.map.size > this.maxSize && this.evictLRU();
+  }
+  evictLRU() {
+    let n, t = 1 / 0;
+    for (const [s, r] of this.accessOrder)
+      r < t && (t = r, n = s);
+    n !== void 0 && (this.map.delete(n), this.accessOrder.delete(n));
+  }
+  has(n) {
+    return this.map.has(n);
+  }
+  clear() {
+    this.map.clear(), this.accessOrder.clear(), this.accessCounter = 0;
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+const an = () => {
+  if (typeof navigator < "u" && "deviceMemory" in navigator) {
+    const n = navigator.deviceMemory;
+    if (n)
+      return Math.min(1e3, Math.max(200, n * 100));
+  }
+  return (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV === "test";
+    } catch {
+      return !1;
+    }
+  })() ? 100 : 500;
+}, Ge = new cn(
+  an()
+);
+function ln(e, n) {
+  if (e == null) {
+    V(
+      `⚠️ Event handler for '@${n}' is ${e}. This will prevent the event from working. Use a function reference instead: @${n}="\${functionName}"`
+    );
+    return;
+  }
+  typeof e != "function" && V(
+    `🚨 Potential infinite loop detected! Event handler for '@${n}' appears to be the result of a function call (${typeof e}) instead of a function reference. Change @${n}="\${functionName()}" to @${n}="\${functionName}" to pass the function reference instead of calling it immediately.`
+  ), e === void 0 && typeof e != "function" && V(
+    `💡 Tip: If your event handler function returns undefined, make sure you're passing the function reference, not calling it. Use @${n}="\${fn}" not @${n}="\${fn()}"`
+  );
+}
+function fn(e, n = [], t = {}) {
+  const s = {}, r = {}, i = {}, o = [], c = /([:@#]?)([a-zA-Z0-9-:.]+)(?:\s*=\s*("([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'|([^\s>]+)))?/g;
+  let f;
+  for (; f = c.exec(e); ) {
+    const u = f[1], m = f[2];
+    let p = "";
+    for (let a = 3; a < f.length; a++)
+      if (f[a] !== void 0) {
+        p = f[a];
+        break;
+      }
+    p.length >= 2 && (p[0] === '"' && p[p.length - 1] === '"' || p[0] === "'" && p[p.length - 1] === "'") && (p = p.slice(1, -1));
+    const d = !/=/.test(f[0]), C = p.match(/^{{(\d+)}}$/);
+    let T = d ? !0 : C ? n[Number(C[1])] ?? null : p;
+    C || (T === "true" ? T = !0 : T === "false" ? T = !1 : T === "null" ? T = null : isNaN(Number(T)) || (T = Number(T)));
+    const w = [
+      "model",
+      "bind",
+      "show",
+      "class",
+      "style",
+      "ref",
+      "when"
+    ];
+    if (u === ":") {
+      const [a, E] = m.split(":"), [v, ...b] = a.split(".");
+      if (w.includes(v)) {
+        const h = [...b], k = v === "model" && E ? `model:${E}` : v;
+        i[k] = {
+          value: T,
+          modifiers: h,
+          arg: E
+        };
+      } else if (m === "disabled") {
+        let h = T;
+        h && M(h) && (h = h.value);
+        const k = typeof h;
+        if (h === "" || k === "boolean" || k === "string" && (h === "true" || h === "false") || h == null || k === "number")
+          s[m] = h;
+        else {
+          let y = T;
+          y && M(y) && (y = y.value), r[m] = y;
+        }
+        o.push(m);
+      } else {
+        let h = T;
+        h && M(h) && (h = h.value), r[m] = h, o.push(m);
+      }
+    } else if (u === "@") {
+      const [a, ...E] = m.split("."), v = E;
+      ln(T, a);
+      const b = typeof T == "function" ? T : typeof t[T] == "function" ? t[T] : void 0;
+      if (b) {
+        const h = (S) => {
+          if (v.includes("prevent") && S.preventDefault(), v.includes("stop") && S.stopPropagation(), !(v.includes("self") && S.target !== S.currentTarget))
+            return v.includes("once") && S.currentTarget?.removeEventListener(
+              a,
+              h
+            ), b(S);
+        }, k = "on" + a.charAt(0).toUpperCase() + a.slice(1);
+        s[k] = h;
+      }
+    } else m === "ref" ? s.ref = T : r[m] = T;
+  }
+  return { props: s, attrs: r, directives: i, bound: o };
+}
+function Xe(e) {
+  if (!ue(e) || Pe(e))
+    return e;
+  const n = e.props?.directives;
+  if (n && n.when) {
+    const t = n.when.value, s = M(t) ? t.value : t, r = { ...n };
+    delete r.when;
+    const i = { ...e.props };
+    Object.keys(r).length > 0 ? i.directives = r : delete i.directives;
+    const o = {
+      ...e,
+      props: i
+    };
+    return Array.isArray(o.children) && (o.children = o.children.map(
+      (f) => typeof f == "object" && f !== null ? Xe(f) : f
+    )), {
+      tag: "#anchor",
+      key: e.key != null ? `when-${e.key}` : `when-${e.tag}`,
+      children: s ? [o] : []
+    };
+  }
+  if (Array.isArray(e.children)) {
+    const t = e.children.map(
+      (s) => typeof s == "object" && s !== null ? Xe(s) : s
+    );
+    return {
+      ...e,
+      children: t
+    };
+  }
+  return e;
+}
+function un(e, n, t) {
+  const s = Oe.length > 0 ? Oe[Oe.length - 1] : void 0, r = t ?? s, i = !t && n.length === 0, o = i ? e.join("<!--TEMPLATE_DELIM-->") : null;
+  if (i && o) {
+    const l = Ge.get(o);
+    if (l) return l;
+  }
+  function c(l, g) {
+    return ce("#text", {}, l, g);
+  }
+  function f(l, g, A = !1) {
+    let N = typeof l == "string" ? At(l) : l;
+    return !A && typeof N == "string" && /[\r\n]/.test(N) && (N = N.replace(/\s+/g, " ")), ce("#text", {}, N, g);
+  }
+  let u = "";
+  for (let l = 0; l < e.length; l++)
+    u += e[l], l < n.length && (u += `{{${l}}}`);
+  const m = /<!--[\s\S]*?-->|<\/?([a-zA-Z0-9-]+)((?:\s+[^\s=>/]+(?:\s*=\s*(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s>]+))?)*)\s*\/?>|{{(\d+)}}|([^<]+)/g, p = [];
+  let d, C = [], T = null, w = {}, a, E = 0;
+  const v = [], b = /* @__PURE__ */ new Set([
+    "pre",
+    "code",
+    "textarea",
+    "script",
+    "style"
+  ]);
+  function h() {
+    if (T && b.has(T.toLowerCase()))
+      return !0;
+    for (const l of p)
+      if (b.has(l.tag.toLowerCase()))
+        return !0;
+    return !1;
+  }
+  function k(l) {
+    if (!l || typeof l != "object" || Pe(l)) return;
+    const g = l, A = w;
+    if (g.props || g.attrs) {
+      const N = g;
+      N.props && (A.props || (A.props = {}), Object.assign(A.props, N.props)), N.attrs && (A.attrs || (A.attrs = {}), Object.keys(N.attrs).forEach((O) => {
+        if (O === "style" && A.attrs.style) {
+          const P = String(A.attrs.style).replace(/;?\s*$/, ""), D = String(N.attrs.style).replace(/^;?\s*/, "");
+          A.attrs.style = P + "; " + D;
+        } else if (O === "class" && A.attrs.class) {
+          const P = String(A.attrs.class).trim().split(/\s+/).filter(Boolean), D = String(N.attrs.class).trim().split(/\s+/).filter(Boolean), j = [
+            .../* @__PURE__ */ new Set([...P, ...D])
+          ];
+          A.attrs.class = j.join(" ");
+        } else
+          A.attrs[O] = N.attrs[O];
+      }));
+    } else
+      A.props || (A.props = {}), Object.assign(A.props, g);
+  }
+  function S(l, g) {
+    const A = T ? C : v;
+    if (Pe(l)) {
+      const N = l.key ?? g, O = l.children;
+      A.push({
+        ...l,
+        key: N,
+        children: O
+      });
+      return;
+    }
+    if (ue(l)) {
+      A.push(on(l, void 0));
+      return;
+    }
+    if (Array.isArray(l)) {
+      if (l.length === 0) return;
+      for (let N = 0; N < l.length; N++) {
+        const O = l[N];
+        Pe(O) || ue(O) || Array.isArray(O) ? S(O, `${g}-${N}`) : O !== null && typeof O == "object" ? st(O) ? A.push(
+          ce(
+            "#raw",
+            {},
+            O.__rawHTML,
+            `${g}-${N}`
+          )
+        ) : k(O) : A.push(c(String(O), `${g}-${N}`));
+      }
+      return;
+    }
+    if (l !== null && typeof l == "object") {
+      if (st(l)) {
+        const N = l.__rawHTML ?? "";
+        A.push(ce("#raw", {}, N, g));
+        return;
+      }
+      k(l);
+      return;
+    }
+    A.push(c(String(l), g));
+  }
+  const L = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  for (; d = m.exec(u); )
+    if (!(d[0].startsWith("<!--") && d[0].endsWith("-->"))) {
+      if (d[1]) {
+        const l = d[1], g = d[0][1] === "/", A = d[0][d[0].length - 2] === "/" || L.has(l), {
+          props: N,
+          attrs: O,
+          directives: P,
+          bound: D
+        } = fn(
+          d[2] || "",
+          n,
+          r ?? {}
+        ), j = { props: {}, attrs: {} };
+        for (const z in N) j.props[z] = N[z];
+        for (const z in O) j.attrs[z] = O[z];
+        j.attrs && Object.prototype.hasOwnProperty.call(j.attrs, "key") && !(j.props && Object.prototype.hasOwnProperty.call(j.props, "key")) && x(() => {
+          j.props.key = j.attrs.key;
+        });
+        try {
+          const z = {
+            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"]
+          }, I = l.toLowerCase(), ie = z[I] ?? [];
+          if (j.attrs) {
+            for (const R of ie)
+              if (D && D.includes(R) && R in j.attrs && !(j.props && R in j.props)) {
+                let $ = j.attrs[R];
+                if ($ && M($))
+                  $ = $.value, j.props[R] = $, delete j.attrs[R];
+                else if ($ && typeof $ == "object" && "value" in $ && !($ instanceof Node))
+                  try {
+                    const W = $.value;
+                    j.props[R] = (I === "select" || I === "option") && R === "value" ? String(W) : W, delete j.attrs[R];
+                  } catch {
+                  }
+                else {
+                  const W = typeof $;
+                  if (R === "disabled")
+                    ($ === "" || W === "boolean" || W === "string" && ($ === "true" || $ === "false") || $ == null || W === "number") && (j.props[R] = $, delete j.attrs[R]);
+                  else if ($ === "" || W === "string" || W === "number" || W === "boolean" || $ == null) {
+                    const te = (I === "select" || I === "option") && R === "value" ? String($) : $;
+                    j.props[R] = te, delete j.attrs[R];
+                  }
+                }
+              }
+          }
+          if (l.includes("-") || !!r?.__customElements?.has?.(l)) {
+            if (j.isCustomElement = !0, D && j.attrs) {
+              const R = /* @__PURE__ */ new Set(["id", "name", "data-key", "key"]);
+              for (const $ of D)
+                if ($ in j.attrs && !(j.props && $ in j.props)) {
+                  const W = $.includes("-") ? Qe($) : $, te = j.attrs[$];
+                  if (j.props[W] = te, R.has($) || pt($))
+                    try {
+                      const xe = F(j.attrs[$]);
+                      xe === null ? delete j.attrs[$] : j.attrs[$] = xe;
+                    } catch {
+                      delete j.attrs[$];
+                    }
+                  else
+                    delete j.attrs[$];
+                }
+            }
+            try {
+              if (j.attrs && !(j.props && "modelValue" in j.props)) {
+                const R = j.attrs["model-value"] ?? j.attrs.modelValue;
+                typeof R < "u" && (j.props.modelValue = R);
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        if (P && Object.keys(P).some(
+          (z) => z === "model" || z.startsWith("model:")
+        ))
+          try {
+            const I = globalThis[/* @__PURE__ */ Symbol.for("cer.registry")], ie = !!(I && typeof I.has == "function" && I.has(l)), X = r, R = !!(X && (X.__customElements instanceof Set && X.__customElements.has(l) || Array.isArray(X.__isCustomElements) && X.__isCustomElements.includes(l)));
+            if (!!(l.includes("-") || R || ie))
+              for (const te of Object.keys(P)) {
+                if (te !== "model" && !te.startsWith("model:")) continue;
+                const $e = P[te], xe = $e.arg ?? (te.includes(":") ? te.split(":", 2)[1] : void 0), q = $e.value, ze = xe ?? "modelValue", et = K, vt = We, Se = r?._state || r;
+                let se;
+                typeof q == "string" && Se ? se = et(
+                  Se,
+                  q
+                ) : se = q, j.props[ze] = se;
+                try {
+                  const ae = Y(ze);
+                  j.attrs || (j.attrs = {}), se != null && (typeof se == "string" || typeof se == "number" || typeof se == "boolean") && (j.attrs[ae] = se);
+                } catch {
+                }
+                j.isCustomElement = !0;
+                const tt = `update:${Y(ze)}`.replace(
+                  /-([a-z])/g,
+                  (ae, re) => re.toUpperCase()
+                ), Et = "on" + tt.charAt(0).toUpperCase() + tt.slice(1);
+                j.props[Et] = function(ae) {
+                  const re = ae.detail !== void 0 ? ae.detail : ae.target ? ae.target.value : void 0;
+                  if (Se)
+                    if (q && M(q)) {
+                      const le = q.value;
+                      if (Array.isArray(re) && Array.isArray(le) ? JSON.stringify([...re].sort()) !== JSON.stringify([...le].sort()) : re !== le) {
+                        q.value = re;
+                        try {
+                          const fe = r;
+                          if (fe) {
+                            const Ce = fe.requestRender, ke = fe._requestRender;
+                            typeof Ce == "function" ? Ce() : typeof ke == "function" && ke();
+                          }
+                        } catch {
+                        }
+                      }
+                    } else {
+                      const le = et(
+                        Se || {},
+                        typeof q == "string" ? q : String(q)
+                      );
+                      if (Array.isArray(re) && Array.isArray(le) ? JSON.stringify([...re].sort()) !== JSON.stringify([...le].sort()) : re !== le) {
+                        vt(
+                          Se || {},
+                          typeof q == "string" ? q : String(q),
+                          re
+                        );
+                        try {
+                          const fe = r;
+                          if (fe) {
+                            const Ce = fe.requestRender, ke = fe._requestRender;
+                            typeof Ce == "function" ? Ce() : typeof ke == "function" && ke();
+                          }
+                        } catch {
+                        }
+                      }
+                    }
+                }, delete P[te];
+              }
+          } catch {
+          }
+        if (Object.keys(P).length > 0 && (j.directives = { ...P }), g) {
+          const z = C.some(
+            (R) => typeof R == "object" && R.tag !== "#text"
+          );
+          let I = C;
+          if (z && C.length > 0) {
+            let R = 0;
+            for (; R < C.length; ) {
+              const W = C[R];
+              if (!ue(W) || W.tag !== "#text" || typeof W.children != "string" || W.children.trim() !== "")
+                break;
+              R++;
+            }
+            let $ = C.length - 1;
+            for (; $ >= 0; ) {
+              const W = C[$];
+              if (!ue(W) || W.tag !== "#text" || typeof W.children != "string" || W.children.trim() !== "")
+                break;
+              $--;
+            }
+            R === 0 && $ === C.length - 1 ? I = C : R > $ ? I = [] : I = C.slice(R, $ + 1);
+          }
+          const ie = ce(
+            T,
+            w,
+            I.length === 1 && ue(I[0]) && I[0].tag === "#text" ? typeof I[0].children == "string" ? I[0].children : "" : I.length ? I : void 0,
+            a
+          ), X = p.pop();
+          X ? (T = X.tag, w = X.props, a = X.key, C = X.children, C.push(ie)) : (v.push(ie), T = null, w = {}, a = void 0, C = []);
+        } else A ? T ? C.push(ce(l, j, void 0, void 0)) : v.push(ce(l, j, void 0, void 0)) : (T && p.push({
+          tag: T,
+          props: w,
+          children: C,
+          key: a
+        }), T = l, w = j, C = []);
+      } else if (typeof d[3] < "u") {
+        const l = Number(d[3]), g = n[l], A = `interp-${l}`;
+        S(g, A);
+      } else if (d[4]) {
+        const l = d[4], g = T ? C : v, A = l.split(/({{\d+}})/);
+        for (const N of A) {
+          if (!N) continue;
+          const O = N.match(/^{{(\d+)}}$/);
+          if (O) {
+            const P = Number(O[1]), D = n[P], j = `interp-${P}`;
+            S(D, j);
+          } else {
+            const P = `text-${E++}`, D = h();
+            g.push(f(N, P, D));
+          }
+        }
+      }
+    }
+  const _ = v.filter((l) => ue(l) && l.tag === "#text" ? typeof l.children == "string" && l.children.trim() !== "" : !0).map(
+    (l) => Xe(l)
+  );
+  if (_.length === 1) {
+    const l = _[0];
+    return i && o && Ge.set(o, l), l;
+  } else if (_.length > 1) {
+    const l = _;
+    return i && o && Ge.set(o, l), l;
+  }
+  return ce("div", {}, "", "fallback-root");
+}
+function jn(e, ...n) {
+  if (ee()) return [];
+  const t = n[n.length - 1], s = typeof t == "object" && t && !Array.isArray(t) ? t : void 0;
+  return un(e, n, s);
+}
+export {
+  Ln as a,
+  kn as b,
+  On as c,
+  Tn as d,
+  wn as e,
+  bn as f,
+  gn as g,
+  jn as h,
+  mn as i,
+  Sn as j,
+  vn as k,
+  En as l,
+  Nn as m,
+  _n as n,
+  An as p,
+  Cn as u,
+  Yt as v
+};
+//# sourceMappingURL=template-compiler-CJFwjLCP.js.map