@reddb-io/ui 0.3.0 → 0.3.1

package/dist/embed/index-client-BeiP-va5.js

@@ -0,0 +1,3303 @@
+var us = Object.defineProperty;
+var Un = (e) => {
+  throw TypeError(e);
+};
+var cs = (e, t, n) => t in e ? us(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var F = (e, t, n) => cs(e, typeof t != "symbol" ? t + "" : t, n), cn = (e, t, n) => t.has(e) || Un("Cannot " + n);
+var f = (e, t, n) => (cn(e, t, "read from private field"), n ? n.call(e) : t.get(e)), y = (e, t, n) => t.has(e) ? Un("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), g = (e, t, n, r) => (cn(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), m = (e, t, n) => (cn(e, t, "access private method"), n);
+var sr = Array.isArray, ds = Array.prototype.indexOf, Ue = Array.prototype.includes, hs = Array.from, ir = Object.defineProperty, bt = Object.getOwnPropertyDescriptor, _s = Object.getOwnPropertyDescriptors, vs = Object.prototype, ps = Array.prototype, fr = Object.getPrototypeOf, $n = Object.isExtensible;
+function Wi(e) {
+  return typeof e == "function";
+}
+const pe = () => {
+};
+function Ki(e) {
+  return typeof (e == null ? void 0 : e.then) == "function";
+}
+function Xi(e) {
+  return e();
+}
+function ar(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function lr() {
+  var e, t, n = new Promise((r, s) => {
+    e = r, t = s;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+function Ji(e, t, n = !1) {
+  return e === void 0 ? n ? (
+    /** @type {() => V} */
+    t()
+  ) : (
+    /** @type {V} */
+    t
+  ) : e;
+}
+function Zi(e, t) {
+  if (Array.isArray(e))
+    return e;
+  if (t === void 0 || !(Symbol.iterator in e))
+    return Array.from(e);
+  const n = [];
+  for (const r of e)
+    if (n.push(r), n.length === t) break;
+  return n;
+}
+function Qi(e, t) {
+  var n = {};
+  for (var r in e)
+    t.includes(r) || (n[r] = e[r]);
+  for (var s of Object.getOwnPropertySymbols(e))
+    Object.propertyIsEnumerable.call(e, s) && !t.includes(s) && (n[s] = e[s]);
+  return n;
+}
+const D = 2, ut = 4, Dt = 8, Mn = 1 << 24, fe = 16, ye = 32, Se = 64, vn = 128, X = 512, R = 1024, I = 2048, le = 4096, J = 8192, ge = 16384, De = 32768, zn = 1 << 25, ct = 65536, St = 1 << 17, gs = 1 << 18, Xe = 1 << 19, or = 1 << 20, ef = 1 << 25, We = 65536, Kt = 1 << 21, rt = 1 << 22, Me = 1 << 23, $e = Symbol("$state"), tf = Symbol("legacy props"), nf = Symbol(""), ys = Symbol("attributes"), bs = Symbol("class"), ws = Symbol("style"), pt = Symbol("text"), qt = Symbol("form reset"), rn = new class extends Error {
+  constructor() {
+    super(...arguments);
+    F(this, "name", "StaleReactionError");
+    F(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}();
+var nr;
+const sf = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  !!((nr = globalThis.document) != null && nr.contentType) && /* @__PURE__ */ globalThis.document.contentType.includes("xml")
+), ff = 1, Pt = 3, sn = 8;
+function ur(e) {
+  throw new Error("https://svelte.dev/e/experimental_async_required");
+}
+function af() {
+  throw new Error("https://svelte.dev/e/invalid_default_snippet");
+}
+function _t(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function ms() {
+  throw new Error("https://svelte.dev/e/missing_context");
+}
+function Es() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function lf(e, t, n) {
+  throw new Error("https://svelte.dev/e/each_key_duplicate");
+}
+function Ts(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Ss() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function As(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function ks() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function xs() {
+  throw new Error("https://svelte.dev/e/fork_discarded");
+}
+function Ns() {
+  throw new Error("https://svelte.dev/e/fork_timing");
+}
+function Os() {
+  throw new Error("https://svelte.dev/e/get_abort_signal_outside_reaction");
+}
+function Rs() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function cr(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_legacy_only");
+}
+function of(e) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function Ms() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Cs() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Is() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Ds() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+const uf = 1, cf = 2, df = 4, hf = 8, _f = 16, vf = 1, pf = 2, gf = 4, yf = 8, bf = 16, wf = 1, mf = 2, Ef = 4, dr = 1, Ps = 2, hr = "[", _r = "[!", Gn = "[?", vr = "]", dt = {}, M = Symbol("uninitialized"), Ls = "http://www.w3.org/1999/xhtml", Tf = "http://www.w3.org/2000/svg", Sf = "http://www.w3.org/1998/Math/MathML", Af = "@attach";
+function Fs() {
+  console.warn("https://svelte.dev/e/derived_inert");
+}
+function js(e) {
+  console.warn("https://svelte.dev/e/hydratable_missing_but_expected");
+}
+function fn(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function kf() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+function Hs() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let N = !1;
+function Ht(e) {
+  N = e;
+}
+let E;
+function oe(e) {
+  if (e === null)
+    throw fn(), dt;
+  return E = e;
+}
+function Cn() {
+  return oe(/* @__PURE__ */ Ae(E));
+}
+function xf(e) {
+  if (N) {
+    if (/* @__PURE__ */ Ae(E) !== null)
+      throw fn(), dt;
+    E = e;
+  }
+}
+function Vs(e = 1) {
+  if (N) {
+    for (var t = e, n = E; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ Ae(n);
+    E = n;
+  }
+}
+function Bs(e = !0) {
+  for (var t = 0, n = E; ; ) {
+    if (n.nodeType === sn) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === vr) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (r === hr || r === _r || // "[1", "[2", etc. for if blocks
+      r[0] === "[" && !isNaN(Number(r.slice(1)))) && (t += 1);
+    }
+    var s = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Ae(n)
+    );
+    e && n.remove(), n = s;
+  }
+}
+function Nf(e) {
+  if (!e || e.nodeType !== sn)
+    throw fn(), dt;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function pr(e) {
+  return e === this.v;
+}
+function gr(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function yr(e) {
+  return !gr(e, this.v);
+}
+let Lt = !1;
+function Of() {
+  Lt = !0;
+}
+let T = null;
+function ht(e) {
+  T = e;
+}
+function Ys() {
+  const e = {};
+  return [
+    () => (mr(e) || ms(), br(e)),
+    (t) => wr(e, t)
+  ];
+}
+function br(e) {
+  return (
+    /** @type {T} */
+    an().get(e)
+  );
+}
+function wr(e, t) {
+  return an().set(e, t), t;
+}
+function mr(e) {
+  return an().has(e);
+}
+function qs() {
+  return an();
+}
+function Us(e, t = !1, n) {
+  T = {
+    p: T,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    r: (
+      /** @type {Effect} */
+      w
+    ),
+    l: Lt && !t ? { s: null, u: null, $: [] } : null
+  };
+}
+function $s(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    T
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var r of n)
+      zr(r);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, T = t.p, e ?? /** @type {T} */
+  {};
+}
+function Ft() {
+  return !Lt || T !== null && T.l === null;
+}
+function an(e) {
+  return T === null && _t(), T.c ?? (T.c = new Map(zs(T) || void 0));
+}
+function zs(e) {
+  let t = e.p;
+  for (; t !== null; ) {
+    const n = t.c;
+    if (n !== null)
+      return n;
+    t = t.p;
+  }
+  return null;
+}
+let Pe = [];
+function Er() {
+  var e = Pe;
+  Pe = [], ar(e);
+}
+function Ce(e) {
+  if (Pe.length === 0 && !mt) {
+    var t = Pe;
+    queueMicrotask(() => {
+      t === Pe && Er();
+    });
+  }
+  Pe.push(e);
+}
+function Gs() {
+  for (; Pe.length > 0; )
+    Er();
+}
+function Tr(e) {
+  var t = w;
+  if (t === null)
+    return b.f |= Me, e;
+  if ((t.f & De) === 0 && (t.f & ut) === 0)
+    throw e;
+  Re(e, t);
+}
+function Re(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & vn) !== 0) {
+      if ((t.f & De) === 0)
+        throw e;
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    }
+    t = t.parent;
+  }
+  throw e;
+}
+const Ws = -7169;
+function x(e, t) {
+  e.f = e.f & Ws | t;
+}
+function In(e) {
+  (e.f & X) !== 0 || e.deps === null ? x(e, R) : x(e, le);
+}
+function Sr(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & D) === 0 || (t.f & We) === 0 || (t.f ^= We, Sr(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function Ar(e, t, n) {
+  (e.f & I) !== 0 ? t.add(e) : (e.f & le) !== 0 && n.add(e), Sr(e.deps), x(e, R);
+}
+function Dn(e, t, n) {
+  if (e == null)
+    return t(void 0), n && n(void 0), pe;
+  const r = Je(
+    () => e.subscribe(
+      t,
+      // @ts-expect-error
+      n
+    )
+  );
+  return r.unsubscribe ? () => r.unsubscribe() : r;
+}
+const Qe = [];
+function Ks(e, t) {
+  return {
+    subscribe: Xs(e, t).subscribe
+  };
+}
+function Xs(e, t = pe) {
+  let n = null;
+  const r = /* @__PURE__ */ new Set();
+  function s(o) {
+    if (gr(e, o) && (e = o, n)) {
+      const l = !Qe.length;
+      for (const u of r)
+        u[1](), Qe.push(u, e);
+      if (l) {
+        for (let u = 0; u < Qe.length; u += 2)
+          Qe[u][0](Qe[u + 1]);
+        Qe.length = 0;
+      }
+    }
+  }
+  function i(o) {
+    s(o(
+      /** @type {T} */
+      e
+    ));
+  }
+  function a(o, l = pe) {
+    const u = [o, l];
+    return r.add(u), r.size === 1 && (n = t(s, i) || pe), o(
+      /** @type {T} */
+      e
+    ), () => {
+      r.delete(u), r.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: s, update: i, subscribe: a };
+}
+function Rf(e, t, n) {
+  const r = !Array.isArray(e), s = r ? [e] : e;
+  if (!s.every(Boolean))
+    throw new Error("derived() expects stores as input, got a falsy value");
+  const i = t.length < 2;
+  return Ks(n, (a, o) => {
+    let l = !1;
+    const u = [];
+    let _ = 0, d = pe;
+    const c = () => {
+      if (_)
+        return;
+      d();
+      const h = t(r ? u[0] : u, a, o);
+      i ? a(h) : d = typeof h == "function" ? h : pe;
+    }, v = s.map(
+      (h, A) => Dn(
+        h,
+        (O) => {
+          u[A] = O, _ &= ~(1 << A), l && c();
+        },
+        () => {
+          _ |= 1 << A;
+        }
+      )
+    );
+    return l = !0, c(), function() {
+      ar(v), d(), l = !1;
+    };
+  });
+}
+function Js(e) {
+  let t;
+  return Dn(e, (n) => t = n)(), t;
+}
+let pn = !1, Vt = !1, gn = Symbol("unmounted");
+function Mf(e, t, n) {
+  const r = n[t] ?? (n[t] = {
+    store: null,
+    source: /* @__PURE__ */ _i(void 0),
+    unsubscribe: pe
+  });
+  if (r.store !== e && !(gn in n))
+    if (r.unsubscribe(), r.store = e ?? null, e == null)
+      r.source.v = void 0, r.unsubscribe = pe;
+    else {
+      var s = !0;
+      r.unsubscribe = Dn(e, (i) => {
+        s ? r.source.v = i : _e(r.source, i);
+      }), s = !1;
+    }
+  return e && gn in n ? Js(e) : ve(r.source);
+}
+function Cf(e, t, n) {
+  let r = n[t];
+  return r && r.store !== e && (r.unsubscribe(), r.unsubscribe = pe), e;
+}
+function If(e, t) {
+  return Zs(e, t), t;
+}
+function Df() {
+  const e = {};
+  function t() {
+    un(() => {
+      for (var n in e)
+        e[n].unsubscribe();
+      ir(e, gn, {
+        enumerable: !1,
+        value: !0
+      });
+    });
+  }
+  return [e, t];
+}
+function Zs(e, t) {
+  pn = !0;
+  try {
+    e.set(t);
+  } finally {
+    pn = !1;
+  }
+}
+function Pf(e) {
+  var t = Vt;
+  try {
+    return Vt = !1, [e(), Vt];
+  } finally {
+    Vt = t;
+  }
+}
+let dn = null, et = null, p = null, wt = null, C = null, yn = null, mt = !1, hn = !1, nt = null, Ut = null;
+var Wn = 0;
+let Qs = 1;
+var st, xe, je, it, ft, He, at, me, xt, Y, Nt, Ne, ce, de, lt, Ve, S, bn, gt, wn, kr, xr, $t, ei, mn, tt;
+const en = class en {
+  constructor() {
+    y(this, S);
+    F(this, "id", Qs++);
+    /** True as soon as `#process` was called */
+    y(this, st, !1);
+    F(this, "linked", !0);
+    /** @type {Batch | null} */
+    y(this, xe, null);
+    /** @type {Batch | null} */
+    y(this, je, null);
+    /** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
+    F(this, "async_deriveds", /* @__PURE__ */ new Map());
+    /**
+     * The current values of any signals that are updated in this batch.
+     * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
+     * They keys of this map are identical to `this.#previous`
+     * @type {Map<Value, [any, boolean]>}
+     */
+    F(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Value, any>}
+     */
+    F(this, "previous", /* @__PURE__ */ new Map());
+    /**
+     * Async effects which this batch doesn't take into account anymore when calculating blockers,
+     * as it has a value for it already.
+     * @type {Set<Effect>}
+     */
+    F(this, "unblocked", /* @__PURE__ */ new Set());
+    /**
+     * 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<(batch: Batch) => void>}
+     */
+    y(this, it, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    y(this, ft, /* @__PURE__ */ new Set());
+    /**
+     * Callbacks that should run only when a fork is committed.
+     * @type {Set<(batch: Batch) => void>}
+     */
+    y(this, He, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    y(this, at, 0);
+    /**
+     * Async effects that are currently in flight, _not_ inside a pending boundary
+     * @type {Map<Effect, number>}
+     */
+    y(this, me, /* @__PURE__ */ new Map());
+    /**
+     * 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}
+     */
+    y(this, xt, null);
+    /**
+     * The root effects that need to be flushed
+     * @type {Effect[]}
+     */
+    y(this, Y, []);
+    /**
+     * Effects created while this batch was active.
+     * @type {Effect[]}
+     */
+    y(this, Nt, []);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, Ne, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, ce, /* @__PURE__ */ new Set());
+    /**
+     * A map of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`.
+     * The value contains child effects that were dirty/maybe_dirty before being reset,
+     * so they can be rescheduled if the branch survives.
+     * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
+     */
+    y(this, de, /* @__PURE__ */ new Map());
+    /**
+     * Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
+     * @type {Set<Effect>}
+     */
+    y(this, lt, /* @__PURE__ */ new Set());
+    F(this, "is_fork", !1);
+    y(this, Ve, !1);
+  }
+  /**
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
+   */
+  skip_effect(t) {
+    f(this, de).has(t) || f(this, de).set(t, { d: [], m: [] }), f(this, lt).delete(t);
+  }
+  /**
+   * Remove an effect from the #skipped_branches map and reschedule
+   * any tracked dirty/maybe_dirty child effects
+   * @param {Effect} effect
+   * @param {(e: Effect) => void} callback
+   */
+  unskip_effect(t, n = (r) => this.schedule(r)) {
+    var r = f(this, de).get(t);
+    if (r) {
+      f(this, de).delete(t);
+      for (var s of r.d)
+        x(s, I), n(s);
+      for (s of r.m)
+        x(s, le), n(s);
+    }
+    f(this, lt).add(t);
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Value} source
+   * @param {any} value
+   * @param {boolean} [is_derived]
+   */
+  capture(t, n, r = !1) {
+    t.v !== M && !this.previous.has(t) && this.previous.set(t, t.v), (t.f & Me) === 0 && (this.current.set(t, [n, r]), C == null || C.set(t, n)), this.is_fork || (t.v = n);
+  }
+  activate() {
+    p = this;
+  }
+  deactivate() {
+    p = null, C = null;
+  }
+  flush() {
+    try {
+      hn = !0, p = this, m(this, S, gt).call(this);
+    } finally {
+      Wn = 0, yn = null, nt = null, Ut = null, hn = !1, p = null, C = null, ze.clear();
+    }
+  }
+  discard() {
+    for (const t of f(this, ft)) t(this);
+    f(this, ft).clear(), f(this, He).clear(), m(this, S, tt).call(this);
+  }
+  /**
+   * @param {Effect} effect
+   */
+  register_created_effect(t) {
+    f(this, Nt).push(t);
+  }
+  /**
+   * @param {boolean} blocking
+   * @param {Effect} effect
+   */
+  increment(t, n) {
+    if (g(this, at, f(this, at) + 1), t) {
+      let r = f(this, me).get(n) ?? 0;
+      f(this, me).set(n, r + 1);
+    }
+  }
+  /**
+   * @param {boolean} blocking
+   * @param {Effect} effect
+   */
+  decrement(t, n) {
+    if (g(this, at, f(this, at) - 1), t) {
+      let r = f(this, me).get(n) ?? 0;
+      r === 1 ? f(this, me).delete(n) : f(this, me).set(n, r - 1);
+    }
+    f(this, Ve) || (g(this, Ve, !0), Ce(() => {
+      g(this, Ve, !1), this.linked && this.flush();
+    }));
+  }
+  /**
+   * @param {Set<Effect>} dirty_effects
+   * @param {Set<Effect>} maybe_dirty_effects
+   */
+  transfer_effects(t, n) {
+    for (const r of t)
+      f(this, Ne).add(r);
+    for (const r of n)
+      f(this, ce).add(r);
+    t.clear(), n.clear();
+  }
+  /** @param {(batch: Batch) => void} fn */
+  oncommit(t) {
+    f(this, it).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    f(this, ft).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  on_fork_commit(t) {
+    f(this, He).add(t);
+  }
+  run_fork_commit_callbacks() {
+    for (const t of f(this, He)) t(this);
+    f(this, He).clear();
+  }
+  settled() {
+    return (f(this, xt) ?? g(this, xt, lr())).promise;
+  }
+  static ensure() {
+    var t;
+    if (p === null) {
+      const n = p = new en();
+      m(t = n, S, mn).call(t), !hn && !mt && Ce(() => {
+        f(n, st) || n.flush();
+      });
+    }
+    return p;
+  }
+  apply() {
+    {
+      C = null;
+      return;
+    }
+  }
+  /**
+   *
+   * @param {Effect} effect
+   */
+  schedule(t) {
+    var s;
+    if (yn = t, (s = t.b) != null && s.is_pending && (t.f & (ut | Dt | Mn)) !== 0 && (t.f & De) === 0) {
+      t.b.defer_effect(t);
+      return;
+    }
+    for (var n = t; n.parent !== null; ) {
+      n = n.parent;
+      var r = n.f;
+      if (nt !== null && n === w && (b === null || (b.f & D) === 0) && !pn)
+        return;
+      if ((r & (Se | ye)) !== 0) {
+        if ((r & R) === 0)
+          return;
+        n.f ^= R;
+      }
+    }
+    f(this, Y).push(n);
+  }
+};
+st = new WeakMap(), xe = new WeakMap(), je = new WeakMap(), it = new WeakMap(), ft = new WeakMap(), He = new WeakMap(), at = new WeakMap(), me = new WeakMap(), xt = new WeakMap(), Y = new WeakMap(), Nt = new WeakMap(), Ne = new WeakMap(), ce = new WeakMap(), de = new WeakMap(), lt = new WeakMap(), Ve = new WeakMap(), S = new WeakSet(), bn = function() {
+  if (this.is_fork) return !0;
+  for (const r of f(this, me).keys()) {
+    for (var t = r, n = !1; t.parent !== null; ) {
+      if (f(this, de).has(t)) {
+        n = !0;
+        break;
+      }
+      t = t.parent;
+    }
+    if (!n)
+      return !0;
+  }
+  return !1;
+}, gt = function() {
+  var l, u, _, d;
+  if (g(this, st, !0), Wn++ > 1e3 && (m(this, S, tt).call(this), ti()), !m(this, S, bn).call(this)) {
+    for (const c of f(this, Ne))
+      f(this, ce).delete(c), x(c, I), this.schedule(c);
+    for (const c of f(this, ce))
+      x(c, le), this.schedule(c);
+  }
+  const t = f(this, Y);
+  g(this, Y, []), this.apply();
+  var n = nt = [], r = [], s = Ut = [];
+  for (const c of t)
+    try {
+      m(this, S, wn).call(this, c, n, r);
+    } catch (v) {
+      throw Mr(c), v;
+    }
+  if (p = null, s.length > 0) {
+    var i = en.ensure();
+    for (const c of s)
+      i.schedule(c);
+  }
+  if (nt = null, Ut = null, m(this, S, bn).call(this)) {
+    m(this, S, $t).call(this, r), m(this, S, $t).call(this, n);
+    for (const [c, v] of f(this, de))
+      Rr(c, v);
+    s.length > 0 && /** @type {unknown} */
+    m(l = p, S, gt).call(l);
+    return;
+  }
+  const a = m(this, S, kr).call(this);
+  if (a) {
+    m(u = a, S, xr).call(u, this);
+    return;
+  }
+  f(this, Ne).clear(), f(this, ce).clear();
+  for (const c of f(this, it)) c(this);
+  f(this, it).clear(), wt = this, Kn(r), Kn(n), wt = null, (_ = f(this, xt)) == null || _.resolve();
+  var o = (
+    /** @type {Batch | null} */
+    /** @type {unknown} */
+    p
+  );
+  if (this.linked && f(this, at) === 0 && m(this, S, tt).call(this), f(this, Y).length > 0) {
+    o === null && (o = this, m(this, S, mn).call(this));
+    const c = o;
+    f(c, Y).push(...f(this, Y).filter((v) => !f(c, Y).includes(v)));
+  }
+  o !== null && m(d = o, S, gt).call(d);
+}, /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ * @param {Effect[]} effects
+ * @param {Effect[]} render_effects
+ */
+wn = function(t, n, r) {
+  t.f ^= R;
+  for (var s = t.first; s !== null; ) {
+    var i = s.f, a = (i & (ye | Se)) !== 0, o = a && (i & R) !== 0, l = o || (i & J) !== 0 || f(this, de).has(s);
+    if (!l && s.fn !== null) {
+      a ? s.f ^= R : (i & ut) !== 0 ? n.push(s) : vt(s) && ((i & fe) !== 0 && f(this, ce).add(s), Ke(s));
+      var u = s.first;
+      if (u !== null) {
+        s = u;
+        continue;
+      }
+    }
+    for (; s !== null; ) {
+      var _ = s.next;
+      if (_ !== null) {
+        s = _;
+        break;
+      }
+      s = s.parent;
+    }
+  }
+}, kr = function() {
+  for (var t = f(this, xe); t !== null; ) {
+    if (!t.is_fork) {
+      for (const [n, [, r]] of this.current)
+        if (t.current.has(n) && !r)
+          return t;
+    }
+    t = f(t, xe);
+  }
+  return null;
+}, /**
+ * @param {Batch} batch
+ */
+xr = function(t) {
+  var r;
+  for (const [s, i] of t.current)
+    !this.previous.has(s) && t.previous.has(s) && this.previous.set(s, t.previous.get(s)), this.current.set(s, i);
+  for (const [s, i] of t.async_deriveds) {
+    const a = this.async_deriveds.get(s);
+    a && i.promise.then(a.resolve);
+  }
+  const n = (s) => {
+    var i = s.reactions;
+    if (i !== null)
+      for (const l of i) {
+        var a = l.f;
+        if ((a & D) !== 0)
+          n(
+            /** @type {Derived} */
+            l
+          );
+        else {
+          var o = (
+            /** @type {Effect} */
+            l
+          );
+          a & (rt | fe) && !this.async_deriveds.has(o) && (f(this, ce).delete(o), x(o, I), this.schedule(o));
+        }
+      }
+  };
+  for (const s of this.current.keys())
+    n(s);
+  this.oncommit(() => t.discard()), m(r = t, S, tt).call(r), p = this, m(this, S, gt).call(this);
+}, /**
+ * @param {Effect[]} effects
+ */
+$t = function(t) {
+  for (var n = 0; n < t.length; n += 1)
+    Ar(t[n], f(this, Ne), f(this, ce));
+}, ei = function() {
+  var _;
+  m(this, S, tt).call(this);
+  for (let d = dn; d !== null; d = f(d, je)) {
+    var t = d.id < this.id, n = [];
+    for (const [c, [v, h]] of this.current) {
+      if (d.current.has(c)) {
+        var r = (
+          /** @type {[any, boolean]} */
+          d.current.get(c)[0]
+        );
+        if (t && v !== r)
+          d.current.set(c, [v, h]);
+        else
+          continue;
+      }
+      n.push(c);
+    }
+    if (t)
+      for (const [c, v] of this.async_deriveds) {
+        const h = d.async_deriveds.get(c);
+        h && v.promise.then(h.resolve);
+      }
+    if (f(d, st)) {
+      var s = [...d.current.keys()].filter((c) => !this.current.has(c));
+      if (s.length === 0)
+        t && d.discard();
+      else if (n.length > 0) {
+        if (t)
+          for (const c of f(this, lt))
+            d.unskip_effect(c, (v) => {
+              var h;
+              (v.f & (fe | rt)) !== 0 ? d.schedule(v) : m(h = d, S, $t).call(h, [v]);
+            });
+        d.activate();
+        var i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map();
+        for (var o of n)
+          Nr(o, s, i, a);
+        a = /* @__PURE__ */ new Map();
+        var l = [...d.current.keys()].filter(
+          (c) => this.current.has(c) ? (
+            /** @type {[any, boolean]} */
+            this.current.get(c)[0] !== c.v
+          ) : !0
+        );
+        if (l.length > 0)
+          for (const c of f(this, Nt))
+            (c.f & (ge | J | St)) === 0 && Pn(c, l, a) && ((c.f & (rt | fe)) !== 0 ? (x(c, I), d.schedule(c)) : f(d, Ne).add(c));
+        if (f(d, Y).length > 0 && !f(d, Ve)) {
+          d.apply();
+          for (var u of f(d, Y))
+            m(_ = d, S, wn).call(_, u, [], []);
+          g(d, Y, []);
+        }
+        d.deactivate();
+      }
+    }
+  }
+}, mn = function() {
+  et === null ? dn = et = this : (g(et, je, this), g(this, xe, et)), et = this;
+}, tt = function() {
+  var t = f(this, xe), n = f(this, je);
+  t === null ? dn = n : g(t, je, n), n === null ? et = t : g(n, xe, t), this.linked = !1;
+};
+let be = en;
+function Xt(e) {
+  var t = mt;
+  mt = !0;
+  try {
+    var n;
+    for (e && (p !== null && !p.is_fork && p.flush(), n = e()); ; ) {
+      if (Gs(), p === null)
+        return (
+          /** @type {T} */
+          n
+        );
+      p.flush();
+    }
+  } finally {
+    mt = t;
+  }
+}
+function ti() {
+  try {
+    ks();
+  } catch (e) {
+    Re(e, yn);
+  }
+}
+let se = null;
+function Kn(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var r = e[n++];
+      if ((r.f & (ge | J)) === 0 && vt(r) && (se = /* @__PURE__ */ new Set(), Ke(r), r.deps === null && r.first === null && r.nodes === null && r.teardown === null && r.ac === null && Kr(r), (se == null ? void 0 : se.size) > 0)) {
+        ze.clear();
+        for (const s of se) {
+          if ((s.f & (ge | J)) !== 0) continue;
+          const i = [s];
+          let a = s.parent;
+          for (; a !== null; )
+            se.has(a) && (se.delete(a), i.push(a)), a = a.parent;
+          for (let o = i.length - 1; o >= 0; o--) {
+            const l = i[o];
+            (l.f & (ge | J)) === 0 && Ke(l);
+          }
+        }
+        se.clear();
+      }
+    }
+    se = null;
+  }
+}
+function Nr(e, t, n, r) {
+  if (!n.has(e) && (n.add(e), e.reactions !== null))
+    for (const s of e.reactions) {
+      const i = s.f;
+      (i & D) !== 0 ? Nr(
+        /** @type {Derived} */
+        s,
+        t,
+        n,
+        r
+      ) : (i & (rt | fe)) !== 0 && (i & I) === 0 && Pn(s, t, r) && (x(s, I), Ln(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Or(e, t) {
+  if (e.reactions !== null)
+    for (const n of e.reactions) {
+      const r = n.f;
+      (r & D) !== 0 ? Or(
+        /** @type {Derived} */
+        n,
+        t
+      ) : (r & St) !== 0 && (x(n, I), t.add(
+        /** @type {Effect} */
+        n
+      ));
+    }
+}
+function Pn(e, t, n) {
+  const r = n.get(e);
+  if (r !== void 0) return r;
+  if (e.deps !== null)
+    for (const s of e.deps) {
+      if (Ue.call(t, s))
+        return !0;
+      if ((s.f & D) !== 0 && Pn(
+        /** @type {Derived} */
+        s,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          s,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function Ln(e) {
+  p.schedule(e);
+}
+function Rr(e, t) {
+  if (!((e.f & ye) !== 0 && (e.f & R) !== 0)) {
+    (e.f & I) !== 0 ? t.d.push(e) : (e.f & le) !== 0 && t.m.push(e), x(e, R);
+    for (var n = e.first; n !== null; )
+      Rr(n, t), n = n.next;
+  }
+}
+function Mr(e) {
+  x(e, R);
+  for (var t = e.first; t !== null; )
+    Mr(t), t = t.next;
+}
+function ni(e) {
+  ur(), p !== null && Ns();
+  var t = be.ensure();
+  t.is_fork = !0, C = /* @__PURE__ */ new Map();
+  var n = !1, r = t.settled();
+  return Xt(e), {
+    commit: async () => {
+      if (n) {
+        await r;
+        return;
+      }
+      t.linked || xs(), n = !0, t.is_fork = !1;
+      for (var [s, [i]] of t.current)
+        s.v = i, s.wv = Qt();
+      t.activate(), t.run_fork_commit_callbacks(), t.deactivate(), Xt(() => {
+        var a = /* @__PURE__ */ new Set();
+        for (var o of t.current.keys())
+          Or(o, a);
+        hi(a), Hr();
+      }), t.flush(), await r;
+    },
+    discard: () => {
+      for (var s of t.current.keys())
+        s.wv = Qt();
+      !n && t.linked && t.discard();
+    }
+  };
+}
+function ri(e) {
+  let t = 0, n = jt(0), r;
+  return () => {
+    Hn() && (ve(n), Vn(() => (t === 0 && (r = Je(() => e(() => Et(n)))), t += 1, () => {
+      Ce(() => {
+        t -= 1, t === 0 && (r == null || r(), r = void 0, Et(n));
+      });
+    })));
+  };
+}
+var si = ct | Xe;
+function ii(e, t, n, r) {
+  new fi(e, t, n, r);
+}
+var q, Ot, W, Be, j, K, L, U, Ee, Ye, Oe, ot, Rt, Mt, Te, tn, k, Cr, Ir, Dr, En, zt, Gt, Tn, Sn;
+class fi {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   * @param {((error: unknown) => unknown) | undefined} [transform_error]
+   */
+  constructor(t, n, r, s) {
+    y(this, k);
+    /** @type {Boundary | null} */
+    F(this, "parent");
+    F(this, "is_pending", !1);
+    /**
+     * API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
+     * Inherited from parent boundary, or defaults to identity.
+     * @type {(error: unknown) => unknown}
+     */
+    F(this, "transform_error");
+    /** @type {TemplateNode} */
+    y(this, q);
+    /** @type {TemplateNode | null} */
+    y(this, Ot, N ? E : null);
+    /** @type {BoundaryProps} */
+    y(this, W);
+    /** @type {((anchor: Node) => void)} */
+    y(this, Be);
+    /** @type {Effect} */
+    y(this, j);
+    /** @type {Effect | null} */
+    y(this, K, null);
+    /** @type {Effect | null} */
+    y(this, L, null);
+    /** @type {Effect | null} */
+    y(this, U, null);
+    /** @type {DocumentFragment | null} */
+    y(this, Ee, null);
+    y(this, Ye, 0);
+    y(this, Oe, 0);
+    y(this, ot, !1);
+    /** @type {Set<Effect>} */
+    y(this, Rt, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    y(this, Mt, /* @__PURE__ */ new Set());
+    /**
+     * A source containing the number of pending async deriveds/expressions.
+     * Only created if `$effect.pending()` is used inside the boundary,
+     * otherwise updating the source results in needless `Batch.ensure()`
+     * calls followed by no-op flushes
+     * @type {Source<number> | null}
+     */
+    y(this, Te, null);
+    y(this, tn, ri(() => (g(this, Te, jt(f(this, Ye))), () => {
+      g(this, Te, null);
+    })));
+    var i;
+    g(this, q, t), g(this, W, n), g(this, Be, (a) => {
+      var o = (
+        /** @type {Effect} */
+        w
+      );
+      o.b = this, o.f |= vn, r(a);
+    }), this.parent = /** @type {Effect} */
+    w.b, this.transform_error = s ?? ((i = this.parent) == null ? void 0 : i.transform_error) ?? ((a) => a), g(this, j, Gr(() => {
+      if (N) {
+        const a = (
+          /** @type {Comment} */
+          f(this, Ot)
+        );
+        Cn();
+        const o = a.data === _r;
+        if (a.data.startsWith(Gn)) {
+          const u = JSON.parse(a.data.slice(Gn.length));
+          m(this, k, Ir).call(this, u);
+        } else o ? m(this, k, Dr).call(this) : m(this, k, Cr).call(this);
+      } else
+        m(this, k, En).call(this);
+    }, si)), N && g(this, q, E);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    Ar(t, f(this, Rt), f(this, Mt));
+  }
+  /**
+   * Returns `false` if the effect exists inside a boundary whose pending snippet is shown
+   * @returns {boolean}
+   */
+  is_rendered() {
+    return !this.is_pending && (!this.parent || this.parent.is_rendered());
+  }
+  has_pending_snippet() {
+    return !!f(this, W).pending;
+  }
+  /**
+   * Update the source that powers `$effect.pending()` inside this boundary,
+   * and controls when the current `pending` snippet (if any) is removed.
+   * Do not call from inside the class
+   * @param {1 | -1} d
+   * @param {Batch} batch
+   */
+  update_pending_count(t, n) {
+    m(this, k, Tn).call(this, t, n), g(this, Ye, f(this, Ye) + t), !(!f(this, Te) || f(this, ot)) && (g(this, ot, !0), Ce(() => {
+      g(this, ot, !1), f(this, Te) && Zt(f(this, Te), f(this, Ye));
+    }));
+  }
+  get_effect_pending() {
+    return f(this, tn).call(this), ve(
+      /** @type {Source<number>} */
+      f(this, Te)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    if (!f(this, W).onerror && !f(this, W).failed)
+      throw t;
+    p != null && p.is_fork ? (f(this, K) && p.skip_effect(f(this, K)), f(this, L) && p.skip_effect(f(this, L)), f(this, U) && p.skip_effect(f(this, U)), p.on_fork_commit(() => {
+      m(this, k, Sn).call(this, t);
+    })) : m(this, k, Sn).call(this, t);
+  }
+}
+q = new WeakMap(), Ot = new WeakMap(), W = new WeakMap(), Be = new WeakMap(), j = new WeakMap(), K = new WeakMap(), L = new WeakMap(), U = new WeakMap(), Ee = new WeakMap(), Ye = new WeakMap(), Oe = new WeakMap(), ot = new WeakMap(), Rt = new WeakMap(), Mt = new WeakMap(), Te = new WeakMap(), tn = new WeakMap(), k = new WeakSet(), Cr = function() {
+  try {
+    g(this, K, we(() => f(this, Be).call(this, f(this, q))));
+  } catch (t) {
+    this.error(t);
+  }
+}, /**
+ * @param {unknown} error The deserialized error from the server's hydration comment
+ */
+Ir = function(t) {
+  const n = f(this, W).failed;
+  n && g(this, U, we(() => {
+    n(
+      f(this, q),
+      () => t,
+      () => () => {
+      }
+    );
+  }));
+}, Dr = function() {
+  const t = f(this, W).pending;
+  t && (this.is_pending = !0, g(this, L, we(() => t(f(this, q)))), Ce(() => {
+    var n = g(this, Ee, document.createDocumentFragment()), r = ue();
+    n.append(r), g(this, K, m(this, k, Gt).call(this, () => we(() => f(this, Be).call(this, r)))), f(this, Oe) === 0 && (f(this, q).before(n), g(this, Ee, null), Tt(
+      /** @type {Effect} */
+      f(this, L),
+      () => {
+        g(this, L, null);
+      }
+    ), m(this, k, zt).call(
+      this,
+      /** @type {Batch} */
+      p
+    ));
+  }));
+}, En = function() {
+  try {
+    if (this.is_pending = this.has_pending_snippet(), g(this, Oe, 0), g(this, Ye, 0), g(this, K, we(() => {
+      f(this, Be).call(this, f(this, q));
+    })), f(this, Oe) > 0) {
+      var t = g(this, Ee, document.createDocumentFragment());
+      Zr(f(this, K), t);
+      const n = (
+        /** @type {(anchor: Node) => void} */
+        f(this, W).pending
+      );
+      g(this, L, we(() => n(f(this, q))));
+    } else
+      m(this, k, zt).call(
+        this,
+        /** @type {Batch} */
+        p
+      );
+  } catch (n) {
+    this.error(n);
+  }
+}, /**
+ * @param {Batch} batch
+ */
+zt = function(t) {
+  this.is_pending = !1, t.transfer_effects(f(this, Rt), f(this, Mt));
+}, /**
+ * @template T
+ * @param {() => T} fn
+ */
+Gt = function(t) {
+  var n = w, r = b, s = T;
+  te(f(this, j)), ee(f(this, j)), ht(f(this, j).ctx);
+  try {
+    return be.ensure(), t();
+  } catch (i) {
+    return Tr(i), null;
+  } finally {
+    te(n), ee(r), ht(s);
+  }
+}, /**
+ * Updates the pending count associated with the currently visible pending snippet,
+ * if any, such that we can replace the snippet with content once work is done
+ * @param {1 | -1} d
+ * @param {Batch} batch
+ */
+Tn = function(t, n) {
+  var r;
+  if (!this.has_pending_snippet()) {
+    this.parent && m(r = this.parent, k, Tn).call(r, t, n);
+    return;
+  }
+  g(this, Oe, f(this, Oe) + t), f(this, Oe) === 0 && (m(this, k, zt).call(this, n), f(this, L) && Tt(f(this, L), () => {
+    g(this, L, null);
+  }), f(this, Ee) && (f(this, q).before(f(this, Ee)), g(this, Ee, null)));
+}, /**
+ * @param {unknown} error
+ */
+Sn = function(t) {
+  f(this, K) && (V(f(this, K)), g(this, K, null)), f(this, L) && (V(f(this, L)), g(this, L, null)), f(this, U) && (V(f(this, U)), g(this, U, null)), N && (oe(
+    /** @type {TemplateNode} */
+    f(this, Ot)
+  ), Vs(), oe(Bs()));
+  var n = f(this, W).onerror;
+  let r = f(this, W).failed;
+  var s = !1, i = !1;
+  const a = () => {
+    if (s) {
+      Hs();
+      return;
+    }
+    s = !0, i && Ds(), f(this, U) !== null && Tt(f(this, U), () => {
+      g(this, U, null);
+    }), m(this, k, Gt).call(this, () => {
+      m(this, k, En).call(this);
+    });
+  }, o = (l) => {
+    try {
+      i = !0, n == null || n(l, a), i = !1;
+    } catch (u) {
+      Re(u, f(this, j) && f(this, j).parent);
+    }
+    r && g(this, U, m(this, k, Gt).call(this, () => {
+      try {
+        return we(() => {
+          var u = (
+            /** @type {Effect} */
+            w
+          );
+          u.b = this, u.f |= vn, r(
+            f(this, q),
+            () => l,
+            () => a
+          );
+        });
+      } catch (u) {
+        return Re(
+          u,
+          /** @type {Effect} */
+          f(this, j).parent
+        ), null;
+      }
+    }));
+  };
+  Ce(() => {
+    var l;
+    try {
+      l = this.transform_error(t);
+    } catch (u) {
+      Re(u, f(this, j) && f(this, j).parent);
+      return;
+    }
+    l !== null && typeof l == "object" && typeof /** @type {any} */
+    l.then == "function" ? l.then(
+      o,
+      /** @param {unknown} e */
+      (u) => Re(u, f(this, j) && f(this, j).parent)
+    ) : o(l);
+  });
+};
+function ai(e, t, n, r) {
+  const s = Ft() ? Fn : ui;
+  var i = e.filter((c) => !c.settled);
+  if (n.length === 0 && i.length === 0) {
+    r(t.map(s));
+    return;
+  }
+  var a = (
+    /** @type {Effect} */
+    w
+  ), o = li(), l = i.length === 1 ? i[0].promise : i.length > 1 ? Promise.all(i.map((c) => c.promise)) : null;
+  function u(c) {
+    if ((a.f & ge) === 0) {
+      o();
+      try {
+        r(c);
+      } catch (v) {
+        Re(v, a);
+      }
+      Jt();
+    }
+  }
+  var _ = Pr();
+  if (n.length === 0) {
+    l.then(() => u(t.map(s))).finally(_);
+    return;
+  }
+  function d() {
+    Promise.all(n.map((c) => /* @__PURE__ */ oi(c))).then((c) => u([...t.map(s), ...c])).catch((c) => Re(c, a)).finally(_);
+  }
+  l ? l.then(() => {
+    o(), d(), Jt();
+  }) : d();
+}
+function li() {
+  var e = (
+    /** @type {Effect} */
+    w
+  ), t = b, n = T, r = (
+    /** @type {Batch} */
+    p
+  );
+  return function(i = !0) {
+    te(e), ee(t), ht(n), i && (e.f & ge) === 0 && (r == null || r.activate(), r == null || r.apply());
+  };
+}
+function Jt(e = !0) {
+  te(null), ee(null), ht(null), e && (p == null || p.deactivate());
+}
+function Pr() {
+  var e = (
+    /** @type {Effect} */
+    w
+  ), t = (
+    /** @type {Boundary} */
+    e.b
+  ), n = (
+    /** @type {Batch} */
+    p
+  ), r = t.is_rendered();
+  return t.update_pending_count(1, n), n.increment(r, e), () => {
+    t.update_pending_count(-1, n), n.decrement(r, e);
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Fn(e) {
+  var t = D | I;
+  return w !== null && (w.f |= Xe), {
+    ctx: T,
+    deps: null,
+    effects: null,
+    equals: pr,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      M
+    ),
+    wv: 0,
+    parent: w,
+    ac: null
+  };
+}
+const Bt = Symbol("obsolete");
+// @__NO_SIDE_EFFECTS__
+function oi(e, t, n) {
+  let r = (
+    /** @type {Effect | null} */
+    w
+  );
+  r === null && Es();
+  var s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), i = jt(
+    /** @type {V} */
+    M
+  ), a = !b, o = /* @__PURE__ */ new Set();
+  return mi(() => {
+    var v;
+    var l = (
+      /** @type {Effect} */
+      w
+    ), u = lr();
+    s = u.promise;
+    try {
+      Promise.resolve(e()).then(u.resolve, (h) => {
+        h !== rn && u.reject(h);
+      }).finally(Jt);
+    } catch (h) {
+      u.reject(h), Jt();
+    }
+    var _ = (
+      /** @type {Batch} */
+      p
+    );
+    if (a) {
+      if ((l.f & De) !== 0)
+        var d = Pr();
+      if (
+        /** @type {Boundary} */
+        r.b.is_rendered()
+      )
+        (v = _.async_deriveds.get(l)) == null || v.reject(Bt);
+      else
+        for (const h of o.values())
+          h.reject(Bt);
+      o.add(u), _.async_deriveds.set(l, u);
+    }
+    const c = (h, A = void 0) => {
+      d == null || d(), o.delete(u), A !== Bt && (_.activate(), A ? (i.f |= Me, Zt(i, A)) : ((i.f & Me) !== 0 && (i.f ^= Me), Zt(i, h)), _.deactivate());
+    };
+    u.promise.then(c, (h) => c(null, h || "unknown"));
+  }), un(() => {
+    for (const l of o)
+      l.reject(Bt);
+  }), new Promise((l) => {
+    function u(_) {
+      function d() {
+        _ === s ? l(i) : u(s);
+      }
+      _.then(d, d);
+    }
+    u(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Lf(e) {
+  const t = /* @__PURE__ */ Fn(e);
+  return Qr(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function ui(e) {
+  const t = /* @__PURE__ */ Fn(e);
+  return t.equals = yr, t;
+}
+function ci(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      V(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function jn(e) {
+  var t, n = w, r = e.parent;
+  if (!Ie && r !== null && e.v !== M && // if it was never evaluated before, it's guaranteed to fail downstream, so we try to execute instead
+  (r.f & (ge | J)) !== 0)
+    return Fs(), e.v;
+  te(r);
+  try {
+    e.f &= ~We, ci(e), t = ns(e);
+  } finally {
+    te(n);
+  }
+  return t;
+}
+function Lr(e) {
+  var t = jn(e);
+  if (!e.equals(t) && (e.wv = Qt(), (!(p != null && p.is_fork) || e.deps === null) && (p !== null ? (p.capture(e, t, !0), wt == null || wt.capture(e, t, !0)) : e.v = t, e.deps === null))) {
+    x(e, R);
+    return;
+  }
+  Ie || (C !== null ? (Hn() || p != null && p.is_fork) && C.set(e, t) : In(e));
+}
+function di(e) {
+  var t, n;
+  if (e.effects !== null)
+    for (const r of e.effects)
+      (r.teardown || r.ac) && ((t = r.teardown) == null || t.call(r), (n = r.ac) == null || n.abort(rn), r.fn !== null && (r.teardown = pe), r.ac = null, kt(r, 0), Bn(r));
+}
+function Fr(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      t.teardown && t.fn !== null && Ke(t);
+}
+let At = /* @__PURE__ */ new Set();
+const ze = /* @__PURE__ */ new Map();
+function hi(e) {
+  At = e;
+}
+let jr = !1;
+function jt(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: pr,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function ke(e, t) {
+  const n = jt(e);
+  return Qr(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function _i(e, t = !1, n = !0) {
+  var s;
+  const r = jt(e);
+  return t || (r.equals = yr), Lt && n && T !== null && T.l !== null && ((s = T.l).s ?? (s.s = [])).push(r), r;
+}
+function Ff(e, t) {
+  return _e(
+    e,
+    Je(() => ve(e))
+  ), t;
+}
+function _e(e, t, n = !1) {
+  b !== 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
+  (!ae || (b.f & St) !== 0) && Ft() && (b.f & (D | fe | rt | St)) !== 0 && (Z === null || !Ue.call(Z, e)) && Is();
+  let r = n ? yt(t) : t;
+  return Zt(e, r, Ut);
+}
+function Zt(e, t, n = null) {
+  if (!e.equals(t)) {
+    ze.set(e, Ie ? t : e.v);
+    var r = be.ensure();
+    if (r.capture(e, t), (e.f & D) !== 0) {
+      const s = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & I) !== 0 && jn(s), C === null && In(s);
+    }
+    e.wv = Qt(), Vr(e, I, n), Ft() && w !== null && (w.f & R) !== 0 && (w.f & (ye | Se)) === 0 && (G === null ? Ai([e]) : G.push(e)), !r.is_fork && At.size > 0 && !jr && Hr();
+  }
+  return t;
+}
+function Hr() {
+  jr = !1;
+  for (const e of At) {
+    (e.f & R) !== 0 && x(e, le);
+    let t;
+    try {
+      t = vt(e);
+    } catch {
+      t = !0;
+    }
+    t && Ke(e);
+  }
+  At.clear();
+}
+function jf(e, t = 1) {
+  var n = ve(e), r = t === 1 ? n++ : n--;
+  return _e(e, n), r;
+}
+function Et(e) {
+  _e(e, e.v + 1);
+}
+function Vr(e, t, n) {
+  var r = e.reactions;
+  if (r !== null)
+    for (var s = Ft(), i = r.length, a = 0; a < i; a++) {
+      var o = r[a], l = o.f;
+      if (!(!s && o === w)) {
+        var u = (l & I) === 0;
+        if (u && x(o, t), (l & St) !== 0)
+          At.add(
+            /** @type {Effect} */
+            o
+          );
+        else if ((l & D) !== 0) {
+          var _ = (
+            /** @type {Derived} */
+            o
+          );
+          C == null || C.delete(_), (l & We) === 0 && (l & X && (w === null || (w.f & Kt) === 0) && (o.f |= We), Vr(_, le, n));
+        } else if (u) {
+          var d = (
+            /** @type {Effect} */
+            o
+          );
+          (l & fe) !== 0 && se !== null && se.add(d), n !== null ? n.push(d) : Ln(d);
+        }
+      }
+    }
+}
+function yt(e) {
+  if (typeof e != "object" || e === null || $e in e)
+    return e;
+  const t = fr(e);
+  if (t !== vs && t !== ps)
+    return e;
+  var n = /* @__PURE__ */ new Map(), r = sr(e), s = /* @__PURE__ */ ke(0), i = Ge, a = (o) => {
+    if (Ge === i)
+      return o();
+    var l = b, u = Ge;
+    ee(null), er(i);
+    var _ = o();
+    return ee(l), er(u), _;
+  };
+  return r && n.set("length", /* @__PURE__ */ ke(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(o, l, u) {
+        (!("value" in u) || u.configurable === !1 || u.enumerable === !1 || u.writable === !1) && Ms();
+        var _ = n.get(l);
+        return _ === void 0 ? a(() => {
+          var d = /* @__PURE__ */ ke(u.value);
+          return n.set(l, d), d;
+        }) : _e(_, u.value, !0), !0;
+      },
+      deleteProperty(o, l) {
+        var u = n.get(l);
+        if (u === void 0) {
+          if (l in o) {
+            const _ = a(() => /* @__PURE__ */ ke(M));
+            n.set(l, _), Et(s);
+          }
+        } else
+          _e(u, M), Et(s);
+        return !0;
+      },
+      get(o, l, u) {
+        var v;
+        if (l === $e)
+          return e;
+        var _ = n.get(l), d = l in o;
+        if (_ === void 0 && (!d || (v = bt(o, l)) != null && v.writable) && (_ = a(() => {
+          var h = yt(d ? o[l] : M), A = /* @__PURE__ */ ke(h);
+          return A;
+        }), n.set(l, _)), _ !== void 0) {
+          var c = ve(_);
+          return c === M ? void 0 : c;
+        }
+        return Reflect.get(o, l, u);
+      },
+      getOwnPropertyDescriptor(o, l) {
+        var u = Reflect.getOwnPropertyDescriptor(o, l);
+        if (u && "value" in u) {
+          var _ = n.get(l);
+          _ && (u.value = ve(_));
+        } else if (u === void 0) {
+          var d = n.get(l), c = d == null ? void 0 : d.v;
+          if (d !== void 0 && c !== M)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: c,
+              writable: !0
+            };
+        }
+        return u;
+      },
+      has(o, l) {
+        var c;
+        if (l === $e)
+          return !0;
+        var u = n.get(l), _ = u !== void 0 && u.v !== M || Reflect.has(o, l);
+        if (u !== void 0 || w !== null && (!_ || (c = bt(o, l)) != null && c.writable)) {
+          u === void 0 && (u = a(() => {
+            var v = _ ? yt(o[l]) : M, h = /* @__PURE__ */ ke(v);
+            return h;
+          }), n.set(l, u));
+          var d = ve(u);
+          if (d === M)
+            return !1;
+        }
+        return _;
+      },
+      set(o, l, u, _) {
+        var Ze;
+        var d = n.get(l), c = l in o;
+        if (r && l === "length")
+          for (var v = u; v < /** @type {Source<number>} */
+          d.v; v += 1) {
+            var h = n.get(v + "");
+            h !== void 0 ? _e(h, M) : v in o && (h = a(() => /* @__PURE__ */ ke(M)), n.set(v + "", h));
+          }
+        if (d === void 0)
+          (!c || (Ze = bt(o, l)) != null && Ze.writable) && (d = a(() => /* @__PURE__ */ ke(void 0)), _e(d, yt(u)), n.set(l, d));
+        else {
+          c = d.v !== M;
+          var A = a(() => yt(u));
+          _e(d, A);
+        }
+        var O = Reflect.getOwnPropertyDescriptor(o, l);
+        if (O != null && O.set && O.set.call(_, u), !c) {
+          if (r && typeof l == "string") {
+            var P = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), re = Number(l);
+            Number.isInteger(re) && re >= P.v && _e(P, re + 1);
+          }
+          Et(s);
+        }
+        return !0;
+      },
+      ownKeys(o) {
+        ve(s);
+        var l = Reflect.ownKeys(o).filter((d) => {
+          var c = n.get(d);
+          return c === void 0 || c.v !== M;
+        });
+        for (var [u, _] of n)
+          _.v !== M && !(u in o) && l.push(u);
+        return l;
+      },
+      setPrototypeOf() {
+        Cs();
+      }
+    }
+  );
+}
+function Xn(e) {
+  try {
+    if (e !== null && typeof e == "object" && $e in e)
+      return e[$e];
+  } catch {
+  }
+  return e;
+}
+function Hf(e, t) {
+  return Object.is(Xn(e), Xn(t));
+}
+var Jn, Br, Yr, qr;
+function An() {
+  if (Jn === void 0) {
+    Jn = window, Br = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    Yr = bt(t, "firstChild").get, qr = bt(t, "nextSibling").get, $n(e) && (e[bs] = void 0, e[ys] = null, e[ws] = void 0, e.__e = void 0), $n(n) && (n[pt] = void 0);
+  }
+}
+function ue(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function z(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Yr.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Ae(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    qr.call(e)
+  );
+}
+function Vf(e, t) {
+  if (!N)
+    return /* @__PURE__ */ z(e);
+  var n = /* @__PURE__ */ z(E);
+  if (n === null)
+    n = E.appendChild(ue());
+  else if (t && n.nodeType !== Pt) {
+    var r = ue();
+    return n == null || n.before(r), oe(r), r;
+  }
+  return t && ln(
+    /** @type {Text} */
+    n
+  ), oe(n), n;
+}
+function Bf(e, t = !1) {
+  if (!N) {
+    var n = /* @__PURE__ */ z(e);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ Ae(n) : n;
+  }
+  if (t) {
+    if ((E == null ? void 0 : E.nodeType) !== Pt) {
+      var r = ue();
+      return E == null || E.before(r), oe(r), r;
+    }
+    ln(
+      /** @type {Text} */
+      E
+    );
+  }
+  return E;
+}
+function Yf(e, t = 1, n = !1) {
+  let r = N ? E : e;
+  for (var s; t--; )
+    s = r, r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Ae(r);
+  if (!N)
+    return r;
+  if (n) {
+    if ((r == null ? void 0 : r.nodeType) !== Pt) {
+      var i = ue();
+      return r === null ? s == null || s.after(i) : r.before(i), oe(i), i;
+    }
+    ln(
+      /** @type {Text} */
+      r
+    );
+  }
+  return oe(r), r;
+}
+function Ur(e) {
+  e.textContent = "";
+}
+function vi() {
+  return !1;
+}
+function pi(e, t, n) {
+  return (
+    /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
+    document.createElementNS(t ?? Ls, e, void 0)
+  );
+}
+function ln(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Pt; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function qf(e, t) {
+  if (t) {
+    const n = document.body;
+    e.autofocus = !0, Ce(() => {
+      document.activeElement === n && e.focus();
+    });
+  }
+}
+function Uf(e) {
+  N && /* @__PURE__ */ z(e) !== null && Ur(e);
+}
+let Zn = !1;
+function gi() {
+  Zn || (Zn = !0, document.addEventListener(
+    "reset",
+    (e) => {
+      Promise.resolve().then(() => {
+        var t;
+        if (!e.defaultPrevented)
+          for (
+            const n of
+            /**@type {HTMLFormElement} */
+            e.target.elements
+          )
+            (t = n[qt]) == null || t.call(n);
+      });
+    },
+    // In the capture phase to guarantee we get noticed of it (no possibility of stopPropagation)
+    { capture: !0 }
+  ));
+}
+function on(e) {
+  var t = b, n = w;
+  ee(null), te(null);
+  try {
+    return e();
+  } finally {
+    ee(t), te(n);
+  }
+}
+function $f(e, t, n, r = n) {
+  e.addEventListener(t, () => on(n));
+  const s = (
+    /** @type {any} */
+    e[qt]
+  );
+  s ? e[qt] = () => {
+    s(), r(!0);
+  } : e[qt] = () => r(!0), gi();
+}
+function $r(e) {
+  w === null && (b === null && As(), Ss()), Ie && Ts();
+}
+function yi(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function ne(e, t) {
+  var n = w;
+  n !== null && (n.f & J) !== 0 && (e |= J);
+  var r = {
+    ctx: T,
+    deps: null,
+    nodes: null,
+    f: e | I | X,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: n,
+    b: n && n.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  p == null || p.register_created_effect(r);
+  var s = r;
+  if ((e & ut) !== 0)
+    nt !== null ? nt.push(r) : be.ensure().schedule(r);
+  else if (t !== null) {
+    try {
+      Ke(r);
+    } catch (a) {
+      throw V(r), a;
+    }
+    s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+    (s.f & Xe) === 0 && (s = s.first, (e & fe) !== 0 && (e & ct) !== 0 && s !== null && (s.f |= ct));
+  }
+  if (s !== null && (s.parent = n, n !== null && yi(s, n), b !== null && (b.f & D) !== 0 && (e & Se) === 0)) {
+    var i = (
+      /** @type {Derived} */
+      b
+    );
+    (i.effects ?? (i.effects = [])).push(s);
+  }
+  return r;
+}
+function Hn() {
+  return b !== null && !ae;
+}
+function un(e) {
+  const t = ne(Dt, null);
+  return x(t, R), t.teardown = e, t;
+}
+function bi(e) {
+  $r();
+  var t = (
+    /** @type {Effect} */
+    w.f
+  ), n = !b && (t & ye) !== 0 && (t & De) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      T
+    );
+    (r.e ?? (r.e = [])).push(e);
+  } else
+    return zr(e);
+}
+function zr(e) {
+  return ne(ut | or, e);
+}
+function zf(e) {
+  return $r(), ne(Dt | or, e);
+}
+function Gf(e) {
+  be.ensure();
+  const t = ne(Se | Xe, e);
+  return () => {
+    V(t);
+  };
+}
+function wi(e) {
+  be.ensure();
+  const t = ne(Se | Xe, e);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? Tt(t, () => {
+      V(t), r(void 0);
+    }) : (V(t), r(void 0));
+  });
+}
+function Wf(e) {
+  return ne(ut, e);
+}
+function Kf(e, t) {
+  var n = (
+    /** @type {ComponentContextLegacy} */
+    T
+  ), r = { effect: null, ran: !1, deps: e };
+  n.l.$.push(r), r.effect = Vn(() => {
+    if (e(), !r.ran) {
+      r.ran = !0;
+      var s = (
+        /** @type {Effect} */
+        w
+      );
+      try {
+        te(s.parent), Je(t);
+      } finally {
+        te(s);
+      }
+    }
+  });
+}
+function Xf() {
+  var e = (
+    /** @type {ComponentContextLegacy} */
+    T
+  );
+  Vn(() => {
+    for (var t of e.l.$) {
+      t.deps();
+      var n = t.effect;
+      (n.f & R) !== 0 && n.deps !== null && x(n, le), vt(n) && Ke(n), t.ran = !1;
+    }
+  });
+}
+function mi(e) {
+  return ne(rt | Xe, e);
+}
+function Vn(e, t = 0) {
+  return ne(Dt | t, e);
+}
+function Jf(e, t = [], n = [], r = []) {
+  ai(r, t, n, (s) => {
+    ne(Dt, () => e(...s.map(ve)));
+  });
+}
+function Gr(e, t = 0) {
+  var n = ne(fe | t, e);
+  return n;
+}
+function Zf(e, t = 0) {
+  var n = ne(Mn | t, e);
+  return n;
+}
+function we(e) {
+  return ne(ye | Xe, e);
+}
+function Wr(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = Ie, r = b;
+    Qn(!0), ee(null);
+    try {
+      t.call(null);
+    } finally {
+      Qn(n), ee(r);
+    }
+  }
+}
+function Bn(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const s = n.ac;
+    s !== null && on(() => {
+      s.abort(rn);
+    });
+    var r = n.next;
+    (n.f & Se) !== 0 ? n.parent = null : V(n, t), n = r;
+  }
+}
+function Ei(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & ye) === 0 && V(t), t = n;
+  }
+}
+function V(e, t = !0) {
+  var n = !1;
+  (t || (e.f & gs) !== 0) && e.nodes !== null && e.nodes.end !== null && (Ti(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), x(e, zn), Bn(e, t && !n), kt(e, 0);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const i of r)
+      i.stop();
+  Wr(e), e.f ^= zn, e.f |= ge;
+  var s = e.parent;
+  s !== null && s.first !== null && Kr(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = e.b = null;
+}
+function Ti(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ Ae(e);
+    e.remove(), e = n;
+  }
+}
+function Kr(e) {
+  var t = e.parent, n = e.prev, r = e.next;
+  n !== null && (n.next = r), r !== null && (r.prev = n), t !== null && (t.first === e && (t.first = r), t.last === e && (t.last = n));
+}
+function Tt(e, t, n = !0) {
+  var r = [];
+  Xr(e, r, !0);
+  var s = () => {
+    n && V(e), t && t();
+  }, i = r.length;
+  if (i > 0) {
+    var a = () => --i || s();
+    for (var o of r)
+      o.out(a);
+  } else
+    s();
+}
+function Xr(e, t, n) {
+  if ((e.f & J) === 0) {
+    e.f ^= J;
+    var r = e.nodes && e.nodes.t;
+    if (r !== null)
+      for (const o of r)
+        (o.is_global || n) && t.push(o);
+    for (var s = e.first; s !== null; ) {
+      var i = s.next;
+      if ((s.f & Se) === 0) {
+        var a = (s.f & ct) !== 0 || // If this is a branch effect without a block effect parent,
+        // it means the parent block effect was pruned. In that case,
+        // transparency information was transferred to the branch effect.
+        (s.f & ye) !== 0 && (e.f & fe) !== 0;
+        Xr(s, t, a ? n : !1);
+      }
+      s = i;
+    }
+  }
+}
+function Si(e) {
+  Jr(e, !0);
+}
+function Jr(e, t) {
+  if ((e.f & J) !== 0) {
+    e.f ^= J, (e.f & R) === 0 && (x(e, I), be.ensure().schedule(e));
+    for (var n = e.first; n !== null; ) {
+      var r = n.next, s = (n.f & ct) !== 0 || (n.f & ye) !== 0;
+      Jr(n, s ? t : !1), n = r;
+    }
+    var i = e.nodes && e.nodes.t;
+    if (i !== null)
+      for (const a of i)
+        (a.is_global || t) && a.in();
+  }
+}
+function Zr(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, r = e.nodes.end; n !== null; ) {
+      var s = n === r ? null : /* @__PURE__ */ Ae(n);
+      t.append(n), n = s;
+    }
+}
+let Wt = !1, Ie = !1;
+function Qn(e) {
+  Ie = e;
+}
+let b = null, ae = !1;
+function ee(e) {
+  b = e;
+}
+let w = null;
+function te(e) {
+  w = e;
+}
+let Z = null;
+function Qr(e) {
+  b !== null && (Z === null ? Z = [e] : Z.push(e));
+}
+let H = null, B = 0, G = null;
+function Ai(e) {
+  G = e;
+}
+let es = 1, Le = 0, Ge = Le;
+function er(e) {
+  Ge = e;
+}
+function Qt() {
+  return ++es;
+}
+function vt(e) {
+  var t = e.f;
+  if ((t & I) !== 0)
+    return !0;
+  if (t & D && (e.f &= ~We), (t & le) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = n.length, s = 0; s < r; s++) {
+      var i = n[s];
+      if (vt(
+        /** @type {Derived} */
+        i
+      ) && Lr(
+        /** @type {Derived} */
+        i
+      ), i.wv > e.wv)
+        return !0;
+    }
+    (t & X) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    C === null && x(e, R);
+  }
+  return !1;
+}
+function ts(e, t, n = !0) {
+  var r = e.reactions;
+  if (r !== null && !(Z !== null && Ue.call(Z, e)))
+    for (var s = 0; s < r.length; s++) {
+      var i = r[s];
+      (i.f & D) !== 0 ? ts(
+        /** @type {Derived} */
+        i,
+        t,
+        !1
+      ) : t === i && (n ? x(i, I) : (i.f & R) !== 0 && x(i, le), Ln(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function ns(e) {
+  var A;
+  var t = H, n = B, r = G, s = b, i = Z, a = T, o = ae, l = Ge, u = e.f;
+  H = /** @type {null | Value[]} */
+  null, B = 0, G = null, b = (u & (ye | Se)) === 0 ? e : null, Z = null, ht(e.ctx), ae = !1, Ge = ++Le, e.ac !== null && (on(() => {
+    e.ac.abort(rn);
+  }), e.ac = null);
+  try {
+    e.f |= Kt;
+    var _ = (
+      /** @type {Function} */
+      e.fn
+    ), d = _();
+    e.f |= De;
+    var c = e.deps, v = p == null ? void 0 : p.is_fork;
+    if (H !== null) {
+      var h;
+      if (v || kt(e, B), c !== null && B > 0)
+        for (c.length = B + H.length, h = 0; h < H.length; h++)
+          c[B + h] = H[h];
+      else
+        e.deps = c = H;
+      if (Hn() && (e.f & X) !== 0)
+        for (h = B; h < c.length; h++)
+          ((A = c[h]).reactions ?? (A.reactions = [])).push(e);
+    } else !v && c !== null && B < c.length && (kt(e, B), c.length = B);
+    if (Ft() && G !== null && !ae && c !== null && (e.f & (D | le | I)) === 0)
+      for (h = 0; h < /** @type {Source[]} */
+      G.length; h++)
+        ts(
+          G[h],
+          /** @type {Effect} */
+          e
+        );
+    if (s !== null && s !== e) {
+      if (Le++, s.deps !== null)
+        for (let O = 0; O < n; O += 1)
+          s.deps[O].rv = Le;
+      if (t !== null)
+        for (const O of t)
+          O.rv = Le;
+      G !== null && (r === null ? r = G : r.push(.../** @type {Source[]} */
+      G));
+    }
+    return (e.f & Me) !== 0 && (e.f ^= Me), d;
+  } catch (O) {
+    return Tr(O);
+  } finally {
+    e.f ^= Kt, H = t, B = n, G = r, b = s, Z = i, ht(a), ae = o, Ge = l;
+  }
+}
+function ki(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var r = ds.call(n, e);
+    if (r !== -1) {
+      var s = n.length - 1;
+      s === 0 ? n = t.reactions = null : (n[r] = n[s], n.pop());
+    }
+  }
+  if (n === null && (t.f & D) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (H === null || !Ue.call(H, t))) {
+    var i = (
+      /** @type {Derived} */
+      t
+    );
+    (i.f & X) !== 0 && (i.f ^= X, i.f &= ~We), i.v !== M && In(i), di(i), kt(i, 0);
+  }
+}
+function kt(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var r = t; r < n.length; r++)
+      ki(e, n[r]);
+}
+function Ke(e) {
+  var t = e.f;
+  if ((t & ge) === 0) {
+    x(e, R);
+    var n = w, r = Wt;
+    w = e, Wt = !0;
+    try {
+      (t & (fe | Mn)) !== 0 ? Ei(e) : Bn(e), Wr(e);
+      var s = ns(e);
+      e.teardown = typeof s == "function" ? s : null, e.wv = es;
+      var i;
+    } finally {
+      Wt = r, w = n;
+    }
+  }
+}
+async function xi() {
+  await Promise.resolve(), Xt();
+}
+function Ni() {
+  return be.ensure().settled();
+}
+function ve(e) {
+  var t = e.f, n = (t & D) !== 0;
+  if (b !== null && !ae) {
+    var r = w !== null && (w.f & ge) !== 0;
+    if (!r && (Z === null || !Ue.call(Z, e))) {
+      var s = b.deps;
+      if ((b.f & Kt) !== 0)
+        e.rv < Le && (e.rv = Le, H === null && s !== null && s[B] === e ? B++ : H === null ? H = [e] : H.push(e));
+      else {
+        b.deps ?? (b.deps = []), Ue.call(b.deps, e) || b.deps.push(e);
+        var i = e.reactions;
+        i === null ? e.reactions = [b] : Ue.call(i, b) || i.push(b);
+      }
+    }
+  }
+  if (Ie && ze.has(e))
+    return ze.get(e);
+  if (n) {
+    var a = (
+      /** @type {Derived} */
+      e
+    );
+    if (Ie) {
+      var o = a.v;
+      return ((a.f & R) === 0 && a.reactions !== null || ss(a)) && (o = jn(a)), ze.set(a, o), o;
+    }
+    var l = (a.f & X) === 0 && !ae && b !== null && (Wt || (b.f & X) !== 0), u = (a.f & De) === 0;
+    vt(a) && (l && (a.f |= X), Lr(a)), l && !u && (Fr(a), rs(a));
+  }
+  if (C != null && C.has(e))
+    return C.get(e);
+  if ((e.f & Me) !== 0)
+    throw e.v;
+  return e.v;
+}
+function rs(e) {
+  if (e.f |= X, e.deps !== null)
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & D) !== 0 && (t.f & X) === 0 && (Fr(
+        /** @type {Derived} */
+        t
+      ), rs(
+        /** @type {Derived} */
+        t
+      ));
+}
+function ss(e) {
+  if (e.v === M) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (ze.has(t) || (t.f & D) !== 0 && ss(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function Je(e) {
+  var t = ae;
+  try {
+    return ae = !0, e();
+  } finally {
+    ae = t;
+  }
+}
+function Qf(e) {
+  if (!(typeof e != "object" || !e || e instanceof EventTarget)) {
+    if ($e in e)
+      kn(e);
+    else if (!Array.isArray(e))
+      for (let t in e) {
+        const n = e[t];
+        typeof n == "object" && n && $e in n && kn(n);
+      }
+  }
+}
+function kn(e, t = /* @__PURE__ */ new Set()) {
+  if (typeof e == "object" && e !== null && // We don't want to traverse DOM elements
+  !(e instanceof EventTarget) && !t.has(e)) {
+    t.add(e), e instanceof Date && e.getTime();
+    for (let r in e)
+      try {
+        kn(e[r], t);
+      } catch {
+      }
+    const n = fr(e);
+    if (n !== Object.prototype && n !== Array.prototype && n !== Map.prototype && n !== Set.prototype && n !== Date.prototype) {
+      const r = _s(n);
+      for (let s in r) {
+        const i = r[s].get;
+        if (i)
+          try {
+            i.call(e);
+          } catch {
+          }
+      }
+    }
+  }
+}
+function ea(e) {
+  return e.endsWith("capture") && e !== "gotpointercapture" && e !== "lostpointercapture";
+}
+const Oi = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function ta(e) {
+  return Oi.includes(e);
+}
+const Ri = {
+  // 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 na(e) {
+  return e = e.toLowerCase(), Ri[e] ?? e;
+}
+const Mi = ["touchstart", "touchmove"];
+function Ci(e) {
+  return Mi.includes(e);
+}
+const Ii = (
+  /** @type {const} */
+  ["textarea", "script", "style", "title"]
+);
+function ra(e) {
+  return Ii.includes(
+    /** @type {typeof RAW_TEXT_ELEMENTS[number]} */
+    e
+  );
+}
+const Fe = Symbol("events"), is = /* @__PURE__ */ new Set(), xn = /* @__PURE__ */ new Set();
+function fs(e, t, n, r = {}) {
+  function s(i) {
+    if (r.capture || Nn.call(t, i), !i.cancelBubble)
+      return on(() => n == null ? void 0 : n.call(this, i));
+  }
+  return e.startsWith("pointer") || e.startsWith("touch") || e === "wheel" ? Ce(() => {
+    t.addEventListener(e, s, r);
+  }) : t.addEventListener(e, s, r), s;
+}
+function sa(e, t, n, r = {}) {
+  var s = fs(t, e, n, r);
+  return () => {
+    e.removeEventListener(t, s, r);
+  };
+}
+function ia(e, t, n, r, s) {
+  var i = { capture: r, passive: s }, a = fs(e, t, n, i);
+  (t === document.body || // @ts-ignore
+  t === window || // @ts-ignore
+  t === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+  t instanceof HTMLMediaElement) && un(() => {
+    t.removeEventListener(e, a, i);
+  });
+}
+function fa(e, t, n) {
+  (t[Fe] ?? (t[Fe] = {}))[e] = n;
+}
+function aa(e) {
+  for (var t = 0; t < e.length; t++)
+    is.add(e[t]);
+  for (var n of xn)
+    n(e);
+}
+let tr = null;
+function Nn(e) {
+  var O, P;
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), r = e.type, s = ((O = e.composedPath) == null ? void 0 : O.call(e)) || [], i = (
+    /** @type {null | Element} */
+    s[0] || e.target
+  );
+  tr = e;
+  var a = 0, o = tr === e && e[Fe];
+  if (o) {
+    var l = s.indexOf(o);
+    if (l !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e[Fe] = t;
+      return;
+    }
+    var u = s.indexOf(t);
+    if (u === -1)
+      return;
+    l <= u && (a = l);
+  }
+  if (i = /** @type {Element} */
+  s[a] || e.target, i !== t) {
+    ir(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return i || n;
+      }
+    });
+    var _ = b, d = w;
+    ee(null), te(null);
+    try {
+      for (var c, v = []; i !== null; ) {
+        var h = i.assignedSlot || i.parentNode || /** @type {any} */
+        i.host || null;
+        try {
+          var A = (P = i[Fe]) == null ? void 0 : P[r];
+          A != null && (!/** @type {any} */
+          i.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          e.target === i) && A.call(i, e);
+        } catch (re) {
+          c ? v.push(re) : c = re;
+        }
+        if (e.cancelBubble || h === t || h === null)
+          break;
+        i = h;
+      }
+      if (c) {
+        for (let re of v)
+          queueMicrotask(() => {
+            throw re;
+          });
+        throw c;
+      }
+    } finally {
+      e[Fe] = t, delete e.currentTarget, ee(_), te(d);
+    }
+  }
+}
+var rr;
+const _n = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  ((rr = globalThis == null ? void 0 : globalThis.window) == null ? void 0 : rr.trustedTypes) && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", {
+    /** @param {string} html */
+    createHTML: (e) => e
+  })
+);
+function Di(e) {
+  return (
+    /** @type {string} */
+    (_n == null ? void 0 : _n.createHTML(e)) ?? e
+  );
+}
+function Yn(e) {
+  var t = pi("template");
+  return t.innerHTML = Di(e.replaceAll("<!>", "<!---->")), t.content;
+}
+function Q(e, t) {
+  var n = (
+    /** @type {Effect} */
+    w
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function la(e, t) {
+  var n = (t & dr) !== 0, r = (t & Ps) !== 0, s, i = !e.startsWith("<!>");
+  return () => {
+    if (N)
+      return Q(E, null), E;
+    s === void 0 && (s = Yn(i ? e : "<!>" + e), n || (s = /** @type {TemplateNode} */
+    /* @__PURE__ */ z(s)));
+    var a = (
+      /** @type {TemplateNode} */
+      r || Br ? document.importNode(s, !0) : s.cloneNode(!0)
+    );
+    if (n) {
+      var o = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ z(a)
+      ), l = (
+        /** @type {TemplateNode} */
+        a.lastChild
+      );
+      Q(o, l);
+    } else
+      Q(a, a);
+    return a;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Pi(e, t, n = "svg") {
+  var r = !e.startsWith("<!>"), s = (t & dr) !== 0, i = `<${n}>${r ? e : "<!>" + e}</${n}>`, a;
+  return () => {
+    if (N)
+      return Q(E, null), E;
+    if (!a) {
+      var o = (
+        /** @type {DocumentFragment} */
+        Yn(i)
+      ), l = (
+        /** @type {Element} */
+        /* @__PURE__ */ z(o)
+      );
+      if (s)
+        for (a = document.createDocumentFragment(); /* @__PURE__ */ z(l); )
+          a.appendChild(
+            /** @type {TemplateNode} */
+            /* @__PURE__ */ z(l)
+          );
+      else
+        a = /** @type {Element} */
+        /* @__PURE__ */ z(l);
+    }
+    var u = (
+      /** @type {TemplateNode} */
+      a.cloneNode(!0)
+    );
+    if (s) {
+      var _ = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ z(u)
+      ), d = (
+        /** @type {TemplateNode} */
+        u.lastChild
+      );
+      Q(_, d);
+    } else
+      Q(u, u);
+    return u;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function oa(e, t) {
+  return /* @__PURE__ */ Pi(e, t, "svg");
+}
+function ua(e = "") {
+  if (!N) {
+    var t = ue(e + "");
+    return Q(t, t), t;
+  }
+  var n = E;
+  return n.nodeType !== Pt ? (n.before(n = ue()), oe(n)) : ln(
+    /** @type {Text} */
+    n
+  ), Q(n, n), n;
+}
+function ca() {
+  if (N)
+    return Q(E, null), E;
+  var e = document.createDocumentFragment(), t = document.createComment(""), n = ue();
+  return e.append(t, n), Q(t, n), e;
+}
+function da(e, t) {
+  if (N) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      w
+    );
+    ((n.f & De) === 0 || n.nodes.end === null) && (n.nodes.end = E), Cn();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+let On = !0;
+function ha(e) {
+  On = e;
+}
+function _a(e, t) {
+  var n = t == null ? "" : typeof t == "object" ? `${t}` : t;
+  n !== /** @type {any} */
+  (e[pt] ?? (e[pt] = e.nodeValue)) && (e[pt] = n, e.nodeValue = `${n}`);
+}
+function as(e, t) {
+  return ls(e, t);
+}
+function Li(e, t) {
+  An(), t.intro = t.intro ?? !1;
+  const n = t.target, r = N, s = E;
+  try {
+    for (var i = /* @__PURE__ */ z(n); i && (i.nodeType !== sn || /** @type {Comment} */
+    i.data !== hr); )
+      i = /* @__PURE__ */ Ae(i);
+    if (!i)
+      throw dt;
+    Ht(!0), oe(
+      /** @type {Comment} */
+      i
+    );
+    const a = ls(e, { ...t, anchor: i });
+    return Ht(!1), /**  @type {Exports} */
+    a;
+  } catch (a) {
+    if (a instanceof Error && a.message.split(`
+`).some((o) => o.startsWith("https://svelte.dev/e/")))
+      throw a;
+    return a !== dt && console.warn("Failed to hydrate: ", a), t.recover === !1 && Rs(), An(), Ur(n), Ht(!1), as(e, t);
+  } finally {
+    Ht(r), oe(s);
+  }
+}
+const Yt = /* @__PURE__ */ new Map();
+function ls(e, { target: t, anchor: n, props: r = {}, events: s, context: i, intro: a = !0, transformError: o }) {
+  An();
+  var l = void 0, u = wi(() => {
+    var _ = n ?? t.appendChild(ue());
+    ii(
+      /** @type {TemplateNode} */
+      _,
+      {
+        pending: () => {
+        }
+      },
+      (v) => {
+        Us({});
+        var h = (
+          /** @type {ComponentContext} */
+          T
+        );
+        if (i && (h.c = i), s && (r.$$events = s), N && Q(
+          /** @type {TemplateNode} */
+          v,
+          null
+        ), On = a, l = e(v, r) || {}, On = !0, N && (w.nodes.end = E, E === null || E.nodeType !== sn || /** @type {Comment} */
+        E.data !== vr))
+          throw fn(), dt;
+        $s();
+      },
+      o
+    );
+    var d = /* @__PURE__ */ new Set(), c = (v) => {
+      for (var h = 0; h < v.length; h++) {
+        var A = v[h];
+        if (!d.has(A)) {
+          d.add(A);
+          var O = Ci(A);
+          for (const Ze of [t, document]) {
+            var P = Yt.get(Ze);
+            P === void 0 && (P = /* @__PURE__ */ new Map(), Yt.set(Ze, P));
+            var re = P.get(A);
+            re === void 0 ? (Ze.addEventListener(A, Nn, { passive: O }), P.set(A, 1)) : P.set(A, re + 1);
+          }
+        }
+      }
+    };
+    return c(hs(is)), xn.add(c), () => {
+      var O;
+      for (var v of d)
+        for (const P of [t, document]) {
+          var h = (
+            /** @type {Map<string, number>} */
+            Yt.get(P)
+          ), A = (
+            /** @type {number} */
+            h.get(v)
+          );
+          --A == 0 ? (P.removeEventListener(v, Nn), h.delete(v), h.size === 0 && Yt.delete(P)) : h.set(v, A);
+        }
+      xn.delete(c), _ !== n && ((O = _.parentNode) == null || O.removeChild(_));
+    };
+  });
+  return Rn.set(l, u), l;
+}
+let Rn = /* @__PURE__ */ new WeakMap();
+function Fi(e, t) {
+  const n = Rn.get(e);
+  return n ? (Rn.delete(e), n(t)) : Promise.resolve();
+}
+var ie, he, $, qe, Ct, It, nn;
+class ji {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    /** @type {TemplateNode} */
+    F(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    y(this, ie, /* @__PURE__ */ new Map());
+    /**
+     * Map of keys to effects that are currently rendered in the DOM.
+     * These effects are visible and actively part of the document tree.
+     * Example:
+     * ```
+     * {#if condition}
+     * 	foo
+     * {:else}
+     * 	bar
+     * {/if}
+     * ```
+     * Can result in the entries `true->Effect` and `false->Effect`
+     * @type {Map<Key, Effect>}
+     */
+    y(this, he, /* @__PURE__ */ new Map());
+    /**
+     * Similar to #onscreen with respect to the keys, but contains branches that are not yet
+     * in the DOM, because their insertion is deferred.
+     * @type {Map<Key, Branch>}
+     */
+    y(this, $, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    y(this, qe, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    y(this, Ct, !0);
+    /**
+     * @param {Batch} batch
+     */
+    y(this, It, (t) => {
+      if (f(this, ie).has(t)) {
+        var n = (
+          /** @type {Key} */
+          f(this, ie).get(t)
+        ), r = f(this, he).get(n);
+        if (r)
+          Si(r), f(this, qe).delete(n);
+        else {
+          var s = f(this, $).get(n);
+          s && (f(this, he).set(n, s.effect), f(this, $).delete(n), s.fragment.lastChild.remove(), this.anchor.before(s.fragment), r = s.effect);
+        }
+        for (const [i, a] of f(this, ie)) {
+          if (f(this, ie).delete(i), i === t)
+            break;
+          const o = f(this, $).get(a);
+          o && (V(o.effect), f(this, $).delete(a));
+        }
+        for (const [i, a] of f(this, he)) {
+          if (i === n || f(this, qe).has(i)) continue;
+          const o = () => {
+            if (Array.from(f(this, ie).values()).includes(i)) {
+              var u = document.createDocumentFragment();
+              Zr(a, u), u.append(ue()), f(this, $).set(i, { effect: a, fragment: u });
+            } else
+              V(a);
+            f(this, qe).delete(i), f(this, he).delete(i);
+          };
+          f(this, Ct) || !r ? (f(this, qe).add(i), Tt(a, o, !1)) : o();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    y(this, nn, (t) => {
+      f(this, ie).delete(t);
+      const n = Array.from(f(this, ie).values());
+      for (const [r, s] of f(this, $))
+        n.includes(r) || (V(s.effect), f(this, $).delete(r));
+    });
+    this.anchor = t, g(this, Ct, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var r = (
+      /** @type {Batch} */
+      p
+    ), s = vi();
+    if (n && !f(this, he).has(t) && !f(this, $).has(t))
+      if (s) {
+        var i = document.createDocumentFragment(), a = ue();
+        i.append(a), f(this, $).set(t, {
+          effect: we(() => n(a)),
+          fragment: i
+        });
+      } else
+        f(this, he).set(
+          t,
+          we(() => n(this.anchor))
+        );
+    if (f(this, ie).set(r, t), s) {
+      for (const [o, l] of f(this, he))
+        o === t ? r.unskip_effect(l) : r.skip_effect(l);
+      for (const [o, l] of f(this, $))
+        o === t ? r.unskip_effect(l.effect) : r.skip_effect(l.effect);
+      r.oncommit(f(this, It)), r.ondiscard(f(this, nn));
+    } else
+      N && (this.anchor = E), f(this, It).call(this, r);
+  }
+}
+ie = new WeakMap(), he = new WeakMap(), $ = new WeakMap(), qe = new WeakMap(), Ct = new WeakMap(), It = new WeakMap(), nn = new WeakMap();
+function va(e, t, ...n) {
+  var r = new ji(e);
+  Gr(() => {
+    const s = t() ?? null;
+    r.ensure(s, s && ((i) => s(i, ...n)));
+  }, ct);
+}
+function Hi(e) {
+  return (t, ...n) => {
+    var l;
+    var r = e(...n), s;
+    if (N)
+      s = /** @type {Element} */
+      E, Cn();
+    else {
+      var i = r.render().trim(), a = Yn(i);
+      s = /** @type {Element} */
+      /* @__PURE__ */ z(a), t.before(s);
+    }
+    const o = (l = r.setup) == null ? void 0 : l.call(r, s);
+    Q(s, s), typeof o == "function" && un(o);
+  };
+}
+function Vi(e, t) {
+  var n;
+  if (ur(), N) {
+    const r = (n = window.__svelte) == null ? void 0 : n.h;
+    if (r != null && r.has(e))
+      return (
+        /** @type {T} */
+        r.get(e)
+      );
+    js();
+  }
+  return t();
+}
+function Bi() {
+  return b === null && Os(), (b.ac ?? (b.ac = new AbortController())).signal;
+}
+function os(e) {
+  T === null && _t(), Lt && T.l !== null ? qn(T).m.push(e) : bi(() => {
+    const t = Je(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function Yi(e) {
+  T === null && _t(), os(() => () => Je(e));
+}
+function qi(e, t, { bubbles: n = !1, cancelable: r = !1 } = {}) {
+  return new CustomEvent(e, { detail: t, bubbles: n, cancelable: r });
+}
+function Ui() {
+  const e = T;
+  return e === null && _t(), (t, n, r) => {
+    var i;
+    const s = (
+      /** @type {Record<string, Function | Function[]>} */
+      (i = e.s.$$events) == null ? void 0 : i[
+        /** @type {string} */
+        t
+      ]
+    );
+    if (s) {
+      const a = sr(s) ? s.slice() : [s], o = qi(
+        /** @type {string} */
+        t,
+        n,
+        r
+      );
+      for (const l of a)
+        l.call(e.x, o);
+      return !o.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function $i(e) {
+  T === null && _t(), T.l === null && cr(), qn(T).b.push(e);
+}
+function zi(e) {
+  T === null && _t(), T.l === null && cr(), qn(T).a.push(e);
+}
+function qn(e) {
+  var t = (
+    /** @type {ComponentContextLegacy} */
+    e.l
+  );
+  return t.u ?? (t.u = { a: [], b: [], m: [] });
+}
+const pa = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  afterUpdate: zi,
+  beforeUpdate: $i,
+  createContext: Ys,
+  createEventDispatcher: Ui,
+  createRawSnippet: Hi,
+  flushSync: Xt,
+  fork: ni,
+  getAbortSignal: Bi,
+  getAllContexts: qs,
+  getContext: br,
+  hasContext: mr,
+  hydratable: Vi,
+  hydrate: Li,
+  mount: as,
+  onDestroy: Yi,
+  onMount: os,
+  setContext: wr,
+  settled: Ni,
+  tick: xi,
+  unmount: Fi,
+  untrack: Je
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Jn as $,
+  Af as A,
+  fe as B,
+  bs as C,
+  ge as D,
+  cf as E,
+  qt as F,
+  mf as G,
+  vr as H,
+  J as I,
+  w as J,
+  gi as K,
+  tf as L,
+  da as M,
+  Ls as N,
+  hs as O,
+  yf as P,
+  Q,
+  De as R,
+  $e as S,
+  Ef as T,
+  M as U,
+  qf as V,
+  Gr as W,
+  we as X,
+  ta as Y,
+  li as Z,
+  Pf as _,
+  ys as a,
+  vs as a$,
+  Vf as a0,
+  Ur as a1,
+  ca as a2,
+  T as a3,
+  ri as a4,
+  pi as a5,
+  fs as a6,
+  ue as a7,
+  p as a8,
+  Qf as a9,
+  Cn as aA,
+  E as aB,
+  N as aC,
+  fn as aD,
+  pa as aE,
+  Zt as aF,
+  af as aG,
+  Hf as aH,
+  sr as aI,
+  ea as aJ,
+  Ie as aK,
+  mt as aL,
+  Wi as aM,
+  Ki as aN,
+  ra as aO,
+  Ft as aP,
+  Lt as aQ,
+  Kf as aR,
+  Xf as aS,
+  $f as aT,
+  Zf as aU,
+  Zr as aV,
+  _i as aW,
+  Ff as aX,
+  Vs as aY,
+  pe as aZ,
+  na as a_,
+  aa,
+  fa as ab,
+  Fn as ac,
+  Rf as ad,
+  ui as ae,
+  V as af,
+  lf as ag,
+  Wf as ah,
+  Gf as ai,
+  Of as aj,
+  ia as ak,
+  Qi as al,
+  Ji as am,
+  Bf as an,
+  ai as ao,
+  Xt as ap,
+  la as aq,
+  oa as ar,
+  ve as as,
+  br as at,
+  bt as au,
+  _s as av,
+  z as aw,
+  Ae as ax,
+  fr as ay,
+  mr as az,
+  ye as b,
+  sa as b0,
+  Yi as b1,
+  os as b2,
+  Tt as b3,
+  $s as b4,
+  of as b5,
+  yt as b6,
+  Us as b7,
+  Ce as b8,
+  Nf as b9,
+  If as bA,
+  Cf as bB,
+  un as bC,
+  Jf as bD,
+  ua as bE,
+  xi as bF,
+  Zi as bG,
+  Jt as bH,
+  Je as bI,
+  jf as bJ,
+  Lf as bK,
+  bi as bL,
+  zf as bM,
+  on as bN,
+  Xs as bO,
+  Ks as ba,
+  Ti as bb,
+  Uf as bc,
+  Vn as bd,
+  xf as be,
+  Si as bf,
+  Xi as bg,
+  ar as bh,
+  gr as bi,
+  kf as bj,
+  _e as bk,
+  wr as bl,
+  te as bm,
+  oe as bn,
+  Ht as bo,
+  ha as bp,
+  _a as bq,
+  Df as br,
+  vi as bs,
+  On as bt,
+  Yf as bu,
+  Bs as bv,
+  va as bw,
+  jt as bx,
+  ke as by,
+  Mf as bz,
+  be as c,
+  ji as d,
+  sn as e,
+  zn as f,
+  hf as g,
+  df as h,
+  _f as i,
+  uf as j,
+  ef as k,
+  ct as l,
+  ff as m,
+  dt as n,
+  hr as o,
+  _r as p,
+  sf as q,
+  nf as r,
+  Sf as s,
+  Tf as t,
+  vf as u,
+  bf as v,
+  pf as w,
+  gf as x,
+  ws as y,
+  wf as z
+};
+//# sourceMappingURL=index-client-BeiP-va5.js.map