@44-audio/components 0.1.0-dev.2 → 0.1.0-dev.20

package/dist/index-DCaqXYMO.js

@@ -0,0 +1,2836 @@
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add("5");
+const re = 1, ne = 2, fr = 4, nn = 8, sn = 16, fn = 1, an = 2, un = 4, ln = 8, on = 16, cn = 1, vn = 2, dn = 4, ar = 1, hn = 2, ur = "[", Ce = "[!", Re = "]", Tt = {}, I = Symbol(), _n = "http://www.w3.org/1999/xhtml", lr = !1;
+var Ie = Array.isArray, pn = Array.prototype.indexOf, Pe = Array.from, Xt = Object.keys, Ot = Object.defineProperty, nt = Object.getOwnPropertyDescriptor, $n = Object.getOwnPropertyDescriptors, gn = Object.prototype, wn = Array.prototype, or = Object.getPrototypeOf, We = Object.isExtensible;
+function yt(t) {
+  return typeof t == "function";
+}
+const xt = () => {
+};
+function cr(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function bn() {
+  var t, e, r = new Promise((n, i) => {
+    t = n, e = i;
+  });
+  return { promise: r, resolve: t, reject: e };
+}
+const M = 2, ke = 4, xe = 8, gt = 16, st = 32, ot = 64, vr = 128, q = 256, Zt = 512, P = 1024, B = 2048, ct = 4096, V = 8192, wt = 16384, ie = 32768, se = 65536, Ke = 1 << 17, mn = 1 << 18, It = 1 << 19, yn = 1 << 20, ge = 1 << 21, Le = 1 << 22, ht = 1 << 23, At = Symbol("$state"), Me = Symbol("legacy props"), En = Symbol(""), De = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}(), Fe = 3, Mt = 8;
+function Tn() {
+  throw new Error("https://svelte.dev/e/await_outside_boundary");
+}
+function dr(t) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function An() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Sn(t) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Nn() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function On(t) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function Cn() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Rn() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function In(t) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function Pn() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function kn() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function xn() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function fe(t) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+let E = !1;
+function Y(t) {
+  E = t;
+}
+let A;
+function U(t) {
+  if (t === null)
+    throw fe(), Tt;
+  return A = t;
+}
+function Ut() {
+  return U(
+    /** @type {TemplateNode} */
+    /* @__PURE__ */ ft(A)
+  );
+}
+function Di(t) {
+  if (E) {
+    if (/* @__PURE__ */ ft(A) !== null)
+      throw fe(), Tt;
+    A = t;
+  }
+}
+function Fi(t = 1) {
+  if (E) {
+    for (var e = t, r = A; e--; )
+      r = /** @type {TemplateNode} */
+      /* @__PURE__ */ ft(r);
+    A = r;
+  }
+}
+function we() {
+  for (var t = 0, e = A; ; ) {
+    if (e.nodeType === Mt) {
+      var r = (
+        /** @type {Comment} */
+        e.data
+      );
+      if (r === Re) {
+        if (t === 0) return e;
+        t -= 1;
+      } else (r === ur || r === Ce) && (t += 1);
+    }
+    var n = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ ft(e)
+    );
+    e.remove(), e = n;
+  }
+}
+function hr(t) {
+  if (!t || t.nodeType !== Mt)
+    throw fe(), Tt;
+  return (
+    /** @type {Comment} */
+    t.data
+  );
+}
+function _r(t) {
+  return t === this.v;
+}
+function Ln(t, e) {
+  return t != t ? e == e : t !== e || t !== null && typeof t == "object" || typeof t == "function";
+}
+function ji(t, e) {
+  return t !== e;
+}
+function pr(t) {
+  return !Ln(t, this.v);
+}
+let Pt = !1, Mn = !1;
+function qi() {
+  Pt = !0;
+}
+let O = null;
+function Qt(t) {
+  O = t;
+}
+function Dn(t, e = !1, r) {
+  O = {
+    p: O,
+    c: null,
+    e: null,
+    s: t,
+    x: null,
+    l: Pt && !e ? { s: null, u: null, $: [] } : null
+  };
+}
+function Fn(t) {
+  var e = (
+    /** @type {ComponentContext} */
+    O
+  ), r = e.e;
+  if (r !== null) {
+    e.e = null;
+    for (var n of r)
+      Pr(n);
+  }
+  return t !== void 0 && (e.x = t), O = e.p, t ?? /** @type {T} */
+  {};
+}
+function Bt() {
+  return !Pt || O !== null && O.l === null;
+}
+const jn = /* @__PURE__ */ new WeakMap();
+function qn(t) {
+  var e = b;
+  if (e === null)
+    return y.f |= ht, t;
+  if ((e.f & ie) === 0) {
+    if ((e.f & vr) === 0)
+      throw !e.parent && t instanceof Error && $r(t), t;
+    e.b.error(t);
+  } else
+    je(t, e);
+}
+function je(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & vr) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (r) {
+        t = r;
+      }
+    e = e.parent;
+  }
+  throw t instanceof Error && $r(t), t;
+}
+function $r(t) {
+  const e = jn.get(t);
+  e && (Ot(t, "message", {
+    value: e.message
+  }), Ot(t, "stack", {
+    value: e.stack
+  }));
+}
+let Dt = [], be = [];
+function gr() {
+  var t = Dt;
+  Dt = [], cr(t);
+}
+function Un() {
+  var t = be;
+  be = [], cr(t);
+}
+function ae(t) {
+  Dt.length === 0 && queueMicrotask(gr), Dt.push(t);
+}
+function Bn() {
+  Dt.length > 0 && gr(), be.length > 0 && Un();
+}
+function Hn() {
+  const t = (
+    /** @type {Effect} */
+    b.b
+  );
+  return t === null && Tn(), t;
+}
+// @__NO_SIDE_EFFECTS__
+function ue(t) {
+  var e = M | B, r = y !== null && (y.f & M) !== 0 ? (
+    /** @type {Derived} */
+    y
+  ) : null;
+  return b === null || r !== null && (r.f & q) !== 0 ? e |= q : b.f |= It, {
+    ctx: O,
+    deps: null,
+    effects: null,
+    equals: _r,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      I
+    ),
+    wv: 0,
+    parent: r ?? b,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Yn(t, e) {
+  let r = (
+    /** @type {Effect | null} */
+    b
+  );
+  r === null && An();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), s = Ft(
+    /** @type {V} */
+    I
+  ), f = null, a = !y;
+  return ei(() => {
+    try {
+      var u = t();
+      f && Promise.resolve(u).catch(() => {
+      });
+    } catch (h) {
+      u = Promise.reject(h);
+    }
+    var l = () => u;
+    i = f?.then(l, l) ?? Promise.resolve(u), f = i;
+    var o = (
+      /** @type {Batch} */
+      R
+    ), d = n.is_pending();
+    a && (n.update_pending_count(1), d || o.increment());
+    const v = (h, c = void 0) => {
+      f = null, d || o.activate(), c ? c !== De && (s.f |= ht, jt(s, c)) : ((s.f & ht) !== 0 && (s.f ^= ht), jt(s, h)), a && (n.update_pending_count(-1), d || o.decrement()), mr();
+    };
+    if (i.then(v, (h) => v(null, h || "unknown")), o)
+      return () => {
+        queueMicrotask(() => o.neuter());
+      };
+  }), new Promise((u) => {
+    function l(o) {
+      function d() {
+        o === i ? u(s) : l(i);
+      }
+      o.then(d, d);
+    }
+    l(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Ui(t) {
+  const e = /* @__PURE__ */ ue(t);
+  return qr(e), e;
+}
+// @__NO_SIDE_EFFECTS__
+function qe(t) {
+  const e = /* @__PURE__ */ ue(t);
+  return e.equals = pr, e;
+}
+function wr(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var r = 0; r < e.length; r += 1)
+      Z(
+        /** @type {Effect} */
+        e[r]
+      );
+  }
+}
+function Vn(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & M) === 0)
+      return (
+        /** @type {Effect} */
+        e
+      );
+    e = e.parent;
+  }
+  return null;
+}
+function Ue(t) {
+  var e, r = b;
+  Q(Vn(t));
+  try {
+    wr(t), e = Yr(t);
+  } finally {
+    Q(r);
+  }
+  return e;
+}
+function br(t) {
+  var e = Ue(t);
+  if (t.equals(e) || (t.v = e, t.wv = Br()), !bt) {
+    var r = (ut || (t.f & q) !== 0) && t.deps !== null ? ct : P;
+    x(t, r);
+  }
+}
+function Wn(t, e, r) {
+  const n = Bt() ? ue : qe;
+  if (e.length === 0) {
+    r(t.map(n));
+    return;
+  }
+  var i = R, s = (
+    /** @type {Effect} */
+    b
+  ), f = Kn(), a = Hn();
+  Promise.all(e.map((u) => /* @__PURE__ */ Yn(u))).then((u) => {
+    i?.activate(), f();
+    try {
+      r([...t.map(n), ...u]);
+    } catch (l) {
+      (s.f & wt) === 0 && je(l, s);
+    }
+    i?.deactivate(), mr();
+  }).catch((u) => {
+    a.error(u);
+  });
+}
+function Kn() {
+  var t = b, e = y, r = O, n = R;
+  return function() {
+    Q(t), H(e), Qt(r), n?.activate();
+  };
+}
+function mr() {
+  Q(null), H(null), Qt(null);
+}
+const de = /* @__PURE__ */ new Set();
+let R = null, Ge = /* @__PURE__ */ new Set(), te = [];
+function yr() {
+  const t = (
+    /** @type {() => void} */
+    te.shift()
+  );
+  te.length > 0 && queueMicrotask(yr), t();
+}
+let pt = [], le = null, me = !1, zt = !1;
+class $t {
+  /**
+   * 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>}
+   */
+  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>}
+   */
+  #e = /* @__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>}
+   */
+  #t = /* @__PURE__ */ new Set();
+  /**
+   * The number of async effects that are currently in flight
+   */
+  #r = 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 = null;
+  /**
+   * True if an async effect inside this batch resolved and
+   * its parent branch was already deleted
+   */
+  #o = !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[]}
+   */
+  #i = [];
+  /**
+   * The same as `#async_effects`, but for effects inside a newly-created
+   * `<svelte:boundary>` — these do not prevent the batch from committing
+   * @type {Effect[]}
+   */
+  #f = [];
+  /**
+   * Template effects and `$effect.pre` effects, which run when
+   * a batch is committed
+   * @type {Effect[]}
+   */
+  #s = [];
+  /**
+   * The same as `#render_effects`, but for `$effect` (which runs after)
+   * @type {Effect[]}
+   */
+  #n = [];
+  /**
+   * Block effects, which may need to re-run on subsequent flushes
+   * in order to update internal sources (e.g. each block items)
+   * @type {Effect[]}
+   */
+  #a = [];
+  /**
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Effect[]}
+   */
+  #c = [];
+  /**
+   * Deferred effects that are MAYBE_DIRTY
+   * @type {Effect[]}
+   */
+  #v = [];
+  /**
+   * 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>}
+   */
+  skipped_effects = /* @__PURE__ */ new Set();
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(e) {
+    pt = [];
+    for (const i of e)
+      this.#h(i);
+    if (this.#i.length === 0 && this.#r === 0) {
+      this.#d();
+      var r = this.#s, n = this.#n;
+      this.#s = [], this.#n = [], this.#a = [], R = null, ze(r), ze(n), R === null ? R = this : de.delete(this), this.#l?.resolve();
+    } else
+      this.#u(this.#s), this.#u(this.#n), this.#u(this.#a);
+    for (const i of this.#i)
+      Nt(i);
+    for (const i of this.#f)
+      Nt(i);
+    this.#i = [], this.#f = [];
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   */
+  #h(e) {
+    e.f ^= P;
+    for (var r = e.first; r !== null; ) {
+      var n = r.f, i = (n & (st | ot)) !== 0, s = i && (n & P) !== 0, f = s || (n & V) !== 0 || this.skipped_effects.has(r);
+      if (!f && r.fn !== null) {
+        if (i)
+          r.f ^= P;
+        else if ((n & ke) !== 0)
+          this.#n.push(r);
+        else if ((n & P) === 0)
+          if ((n & Le) !== 0) {
+            var a = r.b?.is_pending() ? this.#f : this.#i;
+            a.push(r);
+          } else oe(r) && ((r.f & gt) !== 0 && this.#a.push(r), Nt(r));
+        var u = r.first;
+        if (u !== null) {
+          r = u;
+          continue;
+        }
+      }
+      var l = r.parent;
+      for (r = r.next; r === null && l !== null; )
+        r = l.next, l = l.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #u(e) {
+    for (const r of e)
+      ((r.f & B) !== 0 ? this.#c : this.#v).push(r), x(r, P);
+    e.length = 0;
+  }
+  /**
+   * 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) {
+    this.#e.has(e) || this.#e.set(e, r), this.current.set(e, e.v);
+  }
+  activate() {
+    R = this;
+  }
+  deactivate() {
+    R = null;
+    for (const e of Ge)
+      if (Ge.delete(e), e(), R !== null)
+        break;
+  }
+  neuter() {
+    this.#o = !0;
+  }
+  flush() {
+    pt.length > 0 ? Tr() : this.#d(), R === this && (this.#r === 0 && de.delete(this), this.deactivate());
+  }
+  /**
+   * Append and remove branches to/from the DOM
+   */
+  #d() {
+    if (!this.#o)
+      for (const e of this.#t)
+        e();
+    this.#t.clear();
+  }
+  increment() {
+    this.#r += 1;
+  }
+  decrement() {
+    if (this.#r -= 1, this.#r === 0) {
+      for (const e of this.#c)
+        x(e, B), Ct(e);
+      for (const e of this.#v)
+        x(e, ct), Ct(e);
+      this.#s = [], this.#n = [], this.flush();
+    } else
+      this.deactivate();
+  }
+  /** @param {() => void} fn */
+  add_callback(e) {
+    this.#t.add(e);
+  }
+  settled() {
+    return (this.#l ??= bn()).promise;
+  }
+  static ensure() {
+    if (R === null) {
+      const e = R = new $t();
+      de.add(R), zt || $t.enqueue(() => {
+        R === e && e.flush();
+      });
+    }
+    return R;
+  }
+  /** @param {() => void} task */
+  static enqueue(e) {
+    te.length === 0 && queueMicrotask(yr), te.unshift(e);
+  }
+}
+function Er(t) {
+  var e = zt;
+  zt = !0;
+  try {
+    for (var r; ; ) {
+      if (Bn(), pt.length === 0 && (R?.flush(), pt.length === 0))
+        return le = null, /** @type {T} */
+        r;
+      Tr();
+    }
+  } finally {
+    zt = e;
+  }
+}
+function Tr() {
+  var t = St;
+  me = !0;
+  try {
+    var e = 0;
+    for (Xe(!0); pt.length > 0; ) {
+      var r = $t.ensure();
+      if (e++ > 1e3) {
+        var n, i;
+        Gn();
+      }
+      r.process(pt), lt.clear();
+    }
+  } finally {
+    me = !1, Xe(t), le = null;
+  }
+}
+function Gn() {
+  try {
+    Cn();
+  } catch (t) {
+    je(t, le);
+  }
+}
+let dt = null;
+function ze(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var r = 0; r < e; ) {
+      var n = t[r++];
+      if ((n.f & (wt | V)) === 0 && oe(n) && (dt = [], Nt(n), n.deps === null && n.first === null && n.nodes_start === null && (n.teardown === null && n.ac === null ? Dr(n) : n.fn = null), dt?.length > 0)) {
+        lt.clear();
+        for (const i of dt)
+          Nt(i);
+        dt = [];
+      }
+    }
+    dt = null;
+  }
+}
+function Ct(t) {
+  for (var e = le = t; e.parent !== null; ) {
+    e = e.parent;
+    var r = e.f;
+    if (me && e === b && (r & gt) !== 0)
+      return;
+    if ((r & (ot | st)) !== 0) {
+      if ((r & P) === 0) return;
+      e.f ^= P;
+    }
+  }
+  pt.push(e);
+}
+const lt = /* @__PURE__ */ new Map();
+function Ft(t, e) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: _r,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function at(t, e) {
+  const r = Ft(t);
+  return qr(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function Ar(t, e = !1, r = !0) {
+  const n = Ft(t);
+  return e || (n.equals = pr), Pt && r && O !== null && O.l !== null && (O.l.s ??= []).push(n), n;
+}
+function et(t, e, r = !1) {
+  y !== 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
+  (!J || (y.f & Ke) !== 0) && Bt() && (y.f & (M | gt | Le | Ke)) !== 0 && !it?.includes(t) && xn();
+  let n = r ? Et(e) : e;
+  return jt(t, n);
+}
+function jt(t, e) {
+  if (!t.equals(e)) {
+    var r = t.v;
+    bt ? lt.set(t, e) : lt.set(t, r), t.v = e;
+    var n = $t.ensure();
+    n.capture(t, r), (t.f & M) !== 0 && ((t.f & B) !== 0 && Ue(
+      /** @type {Derived} */
+      t
+    ), x(t, (t.f & q) === 0 ? P : ct)), t.wv = Br(), Sr(t, B), Bt() && b !== null && (b.f & P) !== 0 && (b.f & (st | ot)) === 0 && (D === null ? ii([t]) : D.push(t));
+  }
+  return e;
+}
+function he(t) {
+  et(t, t.v + 1);
+}
+function Sr(t, e) {
+  var r = t.reactions;
+  if (r !== null)
+    for (var n = Bt(), i = r.length, s = 0; s < i; s++) {
+      var f = r[s], a = f.f;
+      if (!(!n && f === b)) {
+        var u = (a & B) === 0;
+        u && x(f, e), (a & M) !== 0 ? Sr(
+          /** @type {Derived} */
+          f,
+          ct
+        ) : u && ((a & gt) !== 0 && dt !== null && dt.push(
+          /** @type {Effect} */
+          f
+        ), Ct(
+          /** @type {Effect} */
+          f
+        ));
+      }
+    }
+}
+function Et(t) {
+  if (typeof t != "object" || t === null || At in t)
+    return t;
+  const e = or(t);
+  if (e !== gn && e !== wn)
+    return t;
+  var r = /* @__PURE__ */ new Map(), n = Ie(t), i = /* @__PURE__ */ at(0), s = _t, f = (a) => {
+    if (_t === s)
+      return a();
+    var u = y, l = _t;
+    H(null), Qe(s);
+    var o = a();
+    return H(u), Qe(l), o;
+  };
+  return n && r.set("length", /* @__PURE__ */ at(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(a, u, l) {
+        (!("value" in l) || l.configurable === !1 || l.enumerable === !1 || l.writable === !1) && Pn();
+        var o = r.get(u);
+        return o === void 0 ? o = f(() => {
+          var d = /* @__PURE__ */ at(l.value);
+          return r.set(u, d), d;
+        }) : et(o, l.value, !0), !0;
+      },
+      deleteProperty(a, u) {
+        var l = r.get(u);
+        if (l === void 0) {
+          if (u in a) {
+            const o = f(() => /* @__PURE__ */ at(I));
+            r.set(u, o), he(i);
+          }
+        } else
+          et(l, I), he(i);
+        return !0;
+      },
+      get(a, u, l) {
+        if (u === At)
+          return t;
+        var o = r.get(u), d = u in a;
+        if (o === void 0 && (!d || nt(a, u)?.writable) && (o = f(() => {
+          var h = Et(d ? a[u] : I), c = /* @__PURE__ */ at(h);
+          return c;
+        }), r.set(u, o)), o !== void 0) {
+          var v = j(o);
+          return v === I ? void 0 : v;
+        }
+        return Reflect.get(a, u, l);
+      },
+      getOwnPropertyDescriptor(a, u) {
+        var l = Reflect.getOwnPropertyDescriptor(a, u);
+        if (l && "value" in l) {
+          var o = r.get(u);
+          o && (l.value = j(o));
+        } else if (l === void 0) {
+          var d = r.get(u), v = d?.v;
+          if (d !== void 0 && v !== I)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: v,
+              writable: !0
+            };
+        }
+        return l;
+      },
+      has(a, u) {
+        if (u === At)
+          return !0;
+        var l = r.get(u), o = l !== void 0 && l.v !== I || Reflect.has(a, u);
+        if (l !== void 0 || b !== null && (!o || nt(a, u)?.writable)) {
+          l === void 0 && (l = f(() => {
+            var v = o ? Et(a[u]) : I, h = /* @__PURE__ */ at(v);
+            return h;
+          }), r.set(u, l));
+          var d = j(l);
+          if (d === I)
+            return !1;
+        }
+        return o;
+      },
+      set(a, u, l, o) {
+        var d = r.get(u), v = u in a;
+        if (n && u === "length")
+          for (var h = l; h < /** @type {Source<number>} */
+          d.v; h += 1) {
+            var c = r.get(h + "");
+            c !== void 0 ? et(c, I) : h in a && (c = f(() => /* @__PURE__ */ at(I)), r.set(h + "", c));
+          }
+        if (d === void 0)
+          (!v || nt(a, u)?.writable) && (d = f(() => /* @__PURE__ */ at(void 0)), et(d, Et(l)), r.set(u, d));
+        else {
+          v = d.v !== I;
+          var _ = f(() => Et(l));
+          et(d, _);
+        }
+        var p = Reflect.getOwnPropertyDescriptor(a, u);
+        if (p?.set && p.set.call(o, l), !v) {
+          if (n && typeof u == "string") {
+            var w = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), g = Number(u);
+            Number.isInteger(g) && g >= w.v && et(w, g + 1);
+          }
+          he(i);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        j(i);
+        var u = Reflect.ownKeys(a).filter((d) => {
+          var v = r.get(d);
+          return v === void 0 || v.v !== I;
+        });
+        for (var [l, o] of r)
+          o.v !== I && !(l in a) && u.push(l);
+        return u;
+      },
+      setPrototypeOf() {
+        kn();
+      }
+    }
+  );
+}
+var Je, Nr, Or, Cr;
+function ye() {
+  if (Je === void 0) {
+    Je = window, Nr = /Firefox/.test(navigator.userAgent);
+    var t = Element.prototype, e = Node.prototype, r = Text.prototype;
+    Or = nt(e, "firstChild").get, Cr = nt(e, "nextSibling").get, We(t) && (t.__click = void 0, t.__className = void 0, t.__attributes = null, t.__style = void 0, t.__e = void 0), We(r) && (r.__t = void 0);
+  }
+}
+function X(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function F(t) {
+  return Or.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function ft(t) {
+  return Cr.call(t);
+}
+function Bi(t, e) {
+  if (!E)
+    return /* @__PURE__ */ F(t);
+  var r = (
+    /** @type {TemplateNode} */
+    /* @__PURE__ */ F(A)
+  );
+  if (r === null)
+    r = A.appendChild(X());
+  else if (e && r.nodeType !== Fe) {
+    var n = X();
+    return r?.before(n), U(n), n;
+  }
+  return U(r), r;
+}
+function Hi(t, e) {
+  if (!E) {
+    var r = (
+      /** @type {DocumentFragment} */
+      /* @__PURE__ */ F(
+        /** @type {Node} */
+        t
+      )
+    );
+    return r instanceof Comment && r.data === "" ? /* @__PURE__ */ ft(r) : r;
+  }
+  return A;
+}
+function Yi(t, e = 1, r = !1) {
+  let n = E ? A : t;
+  for (var i; e--; )
+    i = n, n = /** @type {TemplateNode} */
+    /* @__PURE__ */ ft(n);
+  if (!E)
+    return n;
+  if (r && n?.nodeType !== Fe) {
+    var s = X();
+    return n === null ? i?.after(s) : n.before(s), U(s), s;
+  }
+  return U(n), /** @type {TemplateNode} */
+  n;
+}
+function Rr(t) {
+  t.textContent = "";
+}
+function Ir() {
+  return !1;
+}
+function Ht(t) {
+  var e = y, r = b;
+  H(null), Q(null);
+  try {
+    return t();
+  } finally {
+    H(e), Q(r);
+  }
+}
+function zn(t) {
+  b === null && y === null && On(), y !== null && (y.f & q) !== 0 && b === null && Nn(), bt && Sn();
+}
+function Jn(t, e) {
+  var r = e.last;
+  r === null ? e.last = e.first = t : (r.next = t, t.prev = r, e.last = t);
+}
+function tt(t, e, r, n = !0) {
+  var i = b;
+  i !== null && (i.f & V) !== 0 && (t |= V);
+  var s = {
+    ctx: O,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | B,
+    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 {
+      Nt(s), s.f |= ie;
+    } catch (u) {
+      throw Z(s), u;
+    }
+  else e !== null && Ct(s);
+  if (n) {
+    var f = s;
+    if (r && f.deps === null && f.teardown === null && f.nodes_start === null && f.first === f.last && // either `null`, or a singular child
+    (f.f & It) === 0 && (f = f.first), f !== null && (f.parent = i, i !== null && Jn(f, i), y !== null && (y.f & M) !== 0 && (t & ot) === 0)) {
+      var a = (
+        /** @type {Derived} */
+        y
+      );
+      (a.effects ??= []).push(f);
+    }
+  }
+  return s;
+}
+function Xn(t) {
+  const e = tt(xe, null, !1);
+  return x(e, P), e.teardown = t, e;
+}
+function Zn(t) {
+  zn();
+  var e = (
+    /** @type {Effect} */
+    b.f
+  ), r = !y && (e & st) !== 0 && (e & ie) === 0;
+  if (r) {
+    var n = (
+      /** @type {ComponentContext} */
+      O
+    );
+    (n.e ??= []).push(t);
+  } else
+    return Pr(t);
+}
+function Pr(t) {
+  return tt(ke | yn, t, !1);
+}
+function Qn(t) {
+  $t.ensure();
+  const e = tt(ot | It, t, !0);
+  return () => {
+    Z(e);
+  };
+}
+function ti(t) {
+  $t.ensure();
+  const e = tt(ot | It, t, !0);
+  return (r = {}) => new Promise((n) => {
+    r.outro ? He(e, () => {
+      Z(e), n(void 0);
+    }) : (Z(e), n(void 0));
+  });
+}
+function Be(t) {
+  return tt(ke, t, !1);
+}
+function ei(t) {
+  return tt(Le | It, t, !0);
+}
+function kr(t, e = 0) {
+  return tt(xe | e, t, !0);
+}
+function Vi(t, e = [], r = []) {
+  Wn(e, r, (n) => {
+    tt(xe, () => t(...n.map(j)), !0);
+  });
+}
+function xr(t, e = 0) {
+  var r = tt(gt | e, t, !0);
+  return r;
+}
+function Rt(t, e = !0) {
+  return tt(st | It, t, !0, e);
+}
+function Lr(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const r = bt, n = y;
+    Ze(!0), H(null);
+    try {
+      e.call(null);
+    } finally {
+      Ze(r), H(n);
+    }
+  }
+}
+function Mr(t, e = !1) {
+  var r = t.first;
+  for (t.first = t.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && Ht(() => {
+      i.abort(De);
+    });
+    var n = r.next;
+    (r.f & ot) !== 0 ? r.parent = null : Z(r, e), r = n;
+  }
+}
+function ri(t) {
+  for (var e = t.first; e !== null; ) {
+    var r = e.next;
+    (e.f & st) === 0 && Z(e), e = r;
+  }
+}
+function Z(t, e = !0) {
+  var r = !1;
+  (e || (t.f & mn) !== 0) && t.nodes_start !== null && t.nodes_end !== null && (ni(
+    t.nodes_start,
+    /** @type {TemplateNode} */
+    t.nodes_end
+  ), r = !0), Mr(t, e && !r), ee(t, 0), x(t, wt);
+  var n = t.transitions;
+  if (n !== null)
+    for (const s of n)
+      s.stop();
+  Lr(t);
+  var i = t.parent;
+  i !== null && i.first !== null && Dr(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes_start = t.nodes_end = t.ac = null;
+}
+function ni(t, e) {
+  for (; t !== null; ) {
+    var r = t === e ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ ft(t)
+    );
+    t.remove(), t = r;
+  }
+}
+function Dr(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 He(t, e) {
+  var r = [];
+  Ye(t, r, !0), Fr(r, () => {
+    Z(t), e && e();
+  });
+}
+function Fr(t, e) {
+  var r = t.length;
+  if (r > 0) {
+    var n = () => --r || e();
+    for (var i of t)
+      i.out(n);
+  } else
+    e();
+}
+function Ye(t, e, r) {
+  if ((t.f & V) === 0) {
+    if (t.f ^= V, t.transitions !== null)
+      for (const f of t.transitions)
+        (f.is_global || r) && e.push(f);
+    for (var n = t.first; n !== null; ) {
+      var i = n.next, s = (n.f & se) !== 0 || (n.f & st) !== 0;
+      Ye(n, e, s ? r : !1), n = i;
+    }
+  }
+}
+function Ve(t) {
+  jr(t, !0);
+}
+function jr(t, e) {
+  if ((t.f & V) !== 0) {
+    t.f ^= V, (t.f & P) === 0 && (x(t, B), Ct(t));
+    for (var r = t.first; r !== null; ) {
+      var n = r.next, i = (r.f & se) !== 0 || (r.f & st) !== 0;
+      jr(r, i ? e : !1), r = n;
+    }
+    if (t.transitions !== null)
+      for (const s of t.transitions)
+        (s.is_global || e) && s.in();
+  }
+}
+let St = !1;
+function Xe(t) {
+  St = t;
+}
+let bt = !1;
+function Ze(t) {
+  bt = t;
+}
+let y = null, J = !1;
+function H(t) {
+  y = t;
+}
+let b = null;
+function Q(t) {
+  b = t;
+}
+let it = null;
+function qr(t) {
+  y !== null && (it === null ? it = [t] : it.push(t));
+}
+let k = null, L = 0, D = null;
+function ii(t) {
+  D = t;
+}
+let Ur = 1, qt = 0, _t = qt;
+function Qe(t) {
+  _t = t;
+}
+let ut = !1;
+function Br() {
+  return ++Ur;
+}
+function oe(t) {
+  var e = t.f;
+  if ((e & B) !== 0)
+    return !0;
+  if ((e & ct) !== 0) {
+    var r = t.deps, n = (e & q) !== 0;
+    if (r !== null) {
+      var i, s, f = (e & Zt) !== 0, a = n && b !== null && !ut, u = r.length;
+      if ((f || a) && (b === null || (b.f & wt) === 0)) {
+        var l = (
+          /** @type {Derived} */
+          t
+        ), o = l.parent;
+        for (i = 0; i < u; i++)
+          s = r[i], (f || !s?.reactions?.includes(l)) && (s.reactions ??= []).push(l);
+        f && (l.f ^= Zt), a && o !== null && (o.f & q) === 0 && (l.f ^= q);
+      }
+      for (i = 0; i < u; i++)
+        if (s = r[i], oe(
+          /** @type {Derived} */
+          s
+        ) && br(
+          /** @type {Derived} */
+          s
+        ), s.wv > t.wv)
+          return !0;
+    }
+    (!n || b !== null && !ut) && x(t, P);
+  }
+  return !1;
+}
+function Hr(t, e, r = !0) {
+  var n = t.reactions;
+  if (n !== null && !it?.includes(t))
+    for (var i = 0; i < n.length; i++) {
+      var s = n[i];
+      (s.f & M) !== 0 ? Hr(
+        /** @type {Derived} */
+        s,
+        e,
+        !1
+      ) : e === s && (r ? x(s, B) : (s.f & P) !== 0 && x(s, ct), Ct(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Yr(t) {
+  var e = k, r = L, n = D, i = y, s = ut, f = it, a = O, u = J, l = _t, o = t.f;
+  k = /** @type {null | Value[]} */
+  null, L = 0, D = null, ut = (o & q) !== 0 && (J || !St || y === null), y = (o & (st | ot)) === 0 ? t : null, it = null, Qt(t.ctx), J = !1, _t = ++qt, t.ac !== null && (Ht(() => {
+    t.ac.abort(De);
+  }), t.ac = null);
+  try {
+    t.f |= ge;
+    var d = (
+      /** @type {Function} */
+      t.fn
+    ), v = d(), h = t.deps;
+    if (k !== null) {
+      var c;
+      if (ee(t, L), h !== null && L > 0)
+        for (h.length = L + k.length, c = 0; c < k.length; c++)
+          h[L + c] = k[c];
+      else
+        t.deps = h = k;
+      if (!ut || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (o & M) !== 0 && /** @type {import('#client').Derived} */
+      t.reactions !== null)
+        for (c = L; c < h.length; c++)
+          (h[c].reactions ??= []).push(t);
+    } else h !== null && L < h.length && (ee(t, L), h.length = L);
+    if (Bt() && D !== null && !J && h !== null && (t.f & (M | ct | B)) === 0)
+      for (c = 0; c < /** @type {Source[]} */
+      D.length; c++)
+        Hr(
+          D[c],
+          /** @type {Effect} */
+          t
+        );
+    return i !== null && i !== t && (qt++, D !== null && (n === null ? n = D : n.push(.../** @type {Source[]} */
+    D))), (t.f & ht) !== 0 && (t.f ^= ht), v;
+  } catch (_) {
+    return qn(_);
+  } finally {
+    t.f ^= ge, k = e, L = r, D = n, y = i, ut = s, it = f, Qt(a), J = u, _t = l;
+  }
+}
+function si(t, e) {
+  let r = e.reactions;
+  if (r !== null) {
+    var n = pn.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 & M) !== 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
+  (k === null || !k.includes(e)) && (x(e, ct), (e.f & (q | Zt)) === 0 && (e.f ^= Zt), wr(
+    /** @type {Derived} **/
+    e
+  ), ee(
+    /** @type {Derived} **/
+    e,
+    0
+  ));
+}
+function ee(t, e) {
+  var r = t.deps;
+  if (r !== null)
+    for (var n = e; n < r.length; n++)
+      si(t, r[n]);
+}
+function Nt(t) {
+  var e = t.f;
+  if ((e & wt) === 0) {
+    x(t, P);
+    var r = b, n = St;
+    b = t, St = !0;
+    try {
+      (e & gt) !== 0 ? ri(t) : Mr(t), Lr(t);
+      var i = Yr(t);
+      t.teardown = typeof i == "function" ? i : null, t.wv = Ur;
+      var s;
+      lr && Mn && (t.f & B) !== 0 && t.deps;
+    } finally {
+      St = n, b = r;
+    }
+  }
+}
+async function Wi() {
+  await Promise.resolve(), Er();
+}
+function j(t) {
+  var e = t.f, r = (e & M) !== 0;
+  if (y !== null && !J) {
+    var n = b !== null && (b.f & wt) !== 0;
+    if (!n && !it?.includes(t)) {
+      var i = y.deps;
+      if ((y.f & ge) !== 0)
+        t.rv < qt && (t.rv = qt, k === null && i !== null && i[L] === t ? L++ : k === null ? k = [t] : (!ut || !k.includes(t)) && k.push(t));
+      else {
+        (y.deps ??= []).push(t);
+        var s = t.reactions;
+        s === null ? t.reactions = [y] : s.includes(y) || s.push(y);
+      }
+    }
+  } else if (r && /** @type {Derived} */
+  t.deps === null && /** @type {Derived} */
+  t.effects === null) {
+    var f = (
+      /** @type {Derived} */
+      t
+    ), a = f.parent;
+    a !== null && (a.f & q) === 0 && (f.f ^= q);
+  }
+  if (bt) {
+    if (lt.has(t))
+      return lt.get(t);
+    if (r) {
+      f = /** @type {Derived} */
+      t;
+      var u = f.v;
+      return ((f.f & P) === 0 && f.reactions !== null || Vr(f)) && (u = Ue(f)), lt.set(f, u), u;
+    }
+  } else r && (f = /** @type {Derived} */
+  t, oe(f) && br(f));
+  if ((t.f & ht) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Vr(t) {
+  if (t.v === I) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (lt.has(e) || (e.f & M) !== 0 && Vr(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+function Yt(t) {
+  var e = J;
+  try {
+    return J = !0, t();
+  } finally {
+    J = e;
+  }
+}
+const fi = -7169;
+function x(t, e) {
+  t.f = t.f & fi | e;
+}
+const Wr = /* @__PURE__ */ new Set(), Ee = /* @__PURE__ */ new Set();
+function ai(t, e, r, n = {}) {
+  function i(s) {
+    if (n.capture || Lt.call(e, s), !s.cancelBubble)
+      return Ht(() => r?.call(this, s));
+  }
+  return t.startsWith("pointer") || t.startsWith("touch") || t === "wheel" ? ae(() => {
+    e.addEventListener(t, i, n);
+  }) : e.addEventListener(t, i, n), i;
+}
+function Ki(t, e, r, n, i) {
+  var s = { capture: n, passive: i }, f = ai(t, e, r, s);
+  (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) && Xn(() => {
+    e.removeEventListener(t, f, s);
+  });
+}
+function Gi(t) {
+  for (var e = 0; e < t.length; e++)
+    Wr.add(t[e]);
+  for (var r of Ee)
+    r(t);
+}
+let tr = null;
+function Lt(t) {
+  var e = this, r = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), n = t.type, i = t.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    i[0] || t.target
+  );
+  tr = t;
+  var f = 0, a = tr === t && t.__root;
+  if (a) {
+    var u = i.indexOf(a);
+    if (u !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t.__root = e;
+      return;
+    }
+    var l = i.indexOf(e);
+    if (l === -1)
+      return;
+    u <= l && (f = u);
+  }
+  if (s = /** @type {Element} */
+  i[f] || t.target, s !== e) {
+    Ot(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || r;
+      }
+    });
+    var o = y, d = b;
+    H(null), Q(null);
+    try {
+      for (var v, h = []; s !== null; ) {
+        var c = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var _ = s["__" + n];
+          if (_ != null && (!/** @type {any} */
+          s.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 === s))
+            if (Ie(_)) {
+              var [p, ...w] = _;
+              p.apply(s, [t, ...w]);
+            } else
+              _.call(s, t);
+        } catch (g) {
+          v ? h.push(g) : v = g;
+        }
+        if (t.cancelBubble || c === e || c === null)
+          break;
+        s = c;
+      }
+      if (v) {
+        for (let g of h)
+          queueMicrotask(() => {
+            throw g;
+          });
+        throw v;
+      }
+    } finally {
+      t.__root = e, delete t.currentTarget, H(o), Q(d);
+    }
+  }
+}
+function Kr(t) {
+  var e = document.createElement("template");
+  return e.innerHTML = t.replaceAll("<!>", "<!---->"), e.content;
+}
+function W(t, e) {
+  var r = (
+    /** @type {Effect} */
+    b
+  );
+  r.nodes_start === null && (r.nodes_start = t, r.nodes_end = e);
+}
+// @__NO_SIDE_EFFECTS__
+function zi(t, e) {
+  var r = (e & ar) !== 0, n = (e & hn) !== 0, i, s = !t.startsWith("<!>");
+  return () => {
+    if (E)
+      return W(A, null), A;
+    i === void 0 && (i = Kr(s ? t : "<!>" + t), r || (i = /** @type {Node} */
+    /* @__PURE__ */ F(i)));
+    var f = (
+      /** @type {TemplateNode} */
+      n || Nr ? document.importNode(i, !0) : i.cloneNode(!0)
+    );
+    if (r) {
+      var a = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ F(f)
+      ), u = (
+        /** @type {TemplateNode} */
+        f.lastChild
+      );
+      W(a, u);
+    } else
+      W(f, f);
+    return f;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function ui(t, e, r = "svg") {
+  var n = !t.startsWith("<!>"), i = (e & ar) !== 0, s = `<${r}>${n ? t : "<!>" + t}</${r}>`, f;
+  return () => {
+    if (E)
+      return W(A, null), A;
+    if (!f) {
+      var a = (
+        /** @type {DocumentFragment} */
+        Kr(s)
+      ), u = (
+        /** @type {Element} */
+        /* @__PURE__ */ F(a)
+      );
+      if (i)
+        for (f = document.createDocumentFragment(); /* @__PURE__ */ F(u); )
+          f.appendChild(
+            /** @type {Node} */
+            /* @__PURE__ */ F(u)
+          );
+      else
+        f = /** @type {Element} */
+        /* @__PURE__ */ F(u);
+    }
+    var l = (
+      /** @type {TemplateNode} */
+      f.cloneNode(!0)
+    );
+    if (i) {
+      var o = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ F(l)
+      ), d = (
+        /** @type {TemplateNode} */
+        l.lastChild
+      );
+      W(o, d);
+    } else
+      W(l, l);
+    return l;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ji(t, e) {
+  return /* @__PURE__ */ ui(t, e, "svg");
+}
+function Xi(t = "") {
+  if (!E) {
+    var e = X(t + "");
+    return W(e, e), e;
+  }
+  var r = A;
+  return r.nodeType !== Fe && (r.before(r = X()), U(r)), W(r, r), r;
+}
+function Zi() {
+  if (E)
+    return W(A, null), A;
+  var t = document.createDocumentFragment(), e = document.createComment(""), r = X();
+  return t.append(e, r), W(e, r), t;
+}
+function li(t, e) {
+  if (E) {
+    b.nodes_end = A, Ut();
+    return;
+  }
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+const oi = ["touchstart", "touchmove"];
+function ci(t) {
+  return oi.includes(t);
+}
+let Te = !0;
+function Qi(t, e) {
+  var r = e == null ? "" : typeof e == "object" ? e + "" : e;
+  r !== (t.__t ??= t.nodeValue) && (t.__t = r, t.nodeValue = r + "");
+}
+function Gr(t, e) {
+  return zr(t, e);
+}
+function vi(t, e) {
+  ye(), e.intro = e.intro ?? !1;
+  const r = e.target, n = E, i = A;
+  try {
+    for (var s = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ F(r)
+    ); s && (s.nodeType !== Mt || /** @type {Comment} */
+    s.data !== ur); )
+      s = /** @type {TemplateNode} */
+      /* @__PURE__ */ ft(s);
+    if (!s)
+      throw Tt;
+    Y(!0), U(
+      /** @type {Comment} */
+      s
+    ), Ut();
+    const f = zr(t, { ...e, anchor: s });
+    if (A === null || A.nodeType !== Mt || /** @type {Comment} */
+    A.data !== Re)
+      throw fe(), Tt;
+    return Y(!1), /**  @type {Exports} */
+    f;
+  } catch (f) {
+    if (f instanceof Error && f.message.split(`
+`).some((a) => a.startsWith("https://svelte.dev/e/")))
+      throw f;
+    return f !== Tt && console.warn("Failed to hydrate: ", f), e.recover === !1 && Rn(), ye(), Rr(r), Y(!1), Gr(t, e);
+  } finally {
+    Y(n), U(i);
+  }
+}
+const mt = /* @__PURE__ */ new Map();
+function zr(t, { target: e, anchor: r, props: n = {}, events: i, context: s, intro: f = !0 }) {
+  ye();
+  var a = /* @__PURE__ */ new Set(), u = (d) => {
+    for (var v = 0; v < d.length; v++) {
+      var h = d[v];
+      if (!a.has(h)) {
+        a.add(h);
+        var c = ci(h);
+        e.addEventListener(h, Lt, { passive: c });
+        var _ = mt.get(h);
+        _ === void 0 ? (document.addEventListener(h, Lt, { passive: c }), mt.set(h, 1)) : mt.set(h, _ + 1);
+      }
+    }
+  };
+  u(Pe(Wr)), Ee.add(u);
+  var l = void 0, o = ti(() => {
+    var d = r ?? e.appendChild(X());
+    return Rt(() => {
+      if (s) {
+        Dn({});
+        var v = (
+          /** @type {ComponentContext} */
+          O
+        );
+        v.c = s;
+      }
+      i && (n.$$events = i), E && W(
+        /** @type {TemplateNode} */
+        d,
+        null
+      ), Te = f, l = t(d, n) || {}, Te = !0, E && (b.nodes_end = A), s && Fn();
+    }), () => {
+      for (var v of a) {
+        e.removeEventListener(v, Lt);
+        var h = (
+          /** @type {number} */
+          mt.get(v)
+        );
+        --h === 0 ? (document.removeEventListener(v, Lt), mt.delete(v)) : mt.set(v, h);
+      }
+      Ee.delete(u), d !== r && d.parentNode?.removeChild(d);
+    };
+  });
+  return Ae.set(l, o), l;
+}
+let Ae = /* @__PURE__ */ new WeakMap();
+function di(t, e) {
+  const r = Ae.get(t);
+  return r ? (Ae.delete(t), r(e)) : Promise.resolve();
+}
+function hi(t) {
+  O === null && dr(), Pt && O.l !== null ? _i(O).m.push(t) : Zn(() => {
+    const e = Yt(t);
+    if (typeof e == "function") return (
+      /** @type {() => void} */
+      e
+    );
+  });
+}
+function ts(t) {
+  O === null && dr(), hi(() => () => Yt(t));
+}
+function _i(t) {
+  var e = (
+    /** @type {ComponentContextLegacy} */
+    t.l
+  );
+  return e.u ??= { a: [], b: [], m: [] };
+}
+function es(t, e, r = !1) {
+  E && Ut();
+  var n = t, i = null, s = null, f = I, a = r ? se : 0, u = !1;
+  const l = (h, c = !0) => {
+    u = !0, v(c, h);
+  };
+  var o = null;
+  function d() {
+    o !== null && (o.lastChild.remove(), n.before(o), o = null);
+    var h = f ? i : s, c = f ? s : i;
+    h && Ve(h), c && He(c, () => {
+      f ? s = null : i = null;
+    });
+  }
+  const v = (h, c) => {
+    if (f === (f = h)) return;
+    let _ = !1;
+    if (E) {
+      const S = hr(n) === Ce;
+      !!f === S && (n = we(), U(n), Y(!1), _ = !0);
+    }
+    var p = Ir(), w = n;
+    if (p && (o = document.createDocumentFragment(), o.append(w = X())), f ? i ??= c && Rt(() => c(w)) : s ??= c && Rt(() => c(w)), p) {
+      var g = (
+        /** @type {Batch} */
+        R
+      ), m = f ? i : s, N = f ? s : i;
+      m && g.skipped_effects.delete(m), N && g.skipped_effects.add(N), g.add_callback(d);
+    } else
+      d();
+    _ && Y(!0);
+  };
+  xr(() => {
+    u = !1, e(l), u || v(null, null);
+  }, a), E && (n = A);
+}
+function rs(t, e) {
+  return e;
+}
+function pi(t, e, r) {
+  for (var n = t.items, i = [], s = e.length, f = 0; f < s; f++)
+    Ye(e[f].e, i, !0);
+  var a = s > 0 && i.length === 0 && r !== null;
+  if (a) {
+    var u = (
+      /** @type {Element} */
+      /** @type {Element} */
+      r.parentNode
+    );
+    Rr(u), u.append(
+      /** @type {Element} */
+      r
+    ), n.clear(), z(t, e[0].prev, e[s - 1].next);
+  }
+  Fr(i, () => {
+    for (var l = 0; l < s; l++) {
+      var o = e[l];
+      a || (n.delete(o.k), z(t, o.prev, o.next)), Z(o.e, !a);
+    }
+  });
+}
+function ns(t, e, r, n, i, s = null) {
+  var f = t, a = { flags: e, items: /* @__PURE__ */ new Map(), first: null }, u = (e & fr) !== 0;
+  if (u) {
+    var l = (
+      /** @type {Element} */
+      t
+    );
+    f = E ? U(
+      /** @type {Comment | Text} */
+      /* @__PURE__ */ F(l)
+    ) : l.appendChild(X());
+  }
+  E && Ut();
+  var o = null, d = !1, v = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ qe(() => {
+    var w = r();
+    return Ie(w) ? w : w == null ? [] : Pe(w);
+  }), c, _;
+  function p() {
+    $i(
+      _,
+      c,
+      a,
+      v,
+      f,
+      i,
+      e,
+      n,
+      r
+    ), s !== null && (c.length === 0 ? o ? Ve(o) : o = Rt(() => s(f)) : o !== null && He(o, () => {
+      o = null;
+    }));
+  }
+  xr(() => {
+    _ ??= /** @type {Effect} */
+    b, c = /** @type {V[]} */
+    j(h);
+    var w = c.length;
+    if (d && w === 0)
+      return;
+    d = w === 0;
+    let g = !1;
+    if (E) {
+      var m = hr(f) === Ce;
+      m !== (w === 0) && (f = we(), U(f), Y(!1), g = !0);
+    }
+    if (E) {
+      for (var N = null, S, $ = 0; $ < w; $++) {
+        if (A.nodeType === Mt && /** @type {Comment} */
+        A.data === Re) {
+          f = /** @type {Comment} */
+          A, g = !0, Y(!1);
+          break;
+        }
+        var T = c[$], C = n(T, $);
+        S = Se(
+          A,
+          a,
+          N,
+          null,
+          T,
+          C,
+          $,
+          i,
+          e,
+          r
+        ), a.items.set(C, S), N = S;
+      }
+      w > 0 && U(we());
+    }
+    if (E)
+      w === 0 && s && (o = Rt(() => s(f)));
+    else if (Ir()) {
+      var K = /* @__PURE__ */ new Set(), Vt = (
+        /** @type {Batch} */
+        R
+      );
+      for ($ = 0; $ < w; $ += 1) {
+        T = c[$], C = n(T, $);
+        var vt = a.items.get(C) ?? v.get(C);
+        vt ? (e & (re | ne)) !== 0 && Jr(vt, T, $, e) : (S = Se(
+          null,
+          a,
+          null,
+          null,
+          T,
+          C,
+          $,
+          i,
+          e,
+          r,
+          !0
+        ), v.set(C, S)), K.add(C);
+      }
+      for (const [G, Wt] of a.items)
+        K.has(G) || Vt.skipped_effects.add(Wt.e);
+      Vt.add_callback(p);
+    } else
+      p();
+    g && Y(!0), j(h);
+  }), E && (f = A);
+}
+function $i(t, e, r, n, i, s, f, a, u) {
+  var l = (f & nn) !== 0, o = (f & (re | ne)) !== 0, d = e.length, v = r.items, h = r.first, c = h, _, p = null, w, g = [], m = [], N, S, $, T;
+  if (l)
+    for (T = 0; T < d; T += 1)
+      N = e[T], S = a(N, T), $ = v.get(S), $ !== void 0 && ($.a?.measure(), (w ??= /* @__PURE__ */ new Set()).add($));
+  for (T = 0; T < d; T += 1) {
+    if (N = e[T], S = a(N, T), $ = v.get(S), $ === void 0) {
+      var C = n.get(S);
+      if (C !== void 0) {
+        n.delete(S), v.set(S, C);
+        var K = p ? p.next : c;
+        z(r, p, C), z(r, C, K), _e(C, K, i), p = C;
+      } else {
+        var Vt = c ? (
+          /** @type {TemplateNode} */
+          c.e.nodes_start
+        ) : i;
+        p = Se(
+          Vt,
+          r,
+          p,
+          p === null ? r.first : p.next,
+          N,
+          S,
+          T,
+          s,
+          f,
+          u
+        );
+      }
+      v.set(S, p), g = [], m = [], c = p.next;
+      continue;
+    }
+    if (o && Jr($, N, T, f), ($.e.f & V) !== 0 && (Ve($.e), l && ($.a?.unfix(), (w ??= /* @__PURE__ */ new Set()).delete($))), $ !== c) {
+      if (_ !== void 0 && _.has($)) {
+        if (g.length < m.length) {
+          var vt = m[0], G;
+          p = vt.prev;
+          var Wt = g[0], ce = g[g.length - 1];
+          for (G = 0; G < g.length; G += 1)
+            _e(g[G], vt, i);
+          for (G = 0; G < m.length; G += 1)
+            _.delete(m[G]);
+          z(r, Wt.prev, ce.next), z(r, p, Wt), z(r, ce, vt), c = vt, p = ce, T -= 1, g = [], m = [];
+        } else
+          _.delete($), _e($, c, i), z(r, $.prev, $.next), z(r, $, p === null ? r.first : p.next), z(r, p, $), p = $;
+        continue;
+      }
+      for (g = [], m = []; c !== null && c.k !== S; )
+        (c.e.f & V) === 0 && (_ ??= /* @__PURE__ */ new Set()).add(c), m.push(c), c = c.next;
+      if (c === null)
+        continue;
+      $ = c;
+    }
+    g.push($), p = $, c = $.next;
+  }
+  if (c !== null || _ !== void 0) {
+    for (var kt = _ === void 0 ? [] : Pe(_); c !== null; )
+      (c.e.f & V) === 0 && kt.push(c), c = c.next;
+    var ve = kt.length;
+    if (ve > 0) {
+      var en = (f & fr) !== 0 && d === 0 ? i : null;
+      if (l) {
+        for (T = 0; T < ve; T += 1)
+          kt[T].a?.measure();
+        for (T = 0; T < ve; T += 1)
+          kt[T].a?.fix();
+      }
+      pi(r, kt, en);
+    }
+  }
+  l && ae(() => {
+    if (w !== void 0)
+      for ($ of w)
+        $.a?.apply();
+  }), t.first = r.first && r.first.e, t.last = p && p.e;
+  for (var rn of n.values())
+    Z(rn.e);
+  n.clear();
+}
+function Jr(t, e, r, n) {
+  (n & re) !== 0 && jt(t.v, e), (n & ne) !== 0 ? jt(
+    /** @type {Value<number>} */
+    t.i,
+    r
+  ) : t.i = r;
+}
+function Se(t, e, r, n, i, s, f, a, u, l, o) {
+  var d = (u & re) !== 0, v = (u & sn) === 0, h = d ? v ? /* @__PURE__ */ Ar(i, !1, !1) : Ft(i) : i, c = (u & ne) === 0 ? f : Ft(f), _ = {
+    i: c,
+    v: h,
+    k: s,
+    a: null,
+    // @ts-expect-error
+    e: null,
+    prev: r,
+    next: n
+  };
+  try {
+    if (t === null) {
+      var p = document.createDocumentFragment();
+      p.append(t = X());
+    }
+    return _.e = Rt(() => a(
+      /** @type {Node} */
+      t,
+      h,
+      c,
+      l
+    ), E), _.e.prev = r && r.e, _.e.next = n && n.e, r === null ? o || (e.first = _) : (r.next = _, r.e.next = _.e), n !== null && (n.prev = _, n.e.prev = _.e), _;
+  } finally {
+  }
+}
+function _e(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, s = (
+    /** @type {TemplateNode} */
+    t.e.nodes_start
+  ); s !== null && s !== n; ) {
+    var f = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ ft(s)
+    );
+    i.before(s), s = f;
+  }
+}
+function z(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 is(t, e, r, n, i) {
+  E && Ut();
+  var s = e.$$slots?.[r], f = !1;
+  s === !0 && (s = e[r === "default" ? "children" : r], f = !0), s === void 0 ? i !== null && i(t) : s(t, f ? () => n : n);
+}
+function ss(t, e) {
+  Be(() => {
+    var r = t.getRootNode(), n = (
+      /** @type {ShadowRoot} */
+      r.host ? (
+        /** @type {ShadowRoot} */
+        r
+      ) : (
+        /** @type {Document} */
+        r.head ?? /** @type {Document} */
+        r.ownerDocument.head
+      )
+    );
+    if (!n.querySelector("#" + e.hash)) {
+      const i = document.createElement("style");
+      i.id = e.hash, i.textContent = e.code, n.appendChild(i);
+    }
+  });
+}
+function Xr(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 = Xr(t[e])) && (n && (n += " "), n += r);
+  } else for (r in t) t[r] && (n && (n += " "), n += r);
+  return n;
+}
+function gi() {
+  for (var t, e, r = 0, n = "", i = arguments.length; r < i; r++) (t = arguments[r]) && (e = Xr(t)) && (n && (n += " "), n += e);
+  return n;
+}
+function fs(t) {
+  return typeof t == "object" ? gi(t) : t ?? "";
+}
+const er = [...` 	
+\r\f \v\uFEFF`];
+function wi(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 s = i.length, f = 0; (f = n.indexOf(i, f)) >= 0; ) {
+          var a = f + s;
+          (f === 0 || er.includes(n[f - 1])) && (a === n.length || er.includes(n[a])) ? n = (f === 0 ? "" : n.substring(0, f)) + n.substring(a + 1) : f = a;
+        }
+  }
+  return n === "" ? null : n;
+}
+function rr(t, e = !1) {
+  var r = e ? " !important;" : ";", n = "";
+  for (var i in t) {
+    var s = t[i];
+    s != null && s !== "" && (n += " " + i + ": " + s + r);
+  }
+  return n;
+}
+function pe(t) {
+  return t[0] !== "-" || t[1] !== "-" ? t.toLowerCase() : t;
+}
+function bi(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 s = !1, f = 0, a = !1, u = [];
+      n && u.push(...Object.keys(n).map(pe)), i && u.push(...Object.keys(i).map(pe));
+      var l = 0, o = -1;
+      const _ = t.length;
+      for (var d = 0; d < _; d++) {
+        var v = t[d];
+        if (a ? v === "/" && t[d - 1] === "*" && (a = !1) : s ? s === v && (s = !1) : v === "/" && t[d + 1] === "*" ? a = !0 : v === '"' || v === "'" ? s = v : v === "(" ? f++ : v === ")" && f--, !a && s === !1 && f === 0) {
+          if (v === ":" && o === -1)
+            o = d;
+          else if (v === ";" || d === _ - 1) {
+            if (o !== -1) {
+              var h = pe(t.substring(l, o).trim());
+              if (!u.includes(h)) {
+                v !== ";" && d++;
+                var c = t.substring(l, d).trim();
+                r += " " + c + ";";
+              }
+            }
+            l = d + 1, o = -1;
+          }
+        }
+      }
+    }
+    return n && (r += rr(n)), i && (r += rr(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return t == null ? null : String(t);
+}
+function as(t, e, r, n, i, s) {
+  var f = t.__className;
+  if (E || f !== r || f === void 0) {
+    var a = wi(r, n, s);
+    (!E || a !== t.getAttribute("class")) && (a == null ? t.removeAttribute("class") : e ? t.className = a : t.setAttribute("class", a)), t.__className = r;
+  } else if (s && i !== s)
+    for (var u in s) {
+      var l = !!s[u];
+      (i == null || l !== !!i[u]) && t.classList.toggle(u, l);
+    }
+  return s;
+}
+function $e(t, e = {}, r, n) {
+  for (var i in r) {
+    var s = r[i];
+    e[i] !== s && (r[i] == null ? t.style.removeProperty(i) : t.style.setProperty(i, s, n));
+  }
+}
+function us(t, e, r, n) {
+  var i = t.__style;
+  if (E || i !== e) {
+    var s = bi(e, n);
+    (!E || s !== t.getAttribute("style")) && (s == null ? t.removeAttribute("style") : t.style.cssText = s), t.__style = e;
+  } else n && (Array.isArray(n) ? ($e(t, r?.[0], n[0]), $e(t, r?.[1], n[1], "important")) : $e(t, r, n));
+  return n;
+}
+const mi = Symbol("is custom element"), yi = Symbol("is html");
+function Ei(t, e, r, n) {
+  var i = Ti(t);
+  E && (i[e] = t.getAttribute(e), e === "src" || e === "srcset" || e === "href" && t.nodeName === "LINK") || i[e] !== (i[e] = r) && (e === "loading" && (t[En] = r), r == null ? t.removeAttribute(e) : typeof r != "string" && Zr(t).includes(e) ? t[e] = r : t.setAttribute(e, r));
+}
+function ls(t, e, r) {
+  var n = y, i = b;
+  let s = E;
+  E && Y(!1), H(null), Q(null);
+  try {
+    // `style` should use `set_attribute` rather than the setter
+    e !== "style" && // Don't compute setters for custom elements while they aren't registered yet,
+    // because during their upgrade/instantiation they might add more setters.
+    // Instead, fall back to a simple "an object, then set as property" heuristic.
+    (Ne.has(t.getAttribute("is") || t.nodeName) || // customElements may not be available in browser extension contexts
+    !customElements || customElements.get(t.getAttribute("is") || t.tagName.toLowerCase()) ? Zr(t).includes(e) : r && typeof r == "object") ? t[e] = r : Ei(t, e, r == null ? r : String(r));
+  } finally {
+    H(n), Q(i), s && Y(!0);
+  }
+}
+function Ti(t) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    t.__attributes ??= {
+      [mi]: t.nodeName.includes("-"),
+      [yi]: t.namespaceURI === _n
+    }
+  );
+}
+var Ne = /* @__PURE__ */ new Map();
+function Zr(t) {
+  var e = t.getAttribute("is") || t.nodeName, r = Ne.get(e);
+  if (r) return r;
+  Ne.set(e, r = []);
+  for (var n, i = t, s = Element.prototype; s !== i; ) {
+    n = $n(i);
+    for (var f in n)
+      n[f].set && r.push(f);
+    i = or(i);
+  }
+  return r;
+}
+const Ai = () => performance.now(), rt = {
+  // 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: () => Ai(),
+  tasks: /* @__PURE__ */ new Set()
+};
+function Qr() {
+  const t = rt.now();
+  rt.tasks.forEach((e) => {
+    e.c(t) || (rt.tasks.delete(e), e.f());
+  }), rt.tasks.size !== 0 && rt.tick(Qr);
+}
+function Si(t) {
+  let e;
+  return rt.tasks.size === 0 && rt.tick(Qr), {
+    promise: new Promise((r) => {
+      rt.tasks.add(e = { c: t, f: r });
+    }),
+    abort() {
+      rt.tasks.delete(e);
+    }
+  };
+}
+function Kt(t, e) {
+  Ht(() => {
+    t.dispatchEvent(new CustomEvent(e));
+  });
+}
+function Ni(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 nr(t) {
+  const e = {}, r = t.split(";");
+  for (const n of r) {
+    const [i, s] = n.split(":");
+    if (!i || s === void 0) break;
+    const f = Ni(i.trim());
+    e[f] = s.trim();
+  }
+  return e;
+}
+const Oi = (t) => t;
+function os(t, e, r, n) {
+  var i = (t & cn) !== 0, s = (t & vn) !== 0, f = i && s, a = (t & dn) !== 0, u = f ? "both" : i ? "in" : "out", l, o = e.inert, d = e.style.overflow, v, h;
+  function c() {
+    return Ht(() => l ??= r()(e, n?.() ?? /** @type {P} */
+    {}, {
+      direction: u
+    }));
+  }
+  var _ = {
+    is_global: a,
+    in() {
+      if (e.inert = o, !i) {
+        h?.abort(), h?.reset?.();
+        return;
+      }
+      s || v?.abort(), Kt(e, "introstart"), v = Oe(e, c(), h, 1, () => {
+        Kt(e, "introend"), v?.abort(), v = l = void 0, e.style.overflow = d;
+      });
+    },
+    out(m) {
+      if (!s) {
+        m?.(), l = void 0;
+        return;
+      }
+      e.inert = !0, Kt(e, "outrostart"), h = Oe(e, c(), v, 0, () => {
+        Kt(e, "outroend"), m?.();
+      });
+    },
+    stop: () => {
+      v?.abort(), h?.abort();
+    }
+  }, p = (
+    /** @type {Effect} */
+    b
+  );
+  if ((p.transitions ??= []).push(_), i && Te) {
+    var w = a;
+    if (!w) {
+      for (var g = (
+        /** @type {Effect | null} */
+        p.parent
+      ); g && (g.f & se) !== 0; )
+        for (; (g = g.parent) && (g.f & gt) === 0; )
+          ;
+      w = !g || (g.f & ie) !== 0;
+    }
+    w && Be(() => {
+      Yt(() => _.in());
+    });
+  }
+}
+function Oe(t, e, r, n, i) {
+  var s = n === 1;
+  if (yt(e)) {
+    var f, a = !1;
+    return ae(() => {
+      if (!a) {
+        var p = e({ direction: s ? "in" : "out" });
+        f = Oe(t, p, r, n, i);
+      }
+    }), {
+      abort: () => {
+        a = !0, f?.abort();
+      },
+      deactivate: () => f.deactivate(),
+      reset: () => f.reset(),
+      t: () => f.t()
+    };
+  }
+  if (r?.deactivate(), !e?.duration)
+    return i(), {
+      abort: xt,
+      deactivate: xt,
+      reset: xt,
+      t: () => n
+    };
+  const { delay: u = 0, css: l, tick: o, easing: d = Oi } = e;
+  var v = [];
+  if (s && r === void 0 && (o && o(0, 1), l)) {
+    var h = nr(l(0, 1));
+    v.push(h, h);
+  }
+  var c = () => 1 - n, _ = t.animate(v, { duration: u, fill: "forwards" });
+  return _.onfinish = () => {
+    _.cancel();
+    var p = r?.t() ?? 1 - n;
+    r?.abort();
+    var w = n - p, g = (
+      /** @type {number} */
+      e.duration * Math.abs(w)
+    ), m = [];
+    if (g > 0) {
+      var N = !1;
+      if (l)
+        for (var S = Math.ceil(g / 16.666666666666668), $ = 0; $ <= S; $ += 1) {
+          var T = p + w * d($ / S), C = nr(l(T, 1 - T));
+          m.push(C), N ||= C.overflow === "hidden";
+        }
+      N && (t.style.overflow = "hidden"), c = () => {
+        var K = (
+          /** @type {number} */
+          /** @type {globalThis.Animation} */
+          _.currentTime
+        );
+        return p + w * d(K / g);
+      }, o && Si(() => {
+        if (_.playState !== "running") return !1;
+        var K = c();
+        return o(K, 1 - K), !0;
+      });
+    }
+    _ = t.animate(m, { duration: g, fill: "forwards" }), _.onfinish = () => {
+      c = () => n, o?.(n, 1 - n), i();
+    };
+  }, {
+    abort: () => {
+      _ && (_.cancel(), _.effect = null, _.onfinish = xt);
+    },
+    deactivate: () => {
+      i = xt;
+    },
+    reset: () => {
+      n === 0 && o?.(1, 0);
+    },
+    t: () => c()
+  };
+}
+function ir(t, e) {
+  return t === e || t?.[At] === e;
+}
+function cs(t = {}, e, r, n) {
+  return Be(() => {
+    var i, s;
+    return kr(() => {
+      i = s, s = [], Yt(() => {
+        t !== r(...s) && (e(t, ...s), i && ir(r(...i), t) && e(null, ...i));
+      });
+    }), () => {
+      ae(() => {
+        s && ir(r(...s), t) && e(null, ...s);
+      });
+    };
+  }), t;
+}
+let Gt = !1;
+function Ci(t) {
+  var e = Gt;
+  try {
+    return Gt = !1, [t(), Gt];
+  } finally {
+    Gt = e;
+  }
+}
+const Ri = {
+  get(t, e) {
+    let r = t.props.length;
+    for (; r--; ) {
+      let n = t.props[r];
+      if (yt(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];
+      yt(i) && (i = i());
+      const s = nt(i, e);
+      if (s && s.set)
+        return s.set(r), !0;
+    }
+    return !1;
+  },
+  getOwnPropertyDescriptor(t, e) {
+    let r = t.props.length;
+    for (; r--; ) {
+      let n = t.props[r];
+      if (yt(n) && (n = n()), typeof n == "object" && n !== null && e in n) {
+        const i = nt(n, e);
+        return i && !i.configurable && (i.configurable = !0), i;
+      }
+    }
+  },
+  has(t, e) {
+    if (e === At || e === Me) return !1;
+    for (let r of t.props)
+      if (yt(r) && (r = r()), r != null && e in r) return !0;
+    return !1;
+  },
+  ownKeys(t) {
+    const e = [];
+    for (let r of t.props)
+      if (yt(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 vs(...t) {
+  return new Proxy({ props: t }, Ri);
+}
+function ds(t, e, r, n) {
+  var i = !Pt || (r & an) !== 0, s = (r & ln) !== 0, f = (r & on) !== 0, a = (
+    /** @type {V} */
+    n
+  ), u = !0, l = () => (u && (u = !1, a = f ? Yt(
+    /** @type {() => V} */
+    n
+  ) : (
+    /** @type {V} */
+    n
+  )), a), o;
+  if (s) {
+    var d = At in t || Me in t;
+    o = nt(t, e)?.set ?? (d && e in t ? (m) => t[e] = m : void 0);
+  }
+  var v, h = !1;
+  s ? [v, h] = Ci(() => (
+    /** @type {V} */
+    t[e]
+  )) : v = /** @type {V} */
+  t[e], v === void 0 && n !== void 0 && (v = l(), o && (i && In(), o(v)));
+  var c;
+  if (i ? c = () => {
+    var m = (
+      /** @type {V} */
+      t[e]
+    );
+    return m === void 0 ? l() : (u = !0, m);
+  } : c = () => {
+    var m = (
+      /** @type {V} */
+      t[e]
+    );
+    return m !== void 0 && (a = /** @type {V} */
+    void 0), m === void 0 ? a : m;
+  }, i && (r & un) === 0)
+    return c;
+  if (o) {
+    var _ = t.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(m, N) {
+        return arguments.length > 0 ? ((!i || !N || _ || h) && o(N ? c() : m), m) : c();
+      })
+    );
+  }
+  var p = !1, w = ((r & fn) !== 0 ? ue : qe)(() => (p = !1, c()));
+  s && j(w);
+  var g = (
+    /** @type {Effect} */
+    b
+  );
+  return (
+    /** @type {() => V} */
+    (function(m, N) {
+      if (arguments.length > 0) {
+        const S = N ? j(w) : i && s ? Et(m) : m;
+        return et(w, S), p = !0, a !== void 0 && (a = S), m;
+      }
+      return bt && p || (g.f & wt) !== 0 ? w.v : j(w);
+    })
+  );
+}
+function Ii(t) {
+  return new Pi(t);
+}
+class Pi {
+  /** @type {any} */
+  #e;
+  /** @type {Record<string, any>} */
+  #t;
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(e) {
+    var r = /* @__PURE__ */ new Map(), n = (s, f) => {
+      var a = /* @__PURE__ */ Ar(f, !1, !1);
+      return r.set(s, a), a;
+    };
+    const i = new Proxy(
+      { ...e.props || {}, $$events: {} },
+      {
+        get(s, f) {
+          return j(r.get(f) ?? n(f, Reflect.get(s, f)));
+        },
+        has(s, f) {
+          return f === Me ? !0 : (j(r.get(f) ?? n(f, Reflect.get(s, f))), Reflect.has(s, f));
+        },
+        set(s, f, a) {
+          return et(r.get(f) ?? n(f, a), a), Reflect.set(s, f, a);
+        }
+      }
+    );
+    this.#t = (e.hydrate ? vi : Gr)(e.component, {
+      target: e.target,
+      anchor: e.anchor,
+      props: i,
+      context: e.context,
+      intro: e.intro ?? !1,
+      recover: e.recover
+    }), (!e?.props?.$$host || e.sync === !1) && Er(), this.#e = i.$$events;
+    for (const s of Object.keys(this.#t))
+      s === "$set" || s === "$destroy" || s === "$on" || Ot(this, s, {
+        get() {
+          return this.#t[s];
+        },
+        /** @param {any} value */
+        set(f) {
+          this.#t[s] = f;
+        },
+        enumerable: !0
+      });
+    this.#t.$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(i, s);
+    }, this.#t.$destroy = () => {
+      di(this.#t);
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(e) {
+    this.#t.$set(e);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(e, r) {
+    this.#e[e] = this.#e[e] || [];
+    const n = (...i) => r.call(this, ...i);
+    return this.#e[e].push(n), () => {
+      this.#e[e] = this.#e[e].filter(
+        /** @param {any} fn */
+        (i) => i !== n
+      );
+    };
+  }
+  $destroy() {
+    this.#t.$destroy();
+  }
+}
+let tn;
+typeof HTMLElement == "function" && (tn = class extends HTMLElement {
+  /** The Svelte component constructor */
+  $$ctor;
+  /** Slots */
+  $$s;
+  /** @type {any} The Svelte component instance */
+  $$c;
+  /** Whether or not the custom element is connected */
+  $$cn = !1;
+  /** @type {Record<string, any>} Component props data */
+  $$d = {};
+  /** `true` if currently in the process of reflecting component props back to attributes */
+  $$r = !1;
+  /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+  $$p_d = {};
+  /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+  $$l = {};
+  /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+  $$l_u = /* @__PURE__ */ new Map();
+  /** @type {any} The managed render effect for reflecting attributes */
+  $$me;
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {*} use_shadow_dom
+   */
+  constructor(t, e, r) {
+    super(), this.$$ctor = t, this.$$s = e, r && this.attachShadow({ mode: "open" });
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(t, e, r) {
+    if (this.$$l[t] = this.$$l[t] || [], this.$$l[t].push(e), this.$$c) {
+      const n = this.$$c.$on(t, e);
+      this.$$l_u.set(e, n);
+    }
+    super.addEventListener(t, e, r);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(t, e, r) {
+    if (super.removeEventListener(t, e, r), this.$$c) {
+      const n = this.$$l_u.get(e);
+      n && (n(), this.$$l_u.delete(e));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let t = function(n) {
+        return (i) => {
+          const s = document.createElement("slot");
+          n !== "default" && (s.name = n), li(i, s);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const e = {}, r = ki(this);
+      for (const n of this.$$s)
+        n in r && (n === "default" && !this.$$d.children ? (this.$$d.children = t(n), e.default = !0) : e[n] = t(n));
+      for (const n of this.attributes) {
+        const i = this.$$g_p(n.name);
+        i in this.$$d || (this.$$d[i] = Jt(i, n.value, this.$$p_d, "toProp"));
+      }
+      for (const n in this.$$p_d)
+        !(n in this.$$d) && this[n] !== void 0 && (this.$$d[n] = this[n], delete this[n]);
+      this.$$c = Ii({
+        component: this.$$ctor,
+        target: this.shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: e,
+          $$host: this
+        }
+      }), this.$$me = Qn(() => {
+        kr(() => {
+          this.$$r = !0;
+          for (const n of Xt(this.$$c)) {
+            if (!this.$$p_d[n]?.reflect) continue;
+            this.$$d[n] = this.$$c[n];
+            const i = Jt(
+              n,
+              this.$$d[n],
+              this.$$p_d,
+              "toAttribute"
+            );
+            i == null ? this.removeAttribute(this.$$p_d[n].attribute || n) : this.setAttribute(this.$$p_d[n].attribute || n, i);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const n in this.$$l)
+        for (const i of this.$$l[n]) {
+          const s = this.$$c.$on(n, i);
+          this.$$l_u.set(i, s);
+        }
+      this.$$l = {};
+    }
+  }
+  // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+  // and setting attributes through setAttribute etc, this is helpful
+  /**
+   * @param {string} attr
+   * @param {string} _oldValue
+   * @param {string} newValue
+   */
+  attributeChangedCallback(t, e, r) {
+    this.$$r || (t = this.$$g_p(t), this.$$d[t] = Jt(t, r, this.$$p_d, "toProp"), this.$$c?.$set({ [t]: this.$$d[t] }));
+  }
+  disconnectedCallback() {
+    this.$$cn = !1, Promise.resolve().then(() => {
+      !this.$$cn && this.$$c && (this.$$c.$destroy(), this.$$me(), this.$$c = void 0);
+    });
+  }
+  /**
+   * @param {string} attribute_name
+   */
+  $$g_p(t) {
+    return Xt(this.$$p_d).find(
+      (e) => this.$$p_d[e].attribute === t || !this.$$p_d[e].attribute && e.toLowerCase() === t
+    ) || t;
+  }
+});
+function Jt(t, e, r, n) {
+  const i = r[t]?.type;
+  if (e = i === "Boolean" && typeof e != "boolean" ? e != null : e, !n || !r[t])
+    return e;
+  if (n === "toAttribute")
+    switch (i) {
+      case "Object":
+      case "Array":
+        return e == null ? null : JSON.stringify(e);
+      case "Boolean":
+        return e ? "" : null;
+      case "Number":
+        return e ?? null;
+      default:
+        return e;
+    }
+  else
+    switch (i) {
+      case "Object":
+      case "Array":
+        return e && JSON.parse(e);
+      case "Boolean":
+        return e;
+      // conversion already handled above
+      case "Number":
+        return e != null ? +e : e;
+      default:
+        return e;
+    }
+}
+function ki(t) {
+  const e = {};
+  return t.childNodes.forEach((r) => {
+    e[
+      /** @type {Element} node */
+      r.slot || "default"
+    ] = !0;
+  }), e;
+}
+function hs(t, e, r, n, i, s) {
+  let f = class extends tn {
+    constructor() {
+      super(t, r, i), this.$$p_d = e;
+    }
+    static get observedAttributes() {
+      return Xt(e).map(
+        (a) => (e[a].attribute || a).toLowerCase()
+      );
+    }
+  };
+  return Xt(e).forEach((a) => {
+    Ot(f.prototype, a, {
+      get() {
+        return this.$$c && a in this.$$c ? this.$$c[a] : this.$$d[a];
+      },
+      set(u) {
+        u = Jt(a, u, e), this.$$d[a] = u;
+        var l = this.$$c;
+        if (l) {
+          var o = nt(l, a)?.get;
+          o ? l[a] = u : l.$set({ [a]: u });
+        }
+      }
+    });
+  }), n.forEach((a) => {
+    Ot(f.prototype, a, {
+      get() {
+        return this.$$c?.[a];
+      }
+    });
+  }), t.element = /** @type {any} */
+  f, f;
+}
+const xi = (t) => t;
+function Li(t) {
+  const e = t - 1;
+  return e * e * e + 1;
+}
+function sr(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 _s(t, { delay: e = 0, duration: r = 400, easing: n = xi } = {}) {
+  const i = +getComputedStyle(t).opacity;
+  return {
+    delay: e,
+    duration: r,
+    easing: n,
+    css: (s) => `opacity: ${s * i}`
+  };
+}
+function ps(t, { delay: e = 0, duration: r = 400, easing: n = Li, x: i = 0, y: s = 0, opacity: f = 0 } = {}) {
+  const a = getComputedStyle(t), u = +a.opacity, l = a.transform === "none" ? "" : a.transform, o = u * (1 - f), [d, v] = sr(i), [h, c] = sr(s);
+  return {
+    delay: e,
+    duration: r,
+    easing: n,
+    css: (_, p) => `
+			transform: ${l} translate(${(1 - _) * d}${v}, ${(1 - _) * h}${c});
+			opacity: ${u - o * p}`
+  };
+}
+export {
+  fs as $,
+  Wi as A,
+  Ui as B,
+  Er as C,
+  es as D,
+  se as E,
+  zi as F,
+  cs as G,
+  Vi as H,
+  Ei as I,
+  Ki as J,
+  ss as K,
+  Bi as L,
+  Di as M,
+  Xi as N,
+  Qi as O,
+  is as P,
+  us as Q,
+  Et as R,
+  Yi as S,
+  Gi as T,
+  I as U,
+  as as V,
+  qi as W,
+  Ji as X,
+  vs as Y,
+  hi as Z,
+  ns as _,
+  Rt as a,
+  rs as a0,
+  os as a1,
+  _s as a2,
+  ls as a3,
+  Xn as a4,
+  Fi as a5,
+  ps as a6,
+  xr as b,
+  A as c,
+  Z as d,
+  Ut as e,
+  ji as f,
+  X as g,
+  E as h,
+  Bt as i,
+  R as j,
+  Ir as k,
+  hs as l,
+  Dn as m,
+  xt as n,
+  ds as o,
+  He as p,
+  j as q,
+  at as r,
+  Ln as s,
+  ts as t,
+  Zn as u,
+  Zi as v,
+  Hi as w,
+  li as x,
+  Fn as y,
+  et as z
+};