@jasonshimmy/custom-elements-runtime 2.8.2 → 3.1.0

package/dist/template-compiler-DtpNsqE-.js

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