@shimmer-from-structure/svelte 1.1.0 → 2.0.0

package/dist/index.esm.js

@@ -1,801 +1,1873 @@
-var _e = Object.defineProperty;
-var ge = (e, t, n) => t in e ? _e(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var G = (e, t, n) => ge(e, typeof t != "symbol" ? t + "" : t, n);
-import { setContext as pe, getContext as be, onMount as ye, tick as ke } from "svelte";
-import { shimmerDefaults as we, extractElementInfo as ve } from "@shimmer-from-structure/core";
-import { shimmerDefaults as ot } from "@shimmer-from-structure/core";
-function X() {
-}
-function Ce(e, t) {
-  for (const n in t) e[n] = t[n];
+var Nt = Object.defineProperty;
+var On = (e) => {
+  throw TypeError(e);
+};
+var It = (e, n, t) => n in e ? Nt(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
+var ee = (e, n, t) => It(e, typeof n != "symbol" ? n + "" : n, t), an = (e, n, t) => n.has(e) || On("Cannot " + t);
+var h = (e, n, t) => (an(e, n, "read from private field"), t ? t.call(e) : n.get(e)), k = (e, n, t) => n.has(e) ? On("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(e) : n.set(e, t), ne = (e, n, t, r) => (an(e, n, "write to private field"), r ? r.call(e, t) : n.set(e, t), t), be = (e, n, t) => (an(e, n, "access private method"), t);
+import { getContext as Ot, setContext as Pt, onMount as Bt, tick as qt } from "svelte";
+import { shimmerDefaults as Lt, extractElementInfo as Ut } from "@shimmer-from-structure/core";
+import { shimmerDefaults as ui } from "@shimmer-from-structure/core";
+const Ht = "5";
+var Kn;
+typeof window < "u" && ((Kn = window.__svelte ?? (window.__svelte = {})).v ?? (Kn.v = /* @__PURE__ */ new Set())).add(Ht);
+const Yt = 1, zt = 2, Vt = 16, jt = 2, C = Symbol(), hn = !1;
+var Gn = Array.isArray, Kt = Array.prototype.indexOf, Me = Array.prototype.includes, xn = Array.from, cn = Object.getOwnPropertyDescriptor, Gt = Object.prototype, Xt = Array.prototype, Wt = Object.getPrototypeOf;
+function Zt(e) {
+  for (var n = 0; n < e.length; n++)
+    e[n]();
+}
+function Xn() {
+  var e, n, t = new Promise((r, i) => {
+    e = r, n = i;
+  });
+  return { promise: t, resolve: e, reject: n };
+}
+const S = 2, $e = 4, fn = 8, Wn = 1 << 24, ie = 16, $ = 32, Oe = 64, Zn = 128, H = 512, A = 1024, N = 2048, ce = 4096, B = 8192, se = 16384, kn = 32768, Ne = 65536, Pn = 1 << 17, Jn = 1 << 18, sn = 1 << 19, Jt = 1 << 20, fe = 1 << 25, ge = 32768, _n = 1 << 21, Cn = 1 << 22, ue = 1 << 23, Je = Symbol("$state"), ke = new class extends Error {
+  constructor() {
+    super(...arguments);
+    ee(this, "name", "StaleReactionError");
+    ee(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}();
+function Qt() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function $t(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function er() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function nr(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function tr() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function rr() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function ir() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function lr() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Qn(e) {
+  return e === this.v;
+}
+function fr(e, n) {
+  return e != e ? n == n : e !== n || e !== null && typeof e == "object" || typeof e == "function";
+}
+function $n(e) {
+  return !fr(e, this.v);
+}
+let sr = !1, J = null;
+function en(e) {
+  J = e;
+}
+function ur(e, n = !1, t) {
+  J = {
+    p: J,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function or(e) {
+  var n = (
+    /** @type {ComponentContext} */
+    J
+  ), t = n.e;
+  if (t !== null) {
+    n.e = null;
+    for (var r of t)
+      vt(r);
+  }
+  return e !== void 0 && (n.x = e), n.i = !0, J = n.p, e ?? /** @type {T} */
+  {};
+}
+function et() {
+  return !0;
+}
+let Ce = [];
+function ar() {
+  var e = Ce;
+  Ce = [], Zt(e);
+}
+function pn(e) {
+  if (Ce.length === 0) {
+    var n = Ce;
+    queueMicrotask(() => {
+      n === Ce && ar();
+    });
+  }
+  Ce.push(e);
+}
+function cr(e) {
+  var n = E;
+  if (n === null)
+    return p.f |= ue, e;
+  if (n.f & kn)
+    nn(e, n);
+  else {
+    if (!(n.f & Zn))
+      throw e;
+    n.b.error(e);
+  }
+}
+function nn(e, n) {
+  for (; n !== null; ) {
+    if (n.f & Zn)
+      try {
+        n.b.error(e);
+        return;
+      } catch (t) {
+        e = t;
+      }
+    n = n.parent;
+  }
+  throw e;
+}
+const vr = -7169;
+function F(e, n) {
+  e.f = e.f & vr | n;
+}
+function Rn(e) {
+  e.f & H || e.deps === null ? F(e, A) : F(e, ce);
+}
+function nt(e) {
+  if (e !== null)
+    for (const n of e)
+      !(n.f & S) || !(n.f & ge) || (n.f ^= ge, nt(
+        /** @type {Derived} */
+        n.deps
+      ));
+}
+function dr(e, n, t) {
+  e.f & N ? n.add(e) : e.f & ce && t.add(e), nt(e.deps), F(e, A);
+}
+const Xe = /* @__PURE__ */ new Set();
+let w = null, R = null, V = [], Sn = null, mn = !1;
+var Te, Ae, he, Fe, Ye, ze, _e, De, Q, gn, wn, tt;
+const In = class In {
+  constructor() {
+    k(this, Q);
+    ee(this, "committed", !1);
+    /**
+     * The current values of any sources that are updated in this batch
+     * They keys of this map are identical to `this.#previous`
+     * @type {Map<Source, any>}
+     */
+    ee(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any sources that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Source, any>}
+     */
+    ee(this, "previous", /* @__PURE__ */ new Map());
+    /**
+     * When the batch is committed (and the DOM is updated), we need to remove old branches
+     * and append new ones by calling the functions added inside (if/each/key/etc) blocks
+     * @type {Set<() => void>}
+     */
+    k(this, Te, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    k(this, Ae, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    k(this, he, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    k(this, Fe, 0);
+    /**
+     * A deferred that resolves when the batch is committed, used with `settled()`
+     * TODO replace with Promise.withResolvers once supported widely enough
+     * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
+     */
+    k(this, Ye, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    k(this, ze, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    k(this, _e, /* @__PURE__ */ new Set());
+    /**
+     * A set of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`
+     * @type {Set<Effect>}
+     */
+    ee(this, "skipped_effects", /* @__PURE__ */ new Set());
+    ee(this, "is_fork", !1);
+    k(this, De, !1);
+  }
+  is_deferred() {
+    return this.is_fork || h(this, Fe) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(n) {
+    var i;
+    V = [], this.apply();
+    var t = [], r = [];
+    for (const l of n)
+      be(this, Q, gn).call(this, l, t, r);
+    if (this.is_deferred())
+      be(this, Q, wn).call(this, r), be(this, Q, wn).call(this, t);
+    else {
+      for (const l of h(this, Te)) l();
+      h(this, Te).clear(), h(this, he) === 0 && be(this, Q, tt).call(this), w = null, Bn(r), Bn(t), (i = h(this, Ye)) == null || i.resolve();
+    }
+    R = null;
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(n, t) {
+    t !== C && !this.previous.has(n) && this.previous.set(n, t), n.f & ue || (this.current.set(n, n.v), R == null || R.set(n, n.v));
+  }
+  activate() {
+    w = this, this.apply();
+  }
+  deactivate() {
+    w === this && (w = null, R = null);
+  }
+  flush() {
+    if (this.activate(), V.length > 0) {
+      if (hr(), w !== null && w !== this)
+        return;
+    } else h(this, he) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const n of h(this, Ae)) n(this);
+    h(this, Ae).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(n) {
+    ne(this, he, h(this, he) + 1), n && ne(this, Fe, h(this, Fe) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(n) {
+    ne(this, he, h(this, he) - 1), n && ne(this, Fe, h(this, Fe) - 1), !h(this, De) && (ne(this, De, !0), pn(() => {
+      ne(this, De, !1), this.is_deferred() ? V.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const n of h(this, ze))
+      h(this, _e).delete(n), F(n, N), we(n);
+    for (const n of h(this, _e))
+      F(n, ce), we(n);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(n) {
+    h(this, Te).add(n);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(n) {
+    h(this, Ae).add(n);
+  }
+  settled() {
+    return (h(this, Ye) ?? ne(this, Ye, Xn())).promise;
+  }
+  static ensure() {
+    if (w === null) {
+      const n = w = new In();
+      Xe.add(w), pn(() => {
+        w === n && n.flush();
+      });
+    }
+    return w;
+  }
+  apply() {
+  }
+};
+Te = new WeakMap(), Ae = new WeakMap(), he = new WeakMap(), Fe = new WeakMap(), Ye = new WeakMap(), ze = new WeakMap(), _e = new WeakMap(), De = new WeakMap(), Q = new WeakSet(), /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ * @param {Effect[]} effects
+ * @param {Effect[]} render_effects
+ */
+gn = function(n, t, r) {
+  n.f ^= A;
+  for (var i = n.first, l = null; i !== null; ) {
+    var u = i.f, f = (u & ($ | Oe)) !== 0, o = f && (u & A) !== 0, s = o || (u & B) !== 0 || this.skipped_effects.has(i);
+    if (!s && i.fn !== null) {
+      f ? i.f ^= A : l !== null && u & ($e | fn | Wn) ? l.b.defer_effect(i) : u & $e ? t.push(i) : Ge(i) && (u & ie && h(this, _e).add(i), He(i));
+      var a = i.first;
+      if (a !== null) {
+        i = a;
+        continue;
+      }
+    }
+    var v = i.parent;
+    for (i = i.next; i === null && v !== null; )
+      v === l && (l = null), i = v.next, v = v.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+wn = function(n) {
+  for (var t = 0; t < n.length; t += 1)
+    dr(n[t], h(this, ze), h(this, _e));
+}, tt = function() {
+  var i;
+  if (Xe.size > 1) {
+    this.previous.clear();
+    var n = R, t = !0;
+    for (const l of Xe) {
+      if (l === this) {
+        t = !1;
+        continue;
+      }
+      const u = [];
+      for (const [o, s] of this.current) {
+        if (l.current.has(o))
+          if (t && s !== l.current.get(o))
+            l.current.set(o, s);
+          else
+            continue;
+        u.push(o);
+      }
+      if (u.length === 0)
+        continue;
+      const f = [...l.current.keys()].filter((o) => !this.current.has(o));
+      if (f.length > 0) {
+        var r = V;
+        V = [];
+        const o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map();
+        for (const a of u)
+          rt(a, f, o, s);
+        if (V.length > 0) {
+          w = l, l.apply();
+          for (const a of V)
+            be(i = l, Q, gn).call(i, a, [], []);
+          l.deactivate();
+        }
+        V = r;
+      }
+    }
+    w = null, R = n;
+  }
+  this.committed = !0, Xe.delete(this);
+};
+let tn = In;
+function hr() {
+  mn = !0;
+  var e = null;
+  try {
+    for (var n = 0; V.length > 0; ) {
+      var t = tn.ensure();
+      if (n++ > 1e3) {
+        var r, i;
+        _r();
+      }
+      t.process(V), oe.clear();
+    }
+  } finally {
+    mn = !1, Sn = null;
+  }
+}
+function _r() {
+  try {
+    tr();
+  } catch (e) {
+    nn(e, Sn);
+  }
+}
+let z = null;
+function Bn(e) {
+  var n = e.length;
+  if (n !== 0) {
+    for (var t = 0; t < n; ) {
+      var r = e[t++];
+      if (!(r.f & (se | B)) && Ge(r) && (z = /* @__PURE__ */ new Set(), He(r), r.deps === null && r.first === null && r.nodes === null && (r.teardown === null && r.ac === null ? pt(r) : r.fn = null), (z == null ? void 0 : z.size) > 0)) {
+        oe.clear();
+        for (const i of z) {
+          if (i.f & (se | B)) continue;
+          const l = [i];
+          let u = i.parent;
+          for (; u !== null; )
+            z.has(u) && (z.delete(u), l.push(u)), u = u.parent;
+          for (let f = l.length - 1; f >= 0; f--) {
+            const o = l[f];
+            o.f & (se | B) || He(o);
+          }
+        }
+        z.clear();
+      }
+    }
+    z = null;
+  }
+}
+function rt(e, n, t, r) {
+  if (!t.has(e) && (t.add(e), e.reactions !== null))
+    for (const i of e.reactions) {
+      const l = i.f;
+      l & S ? rt(
+        /** @type {Derived} */
+        i,
+        n,
+        t,
+        r
+      ) : l & (Cn | ie) && !(l & N) && it(i, n, r) && (F(i, N), we(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function it(e, n, t) {
+  const r = t.get(e);
+  if (r !== void 0) return r;
+  if (e.deps !== null)
+    for (const i of e.deps) {
+      if (Me.call(n, i))
+        return !0;
+      if (i.f & S && it(
+        /** @type {Derived} */
+        i,
+        n,
+        t
+      ))
+        return t.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return t.set(e, !1), !1;
+}
+function we(e) {
+  for (var n = Sn = e; n.parent !== null; ) {
+    n = n.parent;
+    var t = n.f;
+    if (mn && n === E && t & ie && !(t & Jn))
+      return;
+    if (t & (Oe | $)) {
+      if (!(t & A)) return;
+      n.f ^= A;
+    }
+  }
+  V.push(n);
+}
+function pr(e, n, t, r) {
+  const i = Tn;
+  var l = e.filter((d) => !d.settled);
+  if (t.length === 0 && l.length === 0) {
+    r(n.map(i));
+    return;
+  }
+  var u = w, f = (
+    /** @type {Effect} */
+    E
+  ), o = mr(), s = l.length === 1 ? l[0].promise : l.length > 1 ? Promise.all(l.map((d) => d.promise)) : null;
+  function a(d) {
+    o();
+    try {
+      r(d);
+    } catch (_) {
+      f.f & se || nn(_, f);
+    }
+    u == null || u.deactivate(), En();
+  }
+  if (t.length === 0) {
+    s.then(() => a(n.map(i)));
+    return;
+  }
+  function v() {
+    o(), Promise.all(t.map((d) => /* @__PURE__ */ gr(d))).then((d) => a([...n.map(i), ...d])).catch((d) => nn(d, f));
+  }
+  s ? s.then(v) : v();
+}
+function mr() {
+  var e = E, n = p, t = J, r = w;
+  return function(l = !0) {
+    Ie(e), ae(n), en(t), l && (r == null || r.activate());
+  };
+}
+function En() {
+  Ie(null), ae(null), en(null);
+}
+// @__NO_SIDE_EFFECTS__
+function Tn(e) {
+  var n = S | N, t = p !== null && p.f & S ? (
+    /** @type {Derived} */
+    p
+  ) : null;
+  return E !== null && (E.f |= sn), {
+    ctx: J,
+    deps: null,
+    effects: null,
+    equals: Qn,
+    f: n,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      C
+    ),
+    wv: 0,
+    parent: t ?? E,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function gr(e, n, t) {
+  let r = (
+    /** @type {Effect | null} */
+    E
+  );
+  r === null && Qt();
+  var i = (
+    /** @type {Boundary} */
+    r.b
+  ), l = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), u = qe(
+    /** @type {V} */
+    C
+  ), f = !p, o = /* @__PURE__ */ new Map();
+  return Mr(() => {
+    var _;
+    var s = Xn();
+    l = s.promise;
+    try {
+      Promise.resolve(e()).then(s.resolve, s.reject).then(() => {
+        a === w && a.committed && a.deactivate(), En();
+      });
+    } catch (c) {
+      s.reject(c), En();
+    }
+    var a = (
+      /** @type {Batch} */
+      w
+    );
+    if (f) {
+      var v = i.is_rendered();
+      i.update_pending_count(1), a.increment(v), (_ = o.get(a)) == null || _.reject(ke), o.delete(a), o.set(a, s);
+    }
+    const d = (c, m = void 0) => {
+      if (a.activate(), m)
+        m !== ke && (u.f |= ue, Le(u, m));
+      else {
+        u.f & ue && (u.f ^= ue), Le(u, c);
+        for (const [y, D] of o) {
+          if (o.delete(y), y === a) break;
+          D.reject(ke);
+        }
+      }
+      f && (i.update_pending_count(-1), a.decrement(v));
+    };
+    s.promise.then(d, (c) => d(null, c || "unknown"));
+  }), Fr(() => {
+    for (const s of o.values())
+      s.reject(ke);
+  }), new Promise((s) => {
+    function a(v) {
+      function d() {
+        v === l ? s(u) : a(l);
+      }
+      v.then(d, d);
+    }
+    a(l);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function We(e) {
+  const n = /* @__PURE__ */ Tn(e);
+  return wt(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function wr(e) {
+  const n = /* @__PURE__ */ Tn(e);
+  return n.equals = $n, n;
+}
+function lt(e) {
+  var n = e.effects;
+  if (n !== null) {
+    e.effects = null;
+    for (var t = 0; t < n.length; t += 1)
+      re(
+        /** @type {Effect} */
+        n[t]
+      );
+  }
+}
+function Er(e) {
+  for (var n = e.parent; n !== null; ) {
+    if (!(n.f & S))
+      return n.f & se ? null : (
+        /** @type {Effect} */
+        n
+      );
+    n = n.parent;
+  }
+  return null;
+}
+function An(e) {
+  var n, t = E;
+  Ie(Er(e));
+  try {
+    e.f &= ~ge, lt(e), n = xt(e);
+  } finally {
+    Ie(t);
+  }
+  return n;
+}
+function ft(e) {
+  var n = An(e);
+  if (!e.equals(n) && (e.wv = yt(), (!(w != null && w.is_fork) || e.deps === null) && (e.v = n, e.deps === null))) {
+    F(e, A);
+    return;
+  }
+  Ee || (R !== null ? (ct() || w != null && w.is_fork) && R.set(e, n) : Rn(e));
+}
+let yn = /* @__PURE__ */ new Set();
+const oe = /* @__PURE__ */ new Map();
+let st = !1;
+function qe(e, n) {
+  var t = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Qn,
+    rv: 0,
+    wv: 0
+  };
+  return t;
+}
+// @__NO_SIDE_EFFECTS__
+function W(e, n) {
+  const t = qe(e);
+  return wt(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function yr(e, n = !1, t = !0) {
+  const r = qe(e);
+  return n || (r.equals = $n), r;
+}
+function te(e, n, t = !1) {
+  p !== 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
+  (!K || p.f & Pn) && et() && p.f & (S | ie | Cn | Pn) && (Y === null || !Me.call(Y, e)) && lr();
+  let r = t ? Re(n) : n;
+  return Le(e, r);
+}
+function Le(e, n) {
+  if (!e.equals(n)) {
+    var t = e.v;
+    Ee ? oe.set(e, n) : oe.set(e, t), e.v = n;
+    var r = tn.ensure();
+    if (r.capture(e, t), e.f & S) {
+      const i = (
+        /** @type {Derived} */
+        e
+      );
+      e.f & N && An(i), Rn(i);
+    }
+    e.wv = yt(), ut(e, N), E !== null && E.f & A && !(E.f & ($ | Oe)) && (U === null ? qr([e]) : U.push(e)), !r.is_fork && yn.size > 0 && !st && br();
+  }
+  return n;
+}
+function br() {
+  st = !1;
+  for (const e of yn)
+    e.f & A && F(e, ce), Ge(e) && He(e);
+  yn.clear();
+}
+function vn(e) {
+  te(e, e.v + 1);
+}
+function ut(e, n) {
+  var t = e.reactions;
+  if (t !== null)
+    for (var r = t.length, i = 0; i < r; i++) {
+      var l = t[i], u = l.f, f = (u & N) === 0;
+      if (f && F(l, n), u & S) {
+        var o = (
+          /** @type {Derived} */
+          l
+        );
+        R == null || R.delete(o), u & ge || (u & H && (l.f |= ge), ut(o, ce));
+      } else f && (u & ie && z !== null && z.add(
+        /** @type {Effect} */
+        l
+      ), we(
+        /** @type {Effect} */
+        l
+      ));
+    }
+}
+function Re(e) {
+  if (typeof e != "object" || e === null || Je in e)
+    return e;
+  const n = Wt(e);
+  if (n !== Gt && n !== Xt)
+    return e;
+  var t = /* @__PURE__ */ new Map(), r = Gn(e), i = /* @__PURE__ */ W(0), l = me, u = (f) => {
+    if (me === l)
+      return f();
+    var o = p, s = me;
+    ae(null), Un(l);
+    var a = f();
+    return ae(o), Un(s), a;
+  };
+  return r && t.set("length", /* @__PURE__ */ W(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(f, o, s) {
+        (!("value" in s) || s.configurable === !1 || s.enumerable === !1 || s.writable === !1) && rr();
+        var a = t.get(o);
+        return a === void 0 ? a = u(() => {
+          var v = /* @__PURE__ */ W(s.value);
+          return t.set(o, v), v;
+        }) : te(a, s.value, !0), !0;
+      },
+      deleteProperty(f, o) {
+        var s = t.get(o);
+        if (s === void 0) {
+          if (o in f) {
+            const a = u(() => /* @__PURE__ */ W(C));
+            t.set(o, a), vn(i);
+          }
+        } else
+          te(s, C), vn(i);
+        return !0;
+      },
+      get(f, o, s) {
+        var _;
+        if (o === Je)
+          return e;
+        var a = t.get(o), v = o in f;
+        if (a === void 0 && (!v || (_ = cn(f, o)) != null && _.writable) && (a = u(() => {
+          var c = Re(v ? f[o] : C), m = /* @__PURE__ */ W(c);
+          return m;
+        }), t.set(o, a)), a !== void 0) {
+          var d = g(a);
+          return d === C ? void 0 : d;
+        }
+        return Reflect.get(f, o, s);
+      },
+      getOwnPropertyDescriptor(f, o) {
+        var s = Reflect.getOwnPropertyDescriptor(f, o);
+        if (s && "value" in s) {
+          var a = t.get(o);
+          a && (s.value = g(a));
+        } else if (s === void 0) {
+          var v = t.get(o), d = v == null ? void 0 : v.v;
+          if (v !== void 0 && d !== C)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: d,
+              writable: !0
+            };
+        }
+        return s;
+      },
+      has(f, o) {
+        var d;
+        if (o === Je)
+          return !0;
+        var s = t.get(o), a = s !== void 0 && s.v !== C || Reflect.has(f, o);
+        if (s !== void 0 || E !== null && (!a || (d = cn(f, o)) != null && d.writable)) {
+          s === void 0 && (s = u(() => {
+            var _ = a ? Re(f[o]) : C, c = /* @__PURE__ */ W(_);
+            return c;
+          }), t.set(o, s));
+          var v = g(s);
+          if (v === C)
+            return !1;
+        }
+        return a;
+      },
+      set(f, o, s, a) {
+        var G;
+        var v = t.get(o), d = o in f;
+        if (r && o === "length")
+          for (var _ = s; _ < /** @type {Source<number>} */
+          v.v; _ += 1) {
+            var c = t.get(_ + "");
+            c !== void 0 ? te(c, C) : _ in f && (c = u(() => /* @__PURE__ */ W(C)), t.set(_ + "", c));
+          }
+        if (v === void 0)
+          (!d || (G = cn(f, o)) != null && G.writable) && (v = u(() => /* @__PURE__ */ W(void 0)), te(v, Re(s)), t.set(o, v));
+        else {
+          d = v.v !== C;
+          var m = u(() => Re(s));
+          te(v, m);
+        }
+        var y = Reflect.getOwnPropertyDescriptor(f, o);
+        if (y != null && y.set && y.set.call(a, s), !d) {
+          if (r && typeof o == "string") {
+            var D = (
+              /** @type {Source<number>} */
+              t.get("length")
+            ), b = Number(o);
+            Number.isInteger(b) && b >= D.v && te(D, b + 1);
+          }
+          vn(i);
+        }
+        return !0;
+      },
+      ownKeys(f) {
+        g(i);
+        var o = Reflect.ownKeys(f).filter((v) => {
+          var d = t.get(v);
+          return d === void 0 || d.v !== C;
+        });
+        for (var [s, a] of t)
+          a.v !== C && !(s in f) && o.push(s);
+        return o;
+      },
+      setPrototypeOf() {
+        ir();
+      }
+    }
+  );
+}
+var xr, kr, Cr;
+function Se(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Fn(e) {
   return (
-    /** @type {T & S} */
-    e
+    /** @type {TemplateNode | null} */
+    kr.call(e)
   );
 }
-function ie(e) {
-  return e();
+// @__NO_SIDE_EFFECTS__
+function Ke(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Cr.call(e)
+  );
 }
-function Z() {
-  return /* @__PURE__ */ Object.create(null);
+function dn(e, n) {
+  return /* @__PURE__ */ Fn(e);
 }
-function O(e) {
-  e.forEach(ie);
+function qn(e, n = !1) {
+  {
+    var t = /* @__PURE__ */ Fn(e);
+    return t instanceof Comment && t.data === "" ? /* @__PURE__ */ Ke(t) : t;
+  }
 }
-function le(e) {
-  return typeof e == "function";
+function Rr(e, n = 1, t = !1) {
+  let r = e;
+  for (; n--; )
+    r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Ke(r);
+  return r;
 }
-function Re(e, t) {
-  return e != e ? t == t : e !== t || e && typeof e == "object" || typeof e == "function";
+function Sr(e) {
+  e.textContent = "";
 }
-function Ee(e) {
-  return Object.keys(e).length === 0;
+function ot() {
+  return !1;
 }
-function Y(e, t, n, r) {
-  if (e) {
-    const o = se(e, t, n, r);
-    return e[0](o);
+function at(e) {
+  var n = p, t = E;
+  ae(null), Ie(null);
+  try {
+    return e();
+  } finally {
+    ae(n), Ie(t);
   }
 }
-function se(e, t, n, r) {
-  return e[1] && r ? Ce(n.ctx.slice(), e[1](r(t))) : n.ctx;
+function Tr(e) {
+  E === null && (p === null && nr(), er()), Ee && $t();
+}
+function Ar(e, n) {
+  var t = n.last;
+  t === null ? n.last = n.first = e : (t.next = e, e.prev = t, n.last = e);
 }
-function q(e, t, n, r) {
-  if (e[2] && r) {
-    const o = e[2](r(n));
-    if (t.dirty === void 0)
-      return o;
-    if (typeof o == "object") {
-      const l = [], i = Math.max(t.dirty.length, o.length);
-      for (let a = 0; a < i; a += 1)
-        l[a] = t.dirty[a] | o[a];
-      return l;
+function ve(e, n, t) {
+  var r = E;
+  r !== null && r.f & B && (e |= B);
+  var i = {
+    ctx: J,
+    deps: null,
+    nodes: null,
+    f: e | N | H,
+    first: null,
+    fn: n,
+    last: null,
+    next: null,
+    parent: r,
+    b: r && r.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (t)
+    try {
+      He(i), i.f |= kn;
+    } catch (f) {
+      throw re(i), f;
     }
-    return t.dirty | o;
+  else n !== null && we(i);
+  var l = i;
+  if (t && l.deps === null && l.teardown === null && l.nodes === null && l.first === l.last && // either `null`, or a singular child
+  !(l.f & sn) && (l = l.first, e & ie && e & Ne && l !== null && (l.f |= Ne)), l !== null && (l.parent = r, r !== null && Ar(l, r), p !== null && p.f & S && !(e & Oe))) {
+    var u = (
+      /** @type {Derived} */
+      p
+    );
+    (u.effects ?? (u.effects = [])).push(l);
   }
-  return t.dirty;
+  return i;
+}
+function ct() {
+  return p !== null && !K;
+}
+function Fr(e) {
+  const n = ve(fn, null, !1);
+  return F(n, A), n.teardown = e, n;
+}
+function Dr(e) {
+  Tr();
+  var n = (
+    /** @type {Effect} */
+    E.f
+  ), t = !p && (n & $) !== 0 && (n & kn) === 0;
+  if (t) {
+    var r = (
+      /** @type {ComponentContext} */
+      J
+    );
+    (r.e ?? (r.e = [])).push(e);
+  } else
+    return vt(e);
+}
+function vt(e) {
+  return ve($e | Jt, e, !1);
+}
+function dt(e) {
+  return ve($e, e, !1);
+}
+function Mr(e) {
+  return ve(Cn | sn, e, !0);
+}
+function Nr(e, n = 0) {
+  return ve(fn | n, e, !0);
+}
+function Ir(e, n = [], t = [], r = []) {
+  pr(r, n, t, (i) => {
+    ve(fn, () => e(...i.map(g)), !0);
+  });
 }
-function z(e, t, n, r, o, l) {
-  if (o) {
-    const i = se(t, n, r, l);
-    e.p(i, o);
+function Dn(e, n = 0) {
+  var t = ve(ie | n, e, !0);
+  return t;
+}
+function Ue(e) {
+  return ve($ | sn, e, !0);
+}
+function ht(e) {
+  var n = e.teardown;
+  if (n !== null) {
+    const t = Ee, r = p;
+    Ln(!0), ae(null);
+    try {
+      n.call(null);
+    } finally {
+      Ln(t), ae(r);
+    }
   }
 }
-function J(e) {
-  if (e.ctx.length > 32) {
-    const t = [], n = e.ctx.length / 32;
-    for (let r = 0; r < n; r++)
-      t[r] = -1;
-    return t;
+function _t(e, n = !1) {
+  var t = e.first;
+  for (e.first = e.last = null; t !== null; ) {
+    const i = t.ac;
+    i !== null && at(() => {
+      i.abort(ke);
+    });
+    var r = t.next;
+    t.f & Oe ? t.parent = null : re(t, n), t = r;
   }
-  return -1;
 }
-function N(e, t) {
-  e.appendChild(t);
+function Or(e) {
+  for (var n = e.first; n !== null; ) {
+    var t = n.next;
+    n.f & $ || re(n), n = t;
+  }
 }
-function xe(e, t, n) {
-  const r = Be(e);
-  if (!r.getElementById(t)) {
-    const o = P("style");
-    o.id = t, o.textContent = n, Se(r, o);
+function re(e, n = !0) {
+  var t = !1;
+  (n || e.f & Jn) && e.nodes !== null && e.nodes.end !== null && (Pr(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), t = !0), _t(e, n && !t), rn(e, 0), F(e, se);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const l of r)
+      l.stop();
+  ht(e);
+  var i = e.parent;
+  i !== null && i.first !== null && pt(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Pr(e, n) {
+  for (; e !== null; ) {
+    var t = e === n ? null : /* @__PURE__ */ Ke(e);
+    e.remove(), e = t;
   }
 }
-function Be(e) {
-  if (!e) return document;
-  const t = e.getRootNode ? e.getRootNode() : e.ownerDocument;
-  return t && /** @type {ShadowRoot} */
-  t.host ? (
-    /** @type {ShadowRoot} */
-    t
-  ) : e.ownerDocument;
+function pt(e) {
+  var n = e.parent, t = e.prev, r = e.next;
+  t !== null && (t.next = r), r !== null && (r.prev = t), n !== null && (n.first === e && (n.first = r), n.last === e && (n.last = t));
 }
-function Se(e, t) {
-  return N(
-    /** @type {Document} */
-    e.head || e,
-    t
-  ), t.sheet;
+function Mn(e, n, t = !0) {
+  var r = [];
+  mt(e, r, !0);
+  var i = () => {
+    t && re(e), n && n();
+  }, l = r.length;
+  if (l > 0) {
+    var u = () => --l || i();
+    for (var f of r)
+      f.out(u);
+  } else
+    i();
 }
-function Q(e, t, n) {
-  e.insertBefore(t, n || null);
+function mt(e, n, t) {
+  if (!(e.f & B)) {
+    e.f ^= B;
+    var r = e.nodes && e.nodes.t;
+    if (r !== null)
+      for (const f of r)
+        (f.is_global || t) && n.push(f);
+    for (var i = e.first; i !== null; ) {
+      var l = i.next, u = (i.f & Ne) !== 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.
+      (i.f & $) !== 0 && (e.f & ie) !== 0;
+      mt(i, n, u ? t : !1), i = l;
+    }
+  }
 }
-function T(e) {
-  e.parentNode && e.parentNode.removeChild(e);
+function Nn(e) {
+  gt(e, !0);
 }
-function P(e) {
-  return document.createElement(e);
+function gt(e, n) {
+  if (e.f & B) {
+    e.f ^= B, e.f & A || (F(e, N), we(e));
+    for (var t = e.first; t !== null; ) {
+      var r = t.next, i = (t.f & Ne) !== 0 || (t.f & $) !== 0;
+      gt(t, i ? n : !1), t = r;
+    }
+    var l = e.nodes && e.nodes.t;
+    if (l !== null)
+      for (const u of l)
+        (u.is_global || n) && u.in();
+  }
 }
-function ue(e) {
-  return document.createTextNode(e);
+function Br(e, n) {
+  if (e.nodes)
+    for (var t = e.nodes.start, r = e.nodes.end; t !== null; ) {
+      var i = t === r ? null : /* @__PURE__ */ Ke(t);
+      n.append(t), t = i;
+    }
 }
-function fe() {
-  return ue(" ");
+let Qe = !1, Ee = !1;
+function Ln(e) {
+  Ee = e;
 }
-function Me() {
-  return ue("");
+let p = null, K = !1;
+function ae(e) {
+  p = e;
 }
-function $(e, t, n) {
-  n == null ? e.removeAttribute(t) : e.getAttribute(t) !== n && e.setAttribute(t, n);
+let E = null;
+function Ie(e) {
+  E = e;
 }
-function Ne(e) {
-  return Array.from(e.childNodes);
+let Y = null;
+function wt(e) {
+  p !== null && (Y === null ? Y = [e] : Y.push(e));
 }
-function f(e, t, n, r) {
-  n == null ? e.style.removeProperty(t) : e.style.setProperty(t, n, "");
+let M = null, O = 0, U = null;
+function qr(e) {
+  U = e;
 }
-let W;
-function D(e) {
-  W = e;
+let Et = 1, de = 0, me = de;
+function Un(e) {
+  me = e;
 }
-const M = [], K = [];
-let I = [];
-const ee = [], Pe = /* @__PURE__ */ Promise.resolve();
-let U = !1;
-function Ie() {
-  U || (U = !0, Pe.then(ce));
+function yt() {
+  return ++Et;
 }
-function V(e) {
-  I.push(e);
+function Ge(e) {
+  var n = e.f;
+  if (n & N)
+    return !0;
+  if (n & S && (e.f &= ~ge), n & ce) {
+    for (var t = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = t.length, i = 0; i < r; i++) {
+      var l = t[i];
+      if (Ge(
+        /** @type {Derived} */
+        l
+      ) && ft(
+        /** @type {Derived} */
+        l
+      ), l.wv > e.wv)
+        return !0;
+    }
+    n & H && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    R === null && F(e, A);
+  }
+  return !1;
 }
-const H = /* @__PURE__ */ new Set();
-let S = 0;
-function ce() {
-  if (S !== 0)
-    return;
-  const e = W;
-  do {
+function bt(e, n, t = !0) {
+  var r = e.reactions;
+  if (r !== null && !(Y !== null && Me.call(Y, e)))
+    for (var i = 0; i < r.length; i++) {
+      var l = r[i];
+      l.f & S ? bt(
+        /** @type {Derived} */
+        l,
+        n,
+        !1
+      ) : n === l && (t ? F(l, N) : l.f & A && F(l, ce), we(
+        /** @type {Effect} */
+        l
+      ));
+    }
+}
+function xt(e) {
+  var c;
+  var n = M, t = O, r = U, i = p, l = Y, u = J, f = K, o = me, s = e.f;
+  M = /** @type {null | Value[]} */
+  null, O = 0, U = null, p = s & ($ | Oe) ? null : e, Y = null, en(e.ctx), K = !1, me = ++de, e.ac !== null && (at(() => {
+    e.ac.abort(ke);
+  }), e.ac = null);
+  try {
+    e.f |= _n;
+    var a = (
+      /** @type {Function} */
+      e.fn
+    ), v = a(), d = e.deps;
+    if (M !== null) {
+      var _;
+      if (rn(e, O), d !== null && O > 0)
+        for (d.length = O + M.length, _ = 0; _ < M.length; _++)
+          d[O + _] = M[_];
+      else
+        e.deps = d = M;
+      if (ct() && e.f & H)
+        for (_ = O; _ < d.length; _++)
+          ((c = d[_]).reactions ?? (c.reactions = [])).push(e);
+    } else d !== null && O < d.length && (rn(e, O), d.length = O);
+    if (et() && U !== null && !K && d !== null && !(e.f & (S | ce | N)))
+      for (_ = 0; _ < /** @type {Source[]} */
+      U.length; _++)
+        bt(
+          U[_],
+          /** @type {Effect} */
+          e
+        );
+    if (i !== null && i !== e) {
+      if (de++, i.deps !== null)
+        for (let m = 0; m < t; m += 1)
+          i.deps[m].rv = de;
+      if (n !== null)
+        for (const m of n)
+          m.rv = de;
+      U !== null && (r === null ? r = U : r.push(.../** @type {Source[]} */
+      U));
+    }
+    return e.f & ue && (e.f ^= ue), v;
+  } catch (m) {
+    return cr(m);
+  } finally {
+    e.f ^= _n, M = n, O = t, U = r, p = i, Y = l, en(u), K = f, me = o;
+  }
+}
+function Lr(e, n) {
+  let t = n.reactions;
+  if (t !== null) {
+    var r = Kt.call(t, e);
+    if (r !== -1) {
+      var i = t.length - 1;
+      i === 0 ? t = n.reactions = null : (t[r] = t[i], t.pop());
+    }
+  }
+  if (t === null && n.f & S && // 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
+  (M === null || !Me.call(M, n))) {
+    var l = (
+      /** @type {Derived} */
+      n
+    );
+    l.f & H && (l.f ^= H, l.f &= ~ge), Rn(l), lt(l), rn(l, 0);
+  }
+}
+function rn(e, n) {
+  var t = e.deps;
+  if (t !== null)
+    for (var r = n; r < t.length; r++)
+      Lr(e, t[r]);
+}
+function He(e) {
+  var n = e.f;
+  if (!(n & se)) {
+    F(e, A);
+    var t = E, r = Qe;
+    E = e, Qe = !0;
     try {
-      for (; S < M.length; ) {
-        const t = M[S];
-        S++, D(t), Oe(t.$$);
+      n & (ie | Wn) ? Or(e) : _t(e), ht(e);
+      var i = xt(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = Et;
+      var l;
+      hn && sr && e.f & N && e.deps;
+    } finally {
+      Qe = r, E = t;
+    }
+  }
+}
+function g(e) {
+  var n = e.f, t = (n & S) !== 0;
+  if (p !== null && !K) {
+    var r = E !== null && (E.f & se) !== 0;
+    if (!r && (Y === null || !Me.call(Y, e))) {
+      var i = p.deps;
+      if (p.f & _n)
+        e.rv < de && (e.rv = de, M === null && i !== null && i[O] === e ? O++ : M === null ? M = [e] : M.push(e));
+      else {
+        (p.deps ?? (p.deps = [])).push(e);
+        var l = e.reactions;
+        l === null ? e.reactions = [p] : Me.call(l, p) || l.push(p);
       }
-    } catch (t) {
-      throw M.length = 0, S = 0, t;
-    }
-    for (D(null), M.length = 0, S = 0; K.length; ) K.pop()();
-    for (let t = 0; t < I.length; t += 1) {
-      const n = I[t];
-      H.has(n) || (H.add(n), n());
-    }
-    I.length = 0;
-  } while (M.length);
-  for (; ee.length; )
-    ee.pop()();
-  U = !1, H.clear(), D(e);
-}
-function Oe(e) {
-  if (e.fragment !== null) {
-    e.update(), O(e.before_update);
-    const t = e.dirty;
-    e.dirty = [-1], e.fragment && e.fragment.p(e.ctx, t), e.after_update.forEach(V);
-  }
-}
-function De(e) {
-  const t = [], n = [];
-  I.forEach((r) => e.indexOf(r) === -1 ? t.push(r) : n.push(r)), n.forEach((r) => r()), I = t;
-}
-const L = /* @__PURE__ */ new Set();
-let x;
-function ae() {
-  x = {
-    r: 0,
-    c: [],
-    p: x
-    // parent group
-  };
+    }
+  }
+  if (Ee && oe.has(e))
+    return oe.get(e);
+  if (t) {
+    var u = (
+      /** @type {Derived} */
+      e
+    );
+    if (Ee) {
+      var f = u.v;
+      return (!(u.f & A) && u.reactions !== null || Ct(u)) && (f = An(u)), oe.set(u, f), f;
+    }
+    var o = (u.f & H) === 0 && !K && p !== null && (Qe || (p.f & H) !== 0), s = u.deps === null;
+    Ge(u) && (o && (u.f |= H), ft(u)), o && !s && kt(u);
+  }
+  if (R != null && R.has(e))
+    return R.get(e);
+  if (e.f & ue)
+    throw e.v;
+  return e.v;
 }
-function de() {
-  x.r || O(x.c), x = x.p;
-}
-function R(e, t) {
-  e && e.i && (L.delete(e), e.i(t));
-}
-function B(e, t, n, r) {
-  if (e && e.o) {
-    if (L.has(e)) return;
-    L.add(e), x.c.push(() => {
-      L.delete(e), r && (n && e.d(1), r());
-    }), e.o(t);
-  } else r && r();
-}
-function te(e) {
-  return (e == null ? void 0 : e.length) !== void 0 ? e : Array.from(e);
-}
-function Ae(e, t) {
-  e.d(1), t.delete(e.key);
-}
-function je(e, t, n, r, o, l, i, a, c, u, y, m) {
-  let p = e.length, b = l.length, k = p;
-  const s = {};
-  for (; k--; ) s[e[k].key] = k;
-  const h = [], _ = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), w = [];
-  for (k = b; k--; ) {
-    const g = m(o, l, k), v = n(g);
-    let C = i.get(v);
-    C ? w.push(() => C.p(g, t)) : (C = u(v, g), C.c()), _.set(v, h[k] = C), v in s && E.set(v, Math.abs(k - s[v]));
-  }
-  const A = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Set();
-  function d(g) {
-    R(g, 1), g.m(a, y), i.set(g.key, g), y = g.first, b--;
-  }
-  for (; p && b; ) {
-    const g = h[b - 1], v = e[p - 1], C = g.key, F = v.key;
-    g === v ? (y = g.first, p--, b--) : _.has(F) ? !i.has(C) || A.has(C) ? d(g) : j.has(F) ? p-- : E.get(C) > E.get(F) ? (j.add(C), d(g)) : (A.add(F), p--) : (c(v, i), p--);
-  }
-  for (; p--; ) {
-    const g = e[p];
-    _.has(g.key) || c(g, i);
-  }
-  for (; b; ) d(h[b - 1]);
-  return O(w), h;
-}
-function Fe(e, t, n) {
-  const { fragment: r, after_update: o } = e.$$;
-  r && r.m(t, n), V(() => {
-    const l = e.$$.on_mount.map(ie).filter(le);
-    e.$$.on_destroy ? e.$$.on_destroy.push(...l) : O(l), e.$$.on_mount = [];
-  }), o.forEach(V);
-}
-function Le(e, t) {
-  const n = e.$$;
-  n.fragment !== null && (De(n.after_update), O(n.on_destroy), n.fragment && n.fragment.d(t), n.on_destroy = n.fragment = null, n.ctx = []);
-}
-function Te(e, t) {
-  e.$$.dirty[0] === -1 && (M.push(e), Ie(), e.$$.dirty.fill(0)), e.$$.dirty[t / 31 | 0] |= 1 << t % 31;
-}
-function Ge(e, t, n, r, o, l, i = null, a = [-1]) {
-  const c = W;
-  D(e);
-  const u = e.$$ = {
-    fragment: null,
-    ctx: [],
-    // state
-    props: l,
-    update: X,
-    not_equal: o,
-    bound: Z(),
-    // lifecycle
-    on_mount: [],
-    on_destroy: [],
-    on_disconnect: [],
-    before_update: [],
-    after_update: [],
-    context: new Map(t.context || (c ? c.$$.context : [])),
-    // everything else
-    callbacks: Z(),
-    dirty: a,
-    skip_bound: !1,
-    root: t.target || c.$$.root
-  };
-  i && i(u.root);
-  let y = !1;
-  if (u.ctx = n ? n(e, t.props || {}, (m, p, ...b) => {
-    const k = b.length ? b[0] : p;
-    return u.ctx && o(u.ctx[m], u.ctx[m] = k) && (!u.skip_bound && u.bound[m] && u.bound[m](k), y && Te(e, m)), p;
-  }) : [], u.update(), y = !0, O(u.before_update), u.fragment = r ? r(u.ctx) : !1, t.target) {
-    if (t.hydrate) {
-      const m = Ne(t.target);
-      u.fragment && u.fragment.l(m), m.forEach(T);
-    } else
-      u.fragment && u.fragment.c();
-    t.intro && R(e.$$.fragment), Fe(e, t.target, t.anchor), ce();
+function kt(e) {
+  if (e.deps !== null) {
+    e.f |= H;
+    for (const n of e.deps)
+      (n.reactions ?? (n.reactions = [])).push(e), n.f & S && !(n.f & H) && kt(
+        /** @type {Derived} */
+        n
+      );
   }
-  D(c);
 }
-class He {
-  constructor() {
+function Ct(e) {
+  if (e.v === C) return !0;
+  if (e.deps === null) return !1;
+  for (const n of e.deps)
+    if (oe.has(n) || n.f & S && Ct(
+      /** @type {Derived} */
+      n
+    ))
+      return !0;
+  return !1;
+}
+function Ur(e) {
+  var n = K;
+  try {
+    return K = !0, e();
+  } finally {
+    K = n;
+  }
+}
+function Hr(e) {
+  var n = document.createElement("template");
+  return n.innerHTML = e.replaceAll("<!>", "<!---->"), n.content;
+}
+function Rt(e, n) {
+  var t = (
+    /** @type {Effect} */
+    E
+  );
+  t.nodes === null && (t.nodes = { start: e, end: n, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function St(e, n) {
+  var t = (n & jt) !== 0, r, i = !e.startsWith("<!>");
+  return () => {
+    r === void 0 && (r = Hr(i ? e : "<!>" + e), r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Fn(r));
+    var l = (
+      /** @type {TemplateNode} */
+      t || xr ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return Rt(l, l), l;
+  };
+}
+function Hn() {
+  var e = document.createDocumentFragment(), n = document.createComment(""), t = Se();
+  return e.append(n, t), Rt(n, t), e;
+}
+function Ze(e, n) {
+  e !== null && e.before(
+    /** @type {Node} */
+    n
+  );
+}
+var j, Z, P, pe, Ve, je, ln;
+class Tt {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(n, t = !0) {
+    /** @type {TemplateNode} */
+    ee(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    k(this, j, /* @__PURE__ */ new Map());
     /**
-     * ### PRIVATE API
-     *
-     * Do not use, may change at any time
-     *
-     * @type {any}
+     * 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>}
      */
-    G(this, "$$");
+    k(this, Z, /* @__PURE__ */ new Map());
     /**
-     * ### PRIVATE API
-     *
-     * Do not use, may change at any time
-     *
-     * @type {any}
+     * 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>}
      */
-    G(this, "$$set");
-  }
-  /** @returns {void} */
-  $destroy() {
-    Le(this, 1), this.$destroy = X;
+    k(this, P, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    k(this, pe, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    k(this, Ve, !0);
+    k(this, je, () => {
+      var n = (
+        /** @type {Batch} */
+        w
+      );
+      if (h(this, j).has(n)) {
+        var t = (
+          /** @type {Key} */
+          h(this, j).get(n)
+        ), r = h(this, Z).get(t);
+        if (r)
+          Nn(r), h(this, pe).delete(t);
+        else {
+          var i = h(this, P).get(t);
+          i && (h(this, Z).set(t, i.effect), h(this, P).delete(t), i.fragment.lastChild.remove(), this.anchor.before(i.fragment), r = i.effect);
+        }
+        for (const [l, u] of h(this, j)) {
+          if (h(this, j).delete(l), l === n)
+            break;
+          const f = h(this, P).get(u);
+          f && (re(f.effect), h(this, P).delete(u));
+        }
+        for (const [l, u] of h(this, Z)) {
+          if (l === t || h(this, pe).has(l)) continue;
+          const f = () => {
+            if (Array.from(h(this, j).values()).includes(l)) {
+              var s = document.createDocumentFragment();
+              Br(u, s), s.append(Se()), h(this, P).set(l, { effect: u, fragment: s });
+            } else
+              re(u);
+            h(this, pe).delete(l), h(this, Z).delete(l);
+          };
+          h(this, Ve) || !r ? (h(this, pe).add(l), Mn(u, f, !1)) : f();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    k(this, ln, (n) => {
+      h(this, j).delete(n);
+      const t = Array.from(h(this, j).values());
+      for (const [r, i] of h(this, P))
+        t.includes(r) || (re(i.effect), h(this, P).delete(r));
+    });
+    this.anchor = n, ne(this, Ve, t);
   }
   /**
-   * @template {Extract<keyof Events, string>} K
-   * @param {K} type
-   * @param {((e: Events[K]) => void) | null | undefined} callback
-   * @returns {() => void}
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
    */
-  $on(t, n) {
-    if (!le(n))
-      return X;
-    const r = this.$$.callbacks[t] || (this.$$.callbacks[t] = []);
-    return r.push(n), () => {
-      const o = r.indexOf(n);
-      o !== -1 && r.splice(o, 1);
-    };
+  ensure(n, t) {
+    var r = (
+      /** @type {Batch} */
+      w
+    ), i = ot();
+    if (t && !h(this, Z).has(n) && !h(this, P).has(n))
+      if (i) {
+        var l = document.createDocumentFragment(), u = Se();
+        l.append(u), h(this, P).set(n, {
+          effect: Ue(() => t(u)),
+          fragment: l
+        });
+      } else
+        h(this, Z).set(
+          n,
+          Ue(() => t(this.anchor))
+        );
+    if (h(this, j).set(r, n), i) {
+      for (const [f, o] of h(this, Z))
+        f === n ? r.skipped_effects.delete(o) : r.skipped_effects.add(o);
+      for (const [f, o] of h(this, P))
+        f === n ? r.skipped_effects.delete(o.effect) : r.skipped_effects.add(o.effect);
+      r.oncommit(h(this, je)), r.ondiscard(h(this, ln));
+    } else
+      h(this, je).call(this);
   }
-  /**
-   * @param {Partial<Props>} props
-   * @returns {void}
-   */
-  $set(t) {
-    this.$$set && !Ee(t) && (this.$$.skip_bound = !0, this.$$set(t), this.$$.skip_bound = !1);
-  }
-}
-const Xe = "4";
-typeof window < "u" && (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(Xe);
-const me = Symbol("SHIMMER_CONFIG");
-function he() {
-  return be(me) || we;
-}
-function et(e = {}) {
-  const t = he(), n = {
-    shimmerColor: e.shimmerColor ?? t.shimmerColor,
-    backgroundColor: e.backgroundColor ?? t.backgroundColor,
-    duration: e.duration ?? t.duration,
-    fallbackBorderRadius: e.fallbackBorderRadius ?? t.fallbackBorderRadius
-  };
-  pe(me, n);
 }
-function Ke(e) {
-  xe(e, "svelte-17yl4xt", ".shimmer-measure-container.svelte-17yl4xt *{color:transparent !important}.shimmer-measure-container.svelte-17yl4xt img,.shimmer-measure-container.svelte-17yl4xt svg,.shimmer-measure-container.svelte-17yl4xt video{opacity:0}@keyframes svelte-17yl4xt-shimmer-animation{0%{transform:translateX(-100%)}100%{transform:translateX(100%)}}");
-}
-function ne(e, t, n) {
-  const r = e.slice();
-  return r[19] = t[n], r[21] = n, r;
-}
-const Ue = (e) => ({
-  shimmerTemplateProps: e & /*templateProps*/
-  2
-}), re = (e) => ({
-  shimmerTemplateProps: (
-    /*templateProps*/
-    e[1]
-  )
-});
-function Ve(e) {
-  let t, n, r, o, l, i, a = [], c = /* @__PURE__ */ new Map(), u;
-  const y = [ze, qe], m = [];
-  function p(s, h) {
-    return (
-      /*templateProps*/
-      s[1] ? 0 : 1
-    );
+j = new WeakMap(), Z = new WeakMap(), P = new WeakMap(), pe = new WeakMap(), Ve = new WeakMap(), je = new WeakMap(), ln = new WeakMap();
+function Yn(e, n, ...t) {
+  var r = new Tt(e);
+  Dn(() => {
+    const i = n() ?? null;
+    r.ensure(i, i && ((l) => i(l, ...t)));
+  }, Ne);
+}
+function Yr(e, n, t = !1) {
+  var r = new Tt(e), i = t ? Ne : 0;
+  function l(u, f) {
+    r.ensure(u, f);
   }
-  r = p(e), o = m[r] = y[r](e);
-  let b = te(
-    /*elements*/
-    e[3]
-  );
-  const k = (s) => (
-    /*index*/
-    s[21]
-  );
-  for (let s = 0; s < b.length; s += 1) {
-    let h = ne(e, b, s), _ = k(h);
-    c.set(_, a[s] = oe(_, h));
+  Dn(() => {
+    var u = !1;
+    n((f, o = !0) => {
+      u = !0, l(o, f);
+    }), u || l(!1, null);
+  }, i);
+}
+function zr(e, n) {
+  return n;
+}
+function Vr(e, n, t) {
+  for (var r = [], i = n.length, l, u = n.length, f = 0; f < i; f++) {
+    let v = n[f];
+    Mn(
+      v,
+      () => {
+        if (l) {
+          if (l.pending.delete(v), l.done.add(v), l.pending.size === 0) {
+            var d = (
+              /** @type {Set<EachOutroGroup>} */
+              e.outrogroups
+            );
+            bn(xn(l.done)), d.delete(l), d.size === 0 && (e.outrogroups = null);
+          }
+        } else
+          u -= 1;
+      },
+      !1
+    );
   }
-  return {
-    c() {
-      t = P("div"), n = P("div"), o.c(), l = fe(), i = P("div");
-      for (let s = 0; s < a.length; s += 1)
-        a[s].c();
-      $(n, "class", "shimmer-measure-container svelte-17yl4xt"), f(n, "pointer-events", "none"), $(n, "aria-hidden", "true"), f(i, "position", "absolute"), f(i, "top", "0"), f(i, "left", "0"), f(i, "right", "0"), f(i, "bottom", "0"), f(i, "overflow", "hidden"), f(i, "pointer-events", "none"), f(t, "position", "relative");
-    },
-    m(s, h) {
-      Q(s, t, h), N(t, n), m[r].m(n, null), e[15](n), N(t, l), N(t, i);
-      for (let _ = 0; _ < a.length; _ += 1)
-        a[_] && a[_].m(i, null);
-      u = !0;
-    },
-    p(s, h) {
-      let _ = r;
-      r = p(s), r === _ ? m[r].p(s, h) : (ae(), B(m[_], 1, 1, () => {
-        m[_] = null;
-      }), de(), o = m[r], o ? o.p(s, h) : (o = m[r] = y[r](s), o.c()), R(o, 1), o.m(n, null)), h & /*elements, resolvedBackgroundColor, resolvedFallbackBorderRadius, resolvedShimmerColor, resolvedDuration*/
-      248 && (b = te(
-        /*elements*/
-        s[3]
-      ), a = je(a, h, k, 1, s, b, c, i, Ae, oe, null, ne));
-    },
-    i(s) {
-      u || (R(o), u = !0);
-    },
-    o(s) {
-      B(o), u = !1;
-    },
-    d(s) {
-      s && T(t), m[r].d(), e[15](null);
-      for (let h = 0; h < a.length; h += 1)
-        a[h].d();
+  if (u === 0) {
+    var o = r.length === 0 && t !== null;
+    if (o) {
+      var s = (
+        /** @type {Element} */
+        t
+      ), a = (
+        /** @type {Element} */
+        s.parentNode
+      );
+      Sr(a), a.append(s), e.items.clear();
     }
-  };
+    bn(n, !o);
+  } else
+    l = {
+      pending: new Set(n),
+      done: /* @__PURE__ */ new Set()
+    }, (e.outrogroups ?? (e.outrogroups = /* @__PURE__ */ new Set())).add(l);
 }
-function Ye(e) {
-  let t;
-  const n = (
-    /*#slots*/
-    e[14].default
-  ), r = Y(
-    n,
-    e,
-    /*$$scope*/
-    e[13],
-    null
-  );
-  return {
-    c() {
-      r && r.c();
-    },
-    m(o, l) {
-      r && r.m(o, l), t = !0;
-    },
-    p(o, l) {
-      r && r.p && (!t || l & /*$$scope*/
-      8192) && z(
-        r,
+function bn(e, n = !0) {
+  for (var t = 0; t < e.length; t++)
+    re(e[t], n);
+}
+var zn;
+function jr(e, n, t, r, i, l = null) {
+  var u = e, f = /* @__PURE__ */ new Map();
+  {
+    var o = (
+      /** @type {Element} */
+      e
+    );
+    u = o.appendChild(Se());
+  }
+  var s = null, a = /* @__PURE__ */ wr(() => {
+    var y = t();
+    return Gn(y) ? y : y == null ? [] : xn(y);
+  }), v, d = !0;
+  function _() {
+    m.fallback = s, Kr(m, v, u, n, r), s !== null && (v.length === 0 ? s.f & fe ? (s.f ^= fe, Be(s, null, u)) : Nn(s) : Mn(s, () => {
+      s = null;
+    }));
+  }
+  var c = Dn(() => {
+    v = /** @type {V[]} */
+    g(a);
+    for (var y = v.length, D = /* @__PURE__ */ new Set(), b = (
+      /** @type {Batch} */
+      w
+    ), G = ot(), q = 0; q < y; q += 1) {
+      var X = v[q], T = r(X, q), x = d ? null : f.get(T);
+      x ? (x.v && Le(x.v, X), x.i && Le(x.i, q), G && b.skipped_effects.delete(x.e)) : (x = Gr(
+        f,
+        d ? u : zn ?? (zn = Se()),
+        X,
+        T,
+        q,
+        i,
         n,
-        o,
-        /*$$scope*/
-        o[13],
-        t ? q(
-          n,
-          /*$$scope*/
-          o[13],
-          l,
-          null
-        ) : J(
-          /*$$scope*/
-          o[13]
-        ),
-        null
-      );
-    },
-    i(o) {
-      t || (R(r, o), t = !0);
-    },
-    o(o) {
-      B(r, o), t = !1;
-    },
-    d(o) {
-      r && r.d(o);
+        t
+      ), d || (x.e.f |= fe), f.set(T, x)), D.add(T);
     }
-  };
+    if (y === 0 && l && !s && (d ? s = Ue(() => l(u)) : (s = Ue(() => l(zn ?? (zn = Se()))), s.f |= fe)), !d)
+      if (G) {
+        for (const [I, L] of f)
+          D.has(I) || b.skipped_effects.add(L.e);
+        b.oncommit(_), b.ondiscard(() => {
+        });
+      } else
+        _();
+    g(a);
+  }), m = { effect: c, items: f, outrogroups: null, fallback: s };
+  d = !1;
 }
-function qe(e) {
-  let t;
-  const n = (
-    /*#slots*/
-    e[14].default
-  ), r = Y(
-    n,
-    e,
-    /*$$scope*/
-    e[13],
-    null
-  );
-  return {
-    c() {
-      r && r.c();
-    },
-    m(o, l) {
-      r && r.m(o, l), t = !0;
-    },
-    p(o, l) {
-      r && r.p && (!t || l & /*$$scope*/
-      8192) && z(
-        r,
-        n,
-        o,
-        /*$$scope*/
-        o[13],
-        t ? q(
-          n,
-          /*$$scope*/
-          o[13],
-          l,
-          null
-        ) : J(
-          /*$$scope*/
-          o[13]
-        ),
-        null
-      );
-    },
-    i(o) {
-      t || (R(r, o), t = !0);
-    },
-    o(o) {
-      B(r, o), t = !1;
-    },
-    d(o) {
-      r && r.d(o);
+function Pe(e) {
+  for (; e !== null && !(e.f & $); )
+    e = e.next;
+  return e;
+}
+function Kr(e, n, t, r, i) {
+  var I;
+  var l = n.length, u = e.items, f = Pe(e.effect.first), o, s = null, a = [], v = [], d, _, c, m;
+  for (m = 0; m < l; m += 1) {
+    if (d = n[m], _ = i(d, m), c = /** @type {EachItem} */
+    u.get(_).e, e.outrogroups !== null)
+      for (const L of e.outrogroups)
+        L.pending.delete(c), L.done.delete(c);
+    if (c.f & fe)
+      if (c.f ^= fe, c === f)
+        Be(c, null, t);
+      else {
+        var y = s ? s.next : f;
+        c === e.effect.last && (e.effect.last = c.prev), c.prev && (c.prev.next = c.next), c.next && (c.next.prev = c.prev), le(e, s, c), le(e, c, y), Be(c, y, t), s = c, a = [], v = [], f = Pe(s.next);
+        continue;
+      }
+    if (c.f & B && Nn(c), c !== f) {
+      if (o !== void 0 && o.has(c)) {
+        if (a.length < v.length) {
+          var D = v[0], b;
+          s = D.prev;
+          var G = a[0], q = a[a.length - 1];
+          for (b = 0; b < a.length; b += 1)
+            Be(a[b], D, t);
+          for (b = 0; b < v.length; b += 1)
+            o.delete(v[b]);
+          le(e, G.prev, q.next), le(e, s, G), le(e, q, D), f = D, s = q, m -= 1, a = [], v = [];
+        } else
+          o.delete(c), Be(c, f, t), le(e, c.prev, c.next), le(e, c, s === null ? e.effect.first : s.next), le(e, s, c), s = c;
+        continue;
+      }
+      for (a = [], v = []; f !== null && f !== c; )
+        (o ?? (o = /* @__PURE__ */ new Set())).add(f), v.push(f), f = Pe(f.next);
+      if (f === null)
+        continue;
     }
-  };
+    c.f & fe || a.push(c), s = c, f = Pe(c.next);
+  }
+  if (e.outrogroups !== null) {
+    for (const L of e.outrogroups)
+      L.pending.size === 0 && (bn(xn(L.done)), (I = e.outrogroups) == null || I.delete(L));
+    e.outrogroups.size === 0 && (e.outrogroups = null);
+  }
+  if (f !== null || o !== void 0) {
+    var X = [];
+    if (o !== void 0)
+      for (c of o)
+        c.f & B || X.push(c);
+    for (; f !== null; )
+      !(f.f & B) && f !== e.fallback && X.push(f), f = Pe(f.next);
+    var T = X.length;
+    if (T > 0) {
+      var x = l === 0 ? t : null;
+      Vr(e, X, x);
+    }
+  }
 }
-function ze(e) {
-  let t;
-  const n = (
-    /*#slots*/
-    e[14].default
-  ), r = Y(
-    n,
-    e,
-    /*$$scope*/
-    e[13],
-    re
-  );
+function Gr(e, n, t, r, i, l, u, f) {
+  var o = u & Yt ? u & Vt ? qe(t) : /* @__PURE__ */ yr(t, !1, !1) : null, s = u & zt ? qe(i) : null;
   return {
-    c() {
-      r && r.c();
-    },
-    m(o, l) {
-      r && r.m(o, l), t = !0;
-    },
-    p(o, l) {
-      r && r.p && (!t || l & /*$$scope, templateProps*/
-      8194) && z(
-        r,
-        n,
-        o,
-        /*$$scope*/
-        o[13],
-        t ? q(
-          n,
-          /*$$scope*/
-          o[13],
-          l,
-          Ue
-        ) : J(
-          /*$$scope*/
-          o[13]
-        ),
-        re
-      );
-    },
-    i(o) {
-      t || (R(r, o), t = !0);
-    },
-    o(o) {
-      B(r, o), t = !1;
-    },
-    d(o) {
-      r && r.d(o);
-    }
+    v: o,
+    i: s,
+    e: Ue(() => (l(n, o ?? t, s ?? i, f), () => {
+      e.delete(r);
+    }))
   };
 }
-function oe(e, t) {
-  let n, r, o;
-  return {
-    key: e,
-    first: null,
-    c() {
-      n = P("div"), r = P("div"), o = fe(), f(r, "position", "absolute"), f(r, "top", "0"), f(r, "left", "0"), f(r, "width", "100%"), f(r, "height", "100%"), f(r, "background", "linear-gradient(90deg, transparent, " + /*resolvedShimmerColor*/
-      t[7] + ", transparent)"), f(r, "animation", "shimmer-animation " + /*resolvedDuration*/
-      t[5] + "s infinite"), f(n, "position", "absolute"), f(
-        n,
-        "left",
-        /*element*/
-        t[19].x + "px"
-      ), f(
-        n,
-        "top",
-        /*element*/
-        t[19].y + "px"
-      ), f(
-        n,
-        "width",
-        /*element*/
-        t[19].width + "px"
-      ), f(
-        n,
-        "height",
-        /*element*/
-        t[19].height + "px"
-      ), f(
-        n,
-        "background-color",
-        /*resolvedBackgroundColor*/
-        t[6]
-      ), f(
-        n,
-        "border-radius",
-        /*element*/
-        t[19].borderRadius === "0px" ? (
-          /*resolvedFallbackBorderRadius*/
-          t[4] + "px"
-        ) : (
-          /*element*/
-          t[19].borderRadius
-        )
-      ), f(n, "overflow", "hidden"), this.first = n;
-    },
-    m(l, i) {
-      Q(l, n, i), N(n, r), N(n, o);
-    },
-    p(l, i) {
-      t = l, i & /*resolvedShimmerColor*/
-      128 && f(r, "background", "linear-gradient(90deg, transparent, " + /*resolvedShimmerColor*/
-      t[7] + ", transparent)"), i & /*resolvedDuration*/
-      32 && f(r, "animation", "shimmer-animation " + /*resolvedDuration*/
-      t[5] + "s infinite"), i & /*elements*/
-      8 && f(
-        n,
-        "left",
-        /*element*/
-        t[19].x + "px"
-      ), i & /*elements*/
-      8 && f(
-        n,
-        "top",
-        /*element*/
-        t[19].y + "px"
-      ), i & /*elements*/
-      8 && f(
-        n,
-        "width",
-        /*element*/
-        t[19].width + "px"
-      ), i & /*elements*/
-      8 && f(
-        n,
-        "height",
-        /*element*/
-        t[19].height + "px"
-      ), i & /*resolvedBackgroundColor*/
-      64 && f(
-        n,
-        "background-color",
-        /*resolvedBackgroundColor*/
-        t[6]
-      ), i & /*elements, resolvedFallbackBorderRadius*/
-      24 && f(
-        n,
-        "border-radius",
-        /*element*/
-        t[19].borderRadius === "0px" ? (
-          /*resolvedFallbackBorderRadius*/
-          t[4] + "px"
-        ) : (
-          /*element*/
-          t[19].borderRadius
-        )
+function Be(e, n, t) {
+  if (e.nodes)
+    for (var r = e.nodes.start, i = e.nodes.end, l = n && !(n.f & fe) ? (
+      /** @type {EffectNodes} */
+      n.nodes.start
+    ) : t; r !== null; ) {
+      var u = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Ke(r)
       );
-    },
-    d(l) {
-      l && T(n);
+      if (l.before(r), r === i)
+        return;
+      r = u;
     }
-  };
 }
-function Je(e) {
-  let t, n, r, o;
-  const l = [Ye, Ve], i = [];
-  function a(c, u) {
-    return (
-      /*loading*/
-      c[0] ? 1 : 0
+function le(e, n, t) {
+  n === null ? e.effect.first = t : n.next = t, t === null ? e.effect.last = n : t.prev = n;
+}
+function Xr(e, n) {
+  dt(() => {
+    var t = e.getRootNode(), r = (
+      /** @type {ShadowRoot} */
+      t.host ? (
+        /** @type {ShadowRoot} */
+        t
+      ) : (
+        /** @type {Document} */
+        t.head ?? /** @type {Document} */
+        t.ownerDocument.head
+      )
     );
-  }
-  return t = a(e), n = i[t] = l[t](e), {
-    c() {
-      n.c(), r = Me();
-    },
-    m(c, u) {
-      i[t].m(c, u), Q(c, r, u), o = !0;
-    },
-    p(c, [u]) {
-      let y = t;
-      t = a(c), t === y ? i[t].p(c, u) : (ae(), B(i[y], 1, 1, () => {
-        i[y] = null;
-      }), de(), n = i[t], n ? n.p(c, u) : (n = i[t] = l[t](c), n.c()), R(n, 1), n.m(r.parentNode, r));
-    },
-    i(c) {
-      o || (R(n), o = !0);
-    },
-    o(c) {
-      B(n), o = !1;
-    },
-    d(c) {
-      c && T(r), i[t].d(c);
+    if (!r.querySelector("#" + n.hash)) {
+      const i = document.createElement("style");
+      i.id = n.hash, i.textContent = n.code, r.appendChild(i);
     }
+  });
+}
+function Wr(e, n) {
+  return e == null ? null : String(e);
+}
+function Vn(e, n, t, r) {
+  var i = e.__style;
+  if (i !== n) {
+    var l = Wr(n);
+    l == null ? e.removeAttribute("style") : e.style.cssText = l, e.__style = n;
+  }
+  return r;
+}
+function jn(e, n) {
+  return e === n || (e == null ? void 0 : e[Je]) === n;
+}
+function Zr(e = {}, n, t, r) {
+  return dt(() => {
+    var i, l;
+    return Nr(() => {
+      i = l, l = [], Ur(() => {
+        e !== t(...l) && (n(e, ...l), i && jn(t(...i), e) && n(null, ...i));
+      });
+    }), () => {
+      pn(() => {
+        l && jn(t(...l), e) && n(null, ...l);
+      });
+    };
+  }), e;
+}
+function xe(e, n, t, r) {
+  var i = (
+    /** @type {V} */
+    r
+  ), l = !0, u = () => (l && (l = !1, i = /** @type {V} */
+  r), i), f;
+  f = /** @type {V} */
+  e[n], f === void 0 && r !== void 0 && (f = u());
+  var o;
+  return o = () => {
+    var s = (
+      /** @type {V} */
+      e[n]
+    );
+    return s === void 0 ? u() : (l = !0, s);
+  }, o;
+}
+const At = Symbol("SHIMMER_CONFIG");
+function Ft() {
+  return Ot(At) || Lt;
+}
+function ii(e = {}) {
+  const n = Ft(), t = {
+    shimmerColor: e.shimmerColor ?? n.shimmerColor,
+    backgroundColor: e.backgroundColor ?? n.backgroundColor,
+    duration: e.duration ?? n.duration,
+    fallbackBorderRadius: e.fallbackBorderRadius ?? n.fallbackBorderRadius
   };
+  Pt(At, t);
 }
-function Qe(e, t, n) {
-  let r, o, l, i, { $$slots: a = {}, $$scope: c } = t, { loading: u = !0 } = t, { shimmerColor: y = void 0 } = t, { backgroundColor: m = void 0 } = t, { duration: p = void 0 } = t, { fallbackBorderRadius: b = void 0 } = t, { templateProps: k = void 0 } = t, s, h = [];
-  const _ = he();
-  async function E() {
-    if (!u || !s) return;
-    w == null || w.disconnect(), await ke();
-    const d = s, g = d.getBoundingClientRect(), v = [];
-    Array.from(d.children).forEach((C) => {
-      v.push(...ve(C, g));
-    }), n(3, h = v), s && w && w.observe(s, {
+var Jr = /* @__PURE__ */ St('<div class="svelte-euvo5u"><div class="svelte-euvo5u"></div></div>'), Qr = /* @__PURE__ */ St(`<div style="position: relative;" class="svelte-euvo5u"><div class="shimmer-measure-container svelte-euvo5u" style="pointer-events: none;" aria-hidden="true"><!></div> <div style="
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        overflow: hidden;
+        pointer-events: none;
+      " class="svelte-euvo5u"></div></div>`);
+const $r = {
+  hash: "svelte-euvo5u",
+  code: `.shimmer-measure-container.svelte-euvo5u * {color:transparent !important;}.shimmer-measure-container.svelte-euvo5u img,
+  .shimmer-measure-container.svelte-euvo5u svg,
+  .shimmer-measure-container.svelte-euvo5u video {opacity:0;}
+  @keyframes svelte-euvo5u-shimmer-animation {
+    0% {
+      transform: translateX(-100%);
+    }
+    100% {
+      transform: translateX(100%);
+    }
+  }`
+};
+function li(e, n) {
+  ur(n, !0), Xr(e, $r);
+  let t = xe(n, "loading", 3, !0), r = xe(n, "shimmerColor", 3, void 0), i = xe(n, "backgroundColor", 3, void 0), l = xe(n, "duration", 3, void 0), u = xe(n, "fallbackBorderRadius", 3, void 0);
+  xe(n, "templateProps", 3, void 0);
+  let f = /* @__PURE__ */ W(void 0), o = /* @__PURE__ */ W(Re([]));
+  const s = Ft(), a = /* @__PURE__ */ We(() => r() ?? s.shimmerColor), v = /* @__PURE__ */ We(() => i() ?? s.backgroundColor), d = /* @__PURE__ */ We(() => l() ?? s.duration), _ = /* @__PURE__ */ We(() => u() ?? s.fallbackBorderRadius);
+  let c;
+  async function m() {
+    if (!t() || !g(f)) return;
+    c == null || c.disconnect(), await qt();
+    const T = g(f), x = T.getBoundingClientRect(), I = [];
+    Array.from(T.children).forEach((L) => {
+      I.push(...Ut(L, x));
+    }), te(o, I, !0), g(f) && c && c.observe(g(f), {
       childList: !0,
       subtree: !0,
       characterData: !0,
       attributes: !1
     });
   }
-  let w;
-  ye(() => (E(), s && (w = new MutationObserver(() => {
-    u && E();
-  }), w.observe(s, {
+  Dr(() => {
+    t() && g(f) && m();
+  }), Bt(() => (m(), g(f) && (c = new MutationObserver(() => {
+    t() && m();
+  }), c.observe(g(f), {
     childList: !0,
     subtree: !0,
     characterData: !0,
     attributes: !1
+    // Don't observe attribute changes (style updates)
   })), () => {
-    w == null || w.disconnect();
+    c == null || c.disconnect();
   }));
-  function A() {
-    E();
+  function y() {
+    m();
   }
-  function j(d) {
-    K[d ? "unshift" : "push"](() => {
-      s = d, n(2, s);
+  var D = { remeasure: y }, b = Hn(), G = qn(b);
+  {
+    var q = (T) => {
+      var x = Hn(), I = qn(x);
+      Yn(I, () => n.children), Ze(T, x);
+    }, X = (T) => {
+      var x = Qr(), I = dn(x), L = dn(I);
+      Yn(L, () => n.children), Zr(I, (un) => te(f, un), () => g(f));
+      var Dt = Rr(I, 2);
+      jr(Dt, 21, () => g(o), zr, (un, ye) => {
+        var on = Jr(), Mt = dn(on);
+        Ir(() => {
+          Vn(on, `
+            position: absolute;
+            left: ${g(ye).x ?? ""}px;
+            top: ${g(ye).y ?? ""}px;
+            width: ${g(ye).width ?? ""}px;
+            height: ${g(ye).height ?? ""}px;
+            background-color: ${g(v) ?? ""};
+            border-radius: ${(g(ye).borderRadius === "0px" ? g(_) + "px" : g(ye).borderRadius) ?? ""};
+            overflow: hidden;
+          `), Vn(Mt, `
+              position: absolute;
+              top: 0;
+              left: 0;
+              width: 100%;
+              height: 100%;
+              background: linear-gradient(90deg, transparent, ${g(a) ?? ""}, transparent);
+              animation: shimmer-animation ${g(d) ?? ""}s infinite;
+            `);
+        }), Ze(un, on);
+      }), Ze(T, x);
+    };
+    Yr(G, (T) => {
+      t() ? T(X, !1) : T(q);
     });
   }
-  return e.$$set = (d) => {
-    "loading" in d && n(0, u = d.loading), "shimmerColor" in d && n(8, y = d.shimmerColor), "backgroundColor" in d && n(9, m = d.backgroundColor), "duration" in d && n(10, p = d.duration), "fallbackBorderRadius" in d && n(11, b = d.fallbackBorderRadius), "templateProps" in d && n(1, k = d.templateProps), "$$scope" in d && n(13, c = d.$$scope);
-  }, e.$$.update = () => {
-    e.$$.dirty & /*shimmerColor*/
-    256 && n(7, r = y ?? _.shimmerColor), e.$$.dirty & /*backgroundColor*/
-    512 && n(6, o = m ?? _.backgroundColor), e.$$.dirty & /*duration*/
-    1024 && n(5, l = p ?? _.duration), e.$$.dirty & /*fallbackBorderRadius*/
-    2048 && n(4, i = b ?? _.fallbackBorderRadius), e.$$.dirty & /*loading, measureRef*/
-    5 && u && s && E();
-  }, [
-    u,
-    k,
-    s,
-    h,
-    i,
-    l,
-    o,
-    r,
-    y,
-    m,
-    p,
-    b,
-    A,
-    c,
-    a,
-    j
-  ];
-}
-class tt extends He {
-  constructor(t) {
-    super(), Ge(
-      this,
-      t,
-      Qe,
-      Je,
-      Re,
-      {
-        loading: 0,
-        shimmerColor: 8,
-        backgroundColor: 9,
-        duration: 10,
-        fallbackBorderRadius: 11,
-        templateProps: 1,
-        remeasure: 12
-      },
-      Ke
-    );
-  }
-  get remeasure() {
-    return this.$$.ctx[12];
-  }
+  return Ze(e, b), or(D);
 }
 export {
-  tt as Shimmer,
-  he as getShimmerConfig,
-  et as setShimmerConfig,
-  ot as shimmerDefaults
+  li as Shimmer,
+  Ft as getShimmerConfig,
+  ii as setShimmerConfig,
+  ui as shimmerDefaults
 };