@pie-players/pie-tool-tts-inline 0.1.1

package/dist/tool-tts-inline.js

@@ -0,0 +1,2704 @@
+import { ZIndexLayer as Qn } from "@pie-players/pie-assessment-toolkit";
+const er = "5";
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add(er);
+const tr = 2, Wt = "[", pt = "[!", Kt = "]", ke = {}, x = /* @__PURE__ */ Symbol(), nr = "http://www.w3.org/1999/xhtml", at = !1;
+var rr = Array.isArray, ir = Array.prototype.indexOf, ze = Array.prototype.includes, sr = Array.from, Ke = Object.keys, Je = Object.defineProperty, xe = Object.getOwnPropertyDescriptor, lr = Object.getOwnPropertyDescriptors, or = Object.prototype, ar = Array.prototype, Jt = Object.getPrototypeOf, Rt = Object.isExtensible;
+function fr(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function Zt() {
+  var e, t, n = new Promise((r, i) => {
+    e = r, t = i;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const k = 2, Ze = 4, et = 8, Xt = 1 << 24, re = 16, W = 32, ce = 64, gt = 128, D = 512, S = 1024, z = 2048, ie = 4096, U = 8192, Q = 16384, tt = 32768, Ae = 65536, Nt = 1 << 17, Qt = 1 << 18, be = 1 << 19, ur = 1 << 20, ge = 32768, ft = 1 << 21, mt = 1 << 22, ae = 1 << 23, Ue = /* @__PURE__ */ Symbol("$state"), cr = /* @__PURE__ */ Symbol("legacy props"), hr = /* @__PURE__ */ Symbol(""), Te = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}(), nt = 3, je = 8;
+function dr() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function vr(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function _r() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function pr(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function gr() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function mr() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function wr() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function br() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function yr() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function $r() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function rt(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function Er() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let b = !1;
+function Se(e) {
+  b = e;
+}
+let m;
+function Y(e) {
+  if (e === null)
+    throw rt(), ke;
+  return m = e;
+}
+function wt() {
+  return Y(/* @__PURE__ */ se(m));
+}
+function lt(e) {
+  if (b) {
+    if (/* @__PURE__ */ se(m) !== null)
+      throw rt(), ke;
+    m = e;
+  }
+}
+function Tr(e = 1) {
+  if (b) {
+    for (var t = e, n = m; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ se(n);
+    m = n;
+  }
+}
+function en(e = !0) {
+  for (var t = 0, n = m; ; ) {
+    if (n.nodeType === je) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === Kt) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (r === Wt || r === pt) && (t += 1);
+    }
+    var i = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ se(n)
+    );
+    e && n.remove(), n = i;
+  }
+}
+function Sr(e) {
+  if (!e || e.nodeType !== je)
+    throw rt(), ke;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function tn(e) {
+  return e === this.v;
+}
+function xr(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function kr(e) {
+  return !xr(e, this.v);
+}
+let zr = !1, L = null;
+function Ce(e) {
+  L = e;
+}
+function nn(e, t = !1, n) {
+  L = {
+    p: L,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function rn(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    L
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var r of n)
+      $n(r);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, L = t.p, e ?? /** @type {T} */
+  {};
+}
+function sn() {
+  return !0;
+}
+let de = [];
+function ln() {
+  var e = de;
+  de = [], fr(e);
+}
+function _e(e) {
+  if (de.length === 0 && !De) {
+    var t = de;
+    queueMicrotask(() => {
+      t === de && ln();
+    });
+  }
+  de.push(e);
+}
+function Ar() {
+  for (; de.length > 0; )
+    ln();
+}
+function on(e) {
+  var t = g;
+  if (t === null)
+    return _.f |= ae, e;
+  if ((t.f & tt) === 0) {
+    if ((t.f & gt) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    Re(e, t);
+}
+function Re(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & gt) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const Cr = -7169;
+function T(e, t) {
+  e.f = e.f & Cr | t;
+}
+function bt(e) {
+  (e.f & D) !== 0 || e.deps === null ? T(e, S) : T(e, ie);
+}
+function an(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & k) === 0 || (t.f & ge) === 0 || (t.f ^= ge, an(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function fn(e, t, n) {
+  (e.f & z) !== 0 ? t.add(e) : (e.f & ie) !== 0 && n.add(e), an(e.deps), T(e, S);
+}
+const Ve = /* @__PURE__ */ new Set();
+let y = null, V = null, N = [], it = null, ut = !1, De = !1;
+class ee {
+  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
+   */
+  #s = 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}
+   */
+  #l = 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 set of branches that still exist, but will be destroyed when this batch
+   * is committed — we skip over these during `process`
+   * @type {Set<Effect>}
+   */
+  skipped_effects = /* @__PURE__ */ new Set();
+  is_fork = !1;
+  #o = !1;
+  is_deferred() {
+    return this.is_fork || this.#s > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    N = [], this.apply();
+    var n = [], r = [];
+    for (const i of t)
+      this.#a(i, n, r);
+    if (this.is_deferred()) {
+      this.#f(r), this.#f(n);
+      for (const i of this.skipped_effects)
+        dn(i);
+    } else {
+      for (const i of this.#e) i();
+      this.#e.clear(), this.#n === 0 && this.#u(), y = null, Ot(r), Ot(n), this.#l?.resolve();
+    }
+    V = 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 ^= S;
+    for (var i = t.first, s = null; i !== null; ) {
+      var l = i.f, o = (l & (W | ce)) !== 0, a = o && (l & S) !== 0, f = a || (l & U) !== 0 || this.skipped_effects.has(i);
+      if (!f && i.fn !== null) {
+        o ? i.f ^= S : s !== null && (l & (Ze | et | Xt)) !== 0 ? s.b.defer_effect(i) : (l & Ze) !== 0 ? n.push(i) : He(i) && ((l & re) !== 0 && this.#r.add(i), Fe(i));
+        var c = i.first;
+        if (c !== null) {
+          i = c;
+          continue;
+        }
+      }
+      var d = i.parent;
+      for (i = i.next; i === null && d !== null; )
+        d === s && (s = null), i = d.next, d = d.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #f(t) {
+    for (var n = 0; n < t.length; n += 1)
+      fn(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 !== x && !this.previous.has(t) && this.previous.set(t, n), (t.f & ae) === 0 && (this.current.set(t, t.v), V?.set(t, t.v));
+  }
+  activate() {
+    y = this, this.apply();
+  }
+  deactivate() {
+    y === this && (y = null, V = null);
+  }
+  flush() {
+    if (this.activate(), N.length > 0) {
+      if (un(), y !== null && y !== this)
+        return;
+    } else this.#n === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of this.#t) t(this);
+    this.#t.clear();
+  }
+  #u() {
+    if (Ve.size > 1) {
+      this.previous.clear();
+      var t = V, n = !0;
+      for (const i of Ve) {
+        if (i === this) {
+          n = !1;
+          continue;
+        }
+        const s = [];
+        for (const [o, a] of this.current) {
+          if (i.current.has(o))
+            if (n && a !== i.current.get(o))
+              i.current.set(o, a);
+            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 = N;
+          N = [];
+          const o = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map();
+          for (const f of s)
+            cn(f, l, o, a);
+          if (N.length > 0) {
+            y = i, i.apply();
+            for (const f of N)
+              i.#a(f, [], []);
+            i.deactivate();
+          }
+          N = r;
+        }
+      }
+      y = null, V = t;
+    }
+    this.committed = !0, Ve.delete(this);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    this.#n += 1, t && (this.#s += 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    this.#n -= 1, t && (this.#s -= 1), !this.#o && (this.#o = !0, _e(() => {
+      this.#o = !1, this.is_deferred() ? N.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of this.#i)
+      this.#r.delete(t), T(t, z), te(t);
+    for (const t of this.#r)
+      T(t, ie), te(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.#l ??= Zt()).promise;
+  }
+  static ensure() {
+    if (y === null) {
+      const t = y = new ee();
+      Ve.add(y), De || _e(() => {
+        y === t && t.flush();
+      });
+    }
+    return y;
+  }
+  apply() {
+  }
+}
+function le(e) {
+  var t = De;
+  De = !0;
+  try {
+    for (var n; ; ) {
+      if (Ar(), N.length === 0 && (y?.flush(), N.length === 0))
+        return it = null, /** @type {T} */
+        n;
+      un();
+    }
+  } finally {
+    De = t;
+  }
+}
+function un() {
+  ut = !0;
+  var e = null;
+  try {
+    for (var t = 0; N.length > 0; ) {
+      var n = ee.ensure();
+      if (t++ > 1e3) {
+        var r, i;
+        Rr();
+      }
+      n.process(N), fe.clear();
+    }
+  } finally {
+    ut = !1, it = null;
+  }
+}
+function Rr() {
+  try {
+    gr();
+  } catch (e) {
+    Re(e, it);
+  }
+}
+let Z = null;
+function Ot(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var r = e[n++];
+      if ((r.f & (Q | U)) === 0 && He(r) && (Z = /* @__PURE__ */ new Set(), Fe(r), r.deps === null && r.first === null && r.nodes === null && (r.teardown === null && r.ac === null ? kn(r) : r.fn = null), Z?.size > 0)) {
+        fe.clear();
+        for (const i of Z) {
+          if ((i.f & (Q | U)) !== 0) continue;
+          const s = [i];
+          let l = i.parent;
+          for (; l !== null; )
+            Z.has(l) && (Z.delete(l), s.push(l)), l = l.parent;
+          for (let o = s.length - 1; o >= 0; o--) {
+            const a = s[o];
+            (a.f & (Q | U)) === 0 && Fe(a);
+          }
+        }
+        Z.clear();
+      }
+    }
+    Z = null;
+  }
+}
+function cn(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 ? cn(
+        /** @type {Derived} */
+        i,
+        t,
+        n,
+        r
+      ) : (s & (mt | re)) !== 0 && (s & z) === 0 && hn(i, t, r) && (T(i, z), te(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function hn(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 (ze.call(t, i))
+        return !0;
+      if ((i.f & k) !== 0 && hn(
+        /** @type {Derived} */
+        i,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function te(e) {
+  for (var t = it = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (ut && t === g && (n & re) !== 0 && (n & Qt) === 0)
+      return;
+    if ((n & (ce | W)) !== 0) {
+      if ((n & S) === 0) return;
+      t.f ^= S;
+    }
+  }
+  N.push(t);
+}
+function dn(e) {
+  if (!((e.f & W) !== 0 && (e.f & S) !== 0)) {
+    T(e, S);
+    for (var t = e.first; t !== null; )
+      dn(t), t = t.next;
+  }
+}
+function Nr(e) {
+  let t = 0, n = Be(0), r;
+  return () => {
+    Tt() && (p(n), St(() => (t === 0 && (r = Ln(() => e(() => Pe(n)))), t += 1, () => {
+      _e(() => {
+        t -= 1, t === 0 && (r?.(), r = void 0, Pe(n));
+      });
+    })));
+  };
+}
+var Or = Ae | be | gt;
+function Ir(e, t, n) {
+  new Mr(e, t, n);
+}
+class Mr {
+  /** @type {Boundary | null} */
+  parent;
+  is_pending = !1;
+  /** @type {TemplateNode} */
+  #e;
+  /** @type {TemplateNode | null} */
+  #t = b ? m : null;
+  /** @type {BoundaryProps} */
+  #n;
+  /** @type {((anchor: Node) => void)} */
+  #s;
+  /** @type {Effect} */
+  #l;
+  /** @type {Effect | null} */
+  #i = null;
+  /** @type {Effect | null} */
+  #r = null;
+  /** @type {Effect | null} */
+  #o = null;
+  /** @type {DocumentFragment | null} */
+  #a = null;
+  /** @type {TemplateNode | null} */
+  #f = null;
+  #u = 0;
+  #c = 0;
+  #v = !1;
+  #d = !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}
+   */
+  #h = null;
+  #y = Nr(() => (this.#h = Be(this.#u), () => {
+    this.#h = null;
+  }));
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, r) {
+    this.#e = t, this.#n = n, this.#s = r, this.parent = /** @type {Effect} */
+    g.b, this.is_pending = !!this.#n.pending, this.#l = Tn(() => {
+      if (g.b = this, b) {
+        const s = this.#t;
+        wt(), /** @type {Comment} */
+        s.nodeType === je && /** @type {Comment} */
+        s.data === pt ? this.#E() : (this.#$(), this.#c === 0 && (this.is_pending = !1));
+      } else {
+        var i = this.#w();
+        try {
+          this.#i = X(() => r(i));
+        } catch (s) {
+          this.error(s);
+        }
+        this.#c > 0 ? this.#m() : this.is_pending = !1;
+      }
+      return () => {
+        this.#f?.remove();
+      };
+    }, Or), b && (this.#e = m);
+  }
+  #$() {
+    try {
+      this.#i = X(() => this.#s(this.#e));
+    } catch (t) {
+      this.error(t);
+    }
+  }
+  #E() {
+    const t = this.#n.pending;
+    t && (this.#r = X(() => t(this.#e)), _e(() => {
+      var n = this.#w();
+      this.#i = this.#g(() => (ee.ensure(), X(() => this.#s(n)))), this.#c > 0 ? this.#m() : (Le(
+        /** @type {Effect} */
+        this.#r,
+        () => {
+          this.#r = null;
+        }
+      ), this.is_pending = !1);
+    }));
+  }
+  #w() {
+    var t = this.#e;
+    return this.is_pending && (this.#f = ne(), this.#e.before(this.#f), t = this.#f), t;
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    fn(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
+   */
+  #g(t) {
+    var n = g, r = _, i = L;
+    G(this.#l), F(this.#l), Ce(this.#l.ctx);
+    try {
+      return t();
+    } catch (s) {
+      return on(s), null;
+    } finally {
+      G(n), F(r), Ce(i);
+    }
+  }
+  #m() {
+    const t = (
+      /** @type {(anchor: Node) => void} */
+      this.#n.pending
+    );
+    this.#i !== null && (this.#a = document.createDocumentFragment(), this.#a.append(
+      /** @type {TemplateNode} */
+      this.#f
+    ), Cn(this.#i, this.#a)), this.#r === null && (this.#r = X(() => 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
+   */
+  #b(t) {
+    if (!this.has_pending_snippet()) {
+      this.parent && this.parent.#b(t);
+      return;
+    }
+    if (this.#c += t, this.#c === 0) {
+      this.is_pending = !1;
+      for (const n of this.#_)
+        T(n, z), te(n);
+      for (const n of this.#p)
+        T(n, ie), te(n);
+      this.#_.clear(), this.#p.clear(), this.#r && Le(this.#r, () => {
+        this.#r = null;
+      }), this.#a && (this.#e.before(this.#a), this.#a = 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.#b(t), this.#u += t, !(!this.#h || this.#v) && (this.#v = !0, _e(() => {
+      this.#v = !1, this.#h && Xe(this.#h, this.#u);
+    }));
+  }
+  get_effect_pending() {
+    return this.#y(), p(
+      /** @type {Source<number>} */
+      this.#h
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = this.#n.onerror;
+    let r = this.#n.failed;
+    if (this.#d || !n && !r)
+      throw t;
+    this.#i && (C(this.#i), this.#i = null), this.#r && (C(this.#r), this.#r = null), this.#o && (C(this.#o), this.#o = null), b && (Y(
+      /** @type {TemplateNode} */
+      this.#t
+    ), Tr(), Y(en()));
+    var i = !1, s = !1;
+    const l = () => {
+      if (i) {
+        Er();
+        return;
+      }
+      i = !0, s && $r(), ee.ensure(), this.#u = 0, this.#o !== null && Le(this.#o, () => {
+        this.#o = null;
+      }), this.is_pending = this.has_pending_snippet(), this.#i = this.#g(() => (this.#d = !1, X(() => this.#s(this.#e)))), this.#c > 0 ? this.#m() : this.is_pending = !1;
+    };
+    _e(() => {
+      try {
+        s = !0, n?.(t, l), s = !1;
+      } catch (o) {
+        Re(o, this.#l && this.#l.parent);
+      }
+      r && (this.#o = this.#g(() => {
+        ee.ensure(), this.#d = !0;
+        try {
+          return X(() => {
+            r(
+              this.#e,
+              () => t,
+              () => l
+            );
+          });
+        } catch (o) {
+          return Re(
+            o,
+            /** @type {Effect} */
+            this.#l.parent
+          ), null;
+        } finally {
+          this.#d = !1;
+        }
+      }));
+    });
+  }
+}
+function Dr(e, t, n, r) {
+  const i = yt;
+  var s = e.filter((u) => !u.settled);
+  if (n.length === 0 && s.length === 0) {
+    r(t.map(i));
+    return;
+  }
+  var l = y, o = (
+    /** @type {Effect} */
+    g
+  ), a = Pr(), f = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((u) => u.promise)) : null;
+  function c(u) {
+    a();
+    try {
+      r(u);
+    } catch (h) {
+      (o.f & Q) === 0 && Re(h, o);
+    }
+    l?.deactivate(), ct();
+  }
+  if (n.length === 0) {
+    f.then(() => c(t.map(i)));
+    return;
+  }
+  function d() {
+    a(), Promise.all(n.map((u) => /* @__PURE__ */ Lr(u))).then((u) => c([...t.map(i), ...u])).catch((u) => Re(u, o));
+  }
+  f ? f.then(d) : d();
+}
+function Pr() {
+  var e = g, t = _, n = L, r = y;
+  return function(s = !0) {
+    G(e), F(t), Ce(n), s && r?.activate();
+  };
+}
+function ct() {
+  G(null), F(null), Ce(null);
+}
+// @__NO_SIDE_EFFECTS__
+function yt(e) {
+  var t = k | z, n = _ !== null && (_.f & k) !== 0 ? (
+    /** @type {Derived} */
+    _
+  ) : null;
+  return g !== null && (g.f |= be), {
+    ctx: L,
+    deps: null,
+    effects: null,
+    equals: tn,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      x
+    ),
+    wv: 0,
+    parent: n ?? g,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Lr(e, t, n) {
+  let r = (
+    /** @type {Effect | null} */
+    g
+  );
+  r === null && dr();
+  var i = (
+    /** @type {Boundary} */
+    r.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = Be(
+    /** @type {V} */
+    x
+  ), o = !_, a = /* @__PURE__ */ new Map();
+  return Jr(() => {
+    var f = Zt();
+    s = f.promise;
+    try {
+      Promise.resolve(e()).then(f.resolve, f.reject).then(() => {
+        c === y && c.committed && c.deactivate(), ct();
+      });
+    } catch (h) {
+      f.reject(h), ct();
+    }
+    var c = (
+      /** @type {Batch} */
+      y
+    );
+    if (o) {
+      var d = i.is_rendered();
+      i.update_pending_count(1), c.increment(d), a.get(c)?.reject(Te), a.delete(c), a.set(c, f);
+    }
+    const u = (h, v = void 0) => {
+      if (c.activate(), v)
+        v !== Te && (l.f |= ae, Xe(l, v));
+      else {
+        (l.f & ae) !== 0 && (l.f ^= ae), Xe(l, h);
+        for (const [E, j] of a) {
+          if (a.delete(E), E === c) break;
+          j.reject(Te);
+        }
+      }
+      o && (i.update_pending_count(-1), c.decrement(d));
+    };
+    f.promise.then(u, (h) => u(null, h || "unknown"));
+  }), Gr(() => {
+    for (const f of a.values())
+      f.reject(Te);
+  }), new Promise((f) => {
+    function c(d) {
+      function u() {
+        d === s ? f(l) : c(s);
+      }
+      d.then(u, u);
+    }
+    c(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Fr(e) {
+  const t = /* @__PURE__ */ yt(e);
+  return Rn(t), t;
+}
+function vn(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      C(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function jr(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & k) === 0)
+      return (t.f & Q) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function $t(e) {
+  var t, n = g;
+  G(jr(e));
+  try {
+    e.f &= ~ge, vn(e), t = Mn(e);
+  } finally {
+    G(n);
+  }
+  return t;
+}
+function _n(e) {
+  var t = $t(e);
+  if (!e.equals(t) && (e.wv = On(), (!y?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    T(e, S);
+    return;
+  }
+  ue || (V !== null ? (Tt() || y?.is_fork) && V.set(e, t) : bt(e));
+}
+let ht = /* @__PURE__ */ new Set();
+const fe = /* @__PURE__ */ new Map();
+let pn = !1;
+function Be(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: tn,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function O(e, t) {
+  const n = Be(e);
+  return Rn(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function Br(e, t = !1, n = !0) {
+  const r = Be(e);
+  return t || (r.equals = kr), r;
+}
+function w(e, t, n = !1) {
+  _ !== 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
+  (!q || (_.f & Nt) !== 0) && sn() && (_.f & (k | re | mt | Nt)) !== 0 && (P === null || !ze.call(P, e)) && yr();
+  let r = n ? Me(t) : t;
+  return Xe(e, r);
+}
+function Xe(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    ue ? fe.set(e, t) : fe.set(e, n), e.v = t;
+    var r = ee.ensure();
+    if (r.capture(e, n), (e.f & k) !== 0) {
+      const i = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & z) !== 0 && $t(i), bt(i);
+    }
+    e.wv = On(), gn(e, z), g !== null && (g.f & S) !== 0 && (g.f & (W | ce)) === 0 && (M === null ? ei([e]) : M.push(e)), !r.is_fork && ht.size > 0 && !pn && Hr();
+  }
+  return t;
+}
+function Hr() {
+  pn = !1;
+  for (const e of ht)
+    (e.f & S) !== 0 && T(e, ie), He(e) && Fe(e);
+  ht.clear();
+}
+function Pe(e) {
+  w(e, e.v + 1);
+}
+function gn(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 & z) === 0;
+      if (o && T(s, t), (l & k) !== 0) {
+        var a = (
+          /** @type {Derived} */
+          s
+        );
+        V?.delete(a), (l & ge) === 0 && (l & D && (s.f |= ge), gn(a, ie));
+      } else o && ((l & re) !== 0 && Z !== null && Z.add(
+        /** @type {Effect} */
+        s
+      ), te(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Me(e) {
+  if (typeof e != "object" || e === null || Ue in e)
+    return e;
+  const t = Jt(e);
+  if (t !== or && t !== ar)
+    return e;
+  var n = /* @__PURE__ */ new Map(), r = rr(e), i = /* @__PURE__ */ O(0), s = pe, l = (o) => {
+    if (pe === s)
+      return o();
+    var a = _, f = pe;
+    F(null), jt(s);
+    var c = o();
+    return F(a), jt(f), c;
+  };
+  return r && n.set("length", /* @__PURE__ */ O(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(o, a, f) {
+        (!("value" in f) || f.configurable === !1 || f.enumerable === !1 || f.writable === !1) && wr();
+        var c = n.get(a);
+        return c === void 0 ? c = l(() => {
+          var d = /* @__PURE__ */ O(f.value);
+          return n.set(a, d), d;
+        }) : w(c, f.value, !0), !0;
+      },
+      deleteProperty(o, a) {
+        var f = n.get(a);
+        if (f === void 0) {
+          if (a in o) {
+            const c = l(() => /* @__PURE__ */ O(x));
+            n.set(a, c), Pe(i);
+          }
+        } else
+          w(f, x), Pe(i);
+        return !0;
+      },
+      get(o, a, f) {
+        if (a === Ue)
+          return e;
+        var c = n.get(a), d = a in o;
+        if (c === void 0 && (!d || xe(o, a)?.writable) && (c = l(() => {
+          var h = Me(d ? o[a] : x), v = /* @__PURE__ */ O(h);
+          return v;
+        }), n.set(a, c)), c !== void 0) {
+          var u = p(c);
+          return u === x ? void 0 : u;
+        }
+        return Reflect.get(o, a, f);
+      },
+      getOwnPropertyDescriptor(o, a) {
+        var f = Reflect.getOwnPropertyDescriptor(o, a);
+        if (f && "value" in f) {
+          var c = n.get(a);
+          c && (f.value = p(c));
+        } else if (f === void 0) {
+          var d = n.get(a), u = d?.v;
+          if (d !== void 0 && u !== x)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: u,
+              writable: !0
+            };
+        }
+        return f;
+      },
+      has(o, a) {
+        if (a === Ue)
+          return !0;
+        var f = n.get(a), c = f !== void 0 && f.v !== x || Reflect.has(o, a);
+        if (f !== void 0 || g !== null && (!c || xe(o, a)?.writable)) {
+          f === void 0 && (f = l(() => {
+            var u = c ? Me(o[a]) : x, h = /* @__PURE__ */ O(u);
+            return h;
+          }), n.set(a, f));
+          var d = p(f);
+          if (d === x)
+            return !1;
+        }
+        return c;
+      },
+      set(o, a, f, c) {
+        var d = n.get(a), u = a in o;
+        if (r && a === "length")
+          for (var h = f; h < /** @type {Source<number>} */
+          d.v; h += 1) {
+            var v = n.get(h + "");
+            v !== void 0 ? w(v, x) : h in o && (v = l(() => /* @__PURE__ */ O(x)), n.set(h + "", v));
+          }
+        if (d === void 0)
+          (!u || xe(o, a)?.writable) && (d = l(() => /* @__PURE__ */ O(void 0)), w(d, Me(f)), n.set(a, d));
+        else {
+          u = d.v !== x;
+          var E = l(() => Me(f));
+          w(d, E);
+        }
+        var j = Reflect.getOwnPropertyDescriptor(o, a);
+        if (j?.set && j.set.call(c, f), !u) {
+          if (r && typeof a == "string") {
+            var Ne = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), Oe = Number(a);
+            Number.isInteger(Oe) && Oe >= Ne.v && w(Ne, Oe + 1);
+          }
+          Pe(i);
+        }
+        return !0;
+      },
+      ownKeys(o) {
+        p(i);
+        var a = Reflect.ownKeys(o).filter((d) => {
+          var u = n.get(d);
+          return u === void 0 || u.v !== x;
+        });
+        for (var [f, c] of n)
+          c.v !== x && !(f in o) && a.push(f);
+        return a;
+      },
+      setPrototypeOf() {
+        br();
+      }
+    }
+  );
+}
+var It, mn, wn, bn;
+function dt() {
+  if (It === void 0) {
+    It = window, mn = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    wn = xe(t, "firstChild").get, bn = xe(t, "nextSibling").get, Rt(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Rt(n) && (n.__t = void 0);
+  }
+}
+function ne(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function me(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    wn.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function se(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    bn.call(e)
+  );
+}
+function ot(e, t) {
+  if (!b)
+    return /* @__PURE__ */ me(e);
+  var n = /* @__PURE__ */ me(m);
+  if (n === null)
+    n = m.appendChild(ne());
+  else if (t && n.nodeType !== nt) {
+    var r = ne();
+    return n?.before(r), Y(r), r;
+  }
+  return t && Et(
+    /** @type {Text} */
+    n
+  ), Y(n), n;
+}
+function Mt(e, t = !1) {
+  if (!b) {
+    var n = /* @__PURE__ */ me(e);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ se(n) : n;
+  }
+  if (t) {
+    if (m?.nodeType !== nt) {
+      var r = ne();
+      return m?.before(r), Y(r), r;
+    }
+    Et(
+      /** @type {Text} */
+      m
+    );
+  }
+  return m;
+}
+function Dt(e, t = 1, n = !1) {
+  let r = b ? m : e;
+  for (var i; t--; )
+    i = r, r = /** @type {TemplateNode} */
+    /* @__PURE__ */ se(r);
+  if (!b)
+    return r;
+  if (n) {
+    if (r?.nodeType !== nt) {
+      var s = ne();
+      return r === null ? i?.after(s) : r.before(s), Y(s), s;
+    }
+    Et(
+      /** @type {Text} */
+      r
+    );
+  }
+  return Y(r), r;
+}
+function Vr(e) {
+  e.textContent = "";
+}
+function qr() {
+  return !1;
+}
+function Et(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === nt; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function yn(e) {
+  var t = _, n = g;
+  F(null), G(null);
+  try {
+    return e();
+  } finally {
+    F(t), G(n);
+  }
+}
+function Yr(e) {
+  g === null && (_ === null && pr(), _r()), ue && vr();
+}
+function Ur(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function K(e, t, n) {
+  var r = g;
+  r !== null && (r.f & U) !== 0 && (e |= U);
+  var i = {
+    ctx: L,
+    deps: null,
+    nodes: null,
+    f: e | z | D,
+    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 {
+      Fe(i), i.f |= tt;
+    } catch (o) {
+      throw C(i), o;
+    }
+  else t !== null && te(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 & be) === 0 && (s = s.first, (e & re) !== 0 && (e & Ae) !== 0 && s !== null && (s.f |= Ae)), s !== null && (s.parent = r, r !== null && Ur(s, r), _ !== null && (_.f & k) !== 0 && (e & ce) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      _
+    );
+    (l.effects ??= []).push(s);
+  }
+  return i;
+}
+function Tt() {
+  return _ !== null && !q;
+}
+function Gr(e) {
+  const t = K(et, null, !1);
+  return T(t, S), t.teardown = e, t;
+}
+function Pt(e) {
+  Yr();
+  var t = (
+    /** @type {Effect} */
+    g.f
+  ), n = !_ && (t & W) !== 0 && (t & tt) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      L
+    );
+    (r.e ??= []).push(e);
+  } else
+    return $n(e);
+}
+function $n(e) {
+  return K(Ze | ur, e, !1);
+}
+function Wr(e) {
+  ee.ensure();
+  const t = K(ce | be, e, !0);
+  return () => {
+    C(t);
+  };
+}
+function Kr(e) {
+  ee.ensure();
+  const t = K(ce | be, e, !0);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? Le(t, () => {
+      C(t), r(void 0);
+    }) : (C(t), r(void 0));
+  });
+}
+function En(e) {
+  return K(Ze, e, !1);
+}
+function Jr(e) {
+  return K(mt | be, e, !0);
+}
+function St(e, t = 0) {
+  return K(et | t, e, !0);
+}
+function Lt(e, t = [], n = [], r = []) {
+  Dr(r, t, n, (i) => {
+    K(et, () => e(...i.map(p)), !0);
+  });
+}
+function Tn(e, t = 0) {
+  var n = K(re | t, e, !0);
+  return n;
+}
+function X(e) {
+  return K(W | be, e, !0);
+}
+function Sn(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = ue, r = _;
+    Ft(!0), F(null);
+    try {
+      t.call(null);
+    } finally {
+      Ft(n), F(r);
+    }
+  }
+}
+function xn(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const i = n.ac;
+    i !== null && yn(() => {
+      i.abort(Te);
+    });
+    var r = n.next;
+    (n.f & ce) !== 0 ? n.parent = null : C(n, t), n = r;
+  }
+}
+function Zr(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & W) === 0 && C(t), t = n;
+  }
+}
+function C(e, t = !0) {
+  var n = !1;
+  (t || (e.f & Qt) !== 0) && e.nodes !== null && e.nodes.end !== null && (Xr(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), xn(e, t && !n), Qe(e, 0), T(e, Q);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const s of r)
+      s.stop();
+  Sn(e);
+  var i = e.parent;
+  i !== null && i.first !== null && kn(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Xr(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ se(e);
+    e.remove(), e = n;
+  }
+}
+function kn(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 Le(e, t, n = !0) {
+  var r = [];
+  zn(e, r, !0);
+  var i = () => {
+    n && C(e), t && t();
+  }, s = r.length;
+  if (s > 0) {
+    var l = () => --s || i();
+    for (var o of r)
+      o.out(l);
+  } else
+    i();
+}
+function zn(e, t, n) {
+  if ((e.f & U) === 0) {
+    e.f ^= U;
+    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 & Ae) !== 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 & W) !== 0 && (e.f & re) !== 0;
+      zn(i, t, l ? n : !1), i = s;
+    }
+  }
+}
+function Qr(e) {
+  An(e, !0);
+}
+function An(e, t) {
+  if ((e.f & U) !== 0) {
+    e.f ^= U, (e.f & S) === 0 && (T(e, z), te(e));
+    for (var n = e.first; n !== null; ) {
+      var r = n.next, i = (n.f & Ae) !== 0 || (n.f & W) !== 0;
+      An(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 Cn(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, r = e.nodes.end; n !== null; ) {
+      var i = n === r ? null : /* @__PURE__ */ se(n);
+      t.append(n), n = i;
+    }
+}
+let Ge = !1, ue = !1;
+function Ft(e) {
+  ue = e;
+}
+let _ = null, q = !1;
+function F(e) {
+  _ = e;
+}
+let g = null;
+function G(e) {
+  g = e;
+}
+let P = null;
+function Rn(e) {
+  _ !== null && (P === null ? P = [e] : P.push(e));
+}
+let A = null, R = 0, M = null;
+function ei(e) {
+  M = e;
+}
+let Nn = 1, ve = 0, pe = ve;
+function jt(e) {
+  pe = e;
+}
+function On() {
+  return ++Nn;
+}
+function He(e) {
+  var t = e.f;
+  if ((t & z) !== 0)
+    return !0;
+  if (t & k && (e.f &= ~ge), (t & ie) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = n.length, i = 0; i < r; i++) {
+      var s = n[i];
+      if (He(
+        /** @type {Derived} */
+        s
+      ) && _n(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & D) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    V === null && T(e, S);
+  }
+  return !1;
+}
+function In(e, t, n = !0) {
+  var r = e.reactions;
+  if (r !== null && !(P !== null && ze.call(P, e)))
+    for (var i = 0; i < r.length; i++) {
+      var s = r[i];
+      (s.f & k) !== 0 ? In(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (n ? T(s, z) : (s.f & S) !== 0 && T(s, ie), te(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Mn(e) {
+  var t = A, n = R, r = M, i = _, s = P, l = L, o = q, a = pe, f = e.f;
+  A = /** @type {null | Value[]} */
+  null, R = 0, M = null, _ = (f & (W | ce)) === 0 ? e : null, P = null, Ce(e.ctx), q = !1, pe = ++ve, e.ac !== null && (yn(() => {
+    e.ac.abort(Te);
+  }), e.ac = null);
+  try {
+    e.f |= ft;
+    var c = (
+      /** @type {Function} */
+      e.fn
+    ), d = c(), u = e.deps, h = y?.is_fork;
+    if (A !== null) {
+      var v;
+      if (h || Qe(e, R), u !== null && R > 0)
+        for (u.length = R + A.length, v = 0; v < A.length; v++)
+          u[R + v] = A[v];
+      else
+        e.deps = u = A;
+      if (Tt() && (e.f & D) !== 0)
+        for (v = R; v < u.length; v++)
+          (u[v].reactions ??= []).push(e);
+    } else !h && u !== null && R < u.length && (Qe(e, R), u.length = R);
+    if (sn() && M !== null && !q && u !== null && (e.f & (k | ie | z)) === 0)
+      for (v = 0; v < /** @type {Source[]} */
+      M.length; v++)
+        In(
+          M[v],
+          /** @type {Effect} */
+          e
+        );
+    if (i !== null && i !== e) {
+      if (ve++, i.deps !== null)
+        for (let E = 0; E < n; E += 1)
+          i.deps[E].rv = ve;
+      if (t !== null)
+        for (const E of t)
+          E.rv = ve;
+      M !== null && (r === null ? r = M : r.push(.../** @type {Source[]} */
+      M));
+    }
+    return (e.f & ae) !== 0 && (e.f ^= ae), d;
+  } catch (E) {
+    return on(E);
+  } finally {
+    e.f ^= ft, A = t, R = n, M = r, _ = i, P = s, Ce(l), q = o, pe = a;
+  }
+}
+function ti(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var r = ir.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
+  (A === null || !ze.call(A, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & D) !== 0 && (s.f ^= D, s.f &= ~ge), bt(s), vn(s), Qe(s, 0);
+  }
+}
+function Qe(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var r = t; r < n.length; r++)
+      ti(e, n[r]);
+}
+function Fe(e) {
+  var t = e.f;
+  if ((t & Q) === 0) {
+    T(e, S);
+    var n = g, r = Ge;
+    g = e, Ge = !0;
+    try {
+      (t & (re | Xt)) !== 0 ? Zr(e) : xn(e), Sn(e);
+      var i = Mn(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = Nn;
+      var s;
+      at && zr && (e.f & z) !== 0 && e.deps;
+    } finally {
+      Ge = r, g = n;
+    }
+  }
+}
+function p(e) {
+  var t = e.f, n = (t & k) !== 0;
+  if (_ !== null && !q) {
+    var r = g !== null && (g.f & Q) !== 0;
+    if (!r && (P === null || !ze.call(P, e))) {
+      var i = _.deps;
+      if ((_.f & ft) !== 0)
+        e.rv < ve && (e.rv = ve, A === null && i !== null && i[R] === e ? R++ : A === null ? A = [e] : A.push(e));
+      else {
+        (_.deps ??= []).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [_] : ze.call(s, _) || s.push(_);
+      }
+    }
+  }
+  if (ue && fe.has(e))
+    return fe.get(e);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (ue) {
+      var o = l.v;
+      return ((l.f & S) === 0 && l.reactions !== null || Pn(l)) && (o = $t(l)), fe.set(l, o), o;
+    }
+    var a = (l.f & D) === 0 && !q && _ !== null && (Ge || (_.f & D) !== 0), f = l.deps === null;
+    He(l) && (a && (l.f |= D), _n(l)), a && !f && Dn(l);
+  }
+  if (V?.has(e))
+    return V.get(e);
+  if ((e.f & ae) !== 0)
+    throw e.v;
+  return e.v;
+}
+function Dn(e) {
+  if (e.deps !== null) {
+    e.f |= D;
+    for (const t of e.deps)
+      (t.reactions ??= []).push(e), (t.f & k) !== 0 && (t.f & D) === 0 && Dn(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function Pn(e) {
+  if (e.v === x) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (fe.has(t) || (t.f & k) !== 0 && Pn(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function Ln(e) {
+  var t = q;
+  try {
+    return q = !0, e();
+  } finally {
+    q = t;
+  }
+}
+const Fn = /* @__PURE__ */ new Set(), vt = /* @__PURE__ */ new Set();
+function ni(e) {
+  for (var t = 0; t < e.length; t++)
+    Fn.add(e[t]);
+  for (var n of vt)
+    n(e);
+}
+let Bt = null;
+function qe(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), r = e.type, i = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    i[0] || e.target
+  );
+  Bt = e;
+  var l = 0, o = Bt === e && e.__root;
+  if (o) {
+    var a = i.indexOf(o);
+    if (a !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var f = i.indexOf(t);
+    if (f === -1)
+      return;
+    a <= f && (l = a);
+  }
+  if (s = /** @type {Element} */
+  i[l] || e.target, s !== t) {
+    Je(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var c = _, d = g;
+    F(null), G(null);
+    try {
+      for (var u, h = []; s !== null; ) {
+        var v = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var E = s["__" + r];
+          E != 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) && E.call(s, e);
+        } catch (j) {
+          u ? h.push(j) : u = j;
+        }
+        if (e.cancelBubble || v === t || v === null)
+          break;
+        s = v;
+      }
+      if (u) {
+        for (let j of h)
+          queueMicrotask(() => {
+            throw j;
+          });
+        throw u;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, F(c), G(d);
+    }
+  }
+}
+function jn(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function we(e, t) {
+  var n = (
+    /** @type {Effect} */
+    g
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Bn(e, t) {
+  var n = (t & tr) !== 0, r, i = !e.startsWith("<!>");
+  return () => {
+    if (b)
+      return we(m, null), m;
+    r === void 0 && (r = jn(i ? e : "<!>" + e), r = /** @type {TemplateNode} */
+    /* @__PURE__ */ me(r));
+    var s = (
+      /** @type {TemplateNode} */
+      n || mn ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return we(s, s), s;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function ri(e, t, n = "svg") {
+  var r = !e.startsWith("<!>"), i = `<${n}>${r ? e : "<!>" + e}</${n}>`, s;
+  return () => {
+    if (b)
+      return we(m, null), m;
+    if (!s) {
+      var l = (
+        /** @type {DocumentFragment} */
+        jn(i)
+      ), o = (
+        /** @type {Element} */
+        /* @__PURE__ */ me(l)
+      );
+      s = /** @type {Element} */
+      /* @__PURE__ */ me(o);
+    }
+    var a = (
+      /** @type {TemplateNode} */
+      s.cloneNode(!0)
+    );
+    return we(a, a), a;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function xt(e, t) {
+  return /* @__PURE__ */ ri(e, t, "svg");
+}
+function Ht() {
+  if (b)
+    return we(m, null), m;
+  var e = document.createDocumentFragment(), t = document.createComment(""), n = ne();
+  return e.append(t, n), we(t, n), e;
+}
+function oe(e, t) {
+  if (b) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      g
+    );
+    ((n.f & tt) === 0 || n.nodes.end === null) && (n.nodes.end = m), wt();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const ii = ["touchstart", "touchmove"];
+function si(e) {
+  return ii.includes(e);
+}
+function li(e, t) {
+  var n = t == null ? "" : typeof t == "object" ? t + "" : t;
+  n !== (e.__t ??= e.nodeValue) && (e.__t = n, e.nodeValue = n + "");
+}
+function Hn(e, t) {
+  return Vn(e, t);
+}
+function oi(e, t) {
+  dt(), t.intro = t.intro ?? !1;
+  const n = t.target, r = b, i = m;
+  try {
+    for (var s = /* @__PURE__ */ me(n); s && (s.nodeType !== je || /** @type {Comment} */
+    s.data !== Wt); )
+      s = /* @__PURE__ */ se(s);
+    if (!s)
+      throw ke;
+    Se(!0), Y(
+      /** @type {Comment} */
+      s
+    );
+    const l = Vn(e, { ...t, anchor: s });
+    return Se(!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 !== ke && console.warn("Failed to hydrate: ", l), t.recover === !1 && mr(), dt(), Vr(n), Se(!1), Hn(e, t);
+  } finally {
+    Se(r), Y(i);
+  }
+}
+const Ee = /* @__PURE__ */ new Map();
+function Vn(e, { target: t, anchor: n, props: r = {}, events: i, context: s, intro: l = !0 }) {
+  dt();
+  var o = /* @__PURE__ */ new Set(), a = (d) => {
+    for (var u = 0; u < d.length; u++) {
+      var h = d[u];
+      if (!o.has(h)) {
+        o.add(h);
+        var v = si(h);
+        t.addEventListener(h, qe, { passive: v });
+        var E = Ee.get(h);
+        E === void 0 ? (document.addEventListener(h, qe, { passive: v }), Ee.set(h, 1)) : Ee.set(h, E + 1);
+      }
+    }
+  };
+  a(sr(Fn)), vt.add(a);
+  var f = void 0, c = Kr(() => {
+    var d = n ?? t.appendChild(ne());
+    return Ir(
+      /** @type {TemplateNode} */
+      d,
+      {
+        pending: () => {
+        }
+      },
+      (u) => {
+        if (s) {
+          nn({});
+          var h = (
+            /** @type {ComponentContext} */
+            L
+          );
+          h.c = s;
+        }
+        if (i && (r.$$events = i), b && we(
+          /** @type {TemplateNode} */
+          u,
+          null
+        ), f = e(u, r) || {}, b && (g.nodes.end = m, m === null || m.nodeType !== je || /** @type {Comment} */
+        m.data !== Kt))
+          throw rt(), ke;
+        s && rn();
+      }
+    ), () => {
+      for (var u of o) {
+        t.removeEventListener(u, qe);
+        var h = (
+          /** @type {number} */
+          Ee.get(u)
+        );
+        --h === 0 ? (document.removeEventListener(u, qe), Ee.delete(u)) : Ee.set(u, h);
+      }
+      vt.delete(a), d !== n && d.parentNode?.removeChild(d);
+    };
+  });
+  return _t.set(f, c), f;
+}
+let _t = /* @__PURE__ */ new WeakMap();
+function ai(e, t) {
+  const n = _t.get(e);
+  return n ? (_t.delete(e), n(t)) : Promise.resolve();
+}
+class fi {
+  /** @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>}
+   */
+  #s = /* @__PURE__ */ new Set();
+  /**
+   * Whether to pause (i.e. outro) on change, or destroy immediately.
+   * This is necessary for `<svelte:element>`
+   */
+  #l = !0;
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    this.anchor = t, this.#l = n;
+  }
+  #i = () => {
+    var t = (
+      /** @type {Batch} */
+      y
+    );
+    if (this.#e.has(t)) {
+      var n = (
+        /** @type {Key} */
+        this.#e.get(t)
+      ), r = this.#t.get(n);
+      if (r)
+        Qr(r), this.#s.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 && (C(o.effect), this.#n.delete(l));
+      }
+      for (const [s, l] of this.#t) {
+        if (s === n || this.#s.has(s)) continue;
+        const o = () => {
+          if (Array.from(this.#e.values()).includes(s)) {
+            var f = document.createDocumentFragment();
+            Cn(l, f), f.append(ne()), this.#n.set(s, { effect: l, fragment: f });
+          } else
+            C(l);
+          this.#s.delete(s), this.#t.delete(s);
+        };
+        this.#l || !r ? (this.#s.add(s), Le(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) || (C(i.effect), this.#n.delete(r));
+  };
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var r = (
+      /** @type {Batch} */
+      y
+    ), i = qr();
+    if (n && !this.#t.has(t) && !this.#n.has(t))
+      if (i) {
+        var s = document.createDocumentFragment(), l = ne();
+        s.append(l), this.#n.set(t, {
+          effect: X(() => n(l)),
+          fragment: s
+        });
+      } else
+        this.#t.set(
+          t,
+          X(() => n(this.anchor))
+        );
+    if (this.#e.set(r, t), i) {
+      for (const [o, a] of this.#t)
+        o === t ? r.skipped_effects.delete(a) : r.skipped_effects.add(a);
+      for (const [o, a] of this.#n)
+        o === t ? r.skipped_effects.delete(a.effect) : r.skipped_effects.add(a.effect);
+      r.oncommit(this.#i), r.ondiscard(this.#r);
+    } else
+      b && (this.anchor = m), this.#i();
+  }
+}
+function Ye(e, t, n = !1) {
+  b && wt();
+  var r = new fi(e), i = n ? Ae : 0;
+  function s(l, o) {
+    if (b) {
+      const f = Sr(e) === pt;
+      if (l === f) {
+        var a = en();
+        Y(a), r.anchor = a, Se(!1), r.ensure(l, o), Se(!0);
+        return;
+      }
+    }
+    r.ensure(l, o);
+  }
+  Tn(() => {
+    var l = !1;
+    t((o, a = !0) => {
+      l = !0, s(a, o);
+    }), l || s(!1, null);
+  }, i);
+}
+function ui(e, t) {
+  En(() => {
+    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 = document.createElement("style");
+      i.id = t.hash, i.textContent = t.code, r.appendChild(i);
+    }
+  });
+}
+const Vt = [...` 	
+\r\f \v\uFEFF`];
+function ci(e, t, n) {
+  var r = e == null ? "" : "" + e;
+  if (r = r ? r + " " + t : t, n) {
+    for (var i in n)
+      if (n[i])
+        r = r ? r + " " + i : i;
+      else if (r.length)
+        for (var s = i.length, l = 0; (l = r.indexOf(i, l)) >= 0; ) {
+          var o = l + s;
+          (l === 0 || Vt.includes(r[l - 1])) && (o === r.length || Vt.includes(r[o])) ? r = (l === 0 ? "" : r.substring(0, l)) + r.substring(o + 1) : l = o;
+        }
+  }
+  return r === "" ? null : r;
+}
+function qt(e, t, n, r, i, s) {
+  var l = e.__className;
+  if (b || l !== n || l === void 0) {
+    var o = ci(n, r, s);
+    (!b || o !== e.getAttribute("class")) && (o == null ? e.removeAttribute("class") : e.className = o), e.__className = n;
+  } else if (s && i !== s)
+    for (var a in s) {
+      var f = !!s[a];
+      (i == null || f !== !!i[a]) && e.classList.toggle(a, f);
+    }
+  return s;
+}
+const hi = /* @__PURE__ */ Symbol("is custom element"), di = /* @__PURE__ */ Symbol("is html");
+function Yt(e, t, n, r) {
+  var i = vi(e);
+  b && (i[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === "LINK") || i[t] !== (i[t] = n) && (t === "loading" && (e[hr] = n), n == null ? e.removeAttribute(t) : typeof n != "string" && _i(e).includes(t) ? e[t] = n : e.setAttribute(t, n));
+}
+function vi(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ??= {
+      [hi]: e.nodeName.includes("-"),
+      [di]: e.namespaceURI === nr
+    }
+  );
+}
+var Ut = /* @__PURE__ */ new Map();
+function _i(e) {
+  var t = e.getAttribute("is") || e.nodeName, n = Ut.get(t);
+  if (n) return n;
+  Ut.set(t, n = []);
+  for (var r, i = e, s = Element.prototype; s !== i; ) {
+    r = lr(i);
+    for (var l in r)
+      r[l].set && n.push(l);
+    i = Jt(i);
+  }
+  return n;
+}
+function Gt(e, t) {
+  return e === t || e?.[Ue] === t;
+}
+function pi(e = {}, t, n, r) {
+  return En(() => {
+    var i, s;
+    return St(() => {
+      i = s, s = [], Ln(() => {
+        e !== n(...s) && (t(e, ...s), i && Gt(n(...i), e) && t(null, ...i));
+      });
+    }), () => {
+      _e(() => {
+        s && Gt(n(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+function he(e, t, n, r) {
+  var i = (
+    /** @type {V} */
+    r
+  ), s = !0, l = () => (s && (s = !1, i = /** @type {V} */
+  r), i), o;
+  o = /** @type {V} */
+  e[t], o === void 0 && r !== void 0 && (o = l());
+  var a;
+  a = () => {
+    var u = (
+      /** @type {V} */
+      e[t]
+    );
+    return u === void 0 ? l() : (s = !0, u);
+  };
+  var f = !1, c = /* @__PURE__ */ yt(() => (f = !1, a())), d = (
+    /** @type {Effect} */
+    g
+  );
+  return (
+    /** @type {() => V} */
+    (function(u, h) {
+      if (arguments.length > 0) {
+        const v = h ? p(c) : u;
+        return w(c, v), f = !0, i !== void 0 && (i = v), u;
+      }
+      return ue && f || (d.f & Q) !== 0 ? c.v : p(c);
+    })
+  );
+}
+function gi(e) {
+  return new mi(e);
+}
+class mi {
+  /** @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__ */ Br(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 === cr ? !0 : (p(n.get(l) ?? r(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, o) {
+          return w(n.get(l) ?? r(l, o), o), Reflect.set(s, l, o);
+        }
+      }
+    );
+    this.#t = (t.hydrate ? oi : Hn)(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) && le(), this.#e = i.$$events;
+    for (const s of Object.keys(this.#t))
+      s === "$set" || s === "$destroy" || s === "$on" || Je(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 = () => {
+      ai(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 = document.createElement("slot");
+          r !== "default" && (s.name = r), oe(i, s);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const t = {}, n = wi(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] = We(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 = gi({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: t,
+          $$host: this
+        }
+      }), this.$$me = Wr(() => {
+        St(() => {
+          this.$$r = !0;
+          for (const r of Ke(this.$$c)) {
+            if (!this.$$p_d[r]?.reflect) continue;
+            this.$$d[r] = this.$$c[r];
+            const i = We(
+              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] = We(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 Ke(this.$$p_d).find(
+      (t) => this.$$p_d[t].attribute === e || !this.$$p_d[t].attribute && t.toLowerCase() === e
+    ) || e;
+  }
+});
+function We(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 wi(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function bi(e, t, n, r, i, s) {
+  let l = class extends qn {
+    constructor() {
+      super(e, n, i), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Ke(t).map(
+        (o) => (t[o].attribute || o).toLowerCase()
+      );
+    }
+  };
+  return Ke(t).forEach((o) => {
+    Je(l.prototype, o, {
+      get() {
+        return this.$$c && o in this.$$c ? this.$$c[o] : this.$$d[o];
+      },
+      set(a) {
+        a = We(o, a, t), this.$$d[o] = a;
+        var f = this.$$c;
+        if (f) {
+          var c = xe(f, o)?.get;
+          c ? f[o] = a : f.$set({ [o]: a });
+        }
+      }
+    });
+  }), r.forEach((o) => {
+    Je(l.prototype, o, {
+      get() {
+        return this.$$c?.[o];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+var yi = /* @__PURE__ */ xt('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="tts-inline__icon svelte-18mzc0g" aria-hidden="true"><path d="M8 5v14l11-7z" class="svelte-18mzc0g"></path></svg>'), $i = /* @__PURE__ */ xt('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="tts-inline__icon svelte-18mzc0g" aria-hidden="true"><path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z" class="svelte-18mzc0g"></path></svg>'), Ei = /* @__PURE__ */ xt('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="tts-inline__icon svelte-18mzc0g" aria-hidden="true"><path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z" class="svelte-18mzc0g"></path></svg>'), Ti = /* @__PURE__ */ Bn('<button type="button" aria-label="Stop reading"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="tts-inline__icon svelte-18mzc0g" aria-hidden="true"><path d="M6 6h12v12H6z" class="svelte-18mzc0g"></path></svg></button>'), Si = /* @__PURE__ */ Bn('<div class="tts-inline-controls svelte-18mzc0g"><button type="button"><!></button> <!> <div class="sr-only svelte-18mzc0g" role="status" aria-live="polite" aria-atomic="true"> </div></div>');
+const xi = {
+  hash: "svelte-18mzc0g",
+  code: `.tts-inline-controls.svelte-18mzc0g {display:inline-flex;align-items:center;gap:0.25rem;}.tts-inline.svelte-18mzc0g {display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--pie-border, #ccc);background-color:var(--pie-background, white);color:var(--pie-text, #333);border-radius:4px;cursor:pointer;transition:background-color 0.15s ease,
+			transform 0.1s ease,
+			box-shadow 0.15s ease;padding:0.25rem;position:relative;}.tts-inline.svelte-18mzc0g:hover:not(:disabled) {background-color:var(--pie-secondary-background, #f5f5f5);transform:translateY(-1px);box-shadow:0 2px 4px rgba(0, 0, 0, 0.1);}.tts-inline.svelte-18mzc0g:active:not(:disabled) {transform:translateY(0);box-shadow:none;}
+
+	/* Focus indicator - WCAG 2.4.7, 2.4.13 */.tts-inline.svelte-18mzc0g:focus-visible {outline:2px solid #0066cc;outline-offset:2px;box-shadow:0 0 0 4px rgba(0, 102, 204, 0.2);z-index:1;}.tts-inline--speaking.svelte-18mzc0g {background-color:var(--pie-primary, #1976d2);color:white;border-color:var(--pie-primary, #1976d2);
+		animation: svelte-18mzc0g-pulse 1.5s ease-in-out infinite;}.tts-inline--paused.svelte-18mzc0g {background-color:rgba(255, 152, 0, 0.15);}.tts-inline--stop.svelte-18mzc0g {background-color:transparent;}.tts-inline--stop.svelte-18mzc0g:hover:not(:disabled) {background-color:rgba(244, 67, 54, 0.1);}.tts-inline--stop.svelte-18mzc0g .tts-inline__icon:where(.svelte-18mzc0g) {color:#c62828; /* Darker red for better contrast - WCAG 1.4.11 */}.tts-inline.svelte-18mzc0g:disabled {cursor:not-allowed;opacity:0.6;}
+
+	/* Size variants */.tts-inline--sm.svelte-18mzc0g {width:1.5rem;height:1.5rem;
+		/* Increase padding to meet 44px touch target - WCAG 2.5.2 */padding:0.625rem;}.tts-inline--sm.svelte-18mzc0g .tts-inline__icon:where(.svelte-18mzc0g) {width:1rem;height:1rem;}.tts-inline--md.svelte-18mzc0g {width:2rem;height:2rem;}.tts-inline--md.svelte-18mzc0g .tts-inline__icon:where(.svelte-18mzc0g) {width:1.25rem;height:1.25rem;}.tts-inline--lg.svelte-18mzc0g {width:2.5rem;height:2.5rem;}.tts-inline--lg.svelte-18mzc0g .tts-inline__icon:where(.svelte-18mzc0g) {width:1.5rem;height:1.5rem;}.tts-inline__icon.svelte-18mzc0g {fill:currentColor;color:#555;}.tts-inline.svelte-18mzc0g:hover:not(:disabled) .tts-inline__icon:where(.svelte-18mzc0g) {color:#667eea;}.tts-inline--speaking.svelte-18mzc0g .tts-inline__icon:where(.svelte-18mzc0g) {color:#667eea;}
+
+	@keyframes svelte-18mzc0g-pulse {
+		0%,
+		100% {
+			opacity: 1;
+		}
+		50% {
+			opacity: 0.7;
+		}
+	}
+
+	/* Screen reader only content */.sr-only.svelte-18mzc0g {position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border:0;}
+
+	/* Accessibility */
+	@media (prefers-reduced-motion: reduce) {.tts-inline.svelte-18mzc0g,
+		.tts-inline--speaking.svelte-18mzc0g {
+			animation: none !important;transition:none !important;}
+	}`
+};
+function ki(e, t) {
+  nn(t, !0), ui(e, xi);
+  let n = he(t, "toolId", 7, "tts-inline"), r = he(
+    t,
+    "catalogId",
+    7,
+    ""
+    // Explicit catalog ID
+  ), i = he(t, "language", 7, "en-US"), s = he(t, "size", 7, "md"), l = he(t, "coordinator"), o = he(t, "ttsService"), a = he(t, "highlightCoordinator");
+  const f = typeof window < "u";
+  let c = /* @__PURE__ */ O(void 0), d = /* @__PURE__ */ O(!1), u = /* @__PURE__ */ O(!1), h = /* @__PURE__ */ O(!1), v = /* @__PURE__ */ O("");
+  Pt(() => {
+    l() && n() && p(c) && !p(d) && (l().registerTool(n(), "TTS Inline", p(c), Qn.TOOL), w(d, !0));
+  }), Pt(() => () => {
+    l() && n() && l().unregisterTool(n());
+  });
+  async function E() {
+    if (o()) {
+      if (p(h)) {
+        o().resume(), w(h, !1), w(v, "Reading resumed");
+        return;
+      }
+      if (p(u) && !p(h)) {
+        o().pause(), w(h, !0), w(v, "Reading paused");
+        return;
+      }
+      try {
+        w(u, !0), w(h, !1), w(v, "Reading started");
+        const $ = p(c)?.closest(".passage-header, .item-header");
+        let B = null;
+        if ($ && (B = $.parentElement?.querySelector(".passage-content, .item-content") || null), B || (B = p(c)?.closest(".passage-content, .item-content") || null), !B) {
+          console.warn("[TTS Inline] No target container found"), w(u, !1);
+          return;
+        }
+        const H = document.createRange();
+        H.selectNodeContents(B);
+        const Ie = H.toString(), ye = Ie.trim().replace(/\s+/g, " ");
+        if (console.log("[TTS Inline] Text extraction:", {
+          rawLength: Ie.length,
+          normalizedLength: ye.length,
+          preview: ye.substring(0, 100)
+        }), !ye) {
+          console.warn("[TTS Inline] No text content found"), w(u, !1);
+          return;
+        }
+        a() && o().setHighlightCoordinator && o().setHighlightCoordinator(a()), await o().speak(ye, {
+          catalogId: r() || void 0,
+          language: i(),
+          contentElement: B
+        }), w(u, !1), w(h, !1), a() && a().clearTTS();
+      } catch ($) {
+        console.error("[TTS Inline] Error:", $), w(u, !1), w(h, !1), a() && a().clearTTS();
+      }
+    }
+  }
+  function j() {
+    o() && (o().stop(), w(u, !1), w(h, !1), w(v, "Reading stopped"), a() && a().clearTTS());
+  }
+  const Ne = /* @__PURE__ */ Fr(() => s() === "sm" ? "tts-inline--sm" : s() === "lg" ? "tts-inline--lg" : "tts-inline--md");
+  var Oe = {
+    get toolId() {
+      return n();
+    },
+    set toolId($ = "tts-inline") {
+      n($), le();
+    },
+    get catalogId() {
+      return r();
+    },
+    set catalogId($ = "") {
+      r($), le();
+    },
+    get language() {
+      return i();
+    },
+    set language($ = "en-US") {
+      i($), le();
+    },
+    get size() {
+      return s();
+    },
+    set size($ = "md") {
+      s($), le();
+    },
+    get coordinator() {
+      return l();
+    },
+    set coordinator($) {
+      l($), le();
+    },
+    get ttsService() {
+      return o();
+    },
+    set ttsService($) {
+      o($), le();
+    },
+    get highlightCoordinator() {
+      return a();
+    },
+    set highlightCoordinator($) {
+      a($), le();
+    }
+  }, kt = Ht(), Yn = Mt(kt);
+  {
+    var Un = ($) => {
+      var B = Si(), H = ot(B);
+      let Ie;
+      H.__click = E;
+      var ye = ot(H);
+      {
+        var zt = (I) => {
+          var J = yi();
+          oe(I, J);
+        }, Gn = (I) => {
+          var J = Ht(), Jn = Mt(J);
+          {
+            var Zn = ($e) => {
+              var st = $i();
+              oe($e, st);
+            }, Xn = ($e) => {
+              var st = Ei();
+              oe($e, st);
+            };
+            Ye(
+              Jn,
+              ($e) => {
+                p(u) ? $e(Zn) : $e(Xn, !1);
+              },
+              !0
+            );
+          }
+          oe(I, J);
+        };
+        Ye(ye, (I) => {
+          p(h) ? I(zt) : I(Gn, !1);
+        });
+      }
+      lt(H);
+      var At = Dt(H, 2);
+      {
+        var Wn = (I) => {
+          var J = Ti();
+          J.__click = j, Lt(() => {
+            qt(J, 1, `tts-inline tts-inline--stop ${p(Ne) ?? ""}`, "svelte-18mzc0g"), J.disabled = !o();
+          }), oe(I, J);
+        };
+        Ye(At, (I) => {
+          (p(u) || p(h)) && I(Wn);
+        });
+      }
+      var Ct = Dt(At, 2), Kn = ot(Ct, !0);
+      lt(Ct), lt(B), pi(B, (I) => w(c, I), () => p(c)), Lt(() => {
+        Ie = qt(H, 1, `tts-inline ${p(Ne) ?? ""}`, "svelte-18mzc0g", Ie, {
+          "tts-inline--speaking": p(u),
+          "tts-inline--paused": p(h)
+        }), Yt(H, "aria-label", p(h) ? "Resume reading" : p(u) ? "Pause reading" : "Read aloud"), Yt(H, "aria-pressed", p(u) || p(h)), H.disabled = !o(), li(Kn, p(v));
+      }), oe($, B);
+    };
+    Ye(Yn, ($) => {
+      f && $(Un);
+    });
+  }
+  return oe(e, kt), rn(Oe);
+}
+ni(["click"]);
+customElements.define("pie-tool-tts-inline", bi(
+  ki,
+  {
+    toolId: { attribute: "tool-id", type: "String" },
+    catalogId: { attribute: "catalog-id", type: "String" },
+    language: { attribute: "language", type: "String" },
+    size: { attribute: "size", type: "String" },
+    coordinator: { type: "Object" },
+    ttsService: { type: "Object" },
+    highlightCoordinator: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  ki as default
+};