zabi-components 1.0.0

package/dist/index-DInFKA3g.js

@@ -0,0 +1,2645 @@
+var vn = Object.defineProperty;
+var Qe = (t) => {
+  throw TypeError(t);
+};
+var _n = (t, e, r) => e in t ? vn(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var $t = (t, e, r) => _n(t, typeof e != "symbol" ? e + "" : e, r), me = (t, e, r) => e.has(t) || Qe("Cannot " + r);
+var O = (t, e, r) => (me(t, e, "read from private field"), r ? r.call(t) : e.get(t)), L = (t, e, r) => e.has(t) ? Qe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), j = (t, e, r, n) => (me(t, e, "write to private field"), n ? n.call(t, r) : e.set(t, r), r), ot = (t, e, r) => (me(t, e, "access private method"), r);
+var gr;
+typeof window < "u" && ((gr = window.__svelte ?? (window.__svelte = {})).v ?? (gr.v = /* @__PURE__ */ new Set())).add("5");
+let Gt = !1, dn = !1;
+function pn() {
+  Gt = !0;
+}
+pn();
+const oe = 1, ce = 2, br = 4, hn = 8, wn = 16, gn = 1, bn = 2, yn = 4, En = 8, mn = 16, An = 4, Sn = 1, Tn = 2, P = Symbol(), On = "http://www.w3.org/1999/xhtml", zi = "http://www.w3.org/2000/svg", Pn = "@attach", yr = !1;
+var ve = Array.isArray, Cn = Array.prototype.indexOf, Er = Array.from, Ce = Object.defineProperty, mt = Object.getOwnPropertyDescriptor, mr = Object.getOwnPropertyDescriptors, Nn = Object.prototype, kn = Array.prototype, Fe = Object.getPrototypeOf;
+function bt(t) {
+  return typeof t == "function";
+}
+const Mt = () => {
+};
+function In(t) {
+  return t();
+}
+function Ne(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function Rn() {
+  var t, e, r = new Promise((n, i) => {
+    t = n, e = i;
+  });
+  return { promise: r, resolve: t, reject: e };
+}
+function Zi(t, e) {
+  if (Array.isArray(t))
+    return t;
+  if (!(Symbol.iterator in t))
+    return Array.from(t);
+  const r = [];
+  for (const n of t)
+    if (r.push(n), r.length === e) break;
+  return r;
+}
+const x = 2, De = 4, _e = 8, ht = 16, tt = 32, kt = 64, Ar = 128, q = 256, ie = 512, k = 1024, V = 2048, et = 4096, H = 8192, wt = 16384, de = 32768, pe = 65536, tr = 1 << 17, $n = 1 << 18, he = 1 << 19, Sr = 1 << 20, ke = 1 << 21, xe = 1 << 22, _t = 1 << 23, Q = Symbol("$state"), Tr = Symbol("legacy props"), Mn = Symbol(""), je = new class extends Error {
+  constructor() {
+    super(...arguments);
+    $t(this, "name", "StaleReactionError");
+    $t(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 Fn(t) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Dn() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function xn(t) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function jn() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Un(t) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function qn() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Vn() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Bn() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Hn() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+let Yn = !1;
+function Or(t) {
+  return t === this.v;
+}
+function Wn(t, e) {
+  return t != t ? e == e : t !== e || t !== null && typeof t == "object" || typeof t == "function";
+}
+function Pr(t) {
+  return !Wn(t, this.v);
+}
+let C = null;
+function fe(t) {
+  C = t;
+}
+function Ji(t, e = !1, r) {
+  C = {
+    p: C,
+    c: null,
+    e: null,
+    s: t,
+    x: null,
+    l: Gt && !e ? { s: null, u: null, $: [] } : null
+  };
+}
+function Qi(t) {
+  var e = (
+    /** @type {ComponentContext} */
+    C
+  ), r = e.e;
+  if (r !== null) {
+    e.e = null;
+    for (var n of r)
+      xr(n);
+  }
+  return t !== void 0 && (e.x = t), C = e.p, t ?? /** @type {T} */
+  {};
+}
+function Kt() {
+  return !Gt || C !== null && C.l === null;
+}
+let yt = [];
+function Gn() {
+  var t = yt;
+  yt = [], Ne(t);
+}
+function zt(t) {
+  if (yt.length === 0) {
+    var e = yt;
+    queueMicrotask(() => {
+      e === yt && Gn();
+    });
+  }
+  yt.push(t);
+}
+const Kn = /* @__PURE__ */ new WeakMap();
+function zn(t) {
+  var e = S;
+  if (e === null)
+    return A.f |= _t, t;
+  if ((e.f & de) === 0) {
+    if ((e.f & Ar) === 0)
+      throw !e.parent && t instanceof Error && Cr(t), t;
+    e.b.error(t);
+  } else
+    ae(t, e);
+}
+function ae(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & Ar) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (r) {
+        t = r;
+      }
+    e = e.parent;
+  }
+  throw t instanceof Error && Cr(t), t;
+}
+function Cr(t) {
+  const e = Kn.get(t);
+  e && (Ce(t, "message", {
+    value: e.message
+  }), Ce(t, "stack", {
+    value: e.stack
+  }));
+}
+const Ae = /* @__PURE__ */ new Set();
+let N = null, er = /* @__PURE__ */ new Set(), Dt = [], Ue = null, Ie = !1;
+var Vt, St, ft, Bt, Ht, ct, Tt, vt, at, Ot, Yt, Wt, Y, Nr, ne, Re;
+const le = class le {
+  constructor() {
+    L(this, Y);
+    /**
+     * 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>}
+     */
+    $t(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>}
+     */
+    L(this, Vt, /* @__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>}
+     */
+    L(this, St, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    L(this, ft, 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}
+     */
+    L(this, Bt, null);
+    /**
+     * True if an async effect inside this batch resolved and
+     * its parent branch was already deleted
+     */
+    L(this, Ht, !1);
+    /**
+     * Async effects (created inside `async_derived`) encountered during processing.
+     * These run after the rest of the batch has updated, since they should
+     * always have the latest values
+     * @type {Effect[]}
+     */
+    L(this, ct, []);
+    /**
+     * The same as `#async_effects`, but for effects inside a newly-created
+     * `<svelte:boundary>` — these do not prevent the batch from committing
+     * @type {Effect[]}
+     */
+    L(this, Tt, []);
+    /**
+     * Template effects and `$effect.pre` effects, which run when
+     * a batch is committed
+     * @type {Effect[]}
+     */
+    L(this, vt, []);
+    /**
+     * The same as `#render_effects`, but for `$effect` (which runs after)
+     * @type {Effect[]}
+     */
+    L(this, at, []);
+    /**
+     * Block effects, which may need to re-run on subsequent flushes
+     * in order to update internal sources (e.g. each block items)
+     * @type {Effect[]}
+     */
+    L(this, Ot, []);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Effect[]}
+     */
+    L(this, Yt, []);
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Effect[]}
+     */
+    L(this, Wt, []);
+    /**
+     * 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>}
+     */
+    $t(this, "skipped_effects", /* @__PURE__ */ new Set());
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(e) {
+    var i;
+    Dt = [];
+    for (const f of e)
+      ot(this, Y, Nr).call(this, f);
+    if (O(this, ct).length === 0 && O(this, ft) === 0) {
+      ot(this, Y, Re).call(this);
+      var r = O(this, vt), n = O(this, at);
+      j(this, vt, []), j(this, at, []), j(this, Ot, []), N = null, rr(r), rr(n), N === null ? N = this : Ae.delete(this), (i = O(this, Bt)) == null || i.resolve();
+    } else
+      ot(this, Y, ne).call(this, O(this, vt)), ot(this, Y, ne).call(this, O(this, at)), ot(this, Y, ne).call(this, O(this, Ot));
+    for (const f of O(this, ct))
+      pt(f);
+    for (const f of O(this, Tt))
+      pt(f);
+    j(this, ct, []), j(this, Tt, []);
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(e, r) {
+    O(this, Vt).has(e) || O(this, Vt).set(e, r), this.current.set(e, e.v);
+  }
+  activate() {
+    N = this;
+  }
+  deactivate() {
+    N = null;
+    for (const e of er)
+      if (er.delete(e), e(), N !== null)
+        break;
+  }
+  neuter() {
+    j(this, Ht, !0);
+  }
+  flush() {
+    Dt.length > 0 ? Zn() : ot(this, Y, Re).call(this), N === this && (O(this, ft) === 0 && Ae.delete(this), this.deactivate());
+  }
+  increment() {
+    j(this, ft, O(this, ft) + 1);
+  }
+  decrement() {
+    if (j(this, ft, O(this, ft) - 1), O(this, ft) === 0) {
+      for (const e of O(this, Yt))
+        $(e, V), Pt(e);
+      for (const e of O(this, Wt))
+        $(e, et), Pt(e);
+      j(this, vt, []), j(this, at, []), this.flush();
+    } else
+      this.deactivate();
+  }
+  /** @param {() => void} fn */
+  add_callback(e) {
+    O(this, St).add(e);
+  }
+  settled() {
+    return (O(this, Bt) ?? j(this, Bt, Rn())).promise;
+  }
+  static ensure() {
+    if (N === null) {
+      const e = N = new le();
+      Ae.add(N), le.enqueue(() => {
+        N === e && e.flush();
+      });
+    }
+    return N;
+  }
+  /** @param {() => void} task */
+  static enqueue(e) {
+    zt(e);
+  }
+};
+Vt = new WeakMap(), St = new WeakMap(), ft = new WeakMap(), Bt = new WeakMap(), Ht = new WeakMap(), ct = new WeakMap(), Tt = new WeakMap(), vt = new WeakMap(), at = new WeakMap(), Ot = new WeakMap(), Yt = new WeakMap(), Wt = new WeakMap(), Y = new WeakSet(), /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ */
+Nr = function(e) {
+  var o;
+  e.f ^= k;
+  for (var r = e.first; r !== null; ) {
+    var n = r.f, i = (n & (tt | kt)) !== 0, f = i && (n & k) !== 0, a = f || (n & H) !== 0 || this.skipped_effects.has(r);
+    if (!a && r.fn !== null) {
+      if (i)
+        r.f ^= k;
+      else if ((n & De) !== 0)
+        O(this, at).push(r);
+      else if ((n & k) === 0)
+        if ((n & xe) !== 0) {
+          var l = (o = r.b) != null && o.is_pending() ? O(this, Tt) : O(this, ct);
+          l.push(r);
+        } else Jt(r) && ((r.f & ht) !== 0 && O(this, Ot).push(r), pt(r));
+      var u = r.first;
+      if (u !== null) {
+        r = u;
+        continue;
+      }
+    }
+    var s = r.parent;
+    for (r = r.next; r === null && s !== null; )
+      r = s.next, s = s.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+ne = function(e) {
+  for (const r of e)
+    ((r.f & V) !== 0 ? O(this, Yt) : O(this, Wt)).push(r), $(r, k);
+  e.length = 0;
+}, /**
+ * Append and remove branches to/from the DOM
+ */
+Re = function() {
+  if (!O(this, Ht))
+    for (const e of O(this, St))
+      e();
+  O(this, St).clear();
+};
+let se = le;
+function Zn() {
+  var t = At;
+  Ie = !0;
+  try {
+    var e = 0;
+    for (ar(!0); Dt.length > 0; ) {
+      var r = se.ensure();
+      if (e++ > 1e3) {
+        var n, i;
+        Xn();
+      }
+      r.process(Dt), ut.clear();
+    }
+  } finally {
+    Ie = !1, ar(t), Ue = null;
+  }
+}
+function Xn() {
+  try {
+    jn();
+  } catch (t) {
+    ae(t, Ue);
+  }
+}
+let Z = null;
+function rr(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var r = 0; r < e; ) {
+      var n = t[r++];
+      if ((n.f & (wt | H)) === 0 && Jt(n) && (Z = [], pt(n), n.deps === null && n.first === null && n.nodes_start === null && (n.teardown === null && n.ac === null ? Vr(n) : n.fn = null), (Z == null ? void 0 : Z.length) > 0)) {
+        ut.clear();
+        for (const i of Z)
+          pt(i);
+        Z = [];
+      }
+    }
+    Z = null;
+  }
+}
+function Pt(t) {
+  for (var e = Ue = t; e.parent !== null; ) {
+    e = e.parent;
+    var r = e.f;
+    if (Ie && e === S && (r & ht) !== 0)
+      return;
+    if ((r & (kt | tt)) !== 0) {
+      if ((r & k) === 0) return;
+      e.f ^= k;
+    }
+  }
+  Dt.push(e);
+}
+function kr(t, e, r) {
+  const n = Kt() ? Zt : qe;
+  if (e.length === 0) {
+    r(t.map(n));
+    return;
+  }
+  var i = N, f = (
+    /** @type {Effect} */
+    S
+  ), a = Jn();
+  Promise.all(e.map((l) => /* @__PURE__ */ Qn(l))).then((l) => {
+    i == null || i.activate(), a();
+    try {
+      r([...t.map(n), ...l]);
+    } catch (u) {
+      (f.f & wt) === 0 && ae(u, f);
+    }
+    i == null || i.deactivate(), Ir();
+  }).catch((l) => {
+    ae(l, f);
+  });
+}
+function Jn() {
+  var t = S, e = A, r = C, n = N;
+  return function() {
+    lt(t), z(e), fe(r), n == null || n.activate();
+  };
+}
+function Ir() {
+  lt(null), z(null), fe(null);
+}
+// @__NO_SIDE_EFFECTS__
+function Zt(t) {
+  var e = x | V, r = A !== null && (A.f & x) !== 0 ? (
+    /** @type {Derived} */
+    A
+  ) : null;
+  return S === null || r !== null && (r.f & q) !== 0 ? e |= q : S.f |= he, {
+    ctx: C,
+    deps: null,
+    effects: null,
+    equals: Or,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      P
+    ),
+    wv: 0,
+    parent: r ?? S,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Qn(t, e) {
+  let r = (
+    /** @type {Effect | null} */
+    S
+  );
+  r === null && Ln();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), f = xt(
+    /** @type {V} */
+    P
+  ), a = null, l = !A;
+  return ci(() => {
+    try {
+      var u = t();
+      a && Promise.resolve(u).catch(() => {
+      });
+    } catch (p) {
+      u = Promise.reject(p);
+    }
+    var s = () => u;
+    i = (a == null ? void 0 : a.then(s, s)) ?? Promise.resolve(u), a = i;
+    var o = (
+      /** @type {Batch} */
+      N
+    ), v = n.is_pending();
+    l && (n.update_pending_count(1), v || o.increment());
+    const _ = (p, c = void 0) => {
+      a = null, v || o.activate(), c ? c !== je && (f.f |= _t, jt(f, c)) : ((f.f & _t) !== 0 && (f.f ^= _t), jt(f, p)), l && (n.update_pending_count(-1), v || o.decrement()), Ir();
+    };
+    if (i.then(_, (p) => _(null, p || "unknown")), o)
+      return () => {
+        queueMicrotask(() => o.neuter());
+      };
+  }), new Promise((u) => {
+    function s(o) {
+      function v() {
+        o === i ? u(f) : s(i);
+      }
+      o.then(v, v);
+    }
+    s(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function tf(t) {
+  const e = /* @__PURE__ */ Zt(t);
+  return Wr(e), e;
+}
+// @__NO_SIDE_EFFECTS__
+function qe(t) {
+  const e = /* @__PURE__ */ Zt(t);
+  return e.equals = Pr, e;
+}
+function Rr(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var r = 0; r < e.length; r += 1)
+      K(
+        /** @type {Effect} */
+        e[r]
+      );
+  }
+}
+function ti(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & x) === 0)
+      return (
+        /** @type {Effect} */
+        e
+      );
+    e = e.parent;
+  }
+  return null;
+}
+function Ve(t) {
+  var e, r = S;
+  lt(ti(t));
+  try {
+    Rr(t), e = Zr(t);
+  } finally {
+    lt(r);
+  }
+  return e;
+}
+function $r(t) {
+  var e = Ve(t);
+  if (t.equals(e) || (t.v = e, t.wv = Kr()), !gt) {
+    var r = (st || (t.f & q) !== 0) && t.deps !== null ? et : k;
+    $(t, r);
+  }
+}
+const ut = /* @__PURE__ */ new Map();
+function xt(t, e) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: Or,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function it(t, e) {
+  const r = xt(t);
+  return Wr(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function ei(t, e = !1, r = !0) {
+  var i;
+  const n = xt(t);
+  return e || (n.equals = Pr), Gt && r && C !== null && C.l !== null && ((i = C.l).s ?? (i.s = [])).push(n), n;
+}
+function ef(t, e) {
+  return X(
+    t,
+    Qt(() => F(t))
+  ), e;
+}
+function X(t, e, 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
+  (!G || (A.f & tr) !== 0) && Kt() && (A.f & (x | ht | xe | tr)) !== 0 && !(R != null && R.includes(t)) && Bn();
+  let n = r ? Et(e) : e;
+  return jt(t, n);
+}
+function jt(t, e) {
+  if (!t.equals(e)) {
+    var r = t.v;
+    gt ? ut.set(t, e) : ut.set(t, r), t.v = e;
+    var n = se.ensure();
+    n.capture(t, r), (t.f & x) !== 0 && ((t.f & V) !== 0 && Ve(
+      /** @type {Derived} */
+      t
+    ), $(t, (t.f & q) === 0 ? k : et)), t.wv = Kr(), Mr(t, V), Kt() && S !== null && (S.f & k) !== 0 && (S.f & (tt | kt)) === 0 && (U === null ? di([t]) : U.push(t));
+  }
+  return e;
+}
+function Se(t) {
+  X(t, t.v + 1);
+}
+function Mr(t, e) {
+  var r = t.reactions;
+  if (r !== null)
+    for (var n = Kt(), i = r.length, f = 0; f < i; f++) {
+      var a = r[f], l = a.f;
+      if (!(!n && a === S)) {
+        var u = (l & V) === 0;
+        u && $(a, e), (l & x) !== 0 ? Mr(
+          /** @type {Derived} */
+          a,
+          et
+        ) : u && ((l & ht) !== 0 && Z !== null && Z.push(
+          /** @type {Effect} */
+          a
+        ), Pt(
+          /** @type {Effect} */
+          a
+        ));
+      }
+    }
+}
+function Et(t) {
+  if (typeof t != "object" || t === null || Q in t)
+    return t;
+  const e = Fe(t);
+  if (e !== Nn && e !== kn)
+    return t;
+  var r = /* @__PURE__ */ new Map(), n = ve(t), i = /* @__PURE__ */ it(0), f = dt, a = (l) => {
+    if (dt === f)
+      return l();
+    var u = A, s = dt;
+    z(null), ur(f);
+    var o = l();
+    return z(u), ur(s), o;
+  };
+  return n && r.set("length", /* @__PURE__ */ it(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(l, u, s) {
+        (!("value" in s) || s.configurable === !1 || s.enumerable === !1 || s.writable === !1) && qn();
+        var o = r.get(u);
+        return o === void 0 ? o = a(() => {
+          var v = /* @__PURE__ */ it(s.value);
+          return r.set(u, v), v;
+        }) : X(o, s.value, !0), !0;
+      },
+      deleteProperty(l, u) {
+        var s = r.get(u);
+        if (s === void 0) {
+          if (u in l) {
+            const o = a(() => /* @__PURE__ */ it(P));
+            r.set(u, o), Se(i);
+          }
+        } else
+          X(s, P), Se(i);
+        return !0;
+      },
+      get(l, u, s) {
+        var p;
+        if (u === Q)
+          return t;
+        var o = r.get(u), v = u in l;
+        if (o === void 0 && (!v || (p = mt(l, u)) != null && p.writable) && (o = a(() => {
+          var c = Et(v ? l[u] : P), d = /* @__PURE__ */ it(c);
+          return d;
+        }), r.set(u, o)), o !== void 0) {
+          var _ = F(o);
+          return _ === P ? void 0 : _;
+        }
+        return Reflect.get(l, u, s);
+      },
+      getOwnPropertyDescriptor(l, u) {
+        var s = Reflect.getOwnPropertyDescriptor(l, u);
+        if (s && "value" in s) {
+          var o = r.get(u);
+          o && (s.value = F(o));
+        } else if (s === void 0) {
+          var v = r.get(u), _ = v == null ? void 0 : v.v;
+          if (v !== void 0 && _ !== P)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: _,
+              writable: !0
+            };
+        }
+        return s;
+      },
+      has(l, u) {
+        var _;
+        if (u === Q)
+          return !0;
+        var s = r.get(u), o = s !== void 0 && s.v !== P || Reflect.has(l, u);
+        if (s !== void 0 || S !== null && (!o || (_ = mt(l, u)) != null && _.writable)) {
+          s === void 0 && (s = a(() => {
+            var p = o ? Et(l[u]) : P, c = /* @__PURE__ */ it(p);
+            return c;
+          }), r.set(u, s));
+          var v = F(s);
+          if (v === P)
+            return !1;
+        }
+        return o;
+      },
+      set(l, u, s, o) {
+        var g;
+        var v = r.get(u), _ = u in l;
+        if (n && u === "length")
+          for (var p = s; p < /** @type {Source<number>} */
+          v.v; p += 1) {
+            var c = r.get(p + "");
+            c !== void 0 ? X(c, P) : p in l && (c = a(() => /* @__PURE__ */ it(P)), r.set(p + "", c));
+          }
+        if (v === void 0)
+          (!_ || (g = mt(l, u)) != null && g.writable) && (v = a(() => /* @__PURE__ */ it(void 0)), X(v, Et(s)), r.set(u, v));
+        else {
+          _ = v.v !== P;
+          var d = a(() => Et(s));
+          X(v, d);
+        }
+        var h = Reflect.getOwnPropertyDescriptor(l, u);
+        if (h != null && h.set && h.set.call(o, s), !_) {
+          if (n && typeof u == "string") {
+            var w = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), T = Number(u);
+            Number.isInteger(T) && T >= w.v && X(w, T + 1);
+          }
+          Se(i);
+        }
+        return !0;
+      },
+      ownKeys(l) {
+        F(i);
+        var u = Reflect.ownKeys(l).filter((v) => {
+          var _ = r.get(v);
+          return _ === void 0 || _.v !== P;
+        });
+        for (var [s, o] of r)
+          o.v !== P && !(s in l) && u.push(s);
+        return u;
+      },
+      setPrototypeOf() {
+        Vn();
+      }
+    }
+  );
+}
+function nr(t) {
+  try {
+    if (t !== null && typeof t == "object" && Q in t)
+      return t[Q];
+  } catch {
+  }
+  return t;
+}
+function ri(t, e) {
+  return Object.is(nr(t), nr(e));
+}
+var ni, ii, fi;
+function Xt(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Ct(t) {
+  return ii.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function we(t) {
+  return fi.call(t);
+}
+function rf(t, e) {
+  return /* @__PURE__ */ Ct(t);
+}
+function nf(t, e = !1) {
+  {
+    var r = (
+      /** @type {DocumentFragment} */
+      /* @__PURE__ */ Ct(
+        /** @type {Node} */
+        t
+      )
+    );
+    return r instanceof Comment && r.data === "" ? /* @__PURE__ */ we(r) : r;
+  }
+}
+function ff(t, e = 1, r = !1) {
+  let n = t;
+  for (; e--; )
+    n = /** @type {TemplateNode} */
+    /* @__PURE__ */ we(n);
+  return n;
+}
+function ai(t) {
+  t.textContent = "";
+}
+function Lr() {
+  return !1;
+}
+function si(t, e) {
+  if (e) {
+    const r = document.body;
+    t.autofocus = !0, zt(() => {
+      document.activeElement === r && t.focus();
+    });
+  }
+}
+let ir = !1;
+function ui() {
+  ir || (ir = !0, document.addEventListener(
+    "reset",
+    (t) => {
+      Promise.resolve().then(() => {
+        var e;
+        if (!t.defaultPrevented)
+          for (
+            const r of
+            /**@type {HTMLFormElement} */
+            t.target.elements
+          )
+            (e = r.__on_r) == null || e.call(r);
+      });
+    },
+    // In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
+    { capture: !0 }
+  ));
+}
+function It(t) {
+  var e = A, r = S;
+  z(null), lt(null);
+  try {
+    return t();
+  } finally {
+    z(e), lt(r);
+  }
+}
+function af(t, e, r, n = r) {
+  t.addEventListener(e, () => It(r));
+  const i = t.__on_r;
+  i ? t.__on_r = () => {
+    i(), n(!0);
+  } : t.__on_r = () => n(!0), ui();
+}
+function Fr(t) {
+  S === null && A === null && xn(), A !== null && (A.f & q) !== 0 && S === null && Dn(), gt && Fn();
+}
+function li(t, e) {
+  var r = e.last;
+  r === null ? e.last = e.first = t : (r.next = t, t.prev = r, e.last = t);
+}
+function rt(t, e, r, n = !0) {
+  var i = S;
+  i !== null && (i.f & H) !== 0 && (t |= H);
+  var f = {
+    ctx: C,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | V,
+    first: null,
+    fn: e,
+    last: null,
+    next: null,
+    parent: i,
+    b: i && i.b,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    wv: 0,
+    ac: null
+  };
+  if (r)
+    try {
+      pt(f), f.f |= de;
+    } catch (u) {
+      throw K(f), u;
+    }
+  else e !== null && Pt(f);
+  if (n) {
+    var a = f;
+    if (r && a.deps === null && a.teardown === null && a.nodes_start === null && a.first === a.last && // either `null`, or a singular child
+    (a.f & he) === 0 && (a = a.first), a !== null && (a.parent = i, i !== null && li(a, i), A !== null && (A.f & x) !== 0 && (t & kt) === 0)) {
+      var l = (
+        /** @type {Derived} */
+        A
+      );
+      (l.effects ?? (l.effects = [])).push(a);
+    }
+  }
+  return f;
+}
+function Dr(t) {
+  const e = rt(_e, null, !1);
+  return $(e, k), e.teardown = t, e;
+}
+function fr(t) {
+  Fr();
+  var e = (
+    /** @type {Effect} */
+    S.f
+  ), r = !A && (e & tt) !== 0 && (e & de) === 0;
+  if (r) {
+    var n = (
+      /** @type {ComponentContext} */
+      C
+    );
+    (n.e ?? (n.e = [])).push(t);
+  } else
+    return xr(t);
+}
+function xr(t) {
+  return rt(De | Sr, t, !1);
+}
+function oi(t) {
+  return Fr(), rt(_e | Sr, t, !0);
+}
+function Be(t) {
+  return rt(De, t, !1);
+}
+function sf(t, e) {
+  var r = (
+    /** @type {ComponentContextLegacy} */
+    C
+  ), n = { effect: null, ran: !1, deps: t };
+  r.l.$.push(n), n.effect = jr(() => {
+    t(), !n.ran && (n.ran = !0, Qt(e));
+  });
+}
+function uf() {
+  var t = (
+    /** @type {ComponentContextLegacy} */
+    C
+  );
+  jr(() => {
+    for (var e of t.l.$) {
+      e.deps();
+      var r = e.effect;
+      (r.f & k) !== 0 && $(r, et), Jt(r) && pt(r), e.ran = !1;
+    }
+  });
+}
+function ci(t) {
+  return rt(xe | he, t, !0);
+}
+function jr(t, e = 0) {
+  return rt(_e | e, t, !0);
+}
+function lf(t, e = [], r = []) {
+  kr(e, r, (n) => {
+    rt(_e, () => t(...n.map(F)), !0);
+  });
+}
+function ge(t, e = 0) {
+  var r = rt(ht | e, t, !0);
+  return r;
+}
+function Nt(t, e = !0) {
+  return rt(tt | he, t, !0, e);
+}
+function Ur(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const r = gt, n = A;
+    sr(!0), z(null);
+    try {
+      e.call(null);
+    } finally {
+      sr(r), z(n);
+    }
+  }
+}
+function qr(t, e = !1) {
+  var r = t.first;
+  for (t.first = t.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && It(() => {
+      i.abort(je);
+    });
+    var n = r.next;
+    (r.f & kt) !== 0 ? r.parent = null : K(r, e), r = n;
+  }
+}
+function vi(t) {
+  for (var e = t.first; e !== null; ) {
+    var r = e.next;
+    (e.f & tt) === 0 && K(e), e = r;
+  }
+}
+function K(t, e = !0) {
+  var r = !1;
+  (e || (t.f & $n) !== 0) && t.nodes_start !== null && t.nodes_end !== null && (_i(
+    t.nodes_start,
+    /** @type {TemplateNode} */
+    t.nodes_end
+  ), r = !0), qr(t, e && !r), ue(t, 0), $(t, wt);
+  var n = t.transitions;
+  if (n !== null)
+    for (const f of n)
+      f.stop();
+  Ur(t);
+  var i = t.parent;
+  i !== null && i.first !== null && Vr(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes_start = t.nodes_end = t.ac = null;
+}
+function _i(t, e) {
+  for (; t !== null; ) {
+    var r = t === e ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ we(t)
+    );
+    t.remove(), t = r;
+  }
+}
+function Vr(t) {
+  var e = t.parent, r = t.prev, n = t.next;
+  r !== null && (r.next = n), n !== null && (n.prev = r), e !== null && (e.first === t && (e.first = n), e.last === t && (e.last = r));
+}
+function Br(t, e) {
+  var r = [];
+  He(t, r, !0), Hr(r, () => {
+    K(t), e && e();
+  });
+}
+function Hr(t, e) {
+  var r = t.length;
+  if (r > 0) {
+    var n = () => --r || e();
+    for (var i of t)
+      i.out(n);
+  } else
+    e();
+}
+function He(t, e, r) {
+  if ((t.f & H) === 0) {
+    if (t.f ^= H, t.transitions !== null)
+      for (const a of t.transitions)
+        (a.is_global || r) && e.push(a);
+    for (var n = t.first; n !== null; ) {
+      var i = n.next, f = (n.f & pe) !== 0 || (n.f & tt) !== 0;
+      He(n, e, f ? r : !1), n = i;
+    }
+  }
+}
+function Ye(t) {
+  Yr(t, !0);
+}
+function Yr(t, e) {
+  if ((t.f & H) !== 0) {
+    t.f ^= H, (t.f & k) === 0 && ($(t, V), Pt(t));
+    for (var r = t.first; r !== null; ) {
+      var n = r.next, i = (r.f & pe) !== 0 || (r.f & tt) !== 0;
+      Yr(r, i ? e : !1), r = n;
+    }
+    if (t.transitions !== null)
+      for (const f of t.transitions)
+        (f.is_global || e) && f.in();
+  }
+}
+let At = !1;
+function ar(t) {
+  At = t;
+}
+let gt = !1;
+function sr(t) {
+  gt = t;
+}
+let A = null, G = !1;
+function z(t) {
+  A = t;
+}
+let S = null;
+function lt(t) {
+  S = t;
+}
+let R = null;
+function Wr(t) {
+  A !== null && (R === null ? R = [t] : R.push(t));
+}
+let I = null, D = 0, U = null;
+function di(t) {
+  U = t;
+}
+let Gr = 1, Ut = 0, dt = Ut;
+function ur(t) {
+  dt = t;
+}
+let st = !1;
+function Kr() {
+  return ++Gr;
+}
+function Jt(t) {
+  var v;
+  var e = t.f;
+  if ((e & V) !== 0)
+    return !0;
+  if ((e & et) !== 0) {
+    var r = t.deps, n = (e & q) !== 0;
+    if (r !== null) {
+      var i, f, a = (e & ie) !== 0, l = n && S !== null && !st, u = r.length;
+      if ((a || l) && (S === null || (S.f & wt) === 0)) {
+        var s = (
+          /** @type {Derived} */
+          t
+        ), o = s.parent;
+        for (i = 0; i < u; i++)
+          f = r[i], (a || !((v = f == null ? void 0 : f.reactions) != null && v.includes(s))) && (f.reactions ?? (f.reactions = [])).push(s);
+        a && (s.f ^= ie), l && o !== null && (o.f & q) === 0 && (s.f ^= q);
+      }
+      for (i = 0; i < u; i++)
+        if (f = r[i], Jt(
+          /** @type {Derived} */
+          f
+        ) && $r(
+          /** @type {Derived} */
+          f
+        ), f.wv > t.wv)
+          return !0;
+    }
+    (!n || S !== null && !st) && $(t, k);
+  }
+  return !1;
+}
+function zr(t, e, r = !0) {
+  var n = t.reactions;
+  if (n !== null && !(R != null && R.includes(t)))
+    for (var i = 0; i < n.length; i++) {
+      var f = n[i];
+      (f.f & x) !== 0 ? zr(
+        /** @type {Derived} */
+        f,
+        e,
+        !1
+      ) : e === f && (r ? $(f, V) : (f.f & k) !== 0 && $(f, et), Pt(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function Zr(t) {
+  var d;
+  var e = I, r = D, n = U, i = A, f = st, a = R, l = C, u = G, s = dt, o = t.f;
+  I = /** @type {null | Value[]} */
+  null, D = 0, U = null, st = (o & q) !== 0 && (G || !At || A === null), A = (o & (tt | kt)) === 0 ? t : null, R = null, fe(t.ctx), G = !1, dt = ++Ut, t.ac !== null && (It(() => {
+    t.ac.abort(je);
+  }), t.ac = null);
+  try {
+    t.f |= ke;
+    var v = (
+      /** @type {Function} */
+      t.fn
+    ), _ = v(), p = t.deps;
+    if (I !== null) {
+      var c;
+      if (ue(t, D), p !== null && D > 0)
+        for (p.length = D + I.length, c = 0; c < I.length; c++)
+          p[D + c] = I[c];
+      else
+        t.deps = p = I;
+      if (!st || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (o & x) !== 0 && /** @type {import('#client').Derived} */
+      t.reactions !== null)
+        for (c = D; c < p.length; c++)
+          ((d = p[c]).reactions ?? (d.reactions = [])).push(t);
+    } else p !== null && D < p.length && (ue(t, D), p.length = D);
+    if (Kt() && U !== null && !G && p !== null && (t.f & (x | et | V)) === 0)
+      for (c = 0; c < /** @type {Source[]} */
+      U.length; c++)
+        zr(
+          U[c],
+          /** @type {Effect} */
+          t
+        );
+    return i !== null && i !== t && (Ut++, U !== null && (n === null ? n = U : n.push(.../** @type {Source[]} */
+    U))), (t.f & _t) !== 0 && (t.f ^= _t), _;
+  } catch (h) {
+    return zn(h);
+  } finally {
+    t.f ^= ke, I = e, D = r, U = n, A = i, st = f, R = a, fe(l), G = u, dt = s;
+  }
+}
+function pi(t, e) {
+  let r = e.reactions;
+  if (r !== null) {
+    var n = Cn.call(r, t);
+    if (n !== -1) {
+      var i = r.length - 1;
+      i === 0 ? r = e.reactions = null : (r[n] = r[i], r.pop());
+    }
+  }
+  r === null && (e.f & x) !== 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
+  (I === null || !I.includes(e)) && ($(e, et), (e.f & (q | ie)) === 0 && (e.f ^= ie), Rr(
+    /** @type {Derived} **/
+    e
+  ), ue(
+    /** @type {Derived} **/
+    e,
+    0
+  ));
+}
+function ue(t, e) {
+  var r = t.deps;
+  if (r !== null)
+    for (var n = e; n < r.length; n++)
+      pi(t, r[n]);
+}
+function pt(t) {
+  var e = t.f;
+  if ((e & wt) === 0) {
+    $(t, k);
+    var r = S, n = At;
+    S = t, At = !0;
+    try {
+      (e & ht) !== 0 ? vi(t) : qr(t), Ur(t);
+      var i = Zr(t);
+      t.teardown = typeof i == "function" ? i : null, t.wv = Gr;
+      var f;
+      yr && dn && (t.f & V) !== 0 && t.deps;
+    } finally {
+      At = n, S = r;
+    }
+  }
+}
+function F(t) {
+  var e = t.f, r = (e & x) !== 0;
+  if (A !== null && !G) {
+    var n = S !== null && (S.f & wt) !== 0;
+    if (!n && !(R != null && R.includes(t))) {
+      var i = A.deps;
+      if ((A.f & ke) !== 0)
+        t.rv < Ut && (t.rv = Ut, I === null && i !== null && i[D] === t ? D++ : I === null ? I = [t] : (!st || !I.includes(t)) && I.push(t));
+      else {
+        (A.deps ?? (A.deps = [])).push(t);
+        var f = t.reactions;
+        f === null ? t.reactions = [A] : f.includes(A) || f.push(A);
+      }
+    }
+  } else if (r && /** @type {Derived} */
+  t.deps === null && /** @type {Derived} */
+  t.effects === null) {
+    var a = (
+      /** @type {Derived} */
+      t
+    ), l = a.parent;
+    l !== null && (l.f & q) === 0 && (a.f ^= q);
+  }
+  if (gt) {
+    if (ut.has(t))
+      return ut.get(t);
+    if (r) {
+      a = /** @type {Derived} */
+      t;
+      var u = a.v;
+      return ((a.f & k) === 0 && a.reactions !== null || Xr(a)) && (u = Ve(a)), ut.set(a, u), u;
+    }
+  } else r && (a = /** @type {Derived} */
+  t, Jt(a) && $r(a));
+  if ((t.f & _t) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Xr(t) {
+  if (t.v === P) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (ut.has(e) || (e.f & x) !== 0 && Xr(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+function Qt(t) {
+  var e = G;
+  try {
+    return G = !0, t();
+  } finally {
+    G = e;
+  }
+}
+const hi = -7169;
+function $(t, e) {
+  t.f = t.f & hi | e;
+}
+function wi(t) {
+  if (!(typeof t != "object" || !t || t instanceof EventTarget)) {
+    if (Q in t)
+      $e(t);
+    else if (!Array.isArray(t))
+      for (let e in t) {
+        const r = t[e];
+        typeof r == "object" && r && Q in r && $e(r);
+      }
+  }
+}
+function $e(t, e = /* @__PURE__ */ new Set()) {
+  if (typeof t == "object" && t !== null && // We don't want to traverse DOM elements
+  !(t instanceof EventTarget) && !e.has(t)) {
+    e.add(t), t instanceof Date && t.getTime();
+    for (let n in t)
+      try {
+        $e(t[n], e);
+      } catch {
+      }
+    const r = Fe(t);
+    if (r !== Object.prototype && r !== Array.prototype && r !== Map.prototype && r !== Set.prototype && r !== Date.prototype) {
+      const n = mr(r);
+      for (let i in n) {
+        const f = n[i].get;
+        if (f)
+          try {
+            f.call(t);
+          } catch {
+          }
+      }
+    }
+  }
+}
+const gi = /* @__PURE__ */ new Set(), bi = /* @__PURE__ */ new Set();
+function Jr(t, e, r, n = {}) {
+  function i(f) {
+    if (n.capture || Ei.call(e, f), !f.cancelBubble)
+      return It(() => r == null ? void 0 : r.call(this, f));
+  }
+  return t.startsWith("pointer") || t.startsWith("touch") || t === "wheel" ? zt(() => {
+    e.addEventListener(t, i, n);
+  }) : e.addEventListener(t, i, n), i;
+}
+function of(t, e, r, n, i) {
+  var f = { capture: n, passive: i }, a = Jr(t, e, r, f);
+  (e === document.body || // @ts-ignore
+  e === window || // @ts-ignore
+  e === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+  e instanceof HTMLMediaElement) && Dr(() => {
+    e.removeEventListener(t, a, f);
+  });
+}
+function yi(t) {
+  for (var e = 0; e < t.length; e++)
+    gi.add(t[e]);
+  for (var r of bi)
+    r(t);
+}
+let lr = null;
+function Ei(t) {
+  var T;
+  var e = this, r = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), n = t.type, i = ((T = t.composedPath) == null ? void 0 : T.call(t)) || [], f = (
+    /** @type {null | Element} */
+    i[0] || t.target
+  );
+  lr = t;
+  var a = 0, l = lr === t && t.__root;
+  if (l) {
+    var u = i.indexOf(l);
+    if (u !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t.__root = e;
+      return;
+    }
+    var s = i.indexOf(e);
+    if (s === -1)
+      return;
+    u <= s && (a = u);
+  }
+  if (f = /** @type {Element} */
+  i[a] || t.target, f !== e) {
+    Ce(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return f || r;
+      }
+    });
+    var o = A, v = S;
+    z(null), lt(null);
+    try {
+      for (var _, p = []; f !== null; ) {
+        var c = f.assignedSlot || f.parentNode || /** @type {any} */
+        f.host || null;
+        try {
+          var d = f["__" + n];
+          if (d != 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
+          t.target === f))
+            if (ve(d)) {
+              var [h, ...w] = d;
+              h.apply(f, [t, ...w]);
+            } else
+              d.call(f, t);
+        } catch (g) {
+          _ ? p.push(g) : _ = g;
+        }
+        if (t.cancelBubble || c === e || c === null)
+          break;
+        f = c;
+      }
+      if (_) {
+        for (let g of p)
+          queueMicrotask(() => {
+            throw g;
+          });
+        throw _;
+      }
+    } finally {
+      t.__root = e, delete t.currentTarget, z(o), lt(v);
+    }
+  }
+}
+function Qr(t) {
+  var e = document.createElement("template");
+  return e.innerHTML = t.replaceAll("<!>", "<!---->"), e.content;
+}
+function qt(t, e) {
+  var r = (
+    /** @type {Effect} */
+    S
+  );
+  r.nodes_start === null && (r.nodes_start = t, r.nodes_end = e);
+}
+// @__NO_SIDE_EFFECTS__
+function cf(t, e) {
+  var r = (e & Sn) !== 0, n = (e & Tn) !== 0, i, f = !t.startsWith("<!>");
+  return () => {
+    i === void 0 && (i = Qr(f ? t : "<!>" + t), r || (i = /** @type {Node} */
+    /* @__PURE__ */ Ct(i)));
+    var a = (
+      /** @type {TemplateNode} */
+      n || ni ? document.importNode(i, !0) : i.cloneNode(!0)
+    );
+    if (r) {
+      var l = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Ct(a)
+      ), u = (
+        /** @type {TemplateNode} */
+        a.lastChild
+      );
+      qt(l, u);
+    } else
+      qt(a, a);
+    return a;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function mi(t, e, r = "svg") {
+  var n = !t.startsWith("<!>"), i = `<${r}>${n ? t : "<!>" + t}</${r}>`, f;
+  return () => {
+    if (!f) {
+      var a = (
+        /** @type {DocumentFragment} */
+        Qr(i)
+      ), l = (
+        /** @type {Element} */
+        /* @__PURE__ */ Ct(a)
+      );
+      f = /** @type {Element} */
+      /* @__PURE__ */ Ct(l);
+    }
+    var u = (
+      /** @type {TemplateNode} */
+      f.cloneNode(!0)
+    );
+    return qt(u, u), u;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function vf(t, e) {
+  return /* @__PURE__ */ mi(t, e, "svg");
+}
+function _f(t = "") {
+  {
+    var e = Xt(t + "");
+    return qt(e, e), e;
+  }
+}
+function df() {
+  var t = document.createDocumentFragment(), e = document.createComment(""), r = Xt();
+  return t.append(e, r), qt(e, r), t;
+}
+function pf(t, e) {
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+function Ai(t) {
+  return t.endsWith("capture") && t !== "gotpointercapture" && t !== "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(t) {
+  return Si.includes(t);
+}
+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 Pi(t) {
+  return t = t.toLowerCase(), Oi[t] ?? t;
+}
+let tn = !0;
+function hf(t) {
+  tn = t;
+}
+function wf(t, e) {
+  var r = e == null ? "" : typeof e == "object" ? e + "" : e;
+  r !== (t.__t ?? (t.__t = t.nodeValue)) && (t.__t = r, t.nodeValue = r + "");
+}
+function gf(t, e, r = !1) {
+  var n = t, i = null, f = null, a = P, l = r ? pe : 0, u = !1;
+  const s = (p, c = !0) => {
+    u = !0, _(c, p);
+  };
+  var o = null;
+  function v() {
+    o !== null && (o.lastChild.remove(), n.before(o), o = null);
+    var p = a ? i : f, c = a ? f : i;
+    p && Ye(p), c && Br(c, () => {
+      a ? f = null : i = null;
+    });
+  }
+  const _ = (p, c) => {
+    if (a !== (a = p)) {
+      var d = Lr(), h = n;
+      if (d && (o = document.createDocumentFragment(), o.append(h = Xt())), a ? i ?? (i = c && Nt(() => c(h))) : f ?? (f = c && Nt(() => c(h))), d) {
+        var w = (
+          /** @type {Batch} */
+          N
+        ), T = a ? i : f, g = a ? f : i;
+        T && w.skipped_effects.delete(T), g && w.skipped_effects.add(g), w.add_callback(v);
+      } else
+        v();
+    }
+  };
+  ge(() => {
+    u = !1, e(s), u || _(null, null);
+  }, l);
+}
+function bf(t, e) {
+  return e;
+}
+function Ci(t, e, r) {
+  for (var n = t.items, i = [], f = e.length, a = 0; a < f; a++)
+    He(e[a].e, i, !0);
+  var l = f > 0 && i.length === 0 && r !== null;
+  if (l) {
+    var u = (
+      /** @type {Element} */
+      /** @type {Element} */
+      r.parentNode
+    );
+    ai(u), u.append(
+      /** @type {Element} */
+      r
+    ), n.clear(), W(t, e[0].prev, e[f - 1].next);
+  }
+  Hr(i, () => {
+    for (var s = 0; s < f; s++) {
+      var o = e[s];
+      l || (n.delete(o.k), W(t, o.prev, o.next)), K(o.e, !l);
+    }
+  });
+}
+function yf(t, e, r, n, i, f = null) {
+  var a = t, l = { flags: e, items: /* @__PURE__ */ new Map(), first: null }, u = (e & br) !== 0;
+  if (u) {
+    var s = (
+      /** @type {Element} */
+      t
+    );
+    a = s.appendChild(Xt());
+  }
+  var o = null, v = !1, _ = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ qe(() => {
+    var w = r();
+    return ve(w) ? w : w == null ? [] : Er(w);
+  }), c, d;
+  function h() {
+    Ni(
+      d,
+      c,
+      l,
+      _,
+      a,
+      i,
+      e,
+      n,
+      r
+    ), f !== null && (c.length === 0 ? o ? Ye(o) : o = Nt(() => f(a)) : o !== null && Br(o, () => {
+      o = null;
+    }));
+  }
+  ge(() => {
+    d ?? (d = /** @type {Effect} */
+    S), c = /** @type {V[]} */
+    F(p);
+    var w = c.length;
+    if (!(v && w === 0)) {
+      v = w === 0;
+      var T, g, b, m;
+      if (Lr()) {
+        var y = /* @__PURE__ */ new Set(), E = (
+          /** @type {Batch} */
+          N
+        );
+        for (g = 0; g < w; g += 1) {
+          b = c[g], m = n(b, g);
+          var M = l.items.get(m) ?? _.get(m);
+          M ? (e & (oe | ce)) !== 0 && en(M, b, g, e) : (T = rn(
+            null,
+            l,
+            null,
+            null,
+            b,
+            m,
+            g,
+            i,
+            e,
+            r,
+            !0
+          ), _.set(m, T)), y.add(m);
+        }
+        for (const [B, be] of l.items)
+          y.has(B) || E.skipped_effects.add(be.e);
+        E.add_callback(h);
+      } else
+        h();
+      F(p);
+    }
+  });
+}
+function Ni(t, e, r, n, i, f, a, l, u) {
+  var Ke, ze, Ze, Xe;
+  var s = (a & hn) !== 0, o = (a & (oe | ce)) !== 0, v = e.length, _ = r.items, p = r.first, c = p, d, h = null, w, T = [], g = [], b, m, y, E;
+  if (s)
+    for (E = 0; E < v; E += 1)
+      b = e[E], m = l(b, E), y = _.get(m), y !== void 0 && ((Ke = y.a) == null || Ke.measure(), (w ?? (w = /* @__PURE__ */ new Set())).add(y));
+  for (E = 0; E < v; E += 1) {
+    if (b = e[E], m = l(b, E), y = _.get(m), y === void 0) {
+      var M = n.get(m);
+      if (M !== void 0) {
+        n.delete(m), _.set(m, M);
+        var B = h ? h.next : c;
+        W(r, h, M), W(r, M, B), Te(M, B, i), h = M;
+      } else {
+        var be = c ? (
+          /** @type {TemplateNode} */
+          c.e.nodes_start
+        ) : i;
+        h = rn(
+          be,
+          r,
+          h,
+          h === null ? r.first : h.next,
+          b,
+          m,
+          E,
+          f,
+          a,
+          u
+        );
+      }
+      _.set(m, h), T = [], g = [], c = h.next;
+      continue;
+    }
+    if (o && en(y, b, E, a), (y.e.f & H) !== 0 && (Ye(y.e), s && ((ze = y.a) == null || ze.unfix(), (w ?? (w = /* @__PURE__ */ new Set())).delete(y))), y !== c) {
+      if (d !== void 0 && d.has(y)) {
+        if (T.length < g.length) {
+          var te = g[0], nt;
+          h = te.prev;
+          var Ge = T[0], ye = T[T.length - 1];
+          for (nt = 0; nt < T.length; nt += 1)
+            Te(T[nt], te, i);
+          for (nt = 0; nt < g.length; nt += 1)
+            d.delete(g[nt]);
+          W(r, Ge.prev, ye.next), W(r, h, Ge), W(r, ye, te), c = te, h = ye, E -= 1, T = [], g = [];
+        } else
+          d.delete(y), Te(y, c, i), W(r, y.prev, y.next), W(r, y, h === null ? r.first : h.next), W(r, h, y), h = y;
+        continue;
+      }
+      for (T = [], g = []; c !== null && c.k !== m; )
+        (c.e.f & H) === 0 && (d ?? (d = /* @__PURE__ */ new Set())).add(c), g.push(c), c = c.next;
+      if (c === null)
+        continue;
+      y = c;
+    }
+    T.push(y), h = y, c = y.next;
+  }
+  if (c !== null || d !== void 0) {
+    for (var Rt = d === void 0 ? [] : Er(d); c !== null; )
+      (c.e.f & H) === 0 && Rt.push(c), c = c.next;
+    var Ee = Rt.length;
+    if (Ee > 0) {
+      var on = (a & br) !== 0 && v === 0 ? i : null;
+      if (s) {
+        for (E = 0; E < Ee; E += 1)
+          (Ze = Rt[E].a) == null || Ze.measure();
+        for (E = 0; E < Ee; E += 1)
+          (Xe = Rt[E].a) == null || Xe.fix();
+      }
+      Ci(r, Rt, on);
+    }
+  }
+  s && zt(() => {
+    var Je;
+    if (w !== void 0)
+      for (y of w)
+        (Je = y.a) == null || Je.apply();
+  }), t.first = r.first && r.first.e, t.last = h && h.e;
+  for (var cn of n.values())
+    K(cn.e);
+  n.clear();
+}
+function en(t, e, r, n) {
+  (n & oe) !== 0 && jt(t.v, e), (n & ce) !== 0 ? jt(
+    /** @type {Value<number>} */
+    t.i,
+    r
+  ) : t.i = r;
+}
+function rn(t, e, r, n, i, f, a, l, u, s, o) {
+  var v = (u & oe) !== 0, _ = (u & wn) === 0, p = v ? _ ? /* @__PURE__ */ ei(i, !1, !1) : xt(i) : i, c = (u & ce) === 0 ? a : xt(a), d = {
+    i: c,
+    v: p,
+    k: f,
+    a: null,
+    // @ts-expect-error
+    e: null,
+    prev: r,
+    next: n
+  };
+  try {
+    if (t === null) {
+      var h = document.createDocumentFragment();
+      h.append(t = Xt());
+    }
+    return d.e = Nt(() => l(
+      /** @type {Node} */
+      t,
+      p,
+      c,
+      s
+    ), Yn), d.e.prev = r && r.e, d.e.next = n && n.e, r === null ? o || (e.first = d) : (r.next = d, r.e.next = d.e), n !== null && (n.prev = d, n.e.prev = d.e), d;
+  } finally {
+  }
+}
+function Te(t, e, r) {
+  for (var n = t.next ? (
+    /** @type {TemplateNode} */
+    t.next.e.nodes_start
+  ) : r, i = e ? (
+    /** @type {TemplateNode} */
+    e.e.nodes_start
+  ) : r, f = (
+    /** @type {TemplateNode} */
+    t.e.nodes_start
+  ); f !== null && f !== n; ) {
+    var a = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ we(f)
+    );
+    i.before(f), f = a;
+  }
+}
+function W(t, e, r) {
+  e === null ? t.first = r : (e.next = r, e.e.next = r && r.e), r !== null && (r.prev = e, r.e.prev = e && e.e);
+}
+function ki(t, e) {
+  var r = void 0, n;
+  ge(() => {
+    r !== (r = e()) && (n && (K(n), n = null), r && (n = Nt(() => {
+      Be(() => (
+        /** @type {(node: Element) => void} */
+        r(t)
+      ));
+    })));
+  });
+}
+function nn(t) {
+  var e, r, n = "";
+  if (typeof t == "string" || typeof t == "number") n += t;
+  else if (typeof t == "object") if (Array.isArray(t)) {
+    var i = t.length;
+    for (e = 0; e < i; e++) t[e] && (r = nn(t[e])) && (n && (n += " "), n += r);
+  } else for (r in t) t[r] && (n && (n += " "), n += r);
+  return n;
+}
+function Ii() {
+  for (var t, e, r = 0, n = "", i = arguments.length; r < i; r++) (t = arguments[r]) && (e = nn(t)) && (n && (n += " "), n += e);
+  return n;
+}
+function Ri(t) {
+  return typeof t == "object" ? Ii(t) : t ?? "";
+}
+const or = [...` 	
+\r\f \v\uFEFF`];
+function $i(t, e, r) {
+  var n = t == null ? "" : "" + t;
+  if (e && (n = n ? n + " " + e : e), r) {
+    for (var i in r)
+      if (r[i])
+        n = n ? n + " " + i : i;
+      else if (n.length)
+        for (var f = i.length, a = 0; (a = n.indexOf(i, a)) >= 0; ) {
+          var l = a + f;
+          (a === 0 || or.includes(n[a - 1])) && (l === n.length || or.includes(n[l])) ? n = (a === 0 ? "" : n.substring(0, a)) + n.substring(l + 1) : a = l;
+        }
+  }
+  return n === "" ? null : n;
+}
+function cr(t, e = !1) {
+  var r = e ? " !important;" : ";", n = "";
+  for (var i in t) {
+    var f = t[i];
+    f != null && f !== "" && (n += " " + i + ": " + f + r);
+  }
+  return n;
+}
+function Oe(t) {
+  return t[0] !== "-" || t[1] !== "-" ? t.toLowerCase() : t;
+}
+function Mi(t, e) {
+  if (e) {
+    var r = "", n, i;
+    if (Array.isArray(e) ? (n = e[0], i = e[1]) : n = e, t) {
+      t = String(t).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
+      var f = !1, a = 0, l = !1, u = [];
+      n && u.push(...Object.keys(n).map(Oe)), i && u.push(...Object.keys(i).map(Oe));
+      var s = 0, o = -1;
+      const d = t.length;
+      for (var v = 0; v < d; v++) {
+        var _ = t[v];
+        if (l ? _ === "/" && t[v - 1] === "*" && (l = !1) : f ? f === _ && (f = !1) : _ === "/" && t[v + 1] === "*" ? l = !0 : _ === '"' || _ === "'" ? f = _ : _ === "(" ? a++ : _ === ")" && a--, !l && f === !1 && a === 0) {
+          if (_ === ":" && o === -1)
+            o = v;
+          else if (_ === ";" || v === d - 1) {
+            if (o !== -1) {
+              var p = Oe(t.substring(s, o).trim());
+              if (!u.includes(p)) {
+                _ !== ";" && v++;
+                var c = t.substring(s, v).trim();
+                r += " " + c + ";";
+              }
+            }
+            s = v + 1, o = -1;
+          }
+        }
+      }
+    }
+    return n && (r += cr(n)), i && (r += cr(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return t == null ? null : String(t);
+}
+function Li(t, e, r, n, i, f) {
+  var a = t.__className;
+  if (a !== r || a === void 0) {
+    var l = $i(r, n, f);
+    l == null ? t.removeAttribute("class") : e ? t.className = l : t.setAttribute("class", l), t.__className = r;
+  } else if (f && i !== f)
+    for (var u in f) {
+      var s = !!f[u];
+      (i == null || s !== !!i[u]) && t.classList.toggle(u, s);
+    }
+  return f;
+}
+function Pe(t, e = {}, r, n) {
+  for (var i in r) {
+    var f = r[i];
+    e[i] !== f && (r[i] == null ? t.style.removeProperty(i) : t.style.setProperty(i, f, n));
+  }
+}
+function Fi(t, e, r, n) {
+  var i = t.__style;
+  if (i !== e) {
+    var f = Mi(e, n);
+    f == null ? t.removeAttribute("style") : t.style.cssText = f, t.__style = e;
+  } else n && (Array.isArray(n) ? (Pe(t, r == null ? void 0 : r[0], n[0]), Pe(t, r == null ? void 0 : r[1], n[1], "important")) : Pe(t, r, n));
+  return n;
+}
+function Me(t, e, r = !1) {
+  if (t.multiple) {
+    if (e == null)
+      return;
+    if (!ve(e))
+      return Hn();
+    for (var n of t.options)
+      n.selected = e.includes(vr(n));
+    return;
+  }
+  for (n of t.options) {
+    var i = vr(n);
+    if (ri(i, e)) {
+      n.selected = !0;
+      return;
+    }
+  }
+  (!r || e !== void 0) && (t.selectedIndex = -1);
+}
+function Di(t) {
+  var e = new MutationObserver(() => {
+    Me(t, t.__value);
+  });
+  e.observe(t, {
+    // 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"]
+  }), Dr(() => {
+    e.disconnect();
+  });
+}
+function vr(t) {
+  return "__value" in t ? t.__value : t.value;
+}
+const Lt = Symbol("class"), Ft = Symbol("style"), fn = Symbol("is custom element"), an = Symbol("is html");
+function Ef(t, e) {
+  var r = We(t);
+  r.value === (r.value = // treat null and undefined the same for the initial value
+  e ?? void 0) || // @ts-expect-error
+  // `progress` elements always need their value set when it's `0`
+  t.value === e && (e !== 0 || t.nodeName !== "PROGRESS") || (t.value = e ?? "");
+}
+function xi(t, e) {
+  e ? t.hasAttribute("selected") || t.setAttribute("selected", "") : t.removeAttribute("selected");
+}
+function _r(t, e, r, n) {
+  var i = We(t);
+  i[e] !== (i[e] = r) && (e === "loading" && (t[Mn] = r), r == null ? t.removeAttribute(e) : typeof r != "string" && sn(t).includes(e) ? t[e] = r : t.setAttribute(e, r));
+}
+function ji(t, e, r, n, i = !1, f = !1) {
+  var a = We(t), l = a[fn], u = !a[an], s = e || {}, o = t.tagName === "OPTION";
+  for (var v in e)
+    v in r || (r[v] = null);
+  r.class ? r.class = Ri(r.class) : (n || r[Lt]) && (r.class = null), r[Ft] && (r.style ?? (r.style = null));
+  var _ = sn(t);
+  for (const g in r) {
+    let b = r[g];
+    if (o && g === "value" && b == null) {
+      t.value = t.__value = "", s[g] = b;
+      continue;
+    }
+    if (g === "class") {
+      var p = t.namespaceURI === "http://www.w3.org/1999/xhtml";
+      Li(t, p, b, n, e == null ? void 0 : e[Lt], r[Lt]), s[g] = b, s[Lt] = r[Lt];
+      continue;
+    }
+    if (g === "style") {
+      Fi(t, b, e == null ? void 0 : e[Ft], r[Ft]), s[g] = b, s[Ft] = r[Ft];
+      continue;
+    }
+    var c = s[g];
+    if (!(b === c && !(b === void 0 && t.hasAttribute(g)))) {
+      s[g] = b;
+      var d = g[0] + g[1];
+      if (d !== "$$")
+        if (d === "on") {
+          const m = {}, y = "$$" + g;
+          let E = g.slice(2);
+          var h = Ti(E);
+          if (Ai(E) && (E = E.slice(0, -7), m.capture = !0), !h && c) {
+            if (b != null) continue;
+            t.removeEventListener(E, s[y], m), s[y] = null;
+          }
+          if (b != null)
+            if (h)
+              t[`__${E}`] = b, yi([E]);
+            else {
+              let M = function(B) {
+                s[g].call(this, B);
+              };
+              s[y] = Jr(E, t, M, m);
+            }
+          else h && (t[`__${E}`] = void 0);
+        } else if (g === "style")
+          _r(t, g, b);
+        else if (g === "autofocus")
+          si(
+            /** @type {HTMLElement} */
+            t,
+            !!b
+          );
+        else if (!l && (g === "__value" || g === "value" && b != null))
+          t.value = t.__value = b;
+        else if (g === "selected" && o)
+          xi(
+            /** @type {HTMLOptionElement} */
+            t,
+            b
+          );
+        else {
+          var w = g;
+          u || (w = Pi(w));
+          var T = w === "defaultValue" || w === "defaultChecked";
+          if (b == null && !l && !T)
+            if (a[g] = null, w === "value" || w === "checked") {
+              let m = (
+                /** @type {HTMLInputElement} */
+                t
+              );
+              const y = e === 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
+              t.removeAttribute(g);
+          else T || _.includes(w) && (l || typeof b != "string") ? (t[w] = b, w in a && (a[w] = P)) : typeof b != "function" && _r(t, w, b);
+        }
+    }
+  }
+  return s;
+}
+function mf(t, e, r = [], n = [], i, f = !1, a = !1) {
+  kr(r, n, (l) => {
+    var u = void 0, s = {}, o = t.nodeName === "SELECT", v = !1;
+    if (ge(() => {
+      var p = e(...l.map(F)), c = ji(
+        t,
+        u,
+        p,
+        i,
+        f,
+        a
+      );
+      v && o && "value" in p && Me(
+        /** @type {HTMLSelectElement} */
+        t,
+        p.value
+      );
+      for (let h of Object.getOwnPropertySymbols(s))
+        p[h] || K(s[h]);
+      for (let h of Object.getOwnPropertySymbols(p)) {
+        var d = p[h];
+        h.description === Pn && (!u || d !== u[h]) && (s[h] && K(s[h]), s[h] = Nt(() => ki(t, () => d))), c[h] = d;
+      }
+      u = c;
+    }), o) {
+      var _ = (
+        /** @type {HTMLSelectElement} */
+        t
+      );
+      Be(() => {
+        Me(
+          _,
+          /** @type {Record<string | symbol, any>} */
+          u.value,
+          !0
+        ), Di(_);
+      });
+    }
+    v = !0;
+  });
+}
+function We(t) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    t.__attributes ?? (t.__attributes = {
+      [fn]: t.nodeName.includes("-"),
+      [an]: t.namespaceURI === On
+    })
+  );
+}
+var dr = /* @__PURE__ */ new Map();
+function sn(t) {
+  var e = t.getAttribute("is") || t.nodeName, r = dr.get(e);
+  if (r) return r;
+  dr.set(e, r = []);
+  for (var n, i = t, f = Element.prototype; f !== i; ) {
+    n = mr(i);
+    for (var a in n)
+      n[a].set && r.push(a);
+    i = Fe(i);
+  }
+  return r;
+}
+const Ui = () => performance.now(), J = {
+  // don't access requestAnimationFrame eagerly outside method
+  // this allows basic testing of user code without JSDOM
+  // bunder will eval and remove ternary when the user's app is built
+  tick: (
+    /** @param {any} _ */
+    (t) => requestAnimationFrame(t)
+  ),
+  now: () => Ui(),
+  tasks: /* @__PURE__ */ new Set()
+};
+function un() {
+  const t = J.now();
+  J.tasks.forEach((e) => {
+    e.c(t) || (J.tasks.delete(e), e.f());
+  }), J.tasks.size !== 0 && J.tick(un);
+}
+function qi(t) {
+  let e;
+  return J.tasks.size === 0 && J.tick(un), {
+    promise: new Promise((r) => {
+      J.tasks.add(e = { c: t, f: r });
+    }),
+    abort() {
+      J.tasks.delete(e);
+    }
+  };
+}
+function ee(t, e) {
+  It(() => {
+    t.dispatchEvent(new CustomEvent(e));
+  });
+}
+function Vi(t) {
+  if (t === "float") return "cssFloat";
+  if (t === "offset") return "cssOffset";
+  if (t.startsWith("--")) return t;
+  const e = t.split("-");
+  return e.length === 1 ? e[0] : e[0] + e.slice(1).map(
+    /** @param {any} word */
+    (r) => r[0].toUpperCase() + r.slice(1)
+  ).join("");
+}
+function pr(t) {
+  const e = {}, r = t.split(";");
+  for (const n of r) {
+    const [i, f] = n.split(":");
+    if (!i || f === void 0) break;
+    const a = Vi(i.trim());
+    e[a] = f.trim();
+  }
+  return e;
+}
+const Bi = (t) => t;
+function Af(t, e, r, n) {
+  var i = (t & An) !== 0, f = "both", a, l = e.inert, u = e.style.overflow, s, o;
+  function v() {
+    return It(() => a ?? (a = r()(e, (n == null ? void 0 : n()) ?? /** @type {P} */
+    {}, {
+      direction: f
+    })));
+  }
+  var _ = {
+    is_global: i,
+    in() {
+      e.inert = l, ee(e, "introstart"), s = Le(e, v(), o, 1, () => {
+        ee(e, "introend"), s == null || s.abort(), s = a = void 0, e.style.overflow = u;
+      });
+    },
+    out(h) {
+      e.inert = !0, ee(e, "outrostart"), o = Le(e, v(), s, 0, () => {
+        ee(e, "outroend"), h == null || h();
+      });
+    },
+    stop: () => {
+      s == null || s.abort(), o == null || o.abort();
+    }
+  }, p = (
+    /** @type {Effect} */
+    S
+  );
+  if ((p.transitions ?? (p.transitions = [])).push(_), tn) {
+    var c = i;
+    if (!c) {
+      for (var d = (
+        /** @type {Effect | null} */
+        p.parent
+      ); d && (d.f & pe) !== 0; )
+        for (; (d = d.parent) && (d.f & ht) === 0; )
+          ;
+      c = !d || (d.f & de) !== 0;
+    }
+    c && Be(() => {
+      Qt(() => _.in());
+    });
+  }
+}
+function Le(t, e, r, n, i) {
+  var f = n === 1;
+  if (bt(e)) {
+    var a, l = !1;
+    return zt(() => {
+      if (!l) {
+        var h = e({ direction: f ? "in" : "out" });
+        a = Le(t, h, r, n, i);
+      }
+    }), {
+      abort: () => {
+        l = !0, a == null || a.abort();
+      },
+      deactivate: () => a.deactivate(),
+      reset: () => a.reset(),
+      t: () => a.t()
+    };
+  }
+  if (r == null || r.deactivate(), !(e != null && e.duration))
+    return i(), {
+      abort: Mt,
+      deactivate: Mt,
+      reset: Mt,
+      t: () => n
+    };
+  const { delay: u = 0, css: s, tick: o, easing: v = Bi } = e;
+  var _ = [];
+  if (f && r === void 0 && (o && o(0, 1), s)) {
+    var p = pr(s(0, 1));
+    _.push(p, p);
+  }
+  var c = () => 1 - n, d = t.animate(_, { duration: u, fill: "forwards" });
+  return d.onfinish = () => {
+    d.cancel();
+    var h = (r == null ? void 0 : r.t()) ?? 1 - n;
+    r == null || r.abort();
+    var w = n - h, T = (
+      /** @type {number} */
+      e.duration * Math.abs(w)
+    ), g = [];
+    if (T > 0) {
+      var b = !1;
+      if (s)
+        for (var m = Math.ceil(T / 16.666666666666668), y = 0; y <= m; y += 1) {
+          var E = h + w * v(y / m), M = pr(s(E, 1 - E));
+          g.push(M), b || (b = M.overflow === "hidden");
+        }
+      b && (t.style.overflow = "hidden"), c = () => {
+        var B = (
+          /** @type {number} */
+          /** @type {globalThis.Animation} */
+          d.currentTime
+        );
+        return h + w * v(B / T);
+      }, o && qi(() => {
+        if (d.playState !== "running") return !1;
+        var B = c();
+        return o(B, 1 - B), !0;
+      });
+    }
+    d = t.animate(g, { duration: T, fill: "forwards" }), d.onfinish = () => {
+      c = () => n, o == null || o(n, 1 - n), i();
+    };
+  }, {
+    abort: () => {
+      d && (d.cancel(), d.effect = null, d.onfinish = Mt);
+    },
+    deactivate: () => {
+      i = Mt;
+    },
+    reset: () => {
+      n === 0 && (o == null || o(1, 0));
+    },
+    t: () => c()
+  };
+}
+function Sf(t = !1) {
+  const e = (
+    /** @type {ComponentContextLegacy} */
+    C
+  ), r = e.l.u;
+  if (!r) return;
+  let n = () => wi(e.s);
+  if (t) {
+    let i = 0, f = (
+      /** @type {Record<string, any>} */
+      {}
+    );
+    const a = /* @__PURE__ */ Zt(() => {
+      let l = !1;
+      const u = e.s;
+      for (const s in u)
+        u[s] !== f[s] && (f[s] = u[s], l = !0);
+      return l && i++, i;
+    });
+    n = () => F(a);
+  }
+  r.b.length && oi(() => {
+    hr(e, n), Ne(r.b);
+  }), fr(() => {
+    const i = Qt(() => r.m.map(In));
+    return () => {
+      for (const f of i)
+        typeof f == "function" && f();
+    };
+  }), r.a.length && fr(() => {
+    hr(e, n), Ne(r.a);
+  });
+}
+function hr(t, e) {
+  if (t.l.s)
+    for (const r of t.l.s) F(r);
+  e();
+}
+let re = !1;
+function Hi(t) {
+  var e = re;
+  try {
+    return re = !1, [t(), re];
+  } finally {
+    re = e;
+  }
+}
+const Yi = {
+  get(t, e) {
+    if (!t.exclude.includes(e))
+      return t.props[e];
+  },
+  set(t, e) {
+    return !1;
+  },
+  getOwnPropertyDescriptor(t, e) {
+    if (!t.exclude.includes(e) && e in t.props)
+      return {
+        enumerable: !0,
+        configurable: !0,
+        value: t.props[e]
+      };
+  },
+  has(t, e) {
+    return t.exclude.includes(e) ? !1 : e in t.props;
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(t.props).filter((e) => !t.exclude.includes(e));
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Tf(t, e, r) {
+  return new Proxy(
+    { props: t, exclude: e },
+    Yi
+  );
+}
+const Wi = {
+  get(t, e) {
+    let r = t.props.length;
+    for (; r--; ) {
+      let n = t.props[r];
+      if (bt(n) && (n = n()), typeof n == "object" && n !== null && e in n) return n[e];
+    }
+  },
+  set(t, e, r) {
+    let n = t.props.length;
+    for (; n--; ) {
+      let i = t.props[n];
+      bt(i) && (i = i());
+      const f = mt(i, e);
+      if (f && f.set)
+        return f.set(r), !0;
+    }
+    return !1;
+  },
+  getOwnPropertyDescriptor(t, e) {
+    let r = t.props.length;
+    for (; r--; ) {
+      let n = t.props[r];
+      if (bt(n) && (n = n()), typeof n == "object" && n !== null && e in n) {
+        const i = mt(n, e);
+        return i && !i.configurable && (i.configurable = !0), i;
+      }
+    }
+  },
+  has(t, e) {
+    if (e === Q || e === Tr) return !1;
+    for (let r of t.props)
+      if (bt(r) && (r = r()), r != null && e in r) return !0;
+    return !1;
+  },
+  ownKeys(t) {
+    const e = [];
+    for (let r of t.props)
+      if (bt(r) && (r = r()), !!r) {
+        for (const n in r)
+          e.includes(n) || e.push(n);
+        for (const n of Object.getOwnPropertySymbols(r))
+          e.includes(n) || e.push(n);
+      }
+    return e;
+  }
+};
+function Of(...t) {
+  return new Proxy({ props: t }, Wi);
+}
+function Pf(t, e, r, n) {
+  var g;
+  var i = !Gt || (r & bn) !== 0, f = (r & En) !== 0, a = (r & mn) !== 0, l = (
+    /** @type {V} */
+    n
+  ), u = !0, s = () => (u && (u = !1, l = a ? Qt(
+    /** @type {() => V} */
+    n
+  ) : (
+    /** @type {V} */
+    n
+  )), l), o;
+  if (f) {
+    var v = Q in t || Tr in t;
+    o = ((g = mt(t, e)) == null ? void 0 : g.set) ?? (v && e in t ? (b) => t[e] = b : void 0);
+  }
+  var _, p = !1;
+  f ? [_, p] = Hi(() => (
+    /** @type {V} */
+    t[e]
+  )) : _ = /** @type {V} */
+  t[e], _ === void 0 && n !== void 0 && (_ = s(), o && (i && Un(), o(_)));
+  var c;
+  if (i ? c = () => {
+    var b = (
+      /** @type {V} */
+      t[e]
+    );
+    return b === void 0 ? s() : (u = !0, b);
+  } : c = () => {
+    var b = (
+      /** @type {V} */
+      t[e]
+    );
+    return b !== void 0 && (l = /** @type {V} */
+    void 0), b === void 0 ? l : b;
+  }, i && (r & yn) === 0)
+    return c;
+  if (o) {
+    var d = t.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(b, m) {
+        return arguments.length > 0 ? ((!i || !m || d || p) && o(m ? c() : b), b) : c();
+      })
+    );
+  }
+  var h = !1, w = ((r & gn) !== 0 ? Zt : qe)(() => (h = !1, c()));
+  f && F(w);
+  var T = (
+    /** @type {Effect} */
+    S
+  );
+  return (
+    /** @type {() => V} */
+    (function(b, m) {
+      if (arguments.length > 0) {
+        const y = m ? F(w) : i && f ? Et(b) : b;
+        return X(w, y), h = !0, l !== void 0 && (l = y), b;
+      }
+      return gt && h || (T.f & wt) !== 0 ? w.v : F(w);
+    })
+  );
+}
+const Gi = (t) => t;
+function ln(t) {
+  const e = t - 1;
+  return e * e * e + 1;
+}
+function wr(t) {
+  const e = typeof t == "string" && t.match(/^\s*(-?[\d.]+)([^\s]*)\s*$/);
+  return e ? [parseFloat(e[1]), e[2] || "px"] : [
+    /** @type {number} */
+    t,
+    "px"
+  ];
+}
+function Cf(t, { delay: e = 0, duration: r = 400, easing: n = Gi } = {}) {
+  const i = +getComputedStyle(t).opacity;
+  return {
+    delay: e,
+    duration: r,
+    easing: n,
+    css: (f) => `opacity: ${f * i}`
+  };
+}
+function Nf(t, { delay: e = 0, duration: r = 400, easing: n = ln, x: i = 0, y: f = 0, opacity: a = 0 } = {}) {
+  const l = getComputedStyle(t), u = +l.opacity, s = l.transform === "none" ? "" : l.transform, o = u * (1 - a), [v, _] = wr(i), [p, c] = wr(f);
+  return {
+    delay: e,
+    duration: r,
+    easing: n,
+    css: (d, h) => `
+			transform: ${s} translate(${(1 - d) * v}${_}, ${(1 - d) * p}${c});
+			opacity: ${u - o * h}`
+  };
+}
+function kf(t, { delay: e = 0, duration: r = 400, easing: n = ln, axis: i = "y" } = {}) {
+  const f = getComputedStyle(t), a = +f.opacity, l = i === "y" ? "height" : "width", u = parseFloat(f[l]), s = i === "y" ? ["top", "bottom"] : ["left", "right"], o = s.map(
+    (w) => (
+      /** @type {'Left' | 'Right' | 'Top' | 'Bottom'} */
+      `${w[0].toUpperCase()}${w.slice(1)}`
+    )
+  ), v = parseFloat(f[`padding${o[0]}`]), _ = parseFloat(f[`padding${o[1]}`]), p = parseFloat(f[`margin${o[0]}`]), c = parseFloat(f[`margin${o[1]}`]), d = parseFloat(
+    f[`border${o[0]}Width`]
+  ), h = parseFloat(
+    f[`border${o[1]}Width`]
+  );
+  return {
+    delay: e,
+    duration: r,
+    easing: n,
+    css: (w) => `overflow: hidden;opacity: ${Math.min(w * 20, 1) * a};${l}: ${w * u}px;padding-${s[0]}: ${w * v}px;padding-${s[1]}: ${w * _}px;margin-${s[0]}: ${w * p}px;margin-${s[1]}: ${w * c}px;border-${s[0]}-width: ${w * d}px;border-${s[1]}-width: ${w * h}px;min-${l}: 0`
+  };
+}
+export {
+  Q as $,
+  X as A,
+  _f as B,
+  Fi as C,
+  qe as D,
+  vf as E,
+  mf as F,
+  ef as G,
+  ge as H,
+  pe as I,
+  Nt as J,
+  K,
+  Mt as L,
+  Xt as M,
+  N,
+  Lr as O,
+  Br as P,
+  zi as Q,
+  qt as R,
+  S,
+  Ye as T,
+  hf as U,
+  Be as V,
+  af as W,
+  jr as X,
+  mt as Y,
+  Dr as Z,
+  zt as _,
+  uf as a,
+  Tf as a0,
+  bf as a1,
+  tf as a2,
+  Zi as a3,
+  Of as a4,
+  Cf as a5,
+  kf as a6,
+  Ef as a7,
+  Di as a8,
+  Me as a9,
+  gf as b,
+  df as c,
+  pf as d,
+  Qi as e,
+  nf as f,
+  Ji as g,
+  wi as h,
+  Sf as i,
+  cf as j,
+  yf as k,
+  sf as l,
+  rf as m,
+  Ri as n,
+  F as o,
+  Pf as p,
+  Li as q,
+  _r as r,
+  ff as s,
+  lf as t,
+  Qt as u,
+  wf as v,
+  of as w,
+  Af as x,
+  Nf as y,
+  ei as z
+};