@pie-players/pie-section-player-tools-session-debugger 0.1.1

package/dist/section-player-tools-session-debugger.js

@@ -0,0 +1,2709 @@
+var vs = Object.defineProperty;
+var zn = (e) => {
+  throw TypeError(e);
+};
+var _s = (e, t, n) => t in e ? vs(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var T = (e, t, n) => _s(e, typeof t != "symbol" ? t + "" : t, n), tn = (e, t, n) => t.has(e) || zn("Cannot " + n);
+var l = (e, t, n) => (tn(e, t, "read from private field"), n ? n.call(e) : t.get(e)), m = (e, t, n) => t.has(e) ? zn("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), p = (e, t, n, r) => (tn(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), j = (e, t, n) => (tn(e, t, "access private method"), n);
+var Zn;
+typeof window < "u" && ((Zn = window.__svelte ?? (window.__svelte = {})).v ?? (Zn.v = /* @__PURE__ */ new Set())).add("5");
+const ps = 2, bn = "[", $n = "[!", Qn = "]", ot = {}, R = /* @__PURE__ */ Symbol(), er = "http://www.w3.org/1999/xhtml", on = !1;
+var tr = Array.isArray, gs = Array.prototype.indexOf, lt = Array.prototype.includes, ms = Array.from, Ft = Object.keys, Ht = Object.defineProperty, Ge = Object.getOwnPropertyDescriptor, ws = Object.getOwnPropertyDescriptors, bs = Object.prototype, $s = Array.prototype, nr = Object.getPrototypeOf, Vn = Object.isExtensible;
+const ys = () => {
+};
+function Es(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function rr() {
+  var e, t, n = new Promise((r, s) => {
+    e = r, t = s;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const O = 2, zt = 4, Wt = 8, sr = 1 << 24, $e = 16, de = 32, Ne = 64, ln = 128, J = 512, N = 1024, D = 2048, ne = 4096, fe = 8192, we = 16384, ht = 32768, ft = 65536, Yn = 1 << 17, ir = 1 << 18, qe = 1 << 19, xs = 1 << 20, Be = 65536, fn = 1 << 21, yn = 1 << 22, Me = 1 << 23, nn = /* @__PURE__ */ Symbol("$state"), Ss = /* @__PURE__ */ Symbol("legacy props"), Oe = new class extends Error {
+  constructor() {
+    super(...arguments);
+    T(this, "name", "StaleReactionError");
+    T(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), En = 3, qt = 8;
+function or(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function ks() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Is(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Ts() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function Ms(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function As() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Cs() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function Ns() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Rs() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Os() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Ds() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function Ut(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function Ps() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let k = !1;
+function Je(e) {
+  k = e;
+}
+let S;
+function ue(e) {
+  if (e === null)
+    throw Ut(), ot;
+  return S = e;
+}
+function xn() {
+  return ue(/* @__PURE__ */ Re(S));
+}
+function xe(e) {
+  if (k) {
+    if (/* @__PURE__ */ Re(S) !== null)
+      throw Ut(), ot;
+    S = e;
+  }
+}
+function Ls(e = 1) {
+  if (k) {
+    for (var t = e, n = S; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ Re(n);
+    S = n;
+  }
+}
+function lr(e = !0) {
+  for (var t = 0, n = S; ; ) {
+    if (n.nodeType === qt) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === Qn) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (r === bn || r === $n || // "[1", "[2", etc. for if blocks
+      r[0] === "[" && !isNaN(Number(r.slice(1)))) && (t += 1);
+    }
+    var s = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Re(n)
+    );
+    e && n.remove(), n = s;
+  }
+}
+function js(e) {
+  if (!e || e.nodeType !== qt)
+    throw Ut(), ot;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function fr(e) {
+  return e === this.v;
+}
+function Fs(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function Hs(e) {
+  return !Fs(e, this.v);
+}
+let zs = !1, V = null;
+function ut(e) {
+  V = e;
+}
+function ur(e, t = !1, n) {
+  V = {
+    p: V,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function ar(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    V
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var r of n)
+      Rr(r);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, V = t.p, e ?? /** @type {T} */
+  {};
+}
+function cr() {
+  return !0;
+}
+let De = [];
+function dr() {
+  var e = De;
+  De = [], Es(e);
+}
+function Ze(e) {
+  if (De.length === 0 && !pt) {
+    var t = De;
+    queueMicrotask(() => {
+      t === De && dr();
+    });
+  }
+  De.push(e);
+}
+function Vs() {
+  for (; De.length > 0; )
+    dr();
+}
+function hr(e) {
+  var t = $;
+  if (t === null)
+    return b.f |= Me, e;
+  if ((t.f & ht) === 0 && (t.f & zt) === 0)
+    throw e;
+  at(e, t);
+}
+function at(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & ln) !== 0) {
+      if ((t.f & ht) === 0)
+        throw e;
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    }
+    t = t.parent;
+  }
+  throw e;
+}
+const Ys = -7169;
+function M(e, t) {
+  e.f = e.f & Ys | t;
+}
+function Sn(e) {
+  (e.f & J) !== 0 || e.deps === null ? M(e, N) : M(e, ne);
+}
+function vr(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & O) === 0 || (t.f & Be) === 0 || (t.f ^= Be, vr(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function _r(e, t, n) {
+  (e.f & D) !== 0 ? t.add(e) : (e.f & ne) !== 0 && n.add(e), vr(e.deps), M(e, N);
+}
+const Ct = /* @__PURE__ */ new Set();
+let x = null, Q = null, F = [], Xt = null, un = !1, pt = !1;
+var Qe, et, je, tt, $t, yt, Fe, ve, nt, ce, an, cn, pr;
+const An = class An {
+  constructor() {
+    m(this, ce);
+    T(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>}
+     */
+    T(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any sources that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Source, any>}
+     */
+    T(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>}
+     */
+    m(this, Qe, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    m(this, et, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    m(this, je, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    m(this, tt, 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}
+     */
+    m(this, $t, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    m(this, yt, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    m(this, Fe, /* @__PURE__ */ new Set());
+    /**
+     * A map of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`.
+     * The value contains child effects that were dirty/maybe_dirty before being reset,
+     * so they can be rescheduled if the branch survives.
+     * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
+     */
+    m(this, ve, /* @__PURE__ */ new Map());
+    T(this, "is_fork", !1);
+    m(this, nt, !1);
+  }
+  is_deferred() {
+    return this.is_fork || l(this, tt) > 0;
+  }
+  /**
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
+   */
+  skip_effect(t) {
+    l(this, ve).has(t) || l(this, ve).set(t, { d: [], m: [] });
+  }
+  /**
+   * Remove an effect from the #skipped_branches map and reschedule
+   * any tracked dirty/maybe_dirty child effects
+   * @param {Effect} effect
+   */
+  unskip_effect(t) {
+    var n = l(this, ve).get(t);
+    if (n) {
+      l(this, ve).delete(t);
+      for (var r of n.d)
+        M(r, D), ee(r);
+      for (r of n.m)
+        M(r, ne), ee(r);
+    }
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    F = [], this.apply();
+    var n = [], r = [];
+    for (const s of t)
+      j(this, ce, an).call(this, s, n, r);
+    if (this.is_deferred()) {
+      j(this, ce, cn).call(this, r), j(this, ce, cn).call(this, n);
+      for (const [s, i] of l(this, ve))
+        br(s, i);
+    } else {
+      for (const s of l(this, Qe)) s();
+      l(this, Qe).clear(), l(this, je) === 0 && j(this, ce, pr).call(this), x = null, Bn(r), Bn(n), l(this, $t)?.resolve();
+    }
+    Q = 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(t, n) {
+    n !== R && !this.previous.has(t) && this.previous.set(t, n), (t.f & Me) === 0 && (this.current.set(t, t.v), Q?.set(t, t.v));
+  }
+  activate() {
+    x = this, this.apply();
+  }
+  deactivate() {
+    x === this && (x = null, Q = null);
+  }
+  flush() {
+    if (this.activate(), F.length > 0) {
+      if (gr(), x !== null && x !== this)
+        return;
+    } else l(this, je) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of l(this, et)) t(this);
+    l(this, et).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    p(this, je, l(this, je) + 1), t && p(this, tt, l(this, tt) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    p(this, je, l(this, je) - 1), t && p(this, tt, l(this, tt) - 1), !l(this, nt) && (p(this, nt, !0), Ze(() => {
+      p(this, nt, !1), this.is_deferred() ? F.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of l(this, yt))
+      l(this, Fe).delete(t), M(t, D), ee(t);
+    for (const t of l(this, Fe))
+      M(t, ne), ee(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    l(this, Qe).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    l(this, et).add(t);
+  }
+  settled() {
+    return (l(this, $t) ?? p(this, $t, rr())).promise;
+  }
+  static ensure() {
+    if (x === null) {
+      const t = x = new An();
+      Ct.add(x), pt || Ze(() => {
+        x === t && t.flush();
+      });
+    }
+    return x;
+  }
+  apply() {
+  }
+};
+Qe = new WeakMap(), et = new WeakMap(), je = new WeakMap(), tt = new WeakMap(), $t = new WeakMap(), yt = new WeakMap(), Fe = new WeakMap(), ve = new WeakMap(), nt = new WeakMap(), ce = 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
+ */
+an = function(t, n, r) {
+  t.f ^= N;
+  for (var s = t.first, i = null; s !== null; ) {
+    var o = s.f, f = (o & (de | Ne)) !== 0, u = f && (o & N) !== 0, a = u || (o & fe) !== 0 || l(this, ve).has(s);
+    if (!a && s.fn !== null) {
+      f ? s.f ^= N : i !== null && (o & (zt | Wt | sr)) !== 0 ? i.b.defer_effect(s) : (o & zt) !== 0 ? n.push(s) : It(s) && ((o & $e) !== 0 && l(this, Fe).add(s), dt(s));
+      var c = s.first;
+      if (c !== null) {
+        s = c;
+        continue;
+      }
+    }
+    for (; s !== null; ) {
+      s === i && (i = null);
+      var h = s.next;
+      if (h !== null) {
+        s = h;
+        break;
+      }
+      s = s.parent;
+    }
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+cn = function(t) {
+  for (var n = 0; n < t.length; n += 1)
+    _r(t[n], l(this, yt), l(this, Fe));
+}, pr = function() {
+  var s;
+  if (Ct.size > 1) {
+    this.previous.clear();
+    var t = Q, n = !0;
+    for (const i of Ct) {
+      if (i === this) {
+        n = !1;
+        continue;
+      }
+      const o = [];
+      for (const [u, a] of this.current) {
+        if (i.current.has(u))
+          if (n && a !== i.current.get(u))
+            i.current.set(u, a);
+          else
+            continue;
+        o.push(u);
+      }
+      if (o.length === 0)
+        continue;
+      const f = [...i.current.keys()].filter((u) => !this.current.has(u));
+      if (f.length > 0) {
+        var r = F;
+        F = [];
+        const u = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map();
+        for (const c of o)
+          mr(c, f, u, a);
+        if (F.length > 0) {
+          x = i, i.apply();
+          for (const c of F)
+            j(s = i, ce, an).call(s, c, [], []);
+          i.deactivate();
+        }
+        F = r;
+      }
+    }
+    x = null, Q = t;
+  }
+  this.committed = !0, Ct.delete(this);
+};
+let be = An;
+function Dt(e) {
+  var t = pt;
+  pt = !0;
+  try {
+    for (var n; ; ) {
+      if (Vs(), F.length === 0 && (x?.flush(), F.length === 0))
+        return Xt = null, /** @type {T} */
+        n;
+      gr();
+    }
+  } finally {
+    pt = t;
+  }
+}
+function gr() {
+  un = !0;
+  var e = null;
+  try {
+    for (var t = 0; F.length > 0; ) {
+      var n = be.ensure();
+      if (t++ > 1e3) {
+        var r, s;
+        Bs();
+      }
+      n.process(F), Ae.clear();
+    }
+  } finally {
+    F = [], un = !1, Xt = null;
+  }
+}
+function Bs() {
+  try {
+    As();
+  } catch (e) {
+    at(e, Xt);
+  }
+}
+let he = null;
+function Bn(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var r = e[n++];
+      if ((r.f & (we | fe)) === 0 && It(r) && (he = /* @__PURE__ */ new Set(), dt(r), r.deps === null && r.first === null && r.nodes === null && r.teardown === null && r.ac === null && Lr(r), he?.size > 0)) {
+        Ae.clear();
+        for (const s of he) {
+          if ((s.f & (we | fe)) !== 0) continue;
+          const i = [s];
+          let o = s.parent;
+          for (; o !== null; )
+            he.has(o) && (he.delete(o), i.push(o)), o = o.parent;
+          for (let f = i.length - 1; f >= 0; f--) {
+            const u = i[f];
+            (u.f & (we | fe)) === 0 && dt(u);
+          }
+        }
+        he.clear();
+      }
+    }
+    he = null;
+  }
+}
+function mr(e, t, n, r) {
+  if (!n.has(e) && (n.add(e), e.reactions !== null))
+    for (const s of e.reactions) {
+      const i = s.f;
+      (i & O) !== 0 ? mr(
+        /** @type {Derived} */
+        s,
+        t,
+        n,
+        r
+      ) : (i & (yn | $e)) !== 0 && (i & D) === 0 && wr(s, t, r) && (M(s, D), ee(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function wr(e, t, n) {
+  const r = n.get(e);
+  if (r !== void 0) return r;
+  if (e.deps !== null)
+    for (const s of e.deps) {
+      if (lt.call(t, s))
+        return !0;
+      if ((s.f & O) !== 0 && wr(
+        /** @type {Derived} */
+        s,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          s,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function ee(e) {
+  for (var t = Xt = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (un && t === $ && (n & $e) !== 0 && (n & ir) === 0)
+      return;
+    if ((n & (Ne | de)) !== 0) {
+      if ((n & N) === 0) return;
+      t.f ^= N;
+    }
+  }
+  F.push(t);
+}
+function br(e, t) {
+  if (!((e.f & de) !== 0 && (e.f & N) !== 0)) {
+    (e.f & D) !== 0 ? t.d.push(e) : (e.f & ne) !== 0 && t.m.push(e), M(e, N);
+    for (var n = e.first; n !== null; )
+      br(n, t), n = n.next;
+  }
+}
+function Ws(e) {
+  let t = 0, n = kt(0), r;
+  return () => {
+    Tn() && (w(n), Or(() => (t === 0 && (r = Xr(() => e(() => gt(n)))), t += 1, () => {
+      Ze(() => {
+        t -= 1, t === 0 && (r?.(), r = void 0, gt(n));
+      });
+    })));
+  };
+}
+var qs = ft | qe;
+function Us(e, t, n) {
+  new Xs(e, t, n);
+}
+var U, Et, _e, He, se, ie, B, oe, pe, ze, Te, rt, st, it, ge, Yt, L, $r, yr, dn, Pt, hn;
+class Xs {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, r) {
+    m(this, L);
+    /** @type {Boundary | null} */
+    T(this, "parent");
+    T(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    m(this, U);
+    /** @type {TemplateNode | null} */
+    m(this, Et, k ? S : null);
+    /** @type {BoundaryProps} */
+    m(this, _e);
+    /** @type {((anchor: Node) => void)} */
+    m(this, He);
+    /** @type {Effect} */
+    m(this, se);
+    /** @type {Effect | null} */
+    m(this, ie, null);
+    /** @type {Effect | null} */
+    m(this, B, null);
+    /** @type {Effect | null} */
+    m(this, oe, null);
+    /** @type {DocumentFragment | null} */
+    m(this, pe, null);
+    m(this, ze, 0);
+    m(this, Te, 0);
+    m(this, rt, !1);
+    /** @type {Set<Effect>} */
+    m(this, st, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    m(this, it, /* @__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}
+     */
+    m(this, ge, null);
+    m(this, Yt, Ws(() => (p(this, ge, kt(l(this, ze))), () => {
+      p(this, ge, null);
+    })));
+    p(this, U, t), p(this, _e, n), p(this, He, (s) => {
+      var i = (
+        /** @type {Effect} */
+        $
+      );
+      i.b = this, i.f |= ln, r(s);
+    }), this.parent = /** @type {Effect} */
+    $.b, p(this, se, Dr(() => {
+      if (k) {
+        const s = (
+          /** @type {Comment} */
+          l(this, Et)
+        );
+        xn(), s.data === $n ? j(this, L, yr).call(this) : j(this, L, $r).call(this);
+      } else
+        j(this, L, dn).call(this);
+    }, qs)), k && p(this, U, S);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    _r(t, l(this, st), l(this, it));
+  }
+  /**
+   * 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 !!l(this, _e).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
+   */
+  update_pending_count(t) {
+    j(this, L, hn).call(this, t), p(this, ze, l(this, ze) + t), !(!l(this, ge) || l(this, rt)) && (p(this, rt, !0), Ze(() => {
+      p(this, rt, !1), l(this, ge) && Vt(l(this, ge), l(this, ze));
+    }));
+  }
+  get_effect_pending() {
+    return l(this, Yt).call(this), w(
+      /** @type {Source<number>} */
+      l(this, ge)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = l(this, _e).onerror;
+    let r = l(this, _e).failed;
+    if (!n && !r)
+      throw t;
+    l(this, ie) && (z(l(this, ie)), p(this, ie, null)), l(this, B) && (z(l(this, B)), p(this, B, null)), l(this, oe) && (z(l(this, oe)), p(this, oe, null)), k && (ue(
+      /** @type {TemplateNode} */
+      l(this, Et)
+    ), Ls(), ue(lr()));
+    var s = !1, i = !1;
+    const o = () => {
+      if (s) {
+        Ps();
+        return;
+      }
+      s = !0, i && Ds(), l(this, oe) !== null && mt(l(this, oe), () => {
+        p(this, oe, null);
+      }), j(this, L, Pt).call(this, () => {
+        be.ensure(), j(this, L, dn).call(this);
+      });
+    };
+    Ze(() => {
+      try {
+        i = !0, n?.(t, o), i = !1;
+      } catch (f) {
+        at(f, l(this, se) && l(this, se).parent);
+      }
+      r && p(this, oe, j(this, L, Pt).call(this, () => {
+        be.ensure();
+        try {
+          return Ie(() => {
+            var f = (
+              /** @type {Effect} */
+              $
+            );
+            f.b = this, f.f |= ln, r(
+              l(this, U),
+              () => t,
+              () => o
+            );
+          });
+        } catch (f) {
+          return at(
+            f,
+            /** @type {Effect} */
+            l(this, se).parent
+          ), null;
+        }
+      }));
+    });
+  }
+}
+U = new WeakMap(), Et = new WeakMap(), _e = new WeakMap(), He = new WeakMap(), se = new WeakMap(), ie = new WeakMap(), B = new WeakMap(), oe = new WeakMap(), pe = new WeakMap(), ze = new WeakMap(), Te = new WeakMap(), rt = new WeakMap(), st = new WeakMap(), it = new WeakMap(), ge = new WeakMap(), Yt = new WeakMap(), L = new WeakSet(), $r = function() {
+  try {
+    p(this, ie, Ie(() => l(this, He).call(this, l(this, U))));
+  } catch (t) {
+    this.error(t);
+  }
+}, yr = function() {
+  const t = l(this, _e).pending;
+  t && (this.is_pending = !0, p(this, B, Ie(() => t(l(this, U)))), Ze(() => {
+    var n = p(this, pe, document.createDocumentFragment()), r = We();
+    n.append(r), p(this, ie, j(this, L, Pt).call(this, () => (be.ensure(), Ie(() => l(this, He).call(this, r))))), l(this, Te) === 0 && (l(this, U).before(n), p(this, pe, null), mt(
+      /** @type {Effect} */
+      l(this, B),
+      () => {
+        p(this, B, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, dn = function() {
+  try {
+    if (this.is_pending = this.has_pending_snippet(), p(this, Te, 0), p(this, ze, 0), p(this, ie, Ie(() => {
+      l(this, He).call(this, l(this, U));
+    })), l(this, Te) > 0) {
+      var t = p(this, pe, document.createDocumentFragment());
+      Hr(l(this, ie), t);
+      const n = (
+        /** @type {(anchor: Node) => void} */
+        l(this, _e).pending
+      );
+      p(this, B, Ie(() => n(l(this, U))));
+    } else
+      this.is_pending = !1;
+  } catch (n) {
+    this.error(n);
+  }
+}, /**
+ * @template T
+ * @param {() => T} fn
+ */
+Pt = function(t) {
+  var n = $, r = b, s = V;
+  ae(l(this, se)), G(l(this, se)), ut(l(this, se).ctx);
+  try {
+    return t();
+  } catch (i) {
+    return hr(i), null;
+  } finally {
+    ae(n), G(r), ut(s);
+  }
+}, /**
+ * Updates the pending count associated with the currently visible pending snippet,
+ * if any, such that we can replace the snippet with content once work is done
+ * @param {1 | -1} d
+ */
+hn = function(t) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && j(n = this.parent, L, hn).call(n, t);
+    return;
+  }
+  if (p(this, Te, l(this, Te) + t), l(this, Te) === 0) {
+    this.is_pending = !1;
+    for (const r of l(this, st))
+      M(r, D), ee(r);
+    for (const r of l(this, it))
+      M(r, ne), ee(r);
+    l(this, st).clear(), l(this, it).clear(), l(this, B) && mt(l(this, B), () => {
+      p(this, B, null);
+    }), l(this, pe) && (l(this, U).before(l(this, pe)), p(this, pe, null));
+  }
+};
+function Js(e, t, n, r) {
+  const s = kn;
+  var i = e.filter((d) => !d.settled);
+  if (n.length === 0 && i.length === 0) {
+    r(t.map(s));
+    return;
+  }
+  var o = x, f = (
+    /** @type {Effect} */
+    $
+  ), u = Ks(), a = i.length === 1 ? i[0].promise : i.length > 1 ? Promise.all(i.map((d) => d.promise)) : null;
+  function c(d) {
+    u();
+    try {
+      r(d);
+    } catch (g) {
+      (f.f & we) === 0 && at(g, f);
+    }
+    o?.deactivate(), vn();
+  }
+  if (n.length === 0) {
+    a.then(() => c(t.map(s)));
+    return;
+  }
+  function h() {
+    u(), Promise.all(n.map((d) => /* @__PURE__ */ Gs(d))).then((d) => c([...t.map(s), ...d])).catch((d) => at(d, f));
+  }
+  a ? a.then(h) : h();
+}
+function Ks() {
+  var e = $, t = b, n = V, r = x;
+  return function(i = !0) {
+    ae(e), G(t), ut(n), i && r?.activate();
+  };
+}
+function vn() {
+  ae(null), G(null), ut(null);
+}
+// @__NO_SIDE_EFFECTS__
+function kn(e) {
+  var t = O | D, n = b !== null && (b.f & O) !== 0 ? (
+    /** @type {Derived} */
+    b
+  ) : null;
+  return $ !== null && ($.f |= qe), {
+    ctx: V,
+    deps: null,
+    effects: null,
+    equals: fr,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      R
+    ),
+    wv: 0,
+    parent: n ?? $,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Gs(e, t, n) {
+  let r = (
+    /** @type {Effect | null} */
+    $
+  );
+  r === null && ks();
+  var s = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), o = kt(
+    /** @type {V} */
+    R
+  ), f = !b, u = /* @__PURE__ */ new Map();
+  return ci(() => {
+    var a = rr();
+    i = a.promise;
+    try {
+      Promise.resolve(e()).then(a.resolve, a.reject).then(() => {
+        c === x && c.committed && c.deactivate(), vn();
+      });
+    } catch (g) {
+      a.reject(g), vn();
+    }
+    var c = (
+      /** @type {Batch} */
+      x
+    );
+    if (f) {
+      var h = s.is_rendered();
+      s.update_pending_count(1), c.increment(h), u.get(c)?.reject(Oe), u.delete(c), u.set(c, a);
+    }
+    const d = (g, v = void 0) => {
+      if (c.activate(), v)
+        v !== Oe && (o.f |= Me, Vt(o, v));
+      else {
+        (o.f & Me) !== 0 && (o.f ^= Me), Vt(o, g);
+        for (const [C, y] of u) {
+          if (u.delete(C), C === c) break;
+          y.reject(Oe);
+        }
+      }
+      f && (s.update_pending_count(-1), c.decrement(h));
+    };
+    a.promise.then(d, (g) => d(null, g || "unknown"));
+  }), fi(() => {
+    for (const a of u.values())
+      a.reject(Oe);
+  }), new Promise((a) => {
+    function c(h) {
+      function d() {
+        h === i ? a(o) : c(i);
+      }
+      h.then(d, d);
+    }
+    c(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Zs(e) {
+  const t = /* @__PURE__ */ kn(e);
+  return zr(t), t;
+}
+function Qs(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      z(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function ei(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & O) === 0)
+      return (t.f & we) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function In(e) {
+  var t, n = $;
+  ae(ei(e));
+  try {
+    e.f &= ~Be, Qs(e), t = Wr(e);
+  } finally {
+    ae(n);
+  }
+  return t;
+}
+function Er(e) {
+  var t = In(e);
+  if (!e.equals(t) && (e.wv = Yr(), (!x?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    M(e, N);
+    return;
+  }
+  Ce || (Q !== null ? (Tn() || x?.is_fork) && Q.set(e, t) : Sn(e));
+}
+function ti(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      (t.teardown || t.ac) && (t.teardown?.(), t.ac?.abort(Oe), t.teardown = ys, t.ac = null, wt(t, 0), Mn(t));
+}
+function xr(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      t.teardown && dt(t);
+}
+let _n = /* @__PURE__ */ new Set();
+const Ae = /* @__PURE__ */ new Map();
+let Sr = !1;
+function kt(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: fr,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function P(e, t) {
+  const n = kt(e);
+  return zr(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function ni(e, t = !1, n = !0) {
+  const r = kt(e);
+  return t || (r.equals = Hs), r;
+}
+function E(e, t, n = !1) {
+  b !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
+  // to ensure we error if state is set inside an inspect effect
+  (!te || (b.f & Yn) !== 0) && cr() && (b.f & (O | $e | yn | Yn)) !== 0 && (K === null || !lt.call(K, e)) && Os();
+  let r = n ? Ke(t) : t;
+  return Vt(e, r);
+}
+function Vt(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    Ce ? Ae.set(e, t) : Ae.set(e, n), e.v = t;
+    var r = be.ensure();
+    if (r.capture(e, n), (e.f & O) !== 0) {
+      const s = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & D) !== 0 && In(s), Sn(s);
+    }
+    e.wv = Yr(), kr(e, D), $ !== null && ($.f & N) !== 0 && ($.f & (de | Ne)) === 0 && (q === null ? _i([e]) : q.push(e)), !r.is_fork && _n.size > 0 && !Sr && ri();
+  }
+  return t;
+}
+function ri() {
+  Sr = !1;
+  for (const e of _n)
+    (e.f & N) !== 0 && M(e, ne), It(e) && dt(e);
+  _n.clear();
+}
+function gt(e) {
+  E(e, e.v + 1);
+}
+function kr(e, t) {
+  var n = e.reactions;
+  if (n !== null)
+    for (var r = n.length, s = 0; s < r; s++) {
+      var i = n[s], o = i.f, f = (o & D) === 0;
+      if (f && M(i, t), (o & O) !== 0) {
+        var u = (
+          /** @type {Derived} */
+          i
+        );
+        Q?.delete(u), (o & Be) === 0 && (o & J && (i.f |= Be), kr(u, ne));
+      } else f && ((o & $e) !== 0 && he !== null && he.add(
+        /** @type {Effect} */
+        i
+      ), ee(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function Ke(e) {
+  if (typeof e != "object" || e === null || nn in e)
+    return e;
+  const t = nr(e);
+  if (t !== bs && t !== $s)
+    return e;
+  var n = /* @__PURE__ */ new Map(), r = tr(e), s = /* @__PURE__ */ P(0), i = Ye, o = (f) => {
+    if (Ye === i)
+      return f();
+    var u = b, a = Ye;
+    G(null), Un(i);
+    var c = f();
+    return G(u), Un(a), c;
+  };
+  return r && n.set("length", /* @__PURE__ */ P(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(f, u, a) {
+        (!("value" in a) || a.configurable === !1 || a.enumerable === !1 || a.writable === !1) && Ns();
+        var c = n.get(u);
+        return c === void 0 ? o(() => {
+          var h = /* @__PURE__ */ P(a.value);
+          return n.set(u, h), h;
+        }) : E(c, a.value, !0), !0;
+      },
+      deleteProperty(f, u) {
+        var a = n.get(u);
+        if (a === void 0) {
+          if (u in f) {
+            const c = o(() => /* @__PURE__ */ P(R));
+            n.set(u, c), gt(s);
+          }
+        } else
+          E(a, R), gt(s);
+        return !0;
+      },
+      get(f, u, a) {
+        if (u === nn)
+          return e;
+        var c = n.get(u), h = u in f;
+        if (c === void 0 && (!h || Ge(f, u)?.writable) && (c = o(() => {
+          var g = Ke(h ? f[u] : R), v = /* @__PURE__ */ P(g);
+          return v;
+        }), n.set(u, c)), c !== void 0) {
+          var d = w(c);
+          return d === R ? void 0 : d;
+        }
+        return Reflect.get(f, u, a);
+      },
+      getOwnPropertyDescriptor(f, u) {
+        var a = Reflect.getOwnPropertyDescriptor(f, u);
+        if (a && "value" in a) {
+          var c = n.get(u);
+          c && (a.value = w(c));
+        } else if (a === void 0) {
+          var h = n.get(u), d = h?.v;
+          if (h !== void 0 && d !== R)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: d,
+              writable: !0
+            };
+        }
+        return a;
+      },
+      has(f, u) {
+        if (u === nn)
+          return !0;
+        var a = n.get(u), c = a !== void 0 && a.v !== R || Reflect.has(f, u);
+        if (a !== void 0 || $ !== null && (!c || Ge(f, u)?.writable)) {
+          a === void 0 && (a = o(() => {
+            var d = c ? Ke(f[u]) : R, g = /* @__PURE__ */ P(d);
+            return g;
+          }), n.set(u, a));
+          var h = w(a);
+          if (h === R)
+            return !1;
+        }
+        return c;
+      },
+      set(f, u, a, c) {
+        var h = n.get(u), d = u in f;
+        if (r && u === "length")
+          for (var g = a; g < /** @type {Source<number>} */
+          h.v; g += 1) {
+            var v = n.get(g + "");
+            v !== void 0 ? E(v, R) : g in f && (v = o(() => /* @__PURE__ */ P(R)), n.set(g + "", v));
+          }
+        if (h === void 0)
+          (!d || Ge(f, u)?.writable) && (h = o(() => /* @__PURE__ */ P(void 0)), E(h, Ke(a)), n.set(u, h));
+        else {
+          d = h.v !== R;
+          var C = o(() => Ke(a));
+          E(h, C);
+        }
+        var y = Reflect.getOwnPropertyDescriptor(f, u);
+        if (y?.set && y.set.call(c, a), !d) {
+          if (r && typeof u == "string") {
+            var Ee = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), re = Number(u);
+            Number.isInteger(re) && re >= Ee.v && E(Ee, re + 1);
+          }
+          gt(s);
+        }
+        return !0;
+      },
+      ownKeys(f) {
+        w(s);
+        var u = Reflect.ownKeys(f).filter((h) => {
+          var d = n.get(h);
+          return d === void 0 || d.v !== R;
+        });
+        for (var [a, c] of n)
+          c.v !== R && !(a in f) && u.push(a);
+        return u;
+      },
+      setPrototypeOf() {
+        Rs();
+      }
+    }
+  );
+}
+var Wn, Ir, Tr, Mr;
+function pn() {
+  if (Wn === void 0) {
+    Wn = window, Ir = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    Tr = Ge(t, "firstChild").get, Mr = Ge(t, "nextSibling").get, Vn(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Vn(n) && (n.__t = void 0);
+  }
+}
+function We(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function ct(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Tr.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Re(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Mr.call(e)
+  );
+}
+function Se(e, t) {
+  if (!k)
+    return /* @__PURE__ */ ct(e);
+  var n = /* @__PURE__ */ ct(S);
+  if (n === null)
+    n = S.appendChild(We());
+  else if (t && n.nodeType !== En) {
+    var r = We();
+    return n?.before(r), ue(r), r;
+  }
+  return t && Cr(
+    /** @type {Text} */
+    n
+  ), ue(n), n;
+}
+function Xe(e, t = 1, n = !1) {
+  let r = k ? S : e;
+  for (var s; t--; )
+    s = r, r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Re(r);
+  if (!k)
+    return r;
+  if (n) {
+    if (r?.nodeType !== En) {
+      var i = We();
+      return r === null ? s?.after(i) : r.before(i), ue(i), i;
+    }
+    Cr(
+      /** @type {Text} */
+      r
+    );
+  }
+  return ue(r), r;
+}
+function si(e) {
+  e.textContent = "";
+}
+function ii() {
+  return !1;
+}
+function Ar(e, t, n) {
+  return (
+    /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
+    document.createElementNS(er, e, void 0)
+  );
+}
+function Cr(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === En; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function Nr(e) {
+  var t = b, n = $;
+  G(null), ae(null);
+  try {
+    return e();
+  } finally {
+    G(t), ae(n);
+  }
+}
+function oi(e) {
+  $ === null && (b === null && Ms(), Ts()), Ce && Is();
+}
+function li(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function ye(e, t, n) {
+  var r = $;
+  r !== null && (r.f & fe) !== 0 && (e |= fe);
+  var s = {
+    ctx: V,
+    deps: null,
+    nodes: null,
+    f: e | D | J,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: r,
+    b: r && r.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (n)
+    try {
+      dt(s);
+    } catch (f) {
+      throw z(s), f;
+    }
+  else t !== null && ee(s);
+  var i = s;
+  if (n && i.deps === null && i.teardown === null && i.nodes === null && i.first === i.last && // either `null`, or a singular child
+  (i.f & qe) === 0 && (i = i.first, (e & $e) !== 0 && (e & ft) !== 0 && i !== null && (i.f |= ft)), i !== null && (i.parent = r, r !== null && li(i, r), b !== null && (b.f & O) !== 0 && (e & Ne) === 0)) {
+    var o = (
+      /** @type {Derived} */
+      b
+    );
+    (o.effects ?? (o.effects = [])).push(i);
+  }
+  return s;
+}
+function Tn() {
+  return b !== null && !te;
+}
+function fi(e) {
+  const t = ye(Wt, null, !1);
+  return M(t, N), t.teardown = e, t;
+}
+function gn(e) {
+  oi();
+  var t = (
+    /** @type {Effect} */
+    $.f
+  ), n = !b && (t & de) !== 0 && (t & ht) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      V
+    );
+    (r.e ?? (r.e = [])).push(e);
+  } else
+    return Rr(e);
+}
+function Rr(e) {
+  return ye(zt | xs, e, !1);
+}
+function ui(e) {
+  be.ensure();
+  const t = ye(Ne | qe, e, !0);
+  return () => {
+    z(t);
+  };
+}
+function ai(e) {
+  be.ensure();
+  const t = ye(Ne | qe, e, !0);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? mt(t, () => {
+      z(t), r(void 0);
+    }) : (z(t), r(void 0));
+  });
+}
+function ci(e) {
+  return ye(yn | qe, e, !0);
+}
+function Or(e, t = 0) {
+  return ye(Wt | t, e, !0);
+}
+function rn(e, t = [], n = [], r = []) {
+  Js(r, t, n, (s) => {
+    ye(Wt, () => e(...s.map(w)), !0);
+  });
+}
+function Dr(e, t = 0) {
+  var n = ye($e | t, e, !0);
+  return n;
+}
+function Ie(e) {
+  return ye(de | qe, e, !0);
+}
+function Pr(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = Ce, r = b;
+    qn(!0), G(null);
+    try {
+      t.call(null);
+    } finally {
+      qn(n), G(r);
+    }
+  }
+}
+function Mn(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const s = n.ac;
+    s !== null && Nr(() => {
+      s.abort(Oe);
+    });
+    var r = n.next;
+    (n.f & Ne) !== 0 ? n.parent = null : z(n, t), n = r;
+  }
+}
+function di(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & de) === 0 && z(t), t = n;
+  }
+}
+function z(e, t = !0) {
+  var n = !1;
+  (t || (e.f & ir) !== 0) && e.nodes !== null && e.nodes.end !== null && (hi(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), Mn(e, t && !n), wt(e, 0), M(e, we);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const i of r)
+      i.stop();
+  Pr(e);
+  var s = e.parent;
+  s !== null && s.first !== null && Lr(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function hi(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ Re(e);
+    e.remove(), e = n;
+  }
+}
+function Lr(e) {
+  var t = e.parent, n = e.prev, r = e.next;
+  n !== null && (n.next = r), r !== null && (r.prev = n), t !== null && (t.first === e && (t.first = r), t.last === e && (t.last = n));
+}
+function mt(e, t, n = !0) {
+  var r = [];
+  jr(e, r, !0);
+  var s = () => {
+    n && z(e), t && t();
+  }, i = r.length;
+  if (i > 0) {
+    var o = () => --i || s();
+    for (var f of r)
+      f.out(o);
+  } else
+    s();
+}
+function jr(e, t, n) {
+  if ((e.f & fe) === 0) {
+    e.f ^= fe;
+    var r = e.nodes && e.nodes.t;
+    if (r !== null)
+      for (const f of r)
+        (f.is_global || n) && t.push(f);
+    for (var s = e.first; s !== null; ) {
+      var i = s.next, o = (s.f & ft) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (s.f & de) !== 0 && (e.f & $e) !== 0;
+      jr(s, t, o ? n : !1), s = i;
+    }
+  }
+}
+function vi(e) {
+  Fr(e, !0);
+}
+function Fr(e, t) {
+  if ((e.f & fe) !== 0) {
+    e.f ^= fe, (e.f & N) === 0 && (M(e, D), ee(e));
+    for (var n = e.first; n !== null; ) {
+      var r = n.next, s = (n.f & ft) !== 0 || (n.f & de) !== 0;
+      Fr(n, s ? t : !1), n = r;
+    }
+    var i = e.nodes && e.nodes.t;
+    if (i !== null)
+      for (const o of i)
+        (o.is_global || t) && o.in();
+  }
+}
+function Hr(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, r = e.nodes.end; n !== null; ) {
+      var s = n === r ? null : /* @__PURE__ */ Re(n);
+      t.append(n), n = s;
+    }
+}
+let Lt = !1, Ce = !1;
+function qn(e) {
+  Ce = e;
+}
+let b = null, te = !1;
+function G(e) {
+  b = e;
+}
+let $ = null;
+function ae(e) {
+  $ = e;
+}
+let K = null;
+function zr(e) {
+  b !== null && (K === null ? K = [e] : K.push(e));
+}
+let H = null, Y = 0, q = null;
+function _i(e) {
+  q = e;
+}
+let Vr = 1, Pe = 0, Ye = Pe;
+function Un(e) {
+  Ye = e;
+}
+function Yr() {
+  return ++Vr;
+}
+function It(e) {
+  var t = e.f;
+  if ((t & D) !== 0)
+    return !0;
+  if (t & O && (e.f &= ~Be), (t & ne) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = n.length, s = 0; s < r; s++) {
+      var i = n[s];
+      if (It(
+        /** @type {Derived} */
+        i
+      ) && Er(
+        /** @type {Derived} */
+        i
+      ), i.wv > e.wv)
+        return !0;
+    }
+    (t & J) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    Q === null && M(e, N);
+  }
+  return !1;
+}
+function Br(e, t, n = !0) {
+  var r = e.reactions;
+  if (r !== null && !(K !== null && lt.call(K, e)))
+    for (var s = 0; s < r.length; s++) {
+      var i = r[s];
+      (i.f & O) !== 0 ? Br(
+        /** @type {Derived} */
+        i,
+        t,
+        !1
+      ) : t === i && (n ? M(i, D) : (i.f & N) !== 0 && M(i, ne), ee(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function Wr(e) {
+  var C;
+  var t = H, n = Y, r = q, s = b, i = K, o = V, f = te, u = Ye, a = e.f;
+  H = /** @type {null | Value[]} */
+  null, Y = 0, q = null, b = (a & (de | Ne)) === 0 ? e : null, K = null, ut(e.ctx), te = !1, Ye = ++Pe, e.ac !== null && (Nr(() => {
+    e.ac.abort(Oe);
+  }), e.ac = null);
+  try {
+    e.f |= fn;
+    var c = (
+      /** @type {Function} */
+      e.fn
+    ), h = c();
+    e.f |= ht;
+    var d = e.deps, g = x?.is_fork;
+    if (H !== null) {
+      var v;
+      if (g || wt(e, Y), d !== null && Y > 0)
+        for (d.length = Y + H.length, v = 0; v < H.length; v++)
+          d[Y + v] = H[v];
+      else
+        e.deps = d = H;
+      if (Tn() && (e.f & J) !== 0)
+        for (v = Y; v < d.length; v++)
+          ((C = d[v]).reactions ?? (C.reactions = [])).push(e);
+    } else !g && d !== null && Y < d.length && (wt(e, Y), d.length = Y);
+    if (cr() && q !== null && !te && d !== null && (e.f & (O | ne | D)) === 0)
+      for (v = 0; v < /** @type {Source[]} */
+      q.length; v++)
+        Br(
+          q[v],
+          /** @type {Effect} */
+          e
+        );
+    if (s !== null && s !== e) {
+      if (Pe++, s.deps !== null)
+        for (let y = 0; y < n; y += 1)
+          s.deps[y].rv = Pe;
+      if (t !== null)
+        for (const y of t)
+          y.rv = Pe;
+      q !== null && (r === null ? r = q : r.push(.../** @type {Source[]} */
+      q));
+    }
+    return (e.f & Me) !== 0 && (e.f ^= Me), h;
+  } catch (y) {
+    return hr(y);
+  } finally {
+    e.f ^= fn, H = t, Y = n, q = r, b = s, K = i, ut(o), te = f, Ye = u;
+  }
+}
+function pi(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var r = gs.call(n, e);
+    if (r !== -1) {
+      var s = n.length - 1;
+      s === 0 ? n = t.reactions = null : (n[r] = n[s], n.pop());
+    }
+  }
+  if (n === null && (t.f & O) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (H === null || !lt.call(H, t))) {
+    var i = (
+      /** @type {Derived} */
+      t
+    );
+    (i.f & J) !== 0 && (i.f ^= J, i.f &= ~Be), Sn(i), ti(i), wt(i, 0);
+  }
+}
+function wt(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var r = t; r < n.length; r++)
+      pi(e, n[r]);
+}
+function dt(e) {
+  var t = e.f;
+  if ((t & we) === 0) {
+    M(e, N);
+    var n = $, r = Lt;
+    $ = e, Lt = !0;
+    try {
+      (t & ($e | sr)) !== 0 ? di(e) : Mn(e), Pr(e);
+      var s = Wr(e);
+      e.teardown = typeof s == "function" ? s : null, e.wv = Vr;
+      var i;
+      on && zs && (e.f & D) !== 0 && e.deps;
+    } finally {
+      Lt = r, $ = n;
+    }
+  }
+}
+function w(e) {
+  var t = e.f, n = (t & O) !== 0;
+  if (b !== null && !te) {
+    var r = $ !== null && ($.f & we) !== 0;
+    if (!r && (K === null || !lt.call(K, e))) {
+      var s = b.deps;
+      if ((b.f & fn) !== 0)
+        e.rv < Pe && (e.rv = Pe, H === null && s !== null && s[Y] === e ? Y++ : H === null ? H = [e] : H.push(e));
+      else {
+        (b.deps ?? (b.deps = [])).push(e);
+        var i = e.reactions;
+        i === null ? e.reactions = [b] : lt.call(i, b) || i.push(b);
+      }
+    }
+  }
+  if (Ce && Ae.has(e))
+    return Ae.get(e);
+  if (n) {
+    var o = (
+      /** @type {Derived} */
+      e
+    );
+    if (Ce) {
+      var f = o.v;
+      return ((o.f & N) === 0 && o.reactions !== null || Ur(o)) && (f = In(o)), Ae.set(o, f), f;
+    }
+    var u = (o.f & J) === 0 && !te && b !== null && (Lt || (b.f & J) !== 0), a = (o.f & ht) === 0;
+    It(o) && (u && (o.f |= J), Er(o)), u && !a && (xr(o), qr(o));
+  }
+  if (Q?.has(e))
+    return Q.get(e);
+  if ((e.f & Me) !== 0)
+    throw e.v;
+  return e.v;
+}
+function qr(e) {
+  if (e.f |= J, e.deps !== null)
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & O) !== 0 && (t.f & J) === 0 && (xr(
+        /** @type {Derived} */
+        t
+      ), qr(
+        /** @type {Derived} */
+        t
+      ));
+}
+function Ur(e) {
+  if (e.v === R) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (Ae.has(t) || (t.f & O) !== 0 && Ur(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function Xr(e) {
+  var t = te;
+  try {
+    return te = !0, e();
+  } finally {
+    te = t;
+  }
+}
+const Le = /* @__PURE__ */ Symbol("events"), Jr = /* @__PURE__ */ new Set(), mn = /* @__PURE__ */ new Set();
+function Nt(e, t, n) {
+  (t[Le] ?? (t[Le] = {}))[e] = n;
+}
+function gi(e) {
+  for (var t = 0; t < e.length; t++)
+    Jr.add(e[t]);
+  for (var n of mn)
+    n(e);
+}
+let Xn = null;
+function Jn(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), r = e.type, s = e.composedPath?.() || [], i = (
+    /** @type {null | Element} */
+    s[0] || e.target
+  );
+  Xn = e;
+  var o = 0, f = Xn === e && e[Le];
+  if (f) {
+    var u = s.indexOf(f);
+    if (u !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e[Le] = t;
+      return;
+    }
+    var a = s.indexOf(t);
+    if (a === -1)
+      return;
+    u <= a && (o = u);
+  }
+  if (i = /** @type {Element} */
+  s[o] || e.target, i !== t) {
+    Ht(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return i || n;
+      }
+    });
+    var c = b, h = $;
+    G(null), ae(null);
+    try {
+      for (var d, g = []; i !== null; ) {
+        var v = i.assignedSlot || i.parentNode || /** @type {any} */
+        i.host || null;
+        try {
+          var C = i[Le]?.[r];
+          C != null && (!/** @type {any} */
+          i.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          e.target === i) && C.call(i, e);
+        } catch (y) {
+          d ? g.push(y) : d = y;
+        }
+        if (e.cancelBubble || v === t || v === null)
+          break;
+        i = v;
+      }
+      if (d) {
+        for (let y of g)
+          queueMicrotask(() => {
+            throw y;
+          });
+        throw d;
+      }
+    } finally {
+      e[Le] = t, delete e.currentTarget, G(c), ae(h);
+    }
+  }
+}
+const mi = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  globalThis?.window?.trustedTypes && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", {
+    /** @param {string} html */
+    createHTML: (e) => e
+  })
+);
+function wi(e) {
+  return (
+    /** @type {string} */
+    mi?.createHTML(e) ?? e
+  );
+}
+function Kr(e, t = !1) {
+  var n = Ar("template");
+  return e = e.replaceAll("<!>", "<!---->"), n.innerHTML = t ? wi(e) : e, n.content;
+}
+function bt(e, t) {
+  var n = (
+    /** @type {Effect} */
+    $
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Tt(e, t) {
+  var n = (t & ps) !== 0, r, s = !e.startsWith("<!>");
+  return () => {
+    if (k)
+      return bt(S, null), S;
+    r === void 0 && (r = Kr(s ? e : "<!>" + e, !0), r = /** @type {TemplateNode} */
+    /* @__PURE__ */ ct(r));
+    var i = (
+      /** @type {TemplateNode} */
+      n || Ir ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return bt(i, i), i;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function bi(e, t, n = "svg") {
+  var r = !e.startsWith("<!>"), s = `<${n}>${r ? e : "<!>" + e}</${n}>`, i;
+  return () => {
+    if (k)
+      return bt(S, null), S;
+    if (!i) {
+      var o = (
+        /** @type {DocumentFragment} */
+        Kr(s, !0)
+      ), f = (
+        /** @type {Element} */
+        /* @__PURE__ */ ct(o)
+      );
+      i = /** @type {Element} */
+      /* @__PURE__ */ ct(f);
+    }
+    var u = (
+      /** @type {TemplateNode} */
+      i.cloneNode(!0)
+    );
+    return bt(u, u), u;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Gr(e, t) {
+  return /* @__PURE__ */ bi(e, t, "svg");
+}
+function ke(e, t) {
+  if (k) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      $
+    );
+    ((n.f & ht) === 0 || n.nodes.end === null) && (n.nodes.end = S), xn();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const $i = ["touchstart", "touchmove"];
+function yi(e) {
+  return $i.includes(e);
+}
+function Ei(e, t) {
+  var n = t == null ? "" : typeof t == "object" ? t + "" : t;
+  n !== (e.__t ?? (e.__t = e.nodeValue)) && (e.__t = n, e.nodeValue = n + "");
+}
+function Zr(e, t) {
+  return Qr(e, t);
+}
+function xi(e, t) {
+  pn(), t.intro = t.intro ?? !1;
+  const n = t.target, r = k, s = S;
+  try {
+    for (var i = /* @__PURE__ */ ct(n); i && (i.nodeType !== qt || /** @type {Comment} */
+    i.data !== bn); )
+      i = /* @__PURE__ */ Re(i);
+    if (!i)
+      throw ot;
+    Je(!0), ue(
+      /** @type {Comment} */
+      i
+    );
+    const o = Qr(e, { ...t, anchor: i });
+    return Je(!1), /**  @type {Exports} */
+    o;
+  } catch (o) {
+    if (o instanceof Error && o.message.split(`
+`).some((f) => f.startsWith("https://svelte.dev/e/")))
+      throw o;
+    return o !== ot && console.warn("Failed to hydrate: ", o), t.recover === !1 && Cs(), pn(), si(n), Je(!1), Zr(e, t);
+  } finally {
+    Je(r), ue(s);
+  }
+}
+const Rt = /* @__PURE__ */ new Map();
+function Qr(e, { target: t, anchor: n, props: r = {}, events: s, context: i, intro: o = !0 }) {
+  pn();
+  var f = void 0, u = ai(() => {
+    var a = n ?? t.appendChild(We());
+    Us(
+      /** @type {TemplateNode} */
+      a,
+      {
+        pending: () => {
+        }
+      },
+      (d) => {
+        ur({});
+        var g = (
+          /** @type {ComponentContext} */
+          V
+        );
+        if (i && (g.c = i), s && (r.$$events = s), k && bt(
+          /** @type {TemplateNode} */
+          d,
+          null
+        ), f = e(d, r) || {}, k && ($.nodes.end = S, S === null || S.nodeType !== qt || /** @type {Comment} */
+        S.data !== Qn))
+          throw Ut(), ot;
+        ar();
+      }
+    );
+    var c = /* @__PURE__ */ new Set(), h = (d) => {
+      for (var g = 0; g < d.length; g++) {
+        var v = d[g];
+        if (!c.has(v)) {
+          c.add(v);
+          var C = yi(v);
+          for (const re of [t, document]) {
+            var y = Rt.get(re);
+            y === void 0 && (y = /* @__PURE__ */ new Map(), Rt.set(re, y));
+            var Ee = y.get(v);
+            Ee === void 0 ? (re.addEventListener(v, Jn, { passive: C }), y.set(v, 1)) : y.set(v, Ee + 1);
+          }
+        }
+      }
+    };
+    return h(ms(Jr)), mn.add(h), () => {
+      for (var d of c)
+        for (const C of [t, document]) {
+          var g = (
+            /** @type {Map<string, number>} */
+            Rt.get(C)
+          ), v = (
+            /** @type {number} */
+            g.get(d)
+          );
+          --v == 0 ? (C.removeEventListener(d, Jn), g.delete(d), g.size === 0 && Rt.delete(C)) : g.set(d, v);
+        }
+      mn.delete(h), a !== n && a.parentNode?.removeChild(a);
+    };
+  });
+  return wn.set(f, u), f;
+}
+let wn = /* @__PURE__ */ new WeakMap();
+function Si(e, t) {
+  const n = wn.get(e);
+  return n ? (wn.delete(e), n(t)) : Promise.resolve();
+}
+var Z, le, W, Ve, xt, St, Bt;
+class ki {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    /** @type {TemplateNode} */
+    T(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    m(this, Z, /* @__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>}
+     */
+    m(this, le, /* @__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>}
+     */
+    m(this, W, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    m(this, Ve, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    m(this, xt, !0);
+    m(this, St, () => {
+      var t = (
+        /** @type {Batch} */
+        x
+      );
+      if (l(this, Z).has(t)) {
+        var n = (
+          /** @type {Key} */
+          l(this, Z).get(t)
+        ), r = l(this, le).get(n);
+        if (r)
+          vi(r), l(this, Ve).delete(n);
+        else {
+          var s = l(this, W).get(n);
+          s && (l(this, le).set(n, s.effect), l(this, W).delete(n), s.fragment.lastChild.remove(), this.anchor.before(s.fragment), r = s.effect);
+        }
+        for (const [i, o] of l(this, Z)) {
+          if (l(this, Z).delete(i), i === t)
+            break;
+          const f = l(this, W).get(o);
+          f && (z(f.effect), l(this, W).delete(o));
+        }
+        for (const [i, o] of l(this, le)) {
+          if (i === n || l(this, Ve).has(i)) continue;
+          const f = () => {
+            if (Array.from(l(this, Z).values()).includes(i)) {
+              var a = document.createDocumentFragment();
+              Hr(o, a), a.append(We()), l(this, W).set(i, { effect: o, fragment: a });
+            } else
+              z(o);
+            l(this, Ve).delete(i), l(this, le).delete(i);
+          };
+          l(this, xt) || !r ? (l(this, Ve).add(i), mt(o, f, !1)) : f();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    m(this, Bt, (t) => {
+      l(this, Z).delete(t);
+      const n = Array.from(l(this, Z).values());
+      for (const [r, s] of l(this, W))
+        n.includes(r) || (z(s.effect), l(this, W).delete(r));
+    });
+    this.anchor = t, p(this, xt, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var r = (
+      /** @type {Batch} */
+      x
+    ), s = ii();
+    if (n && !l(this, le).has(t) && !l(this, W).has(t))
+      if (s) {
+        var i = document.createDocumentFragment(), o = We();
+        i.append(o), l(this, W).set(t, {
+          effect: Ie(() => n(o)),
+          fragment: i
+        });
+      } else
+        l(this, le).set(
+          t,
+          Ie(() => n(this.anchor))
+        );
+    if (l(this, Z).set(r, t), s) {
+      for (const [f, u] of l(this, le))
+        f === t ? r.unskip_effect(u) : r.skip_effect(u);
+      for (const [f, u] of l(this, W))
+        f === t ? r.unskip_effect(u.effect) : r.skip_effect(u.effect);
+      r.oncommit(l(this, St)), r.ondiscard(l(this, Bt));
+    } else
+      k && (this.anchor = S), l(this, St).call(this);
+  }
+}
+Z = new WeakMap(), le = new WeakMap(), W = new WeakMap(), Ve = new WeakMap(), xt = new WeakMap(), St = new WeakMap(), Bt = new WeakMap();
+function Ii(e) {
+  V === null && or(), gn(() => {
+    const t = Xr(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function Ti(e, t, { bubbles: n = !1, cancelable: r = !1 } = {}) {
+  return new CustomEvent(e, { detail: t, bubbles: n, cancelable: r });
+}
+function Mi() {
+  const e = V;
+  return e === null && or(), (t, n, r) => {
+    const s = (
+      /** @type {Record<string, Function | Function[]>} */
+      e.s.$$events?.[
+        /** @type {string} */
+        t
+      ]
+    );
+    if (s) {
+      const i = tr(s) ? s.slice() : [s], o = Ti(
+        /** @type {string} */
+        t,
+        n,
+        r
+      );
+      for (const f of i)
+        f.call(e.x, o);
+      return !o.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function Ot(e, t, n = !1) {
+  k && xn();
+  var r = new ki(e), s = n ? ft : 0;
+  function i(o, f) {
+    if (k) {
+      const c = js(e);
+      var u;
+      if (c === bn ? u = 0 : c === $n ? u = !1 : u = parseInt(c.substring(1)), o !== u) {
+        var a = lr();
+        ue(a), r.anchor = a, Je(!1), r.ensure(o, f), Je(!0);
+        return;
+      }
+    }
+    r.ensure(o, f);
+  }
+  Dr(() => {
+    var o = !1;
+    t((f, u = 0) => {
+      o = !0, i(u, f);
+    }), o || i(!1, null);
+  }, s);
+}
+function Ai(e, t) {
+  return e == null ? null : String(e);
+}
+function Kn(e, t, n, r) {
+  var s = e.__style;
+  if (k || s !== t) {
+    var i = Ai(t);
+    (!k || i !== e.getAttribute("style")) && (i == null ? e.removeAttribute("style") : e.style.cssText = i), e.__style = t;
+  }
+  return r;
+}
+const Ci = /* @__PURE__ */ Symbol("is custom element"), Ni = /* @__PURE__ */ Symbol("is html");
+function Ri(e, t, n, r) {
+  var s = Oi(e);
+  k && (s[t] = e.getAttribute(t)), s[t] !== (s[t] = n) && (n == null ? e.removeAttribute(t) : typeof n != "string" && Di(e).includes(t) ? e[t] = n : e.setAttribute(t, n));
+}
+function Oi(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Ci]: e.nodeName.includes("-"),
+      [Ni]: e.namespaceURI === er
+    })
+  );
+}
+var Gn = /* @__PURE__ */ new Map();
+function Di(e) {
+  var t = e.getAttribute("is") || e.nodeName, n = Gn.get(t);
+  if (n) return n;
+  Gn.set(t, n = []);
+  for (var r, s = e, i = Element.prototype; i !== s; ) {
+    r = ws(s);
+    for (var o in r)
+      r[o].set && n.push(o);
+    s = nr(s);
+  }
+  return n;
+}
+function sn(e, t, n, r) {
+  var s = (
+    /** @type {V} */
+    r
+  ), i = !0, o = () => (i && (i = !1, s = /** @type {V} */
+  r), s), f;
+  f = /** @type {V} */
+  e[t], f === void 0 && r !== void 0 && (f = o());
+  var u;
+  u = () => {
+    var d = (
+      /** @type {V} */
+      e[t]
+    );
+    return d === void 0 ? o() : (i = !0, d);
+  };
+  var a = !1, c = /* @__PURE__ */ kn(() => (a = !1, u())), h = (
+    /** @type {Effect} */
+    $
+  );
+  return (
+    /** @type {() => V} */
+    (function(d, g) {
+      if (arguments.length > 0) {
+        const v = g ? w(c) : d;
+        return E(c, v), a = !0, s !== void 0 && (s = v), d;
+      }
+      return Ce && a || (h.f & we) !== 0 ? c.v : w(c);
+    })
+  );
+}
+function Pi(e) {
+  return new Li(e);
+}
+var me, X;
+class Li {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    m(this, me);
+    /** @type {Record<string, any>} */
+    m(this, X);
+    var n = /* @__PURE__ */ new Map(), r = (i, o) => {
+      var f = /* @__PURE__ */ ni(o, !1, !1);
+      return n.set(i, f), f;
+    };
+    const s = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(i, o) {
+          return w(n.get(o) ?? r(o, Reflect.get(i, o)));
+        },
+        has(i, o) {
+          return o === Ss ? !0 : (w(n.get(o) ?? r(o, Reflect.get(i, o))), Reflect.has(i, o));
+        },
+        set(i, o, f) {
+          return E(n.get(o) ?? r(o, f), f), Reflect.set(i, o, f);
+        }
+      }
+    );
+    p(this, X, (t.hydrate ? xi : Zr)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: s,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover
+    })), (!t?.props?.$$host || t.sync === !1) && Dt(), p(this, me, s.$$events);
+    for (const i of Object.keys(l(this, X)))
+      i === "$set" || i === "$destroy" || i === "$on" || Ht(this, i, {
+        get() {
+          return l(this, X)[i];
+        },
+        /** @param {any} value */
+        set(o) {
+          l(this, X)[i] = o;
+        },
+        enumerable: !0
+      });
+    l(this, X).$set = /** @param {Record<string, any>} next */
+    (i) => {
+      Object.assign(s, i);
+    }, l(this, X).$destroy = () => {
+      Si(l(this, X));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    l(this, X).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, n) {
+    l(this, me)[t] = l(this, me)[t] || [];
+    const r = (...s) => n.call(this, ...s);
+    return l(this, me)[t].push(r), () => {
+      l(this, me)[t] = l(this, me)[t].filter(
+        /** @param {any} fn */
+        (s) => s !== r
+      );
+    };
+  }
+  $destroy() {
+    l(this, X).$destroy();
+  }
+}
+me = new WeakMap(), X = new WeakMap();
+let es;
+typeof HTMLElement == "function" && (es = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(t, n, r) {
+    super();
+    /** The Svelte component constructor */
+    T(this, "$$ctor");
+    /** Slots */
+    T(this, "$$s");
+    /** @type {any} The Svelte component instance */
+    T(this, "$$c");
+    /** Whether or not the custom element is connected */
+    T(this, "$$cn", !1);
+    /** @type {Record<string, any>} Component props data */
+    T(this, "$$d", {});
+    /** `true` if currently in the process of reflecting component props back to attributes */
+    T(this, "$$r", !1);
+    /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+    T(this, "$$p_d", {});
+    /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+    T(this, "$$l", {});
+    /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+    T(this, "$$l_u", /* @__PURE__ */ new Map());
+    /** @type {any} The managed render effect for reflecting attributes */
+    T(this, "$$me");
+    /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+    T(this, "$$shadowRoot", null);
+    this.$$ctor = t, this.$$s = n, r && (this.$$shadowRoot = this.attachShadow(r));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(t, n, r) {
+    if (this.$$l[t] = this.$$l[t] || [], this.$$l[t].push(n), this.$$c) {
+      const s = this.$$c.$on(t, n);
+      this.$$l_u.set(n, s);
+    }
+    super.addEventListener(t, n, r);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(t, n, r) {
+    if (super.removeEventListener(t, n, r), this.$$c) {
+      const s = this.$$l_u.get(n);
+      s && (s(), this.$$l_u.delete(n));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let t = function(s) {
+        return (i) => {
+          const o = Ar("slot");
+          s !== "default" && (o.name = s), ke(i, o);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const n = {}, r = ji(this);
+      for (const s of this.$$s)
+        s in r && (s === "default" && !this.$$d.children ? (this.$$d.children = t(s), n.default = !0) : n[s] = t(s));
+      for (const s of this.attributes) {
+        const i = this.$$g_p(s.name);
+        i in this.$$d || (this.$$d[i] = jt(i, s.value, this.$$p_d, "toProp"));
+      }
+      for (const s in this.$$p_d)
+        !(s in this.$$d) && this[s] !== void 0 && (this.$$d[s] = this[s], delete this[s]);
+      this.$$c = Pi({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: n,
+          $$host: this
+        }
+      }), this.$$me = ui(() => {
+        Or(() => {
+          this.$$r = !0;
+          for (const s of Ft(this.$$c)) {
+            if (!this.$$p_d[s]?.reflect) continue;
+            this.$$d[s] = this.$$c[s];
+            const i = jt(
+              s,
+              this.$$d[s],
+              this.$$p_d,
+              "toAttribute"
+            );
+            i == null ? this.removeAttribute(this.$$p_d[s].attribute || s) : this.setAttribute(this.$$p_d[s].attribute || s, i);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const s in this.$$l)
+        for (const i of this.$$l[s]) {
+          const o = this.$$c.$on(s, i);
+          this.$$l_u.set(i, o);
+        }
+      this.$$l = {};
+    }
+  }
+  // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+  // and setting attributes through setAttribute etc, this is helpful
+  /**
+   * @param {string} attr
+   * @param {string} _oldValue
+   * @param {string} newValue
+   */
+  attributeChangedCallback(t, n, r) {
+    this.$$r || (t = this.$$g_p(t), this.$$d[t] = jt(t, r, this.$$p_d, "toProp"), this.$$c?.$set({ [t]: this.$$d[t] }));
+  }
+  disconnectedCallback() {
+    this.$$cn = !1, Promise.resolve().then(() => {
+      !this.$$cn && this.$$c && (this.$$c.$destroy(), this.$$me(), this.$$c = void 0);
+    });
+  }
+  /**
+   * @param {string} attribute_name
+   */
+  $$g_p(t) {
+    return Ft(this.$$p_d).find(
+      (n) => this.$$p_d[n].attribute === t || !this.$$p_d[n].attribute && n.toLowerCase() === t
+    ) || t;
+  }
+});
+function jt(e, t, n, r) {
+  const s = n[e]?.type;
+  if (t = s === "Boolean" && typeof t != "boolean" ? t != null : t, !r || !n[e])
+    return t;
+  if (r === "toAttribute")
+    switch (s) {
+      case "Object":
+      case "Array":
+        return t == null ? null : JSON.stringify(t);
+      case "Boolean":
+        return t ? "" : null;
+      case "Number":
+        return t ?? null;
+      default:
+        return t;
+    }
+  else
+    switch (s) {
+      case "Object":
+      case "Array":
+        return t && JSON.parse(t);
+      case "Boolean":
+        return t;
+      // conversion already handled above
+      case "Number":
+        return t != null ? +t : t;
+      default:
+        return t;
+    }
+}
+function ji(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function Fi(e, t, n, r, s, i) {
+  let o = class extends es {
+    constructor() {
+      super(e, n, s), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Ft(t).map(
+        (f) => (t[f].attribute || f).toLowerCase()
+      );
+    }
+  };
+  return Ft(t).forEach((f) => {
+    Ht(o.prototype, f, {
+      get() {
+        return this.$$c && f in this.$$c ? this.$$c[f] : this.$$d[f];
+      },
+      set(u) {
+        u = jt(f, u, t), this.$$d[f] = u;
+        var a = this.$$c;
+        if (a) {
+          var c = Ge(a, f)?.get;
+          c ? a[f] = u : a.$set({ [f]: u });
+        }
+      }
+    });
+  }), r.forEach((f) => {
+    Ht(o.prototype, f, {
+      get() {
+        return this.$$c?.[f];
+      }
+    });
+  }), e.element = /** @type {any} */
+  o, o;
+}
+var Hi = /* @__PURE__ */ Gr('<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 15l7-7 7 7"></path></svg>'), zi = /* @__PURE__ */ Gr('<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path></svg>'), Vi = /* @__PURE__ */ Tt('<div class="alert alert-info"><svg xmlns="http://www.w3.org/2000/svg" class="stroke-current shrink-0 h-5 w-5" fill="none" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path></svg> <span class="text-xs">No session data yet. Interact with the questions to see updates.</span></div>'), Yi = /* @__PURE__ */ Tt('<div class="bg-base-200 rounded p-3 flex-1 min-h-0 flex flex-col"><div class="text-xs font-semibold mb-2">Item Sessions Snapshot</div> <pre class="bg-base-300 p-2 rounded text-xs overflow-auto flex-1 min-h-0"> </pre></div>'), Bi = /* @__PURE__ */ Tt('<div class="p-4 flex flex-col min-h-0 overflow-hidden"><div class="space-y-3 flex-1 min-h-0 flex flex-col"><div class="mb-2"><div class="text-sm font-bold mb-2">PIE Session Data (Persistent)</div></div> <!></div></div>'), Wi = /* @__PURE__ */ Tt('<div class="absolute bottom-0 right-0 w-4 h-4 cursor-se-resize" role="button" tabindex="0" title="Resize window"><svg class="w-full h-full text-base-content/30" viewBox="0 0 16 16" fill="currentColor"><path d="M16 16V14H14V16H16Z"></path><path d="M16 11V9H14V11H16Z"></path><path d="M13 16V14H11V16H13Z"></path></svg></div>'), qi = /* @__PURE__ */ Tt('<div class="fixed z-100 bg-base-100 rounded-lg shadow-2xl border-2 border-base-300"><div class="flex items-center justify-between px-4 py-2 bg-base-200 rounded-t-lg cursor-move select-none border-b border-base-300" role="button" tabindex="0" aria-label="Drag session panel"><div class="flex items-center gap-2"><svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path></svg> <h3 class="font-bold text-sm">Session Data</h3></div> <div class="flex gap-1"><button class="btn btn-xs btn-ghost btn-circle"><!></button> <button class="btn btn-xs btn-ghost btn-circle" title="Close"><svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg></button></div></div> <!> <!></div>');
+function Ui(e, t) {
+  ur(t, !0);
+  const n = Mi();
+  let r = sn(t, "toolkitCoordinator", 7, null), s = sn(t, "sectionId", 7, ""), i = sn(t, "attemptId", 7, void 0), o = /* @__PURE__ */ P(!1), f = /* @__PURE__ */ P(24), u = /* @__PURE__ */ P(100), a = /* @__PURE__ */ P(220), c = /* @__PURE__ */ P(600), h = /* @__PURE__ */ P(!1), d = /* @__PURE__ */ P(!1), g = 0, v = 0, C = 0, y = 0, Ee = 0, re = 0, Cn = 0, Nn = 0, Jt = /* @__PURE__ */ P(Ke({
+    currentItemIndex: null,
+    currentItemId: null,
+    visitedItemIdentifiers: [],
+    updatedAt: null,
+    lastChangedItemId: null,
+    itemSessions: {}
+  }));
+  function Rn(_) {
+    try {
+      return structuredClone(_);
+    } catch {
+      return JSON.parse(JSON.stringify(_));
+    }
+  }
+  function On() {
+    if (!(!r() || !s()))
+      return r().getSectionController?.({ sectionId: s(), attemptId: i() });
+  }
+  function Dn(_) {
+    const A = On()?.getCurrentSectionAttemptSlice?.() || null;
+    E(
+      Jt,
+      {
+        currentItemIndex: typeof A?.currentItemIndex == "number" ? A.currentItemIndex : null,
+        currentItemId: typeof A?.currentItemId == "string" && A.currentItemId ? A.currentItemId : null,
+        visitedItemIdentifiers: Rn(A?.visitedItemIdentifiers || []),
+        updatedAt: _?.updatedAt || Date.now(),
+        lastChangedItemId: _?.itemId || null,
+        itemSessions: Rn(A?.itemSessions || {})
+      },
+      !0
+    );
+  }
+  gn(() => {
+    if (!r() || !s()) return;
+    Dn();
+    const I = On()?.subscribe?.((A) => {
+      Dn({
+        itemId: A?.itemId,
+        updatedAt: A?.timestamp || Date.now()
+      });
+    });
+    return () => {
+      I?.();
+    };
+  }), Ii(() => {
+    const _ = (Zt, Qt, en) => Math.max(Qt, Math.min(Zt, en)), I = window.innerWidth, A = window.innerHeight;
+    E(a, _(Math.round(I * 0.29), 280, 560), !0), E(c, _(Math.round(A * 0.72), 360, 860), !0), E(f, Math.max(16, Math.round(I * 0.08)), !0), E(u, Math.max(16, Math.round((A - w(c)) / 2)), !0);
+  });
+  function ts(_) {
+    E(h, !0), g = _.clientX, v = _.clientY, C = w(f), y = w(u), document.addEventListener("mousemove", Pn), document.addEventListener("mouseup", Kt);
+  }
+  function Pn(_) {
+    if (!w(h)) return;
+    const I = _.clientX - g, A = _.clientY - v;
+    E(f, C + I), E(u, y + A), E(f, Math.max(0, Math.min(w(f), window.innerWidth - w(a))), !0), E(u, Math.max(0, Math.min(w(u), window.innerHeight - 100)), !0);
+  }
+  function Kt() {
+    E(h, !1), document.removeEventListener("mousemove", Pn), document.removeEventListener("mouseup", Kt);
+  }
+  function ns(_) {
+    E(d, !0), Ee = _.clientX, re = _.clientY, Cn = w(a), Nn = w(c), document.addEventListener("mousemove", Ln), document.addEventListener("mouseup", Gt), _.stopPropagation();
+  }
+  function Ln(_) {
+    if (!w(d)) return;
+    const I = _.clientX - Ee, A = _.clientY - re;
+    E(a, Math.max(300, Math.min(Cn + I, window.innerWidth - w(f))), !0), E(c, Math.max(200, Math.min(Nn + A, window.innerHeight - w(u))), !0);
+  }
+  function Gt() {
+    E(d, !1), document.removeEventListener("mousemove", Ln), document.removeEventListener("mouseup", Gt);
+  }
+  gn(() => () => {
+    Kt(), Gt();
+  });
+  var rs = {
+    get toolkitCoordinator() {
+      return r();
+    },
+    set toolkitCoordinator(_ = null) {
+      r(_), Dt();
+    },
+    get sectionId() {
+      return s();
+    },
+    set sectionId(_ = "") {
+      s(_), Dt();
+    },
+    get attemptId() {
+      return i();
+    },
+    set attemptId(_ = void 0) {
+      i(_), Dt();
+    }
+  }, Mt = qi(), At = Se(Mt), jn = Xe(Se(At), 2), vt = Se(jn), ss = Se(vt);
+  {
+    var is = (_) => {
+      var I = Hi();
+      ke(_, I);
+    }, os = (_) => {
+      var I = zi();
+      ke(_, I);
+    };
+    Ot(ss, (_) => {
+      w(o) ? _(is) : _(os, !1);
+    });
+  }
+  xe(vt);
+  var ls = Xe(vt, 2);
+  xe(jn), xe(At);
+  var Fn = Xe(At, 2);
+  {
+    var fs = (_) => {
+      var I = Bi(), A = Se(I), Zt = Xe(Se(A), 2);
+      {
+        var Qt = (Ue) => {
+          var _t = Vi();
+          ke(Ue, _t);
+        }, en = /* @__PURE__ */ Zs(() => Object.keys(w(Jt).itemSessions || {}).length === 0), cs = (Ue) => {
+          var _t = Yi(), Hn = Xe(Se(_t), 2), ds = Se(Hn, !0);
+          xe(Hn), xe(_t), rn((hs) => Ei(ds, hs), [() => JSON.stringify(w(Jt), null, 2)]), ke(Ue, _t);
+        };
+        Ot(Zt, (Ue) => {
+          w(en) ? Ue(Qt) : Ue(cs, !1);
+        });
+      }
+      xe(A), xe(I), rn(() => Kn(I, `height: ${w(c) - 60}px;`)), ke(_, I);
+    };
+    Ot(Fn, (_) => {
+      w(o) || _(fs);
+    });
+  }
+  var us = Xe(Fn, 2);
+  {
+    var as = (_) => {
+      var I = Wi();
+      Nt("mousedown", I, ns), ke(_, I);
+    };
+    Ot(us, (_) => {
+      w(o) || _(as);
+    });
+  }
+  return xe(Mt), rn(() => {
+    Kn(Mt, `left: ${w(f) ?? ""}px; top: ${w(u) ?? ""}px; width: ${w(a) ?? ""}px; ${w(o) ? "height: auto;" : `height: ${w(c)}px;`}`), Ri(vt, "title", w(o) ? "Maximize" : "Minimize");
+  }), Nt("mousedown", At, ts), Nt("click", vt, () => E(o, !w(o))), Nt("click", ls, () => n("close")), ke(e, Mt), ar(rs);
+}
+gi(["mousedown", "click"]);
+customElements.define("pie-section-player-tools-session-debugger", Fi(
+  Ui,
+  {
+    sectionId: { attribute: "section-id", type: "String" },
+    attemptId: { attribute: "attempt-id", type: "String" },
+    toolkitCoordinator: { attribute: "toolkit-coordinator", type: "Object" }
+  },
+  [],
+  [],
+  { mode: "open" }
+));
+export {
+  Ui as default
+};