zabi-components 2.0.2 → 2.0.3

package/dist/props-ChfwWtCN.js

@@ -0,0 +1,2513 @@
+var _n = Object.defineProperty;
+var er = (e) => {
+  throw TypeError(e);
+};
+var dn = (e, t, r) => t in e ? _n(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var Le = (e, t, r) => dn(e, typeof t != "symbol" ? t + "" : t, r), Ot = (e, t, r) => t.has(e) || er("Cannot " + r);
+var O = (e, t, r) => (Ot(e, t, "read from private field"), r ? r.call(e) : t.get(e)), q = (e, t, r) => t.has(e) ? er("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), re = (e, t, r, n) => (Ot(e, t, "write to private field"), n ? n.call(e, r) : t.set(e, r), r), ne = (e, t, r) => (Ot(e, t, "access private method"), r);
+var hr;
+typeof window < "u" && ((hr = window.__svelte ?? (window.__svelte = {})).v ?? (hr.v = /* @__PURE__ */ new Set())).add("5");
+let Ge = !1, pn = !1;
+function hn() {
+  Ge = !0;
+}
+hn();
+const ct = 1, vt = 2, gr = 4, gn = 8, bn = 16, wn = 1, En = 2, yn = 4, mn = 8, An = 16, Sn = 1, Tn = 2, N = Symbol(), On = "http://www.w3.org/1999/xhtml", Bi = "http://www.w3.org/2000/svg", kn = "@attach", br = !1;
+var _t = Array.isArray, Nn = Array.prototype.indexOf, wr = Array.from, nt = Object.defineProperty, ye = Object.getOwnPropertyDescriptor, Er = Object.getOwnPropertyDescriptors, Pn = Object.prototype, In = Array.prototype, Ut = Object.getPrototypeOf;
+function De(e) {
+  return typeof e == "function";
+}
+const it = () => {
+};
+function Cn(e) {
+  return e();
+}
+function Rt(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function yr() {
+  var e, t, r = new Promise((n, i) => {
+    e = n, t = i;
+  });
+  return { promise: r, resolve: e, reject: t };
+}
+function Hi(e, t) {
+  if (Array.isArray(e))
+    return e;
+  if (!(Symbol.iterator in e))
+    return Array.from(e);
+  const r = [];
+  for (const n of e)
+    if (r.push(n), r.length === t) break;
+  return r;
+}
+const D = 2, xt = 4, dt = 8, pe = 16, J = 32, Re = 64, mr = 128, x = 256, ft = 512, I = 1024, j = 2048, Q = 4096, B = 8192, he = 16384, $t = 32768, Vt = 65536, tr = 1 << 17, Rn = 1 << 18, pt = 1 << 19, Ar = 1 << 20, Mt = 1 << 21, ht = 1 << 22, ve = 1 << 23, X = Symbol("$state"), Sr = Symbol("legacy props"), Mn = Symbol(""), qe = new class extends Error {
+  constructor() {
+    super(...arguments);
+    Le(this, "name", "StaleReactionError");
+    Le(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}();
+function Ln() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Dn(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Fn() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function jn(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function qn() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Un(e) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function xn() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function $n() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Vn() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Bn() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+let Hn = !1;
+function Tr(e) {
+  return e === this.v;
+}
+function Yn(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function Or(e) {
+  return !Yn(e, this.v);
+}
+let P = null;
+function ut(e) {
+  P = e;
+}
+function Wi(e, t = !1, r) {
+  P = {
+    p: P,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: Ge && !t ? { s: null, u: null, $: [] } : null
+  };
+}
+function Gi(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    P
+  ), r = t.e;
+  if (r !== null) {
+    t.e = null;
+    for (var n of r)
+      Ur(n);
+  }
+  return P = t.p, /** @type {T} */
+  {};
+}
+function Ke() {
+  return !Ge || P !== null && P.l === null;
+}
+let oe = [];
+function kr() {
+  var e = oe;
+  oe = [], Rt(e);
+}
+function gt(e) {
+  if (oe.length === 0 && !Ue) {
+    var t = oe;
+    queueMicrotask(() => {
+      t === oe && kr();
+    });
+  }
+  oe.push(e);
+}
+function Wn() {
+  for (; oe.length > 0; )
+    kr();
+}
+const Gn = /* @__PURE__ */ new WeakMap();
+function Kn(e) {
+  var t = S;
+  if (t === null)
+    return A.f |= ve, e;
+  if ((t.f & $t) === 0) {
+    if ((t.f & mr) === 0)
+      throw !t.parent && e instanceof Error && Nr(e), e;
+    t.b.error(e);
+  } else
+    lt(e, t);
+}
+function lt(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & mr) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (r) {
+        e = r;
+      }
+    t = t.parent;
+  }
+  throw e instanceof Error && Nr(e), e;
+}
+function Nr(e) {
+  const t = Gn.get(e);
+  t && (nt(e, "message", {
+    value: t.message
+  }), nt(e, "stack", {
+    value: t.stack
+  }));
+}
+const et = /* @__PURE__ */ new Set();
+let k = null, kt = null, rr = /* @__PURE__ */ new Set(), Y = [], bt = null, Lt = !1, Ue = !1;
+var Ae, Se, ue, He, Te, Oe, ce, ke, Ye, We, $, Dt, rt, Ft;
+const Ee = class Ee {
+  constructor() {
+    q(this, $);
+    /**
+     * The current values of any sources that are updated in this batch
+     * They keys of this map are identical to `this.#previous`
+     * @type {Map<Source, any>}
+     */
+    Le(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any sources that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Source, any>}
+     */
+    q(this, Ae, /* @__PURE__ */ new Map());
+    /**
+     * When the batch is committed (and the DOM is updated), we need to remove old branches
+     * and append new ones by calling the functions added inside (if/each/key/etc) blocks
+     * @type {Set<() => void>}
+     */
+    q(this, Se, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    q(this, ue, 0);
+    /**
+     * A deferred that resolves when the batch is committed, used with `settled()`
+     * TODO replace with Promise.withResolvers once supported widely enough
+     * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
+     */
+    q(this, He, null);
+    /**
+     * Async effects inside a newly-created `<svelte:boundary>`
+     * — these do not prevent the batch from committing
+     * @type {Effect[]}
+     */
+    q(this, Te, []);
+    /**
+     * Template effects and `$effect.pre` effects, which run when
+     * a batch is committed
+     * @type {Effect[]}
+     */
+    q(this, Oe, []);
+    /**
+     * The same as `#render_effects`, but for `$effect` (which runs after)
+     * @type {Effect[]}
+     */
+    q(this, ce, []);
+    /**
+     * Block effects, which may need to re-run on subsequent flushes
+     * in order to update internal sources (e.g. each block items)
+     * @type {Effect[]}
+     */
+    q(this, ke, []);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Effect[]}
+     */
+    q(this, Ye, []);
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Effect[]}
+     */
+    q(this, We, []);
+    /**
+     * A set of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`
+     * @type {Set<Effect>}
+     */
+    Le(this, "skipped_effects", /* @__PURE__ */ new Set());
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    var f;
+    Y = [], kt = null;
+    var r = Ee.apply(this);
+    for (const u of t)
+      ne(this, $, Dt).call(this, u);
+    if (O(this, ue) === 0) {
+      ne(this, $, Ft).call(this);
+      var n = O(this, Oe), i = O(this, ce);
+      re(this, Oe, []), re(this, ce, []), re(this, ke, []), kt = this, k = null, nr(n), nr(i), (f = O(this, He)) == null || f.resolve();
+    } else
+      ne(this, $, rt).call(this, O(this, Oe)), ne(this, $, rt).call(this, O(this, ce)), ne(this, $, rt).call(this, O(this, ke));
+    r();
+    for (const u of O(this, Te))
+      Ce(u);
+    re(this, Te, []);
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(t, r) {
+    O(this, Ae).has(t) || O(this, Ae).set(t, r), this.current.set(t, t.v);
+  }
+  activate() {
+    k = this;
+  }
+  deactivate() {
+    k = null, kt = null;
+    for (const t of rr)
+      if (rr.delete(t), t(), k !== null)
+        break;
+  }
+  flush() {
+    if (Y.length > 0) {
+      if (this.activate(), Pr(), k !== null && k !== this)
+        return;
+    } else O(this, ue) === 0 && ne(this, $, Ft).call(this);
+    this.deactivate();
+  }
+  increment() {
+    re(this, ue, O(this, ue) + 1);
+  }
+  decrement() {
+    if (re(this, ue, O(this, ue) - 1), O(this, ue) === 0) {
+      for (const t of O(this, Ye))
+        C(t, j), de(t);
+      for (const t of O(this, We))
+        C(t, Q), de(t);
+      this.flush();
+    } else
+      this.deactivate();
+  }
+  /** @param {() => void} fn */
+  add_callback(t) {
+    O(this, Se).add(t);
+  }
+  settled() {
+    return (O(this, He) ?? re(this, He, yr())).promise;
+  }
+  static ensure() {
+    if (k === null) {
+      const t = k = new Ee();
+      et.add(k), Ue || Ee.enqueue(() => {
+        k === t && t.flush();
+      });
+    }
+    return k;
+  }
+  /** @param {() => void} task */
+  static enqueue(t) {
+    gt(t);
+  }
+  /**
+   * @param {Batch} current_batch
+   */
+  static apply(t) {
+    return it;
+  }
+};
+Ae = new WeakMap(), Se = new WeakMap(), ue = new WeakMap(), He = new WeakMap(), Te = new WeakMap(), Oe = new WeakMap(), ce = new WeakMap(), ke = new WeakMap(), Ye = new WeakMap(), We = new WeakMap(), $ = new WeakSet(), /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ */
+Dt = function(t) {
+  var s;
+  t.f ^= I;
+  for (var r = t.first; r !== null; ) {
+    var n = r.f, i = (n & (J | Re)) !== 0, f = i && (n & I) !== 0, u = f || (n & B) !== 0 || this.skipped_effects.has(r);
+    if (!u && r.fn !== null) {
+      i ? r.f ^= I : (n & xt) !== 0 ? O(this, ce).push(r) : (n & I) === 0 && ((n & ht) !== 0 && ((s = r.b) != null && s.is_pending()) ? O(this, Te).push(r) : Xe(r) && ((r.f & pe) !== 0 && O(this, ke).push(r), Ce(r)));
+      var a = r.first;
+      if (a !== null) {
+        r = a;
+        continue;
+      }
+    }
+    var l = r.parent;
+    for (r = r.next; r === null && l !== null; )
+      r = l.next, l = l.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+rt = function(t) {
+  for (const r of t)
+    ((r.f & j) !== 0 ? O(this, Ye) : O(this, We)).push(r), C(r, I);
+  t.length = 0;
+}, /**
+ * Append and remove branches to/from the DOM
+ */
+Ft = function() {
+  var t;
+  for (const r of O(this, Se))
+    r();
+  if (O(this, Se).clear(), et.size > 1) {
+    O(this, Ae).clear();
+    let r = !0;
+    for (const n of et) {
+      if (n === this) {
+        r = !1;
+        continue;
+      }
+      for (const [i, f] of this.current) {
+        if (n.current.has(i))
+          if (r)
+            n.current.set(i, f);
+          else
+            continue;
+        Ir(i);
+      }
+      if (Y.length > 0) {
+        k = n;
+        const i = Ee.apply(n);
+        for (const f of Y)
+          ne(t = n, $, Dt).call(t, f);
+        Y = [], i();
+      }
+    }
+    k = null;
+  }
+  et.delete(this);
+};
+let at = Ee;
+function zn(e) {
+  var t = Ue;
+  Ue = !0;
+  try {
+    for (var r; ; ) {
+      if (Wn(), Y.length === 0 && (k == null || k.flush(), Y.length === 0))
+        return bt = null, /** @type {T} */
+        r;
+      Pr();
+    }
+  } finally {
+    Ue = t;
+  }
+}
+function Pr() {
+  var e = me;
+  Lt = !0;
+  try {
+    var t = 0;
+    for (lr(!0); Y.length > 0; ) {
+      var r = at.ensure();
+      if (t++ > 1e3) {
+        var n, i;
+        Zn();
+      }
+      r.process(Y), ae.clear();
+    }
+  } finally {
+    Lt = !1, lr(e), bt = null;
+  }
+}
+function Zn() {
+  try {
+    qn();
+  } catch (e) {
+    lt(e, bt);
+  }
+}
+let z = null;
+function nr(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var r = 0; r < t; ) {
+      var n = e[r++];
+      if ((n.f & (he | B)) === 0 && Xe(n) && (z = [], Ce(n), n.deps === null && n.first === null && n.nodes_start === null && (n.teardown === null && n.ac === null ? Br(n) : n.fn = null), (z == null ? void 0 : z.length) > 0)) {
+        ae.clear();
+        for (const i of z)
+          Ce(i);
+        z = [];
+      }
+    }
+    z = null;
+  }
+}
+function Ir(e) {
+  if (e.reactions !== null)
+    for (const t of e.reactions) {
+      const r = t.f;
+      (r & D) !== 0 ? Ir(
+        /** @type {Derived} */
+        t
+      ) : (r & (ht | pe)) !== 0 && (C(t, j), de(
+        /** @type {Effect} */
+        t
+      ));
+    }
+}
+function de(e) {
+  for (var t = bt = e; t.parent !== null; ) {
+    t = t.parent;
+    var r = t.f;
+    if (Lt && t === S && (r & pe) !== 0)
+      return;
+    if ((r & (Re | J)) !== 0) {
+      if ((r & I) === 0) return;
+      t.f ^= I;
+    }
+  }
+  Y.push(t);
+}
+function Cr(e, t, r) {
+  const n = Ke() ? ze : Bt;
+  if (t.length === 0) {
+    r(e.map(n));
+    return;
+  }
+  var i = k, f = (
+    /** @type {Effect} */
+    S
+  ), u = Xn();
+  Promise.all(t.map((a) => /* @__PURE__ */ Jn(a))).then((a) => {
+    i == null || i.activate(), u();
+    try {
+      r([...e.map(n), ...a]);
+    } catch (l) {
+      (f.f & he) === 0 && lt(l, f);
+    }
+    i == null || i.deactivate(), Rr();
+  }).catch((a) => {
+    lt(a, f);
+  });
+}
+function Xn() {
+  var e = S, t = A, r = P, n = k;
+  return function() {
+    se(e), K(t), ut(r), n == null || n.activate();
+  };
+}
+function Rr() {
+  se(null), K(null), ut(null);
+}
+// @__NO_SIDE_EFFECTS__
+function ze(e) {
+  var t = D | j, r = A !== null && (A.f & D) !== 0 ? (
+    /** @type {Derived} */
+    A
+  ) : null;
+  return S === null || r !== null && (r.f & x) !== 0 ? t |= x : S.f |= pt, {
+    ctx: P,
+    deps: null,
+    effects: null,
+    equals: Tr,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      N
+    ),
+    wv: 0,
+    parent: r ?? S,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Jn(e, t) {
+  let r = (
+    /** @type {Effect | null} */
+    S
+  );
+  r === null && Ln();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), f = $e(
+    /** @type {V} */
+    N
+  ), u = !A, a = /* @__PURE__ */ new Map();
+  return oi(() => {
+    var _;
+    var l = yr();
+    i = l.promise;
+    try {
+      Promise.resolve(e()).then(l.resolve, l.reject);
+    } catch (d) {
+      l.reject(d);
+    }
+    var s = (
+      /** @type {Batch} */
+      k
+    ), c = n.is_pending();
+    u && (n.update_pending_count(1), c || (s.increment(), (_ = a.get(s)) == null || _.reject(qe), a.set(s, l)));
+    const v = (d, o = void 0) => {
+      c || s.activate(), o ? o !== qe && (f.f |= ve, Ne(f, o)) : ((f.f & ve) !== 0 && (f.f ^= ve), Ne(f, d)), u && (n.update_pending_count(-1), c || s.decrement()), Rr();
+    };
+    l.promise.then(v, (d) => v(null, d || "unknown"));
+  }), yt(() => {
+    for (const l of a.values())
+      l.reject(qe);
+  }), new Promise((l) => {
+    function s(c) {
+      function v() {
+        c === i ? l(f) : s(i);
+      }
+      c.then(v, v);
+    }
+    s(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Ki(e) {
+  const t = /* @__PURE__ */ ze(e);
+  return Gr(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function Bt(e) {
+  const t = /* @__PURE__ */ ze(e);
+  return t.equals = Or, t;
+}
+function Mr(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var r = 0; r < t.length; r += 1)
+      G(
+        /** @type {Effect} */
+        t[r]
+      );
+  }
+}
+function Qn(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & D) === 0)
+      return (
+        /** @type {Effect} */
+        t
+      );
+    t = t.parent;
+  }
+  return null;
+}
+function Ht(e) {
+  var t, r = S;
+  se(Qn(e));
+  try {
+    Mr(e), t = Xr(e);
+  } finally {
+    se(r);
+  }
+  return t;
+}
+function Lr(e) {
+  var t = Ht(e);
+  if (e.equals(t) || (e.v = t, e.wv = zr()), !ge) {
+    var r = (le || (e.f & x) !== 0) && e.deps !== null ? Q : I;
+    C(e, r);
+  }
+}
+const ae = /* @__PURE__ */ new Map();
+function $e(e, t) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Tr,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function ie(e, t) {
+  const r = $e(e);
+  return Gr(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function Dr(e, t = !1, r = !0) {
+  var i;
+  const n = $e(e);
+  return t || (n.equals = Or), Ge && r && P !== null && P.l !== null && ((i = P.l).s ?? (i.s = [])).push(n), n;
+}
+function Z(e, t, r = !1) {
+  A !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
+  // to ensure we error if state is set inside an inspect effect
+  (!W || (A.f & tr) !== 0) && Ke() && (A.f & (D | pe | ht | tr)) !== 0 && !(M != null && M.includes(e)) && Vn();
+  let n = r ? we(t) : t;
+  return Ne(e, n);
+}
+function Ne(e, t) {
+  if (!e.equals(t)) {
+    var r = e.v;
+    ge ? ae.set(e, t) : ae.set(e, r), e.v = t;
+    var n = at.ensure();
+    n.capture(e, r), (e.f & D) !== 0 && ((e.f & j) !== 0 && Ht(
+      /** @type {Derived} */
+      e
+    ), C(e, (e.f & x) === 0 ? I : Q)), e.wv = zr(), Fr(e, j), Ke() && S !== null && (S.f & I) !== 0 && (S.f & (J | Re)) === 0 && (U === null ? di([e]) : U.push(e));
+  }
+  return t;
+}
+function Nt(e) {
+  Z(e, e.v + 1);
+}
+function Fr(e, t) {
+  var r = e.reactions;
+  if (r !== null)
+    for (var n = Ke(), i = r.length, f = 0; f < i; f++) {
+      var u = r[f], a = u.f;
+      if (!(!n && u === S)) {
+        var l = (a & j) === 0;
+        l && C(u, t), (a & D) !== 0 ? Fr(
+          /** @type {Derived} */
+          u,
+          Q
+        ) : l && ((a & pe) !== 0 && z !== null && z.push(
+          /** @type {Effect} */
+          u
+        ), de(
+          /** @type {Effect} */
+          u
+        ));
+      }
+    }
+}
+function we(e) {
+  if (typeof e != "object" || e === null || X in e)
+    return e;
+  const t = Ut(e);
+  if (t !== Pn && t !== In)
+    return e;
+  var r = /* @__PURE__ */ new Map(), n = _t(e), i = /* @__PURE__ */ ie(0), f = _e, u = (a) => {
+    if (_e === f)
+      return a();
+    var l = A, s = _e;
+    K(null), sr(f);
+    var c = a();
+    return K(l), sr(s), c;
+  };
+  return n && r.set("length", /* @__PURE__ */ ie(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(a, l, s) {
+        (!("value" in s) || s.configurable === !1 || s.enumerable === !1 || s.writable === !1) && xn();
+        var c = r.get(l);
+        return c === void 0 ? c = u(() => {
+          var v = /* @__PURE__ */ ie(s.value);
+          return r.set(l, v), v;
+        }) : Z(c, s.value, !0), !0;
+      },
+      deleteProperty(a, l) {
+        var s = r.get(l);
+        if (s === void 0) {
+          if (l in a) {
+            const c = u(() => /* @__PURE__ */ ie(N));
+            r.set(l, c), Nt(i);
+          }
+        } else
+          Z(s, N), Nt(i);
+        return !0;
+      },
+      get(a, l, s) {
+        var d;
+        if (l === X)
+          return e;
+        var c = r.get(l), v = l in a;
+        if (c === void 0 && (!v || (d = ye(a, l)) != null && d.writable) && (c = u(() => {
+          var o = we(v ? a[l] : N), b = /* @__PURE__ */ ie(o);
+          return b;
+        }), r.set(l, c)), c !== void 0) {
+          var _ = L(c);
+          return _ === N ? void 0 : _;
+        }
+        return Reflect.get(a, l, s);
+      },
+      getOwnPropertyDescriptor(a, l) {
+        var s = Reflect.getOwnPropertyDescriptor(a, l);
+        if (s && "value" in s) {
+          var c = r.get(l);
+          c && (s.value = L(c));
+        } else if (s === void 0) {
+          var v = r.get(l), _ = v == null ? void 0 : v.v;
+          if (v !== void 0 && _ !== N)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: _,
+              writable: !0
+            };
+        }
+        return s;
+      },
+      has(a, l) {
+        var _;
+        if (l === X)
+          return !0;
+        var s = r.get(l), c = s !== void 0 && s.v !== N || Reflect.has(a, l);
+        if (s !== void 0 || S !== null && (!c || (_ = ye(a, l)) != null && _.writable)) {
+          s === void 0 && (s = u(() => {
+            var d = c ? we(a[l]) : N, o = /* @__PURE__ */ ie(d);
+            return o;
+          }), r.set(l, s));
+          var v = L(s);
+          if (v === N)
+            return !1;
+        }
+        return c;
+      },
+      set(a, l, s, c) {
+        var h;
+        var v = r.get(l), _ = l in a;
+        if (n && l === "length")
+          for (var d = s; d < /** @type {Source<number>} */
+          v.v; d += 1) {
+            var o = r.get(d + "");
+            o !== void 0 ? Z(o, N) : d in a && (o = u(() => /* @__PURE__ */ ie(N)), r.set(d + "", o));
+          }
+        if (v === void 0)
+          (!_ || (h = ye(a, l)) != null && h.writable) && (v = u(() => /* @__PURE__ */ ie(void 0)), Z(v, we(s)), r.set(l, v));
+        else {
+          _ = v.v !== N;
+          var b = u(() => we(s));
+          Z(v, b);
+        }
+        var p = Reflect.getOwnPropertyDescriptor(a, l);
+        if (p != null && p.set && p.set.call(c, s), !_) {
+          if (n && typeof l == "string") {
+            var w = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), T = Number(l);
+            Number.isInteger(T) && T >= w.v && Z(w, T + 1);
+          }
+          Nt(i);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        L(i);
+        var l = Reflect.ownKeys(a).filter((v) => {
+          var _ = r.get(v);
+          return _ === void 0 || _.v !== N;
+        });
+        for (var [s, c] of r)
+          c.v !== N && !(s in a) && l.push(s);
+        return l;
+      },
+      setPrototypeOf() {
+        $n();
+      }
+    }
+  );
+}
+function ir(e) {
+  try {
+    if (e !== null && typeof e == "object" && X in e)
+      return e[X];
+  } catch {
+  }
+  return e;
+}
+function ei(e, t) {
+  return Object.is(ir(e), ir(t));
+}
+var ti, ri, ni;
+function Ze(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Pe(e) {
+  return ri.call(e);
+}
+// @__NO_SIDE_EFFECTS__
+function wt(e) {
+  return ni.call(e);
+}
+function zi(e, t) {
+  return /* @__PURE__ */ Pe(e);
+}
+function Zi(e, t = !1) {
+  {
+    var r = (
+      /** @type {DocumentFragment} */
+      /* @__PURE__ */ Pe(
+        /** @type {Node} */
+        e
+      )
+    );
+    return r instanceof Comment && r.data === "" ? /* @__PURE__ */ wt(r) : r;
+  }
+}
+function Xi(e, t = 1, r = !1) {
+  let n = e;
+  for (; t--; )
+    n = /** @type {TemplateNode} */
+    /* @__PURE__ */ wt(n);
+  return n;
+}
+function ii(e) {
+  e.textContent = "";
+}
+function jr() {
+  return !1;
+}
+function fi(e, t) {
+  if (t) {
+    const r = document.body;
+    e.autofocus = !0, gt(() => {
+      document.activeElement === r && e.focus();
+    });
+  }
+}
+let fr = !1;
+function ui() {
+  fr || (fr = !0, document.addEventListener(
+    "reset",
+    (e) => {
+      Promise.resolve().then(() => {
+        var t;
+        if (!e.defaultPrevented)
+          for (
+            const r of
+            /**@type {HTMLFormElement} */
+            e.target.elements
+          )
+            (t = r.__on_r) == null || t.call(r);
+      });
+    },
+    // In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
+    { capture: !0 }
+  ));
+}
+function Et(e) {
+  var t = A, r = S;
+  K(null), se(null);
+  try {
+    return e();
+  } finally {
+    K(t), se(r);
+  }
+}
+function li(e, t, r, n = r) {
+  e.addEventListener(t, () => Et(r));
+  const i = e.__on_r;
+  i ? e.__on_r = () => {
+    i(), n(!0);
+  } : e.__on_r = () => n(!0), ui();
+}
+function qr(e) {
+  S === null && A === null && jn(), A !== null && (A.f & x) !== 0 && S === null && Fn(), ge && Dn();
+}
+function ai(e, t) {
+  var r = t.last;
+  r === null ? t.last = t.first = e : (r.next = e, e.prev = r, t.last = e);
+}
+function ee(e, t, r, n = !0) {
+  var i = S;
+  i !== null && (i.f & B) !== 0 && (e |= B);
+  var f = {
+    ctx: P,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: e | j,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: i,
+    b: i && i.b,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    wv: 0,
+    ac: null
+  };
+  if (r)
+    try {
+      Ce(f), f.f |= $t;
+    } catch (l) {
+      throw G(f), l;
+    }
+  else t !== null && de(f);
+  if (n) {
+    var u = f;
+    if (r && u.deps === null && u.teardown === null && u.nodes_start === null && u.first === u.last && // either `null`, or a singular child
+    (u.f & pt) === 0 && (u = u.first), u !== null && (u.parent = i, i !== null && ai(u, i), A !== null && (A.f & D) !== 0 && (e & Re) === 0)) {
+      var a = (
+        /** @type {Derived} */
+        A
+      );
+      (a.effects ?? (a.effects = [])).push(u);
+    }
+  }
+  return f;
+}
+function yt(e) {
+  const t = ee(dt, null, !1);
+  return C(t, I), t.teardown = e, t;
+}
+function ur(e) {
+  qr();
+  var t = (
+    /** @type {Effect} */
+    S.f
+  ), r = !A && (t & J) !== 0 && (t & $t) === 0;
+  if (r) {
+    var n = (
+      /** @type {ComponentContext} */
+      P
+    );
+    (n.e ?? (n.e = [])).push(e);
+  } else
+    return Ur(e);
+}
+function Ur(e) {
+  return ee(xt | Ar, e, !1);
+}
+function si(e) {
+  return qr(), ee(dt | Ar, e, !0);
+}
+function Yt(e) {
+  return ee(xt, e, !1);
+}
+function Ji(e, t) {
+  var r = (
+    /** @type {ComponentContextLegacy} */
+    P
+  ), n = { effect: null, ran: !1, deps: e };
+  r.l.$.push(n), n.effect = xr(() => {
+    e(), !n.ran && (n.ran = !0, Je(t));
+  });
+}
+function Qi() {
+  var e = (
+    /** @type {ComponentContextLegacy} */
+    P
+  );
+  xr(() => {
+    for (var t of e.l.$) {
+      t.deps();
+      var r = t.effect;
+      (r.f & I) !== 0 && C(r, Q), Xe(r) && Ce(r), t.ran = !1;
+    }
+  });
+}
+function oi(e) {
+  return ee(ht | pt, e, !0);
+}
+function xr(e, t = 0) {
+  return ee(dt | t, e, !0);
+}
+function ef(e, t = [], r = []) {
+  Cr(t, r, (n) => {
+    ee(dt, () => e(...n.map(L)), !0);
+  });
+}
+function mt(e, t = 0) {
+  var r = ee(pe | t, e, !0);
+  return r;
+}
+function Ie(e, t = !0) {
+  return ee(J | pt, e, !0, t);
+}
+function $r(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const r = ge, n = A;
+    ar(!0), K(null);
+    try {
+      t.call(null);
+    } finally {
+      ar(r), K(n);
+    }
+  }
+}
+function Vr(e, t = !1) {
+  var r = e.first;
+  for (e.first = e.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && Et(() => {
+      i.abort(qe);
+    });
+    var n = r.next;
+    (r.f & Re) !== 0 ? r.parent = null : G(r, t), r = n;
+  }
+}
+function ci(e) {
+  for (var t = e.first; t !== null; ) {
+    var r = t.next;
+    (t.f & J) === 0 && G(t), t = r;
+  }
+}
+function G(e, t = !0) {
+  var r = !1;
+  (t || (e.f & Rn) !== 0) && e.nodes_start !== null && e.nodes_end !== null && (vi(
+    e.nodes_start,
+    /** @type {TemplateNode} */
+    e.nodes_end
+  ), r = !0), Vr(e, t && !r), st(e, 0), C(e, he);
+  var n = e.transitions;
+  if (n !== null)
+    for (const f of n)
+      f.stop();
+  $r(e);
+  var i = e.parent;
+  i !== null && i.first !== null && Br(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes_start = e.nodes_end = e.ac = null;
+}
+function vi(e, t) {
+  for (; e !== null; ) {
+    var r = e === t ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ wt(e)
+    );
+    e.remove(), e = r;
+  }
+}
+function Br(e) {
+  var t = e.parent, r = e.prev, n = e.next;
+  r !== null && (r.next = n), n !== null && (n.prev = r), t !== null && (t.first === e && (t.first = n), t.last === e && (t.last = r));
+}
+function Hr(e, t) {
+  var r = [];
+  Wt(e, r, !0), Yr(r, () => {
+    G(e), t && t();
+  });
+}
+function Yr(e, t) {
+  var r = e.length;
+  if (r > 0) {
+    var n = () => --r || t();
+    for (var i of e)
+      i.out(n);
+  } else
+    t();
+}
+function Wt(e, t, r) {
+  if ((e.f & B) === 0) {
+    if (e.f ^= B, e.transitions !== null)
+      for (const u of e.transitions)
+        (u.is_global || r) && t.push(u);
+    for (var n = e.first; n !== null; ) {
+      var i = n.next, f = (n.f & Vt) !== 0 || (n.f & J) !== 0;
+      Wt(n, t, f ? r : !1), n = i;
+    }
+  }
+}
+function Gt(e) {
+  Wr(e, !0);
+}
+function Wr(e, t) {
+  if ((e.f & B) !== 0) {
+    e.f ^= B, (e.f & I) === 0 && (C(e, j), de(e));
+    for (var r = e.first; r !== null; ) {
+      var n = r.next, i = (r.f & Vt) !== 0 || (r.f & J) !== 0;
+      Wr(r, i ? t : !1), r = n;
+    }
+    if (e.transitions !== null)
+      for (const f of e.transitions)
+        (f.is_global || t) && f.in();
+  }
+}
+let fe = null;
+function _i(e) {
+  var t = fe;
+  try {
+    if (fe = /* @__PURE__ */ new Set(), Je(e), t !== null)
+      for (var r of fe)
+        t.add(r);
+    return fe;
+  } finally {
+    fe = t;
+  }
+}
+function tf(e) {
+  for (var t of _i(e))
+    Ne(t, t.v);
+}
+let me = !1;
+function lr(e) {
+  me = e;
+}
+let ge = !1;
+function ar(e) {
+  ge = e;
+}
+let A = null, W = !1;
+function K(e) {
+  A = e;
+}
+let S = null;
+function se(e) {
+  S = e;
+}
+let M = null;
+function Gr(e) {
+  A !== null && (M === null ? M = [e] : M.push(e));
+}
+let R = null, F = 0, U = null;
+function di(e) {
+  U = e;
+}
+let Kr = 1, Ve = 0, _e = Ve;
+function sr(e) {
+  _e = e;
+}
+let le = !1;
+function zr() {
+  return ++Kr;
+}
+function Xe(e) {
+  var v;
+  var t = e.f;
+  if ((t & j) !== 0)
+    return !0;
+  if ((t & Q) !== 0) {
+    var r = e.deps, n = (t & x) !== 0;
+    if (r !== null) {
+      var i, f, u = (t & ft) !== 0, a = n && S !== null && !le, l = r.length;
+      if ((u || a) && (S === null || (S.f & he) === 0)) {
+        var s = (
+          /** @type {Derived} */
+          e
+        ), c = s.parent;
+        for (i = 0; i < l; i++)
+          f = r[i], (u || !((v = f == null ? void 0 : f.reactions) != null && v.includes(s))) && (f.reactions ?? (f.reactions = [])).push(s);
+        u && (s.f ^= ft), a && c !== null && (c.f & x) === 0 && (s.f ^= x);
+      }
+      for (i = 0; i < l; i++)
+        if (f = r[i], Xe(
+          /** @type {Derived} */
+          f
+        ) && Lr(
+          /** @type {Derived} */
+          f
+        ), f.wv > e.wv)
+          return !0;
+    }
+    (!n || S !== null && !le) && C(e, I);
+  }
+  return !1;
+}
+function Zr(e, t, r = !0) {
+  var n = e.reactions;
+  if (n !== null && !(M != null && M.includes(e)))
+    for (var i = 0; i < n.length; i++) {
+      var f = n[i];
+      (f.f & D) !== 0 ? Zr(
+        /** @type {Derived} */
+        f,
+        t,
+        !1
+      ) : t === f && (r ? C(f, j) : (f.f & I) !== 0 && C(f, Q), de(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function Xr(e) {
+  var b;
+  var t = R, r = F, n = U, i = A, f = le, u = M, a = P, l = W, s = _e, c = e.f;
+  R = /** @type {null | Value[]} */
+  null, F = 0, U = null, le = (c & x) !== 0 && (W || !me || A === null), A = (c & (J | Re)) === 0 ? e : null, M = null, ut(e.ctx), W = !1, _e = ++Ve, e.ac !== null && (Et(() => {
+    e.ac.abort(qe);
+  }), e.ac = null);
+  try {
+    e.f |= Mt;
+    var v = (
+      /** @type {Function} */
+      e.fn
+    ), _ = v(), d = e.deps;
+    if (R !== null) {
+      var o;
+      if (st(e, F), d !== null && F > 0)
+        for (d.length = F + R.length, o = 0; o < R.length; o++)
+          d[F + o] = R[o];
+      else
+        e.deps = d = R;
+      if (!le || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (c & D) !== 0 && /** @type {import('#client').Derived} */
+      e.reactions !== null)
+        for (o = F; o < d.length; o++)
+          ((b = d[o]).reactions ?? (b.reactions = [])).push(e);
+    } else d !== null && F < d.length && (st(e, F), d.length = F);
+    if (Ke() && U !== null && !W && d !== null && (e.f & (D | Q | j)) === 0)
+      for (o = 0; o < /** @type {Source[]} */
+      U.length; o++)
+        Zr(
+          U[o],
+          /** @type {Effect} */
+          e
+        );
+    return i !== null && i !== e && (Ve++, U !== null && (n === null ? n = U : n.push(.../** @type {Source[]} */
+    U))), (e.f & ve) !== 0 && (e.f ^= ve), _;
+  } catch (p) {
+    return Kn(p);
+  } finally {
+    e.f ^= Mt, R = t, F = r, U = n, A = i, le = f, M = u, ut(a), W = l, _e = s;
+  }
+}
+function pi(e, t) {
+  let r = t.reactions;
+  if (r !== null) {
+    var n = Nn.call(r, e);
+    if (n !== -1) {
+      var i = r.length - 1;
+      i === 0 ? r = t.reactions = null : (r[n] = r[i], r.pop());
+    }
+  }
+  r === null && (t.f & D) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (R === null || !R.includes(t)) && (C(t, Q), (t.f & (x | ft)) === 0 && (t.f ^= ft), Mr(
+    /** @type {Derived} **/
+    t
+  ), st(
+    /** @type {Derived} **/
+    t,
+    0
+  ));
+}
+function st(e, t) {
+  var r = e.deps;
+  if (r !== null)
+    for (var n = t; n < r.length; n++)
+      pi(e, r[n]);
+}
+function Ce(e) {
+  var t = e.f;
+  if ((t & he) === 0) {
+    C(e, I);
+    var r = S, n = me;
+    S = e, me = !0;
+    try {
+      (t & pe) !== 0 ? ci(e) : Vr(e), $r(e);
+      var i = Xr(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = Kr;
+      var f;
+      br && pn && (e.f & j) !== 0 && e.deps;
+    } finally {
+      me = n, S = r;
+    }
+  }
+}
+async function rf() {
+  await Promise.resolve(), zn();
+}
+function L(e) {
+  var t = e.f, r = (t & D) !== 0;
+  if (fe == null || fe.add(e), A !== null && !W) {
+    var n = S !== null && (S.f & he) !== 0;
+    if (!n && !(M != null && M.includes(e))) {
+      var i = A.deps;
+      if ((A.f & Mt) !== 0)
+        e.rv < Ve && (e.rv = Ve, R === null && i !== null && i[F] === e ? F++ : R === null ? R = [e] : (!le || !R.includes(e)) && R.push(e));
+      else {
+        (A.deps ?? (A.deps = [])).push(e);
+        var f = e.reactions;
+        f === null ? e.reactions = [A] : f.includes(A) || f.push(A);
+      }
+    }
+  } else if (r && /** @type {Derived} */
+  e.deps === null && /** @type {Derived} */
+  e.effects === null) {
+    var u = (
+      /** @type {Derived} */
+      e
+    ), a = u.parent;
+    a !== null && (a.f & x) === 0 && (u.f ^= x);
+  }
+  if (ge) {
+    if (ae.has(e))
+      return ae.get(e);
+    if (r) {
+      u = /** @type {Derived} */
+      e;
+      var l = u.v;
+      return ((u.f & I) === 0 && u.reactions !== null || Jr(u)) && (l = Ht(u)), ae.set(u, l), l;
+    }
+  } else r && (u = /** @type {Derived} */
+  e, Xe(u) && Lr(u));
+  if ((e.f & ve) !== 0)
+    throw e.v;
+  return e.v;
+}
+function Jr(e) {
+  if (e.v === N) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (ae.has(t) || (t.f & D) !== 0 && Jr(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function Je(e) {
+  var t = W;
+  try {
+    return W = !0, e();
+  } finally {
+    W = t;
+  }
+}
+const hi = -7169;
+function C(e, t) {
+  e.f = e.f & hi | t;
+}
+function gi(e) {
+  if (!(typeof e != "object" || !e || e instanceof EventTarget)) {
+    if (X in e)
+      jt(e);
+    else if (!Array.isArray(e))
+      for (let t in e) {
+        const r = e[t];
+        typeof r == "object" && r && X in r && jt(r);
+      }
+  }
+}
+function jt(e, t = /* @__PURE__ */ new Set()) {
+  if (typeof e == "object" && e !== null && // We don't want to traverse DOM elements
+  !(e instanceof EventTarget) && !t.has(e)) {
+    t.add(e), e instanceof Date && e.getTime();
+    for (let n in e)
+      try {
+        jt(e[n], t);
+      } catch {
+      }
+    const r = Ut(e);
+    if (r !== Object.prototype && r !== Array.prototype && r !== Map.prototype && r !== Set.prototype && r !== Date.prototype) {
+      const n = Er(r);
+      for (let i in n) {
+        const f = n[i].get;
+        if (f)
+          try {
+            f.call(e);
+          } catch {
+          }
+      }
+    }
+  }
+}
+const bi = /* @__PURE__ */ new Set(), wi = /* @__PURE__ */ new Set();
+function Qr(e, t, r, n = {}) {
+  function i(f) {
+    if (n.capture || yi.call(t, f), !f.cancelBubble)
+      return Et(() => r == null ? void 0 : r.call(this, f));
+  }
+  return e.startsWith("pointer") || e.startsWith("touch") || e === "wheel" ? gt(() => {
+    t.addEventListener(e, i, n);
+  }) : t.addEventListener(e, i, n), i;
+}
+function nf(e, t, r, n, i) {
+  var f = { capture: n, passive: i }, u = Qr(e, t, r, f);
+  (t === document.body || // @ts-ignore
+  t === window || // @ts-ignore
+  t === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+  t instanceof HTMLMediaElement) && yt(() => {
+    t.removeEventListener(e, u, f);
+  });
+}
+function Ei(e) {
+  for (var t = 0; t < e.length; t++)
+    bi.add(e[t]);
+  for (var r of wi)
+    r(e);
+}
+let or = null;
+function yi(e) {
+  var T;
+  var t = this, r = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), n = e.type, i = ((T = e.composedPath) == null ? void 0 : T.call(e)) || [], f = (
+    /** @type {null | Element} */
+    i[0] || e.target
+  );
+  or = e;
+  var u = 0, a = or === e && e.__root;
+  if (a) {
+    var l = i.indexOf(a);
+    if (l !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var s = i.indexOf(t);
+    if (s === -1)
+      return;
+    l <= s && (u = l);
+  }
+  if (f = /** @type {Element} */
+  i[u] || e.target, f !== t) {
+    nt(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return f || r;
+      }
+    });
+    var c = A, v = S;
+    K(null), se(null);
+    try {
+      for (var _, d = []; f !== null; ) {
+        var o = f.assignedSlot || f.parentNode || /** @type {any} */
+        f.host || null;
+        try {
+          var b = f["__" + n];
+          if (b != null && (!/** @type {any} */
+          f.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          e.target === f))
+            if (_t(b)) {
+              var [p, ...w] = b;
+              p.apply(f, [e, ...w]);
+            } else
+              b.call(f, e);
+        } catch (h) {
+          _ ? d.push(h) : _ = h;
+        }
+        if (e.cancelBubble || o === t || o === null)
+          break;
+        f = o;
+      }
+      if (_) {
+        for (let h of d)
+          queueMicrotask(() => {
+            throw h;
+          });
+        throw _;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, K(c), se(v);
+    }
+  }
+}
+function en(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function Be(e, t) {
+  var r = (
+    /** @type {Effect} */
+    S
+  );
+  r.nodes_start === null && (r.nodes_start = e, r.nodes_end = t);
+}
+// @__NO_SIDE_EFFECTS__
+function ff(e, t) {
+  var r = (t & Sn) !== 0, n = (t & Tn) !== 0, i, f = !e.startsWith("<!>");
+  return () => {
+    i === void 0 && (i = en(f ? e : "<!>" + e), r || (i = /** @type {Node} */
+    /* @__PURE__ */ Pe(i)));
+    var u = (
+      /** @type {TemplateNode} */
+      n || ti ? document.importNode(i, !0) : i.cloneNode(!0)
+    );
+    if (r) {
+      var a = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Pe(u)
+      ), l = (
+        /** @type {TemplateNode} */
+        u.lastChild
+      );
+      Be(a, l);
+    } else
+      Be(u, u);
+    return u;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function mi(e, t, r = "svg") {
+  var n = !e.startsWith("<!>"), i = `<${r}>${n ? e : "<!>" + e}</${r}>`, f;
+  return () => {
+    if (!f) {
+      var u = (
+        /** @type {DocumentFragment} */
+        en(i)
+      ), a = (
+        /** @type {Element} */
+        /* @__PURE__ */ Pe(u)
+      );
+      f = /** @type {Element} */
+      /* @__PURE__ */ Pe(a);
+    }
+    var l = (
+      /** @type {TemplateNode} */
+      f.cloneNode(!0)
+    );
+    return Be(l, l), l;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function uf(e, t) {
+  return /* @__PURE__ */ mi(e, t, "svg");
+}
+function lf(e = "") {
+  {
+    var t = Ze(e + "");
+    return Be(t, t), t;
+  }
+}
+function af() {
+  var e = document.createDocumentFragment(), t = document.createComment(""), r = Ze();
+  return e.append(t, r), Be(t, r), e;
+}
+function sf(e, t) {
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+function Ai(e) {
+  return e.endsWith("capture") && e !== "gotpointercapture" && e !== "lostpointercapture";
+}
+const Si = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function Ti(e) {
+  return Si.includes(e);
+}
+const Oi = {
+  // no `class: 'className'` because we handle that separately
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
+  readonly: "readOnly",
+  defaultvalue: "defaultValue",
+  defaultchecked: "defaultChecked",
+  srcobject: "srcObject",
+  novalidate: "noValidate",
+  allowfullscreen: "allowFullscreen",
+  disablepictureinpicture: "disablePictureInPicture",
+  disableremoteplayback: "disableRemotePlayback"
+};
+function ki(e) {
+  return e = e.toLowerCase(), Oi[e] ?? e;
+}
+function of(e, t) {
+  var r = t == null ? "" : typeof t == "object" ? t + "" : t;
+  r !== (e.__t ?? (e.__t = e.nodeValue)) && (e.__t = r, e.nodeValue = r + "");
+}
+function cf(e, t, r = !1) {
+  var n = e, i = null, f = null, u = N, a = r ? Vt : 0, l = !1;
+  const s = (d, o = !0) => {
+    l = !0, _(o, d);
+  };
+  var c = null;
+  function v() {
+    c !== null && (c.lastChild.remove(), n.before(c), c = null);
+    var d = u ? i : f, o = u ? f : i;
+    d && Gt(d), o && Hr(o, () => {
+      u ? f = null : i = null;
+    });
+  }
+  const _ = (d, o) => {
+    if (u !== (u = d)) {
+      var b = jr(), p = n;
+      if (b && (c = document.createDocumentFragment(), c.append(p = Ze())), u ? i ?? (i = o && Ie(() => o(p))) : f ?? (f = o && Ie(() => o(p))), b) {
+        var w = (
+          /** @type {Batch} */
+          k
+        ), T = u ? i : f, h = u ? f : i;
+        T && w.skipped_effects.delete(T), h && w.skipped_effects.add(h), w.add_callback(v);
+      } else
+        v();
+    }
+  };
+  mt(() => {
+    l = !1, t(s), l || _(null, null);
+  }, a);
+}
+function vf(e, t) {
+  return t;
+}
+function Ni(e, t, r) {
+  for (var n = e.items, i = [], f = t.length, u = 0; u < f; u++)
+    Wt(t[u].e, i, !0);
+  var a = f > 0 && i.length === 0 && r !== null;
+  if (a) {
+    var l = (
+      /** @type {Element} */
+      /** @type {Element} */
+      r.parentNode
+    );
+    ii(l), l.append(
+      /** @type {Element} */
+      r
+    ), n.clear(), H(e, t[0].prev, t[f - 1].next);
+  }
+  Yr(i, () => {
+    for (var s = 0; s < f; s++) {
+      var c = t[s];
+      a || (n.delete(c.k), H(e, c.prev, c.next)), G(c.e, !a);
+    }
+  });
+}
+function _f(e, t, r, n, i, f = null) {
+  var u = e, a = { flags: t, items: /* @__PURE__ */ new Map(), first: null }, l = (t & gr) !== 0;
+  if (l) {
+    var s = (
+      /** @type {Element} */
+      e
+    );
+    u = s.appendChild(Ze());
+  }
+  var c = null, v = !1, _ = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ Bt(() => {
+    var w = r();
+    return _t(w) ? w : w == null ? [] : wr(w);
+  }), o, b;
+  function p() {
+    Pi(
+      b,
+      o,
+      a,
+      _,
+      u,
+      i,
+      t,
+      n,
+      r
+    ), f !== null && (o.length === 0 ? c ? Gt(c) : c = Ie(() => f(u)) : c !== null && Hr(c, () => {
+      c = null;
+    }));
+  }
+  mt(() => {
+    b ?? (b = /** @type {Effect} */
+    S), o = /** @type {V[]} */
+    L(d);
+    var w = o.length;
+    if (!(v && w === 0)) {
+      v = w === 0;
+      var T, h, g, m;
+      if (jr()) {
+        var y = /* @__PURE__ */ new Set(), E = (
+          /** @type {Batch} */
+          k
+        );
+        for (h = 0; h < w; h += 1) {
+          g = o[h], m = n(g, h);
+          var V = a.items.get(m) ?? _.get(m);
+          V ? (t & (ct | vt)) !== 0 && tn(V, g, h, t) : (T = rn(
+            null,
+            a,
+            null,
+            null,
+            g,
+            m,
+            h,
+            i,
+            t,
+            r,
+            !0
+          ), _.set(m, T)), y.add(m);
+        }
+        for (const [be, At] of a.items)
+          y.has(be) || E.skipped_effects.add(At.e);
+        E.add_callback(p);
+      } else
+        p();
+      L(d);
+    }
+  });
+}
+function Pi(e, t, r, n, i, f, u, a, l) {
+  var zt, Zt, Xt, Jt;
+  var s = (u & gn) !== 0, c = (u & (ct | vt)) !== 0, v = t.length, _ = r.items, d = r.first, o = d, b, p = null, w, T = [], h = [], g, m, y, E;
+  if (s)
+    for (E = 0; E < v; E += 1)
+      g = t[E], m = a(g, E), y = _.get(m), y !== void 0 && ((zt = y.a) == null || zt.measure(), (w ?? (w = /* @__PURE__ */ new Set())).add(y));
+  for (E = 0; E < v; E += 1) {
+    if (g = t[E], m = a(g, E), y = _.get(m), y === void 0) {
+      var V = n.get(m);
+      if (V !== void 0) {
+        n.delete(m), _.set(m, V);
+        var be = p ? p.next : o;
+        H(r, p, V), H(r, V, be), Pt(V, be, i), p = V;
+      } else {
+        var At = o ? (
+          /** @type {TemplateNode} */
+          o.e.nodes_start
+        ) : i;
+        p = rn(
+          At,
+          r,
+          p,
+          p === null ? r.first : p.next,
+          g,
+          m,
+          E,
+          f,
+          u,
+          l
+        );
+      }
+      _.set(m, p), T = [], h = [], o = p.next;
+      continue;
+    }
+    if (c && tn(y, g, E, u), (y.e.f & B) !== 0 && (Gt(y.e), s && ((Zt = y.a) == null || Zt.unfix(), (w ?? (w = /* @__PURE__ */ new Set())).delete(y))), y !== o) {
+      if (b !== void 0 && b.has(y)) {
+        if (T.length < h.length) {
+          var Qe = h[0], te;
+          p = Qe.prev;
+          var Kt = T[0], St = T[T.length - 1];
+          for (te = 0; te < T.length; te += 1)
+            Pt(T[te], Qe, i);
+          for (te = 0; te < h.length; te += 1)
+            b.delete(h[te]);
+          H(r, Kt.prev, St.next), H(r, p, Kt), H(r, St, Qe), o = Qe, p = St, E -= 1, T = [], h = [];
+        } else
+          b.delete(y), Pt(y, o, i), H(r, y.prev, y.next), H(r, y, p === null ? r.first : p.next), H(r, p, y), p = y;
+        continue;
+      }
+      for (T = [], h = []; o !== null && o.k !== m; )
+        (o.e.f & B) === 0 && (b ?? (b = /* @__PURE__ */ new Set())).add(o), h.push(o), o = o.next;
+      if (o === null)
+        continue;
+      y = o;
+    }
+    T.push(y), p = y, o = y.next;
+  }
+  if (o !== null || b !== void 0) {
+    for (var Me = b === void 0 ? [] : wr(b); o !== null; )
+      (o.e.f & B) === 0 && Me.push(o), o = o.next;
+    var Tt = Me.length;
+    if (Tt > 0) {
+      var cn = (u & gr) !== 0 && v === 0 ? i : null;
+      if (s) {
+        for (E = 0; E < Tt; E += 1)
+          (Xt = Me[E].a) == null || Xt.measure();
+        for (E = 0; E < Tt; E += 1)
+          (Jt = Me[E].a) == null || Jt.fix();
+      }
+      Ni(r, Me, cn);
+    }
+  }
+  s && gt(() => {
+    var Qt;
+    if (w !== void 0)
+      for (y of w)
+        (Qt = y.a) == null || Qt.apply();
+  }), e.first = r.first && r.first.e, e.last = p && p.e;
+  for (var vn of n.values())
+    G(vn.e);
+  n.clear();
+}
+function tn(e, t, r, n) {
+  (n & ct) !== 0 && Ne(e.v, t), (n & vt) !== 0 ? Ne(
+    /** @type {Value<number>} */
+    e.i,
+    r
+  ) : e.i = r;
+}
+function rn(e, t, r, n, i, f, u, a, l, s, c) {
+  var v = (l & ct) !== 0, _ = (l & bn) === 0, d = v ? _ ? /* @__PURE__ */ Dr(i, !1, !1) : $e(i) : i, o = (l & vt) === 0 ? u : $e(u), b = {
+    i: o,
+    v: d,
+    k: f,
+    a: null,
+    // @ts-expect-error
+    e: null,
+    prev: r,
+    next: n
+  };
+  try {
+    if (e === null) {
+      var p = document.createDocumentFragment();
+      p.append(e = Ze());
+    }
+    return b.e = Ie(() => a(
+      /** @type {Node} */
+      e,
+      d,
+      o,
+      s
+    ), Hn), b.e.prev = r && r.e, b.e.next = n && n.e, r === null ? c || (t.first = b) : (r.next = b, r.e.next = b.e), n !== null && (n.prev = b, n.e.prev = b.e), b;
+  } finally {
+  }
+}
+function Pt(e, t, r) {
+  for (var n = e.next ? (
+    /** @type {TemplateNode} */
+    e.next.e.nodes_start
+  ) : r, i = t ? (
+    /** @type {TemplateNode} */
+    t.e.nodes_start
+  ) : r, f = (
+    /** @type {TemplateNode} */
+    e.e.nodes_start
+  ); f !== null && f !== n; ) {
+    var u = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ wt(f)
+    );
+    i.before(f), f = u;
+  }
+}
+function H(e, t, r) {
+  t === null ? e.first = r : (t.next = r, t.e.next = r && r.e), r !== null && (r.prev = t, r.e.prev = t && t.e);
+}
+function df(e, t, r, n, i) {
+  var a;
+  var f = (a = t.$$slots) == null ? void 0 : a[r], u = !1;
+  f === !0 && (f = t[r === "default" ? "children" : r], u = !0), f === void 0 || f(e, u ? () => n : n);
+}
+function pf(e) {
+  const t = {};
+  e.children && (t.default = !0);
+  for (const r in e.$$slots)
+    t[r] = !0;
+  return t;
+}
+function Ii(e, t) {
+  var r = void 0, n;
+  mt(() => {
+    r !== (r = t()) && (n && (G(n), n = null), r && (n = Ie(() => {
+      Yt(() => (
+        /** @type {(node: Element) => void} */
+        r(e)
+      ));
+    })));
+  });
+}
+function nn(e) {
+  var t, r, n = "";
+  if (typeof e == "string" || typeof e == "number") n += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var i = e.length;
+    for (t = 0; t < i; t++) e[t] && (r = nn(e[t])) && (n && (n += " "), n += r);
+  } else for (r in e) e[r] && (n && (n += " "), n += r);
+  return n;
+}
+function Ci() {
+  for (var e, t, r = 0, n = "", i = arguments.length; r < i; r++) (e = arguments[r]) && (t = nn(e)) && (n && (n += " "), n += t);
+  return n;
+}
+function Ri(e) {
+  return typeof e == "object" ? Ci(e) : e ?? "";
+}
+const cr = [...` 	
+\r\f \v\uFEFF`];
+function Mi(e, t, r) {
+  var n = e == null ? "" : "" + e;
+  if (t && (n = n ? n + " " + t : t), r) {
+    for (var i in r)
+      if (r[i])
+        n = n ? n + " " + i : i;
+      else if (n.length)
+        for (var f = i.length, u = 0; (u = n.indexOf(i, u)) >= 0; ) {
+          var a = u + f;
+          (u === 0 || cr.includes(n[u - 1])) && (a === n.length || cr.includes(n[a])) ? n = (u === 0 ? "" : n.substring(0, u)) + n.substring(a + 1) : u = a;
+        }
+  }
+  return n === "" ? null : n;
+}
+function vr(e, t = !1) {
+  var r = t ? " !important;" : ";", n = "";
+  for (var i in e) {
+    var f = e[i];
+    f != null && f !== "" && (n += " " + i + ": " + f + r);
+  }
+  return n;
+}
+function It(e) {
+  return e[0] !== "-" || e[1] !== "-" ? e.toLowerCase() : e;
+}
+function Li(e, t) {
+  if (t) {
+    var r = "", n, i;
+    if (Array.isArray(t) ? (n = t[0], i = t[1]) : n = t, e) {
+      e = String(e).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
+      var f = !1, u = 0, a = !1, l = [];
+      n && l.push(...Object.keys(n).map(It)), i && l.push(...Object.keys(i).map(It));
+      var s = 0, c = -1;
+      const b = e.length;
+      for (var v = 0; v < b; v++) {
+        var _ = e[v];
+        if (a ? _ === "/" && e[v - 1] === "*" && (a = !1) : f ? f === _ && (f = !1) : _ === "/" && e[v + 1] === "*" ? a = !0 : _ === '"' || _ === "'" ? f = _ : _ === "(" ? u++ : _ === ")" && u--, !a && f === !1 && u === 0) {
+          if (_ === ":" && c === -1)
+            c = v;
+          else if (_ === ";" || v === b - 1) {
+            if (c !== -1) {
+              var d = It(e.substring(s, c).trim());
+              if (!l.includes(d)) {
+                _ !== ";" && v++;
+                var o = e.substring(s, v).trim();
+                r += " " + o + ";";
+              }
+            }
+            s = v + 1, c = -1;
+          }
+        }
+      }
+    }
+    return n && (r += vr(n)), i && (r += vr(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return e == null ? null : String(e);
+}
+function Di(e, t, r, n, i, f) {
+  var u = e.__className;
+  if (u !== r || u === void 0) {
+    var a = Mi(r, n, f);
+    a == null ? e.removeAttribute("class") : t ? e.className = a : e.setAttribute("class", a), e.__className = r;
+  } else if (f && i !== f)
+    for (var l in f) {
+      var s = !!f[l];
+      (i == null || s !== !!i[l]) && e.classList.toggle(l, s);
+    }
+  return f;
+}
+function Ct(e, t = {}, r, n) {
+  for (var i in r) {
+    var f = r[i];
+    t[i] !== f && (r[i] == null ? e.style.removeProperty(i) : e.style.setProperty(i, f, n));
+  }
+}
+function Fi(e, t, r, n) {
+  var i = e.__style;
+  if (i !== t) {
+    var f = Li(t, n);
+    f == null ? e.removeAttribute("style") : e.style.cssText = f, e.__style = t;
+  } else n && (Array.isArray(n) ? (Ct(e, r == null ? void 0 : r[0], n[0]), Ct(e, r == null ? void 0 : r[1], n[1], "important")) : Ct(e, r, n));
+  return n;
+}
+function ot(e, t, r = !1) {
+  if (e.multiple) {
+    if (t == null)
+      return;
+    if (!_t(t))
+      return Bn();
+    for (var n of e.options)
+      n.selected = t.includes(xe(n));
+    return;
+  }
+  for (n of e.options) {
+    var i = xe(n);
+    if (ei(i, t)) {
+      n.selected = !0;
+      return;
+    }
+  }
+  (!r || t !== void 0) && (e.selectedIndex = -1);
+}
+function fn(e) {
+  var t = new MutationObserver(() => {
+    ot(e, e.__value);
+  });
+  t.observe(e, {
+    // Listen to option element changes
+    childList: !0,
+    subtree: !0,
+    // because of <optgroup>
+    // Listen to option element value attribute changes
+    // (doesn't get notified of select value changes,
+    // because that property is not reflected as an attribute)
+    attributes: !0,
+    attributeFilter: ["value"]
+  }), yt(() => {
+    t.disconnect();
+  });
+}
+function hf(e, t, r = t) {
+  var n = !0;
+  li(e, "change", (i) => {
+    var f = i ? "[selected]" : ":checked", u;
+    if (e.multiple)
+      u = [].map.call(e.querySelectorAll(f), xe);
+    else {
+      var a = e.querySelector(f) ?? // will fall back to first non-disabled option if no option is selected
+      e.querySelector("option:not([disabled])");
+      u = a && xe(a);
+    }
+    r(u);
+  }), Yt(() => {
+    var i = t();
+    if (ot(e, i, n), n && i === void 0) {
+      var f = e.querySelector(":checked");
+      f !== null && (i = xe(f), r(i));
+    }
+    e.__value = i, n = !1;
+  }), fn(e);
+}
+function xe(e) {
+  return "__value" in e ? e.__value : e.value;
+}
+const Fe = Symbol("class"), je = Symbol("style"), un = Symbol("is custom element"), ln = Symbol("is html");
+function ji(e, t) {
+  t ? e.hasAttribute("selected") || e.setAttribute("selected", "") : e.removeAttribute("selected");
+}
+function _r(e, t, r, n) {
+  var i = an(e);
+  i[t] !== (i[t] = r) && (t === "loading" && (e[Mn] = r), r == null ? e.removeAttribute(t) : typeof r != "string" && sn(e).includes(t) ? e[t] = r : e.setAttribute(t, r));
+}
+function qi(e, t, r, n, i = !1, f = !1) {
+  var u = an(e), a = u[un], l = !u[ln], s = t || {}, c = e.tagName === "OPTION";
+  for (var v in t)
+    v in r || (r[v] = null);
+  r.class ? r.class = Ri(r.class) : r[Fe] && (r.class = null), r[je] && (r.style ?? (r.style = null));
+  var _ = sn(e);
+  for (const h in r) {
+    let g = r[h];
+    if (c && h === "value" && g == null) {
+      e.value = e.__value = "", s[h] = g;
+      continue;
+    }
+    if (h === "class") {
+      var d = e.namespaceURI === "http://www.w3.org/1999/xhtml";
+      Di(e, d, g, n, t == null ? void 0 : t[Fe], r[Fe]), s[h] = g, s[Fe] = r[Fe];
+      continue;
+    }
+    if (h === "style") {
+      Fi(e, g, t == null ? void 0 : t[je], r[je]), s[h] = g, s[je] = r[je];
+      continue;
+    }
+    var o = s[h];
+    if (!(g === o && !(g === void 0 && e.hasAttribute(h)))) {
+      s[h] = g;
+      var b = h[0] + h[1];
+      if (b !== "$$")
+        if (b === "on") {
+          const m = {}, y = "$$" + h;
+          let E = h.slice(2);
+          var p = Ti(E);
+          if (Ai(E) && (E = E.slice(0, -7), m.capture = !0), !p && o) {
+            if (g != null) continue;
+            e.removeEventListener(E, s[y], m), s[y] = null;
+          }
+          if (g != null)
+            if (p)
+              e[`__${E}`] = g, Ei([E]);
+            else {
+              let V = function(be) {
+                s[h].call(this, be);
+              };
+              s[y] = Qr(E, e, V, m);
+            }
+          else p && (e[`__${E}`] = void 0);
+        } else if (h === "style")
+          _r(e, h, g);
+        else if (h === "autofocus")
+          fi(
+            /** @type {HTMLElement} */
+            e,
+            !!g
+          );
+        else if (!a && (h === "__value" || h === "value" && g != null))
+          e.value = e.__value = g;
+        else if (h === "selected" && c)
+          ji(
+            /** @type {HTMLOptionElement} */
+            e,
+            g
+          );
+        else {
+          var w = h;
+          l || (w = ki(w));
+          var T = w === "defaultValue" || w === "defaultChecked";
+          if (g == null && !a && !T)
+            if (u[h] = null, w === "value" || w === "checked") {
+              let m = (
+                /** @type {HTMLInputElement} */
+                e
+              );
+              const y = t === void 0;
+              if (w === "value") {
+                let E = m.defaultValue;
+                m.removeAttribute(w), m.defaultValue = E, m.value = m.__value = y ? E : null;
+              } else {
+                let E = m.defaultChecked;
+                m.removeAttribute(w), m.defaultChecked = E, m.checked = y ? E : !1;
+              }
+            } else
+              e.removeAttribute(h);
+          else T || _.includes(w) && (a || typeof g != "string") ? (e[w] = g, w in u && (u[w] = N)) : typeof g != "function" && _r(e, w, g);
+        }
+    }
+  }
+  return s;
+}
+function gf(e, t, r = [], n = [], i, f = !1, u = !1) {
+  Cr(r, n, (a) => {
+    var l = void 0, s = {}, c = e.nodeName === "SELECT", v = !1;
+    if (mt(() => {
+      var d = t(...a.map(L)), o = qi(
+        e,
+        l,
+        d,
+        i,
+        f,
+        u
+      );
+      v && c && "value" in d && ot(
+        /** @type {HTMLSelectElement} */
+        e,
+        d.value
+      );
+      for (let p of Object.getOwnPropertySymbols(s))
+        d[p] || G(s[p]);
+      for (let p of Object.getOwnPropertySymbols(d)) {
+        var b = d[p];
+        p.description === kn && (!l || b !== l[p]) && (s[p] && G(s[p]), s[p] = Ie(() => Ii(e, () => b))), o[p] = b;
+      }
+      l = o;
+    }), c) {
+      var _ = (
+        /** @type {HTMLSelectElement} */
+        e
+      );
+      Yt(() => {
+        ot(
+          _,
+          /** @type {Record<string | symbol, any>} */
+          l.value,
+          !0
+        ), fn(_);
+      });
+    }
+    v = !0;
+  });
+}
+function an(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [un]: e.nodeName.includes("-"),
+      [ln]: e.namespaceURI === On
+    })
+  );
+}
+var dr = /* @__PURE__ */ new Map();
+function sn(e) {
+  var t = e.getAttribute("is") || e.nodeName, r = dr.get(t);
+  if (r) return r;
+  dr.set(t, r = []);
+  for (var n, i = e, f = Element.prototype; f !== i; ) {
+    n = Er(i);
+    for (var u in n)
+      n[u].set && r.push(u);
+    i = Ut(i);
+  }
+  return r;
+}
+function bf(e = !1) {
+  const t = (
+    /** @type {ComponentContextLegacy} */
+    P
+  ), r = t.l.u;
+  if (!r) return;
+  let n = () => gi(t.s);
+  if (e) {
+    let i = 0, f = (
+      /** @type {Record<string, any>} */
+      {}
+    );
+    const u = /* @__PURE__ */ ze(() => {
+      let a = !1;
+      const l = t.s;
+      for (const s in l)
+        l[s] !== f[s] && (f[s] = l[s], a = !0);
+      return a && i++, i;
+    });
+    n = () => L(u);
+  }
+  r.b.length && si(() => {
+    pr(t, n), Rt(r.b);
+  }), ur(() => {
+    const i = Je(() => r.m.map(Cn));
+    return () => {
+      for (const f of i)
+        typeof f == "function" && f();
+    };
+  }), r.a.length && ur(() => {
+    pr(t, n), Rt(r.a);
+  });
+}
+function pr(e, t) {
+  if (e.l.s)
+    for (const r of e.l.s) L(r);
+  t();
+}
+function on(e, t, r) {
+  if (e == null)
+    return t(void 0), it;
+  const n = Je(
+    () => e.subscribe(
+      t,
+      // @ts-expect-error
+      r
+    )
+  );
+  return n.unsubscribe ? () => n.unsubscribe() : n;
+}
+function Ui(e) {
+  let t;
+  return on(e, (r) => t = r)(), t;
+}
+let tt = !1, qt = Symbol();
+function wf(e, t, r) {
+  const n = r[t] ?? (r[t] = {
+    store: null,
+    source: /* @__PURE__ */ Dr(void 0),
+    unsubscribe: it
+  });
+  if (n.store !== e && !(qt in r))
+    if (n.unsubscribe(), n.store = e ?? null, e == null)
+      n.source.v = void 0, n.unsubscribe = it;
+    else {
+      var i = !0;
+      n.unsubscribe = on(e, (f) => {
+        i ? n.source.v = f : Z(n.source, f);
+      }), i = !1;
+    }
+  return e && qt in r ? Ui(e) : L(n.source);
+}
+function Ef() {
+  const e = {};
+  function t() {
+    yt(() => {
+      for (var r in e)
+        e[r].unsubscribe();
+      nt(e, qt, {
+        enumerable: !1,
+        value: !0
+      });
+    });
+  }
+  return [e, t];
+}
+function xi(e) {
+  var t = tt;
+  try {
+    return tt = !1, [e(), tt];
+  } finally {
+    tt = t;
+  }
+}
+const $i = {
+  get(e, t) {
+    let r = e.props.length;
+    for (; r--; ) {
+      let n = e.props[r];
+      if (De(n) && (n = n()), typeof n == "object" && n !== null && t in n) return n[t];
+    }
+  },
+  set(e, t, r) {
+    let n = e.props.length;
+    for (; n--; ) {
+      let i = e.props[n];
+      De(i) && (i = i());
+      const f = ye(i, t);
+      if (f && f.set)
+        return f.set(r), !0;
+    }
+    return !1;
+  },
+  getOwnPropertyDescriptor(e, t) {
+    let r = e.props.length;
+    for (; r--; ) {
+      let n = e.props[r];
+      if (De(n) && (n = n()), typeof n == "object" && n !== null && t in n) {
+        const i = ye(n, t);
+        return i && !i.configurable && (i.configurable = !0), i;
+      }
+    }
+  },
+  has(e, t) {
+    if (t === X || t === Sr) return !1;
+    for (let r of e.props)
+      if (De(r) && (r = r()), r != null && t in r) return !0;
+    return !1;
+  },
+  ownKeys(e) {
+    const t = [];
+    for (let r of e.props)
+      if (De(r) && (r = r()), !!r) {
+        for (const n in r)
+          t.includes(n) || t.push(n);
+        for (const n of Object.getOwnPropertySymbols(r))
+          t.includes(n) || t.push(n);
+      }
+    return t;
+  }
+};
+function yf(...e) {
+  return new Proxy({ props: e }, $i);
+}
+function mf(e, t, r, n) {
+  var h;
+  var i = !Ge || (r & En) !== 0, f = (r & mn) !== 0, u = (r & An) !== 0, a = (
+    /** @type {V} */
+    n
+  ), l = !0, s = () => (l && (l = !1, a = u ? Je(
+    /** @type {() => V} */
+    n
+  ) : (
+    /** @type {V} */
+    n
+  )), a), c;
+  if (f) {
+    var v = X in e || Sr in e;
+    c = ((h = ye(e, t)) == null ? void 0 : h.set) ?? (v && t in e ? (g) => e[t] = g : void 0);
+  }
+  var _, d = !1;
+  f ? [_, d] = xi(() => (
+    /** @type {V} */
+    e[t]
+  )) : _ = /** @type {V} */
+  e[t], _ === void 0 && n !== void 0 && (_ = s(), c && (i && Un(), c(_)));
+  var o;
+  if (i ? o = () => {
+    var g = (
+      /** @type {V} */
+      e[t]
+    );
+    return g === void 0 ? s() : (l = !0, g);
+  } : o = () => {
+    var g = (
+      /** @type {V} */
+      e[t]
+    );
+    return g !== void 0 && (a = /** @type {V} */
+    void 0), g === void 0 ? a : g;
+  }, i && (r & yn) === 0)
+    return o;
+  if (c) {
+    var b = e.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(g, m) {
+        return arguments.length > 0 ? ((!i || !m || b || d) && c(m ? o() : g), g) : o();
+      })
+    );
+  }
+  var p = !1, w = ((r & wn) !== 0 ? ze : Bt)(() => (p = !1, o()));
+  f && L(w);
+  var T = (
+    /** @type {Effect} */
+    S
+  );
+  return (
+    /** @type {() => V} */
+    (function(g, m) {
+      if (arguments.length > 0) {
+        const y = m ? L(w) : i && f ? we(g) : g;
+        return Z(w, y), p = !0, a !== void 0 && (a = y), g;
+      }
+      return ge && p || (T.f & he) !== 0 ? w.v : L(w);
+    })
+  );
+}
+export {
+  Fi as $,
+  S as A,
+  vi as B,
+  en as C,
+  Be as D,
+  Pe as E,
+  xr as F,
+  gt as G,
+  Zi as H,
+  af as I,
+  pf as J,
+  lf as K,
+  mt as L,
+  Vt as M,
+  Ie as N,
+  it as O,
+  G as P,
+  Bi as Q,
+  Ze as R,
+  X as S,
+  Hr as T,
+  Gt as U,
+  li as V,
+  rf as W,
+  k as X,
+  kt as Y,
+  hf as Z,
+  tf as _,
+  cf as a,
+  wf as a0,
+  uf as a1,
+  gf as a2,
+  Ef as a3,
+  Ki as a4,
+  Hi as a5,
+  yf as a6,
+  sf as b,
+  Wi as c,
+  zi as d,
+  nf as e,
+  ff as f,
+  L as g,
+  _r as h,
+  bf as i,
+  mf as j,
+  df as k,
+  Xi as l,
+  Dr as m,
+  Di as n,
+  of as o,
+  Gi as p,
+  _f as q,
+  vf as r,
+  Z as s,
+  ef as t,
+  Je as u,
+  gi as v,
+  Yt as w,
+  Ji as x,
+  Qi as y,
+  Ri as z
+};