@jasonshimmy/custom-elements-runtime 2.5.1 → 2.5.2

package/dist/template-compiler-DD_VZrte.js

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