@reddb-io/ui 0.3.4 → 0.3.5

package/dist/embed/index-client-DxIHaYUc.js

@@ -0,0 +1,969 @@
+var nt = Object.defineProperty;
+var Oe = (t) => {
+  throw TypeError(t);
+};
+var it = (t, e, r) => e in t ? nt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var K = (t, e, r) => it(t, typeof e != "symbol" ? e + "" : e, r), me = (t, e, r) => e.has(t) || Oe("Cannot " + r);
+var s = (t, e, r) => (me(t, e, "read from private field"), r ? r.call(t) : e.get(t)), h = (t, e, r) => e.has(t) ? Oe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), c = (t, e, r, n) => (me(t, e, "write to private field"), n ? n.call(t, r) : e.set(t, r), r), p = (t, e, r) => (me(t, e, "access private method"), r);
+import { av as at, aE as $e, bx as ot, c2 as ge, aV as Le, bq as Q, bR as qe, aR as _, aS as v, a3 as V, b as Fe, a8 as je, aQ as Me, r as ft, s as Pe, a9 as x, ai as z, bl as le, aj as H, bf as Be, al as lt, bH as he, bI as de, bJ as Ie, d as ct, aN as ut, a4 as _e, ae as S, aX as ht, aq as G, bK as Z, bi as dt, bQ as _t, aZ as ae, m as Ue, l as pt, bX as vt, bW as gt, ay as bt, aP as mt, am as yt, c7 as Et, bY as Ye, ah as Tt, R as wt, aK as F, b1 as kt, U as Xe, V as At, X as St, bd as Nt, aW as Ee, e as ze, q as Rt, aL as Ct, p as Te, bL as oe, aT as Mt, ad as Dt, af as xt, a6 as Ot, bp as Lt, H as Ft, aU as Pt, bm as It, W as He, bz as Ht, bO as Wt, ba as ie, b9 as Ge, a$ as Vt, aH as $t, c5 as qt, b6 as jt, ag as Bt, aC as Ut, aD as Yt, aF as Xt, aG as zt, aO as Gt, bG as Jt, bM as Kt, b$ as Qt } from "./index-BEbHY5Se.js";
+function Zt(t) {
+  let e = 0, r = qe(0), n;
+  return () => {
+    at() && ($e(r), ot(() => (e === 0 && (n = ge(() => t(() => Le(r)))), e += 1, () => {
+      Q(() => {
+        e -= 1, e === 0 && (n == null || n(), n = void 0, Le(r));
+      });
+    })));
+  };
+}
+var er = Ue | pt;
+function tr(t, e, r, n) {
+  new rr(t, e, r, n);
+}
+var w, ee, N, U, m, R, g, k, O, Y, W, J, te, re, L, pe, d, Je, Ke, Qe, we, ce, ue, ke, Ae;
+class rr {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   * @param {((error: unknown) => unknown) | undefined} [transform_error]
+   */
+  constructor(e, r, n, a) {
+    h(this, d);
+    /** @type {Boundary | null} */
+    K(this, "parent");
+    K(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}
+     */
+    K(this, "transform_error");
+    /** @type {TemplateNode} */
+    h(this, w);
+    /** @type {TemplateNode | null} */
+    h(this, ee, v ? _ : null);
+    /** @type {BoundaryProps} */
+    h(this, N);
+    /** @type {((anchor: Node) => void)} */
+    h(this, U);
+    /** @type {Effect} */
+    h(this, m);
+    /** @type {Effect | null} */
+    h(this, R, null);
+    /** @type {Effect | null} */
+    h(this, g, null);
+    /** @type {Effect | null} */
+    h(this, k, null);
+    /** @type {DocumentFragment | null} */
+    h(this, O, null);
+    h(this, Y, 0);
+    h(this, W, 0);
+    h(this, J, !1);
+    /** @type {Set<Effect>} */
+    h(this, te, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    h(this, re, /* @__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}
+     */
+    h(this, L, null);
+    h(this, pe, Zt(() => (c(this, L, qe(s(this, Y))), () => {
+      c(this, L, null);
+    })));
+    var i;
+    c(this, w, e), c(this, N, r), c(this, U, (o) => {
+      var l = (
+        /** @type {Effect} */
+        V
+      );
+      l.b = this, l.f |= Fe, n(o);
+    }), this.parent = /** @type {Effect} */
+    V.b, this.transform_error = a ?? ((i = this.parent) == null ? void 0 : i.transform_error) ?? ((o) => o), c(this, m, je(() => {
+      if (v) {
+        const o = (
+          /** @type {Comment} */
+          s(this, ee)
+        );
+        Me();
+        const l = o.data === ft;
+        if (o.data.startsWith(Pe)) {
+          const u = JSON.parse(o.data.slice(Pe.length));
+          p(this, d, Ke).call(this, u);
+        } else l ? p(this, d, Qe).call(this) : p(this, d, Je).call(this);
+      } else
+        p(this, d, we).call(this);
+    }, er)), v && c(this, w, _);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(e) {
+    lt(e, s(this, te), s(this, re));
+  }
+  /**
+   * 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 !!s(this, N).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(e, r) {
+    p(this, d, ke).call(this, e, r), c(this, Y, s(this, Y) + e), !(!s(this, L) || s(this, J)) && (c(this, J, !0), Q(() => {
+      c(this, J, !1), s(this, L) && ht(s(this, L), s(this, Y));
+    }));
+  }
+  get_effect_pending() {
+    return s(this, pe).call(this), $e(
+      /** @type {Source<number>} */
+      s(this, L)
+    );
+  }
+  /** @param {unknown} error */
+  error(e) {
+    var r;
+    if (!s(this, N).onerror && !s(this, N).failed)
+      throw e;
+    (r = H) != null && r.is_fork ? (s(this, R) && H.skip_effect(s(this, R)), s(this, g) && H.skip_effect(s(this, g)), s(this, k) && H.skip_effect(s(this, k)), H.on_fork_commit(() => {
+      p(this, d, Ae).call(this, e);
+    })) : p(this, d, Ae).call(this, e);
+  }
+}
+w = new WeakMap(), ee = new WeakMap(), N = new WeakMap(), U = new WeakMap(), m = new WeakMap(), R = new WeakMap(), g = new WeakMap(), k = new WeakMap(), O = new WeakMap(), Y = new WeakMap(), W = new WeakMap(), J = new WeakMap(), te = new WeakMap(), re = new WeakMap(), L = new WeakMap(), pe = new WeakMap(), d = new WeakSet(), Je = function() {
+  try {
+    c(this, R, x(() => s(this, U).call(this, s(this, w))));
+  } catch (e) {
+    this.error(e);
+  }
+}, /**
+ * @param {unknown} error The deserialized error from the server's hydration comment
+ */
+Ke = function(e) {
+  const r = s(this, N).failed;
+  r && c(this, k, x(() => {
+    r(
+      s(this, w),
+      () => e,
+      () => () => {
+      }
+    );
+  }));
+}, Qe = function() {
+  const e = s(this, N).pending;
+  e && (this.is_pending = !0, c(this, g, x(() => e(s(this, w)))), Q(() => {
+    var r = c(this, O, document.createDocumentFragment()), n = z();
+    r.append(n), c(this, R, p(this, d, ue).call(this, () => x(() => s(this, U).call(this, n)))), s(this, W) === 0 && (s(this, w).before(r), c(this, O, null), le(
+      /** @type {Effect} */
+      s(this, g),
+      () => {
+        c(this, g, null);
+      }
+    ), p(this, d, ce).call(
+      this,
+      /** @type {Batch} */
+      H
+    ));
+  }));
+}, we = function() {
+  try {
+    if (this.is_pending = this.has_pending_snippet(), c(this, W, 0), c(this, Y, 0), c(this, R, x(() => {
+      s(this, U).call(this, s(this, w));
+    })), s(this, W) > 0) {
+      var e = c(this, O, document.createDocumentFragment());
+      Be(s(this, R), e);
+      const r = (
+        /** @type {(anchor: Node) => void} */
+        s(this, N).pending
+      );
+      c(this, g, x(() => r(s(this, w))));
+    } else
+      p(this, d, ce).call(
+        this,
+        /** @type {Batch} */
+        H
+      );
+  } catch (r) {
+    this.error(r);
+  }
+}, /**
+ * @param {Batch} batch
+ */
+ce = function(e) {
+  this.is_pending = !1, e.transfer_effects(s(this, te), s(this, re));
+}, /**
+ * @template T
+ * @param {() => T} fn
+ */
+ue = function(e) {
+  var r = V, n = _e, a = S;
+  he(s(this, m)), de(s(this, m)), Ie(s(this, m).ctx);
+  try {
+    return ct.ensure(), e();
+  } catch (i) {
+    return ut(i), null;
+  } finally {
+    he(r), de(n), Ie(a);
+  }
+}, /**
+ * 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
+ */
+ke = function(e, r) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && p(n = this.parent, d, ke).call(n, e, r);
+    return;
+  }
+  c(this, W, s(this, W) + e), s(this, W) === 0 && (p(this, d, ce).call(this, r), s(this, g) && le(s(this, g), () => {
+    c(this, g, null);
+  }), s(this, O) && (s(this, w).before(s(this, O)), c(this, O, null)));
+}, /**
+ * @param {unknown} error
+ */
+Ae = function(e) {
+  s(this, R) && (G(s(this, R)), c(this, R, null)), s(this, g) && (G(s(this, g)), c(this, g, null)), s(this, k) && (G(s(this, k)), c(this, k, null)), v && (Z(
+    /** @type {TemplateNode} */
+    s(this, ee)
+  ), dt(), Z(_t()));
+  var r = s(this, N).onerror;
+  let n = s(this, N).failed;
+  var a = !1, i = !1;
+  const o = () => {
+    if (a) {
+      gt();
+      return;
+    }
+    a = !0, i && vt(), s(this, k) !== null && le(s(this, k), () => {
+      c(this, k, null);
+    }), p(this, d, ue).call(this, () => {
+      p(this, d, we).call(this);
+    });
+  }, l = (f) => {
+    try {
+      i = !0, r == null || r(f, o), i = !1;
+    } catch (u) {
+      ae(u, s(this, m) && s(this, m).parent);
+    }
+    n && c(this, k, p(this, d, ue).call(this, () => {
+      try {
+        return x(() => {
+          var u = (
+            /** @type {Effect} */
+            V
+          );
+          u.b = this, u.f |= Fe, n(
+            s(this, w),
+            () => f,
+            () => o
+          );
+        });
+      } catch (u) {
+        return ae(
+          u,
+          /** @type {Effect} */
+          s(this, m).parent
+        ), null;
+      }
+    }));
+  };
+  Q(() => {
+    var f;
+    try {
+      f = this.transform_error(e);
+    } catch (u) {
+      ae(u, s(this, m) && s(this, m).parent);
+      return;
+    }
+    f !== null && typeof f == "object" && typeof /** @type {any} */
+    f.then == "function" ? f.then(
+      l,
+      /** @param {unknown} e */
+      (u) => ae(u, s(this, m) && s(this, m).parent)
+    ) : l(f);
+  });
+};
+function sr(t, e) {
+  var r;
+  if (bt(), v) {
+    const n = (r = window.__svelte) == null ? void 0 : r.h;
+    if (n != null && n.has(t))
+      return (
+        /** @type {T} */
+        n.get(t)
+      );
+    mt();
+  }
+  return e();
+}
+const B = Symbol("events"), Ze = /* @__PURE__ */ new Set(), Se = /* @__PURE__ */ new Set();
+function wr(t) {
+  if (!v) return;
+  t.removeAttribute("onload"), t.removeAttribute("onerror");
+  const e = t.__e;
+  e !== void 0 && (t.__e = void 0, queueMicrotask(() => {
+    t.isConnected && t.dispatchEvent(e);
+  }));
+}
+function et(t, e, r, n = {}) {
+  function a(i) {
+    if (n.capture || Ne.call(e, i), !i.cancelBubble)
+      return Et(() => r == null ? void 0 : r.call(this, i));
+  }
+  return t.startsWith("pointer") || t.startsWith("touch") || t === "wheel" ? Q(() => {
+    e.addEventListener(t, a, n);
+  }) : e.addEventListener(t, a, n), a;
+}
+function kr(t, e, r, n = {}) {
+  var a = et(e, t, r, n);
+  return () => {
+    t.removeEventListener(e, a, n);
+  };
+}
+function Ar(t, e, r, n, a) {
+  var i = { capture: n, passive: a }, o = et(t, e, r, i);
+  (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) && Ye(() => {
+    e.removeEventListener(t, o, i);
+  });
+}
+function Sr(t, e, r) {
+  (e[B] ?? (e[B] = {}))[t] = r;
+}
+function Nr(t) {
+  for (var e = 0; e < t.length; e++)
+    Ze.add(t[e]);
+  for (var r of Se)
+    r(t);
+}
+let We = null;
+function Ne(t) {
+  var q, T;
+  var e = this, r = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), n = t.type, a = ((q = t.composedPath) == null ? void 0 : q.call(t)) || [], i = (
+    /** @type {null | Element} */
+    a[0] || t.target
+  );
+  We = t;
+  var o = 0, l = We === t && t[B];
+  if (l) {
+    var f = a.indexOf(l);
+    if (f !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t[B] = e;
+      return;
+    }
+    var u = a.indexOf(e);
+    if (u === -1)
+      return;
+    f <= u && (o = f);
+  }
+  if (i = /** @type {Element} */
+  a[o] || t.target, i !== e) {
+    yt(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return i || r;
+      }
+    });
+    var P = _e, $ = V;
+    de(null), he(null);
+    try {
+      for (var I, y = []; i !== null; ) {
+        var b = i.assignedSlot || i.parentNode || /** @type {any} */
+        i.host || null;
+        try {
+          var E = (T = i[B]) == null ? void 0 : T[n];
+          E != 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
+          t.target === i) && E.call(i, t);
+        } catch (j) {
+          I ? y.push(j) : I = j;
+        }
+        if (t.cancelBubble || b === e || b === null)
+          break;
+        i = b;
+      }
+      if (I) {
+        for (let j of y)
+          queueMicrotask(() => {
+            throw j;
+          });
+        throw I;
+      }
+    } finally {
+      t[B] = e, delete t.currentTarget, de(P), he($);
+    }
+  }
+}
+var Ve;
+const ye = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  ((Ve = globalThis == null ? void 0 : globalThis.window) == null ? void 0 : Ve.trustedTypes) && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", {
+    /** @param {string} html */
+    createHTML: (t) => t
+  })
+);
+function nr(t) {
+  return (
+    /** @type {string} */
+    (ye == null ? void 0 : ye.createHTML(t)) ?? t
+  );
+}
+function De(t) {
+  var e = Tt("template");
+  return e.innerHTML = nr(t.replaceAll("<!>", "<!---->")), e.content;
+}
+function C(t, e) {
+  var r = (
+    /** @type {Effect} */
+    V
+  );
+  r.nodes === null && (r.nodes = { start: t, end: e, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Rr(t, e) {
+  var r = (e & Xe) !== 0, n = (e & At) !== 0, a, i = !t.startsWith("<!>");
+  return () => {
+    if (v)
+      return C(_, null), _;
+    a === void 0 && (a = De(i ? t : "<!>" + t), r || (a = /** @type {TemplateNode} */
+    F(a)));
+    var o = (
+      /** @type {TemplateNode} */
+      n || kt ? document.importNode(a, !0) : a.cloneNode(!0)
+    );
+    if (r) {
+      var l = (
+        /** @type {TemplateNode} */
+        F(o)
+      ), f = (
+        /** @type {TemplateNode} */
+        o.lastChild
+      );
+      C(l, f);
+    } else
+      C(o, o);
+    return o;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function ir(t, e, r = "svg") {
+  var n = !t.startsWith("<!>"), a = (e & Xe) !== 0, i = `<${r}>${n ? t : "<!>" + t}</${r}>`, o;
+  return () => {
+    if (v)
+      return C(_, null), _;
+    if (!o) {
+      var l = (
+        /** @type {DocumentFragment} */
+        De(i)
+      ), f = (
+        /** @type {Element} */
+        F(l)
+      );
+      if (a)
+        for (o = document.createDocumentFragment(); F(f); )
+          o.appendChild(
+            /** @type {TemplateNode} */
+            F(f)
+          );
+      else
+        o = /** @type {Element} */
+        F(f);
+    }
+    var u = (
+      /** @type {TemplateNode} */
+      o.cloneNode(!0)
+    );
+    if (a) {
+      var P = (
+        /** @type {TemplateNode} */
+        F(u)
+      ), $ = (
+        /** @type {TemplateNode} */
+        u.lastChild
+      );
+      C(P, $);
+    } else
+      C(u, u);
+    return u;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Cr(t, e) {
+  return /* @__PURE__ */ ir(t, e, "svg");
+}
+function Mr(t = "") {
+  if (!v) {
+    var e = z(t + "");
+    return C(e, e), e;
+  }
+  var r = _;
+  return r.nodeType !== St ? (r.before(r = z()), Z(r)) : Nt(
+    /** @type {Text} */
+    r
+  ), C(r, r), r;
+}
+function Dr() {
+  if (v)
+    return C(_, null), _;
+  var t = document.createDocumentFragment(), e = document.createComment(""), r = z();
+  return t.append(e, r), C(e, r), t;
+}
+function xr(t, e) {
+  if (v) {
+    var r = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      V
+    );
+    ((r.f & wt) === 0 || r.nodes.end === null) && (r.nodes.end = _), Me();
+    return;
+  }
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+function Or(t) {
+  return t.endsWith("capture") && t !== "gotpointercapture" && t !== "lostpointercapture";
+}
+const ar = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function Lr(t) {
+  return ar.includes(t);
+}
+const or = {
+  // 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 Fr(t) {
+  return t = t.toLowerCase(), or[t] ?? t;
+}
+const fr = ["touchstart", "touchmove"];
+function lr(t) {
+  return fr.includes(t);
+}
+const cr = (
+  /** @type {const} */
+  ["textarea", "script", "style", "title"]
+);
+function Pr(t) {
+  return cr.includes(
+    /** @type {typeof RAW_TEXT_ELEMENTS[number]} */
+    t
+  );
+}
+let Re = !0;
+function Ir(t) {
+  Re = t;
+}
+function Hr(t, e) {
+  var n;
+  var r = e == null ? "" : typeof e == "object" ? `${e}` : e;
+  r !== /** @type {any} */
+  (t[n = He] ?? (t[n] = t.nodeValue)) && (t[He] = r, t.nodeValue = `${r}`);
+}
+function tt(t, e) {
+  return rt(t, e);
+}
+function ur(t, e) {
+  Ee(), e.intro = e.intro ?? !1;
+  const r = e.target, n = v, a = _;
+  try {
+    for (var i = F(r); i && (i.nodeType !== ze || /** @type {Comment} */
+    i.data !== Rt); )
+      i = Ct(i);
+    if (!i)
+      throw Te;
+    oe(!0), Z(
+      /** @type {Comment} */
+      i
+    );
+    const o = rt(t, { ...e, anchor: i });
+    return oe(!1), /**  @type {Exports} */
+    o;
+  } catch (o) {
+    if (o instanceof Error && o.message.split(`
+`).some((l) => l.startsWith("https://svelte.dev/e/")))
+      throw o;
+    return o !== Te && console.warn("Failed to hydrate: ", o), e.recover === !1 && Mt(), Ee(), Dt(r), oe(!1), tt(t, e);
+  } finally {
+    oe(n), Z(a);
+  }
+}
+const fe = /* @__PURE__ */ new Map();
+function rt(t, { target: e, anchor: r, props: n = {}, events: a, context: i, intro: o = !0, transformError: l }) {
+  Ee();
+  var f = void 0, u = xt(() => {
+    var P = r ?? e.appendChild(z());
+    tr(
+      /** @type {TemplateNode} */
+      P,
+      {
+        pending: () => {
+        }
+      },
+      (y) => {
+        Lt({});
+        var b = (
+          /** @type {ComponentContext} */
+          S
+        );
+        if (i && (b.c = i), a && (n.$$events = a), v && C(
+          /** @type {TemplateNode} */
+          y,
+          null
+        ), Re = o, f = t(y, n) || {}, Re = !0, v && (V.nodes.end = _, _ === null || _.nodeType !== ze || /** @type {Comment} */
+        _.data !== Ft))
+          throw Pt(), Te;
+        It();
+      },
+      l
+    );
+    var $ = /* @__PURE__ */ new Set(), I = (y) => {
+      for (var b = 0; b < y.length; b++) {
+        var E = y[b];
+        if (!$.has(E)) {
+          $.add(E);
+          var q = lr(E);
+          for (const be of [e, document]) {
+            var T = fe.get(be);
+            T === void 0 && (T = /* @__PURE__ */ new Map(), fe.set(be, T));
+            var j = T.get(E);
+            j === void 0 ? (be.addEventListener(E, Ne, { passive: q }), T.set(E, 1)) : T.set(E, j + 1);
+          }
+        }
+      }
+    };
+    return I(Ot(Ze)), Se.add(I), () => {
+      var q;
+      for (var y of $)
+        for (const T of [e, document]) {
+          var b = (
+            /** @type {Map<string, number>} */
+            fe.get(T)
+          ), E = (
+            /** @type {number} */
+            b.get(y)
+          );
+          --E == 0 ? (T.removeEventListener(y, Ne), b.delete(y), b.size === 0 && fe.delete(T)) : b.set(y, E);
+        }
+      Se.delete(I), P !== r && ((q = P.parentNode) == null || q.removeChild(P));
+    };
+  });
+  return Ce.set(f, u), f;
+}
+let Ce = /* @__PURE__ */ new WeakMap();
+function hr(t, e) {
+  const r = Ce.get(t);
+  return r ? (Ce.delete(t), r(e)) : Promise.resolve();
+}
+var M, D, A, X, se, ne, ve;
+class dr {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(e, r = !0) {
+    /** @type {TemplateNode} */
+    K(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    h(this, M, /* @__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>}
+     */
+    h(this, D, /* @__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>}
+     */
+    h(this, A, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    h(this, X, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    h(this, se, !0);
+    /**
+     * @param {Batch} batch
+     */
+    h(this, ne, (e) => {
+      if (s(this, M).has(e)) {
+        var r = (
+          /** @type {Key} */
+          s(this, M).get(e)
+        ), n = s(this, D).get(r);
+        if (n)
+          Ht(n), s(this, X).delete(r);
+        else {
+          var a = s(this, A).get(r);
+          a && (s(this, D).set(r, a.effect), s(this, A).delete(r), a.fragment.lastChild.remove(), this.anchor.before(a.fragment), n = a.effect);
+        }
+        for (const [i, o] of s(this, M)) {
+          if (s(this, M).delete(i), i === e)
+            break;
+          const l = s(this, A).get(o);
+          l && (G(l.effect), s(this, A).delete(o));
+        }
+        for (const [i, o] of s(this, D)) {
+          if (i === r || s(this, X).has(i)) continue;
+          const l = () => {
+            if (Array.from(s(this, M).values()).includes(i)) {
+              var u = document.createDocumentFragment();
+              Be(o, u), u.append(z()), s(this, A).set(i, { effect: o, fragment: u });
+            } else
+              G(o);
+            s(this, X).delete(i), s(this, D).delete(i);
+          };
+          s(this, se) || !n ? (s(this, X).add(i), le(o, l, !1)) : l();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    h(this, ve, (e) => {
+      s(this, M).delete(e);
+      const r = Array.from(s(this, M).values());
+      for (const [n, a] of s(this, A))
+        r.includes(n) || (G(a.effect), s(this, A).delete(n));
+    });
+    this.anchor = e, c(this, se, r);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(e, r) {
+    var n = (
+      /** @type {Batch} */
+      H
+    ), a = Wt();
+    if (r && !s(this, D).has(e) && !s(this, A).has(e))
+      if (a) {
+        var i = document.createDocumentFragment(), o = z();
+        i.append(o), s(this, A).set(e, {
+          effect: x(() => r(o)),
+          fragment: i
+        });
+      } else
+        s(this, D).set(
+          e,
+          x(() => r(this.anchor))
+        );
+    if (s(this, M).set(n, e), a) {
+      for (const [l, f] of s(this, D))
+        l === e ? n.unskip_effect(f) : n.skip_effect(f);
+      for (const [l, f] of s(this, A))
+        l === e ? n.unskip_effect(f.effect) : n.skip_effect(f.effect);
+      n.oncommit(s(this, ne)), n.ondiscard(s(this, ve));
+    } else
+      v && (this.anchor = _), s(this, ne).call(this, n);
+  }
+}
+M = new WeakMap(), D = new WeakMap(), A = new WeakMap(), X = new WeakMap(), se = new WeakMap(), ne = new WeakMap(), ve = new WeakMap();
+function Wr(t, e, ...r) {
+  var n = new dr(t);
+  je(() => {
+    const a = e() ?? null;
+    n.ensure(a, a && ((i) => a(i, ...r)));
+  }, Ue);
+}
+function _r(t) {
+  return (e, ...r) => {
+    var f;
+    var n = t(...r), a;
+    if (v)
+      a = /** @type {Element} */
+      _, Me();
+    else {
+      var i = n.render().trim(), o = De(i);
+      a = /** @type {Element} */
+      F(o), e.before(a);
+    }
+    const l = (f = n.setup) == null ? void 0 : f.call(n, a);
+    C(a, a), typeof l == "function" && Ye(l);
+  };
+}
+function pr() {
+  var t;
+  return _e === null && $t(), ((t = _e).ac ?? (t.ac = new AbortController())).signal;
+}
+function st(t) {
+  S === null && ie(), jt && S.l !== null ? xe(S).m.push(t) : qt(() => {
+    const e = ge(t);
+    if (typeof e == "function") return (
+      /** @type {() => void} */
+      e
+    );
+  });
+}
+function vr(t) {
+  S === null && ie(), st(() => () => ge(t));
+}
+function gr(t, e, { bubbles: r = !1, cancelable: n = !1 } = {}) {
+  return new CustomEvent(t, { detail: e, bubbles: r, cancelable: n });
+}
+function br() {
+  const t = S;
+  return t === null && ie(), (e, r, n) => {
+    var i;
+    const a = (
+      /** @type {Record<string, Function | Function[]>} */
+      (i = t.s.$$events) == null ? void 0 : i[
+        /** @type {string} */
+        e
+      ]
+    );
+    if (a) {
+      const o = Vt(a) ? a.slice() : [a], l = gr(
+        /** @type {string} */
+        e,
+        r,
+        n
+      );
+      for (const f of o)
+        f.call(t.x, l);
+      return !l.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function mr(t) {
+  S === null && ie(), S.l === null && Ge(), xe(S).b.push(t);
+}
+function yr(t) {
+  S === null && ie(), S.l === null && Ge(), xe(S).a.push(t);
+}
+function xe(t) {
+  var e = (
+    /** @type {ComponentContextLegacy} */
+    t.l
+  );
+  return e.u ?? (e.u = { a: [], b: [], m: [] });
+}
+const Vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  afterUpdate: yr,
+  beforeUpdate: mr,
+  createContext: Bt,
+  createEventDispatcher: br,
+  createRawSnippet: _r,
+  flushSync: Ut,
+  fork: Yt,
+  getAbortSignal: pr,
+  getAllContexts: Xt,
+  getContext: zt,
+  hasContext: Gt,
+  hydratable: sr,
+  hydrate: ur,
+  mount: tt,
+  onDestroy: vr,
+  onMount: st,
+  setContext: Jt,
+  settled: Kt,
+  tick: Qt,
+  unmount: hr,
+  untrack: ge
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  dr as B,
+  xr as a,
+  C as b,
+  tr as c,
+  Lr as d,
+  Dr as e,
+  Zt as f,
+  et as g,
+  Nr as h,
+  Sr as i,
+  Ar as j,
+  Rr as k,
+  Cr as l,
+  Vr as m,
+  Or as n,
+  Pr as o,
+  Fr as p,
+  kr as q,
+  vr as r,
+  st as s,
+  wr as t,
+  Ir as u,
+  Hr as v,
+  Re as w,
+  Wr as x,
+  Mr as y
+};
+//# sourceMappingURL=index-client-DxIHaYUc.js.map