@pie-element/element-player 0.1.1

package/dist/pie-element-player.js

@@ -0,0 +1,2841 @@
+import { m as Ht } from "./math-mathjax-Dwo4iuV6.js";
+const Hn = "5";
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add(Hn);
+const Yn = 1, zn = 4, Kn = 8, Gn = 16, Wn = 2, $t = "[", yt = "[!", Yt = "]", Re = {}, O = /* @__PURE__ */ Symbol(), Jn = "http://www.w3.org/1999/xhtml", dt = !1;
+var zt = Array.isArray, Zn = Array.prototype.indexOf, Oe = Array.prototype.includes, Xn = Array.from, Qe = Object.keys, et = Object.defineProperty, we = Object.getOwnPropertyDescriptor, Qn = Object.prototype, er = Array.prototype, tr = Object.getPrototypeOf, Pt = Object.isExtensible;
+const nr = () => {
+};
+function rr(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function Kt() {
+  var e, t, n = new Promise((r, i) => {
+    e = r, t = i;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const k = 2, Be = 4, ot = 8, Gt = 1 << 24, le = 16, X = 32, ve = 64, Wt = 128, U = 512, R = 1024, C = 2048, K = 4096, W = 8192, ie = 16384, De = 32768, ke = 65536, Dt = 1 << 17, Jt = 1 << 18, Te = 1 << 19, ir = 1 << 20, Ee = 65536, ht = 1 << 21, bt = 1 << 22, ce = 1 << 23, Ie = /* @__PURE__ */ Symbol("$state"), Zt = /* @__PURE__ */ Symbol("legacy props"), pe = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}(), Et = 3, He = 8;
+function Xt(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function sr() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function lr(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function or() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function fr(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function ar() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function ur() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function cr(e) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function dr() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function hr() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function vr() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function _r() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function ft(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function pr() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let A = !1;
+function Ne(e) {
+  A = e;
+}
+let T;
+function J(e) {
+  if (e === null)
+    throw ft(), Re;
+  return T = e;
+}
+function xt() {
+  return J(/* @__PURE__ */ _e(T));
+}
+function fe(e) {
+  if (A) {
+    if (/* @__PURE__ */ _e(T) !== null)
+      throw ft(), Re;
+    T = e;
+  }
+}
+function mr(e = 1) {
+  if (A) {
+    for (var t = e, n = T; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ _e(n);
+    T = n;
+  }
+}
+function Qt(e = !0) {
+  for (var t = 0, n = T; ; ) {
+    if (n.nodeType === He) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === Yt) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (r === $t || r === yt || // "[1", "[2", etc. for if blocks
+      r[0] === "[" && !isNaN(Number(r.slice(1)))) && (t += 1);
+    }
+    var i = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ _e(n)
+    );
+    e && n.remove(), n = i;
+  }
+}
+function gr(e) {
+  if (!e || e.nodeType !== He)
+    throw ft(), Re;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function en(e) {
+  return e === this.v;
+}
+function wr(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function tn(e) {
+  return !wr(e, this.v);
+}
+let $r = !1, F = null;
+function Ce(e) {
+  F = e;
+}
+function Tt(e, t = !1, n) {
+  F = {
+    p: F,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function St(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    F
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var r of n)
+      yn(r);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, F = t.p, e ?? /** @type {T} */
+  {};
+}
+function nn() {
+  return !0;
+}
+let me = [];
+function rn() {
+  var e = me;
+  me = [], rr(e);
+}
+function $e(e) {
+  if (me.length === 0 && !je) {
+    var t = me;
+    queueMicrotask(() => {
+      t === me && rn();
+    });
+  }
+  me.push(e);
+}
+function yr() {
+  for (; me.length > 0; )
+    rn();
+}
+function sn(e) {
+  var t = y;
+  if (t === null)
+    return w.f |= ce, e;
+  if ((t.f & De) === 0 && (t.f & Be) === 0)
+    throw e;
+  Me(e, t);
+}
+function Me(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & Wt) !== 0) {
+      if ((t.f & De) === 0)
+        throw e;
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    }
+    t = t.parent;
+  }
+  throw e;
+}
+const br = -7169;
+function S(e, t) {
+  e.f = e.f & br | t;
+}
+function Nt(e) {
+  (e.f & U) !== 0 || e.deps === null ? S(e, R) : S(e, K);
+}
+function ln(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & k) === 0 || (t.f & Ee) === 0 || (t.f ^= Ee, ln(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function on(e, t, n) {
+  (e.f & C) !== 0 ? t.add(e) : (e.f & K) !== 0 && n.add(e), ln(e.deps), S(e, R);
+}
+const Ke = /* @__PURE__ */ new Set();
+let x = null, H = null, P = [], at = null, vt = !1, je = !1;
+class se {
+  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>}
+   */
+  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>}
+   */
+  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>}
+   */
+  #e = /* @__PURE__ */ new Set();
+  /**
+   * If a fork is discarded, we need to destroy any effects that are no longer needed
+   * @type {Set<(batch: Batch) => void>}
+   */
+  #t = /* @__PURE__ */ new Set();
+  /**
+   * The number of async effects that are currently in flight
+   */
+  #n = 0;
+  /**
+   * The number of async effects that are currently in flight, _not_ inside a pending boundary
+   */
+  #l = 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}
+   */
+  #o = null;
+  /**
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Set<Effect>}
+   */
+  #i = /* @__PURE__ */ new Set();
+  /**
+   * Deferred effects that are MAYBE_DIRTY
+   * @type {Set<Effect>}
+   */
+  #r = /* @__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[] }>}
+   */
+  #s = /* @__PURE__ */ new Map();
+  is_fork = !1;
+  #f = !1;
+  is_deferred() {
+    return this.is_fork || this.#l > 0;
+  }
+  /**
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
+   */
+  skip_effect(t) {
+    this.#s.has(t) || this.#s.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 = this.#s.get(t);
+    if (n) {
+      this.#s.delete(t);
+      for (var r of n.d)
+        S(r, C), Y(r);
+      for (r of n.m)
+        S(r, K), Y(r);
+    }
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    P = [], this.apply();
+    var n = [], r = [];
+    for (const i of t)
+      this.#a(i, n, r);
+    if (this.is_deferred()) {
+      this.#c(r), this.#c(n);
+      for (const [i, s] of this.#s)
+        cn(i, s);
+    } else {
+      for (const i of this.#e) i();
+      this.#e.clear(), this.#n === 0 && this.#u(), x = null, Lt(r), Lt(n), this.#o?.resolve();
+    }
+    H = null;
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   * @param {Effect[]} effects
+   * @param {Effect[]} render_effects
+   */
+  #a(t, n, r) {
+    t.f ^= R;
+    for (var i = t.first, s = null; i !== null; ) {
+      var l = i.f, o = (l & (X | ve)) !== 0, f = o && (l & R) !== 0, a = f || (l & W) !== 0 || this.#s.has(i);
+      if (!a && i.fn !== null) {
+        o ? i.f ^= R : s !== null && (l & (Be | ot | Gt)) !== 0 ? s.b.defer_effect(i) : (l & Be) !== 0 ? n.push(i) : ze(i) && ((l & le) !== 0 && this.#r.add(i), Pe(i));
+        var d = i.first;
+        if (d !== null) {
+          i = d;
+          continue;
+        }
+      }
+      var c = i.parent;
+      for (i = i.next; i === null && c !== null; )
+        c === s && (s = null), i = c.next, c = c.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #c(t) {
+    for (var n = 0; n < t.length; n += 1)
+      on(t[n], this.#i, this.#r);
+  }
+  /**
+   * 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 !== O && !this.previous.has(t) && this.previous.set(t, n), (t.f & ce) === 0 && (this.current.set(t, t.v), H?.set(t, t.v));
+  }
+  activate() {
+    x = this, this.apply();
+  }
+  deactivate() {
+    x === this && (x = null, H = null);
+  }
+  flush() {
+    if (this.activate(), P.length > 0) {
+      if (fn(), x !== null && x !== this)
+        return;
+    } else this.#n === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of this.#t) t(this);
+    this.#t.clear();
+  }
+  #u() {
+    if (Ke.size > 1) {
+      this.previous.clear();
+      var t = H, n = !0;
+      for (const i of Ke) {
+        if (i === this) {
+          n = !1;
+          continue;
+        }
+        const s = [];
+        for (const [o, f] of this.current) {
+          if (i.current.has(o))
+            if (n && f !== i.current.get(o))
+              i.current.set(o, f);
+            else
+              continue;
+          s.push(o);
+        }
+        if (s.length === 0)
+          continue;
+        const l = [...i.current.keys()].filter((o) => !this.current.has(o));
+        if (l.length > 0) {
+          var r = P;
+          P = [];
+          const o = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map();
+          for (const a of s)
+            an(a, l, o, f);
+          if (P.length > 0) {
+            x = i, i.apply();
+            for (const a of P)
+              i.#a(a, [], []);
+            i.deactivate();
+          }
+          P = r;
+        }
+      }
+      x = null, H = t;
+    }
+    this.committed = !0, Ke.delete(this);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    this.#n += 1, t && (this.#l += 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    this.#n -= 1, t && (this.#l -= 1), !this.#f && (this.#f = !0, $e(() => {
+      this.#f = !1, this.is_deferred() ? P.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of this.#i)
+      this.#r.delete(t), S(t, C), Y(t);
+    for (const t of this.#r)
+      S(t, K), Y(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    this.#e.add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    this.#t.add(t);
+  }
+  settled() {
+    return (this.#o ??= Kt()).promise;
+  }
+  static ensure() {
+    if (x === null) {
+      const t = x = new se();
+      Ke.add(x), je || $e(() => {
+        x === t && t.flush();
+      });
+    }
+    return x;
+  }
+  apply() {
+  }
+}
+function re(e) {
+  var t = je;
+  je = !0;
+  try {
+    for (var n; ; ) {
+      if (yr(), P.length === 0 && (x?.flush(), P.length === 0))
+        return at = null, /** @type {T} */
+        n;
+      fn();
+    }
+  } finally {
+    je = t;
+  }
+}
+function fn() {
+  vt = !0;
+  var e = null;
+  try {
+    for (var t = 0; P.length > 0; ) {
+      var n = se.ensure();
+      if (t++ > 1e3) {
+        var r, i;
+        Er();
+      }
+      n.process(P), de.clear();
+    }
+  } finally {
+    P = [], vt = !1, at = null;
+  }
+}
+function Er() {
+  try {
+    ar();
+  } catch (e) {
+    Me(e, at);
+  }
+}
+let te = null;
+function Lt(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var r = e[n++];
+      if ((r.f & (ie | W)) === 0 && ze(r) && (te = /* @__PURE__ */ new Set(), Pe(r), r.deps === null && r.first === null && r.nodes === null && r.teardown === null && r.ac === null && Tn(r), te?.size > 0)) {
+        de.clear();
+        for (const i of te) {
+          if ((i.f & (ie | W)) !== 0) continue;
+          const s = [i];
+          let l = i.parent;
+          for (; l !== null; )
+            te.has(l) && (te.delete(l), s.push(l)), l = l.parent;
+          for (let o = s.length - 1; o >= 0; o--) {
+            const f = s[o];
+            (f.f & (ie | W)) === 0 && Pe(f);
+          }
+        }
+        te.clear();
+      }
+    }
+    te = null;
+  }
+}
+function an(e, t, n, r) {
+  if (!n.has(e) && (n.add(e), e.reactions !== null))
+    for (const i of e.reactions) {
+      const s = i.f;
+      (s & k) !== 0 ? an(
+        /** @type {Derived} */
+        i,
+        t,
+        n,
+        r
+      ) : (s & (bt | le)) !== 0 && (s & C) === 0 && un(i, t, r) && (S(i, C), Y(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function un(e, t, n) {
+  const r = n.get(e);
+  if (r !== void 0) return r;
+  if (e.deps !== null)
+    for (const i of e.deps) {
+      if (Oe.call(t, i))
+        return !0;
+      if ((i.f & k) !== 0 && un(
+        /** @type {Derived} */
+        i,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function Y(e) {
+  for (var t = at = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (vt && t === y && (n & le) !== 0 && (n & Jt) === 0)
+      return;
+    if ((n & (ve | X)) !== 0) {
+      if ((n & R) === 0) return;
+      t.f ^= R;
+    }
+  }
+  P.push(t);
+}
+function cn(e, t) {
+  if (!((e.f & X) !== 0 && (e.f & R) !== 0)) {
+    (e.f & C) !== 0 ? t.d.push(e) : (e.f & K) !== 0 && t.m.push(e), S(e, R);
+    for (var n = e.first; n !== null; )
+      cn(n, t), n = n.next;
+  }
+}
+function xr(e) {
+  let t = 0, n = Ye(0), r;
+  return () => {
+    kt() && (p(n), Ct(() => (t === 0 && (r = ut(() => e(() => qe(n)))), t += 1, () => {
+      $e(() => {
+        t -= 1, t === 0 && (r?.(), r = void 0, qe(n));
+      });
+    })));
+  };
+}
+var Tr = ke | Te | Wt;
+function Sr(e, t, n) {
+  new Nr(e, t, n);
+}
+class Nr {
+  /** @type {Boundary | null} */
+  parent;
+  is_pending = !1;
+  /** @type {TemplateNode} */
+  #e;
+  /** @type {TemplateNode | null} */
+  #t = A ? T : null;
+  /** @type {BoundaryProps} */
+  #n;
+  /** @type {((anchor: Node) => void)} */
+  #l;
+  /** @type {Effect} */
+  #o;
+  /** @type {Effect | null} */
+  #i = null;
+  /** @type {Effect | null} */
+  #r = null;
+  /** @type {Effect | null} */
+  #s = null;
+  /** @type {DocumentFragment | null} */
+  #f = null;
+  /** @type {TemplateNode | null} */
+  #a = null;
+  #c = 0;
+  #u = 0;
+  #v = !1;
+  #h = !1;
+  /** @type {Set<Effect>} */
+  #_ = /* @__PURE__ */ new Set();
+  /** @type {Set<Effect>} */
+  #p = /* @__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}
+   */
+  #d = null;
+  #y = xr(() => (this.#d = Ye(this.#c), () => {
+    this.#d = null;
+  }));
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, r) {
+    this.#e = t, this.#n = n, this.#l = r, this.parent = /** @type {Effect} */
+    y.b, this.is_pending = !!this.#n.pending, this.#o = En(() => {
+      if (y.b = this, A) {
+        const s = this.#t;
+        xt(), /** @type {Comment} */
+        s.nodeType === He && /** @type {Comment} */
+        s.data === yt ? this.#E() : (this.#b(), this.#u === 0 && (this.is_pending = !1));
+      } else {
+        var i = this.#w();
+        try {
+          this.#i = ne(() => r(i));
+        } catch (s) {
+          this.error(s);
+        }
+        this.#u > 0 ? this.#g() : this.is_pending = !1;
+      }
+      return () => {
+        this.#a?.remove();
+      };
+    }, Tr), A && (this.#e = T);
+  }
+  #b() {
+    try {
+      this.#i = ne(() => this.#l(this.#e));
+    } catch (t) {
+      this.error(t);
+    }
+  }
+  #E() {
+    const t = this.#n.pending;
+    t && (this.#r = ne(() => t(this.#e)), $e(() => {
+      var n = this.#w();
+      this.#i = this.#m(() => (se.ensure(), ne(() => this.#l(n)))), this.#u > 0 ? this.#g() : (Ue(
+        /** @type {Effect} */
+        this.#r,
+        () => {
+          this.#r = null;
+        }
+      ), this.is_pending = !1);
+    }));
+  }
+  #w() {
+    var t = this.#e;
+    return this.is_pending && (this.#a = xe(), this.#e.before(this.#a), t = this.#a), t;
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    on(t, this.#_, this.#p);
+  }
+  /**
+   * 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 !!this.#n.pending;
+  }
+  /**
+   * @param {() => Effect | null} fn
+   */
+  #m(t) {
+    var n = y, r = w, i = F;
+    Z(this.#o), V(this.#o), Ce(this.#o.ctx);
+    try {
+      return t();
+    } catch (s) {
+      return sn(s), null;
+    } finally {
+      Z(n), V(r), Ce(i);
+    }
+  }
+  #g() {
+    const t = (
+      /** @type {(anchor: Node) => void} */
+      this.#n.pending
+    );
+    this.#i !== null && (this.#f = document.createDocumentFragment(), this.#f.append(
+      /** @type {TemplateNode} */
+      this.#a
+    ), An(this.#i, this.#f)), this.#r === null && (this.#r = ne(() => t(this.#e)));
+  }
+  /**
+   * 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
+   */
+  #$(t) {
+    if (!this.has_pending_snippet()) {
+      this.parent && this.parent.#$(t);
+      return;
+    }
+    if (this.#u += t, this.#u === 0) {
+      this.is_pending = !1;
+      for (const n of this.#_)
+        S(n, C), Y(n);
+      for (const n of this.#p)
+        S(n, K), Y(n);
+      this.#_.clear(), this.#p.clear(), this.#r && Ue(this.#r, () => {
+        this.#r = null;
+      }), this.#f && (this.#e.before(this.#f), this.#f = null);
+    }
+  }
+  /**
+   * 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) {
+    this.#$(t), this.#c += t, !(!this.#d || this.#v) && (this.#v = !0, $e(() => {
+      this.#v = !1, this.#d && tt(this.#d, this.#c);
+    }));
+  }
+  get_effect_pending() {
+    return this.#y(), p(
+      /** @type {Source<number>} */
+      this.#d
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = this.#n.onerror;
+    let r = this.#n.failed;
+    if (this.#h || !n && !r)
+      throw t;
+    this.#i && (L(this.#i), this.#i = null), this.#r && (L(this.#r), this.#r = null), this.#s && (L(this.#s), this.#s = null), A && (J(
+      /** @type {TemplateNode} */
+      this.#t
+    ), mr(), J(Qt()));
+    var i = !1, s = !1;
+    const l = () => {
+      if (i) {
+        pr();
+        return;
+      }
+      i = !0, s && _r(), se.ensure(), this.#c = 0, this.#s !== null && Ue(this.#s, () => {
+        this.#s = null;
+      }), this.is_pending = this.has_pending_snippet(), this.#i = this.#m(() => (this.#h = !1, ne(() => this.#l(this.#e)))), this.#u > 0 ? this.#g() : this.is_pending = !1;
+    };
+    $e(() => {
+      try {
+        s = !0, n?.(t, l), s = !1;
+      } catch (o) {
+        Me(o, this.#o && this.#o.parent);
+      }
+      r && (this.#s = this.#m(() => {
+        se.ensure(), this.#h = !0;
+        try {
+          return ne(() => {
+            r(
+              this.#e,
+              () => t,
+              () => l
+            );
+          });
+        } catch (o) {
+          return Me(
+            o,
+            /** @type {Effect} */
+            this.#o.parent
+          ), null;
+        } finally {
+          this.#h = !1;
+        }
+      }));
+    });
+  }
+}
+function Ar(e, t, n, r) {
+  const i = At;
+  var s = e.filter((u) => !u.settled);
+  if (n.length === 0 && s.length === 0) {
+    r(t.map(i));
+    return;
+  }
+  var l = x, o = (
+    /** @type {Effect} */
+    y
+  ), f = Rr(), a = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((u) => u.promise)) : null;
+  function d(u) {
+    f();
+    try {
+      r(u);
+    } catch (v) {
+      (o.f & ie) === 0 && Me(v, o);
+    }
+    l?.deactivate(), _t();
+  }
+  if (n.length === 0) {
+    a.then(() => d(t.map(i)));
+    return;
+  }
+  function c() {
+    f(), Promise.all(n.map((u) => /* @__PURE__ */ Or(u))).then((u) => d([...t.map(i), ...u])).catch((u) => Me(u, o));
+  }
+  a ? a.then(c) : c();
+}
+function Rr() {
+  var e = y, t = w, n = F, r = x;
+  return function(s = !0) {
+    Z(e), V(t), Ce(n), s && r?.activate();
+  };
+}
+function _t() {
+  Z(null), V(null), Ce(null);
+}
+// @__NO_SIDE_EFFECTS__
+function At(e) {
+  var t = k | C, n = w !== null && (w.f & k) !== 0 ? (
+    /** @type {Derived} */
+    w
+  ) : null;
+  return y !== null && (y.f |= Te), {
+    ctx: F,
+    deps: null,
+    effects: null,
+    equals: en,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      O
+    ),
+    wv: 0,
+    parent: n ?? y,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Or(e, t, n) {
+  let r = (
+    /** @type {Effect | null} */
+    y
+  );
+  r === null && sr();
+  var i = (
+    /** @type {Boundary} */
+    r.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = Ye(
+    /** @type {V} */
+    O
+  ), o = !w, f = /* @__PURE__ */ new Map();
+  return Hr(() => {
+    var a = Kt();
+    s = a.promise;
+    try {
+      Promise.resolve(e()).then(a.resolve, a.reject).then(() => {
+        d === x && d.committed && d.deactivate(), _t();
+      });
+    } catch (v) {
+      a.reject(v), _t();
+    }
+    var d = (
+      /** @type {Batch} */
+      x
+    );
+    if (o) {
+      var c = i.is_rendered();
+      i.update_pending_count(1), d.increment(c), f.get(d)?.reject(pe), f.delete(d), f.set(d, a);
+    }
+    const u = (v, m = void 0) => {
+      if (d.activate(), m)
+        m !== pe && (l.f |= ce, tt(l, m));
+      else {
+        (l.f & ce) !== 0 && (l.f ^= ce), tt(l, v);
+        for (const [g, b] of f) {
+          if (f.delete(g), g === d) break;
+          b.reject(pe);
+        }
+      }
+      o && (i.update_pending_count(-1), d.decrement(c));
+    };
+    a.promise.then(u, (v) => u(null, v || "unknown"));
+  }), Ur(() => {
+    for (const a of f.values())
+      a.reject(pe);
+  }), new Promise((a) => {
+    function d(c) {
+      function u() {
+        c === s ? a(l) : d(s);
+      }
+      c.then(u, u);
+    }
+    d(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function kr(e) {
+  const t = /* @__PURE__ */ At(e);
+  return t.equals = tn, t;
+}
+function Cr(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      L(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function Mr(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & k) === 0)
+      return (t.f & ie) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function Rt(e) {
+  var t, n = y;
+  Z(Mr(e));
+  try {
+    e.f &= ~Ee, Cr(e), t = Cn(e);
+  } finally {
+    Z(n);
+  }
+  return t;
+}
+function dn(e) {
+  var t = Rt(e);
+  if (!e.equals(t) && (e.wv = On(), (!x?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    S(e, R);
+    return;
+  }
+  he || (H !== null ? (kt() || x?.is_fork) && H.set(e, t) : Nt(e));
+}
+function Pr(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      (t.teardown || t.ac) && (t.teardown?.(), t.ac?.abort(pe), t.teardown = nr, t.ac = null, Ve(t, 0), Mt(t));
+}
+function hn(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      t.teardown && Pe(t);
+}
+let pt = /* @__PURE__ */ new Set();
+const de = /* @__PURE__ */ new Map();
+let vn = !1;
+function Ye(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: en,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function M(e, t) {
+  const n = Ye(e);
+  return Gr(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function Dr(e, t = !1, n = !0) {
+  const r = Ye(e);
+  return t || (r.equals = tn), r;
+}
+function $(e, t, n = !1) {
+  w !== 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
+  (!z || (w.f & Dt) !== 0) && nn() && (w.f & (k | le | bt | Dt)) !== 0 && (B === null || !Oe.call(B, e)) && vr();
+  let r = n ? Ae(t) : t;
+  return tt(e, r);
+}
+function tt(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    he ? de.set(e, t) : de.set(e, n), e.v = t;
+    var r = se.ensure();
+    if (r.capture(e, n), (e.f & k) !== 0) {
+      const i = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & C) !== 0 && Rt(i), Nt(i);
+    }
+    e.wv = On(), _n(e, C), y !== null && (y.f & R) !== 0 && (y.f & (X | ve)) === 0 && (q === null ? Wr([e]) : q.push(e)), !r.is_fork && pt.size > 0 && !vn && Lr();
+  }
+  return t;
+}
+function Lr() {
+  vn = !1;
+  for (const e of pt)
+    (e.f & R) !== 0 && S(e, K), ze(e) && Pe(e);
+  pt.clear();
+}
+function qe(e) {
+  $(e, e.v + 1);
+}
+function _n(e, t) {
+  var n = e.reactions;
+  if (n !== null)
+    for (var r = n.length, i = 0; i < r; i++) {
+      var s = n[i], l = s.f, o = (l & C) === 0;
+      if (o && S(s, t), (l & k) !== 0) {
+        var f = (
+          /** @type {Derived} */
+          s
+        );
+        H?.delete(f), (l & Ee) === 0 && (l & U && (s.f |= Ee), _n(f, K));
+      } else o && ((l & le) !== 0 && te !== null && te.add(
+        /** @type {Effect} */
+        s
+      ), Y(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Ae(e) {
+  if (typeof e != "object" || e === null || Ie in e)
+    return e;
+  const t = tr(e);
+  if (t !== Qn && t !== er)
+    return e;
+  var n = /* @__PURE__ */ new Map(), r = zt(e), i = /* @__PURE__ */ M(0), s = ye, l = (o) => {
+    if (ye === s)
+      return o();
+    var f = w, a = ye;
+    V(null), jt(s);
+    var d = o();
+    return V(f), jt(a), d;
+  };
+  return r && n.set("length", /* @__PURE__ */ M(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(o, f, a) {
+        (!("value" in a) || a.configurable === !1 || a.enumerable === !1 || a.writable === !1) && dr();
+        var d = n.get(f);
+        return d === void 0 ? l(() => {
+          var c = /* @__PURE__ */ M(a.value);
+          return n.set(f, c), c;
+        }) : $(d, a.value, !0), !0;
+      },
+      deleteProperty(o, f) {
+        var a = n.get(f);
+        if (a === void 0) {
+          if (f in o) {
+            const d = l(() => /* @__PURE__ */ M(O));
+            n.set(f, d), qe(i);
+          }
+        } else
+          $(a, O), qe(i);
+        return !0;
+      },
+      get(o, f, a) {
+        if (f === Ie)
+          return e;
+        var d = n.get(f), c = f in o;
+        if (d === void 0 && (!c || we(o, f)?.writable) && (d = l(() => {
+          var v = Ae(c ? o[f] : O), m = /* @__PURE__ */ M(v);
+          return m;
+        }), n.set(f, d)), d !== void 0) {
+          var u = p(d);
+          return u === O ? void 0 : u;
+        }
+        return Reflect.get(o, f, a);
+      },
+      getOwnPropertyDescriptor(o, f) {
+        var a = Reflect.getOwnPropertyDescriptor(o, f);
+        if (a && "value" in a) {
+          var d = n.get(f);
+          d && (a.value = p(d));
+        } else if (a === void 0) {
+          var c = n.get(f), u = c?.v;
+          if (c !== void 0 && u !== O)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: u,
+              writable: !0
+            };
+        }
+        return a;
+      },
+      has(o, f) {
+        if (f === Ie)
+          return !0;
+        var a = n.get(f), d = a !== void 0 && a.v !== O || Reflect.has(o, f);
+        if (a !== void 0 || y !== null && (!d || we(o, f)?.writable)) {
+          a === void 0 && (a = l(() => {
+            var u = d ? Ae(o[f]) : O, v = /* @__PURE__ */ M(u);
+            return v;
+          }), n.set(f, a));
+          var c = p(a);
+          if (c === O)
+            return !1;
+        }
+        return d;
+      },
+      set(o, f, a, d) {
+        var c = n.get(f), u = f in o;
+        if (r && f === "length")
+          for (var v = a; v < /** @type {Source<number>} */
+          c.v; v += 1) {
+            var m = n.get(v + "");
+            m !== void 0 ? $(m, O) : v in o && (m = l(() => /* @__PURE__ */ M(O)), n.set(v + "", m));
+          }
+        if (c === void 0)
+          (!u || we(o, f)?.writable) && (c = l(() => /* @__PURE__ */ M(void 0)), $(c, Ae(a)), n.set(f, c));
+        else {
+          u = c.v !== O;
+          var g = l(() => Ae(a));
+          $(c, g);
+        }
+        var b = Reflect.getOwnPropertyDescriptor(o, f);
+        if (b?.set && b.set.call(d, a), !u) {
+          if (r && typeof f == "string") {
+            var I = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), N = Number(f);
+            Number.isInteger(N) && N >= I.v && $(I, N + 1);
+          }
+          qe(i);
+        }
+        return !0;
+      },
+      ownKeys(o) {
+        p(i);
+        var f = Reflect.ownKeys(o).filter((c) => {
+          var u = n.get(c);
+          return u === void 0 || u.v !== O;
+        });
+        for (var [a, d] of n)
+          d.v !== O && !(a in o) && f.push(a);
+        return f;
+      },
+      setPrototypeOf() {
+        hr();
+      }
+    }
+  );
+}
+var Ft, pn, mn, gn;
+function mt() {
+  if (Ft === void 0) {
+    Ft = window, pn = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    mn = we(t, "firstChild").get, gn = we(t, "nextSibling").get, Pt(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Pt(n) && (n.__t = void 0);
+  }
+}
+function xe(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function nt(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    mn.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function _e(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    gn.call(e)
+  );
+}
+function ae(e, t) {
+  if (!A)
+    return /* @__PURE__ */ nt(e);
+  var n = /* @__PURE__ */ nt(T);
+  if (n === null)
+    n = T.appendChild(xe());
+  else if (t && n.nodeType !== Et) {
+    var r = xe();
+    return n?.before(r), J(r), r;
+  }
+  return t && wn(
+    /** @type {Text} */
+    n
+  ), J(n), n;
+}
+function rt(e, t = 1, n = !1) {
+  let r = A ? T : e;
+  for (var i; t--; )
+    i = r, r = /** @type {TemplateNode} */
+    /* @__PURE__ */ _e(r);
+  if (!A)
+    return r;
+  if (n) {
+    if (r?.nodeType !== Et) {
+      var s = xe();
+      return r === null ? i?.after(s) : r.before(s), J(s), s;
+    }
+    wn(
+      /** @type {Text} */
+      r
+    );
+  }
+  return J(r), r;
+}
+function Fr(e) {
+  e.textContent = "";
+}
+function Ir() {
+  return !1;
+}
+function Ot(e, t, n) {
+  return (
+    /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
+    document.createElementNS(Jn, e, void 0)
+  );
+}
+function wn(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Et; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function $n(e) {
+  var t = w, n = y;
+  V(null), Z(null);
+  try {
+    return e();
+  } finally {
+    V(t), Z(n);
+  }
+}
+function jr(e) {
+  y === null && (w === null && fr(), or()), he && lr();
+}
+function qr(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function Q(e, t, n) {
+  var r = y;
+  r !== null && (r.f & W) !== 0 && (e |= W);
+  var i = {
+    ctx: F,
+    deps: null,
+    nodes: null,
+    f: e | C | U,
+    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 {
+      Pe(i);
+    } catch (o) {
+      throw L(i), o;
+    }
+  else t !== null && Y(i);
+  var s = i;
+  if (n && s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+  (s.f & Te) === 0 && (s = s.first, (e & le) !== 0 && (e & ke) !== 0 && s !== null && (s.f |= ke)), s !== null && (s.parent = r, r !== null && qr(s, r), w !== null && (w.f & k) !== 0 && (e & ve) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      w
+    );
+    (l.effects ??= []).push(s);
+  }
+  return i;
+}
+function kt() {
+  return w !== null && !z;
+}
+function Ur(e) {
+  const t = Q(ot, null, !1);
+  return S(t, R), t.teardown = e, t;
+}
+function G(e) {
+  jr();
+  var t = (
+    /** @type {Effect} */
+    y.f
+  ), n = !w && (t & X) !== 0 && (t & De) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      F
+    );
+    (r.e ??= []).push(e);
+  } else
+    return yn(e);
+}
+function yn(e) {
+  return Q(Be | ir, e, !1);
+}
+function Br(e) {
+  se.ensure();
+  const t = Q(ve | Te, e, !0);
+  return () => {
+    L(t);
+  };
+}
+function Vr(e) {
+  se.ensure();
+  const t = Q(ve | Te, e, !0);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? Ue(t, () => {
+      L(t), r(void 0);
+    }) : (L(t), r(void 0));
+  });
+}
+function bn(e) {
+  return Q(Be, e, !1);
+}
+function Hr(e) {
+  return Q(bt | Te, e, !0);
+}
+function Ct(e, t = 0) {
+  return Q(ot | t, e, !0);
+}
+function it(e, t = [], n = [], r = []) {
+  Ar(r, t, n, (i) => {
+    Q(ot, () => e(...i.map(p)), !0);
+  });
+}
+function En(e, t = 0) {
+  var n = Q(le | t, e, !0);
+  return n;
+}
+function ne(e) {
+  return Q(X | Te, e, !0);
+}
+function xn(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = he, r = w;
+    It(!0), V(null);
+    try {
+      t.call(null);
+    } finally {
+      It(n), V(r);
+    }
+  }
+}
+function Mt(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const i = n.ac;
+    i !== null && $n(() => {
+      i.abort(pe);
+    });
+    var r = n.next;
+    (n.f & ve) !== 0 ? n.parent = null : L(n, t), n = r;
+  }
+}
+function Yr(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & X) === 0 && L(t), t = n;
+  }
+}
+function L(e, t = !0) {
+  var n = !1;
+  (t || (e.f & Jt) !== 0) && e.nodes !== null && e.nodes.end !== null && (zr(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), Mt(e, t && !n), Ve(e, 0), S(e, ie);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const s of r)
+      s.stop();
+  xn(e);
+  var i = e.parent;
+  i !== null && i.first !== null && Tn(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function zr(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ _e(e);
+    e.remove(), e = n;
+  }
+}
+function Tn(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 Ue(e, t, n = !0) {
+  var r = [];
+  Sn(e, r, !0);
+  var i = () => {
+    n && L(e), t && t();
+  }, s = r.length;
+  if (s > 0) {
+    var l = () => --s || i();
+    for (var o of r)
+      o.out(l);
+  } else
+    i();
+}
+function Sn(e, t, n) {
+  if ((e.f & W) === 0) {
+    e.f ^= W;
+    var r = e.nodes && e.nodes.t;
+    if (r !== null)
+      for (const o of r)
+        (o.is_global || n) && t.push(o);
+    for (var i = e.first; i !== null; ) {
+      var s = i.next, l = (i.f & ke) !== 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 & X) !== 0 && (e.f & le) !== 0;
+      Sn(i, t, l ? n : !1), i = s;
+    }
+  }
+}
+function Kr(e) {
+  Nn(e, !0);
+}
+function Nn(e, t) {
+  if ((e.f & W) !== 0) {
+    e.f ^= W, (e.f & R) === 0 && (S(e, C), Y(e));
+    for (var n = e.first; n !== null; ) {
+      var r = n.next, i = (n.f & ke) !== 0 || (n.f & X) !== 0;
+      Nn(n, i ? t : !1), n = r;
+    }
+    var s = e.nodes && e.nodes.t;
+    if (s !== null)
+      for (const l of s)
+        (l.is_global || t) && l.in();
+  }
+}
+function An(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, r = e.nodes.end; n !== null; ) {
+      var i = n === r ? null : /* @__PURE__ */ _e(n);
+      t.append(n), n = i;
+    }
+}
+let Ze = !1, he = !1;
+function It(e) {
+  he = e;
+}
+let w = null, z = !1;
+function V(e) {
+  w = e;
+}
+let y = null;
+function Z(e) {
+  y = e;
+}
+let B = null;
+function Gr(e) {
+  w !== null && (B === null ? B = [e] : B.push(e));
+}
+let D = null, j = 0, q = null;
+function Wr(e) {
+  q = e;
+}
+let Rn = 1, ge = 0, ye = ge;
+function jt(e) {
+  ye = e;
+}
+function On() {
+  return ++Rn;
+}
+function ze(e) {
+  var t = e.f;
+  if ((t & C) !== 0)
+    return !0;
+  if (t & k && (e.f &= ~Ee), (t & K) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = n.length, i = 0; i < r; i++) {
+      var s = n[i];
+      if (ze(
+        /** @type {Derived} */
+        s
+      ) && dn(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & U) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    H === null && S(e, R);
+  }
+  return !1;
+}
+function kn(e, t, n = !0) {
+  var r = e.reactions;
+  if (r !== null && !(B !== null && Oe.call(B, e)))
+    for (var i = 0; i < r.length; i++) {
+      var s = r[i];
+      (s.f & k) !== 0 ? kn(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (n ? S(s, C) : (s.f & R) !== 0 && S(s, K), Y(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Cn(e) {
+  var t = D, n = j, r = q, i = w, s = B, l = F, o = z, f = ye, a = e.f;
+  D = /** @type {null | Value[]} */
+  null, j = 0, q = null, w = (a & (X | ve)) === 0 ? e : null, B = null, Ce(e.ctx), z = !1, ye = ++ge, e.ac !== null && ($n(() => {
+    e.ac.abort(pe);
+  }), e.ac = null);
+  try {
+    e.f |= ht;
+    var d = (
+      /** @type {Function} */
+      e.fn
+    ), c = d();
+    e.f |= De;
+    var u = e.deps, v = x?.is_fork;
+    if (D !== null) {
+      var m;
+      if (v || Ve(e, j), u !== null && j > 0)
+        for (u.length = j + D.length, m = 0; m < D.length; m++)
+          u[j + m] = D[m];
+      else
+        e.deps = u = D;
+      if (kt() && (e.f & U) !== 0)
+        for (m = j; m < u.length; m++)
+          (u[m].reactions ??= []).push(e);
+    } else !v && u !== null && j < u.length && (Ve(e, j), u.length = j);
+    if (nn() && q !== null && !z && u !== null && (e.f & (k | K | C)) === 0)
+      for (m = 0; m < /** @type {Source[]} */
+      q.length; m++)
+        kn(
+          q[m],
+          /** @type {Effect} */
+          e
+        );
+    if (i !== null && i !== e) {
+      if (ge++, i.deps !== null)
+        for (let g = 0; g < n; g += 1)
+          i.deps[g].rv = ge;
+      if (t !== null)
+        for (const g of t)
+          g.rv = ge;
+      q !== null && (r === null ? r = q : r.push(.../** @type {Source[]} */
+      q));
+    }
+    return (e.f & ce) !== 0 && (e.f ^= ce), c;
+  } catch (g) {
+    return sn(g);
+  } finally {
+    e.f ^= ht, D = t, j = n, q = r, w = i, B = s, Ce(l), z = o, ye = f;
+  }
+}
+function Jr(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var r = Zn.call(n, e);
+    if (r !== -1) {
+      var i = n.length - 1;
+      i === 0 ? n = t.reactions = null : (n[r] = n[i], n.pop());
+    }
+  }
+  if (n === null && (t.f & k) !== 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
+  (D === null || !Oe.call(D, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & U) !== 0 && (s.f ^= U, s.f &= ~Ee), Nt(s), Pr(s), Ve(s, 0);
+  }
+}
+function Ve(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var r = t; r < n.length; r++)
+      Jr(e, n[r]);
+}
+function Pe(e) {
+  var t = e.f;
+  if ((t & ie) === 0) {
+    S(e, R);
+    var n = y, r = Ze;
+    y = e, Ze = !0;
+    try {
+      (t & (le | Gt)) !== 0 ? Yr(e) : Mt(e), xn(e);
+      var i = Cn(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = Rn;
+      var s;
+      dt && $r && (e.f & C) !== 0 && e.deps;
+    } finally {
+      Ze = r, y = n;
+    }
+  }
+}
+function p(e) {
+  var t = e.f, n = (t & k) !== 0;
+  if (w !== null && !z) {
+    var r = y !== null && (y.f & ie) !== 0;
+    if (!r && (B === null || !Oe.call(B, e))) {
+      var i = w.deps;
+      if ((w.f & ht) !== 0)
+        e.rv < ge && (e.rv = ge, D === null && i !== null && i[j] === e ? j++ : D === null ? D = [e] : D.push(e));
+      else {
+        (w.deps ??= []).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [w] : Oe.call(s, w) || s.push(w);
+      }
+    }
+  }
+  if (he && de.has(e))
+    return de.get(e);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (he) {
+      var o = l.v;
+      return ((l.f & R) === 0 && l.reactions !== null || Pn(l)) && (o = Rt(l)), de.set(l, o), o;
+    }
+    var f = (l.f & U) === 0 && !z && w !== null && (Ze || (w.f & U) !== 0), a = (l.f & De) === 0;
+    ze(l) && (f && (l.f |= U), dn(l)), f && !a && (hn(l), Mn(l));
+  }
+  if (H?.has(e))
+    return H.get(e);
+  if ((e.f & ce) !== 0)
+    throw e.v;
+  return e.v;
+}
+function Mn(e) {
+  if (e.f |= U, e.deps !== null)
+    for (const t of e.deps)
+      (t.reactions ??= []).push(e), (t.f & k) !== 0 && (t.f & U) === 0 && (hn(
+        /** @type {Derived} */
+        t
+      ), Mn(
+        /** @type {Derived} */
+        t
+      ));
+}
+function Pn(e) {
+  if (e.v === O) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (de.has(t) || (t.f & k) !== 0 && Pn(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function ut(e) {
+  var t = z;
+  try {
+    return z = !0, e();
+  } finally {
+    z = t;
+  }
+}
+const Zr = /* @__PURE__ */ new Set(), qt = /* @__PURE__ */ new Set();
+let Ut = null;
+function Bt(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), r = e.type, i = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    i[0] || e.target
+  );
+  Ut = e;
+  var l = 0, o = Ut === e && e.__root;
+  if (o) {
+    var f = i.indexOf(o);
+    if (f !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var a = i.indexOf(t);
+    if (a === -1)
+      return;
+    f <= a && (l = f);
+  }
+  if (s = /** @type {Element} */
+  i[l] || e.target, s !== t) {
+    et(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var d = w, c = y;
+    V(null), Z(null);
+    try {
+      for (var u, v = []; s !== null; ) {
+        var m = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var g = s["__" + r];
+          g != null && (!/** @type {any} */
+          s.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          e.target === s) && g.call(s, e);
+        } catch (b) {
+          u ? v.push(b) : u = b;
+        }
+        if (e.cancelBubble || m === t || m === null)
+          break;
+        s = m;
+      }
+      if (u) {
+        for (let b of v)
+          queueMicrotask(() => {
+            throw b;
+          });
+        throw u;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, V(d), Z(c);
+    }
+  }
+}
+const Xr = /* @__PURE__ */ globalThis?.window?.trustedTypes?.createPolicy(
+  "svelte-trusted-html",
+  {
+    /** @param {string} html */
+    createHTML: (e) => e
+  }
+);
+function Qr(e) {
+  return (
+    /** @type {string} */
+    Xr?.createHTML(e) ?? e
+  );
+}
+function ei(e, t = !1) {
+  var n = Ot("template");
+  return e = e.replaceAll("<!>", "<!---->"), n.innerHTML = t ? Qr(e) : e, n.content;
+}
+function gt(e, t) {
+  var n = (
+    /** @type {Effect} */
+    y
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Le(e, t) {
+  var n = (t & Wn) !== 0, r, i = !e.startsWith("<!>");
+  return () => {
+    if (A)
+      return gt(T, null), T;
+    r === void 0 && (r = ei(i ? e : "<!>" + e, !0), r = /** @type {TemplateNode} */
+    /* @__PURE__ */ nt(r));
+    var s = (
+      /** @type {TemplateNode} */
+      n || pn ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return gt(s, s), s;
+  };
+}
+function be(e, t) {
+  if (A) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      y
+    );
+    ((n.f & De) === 0 || n.nodes.end === null) && (n.nodes.end = T), xt();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const ti = ["touchstart", "touchmove"];
+function ni(e) {
+  return ti.includes(e);
+}
+function st(e, t) {
+  var n = t == null ? "" : typeof t == "object" ? t + "" : t;
+  n !== (e.__t ??= e.nodeValue) && (e.__t = n, e.nodeValue = n + "");
+}
+function Dn(e, t) {
+  return Ln(e, t);
+}
+function ri(e, t) {
+  mt(), t.intro = t.intro ?? !1;
+  const n = t.target, r = A, i = T;
+  try {
+    for (var s = /* @__PURE__ */ nt(n); s && (s.nodeType !== He || /** @type {Comment} */
+    s.data !== $t); )
+      s = /* @__PURE__ */ _e(s);
+    if (!s)
+      throw Re;
+    Ne(!0), J(
+      /** @type {Comment} */
+      s
+    );
+    const l = Ln(e, { ...t, anchor: s });
+    return Ne(!1), /**  @type {Exports} */
+    l;
+  } catch (l) {
+    if (l instanceof Error && l.message.split(`
+`).some((o) => o.startsWith("https://svelte.dev/e/")))
+      throw l;
+    return l !== Re && console.warn("Failed to hydrate: ", l), t.recover === !1 && ur(), mt(), Fr(n), Ne(!1), Dn(e, t);
+  } finally {
+    Ne(r), J(i);
+  }
+}
+const Ge = /* @__PURE__ */ new Map();
+function Ln(e, { target: t, anchor: n, props: r = {}, events: i, context: s, intro: l = !0 }) {
+  mt();
+  var o = /* @__PURE__ */ new Set(), f = (c) => {
+    for (var u = 0; u < c.length; u++) {
+      var v = c[u];
+      if (!o.has(v)) {
+        o.add(v);
+        var m = ni(v);
+        for (const I of [t, document]) {
+          var g = Ge.get(I);
+          g === void 0 && (g = /* @__PURE__ */ new Map(), Ge.set(I, g));
+          var b = g.get(v);
+          b === void 0 ? (I.addEventListener(v, Bt, { passive: m }), g.set(v, 1)) : g.set(v, b + 1);
+        }
+      }
+    }
+  };
+  f(Xn(Zr)), qt.add(f);
+  var a = void 0, d = Vr(() => {
+    var c = n ?? t.appendChild(xe());
+    return Sr(
+      /** @type {TemplateNode} */
+      c,
+      {
+        pending: () => {
+        }
+      },
+      (u) => {
+        Tt({});
+        var v = (
+          /** @type {ComponentContext} */
+          F
+        );
+        if (s && (v.c = s), i && (r.$$events = i), A && gt(
+          /** @type {TemplateNode} */
+          u,
+          null
+        ), a = e(u, r) || {}, A && (y.nodes.end = T, T === null || T.nodeType !== He || /** @type {Comment} */
+        T.data !== Yt))
+          throw ft(), Re;
+        St();
+      }
+    ), () => {
+      for (var u of o)
+        for (const g of [t, document]) {
+          var v = (
+            /** @type {Map<string, number>} */
+            Ge.get(g)
+          ), m = (
+            /** @type {number} */
+            v.get(u)
+          );
+          --m == 0 ? (g.removeEventListener(u, Bt), v.delete(u), v.size === 0 && Ge.delete(g)) : v.set(u, m);
+        }
+      qt.delete(f), c !== n && c.parentNode?.removeChild(c);
+    };
+  });
+  return wt.set(a, d), a;
+}
+let wt = /* @__PURE__ */ new WeakMap();
+function ii(e, t) {
+  const n = wt.get(e);
+  return n ? (wt.delete(e), n(t)) : Promise.resolve();
+}
+class si {
+  /** @type {TemplateNode} */
+  anchor;
+  /** @type {Map<Batch, Key>} */
+  #e = /* @__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>}
+   */
+  #t = /* @__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>}
+   */
+  #n = /* @__PURE__ */ new Map();
+  /**
+   * Keys of effects that are currently outroing
+   * @type {Set<Key>}
+   */
+  #l = /* @__PURE__ */ new Set();
+  /**
+   * Whether to pause (i.e. outro) on change, or destroy immediately.
+   * This is necessary for `<svelte:element>`
+   */
+  #o = !0;
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    this.anchor = t, this.#o = n;
+  }
+  #i = () => {
+    var t = (
+      /** @type {Batch} */
+      x
+    );
+    if (this.#e.has(t)) {
+      var n = (
+        /** @type {Key} */
+        this.#e.get(t)
+      ), r = this.#t.get(n);
+      if (r)
+        Kr(r), this.#l.delete(n);
+      else {
+        var i = this.#n.get(n);
+        i && (this.#t.set(n, i.effect), this.#n.delete(n), i.fragment.lastChild.remove(), this.anchor.before(i.fragment), r = i.effect);
+      }
+      for (const [s, l] of this.#e) {
+        if (this.#e.delete(s), s === t)
+          break;
+        const o = this.#n.get(l);
+        o && (L(o.effect), this.#n.delete(l));
+      }
+      for (const [s, l] of this.#t) {
+        if (s === n || this.#l.has(s)) continue;
+        const o = () => {
+          if (Array.from(this.#e.values()).includes(s)) {
+            var a = document.createDocumentFragment();
+            An(l, a), a.append(xe()), this.#n.set(s, { effect: l, fragment: a });
+          } else
+            L(l);
+          this.#l.delete(s), this.#t.delete(s);
+        };
+        this.#o || !r ? (this.#l.add(s), Ue(l, o, !1)) : o();
+      }
+    }
+  };
+  /**
+   * @param {Batch} batch
+   */
+  #r = (t) => {
+    this.#e.delete(t);
+    const n = Array.from(this.#e.values());
+    for (const [r, i] of this.#n)
+      n.includes(r) || (L(i.effect), this.#n.delete(r));
+  };
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var r = (
+      /** @type {Batch} */
+      x
+    ), i = Ir();
+    if (n && !this.#t.has(t) && !this.#n.has(t))
+      if (i) {
+        var s = document.createDocumentFragment(), l = xe();
+        s.append(l), this.#n.set(t, {
+          effect: ne(() => n(l)),
+          fragment: s
+        });
+      } else
+        this.#t.set(
+          t,
+          ne(() => n(this.anchor))
+        );
+    if (this.#e.set(r, t), i) {
+      for (const [o, f] of this.#t)
+        o === t ? r.unskip_effect(f) : r.skip_effect(f);
+      for (const [o, f] of this.#n)
+        o === t ? r.unskip_effect(f.effect) : r.skip_effect(f.effect);
+      r.oncommit(this.#i), r.ondiscard(this.#r);
+    } else
+      A && (this.anchor = T), this.#i();
+  }
+}
+function Fn(e) {
+  F === null && Xt(), G(() => {
+    const t = ut(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function li(e, t, { bubbles: n = !1, cancelable: r = !1 } = {}) {
+  return new CustomEvent(e, { detail: t, bubbles: n, cancelable: r });
+}
+function oi() {
+  const e = F;
+  return e === null && Xt(), (t, n, r) => {
+    const i = (
+      /** @type {Record<string, Function | Function[]>} */
+      e.s.$$events?.[
+        /** @type {string} */
+        t
+      ]
+    );
+    if (i) {
+      const s = zt(i) ? i.slice() : [i], l = li(
+        /** @type {string} */
+        t,
+        n,
+        r
+      );
+      for (const o of s)
+        o.call(e.x, l);
+      return !l.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function lt(e, t, n = !1) {
+  A && xt();
+  var r = new si(e), i = n ? ke : 0;
+  function s(l, o) {
+    if (A) {
+      const d = gr(e);
+      var f;
+      if (d === $t ? f = 0 : d === yt ? f = !1 : f = parseInt(d.substring(1)), l !== f) {
+        var a = Qt();
+        J(a), r.anchor = a, Ne(!1), r.ensure(l, o), Ne(!0);
+        return;
+      }
+    }
+    r.ensure(l, o);
+  }
+  En(() => {
+    var l = !1;
+    t((o, f = 0) => {
+      l = !0, s(f, o);
+    }), l || s(!1, null);
+  }, i);
+}
+function In(e, t) {
+  bn(() => {
+    var n = e.getRootNode(), r = (
+      /** @type {ShadowRoot} */
+      n.host ? (
+        /** @type {ShadowRoot} */
+        n
+      ) : (
+        /** @type {Document} */
+        n.head ?? /** @type {Document} */
+        n.ownerDocument.head
+      )
+    );
+    if (!r.querySelector("#" + t.hash)) {
+      const i = Ot("style");
+      i.id = t.hash, i.textContent = t.code, r.appendChild(i);
+    }
+  });
+}
+function Vt(e, t) {
+  return e === t || e?.[Ie] === t;
+}
+function jn(e = {}, t, n, r) {
+  return bn(() => {
+    var i, s;
+    return Ct(() => {
+      i = s, s = [], ut(() => {
+        e !== n(...s) && (t(e, ...s), i && Vt(n(...i), e) && t(null, ...i));
+      });
+    }), () => {
+      $e(() => {
+        s && Vt(n(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+let We = !1;
+function fi(e) {
+  var t = We;
+  try {
+    return We = !1, [e(), We];
+  } finally {
+    We = t;
+  }
+}
+function ue(e, t, n, r) {
+  var i = (n & Kn) !== 0, s = (n & Gn) !== 0, l = (
+    /** @type {V} */
+    r
+  ), o = !0, f = () => (o && (o = !1, l = s ? ut(
+    /** @type {() => V} */
+    r
+  ) : (
+    /** @type {V} */
+    r
+  )), l), a;
+  if (i) {
+    var d = Ie in e || Zt in e;
+    a = we(e, t)?.set ?? (d && t in e ? (N) => e[t] = N : void 0);
+  }
+  var c, u = !1;
+  i ? [c, u] = fi(() => (
+    /** @type {V} */
+    e[t]
+  )) : c = /** @type {V} */
+  e[t], c === void 0 && r !== void 0 && (c = f(), a && (cr(), a(c)));
+  var v;
+  if (v = () => {
+    var N = (
+      /** @type {V} */
+      e[t]
+    );
+    return N === void 0 ? f() : (o = !0, N);
+  }, (n & zn) === 0)
+    return v;
+  if (a) {
+    var m = e.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(N, oe) {
+        return arguments.length > 0 ? ((!oe || m || u) && a(oe ? v() : N), N) : v();
+      })
+    );
+  }
+  var g = !1, b = ((n & Yn) !== 0 ? At : kr)(() => (g = !1, v()));
+  i && p(b);
+  var I = (
+    /** @type {Effect} */
+    y
+  );
+  return (
+    /** @type {() => V} */
+    (function(N, oe) {
+      if (arguments.length > 0) {
+        const _ = oe ? p(b) : i ? Ae(N) : N;
+        return $(b, _), g = !0, l !== void 0 && (l = _), N;
+      }
+      return he && g || (I.f & ie) !== 0 ? b.v : p(b);
+    })
+  );
+}
+function ai(e) {
+  return new ui(e);
+}
+class ui {
+  /** @type {any} */
+  #e;
+  /** @type {Record<string, any>} */
+  #t;
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    var n = /* @__PURE__ */ new Map(), r = (s, l) => {
+      var o = /* @__PURE__ */ Dr(l, !1, !1);
+      return n.set(s, o), o;
+    };
+    const i = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return p(n.get(l) ?? r(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === Zt ? !0 : (p(n.get(l) ?? r(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, o) {
+          return $(n.get(l) ?? r(l, o), o), Reflect.set(s, l, o);
+        }
+      }
+    );
+    this.#t = (t.hydrate ? ri : Dn)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: i,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover
+    }), (!t?.props?.$$host || t.sync === !1) && re(), this.#e = i.$$events;
+    for (const s of Object.keys(this.#t))
+      s === "$set" || s === "$destroy" || s === "$on" || et(this, s, {
+        get() {
+          return this.#t[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          this.#t[s] = l;
+        },
+        enumerable: !0
+      });
+    this.#t.$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(i, s);
+    }, this.#t.$destroy = () => {
+      ii(this.#t);
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    this.#t.$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, n) {
+    this.#e[t] = this.#e[t] || [];
+    const r = (...i) => n.call(this, ...i);
+    return this.#e[t].push(r), () => {
+      this.#e[t] = this.#e[t].filter(
+        /** @param {any} fn */
+        (i) => i !== r
+      );
+    };
+  }
+  $destroy() {
+    this.#t.$destroy();
+  }
+}
+let qn;
+typeof HTMLElement == "function" && (qn = class extends HTMLElement {
+  /** The Svelte component constructor */
+  $$ctor;
+  /** Slots */
+  $$s;
+  /** @type {any} The Svelte component instance */
+  $$c;
+  /** Whether or not the custom element is connected */
+  $$cn = !1;
+  /** @type {Record<string, any>} Component props data */
+  $$d = {};
+  /** `true` if currently in the process of reflecting component props back to attributes */
+  $$r = !1;
+  /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+  $$p_d = {};
+  /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+  $$l = {};
+  /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+  $$l_u = /* @__PURE__ */ new Map();
+  /** @type {any} The managed render effect for reflecting attributes */
+  $$me;
+  /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+  $$shadowRoot = null;
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(e, t, n) {
+    super(), this.$$ctor = e, this.$$s = t, n && (this.$$shadowRoot = this.attachShadow(n));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(e, t, n) {
+    if (this.$$l[e] = this.$$l[e] || [], this.$$l[e].push(t), this.$$c) {
+      const r = this.$$c.$on(e, t);
+      this.$$l_u.set(t, r);
+    }
+    super.addEventListener(e, t, n);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(e, t, n) {
+    if (super.removeEventListener(e, t, n), this.$$c) {
+      const r = this.$$l_u.get(t);
+      r && (r(), this.$$l_u.delete(t));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let e = function(r) {
+        return (i) => {
+          const s = Ot("slot");
+          r !== "default" && (s.name = r), be(i, s);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const t = {}, n = ci(this);
+      for (const r of this.$$s)
+        r in n && (r === "default" && !this.$$d.children ? (this.$$d.children = e(r), t.default = !0) : t[r] = e(r));
+      for (const r of this.attributes) {
+        const i = this.$$g_p(r.name);
+        i in this.$$d || (this.$$d[i] = Xe(i, r.value, this.$$p_d, "toProp"));
+      }
+      for (const r in this.$$p_d)
+        !(r in this.$$d) && this[r] !== void 0 && (this.$$d[r] = this[r], delete this[r]);
+      this.$$c = ai({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: t,
+          $$host: this
+        }
+      }), this.$$me = Br(() => {
+        Ct(() => {
+          this.$$r = !0;
+          for (const r of Qe(this.$$c)) {
+            if (!this.$$p_d[r]?.reflect) continue;
+            this.$$d[r] = this.$$c[r];
+            const i = Xe(
+              r,
+              this.$$d[r],
+              this.$$p_d,
+              "toAttribute"
+            );
+            i == null ? this.removeAttribute(this.$$p_d[r].attribute || r) : this.setAttribute(this.$$p_d[r].attribute || r, i);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const r in this.$$l)
+        for (const i of this.$$l[r]) {
+          const s = this.$$c.$on(r, i);
+          this.$$l_u.set(i, s);
+        }
+      this.$$l = {};
+    }
+  }
+  // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+  // and setting attributes through setAttribute etc, this is helpful
+  /**
+   * @param {string} attr
+   * @param {string} _oldValue
+   * @param {string} newValue
+   */
+  attributeChangedCallback(e, t, n) {
+    this.$$r || (e = this.$$g_p(e), this.$$d[e] = Xe(e, n, this.$$p_d, "toProp"), this.$$c?.$set({ [e]: this.$$d[e] }));
+  }
+  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(e) {
+    return Qe(this.$$p_d).find(
+      (t) => this.$$p_d[t].attribute === e || !this.$$p_d[t].attribute && t.toLowerCase() === e
+    ) || e;
+  }
+});
+function Xe(e, t, n, r) {
+  const i = n[e]?.type;
+  if (t = i === "Boolean" && typeof t != "boolean" ? t != null : t, !r || !n[e])
+    return t;
+  if (r === "toAttribute")
+    switch (i) {
+      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 (i) {
+      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 ci(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function Un(e, t, n, r, i, s) {
+  let l = class extends qn {
+    constructor() {
+      super(e, n, i), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Qe(t).map(
+        (o) => (t[o].attribute || o).toLowerCase()
+      );
+    }
+  };
+  return Qe(t).forEach((o) => {
+    et(l.prototype, o, {
+      get() {
+        return this.$$c && o in this.$$c ? this.$$c[o] : this.$$d[o];
+      },
+      set(f) {
+        f = Xe(o, f, t), this.$$d[o] = f;
+        var a = this.$$c;
+        if (a) {
+          var d = we(a, o)?.get;
+          d ? a[o] = f : a.$set({ [o]: f });
+        }
+      }
+    });
+  }), r.forEach((o) => {
+    et(l.prototype, o, {
+      get() {
+        return this.$$c?.[o];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+let Je = null;
+async function Bn(e, t, n, r = !1, i = !1) {
+  if (customElements.get(t)) {
+    r && console.log(`[element-loader] Element ${t} already registered`);
+    return;
+  }
+  r && console.log(`[element-loader] Loading element ${e} (cdnUrl: ${n || "local"})`);
+  try {
+    let s;
+    if (!n || n === "") {
+      if (!Je)
+        try {
+          Je = await import("$lib/element-imports");
+        } catch {
+          console.warn("[element-loader] Static imports module not found, trying direct import");
+        }
+      Je?.hasElementModule(e) ? s = await Je.getElementModule(e) : s = await import(
+        /* @vite-ignore */
+        e
+      );
+    } else
+      s = await import(`${n}/${e}`);
+    const l = s.default || s.Element;
+    if (!l)
+      throw new Error(`No default or Element export found for ${e}`);
+    if (typeof l != "function")
+      throw new Error(`Export from ${e} is not a constructor function`);
+    customElements.define(t, l), r && console.log(`[element-loader] ✓ Registered custom element: ${t}`);
+  } catch (s) {
+    const l = s;
+    if (!i)
+      throw console.error(`[element-loader] Failed to load element ${e}:`, l), new Error(`Failed to load element ${e}: ${l.message}`);
+    r && console.log(`[element-loader] Optional element ${e} not available`);
+  }
+}
+var di = /* @__PURE__ */ Le('<div class="loading svelte-156cx1g"> </div>'), hi = /* @__PURE__ */ Le('<div class="error svelte-156cx1g"><strong>Error loading element:</strong> <pre class="svelte-156cx1g"> </pre></div>'), vi = /* @__PURE__ */ Le('<div class="esm-element-player svelte-156cx1g"><!> <!></div>');
+const _i = {
+  hash: "svelte-156cx1g",
+  code: ".esm-element-player.svelte-156cx1g {width:100%;min-height:100px;}.loading.svelte-156cx1g {padding:2rem;text-align:center;color:#666;font-style:italic;}.error.svelte-156cx1g {padding:1rem;background:#fee;border:1px solid #fcc;border-radius:4px;color:#c00;}.error.svelte-156cx1g pre:where(.svelte-156cx1g) {margin:0.5rem 0 0;padding:0.5rem;background:#fff;border-radius:4px;font-size:0.875rem;overflow-x:auto;}"
+};
+function pi(e, t) {
+  Tt(t, !0), In(e, _i);
+  let n = ue(t, "elementName", 7, ""), r = ue(t, "cdnUrl", 7, ""), i = ue(t, "model", 15), s = ue(t, "session", 15);
+  const l = oi();
+  let o, f = /* @__PURE__ */ M(null), a = /* @__PURE__ */ M(null), d = /* @__PURE__ */ M(null), c = /* @__PURE__ */ M(!0), u = null, v = null;
+  G(() => {
+    console.log("[esm-player] Element name changed:", n()), n() ? m() : ($(d, "No element name provided"), $(c, !1));
+  }), G(() => {
+    if (p(f) && i() !== void 0)
+      try {
+        p(f).model = i();
+      } catch (h) {
+        console.error("[esm-player] Error setting model:", h);
+      }
+  }), Fn(() => {
+    if (u = Ht(), typeof window < "u" && (window["@pie-lib/math-rendering"] = { renderMath: u }), u && typeof window < "u") {
+      const h = document.createElement("div");
+      u(h).catch(() => {
+      });
+    }
+    return () => {
+      v && v.disconnect();
+    };
+  }), G(() => {
+    if (o && u) {
+      v && v.disconnect();
+      let h = null;
+      v = new MutationObserver(() => {
+        h && clearTimeout(h), h = window.setTimeout(
+          () => {
+            u && o && u(o).catch((E) => {
+              console.error("[esm-player] Math rendering error:", E);
+            });
+          },
+          100
+        );
+      }), v.observe(o, {
+        childList: !0,
+        subtree: !0,
+        attributes: !1,
+        characterData: !1
+      }), u(o).catch((E) => {
+        console.error("[esm-player] Initial math rendering error:", E);
+      });
+    }
+  }), G(() => {
+    o && u && i() && requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        u && o && u(o).catch((h) => {
+          console.error("[esm-player] Math rendering error:", h);
+        });
+      });
+    });
+  });
+  async function m() {
+    if (!n()) {
+      $(d, "No element name provided"), $(c, !1);
+      return;
+    }
+    try {
+      $(c, !0), $(d, null);
+      const h = `@pie-element/${n()}`;
+      console.log(`[esm-player] Loading element: ${h}`);
+      const E = `${n()}-element`, ee = new Promise((ct, Fe) => setTimeout(() => Fe(new Error(`Timeout loading ${h} (>10s). Check /@pie- routes, Vite server, and network.`)), 1e4));
+      await Promise.race([
+        Bn(h, E, r()),
+        ee
+      ]), await customElements.whenDefined(E), p(f) && p(a) === E ? console.log(`[esm-player] Reusing element instance: ${E}`) : (p(f) && p(f).remove(), console.log(`[esm-player] Creating element instance: ${E}`), $(f, document.createElement(E), !0), $(a, E)), i() !== void 0 && (p(f).model = i());
+      const Se = s() ?? p(f).session;
+      Se !== void 0 && (p(f).session = Se), p(f).addEventListener("session-changed", (ct) => {
+        ct.stopPropagation();
+        const Fe = ct, Vn = p(f).session;
+        console.log("[esm-player] Session changed:", Fe.detail), l("session-changed", {
+          session: Vn,
+          complete: Fe.detail?.complete,
+          component: Fe.detail?.component
+        });
+      }), o && p(f).parentElement !== o && (o.innerHTML = "", o.appendChild(p(f))), console.log(`[esm-player] Element ${n()} loaded successfully`), $(c, !1);
+    } catch (h) {
+      console.error(`[esm-player] Failed to load element ${n()}:`, h), $(d, h instanceof Error ? h.message : String(h), !0), $(c, !1);
+    }
+  }
+  var g = {
+    get elementName() {
+      return n();
+    },
+    set elementName(h = "") {
+      n(h), re();
+    },
+    get cdnUrl() {
+      return r();
+    },
+    set cdnUrl(h = "") {
+      r(h), re();
+    },
+    get model() {
+      return i();
+    },
+    set model(h) {
+      i(h), re();
+    },
+    get session() {
+      return s();
+    },
+    set session(h) {
+      s(h), re();
+    }
+  }, b = vi(), I = ae(b);
+  {
+    var N = (h) => {
+      var E = di(), ee = ae(E);
+      fe(E), it(() => st(ee, `Loading ${n() ?? ""}...`)), be(h, E);
+    };
+    lt(I, (h) => {
+      p(c) && h(N);
+    });
+  }
+  var oe = rt(I, 2);
+  {
+    var _ = (h) => {
+      var E = hi(), ee = rt(ae(E), 2), Se = ae(ee, !0);
+      fe(ee), fe(E), it(() => st(Se, p(d))), be(h, E);
+    };
+    lt(oe, (h) => {
+      p(d) && h(_);
+    });
+  }
+  return fe(b), jn(b, (h) => o = h, () => o), be(e, b), St(g);
+}
+customElements.define("pie-esm-element-player", Un(
+  pi,
+  {
+    elementName: { attribute: "element-name", reflect: !0, type: "String" },
+    cdnUrl: { attribute: "cdn-url", reflect: !0, type: "String" },
+    model: { type: "Object" },
+    session: { type: "Object" }
+  },
+  [],
+  []
+));
+var mi = /* @__PURE__ */ Le('<div class="loading svelte-xidvdr"> </div>'), gi = /* @__PURE__ */ Le('<div class="error svelte-xidvdr"><strong>Error loading print element:</strong> <pre class="svelte-xidvdr"> </pre></div>'), wi = /* @__PURE__ */ Le('<div class="esm-print-player svelte-xidvdr"><!> <!></div>');
+const $i = {
+  hash: "svelte-xidvdr",
+  code: ".esm-print-player.svelte-xidvdr {width:100%;min-height:100px;}.loading.svelte-xidvdr {padding:2rem;text-align:center;color:#666;font-style:italic;}.error.svelte-xidvdr {padding:1rem;background:#fee;border:1px solid #fcc;border-radius:4px;color:#c00;}.error.svelte-xidvdr pre:where(.svelte-xidvdr) {margin:0.5rem 0 0;padding:0.5rem;background:#fff;border-radius:4px;font-size:0.875rem;overflow-x:auto;}"
+};
+function yi(e, t) {
+  Tt(t, !0), In(e, $i);
+  let n = ue(t, "elementName", 7, ""), r = ue(t, "cdnUrl", 7, ""), i = ue(t, "model", 15), s = ue(t, "role", 7, "student"), l, o = /* @__PURE__ */ M(null), f = /* @__PURE__ */ M(null), a = /* @__PURE__ */ M(null), d = /* @__PURE__ */ M(!0), c = null, u = null;
+  G(() => {
+    console.log("[esm-print-player] Element name changed:", n()), n() ? v() : ($(a, "No element name provided"), $(d, !1));
+  }), G(() => {
+    if (p(o) && i() !== void 0)
+      try {
+        p(o).model = i();
+      } catch (_) {
+        console.error("[esm-print-player] Error setting model:", _);
+      }
+  }), G(() => {
+    if (p(o) && s() !== void 0)
+      try {
+        p(o).options = { role: s() };
+      } catch (_) {
+        console.error("[esm-print-player] Error setting role:", _);
+      }
+  }), Fn(() => {
+    if (c = Ht(), typeof window < "u" && (window["@pie-lib/math-rendering"] = { renderMath: c }), c && typeof window < "u") {
+      const _ = document.createElement("div");
+      c(_).catch(() => {
+      });
+    }
+    return () => {
+      u && u.disconnect();
+    };
+  }), G(() => {
+    if (l && c) {
+      u && u.disconnect();
+      let _ = null;
+      u = new MutationObserver(() => {
+        _ && clearTimeout(_), _ = window.setTimeout(
+          () => {
+            c && l && c(l).catch((h) => {
+              console.error("[esm-print-player] Math rendering error:", h);
+            });
+          },
+          150
+        );
+      }), u.observe(l, {
+        childList: !0,
+        subtree: !0,
+        attributes: !1,
+        characterData: !1
+      }), c(l).catch((h) => {
+        console.error("[esm-print-player] Initial math rendering error:", h);
+      });
+    }
+  }), G(() => {
+    l && c && (i() || s()) && requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        c && l && c(l).catch((_) => {
+          console.error("[esm-print-player] Math rendering error:", _);
+        });
+      });
+    });
+  });
+  async function v() {
+    if (!n()) {
+      $(a, "No element name provided"), $(d, !1);
+      return;
+    }
+    try {
+      $(d, !0), $(a, null);
+      const _ = `@pie-element/${n()}/print`;
+      console.log(`[esm-print-player] Loading print element: ${_}`);
+      const h = `${n()}-print`, E = new Promise((ee, Se) => setTimeout(() => Se(new Error(`Timeout loading ${_} (>10s). Check /@pie- routes, Vite server, and network.`)), 1e4));
+      await Promise.race([
+        Bn(_, h, r()),
+        E
+      ]), await customElements.whenDefined(h), p(o) && p(f) === h ? console.log(`[esm-print-player] Reusing element instance: ${h}`) : (p(o) && p(o).remove(), console.log(`[esm-print-player] Creating element instance: ${h}`), $(o, document.createElement(h), !0), $(f, h)), i() !== void 0 && (p(o).model = i()), s() !== void 0 && (p(o).options = { role: s() }), l && p(o).parentElement !== l && (l.innerHTML = "", l.appendChild(p(o))), console.log(`[esm-print-player] Print element ${n()} loaded successfully`), $(d, !1);
+    } catch (_) {
+      console.error(`[esm-print-player] Failed to load print element ${n()}:`, _), $(a, _ instanceof Error ? _.message : String(_), !0), $(d, !1);
+    }
+  }
+  var m = {
+    get elementName() {
+      return n();
+    },
+    set elementName(_ = "") {
+      n(_), re();
+    },
+    get cdnUrl() {
+      return r();
+    },
+    set cdnUrl(_ = "") {
+      r(_), re();
+    },
+    get model() {
+      return i();
+    },
+    set model(_) {
+      i(_), re();
+    },
+    get role() {
+      return s();
+    },
+    set role(_ = "student") {
+      s(_), re();
+    }
+  }, g = wi(), b = ae(g);
+  {
+    var I = (_) => {
+      var h = mi(), E = ae(h);
+      fe(h), it(() => st(E, `Loading ${n() ?? ""} (print)...`)), be(_, h);
+    };
+    lt(b, (_) => {
+      p(d) && _(I);
+    });
+  }
+  var N = rt(b, 2);
+  {
+    var oe = (_) => {
+      var h = gi(), E = rt(ae(h), 2), ee = ae(E, !0);
+      fe(E), fe(h), it(() => st(ee, p(a))), be(_, h);
+    };
+    lt(N, (_) => {
+      p(a) && _(oe);
+    });
+  }
+  return fe(g), jn(g, (_) => l = _, () => l), be(e, g), St(m);
+}
+customElements.define("pie-esm-print-player", Un(
+  yi,
+  {
+    elementName: { attribute: "element-name", reflect: !0, type: "String" },
+    cdnUrl: { attribute: "cdn-url", reflect: !0, type: "String" },
+    model: { type: "Object" },
+    role: { reflect: !0, type: "String" }
+  },
+  [],
+  []
+));
+export {
+  pi as EsmElementPlayer,
+  yi as EsmPrintPlayer
+};