@pie-players/pie-tool-line-reader 0.1.1

package/dist/tool-line-reader.js

@@ -0,0 +1,3217 @@
+var hs = Object.defineProperty;
+var Ar = (e) => {
+  throw TypeError(e);
+};
+var vs = (e, t, n) => t in e ? hs(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var N = (e, t, n) => vs(e, typeof t != "symbol" ? t + "" : t, n), Yn = (e, t, n) => t.has(e) || Ar("Cannot " + n);
+var f = (e, t, n) => (Yn(e, t, "read from private field"), n ? n.call(e) : t.get(e)), $ = (e, t, n) => t.has(e) ? Ar("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), b = (e, t, n, i) => (Yn(e, t, "write to private field"), i ? i.call(e, n) : t.set(e, n), n), F = (e, t, n) => (Yn(e, t, "access private method"), n);
+var qr;
+typeof window < "u" && ((qr = window.__svelte ?? (window.__svelte = {})).v ?? (qr.v = /* @__PURE__ */ new Set())).add("5");
+const _s = 1, ps = 2, gs = 16, ms = 1, bs = 2, Vr = "[", kn = "[!", ir = "]", Ot = {}, B = /* @__PURE__ */ Symbol(), ws = "http://www.w3.org/1999/xhtml", Un = !1;
+var Gr = Array.isArray, $s = Array.prototype.indexOf, Mt = Array.prototype.includes, Tn = Array.from, mn = Object.keys, bn = Object.defineProperty, wt = Object.getOwnPropertyDescriptor, ys = Object.getOwnPropertyDescriptors, Es = Object.prototype, xs = Array.prototype, Wr = Object.getPrototypeOf, Cr = Object.isExtensible;
+function ks(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function Kr() {
+  var e, t, n = new Promise((i, r) => {
+    e = i, t = r;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const Y = 2, wn = 4, Sn = 8, Xr = 1 << 24, je = 16, me = 32, Je = 64, sr = 128, ue = 512, j = 1024, G = 2048, Be = 4096, te = 8192, Ie = 16384, An = 32768, Rt = 65536, Or = 1 << 17, Jr = 1 << 18, vt = 1 << 19, Ts = 1 << 20, qe = 1 << 25, dt = 32768, qn = 1 << 21, lr = 1 << 22, Ve = 1 << 23, un = /* @__PURE__ */ Symbol("$state"), Ss = /* @__PURE__ */ Symbol("legacy props"), As = /* @__PURE__ */ Symbol(""), bt = new class extends Error {
+  constructor() {
+    super(...arguments);
+    N(this, "name", "StaleReactionError");
+    N(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), Cn = 3, It = 8;
+function Cs(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function Os() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Ms(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Rs() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function Ns(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function Ls() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Ps() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function Ds() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Is() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Fs() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function zs() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function On(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function js() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let x = !1;
+function Pe(e) {
+  x = e;
+}
+let k;
+function ne(e) {
+  if (e === null)
+    throw On(), Ot;
+  return k = e;
+}
+function nn() {
+  return ne(/* @__PURE__ */ Se(k));
+}
+function U(e) {
+  if (x) {
+    if (/* @__PURE__ */ Se(k) !== null)
+      throw On(), Ot;
+    k = e;
+  }
+}
+function cn(e = 1) {
+  if (x) {
+    for (var t = e, n = k; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ Se(n);
+    k = n;
+  }
+}
+function $n(e = !0) {
+  for (var t = 0, n = k; ; ) {
+    if (n.nodeType === It) {
+      var i = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (i === ir) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (i === Vr || i === kn) && (t += 1);
+    }
+    var r = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Se(n)
+    );
+    e && n.remove(), n = r;
+  }
+}
+function Qr(e) {
+  if (!e || e.nodeType !== It)
+    throw On(), Ot;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function Zr(e) {
+  return e === this.v;
+}
+function Bs(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function ei(e) {
+  return !Bs(e, this.v);
+}
+let Ys = !1, re = null;
+function Nt(e) {
+  re = e;
+}
+function Mn(e, t = !1, n) {
+  re = {
+    p: re,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function Rn(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    re
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var i of n)
+      xi(i);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, re = t.p, e ?? /** @type {T} */
+  {};
+}
+function ti() {
+  return !0;
+}
+let nt = [];
+function ni() {
+  var e = nt;
+  nt = [], ks(e);
+}
+function Ge(e) {
+  if (nt.length === 0 && !Wt) {
+    var t = nt;
+    queueMicrotask(() => {
+      t === nt && ni();
+    });
+  }
+  nt.push(e);
+}
+function Hs() {
+  for (; nt.length > 0; )
+    ni();
+}
+function ri(e) {
+  var t = T;
+  if (t === null)
+    return y.f |= Ve, e;
+  if ((t.f & An) === 0) {
+    if ((t.f & sr) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    Lt(e, t);
+}
+function Lt(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & sr) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const Us = -7169;
+function D(e, t) {
+  e.f = e.f & Us | t;
+}
+function ar(e) {
+  (e.f & ue) !== 0 || e.deps === null ? D(e, j) : D(e, Be);
+}
+function ii(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & Y) === 0 || (t.f & dt) === 0 || (t.f ^= dt, ii(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function si(e, t, n) {
+  (e.f & G) !== 0 ? t.add(e) : (e.f & Be) !== 0 && n.add(e), ii(e.deps), D(e, j);
+}
+const an = /* @__PURE__ */ new Set();
+let R = null, ve = null, ee = [], Nn = null, Vn = !1, Wt = !1;
+var Et, xt, it, kt, Jt, Qt, st, Tt, Te, Gn, Wn, li;
+const br = class br {
+  constructor() {
+    $(this, Te);
+    N(this, "committed", !1);
+    /**
+     * The current values of any sources that are updated in this batch
+     * They keys of this map are identical to `this.#previous`
+     * @type {Map<Source, any>}
+     */
+    N(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any sources that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Source, any>}
+     */
+    N(this, "previous", /* @__PURE__ */ new Map());
+    /**
+     * When the batch is committed (and the DOM is updated), we need to remove old branches
+     * and append new ones by calling the functions added inside (if/each/key/etc) blocks
+     * @type {Set<() => void>}
+     */
+    $(this, Et, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    $(this, xt, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    $(this, it, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    $(this, kt, 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}
+     */
+    $(this, Jt, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    $(this, Qt, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    $(this, st, /* @__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>}
+     */
+    N(this, "skipped_effects", /* @__PURE__ */ new Set());
+    N(this, "is_fork", !1);
+    $(this, Tt, !1);
+  }
+  is_deferred() {
+    return this.is_fork || f(this, kt) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    ee = [], this.apply();
+    var n = [], i = [];
+    for (const r of t)
+      F(this, Te, Gn).call(this, r, n, i);
+    if (this.is_deferred()) {
+      F(this, Te, Wn).call(this, i), F(this, Te, Wn).call(this, n);
+      for (const r of this.skipped_effects)
+        ui(r);
+    } else {
+      for (const r of f(this, Et)) r();
+      f(this, Et).clear(), f(this, it) === 0 && F(this, Te, li).call(this), R = null, Mr(i), Mr(n), f(this, Jt)?.resolve();
+    }
+    ve = null;
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(t, n) {
+    n !== B && !this.previous.has(t) && this.previous.set(t, n), (t.f & Ve) === 0 && (this.current.set(t, t.v), ve?.set(t, t.v));
+  }
+  activate() {
+    R = this, this.apply();
+  }
+  deactivate() {
+    R === this && (R = null, ve = null);
+  }
+  flush() {
+    if (this.activate(), ee.length > 0) {
+      if (ai(), R !== null && R !== this)
+        return;
+    } else f(this, it) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of f(this, xt)) t(this);
+    f(this, xt).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    b(this, it, f(this, it) + 1), t && b(this, kt, f(this, kt) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    b(this, it, f(this, it) - 1), t && b(this, kt, f(this, kt) - 1), !f(this, Tt) && (b(this, Tt, !0), Ge(() => {
+      b(this, Tt, !1), this.is_deferred() ? ee.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of f(this, Qt))
+      f(this, st).delete(t), D(t, G), ze(t);
+    for (const t of f(this, st))
+      D(t, Be), ze(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    f(this, Et).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    f(this, xt).add(t);
+  }
+  settled() {
+    return (f(this, Jt) ?? b(this, Jt, Kr())).promise;
+  }
+  static ensure() {
+    if (R === null) {
+      const t = R = new br();
+      an.add(R), Wt || Ge(() => {
+        R === t && t.flush();
+      });
+    }
+    return R;
+  }
+  apply() {
+  }
+};
+Et = new WeakMap(), xt = new WeakMap(), it = new WeakMap(), kt = new WeakMap(), Jt = new WeakMap(), Qt = new WeakMap(), st = new WeakMap(), Tt = new WeakMap(), Te = new WeakSet(), /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ * @param {Effect[]} effects
+ * @param {Effect[]} render_effects
+ */
+Gn = function(t, n, i) {
+  t.f ^= j;
+  for (var r = t.first, s = null; r !== null; ) {
+    var l = r.f, a = (l & (me | Je)) !== 0, o = a && (l & j) !== 0, c = o || (l & te) !== 0 || this.skipped_effects.has(r);
+    if (!c && r.fn !== null) {
+      a ? r.f ^= j : s !== null && (l & (wn | Sn | Xr)) !== 0 ? s.b.defer_effect(r) : (l & wn) !== 0 ? n.push(r) : rn(r) && ((l & je) !== 0 && f(this, st).add(r), Xt(r));
+      var d = r.first;
+      if (d !== null) {
+        r = d;
+        continue;
+      }
+    }
+    var h = r.parent;
+    for (r = r.next; r === null && h !== null; )
+      h === s && (s = null), r = h.next, h = h.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+Wn = function(t) {
+  for (var n = 0; n < t.length; n += 1)
+    si(t[n], f(this, Qt), f(this, st));
+}, li = function() {
+  var r;
+  if (an.size > 1) {
+    this.previous.clear();
+    var t = ve, n = !0;
+    for (const s of an) {
+      if (s === this) {
+        n = !1;
+        continue;
+      }
+      const l = [];
+      for (const [o, c] of this.current) {
+        if (s.current.has(o))
+          if (n && c !== s.current.get(o))
+            s.current.set(o, c);
+          else
+            continue;
+        l.push(o);
+      }
+      if (l.length === 0)
+        continue;
+      const a = [...s.current.keys()].filter((o) => !this.current.has(o));
+      if (a.length > 0) {
+        var i = ee;
+        ee = [];
+        const o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+        for (const d of l)
+          oi(d, a, o, c);
+        if (ee.length > 0) {
+          R = s, s.apply();
+          for (const d of ee)
+            F(r = s, Te, Gn).call(r, d, [], []);
+          s.deactivate();
+        }
+        ee = i;
+      }
+    }
+    R = null, ve = t;
+  }
+  this.committed = !0, an.delete(this);
+};
+let Fe = br;
+function fe(e) {
+  var t = Wt;
+  Wt = !0;
+  try {
+    for (var n; ; ) {
+      if (Hs(), ee.length === 0 && (R?.flush(), ee.length === 0))
+        return Nn = null, /** @type {T} */
+        n;
+      ai();
+    }
+  } finally {
+    Wt = t;
+  }
+}
+function ai() {
+  Vn = !0;
+  var e = null;
+  try {
+    for (var t = 0; ee.length > 0; ) {
+      var n = Fe.ensure();
+      if (t++ > 1e3) {
+        var i, r;
+        qs();
+      }
+      n.process(ee), We.clear();
+    }
+  } finally {
+    Vn = !1, Nn = null;
+  }
+}
+function qs() {
+  try {
+    Ls();
+  } catch (e) {
+    Lt(e, Nn);
+  }
+}
+let Oe = null;
+function Mr(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var i = e[n++];
+      if ((i.f & (Ie | te)) === 0 && rn(i) && (Oe = /* @__PURE__ */ new Set(), Xt(i), i.deps === null && i.first === null && i.nodes === null && (i.teardown === null && i.ac === null ? Ai(i) : i.fn = null), Oe?.size > 0)) {
+        We.clear();
+        for (const r of Oe) {
+          if ((r.f & (Ie | te)) !== 0) continue;
+          const s = [r];
+          let l = r.parent;
+          for (; l !== null; )
+            Oe.has(l) && (Oe.delete(l), s.push(l)), l = l.parent;
+          for (let a = s.length - 1; a >= 0; a--) {
+            const o = s[a];
+            (o.f & (Ie | te)) === 0 && Xt(o);
+          }
+        }
+        Oe.clear();
+      }
+    }
+    Oe = null;
+  }
+}
+function oi(e, t, n, i) {
+  if (!n.has(e) && (n.add(e), e.reactions !== null))
+    for (const r of e.reactions) {
+      const s = r.f;
+      (s & Y) !== 0 ? oi(
+        /** @type {Derived} */
+        r,
+        t,
+        n,
+        i
+      ) : (s & (lr | je)) !== 0 && (s & G) === 0 && fi(r, t, i) && (D(r, G), ze(
+        /** @type {Effect} */
+        r
+      ));
+    }
+}
+function fi(e, t, n) {
+  const i = n.get(e);
+  if (i !== void 0) return i;
+  if (e.deps !== null)
+    for (const r of e.deps) {
+      if (Mt.call(t, r))
+        return !0;
+      if ((r.f & Y) !== 0 && fi(
+        /** @type {Derived} */
+        r,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          r,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function ze(e) {
+  for (var t = Nn = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (Vn && t === T && (n & je) !== 0 && (n & Jr) === 0)
+      return;
+    if ((n & (Je | me)) !== 0) {
+      if ((n & j) === 0) return;
+      t.f ^= j;
+    }
+  }
+  ee.push(t);
+}
+function ui(e) {
+  if (!((e.f & me) !== 0 && (e.f & j) !== 0)) {
+    D(e, j);
+    for (var t = e.first; t !== null; )
+      ui(t), t = t.next;
+  }
+}
+function Vs(e) {
+  let t = 0, n = ht(0), i;
+  return () => {
+    ur() && (u(n), cr(() => (t === 0 && (i = vr(() => e(() => Kt(n)))), t += 1, () => {
+      Ge(() => {
+        t -= 1, t === 0 && (i?.(), i = void 0, Kt(n));
+      });
+    })));
+  };
+}
+var Gs = Rt | vt | sr;
+function Ws(e, t, n) {
+  new Ks(e, t, n);
+}
+var Q, Zt, we, lt, $e, le, W, ye, Me, Ue, at, Re, St, ot, At, Ct, Ne, En, L, ci, di, Kn, dn, hn, Xn;
+class Ks {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, i) {
+    $(this, L);
+    /** @type {Boundary | null} */
+    N(this, "parent");
+    N(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    $(this, Q);
+    /** @type {TemplateNode | null} */
+    $(this, Zt, x ? k : null);
+    /** @type {BoundaryProps} */
+    $(this, we);
+    /** @type {((anchor: Node) => void)} */
+    $(this, lt);
+    /** @type {Effect} */
+    $(this, $e);
+    /** @type {Effect | null} */
+    $(this, le, null);
+    /** @type {Effect | null} */
+    $(this, W, null);
+    /** @type {Effect | null} */
+    $(this, ye, null);
+    /** @type {DocumentFragment | null} */
+    $(this, Me, null);
+    /** @type {TemplateNode | null} */
+    $(this, Ue, null);
+    $(this, at, 0);
+    $(this, Re, 0);
+    $(this, St, !1);
+    $(this, ot, !1);
+    /** @type {Set<Effect>} */
+    $(this, At, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    $(this, Ct, /* @__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}
+     */
+    $(this, Ne, null);
+    $(this, En, Vs(() => (b(this, Ne, ht(f(this, at))), () => {
+      b(this, Ne, null);
+    })));
+    b(this, Q, t), b(this, we, n), b(this, lt, i), this.parent = /** @type {Effect} */
+    T.b, this.is_pending = !!f(this, we).pending, b(this, $e, dr(() => {
+      if (T.b = this, x) {
+        const s = f(this, Zt);
+        nn(), /** @type {Comment} */
+        s.nodeType === It && /** @type {Comment} */
+        s.data === kn ? F(this, L, di).call(this) : (F(this, L, ci).call(this), f(this, Re) === 0 && (this.is_pending = !1));
+      } else {
+        var r = F(this, L, Kn).call(this);
+        try {
+          b(this, le, oe(() => i(r)));
+        } catch (s) {
+          this.error(s);
+        }
+        f(this, Re) > 0 ? F(this, L, hn).call(this) : this.is_pending = !1;
+      }
+      return () => {
+        f(this, Ue)?.remove();
+      };
+    }, Gs)), x && b(this, Q, k);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    si(t, f(this, At), f(this, Ct));
+  }
+  /**
+   * 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 !!f(this, we).pending;
+  }
+  /**
+   * Update the source that powers `$effect.pending()` inside this boundary,
+   * and controls when the current `pending` snippet (if any) is removed.
+   * Do not call from inside the class
+   * @param {1 | -1} d
+   */
+  update_pending_count(t) {
+    F(this, L, Xn).call(this, t), b(this, at, f(this, at) + t), !(!f(this, Ne) || f(this, St)) && (b(this, St, !0), Ge(() => {
+      b(this, St, !1), f(this, Ne) && Pt(f(this, Ne), f(this, at));
+    }));
+  }
+  get_effect_pending() {
+    return f(this, En).call(this), u(
+      /** @type {Source<number>} */
+      f(this, Ne)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = f(this, we).onerror;
+    let i = f(this, we).failed;
+    if (f(this, ot) || !n && !i)
+      throw t;
+    f(this, le) && (V(f(this, le)), b(this, le, null)), f(this, W) && (V(f(this, W)), b(this, W, null)), f(this, ye) && (V(f(this, ye)), b(this, ye, null)), x && (ne(
+      /** @type {TemplateNode} */
+      f(this, Zt)
+    ), cn(), ne($n()));
+    var r = !1, s = !1;
+    const l = () => {
+      if (r) {
+        js();
+        return;
+      }
+      r = !0, s && zs(), Fe.ensure(), b(this, at, 0), f(this, ye) !== null && ut(f(this, ye), () => {
+        b(this, ye, null);
+      }), this.is_pending = this.has_pending_snippet(), b(this, le, F(this, L, dn).call(this, () => (b(this, ot, !1), oe(() => f(this, lt).call(this, f(this, Q)))))), f(this, Re) > 0 ? F(this, L, hn).call(this) : this.is_pending = !1;
+    };
+    Ge(() => {
+      try {
+        s = !0, n?.(t, l), s = !1;
+      } catch (a) {
+        Lt(a, f(this, $e) && f(this, $e).parent);
+      }
+      i && b(this, ye, F(this, L, dn).call(this, () => {
+        Fe.ensure(), b(this, ot, !0);
+        try {
+          return oe(() => {
+            i(
+              f(this, Q),
+              () => t,
+              () => l
+            );
+          });
+        } catch (a) {
+          return Lt(
+            a,
+            /** @type {Effect} */
+            f(this, $e).parent
+          ), null;
+        } finally {
+          b(this, ot, !1);
+        }
+      }));
+    });
+  }
+}
+Q = new WeakMap(), Zt = new WeakMap(), we = new WeakMap(), lt = new WeakMap(), $e = new WeakMap(), le = new WeakMap(), W = new WeakMap(), ye = new WeakMap(), Me = new WeakMap(), Ue = new WeakMap(), at = new WeakMap(), Re = new WeakMap(), St = new WeakMap(), ot = new WeakMap(), At = new WeakMap(), Ct = new WeakMap(), Ne = new WeakMap(), En = new WeakMap(), L = new WeakSet(), ci = function() {
+  try {
+    b(this, le, oe(() => f(this, lt).call(this, f(this, Q))));
+  } catch (t) {
+    this.error(t);
+  }
+}, di = function() {
+  const t = f(this, we).pending;
+  t && (b(this, W, oe(() => t(f(this, Q)))), Ge(() => {
+    var n = F(this, L, Kn).call(this);
+    b(this, le, F(this, L, dn).call(this, () => (Fe.ensure(), oe(() => f(this, lt).call(this, n))))), f(this, Re) > 0 ? F(this, L, hn).call(this) : (ut(
+      /** @type {Effect} */
+      f(this, W),
+      () => {
+        b(this, W, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, Kn = function() {
+  var t = f(this, Q);
+  return this.is_pending && (b(this, Ue, ge()), f(this, Q).before(f(this, Ue)), t = f(this, Ue)), t;
+}, /**
+ * @param {() => Effect | null} fn
+ */
+dn = function(t) {
+  var n = T, i = y, r = re;
+  ke(f(this, $e)), de(f(this, $e)), Nt(f(this, $e).ctx);
+  try {
+    return t();
+  } catch (s) {
+    return ri(s), null;
+  } finally {
+    ke(n), de(i), Nt(r);
+  }
+}, hn = function() {
+  const t = (
+    /** @type {(anchor: Node) => void} */
+    f(this, we).pending
+  );
+  f(this, le) !== null && (b(this, Me, document.createDocumentFragment()), f(this, Me).append(
+    /** @type {TemplateNode} */
+    f(this, Ue)
+  ), Mi(f(this, le), f(this, Me))), f(this, W) === null && b(this, W, oe(() => t(f(this, Q))));
+}, /**
+ * 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
+ */
+Xn = function(t) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && F(n = this.parent, L, Xn).call(n, t);
+    return;
+  }
+  if (b(this, Re, f(this, Re) + t), f(this, Re) === 0) {
+    this.is_pending = !1;
+    for (const i of f(this, At))
+      D(i, G), ze(i);
+    for (const i of f(this, Ct))
+      D(i, Be), ze(i);
+    f(this, At).clear(), f(this, Ct).clear(), f(this, W) && ut(f(this, W), () => {
+      b(this, W, null);
+    }), f(this, Me) && (f(this, Q).before(f(this, Me)), b(this, Me, null));
+  }
+};
+function Xs(e, t, n, i) {
+  const r = Ln;
+  var s = e.filter((_) => !_.settled);
+  if (n.length === 0 && s.length === 0) {
+    i(t.map(r));
+    return;
+  }
+  var l = R, a = (
+    /** @type {Effect} */
+    T
+  ), o = Js(), c = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((_) => _.promise)) : null;
+  function d(_) {
+    o();
+    try {
+      i(_);
+    } catch (p) {
+      (a.f & Ie) === 0 && Lt(p, a);
+    }
+    l?.deactivate(), Jn();
+  }
+  if (n.length === 0) {
+    c.then(() => d(t.map(r)));
+    return;
+  }
+  function h() {
+    o(), Promise.all(n.map((_) => /* @__PURE__ */ Qs(_))).then((_) => d([...t.map(r), ..._])).catch((_) => Lt(_, a));
+  }
+  c ? c.then(h) : h();
+}
+function Js() {
+  var e = T, t = y, n = re, i = R;
+  return function(s = !0) {
+    ke(e), de(t), Nt(n), s && i?.activate();
+  };
+}
+function Jn() {
+  ke(null), de(null), Nt(null);
+}
+// @__NO_SIDE_EFFECTS__
+function Ln(e) {
+  var t = Y | G, n = y !== null && (y.f & Y) !== 0 ? (
+    /** @type {Derived} */
+    y
+  ) : null;
+  return T !== null && (T.f |= vt), {
+    ctx: re,
+    deps: null,
+    effects: null,
+    equals: Zr,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      B
+    ),
+    wv: 0,
+    parent: n ?? T,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Qs(e, t, n) {
+  let i = (
+    /** @type {Effect | null} */
+    T
+  );
+  i === null && Os();
+  var r = (
+    /** @type {Boundary} */
+    i.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = ht(
+    /** @type {V} */
+    B
+  ), a = !y, o = /* @__PURE__ */ new Map();
+  return fl(() => {
+    var c = Kr();
+    s = c.promise;
+    try {
+      Promise.resolve(e()).then(c.resolve, c.reject).then(() => {
+        d === R && d.committed && d.deactivate(), Jn();
+      });
+    } catch (p) {
+      c.reject(p), Jn();
+    }
+    var d = (
+      /** @type {Batch} */
+      R
+    );
+    if (a) {
+      var h = r.is_rendered();
+      r.update_pending_count(1), d.increment(h), o.get(d)?.reject(bt), o.delete(d), o.set(d, c);
+    }
+    const _ = (p, v = void 0) => {
+      if (d.activate(), v)
+        v !== bt && (l.f |= Ve, Pt(l, v));
+      else {
+        (l.f & Ve) !== 0 && (l.f ^= Ve), Pt(l, p);
+        for (const [g, m] of o) {
+          if (o.delete(g), g === d) break;
+          m.reject(bt);
+        }
+      }
+      a && (r.update_pending_count(-1), d.decrement(h));
+    };
+    c.promise.then(_, (p) => _(null, p || "unknown"));
+  }), ll(() => {
+    for (const c of o.values())
+      c.reject(bt);
+  }), new Promise((c) => {
+    function d(h) {
+      function _() {
+        h === s ? c(l) : d(s);
+      }
+      h.then(_, _);
+    }
+    d(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Zs(e) {
+  const t = /* @__PURE__ */ Ln(e);
+  return Ri(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function el(e) {
+  const t = /* @__PURE__ */ Ln(e);
+  return t.equals = ei, t;
+}
+function hi(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      V(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function tl(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & Y) === 0)
+      return (t.f & Ie) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function or(e) {
+  var t, n = T;
+  ke(tl(e));
+  try {
+    e.f &= ~dt, hi(e), t = Di(e);
+  } finally {
+    ke(n);
+  }
+  return t;
+}
+function vi(e) {
+  var t = or(e);
+  if (!e.equals(t) && (e.wv = Li(), (!R?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    D(e, j);
+    return;
+  }
+  Xe || (ve !== null ? (ur() || R?.is_fork) && ve.set(e, t) : ar(e));
+}
+let Qn = /* @__PURE__ */ new Set();
+const We = /* @__PURE__ */ new Map();
+let _i = !1;
+function ht(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Zr,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function M(e, t) {
+  const n = ht(e);
+  return Ri(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function pi(e, t = !1, n = !0) {
+  const i = ht(e);
+  return t || (i.equals = ei), i;
+}
+function E(e, t, n = !1) {
+  y !== 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
+  (!_e || (y.f & Or) !== 0) && ti() && (y.f & (Y | je | lr | Or)) !== 0 && (ce === null || !Mt.call(ce, e)) && Fs();
+  let i = n ? De(t) : t;
+  return Pt(e, i);
+}
+function Pt(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    Xe ? We.set(e, t) : We.set(e, n), e.v = t;
+    var i = Fe.ensure();
+    if (i.capture(e, n), (e.f & Y) !== 0) {
+      const r = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & G) !== 0 && or(r), ar(r);
+    }
+    e.wv = Li(), gi(e, G), T !== null && (T.f & j) !== 0 && (T.f & (me | Je)) === 0 && (se === null ? dl([e]) : se.push(e)), !i.is_fork && Qn.size > 0 && !_i && nl();
+  }
+  return t;
+}
+function nl() {
+  _i = !1;
+  for (const e of Qn)
+    (e.f & j) !== 0 && D(e, Be), rn(e) && Xt(e);
+  Qn.clear();
+}
+function Kt(e) {
+  E(e, e.v + 1);
+}
+function gi(e, t) {
+  var n = e.reactions;
+  if (n !== null)
+    for (var i = n.length, r = 0; r < i; r++) {
+      var s = n[r], l = s.f, a = (l & G) === 0;
+      if (a && D(s, t), (l & Y) !== 0) {
+        var o = (
+          /** @type {Derived} */
+          s
+        );
+        ve?.delete(o), (l & dt) === 0 && (l & ue && (s.f |= dt), gi(o, Be));
+      } else a && ((l & je) !== 0 && Oe !== null && Oe.add(
+        /** @type {Effect} */
+        s
+      ), ze(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function De(e) {
+  if (typeof e != "object" || e === null || un in e)
+    return e;
+  const t = Wr(e);
+  if (t !== Es && t !== xs)
+    return e;
+  var n = /* @__PURE__ */ new Map(), i = Gr(e), r = /* @__PURE__ */ M(0), s = ct, l = (a) => {
+    if (ct === s)
+      return a();
+    var o = y, c = ct;
+    de(null), Pr(s);
+    var d = a();
+    return de(o), Pr(c), d;
+  };
+  return i && n.set("length", /* @__PURE__ */ M(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(a, o, c) {
+        (!("value" in c) || c.configurable === !1 || c.enumerable === !1 || c.writable === !1) && Ds();
+        var d = n.get(o);
+        return d === void 0 ? d = l(() => {
+          var h = /* @__PURE__ */ M(c.value);
+          return n.set(o, h), h;
+        }) : E(d, c.value, !0), !0;
+      },
+      deleteProperty(a, o) {
+        var c = n.get(o);
+        if (c === void 0) {
+          if (o in a) {
+            const d = l(() => /* @__PURE__ */ M(B));
+            n.set(o, d), Kt(r);
+          }
+        } else
+          E(c, B), Kt(r);
+        return !0;
+      },
+      get(a, o, c) {
+        if (o === un)
+          return e;
+        var d = n.get(o), h = o in a;
+        if (d === void 0 && (!h || wt(a, o)?.writable) && (d = l(() => {
+          var p = De(h ? a[o] : B), v = /* @__PURE__ */ M(p);
+          return v;
+        }), n.set(o, d)), d !== void 0) {
+          var _ = u(d);
+          return _ === B ? void 0 : _;
+        }
+        return Reflect.get(a, o, c);
+      },
+      getOwnPropertyDescriptor(a, o) {
+        var c = Reflect.getOwnPropertyDescriptor(a, o);
+        if (c && "value" in c) {
+          var d = n.get(o);
+          d && (c.value = u(d));
+        } else if (c === void 0) {
+          var h = n.get(o), _ = h?.v;
+          if (h !== void 0 && _ !== B)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: _,
+              writable: !0
+            };
+        }
+        return c;
+      },
+      has(a, o) {
+        if (o === un)
+          return !0;
+        var c = n.get(o), d = c !== void 0 && c.v !== B || Reflect.has(a, o);
+        if (c !== void 0 || T !== null && (!d || wt(a, o)?.writable)) {
+          c === void 0 && (c = l(() => {
+            var _ = d ? De(a[o]) : B, p = /* @__PURE__ */ M(_);
+            return p;
+          }), n.set(o, c));
+          var h = u(c);
+          if (h === B)
+            return !1;
+        }
+        return d;
+      },
+      set(a, o, c, d) {
+        var h = n.get(o), _ = o in a;
+        if (i && o === "length")
+          for (var p = c; p < /** @type {Source<number>} */
+          h.v; p += 1) {
+            var v = n.get(p + "");
+            v !== void 0 ? E(v, B) : p in a && (v = l(() => /* @__PURE__ */ M(B)), n.set(p + "", v));
+          }
+        if (h === void 0)
+          (!_ || wt(a, o)?.writable) && (h = l(() => /* @__PURE__ */ M(void 0)), E(h, De(c)), n.set(o, h));
+        else {
+          _ = h.v !== B;
+          var g = l(() => De(c));
+          E(h, g);
+        }
+        var m = Reflect.getOwnPropertyDescriptor(a, o);
+        if (m?.set && m.set.call(d, c), !_) {
+          if (i && typeof o == "string") {
+            var S = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), C = Number(o);
+            Number.isInteger(C) && C >= S.v && E(S, C + 1);
+          }
+          Kt(r);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        u(r);
+        var o = Reflect.ownKeys(a).filter((h) => {
+          var _ = n.get(h);
+          return _ === void 0 || _.v !== B;
+        });
+        for (var [c, d] of n)
+          d.v !== B && !(c in a) && o.push(c);
+        return o;
+      },
+      setPrototypeOf() {
+        Is();
+      }
+    }
+  );
+}
+var Rr, mi, bi, wi;
+function Zn() {
+  if (Rr === void 0) {
+    Rr = window, mi = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    bi = wt(t, "firstChild").get, wi = wt(t, "nextSibling").get, Cr(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Cr(n) && (n.__t = void 0);
+  }
+}
+function ge(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Dt(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    bi.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Se(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    wi.call(e)
+  );
+}
+function q(e, t) {
+  if (!x)
+    return /* @__PURE__ */ Dt(e);
+  var n = /* @__PURE__ */ Dt(k);
+  if (n === null)
+    n = k.appendChild(ge());
+  else if (t && n.nodeType !== Cn) {
+    var i = ge();
+    return n?.before(i), ne(i), i;
+  }
+  return t && fr(
+    /** @type {Text} */
+    n
+  ), ne(n), n;
+}
+function et(e, t = !1) {
+  if (!x) {
+    var n = /* @__PURE__ */ Dt(e);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ Se(n) : n;
+  }
+  if (t) {
+    if (k?.nodeType !== Cn) {
+      var i = ge();
+      return k?.before(i), ne(i), i;
+    }
+    fr(
+      /** @type {Text} */
+      k
+    );
+  }
+  return k;
+}
+function z(e, t = 1, n = !1) {
+  let i = x ? k : e;
+  for (var r; t--; )
+    r = i, i = /** @type {TemplateNode} */
+    /* @__PURE__ */ Se(i);
+  if (!x)
+    return i;
+  if (n) {
+    if (i?.nodeType !== Cn) {
+      var s = ge();
+      return i === null ? r?.after(s) : i.before(s), ne(s), s;
+    }
+    fr(
+      /** @type {Text} */
+      i
+    );
+  }
+  return ne(i), i;
+}
+function $i(e) {
+  e.textContent = "";
+}
+function yi() {
+  return !1;
+}
+function fr(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Cn; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+let Nr = !1;
+function rl() {
+  Nr || (Nr = !0, document.addEventListener(
+    "reset",
+    (e) => {
+      Promise.resolve().then(() => {
+        if (!e.defaultPrevented)
+          for (
+            const t of
+            /**@type {HTMLFormElement} */
+            e.target.elements
+          )
+            t.__on_r?.();
+      });
+    },
+    // In the capture phase to guarantee we get noticed of it (no possibility of stopPropagation)
+    { capture: !0 }
+  ));
+}
+function Ei(e) {
+  var t = y, n = T;
+  de(null), ke(null);
+  try {
+    return e();
+  } finally {
+    de(t), ke(n);
+  }
+}
+function il(e) {
+  T === null && (y === null && Ns(), Rs()), Xe && Ms();
+}
+function sl(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function Ae(e, t, n) {
+  var i = T;
+  i !== null && (i.f & te) !== 0 && (e |= te);
+  var r = {
+    ctx: re,
+    deps: null,
+    nodes: null,
+    f: e | G | ue,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: i,
+    b: i && i.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (n)
+    try {
+      Xt(r), r.f |= An;
+    } catch (a) {
+      throw V(r), a;
+    }
+  else t !== null && ze(r);
+  var s = r;
+  if (n && s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+  (s.f & vt) === 0 && (s = s.first, (e & je) !== 0 && (e & Rt) !== 0 && s !== null && (s.f |= Rt)), s !== null && (s.parent = i, i !== null && sl(s, i), y !== null && (y.f & Y) !== 0 && (e & Je) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      y
+    );
+    (l.effects ?? (l.effects = [])).push(s);
+  }
+  return r;
+}
+function ur() {
+  return y !== null && !_e;
+}
+function ll(e) {
+  const t = Ae(Sn, null, !1);
+  return D(t, j), t.teardown = e, t;
+}
+function $t(e) {
+  il();
+  var t = (
+    /** @type {Effect} */
+    T.f
+  ), n = !y && (t & me) !== 0 && (t & An) === 0;
+  if (n) {
+    var i = (
+      /** @type {ComponentContext} */
+      re
+    );
+    (i.e ?? (i.e = [])).push(e);
+  } else
+    return xi(e);
+}
+function xi(e) {
+  return Ae(wn | Ts, e, !1);
+}
+function al(e) {
+  Fe.ensure();
+  const t = Ae(Je | vt, e, !0);
+  return () => {
+    V(t);
+  };
+}
+function ol(e) {
+  Fe.ensure();
+  const t = Ae(Je | vt, e, !0);
+  return (n = {}) => new Promise((i) => {
+    n.outro ? ut(t, () => {
+      V(t), i(void 0);
+    }) : (V(t), i(void 0));
+  });
+}
+function ki(e) {
+  return Ae(wn, e, !1);
+}
+function fl(e) {
+  return Ae(lr | vt, e, !0);
+}
+function cr(e, t = 0) {
+  return Ae(Sn | t, e, !0);
+}
+function tt(e, t = [], n = [], i = []) {
+  Xs(i, t, n, (r) => {
+    Ae(Sn, () => e(...r.map(u)), !0);
+  });
+}
+function dr(e, t = 0) {
+  var n = Ae(je | t, e, !0);
+  return n;
+}
+function oe(e) {
+  return Ae(me | vt, e, !0);
+}
+function Ti(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = Xe, i = y;
+    Lr(!0), de(null);
+    try {
+      t.call(null);
+    } finally {
+      Lr(n), de(i);
+    }
+  }
+}
+function Si(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const r = n.ac;
+    r !== null && Ei(() => {
+      r.abort(bt);
+    });
+    var i = n.next;
+    (n.f & Je) !== 0 ? n.parent = null : V(n, t), n = i;
+  }
+}
+function ul(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & me) === 0 && V(t), t = n;
+  }
+}
+function V(e, t = !0) {
+  var n = !1;
+  (t || (e.f & Jr) !== 0) && e.nodes !== null && e.nodes.end !== null && (cl(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), Si(e, t && !n), yn(e, 0), D(e, Ie);
+  var i = e.nodes && e.nodes.t;
+  if (i !== null)
+    for (const s of i)
+      s.stop();
+  Ti(e);
+  var r = e.parent;
+  r !== null && r.first !== null && Ai(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function cl(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ Se(e);
+    e.remove(), e = n;
+  }
+}
+function Ai(e) {
+  var t = e.parent, n = e.prev, i = e.next;
+  n !== null && (n.next = i), i !== null && (i.prev = n), t !== null && (t.first === e && (t.first = i), t.last === e && (t.last = n));
+}
+function ut(e, t, n = !0) {
+  var i = [];
+  Ci(e, i, !0);
+  var r = () => {
+    n && V(e), t && t();
+  }, s = i.length;
+  if (s > 0) {
+    var l = () => --s || r();
+    for (var a of i)
+      a.out(l);
+  } else
+    r();
+}
+function Ci(e, t, n) {
+  if ((e.f & te) === 0) {
+    e.f ^= te;
+    var i = e.nodes && e.nodes.t;
+    if (i !== null)
+      for (const a of i)
+        (a.is_global || n) && t.push(a);
+    for (var r = e.first; r !== null; ) {
+      var s = r.next, l = (r.f & Rt) !== 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.
+      (r.f & me) !== 0 && (e.f & je) !== 0;
+      Ci(r, t, l ? n : !1), r = s;
+    }
+  }
+}
+function hr(e) {
+  Oi(e, !0);
+}
+function Oi(e, t) {
+  if ((e.f & te) !== 0) {
+    e.f ^= te, (e.f & j) === 0 && (D(e, G), ze(e));
+    for (var n = e.first; n !== null; ) {
+      var i = n.next, r = (n.f & Rt) !== 0 || (n.f & me) !== 0;
+      Oi(n, r ? t : !1), n = i;
+    }
+    var s = e.nodes && e.nodes.t;
+    if (s !== null)
+      for (const l of s)
+        (l.is_global || t) && l.in();
+  }
+}
+function Mi(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, i = e.nodes.end; n !== null; ) {
+      var r = n === i ? null : /* @__PURE__ */ Se(n);
+      t.append(n), n = r;
+    }
+}
+let vn = !1, Xe = !1;
+function Lr(e) {
+  Xe = e;
+}
+let y = null, _e = !1;
+function de(e) {
+  y = e;
+}
+let T = null;
+function ke(e) {
+  T = e;
+}
+let ce = null;
+function Ri(e) {
+  y !== null && (ce === null ? ce = [e] : ce.push(e));
+}
+let K = null, J = 0, se = null;
+function dl(e) {
+  se = e;
+}
+let Ni = 1, rt = 0, ct = rt;
+function Pr(e) {
+  ct = e;
+}
+function Li() {
+  return ++Ni;
+}
+function rn(e) {
+  var t = e.f;
+  if ((t & G) !== 0)
+    return !0;
+  if (t & Y && (e.f &= ~dt), (t & Be) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), i = n.length, r = 0; r < i; r++) {
+      var s = n[r];
+      if (rn(
+        /** @type {Derived} */
+        s
+      ) && vi(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & ue) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    ve === null && D(e, j);
+  }
+  return !1;
+}
+function Pi(e, t, n = !0) {
+  var i = e.reactions;
+  if (i !== null && !(ce !== null && Mt.call(ce, e)))
+    for (var r = 0; r < i.length; r++) {
+      var s = i[r];
+      (s.f & Y) !== 0 ? Pi(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (n ? D(s, G) : (s.f & j) !== 0 && D(s, Be), ze(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Di(e) {
+  var g;
+  var t = K, n = J, i = se, r = y, s = ce, l = re, a = _e, o = ct, c = e.f;
+  K = /** @type {null | Value[]} */
+  null, J = 0, se = null, y = (c & (me | Je)) === 0 ? e : null, ce = null, Nt(e.ctx), _e = !1, ct = ++rt, e.ac !== null && (Ei(() => {
+    e.ac.abort(bt);
+  }), e.ac = null);
+  try {
+    e.f |= qn;
+    var d = (
+      /** @type {Function} */
+      e.fn
+    ), h = d(), _ = e.deps, p = R?.is_fork;
+    if (K !== null) {
+      var v;
+      if (p || yn(e, J), _ !== null && J > 0)
+        for (_.length = J + K.length, v = 0; v < K.length; v++)
+          _[J + v] = K[v];
+      else
+        e.deps = _ = K;
+      if (ur() && (e.f & ue) !== 0)
+        for (v = J; v < _.length; v++)
+          ((g = _[v]).reactions ?? (g.reactions = [])).push(e);
+    } else !p && _ !== null && J < _.length && (yn(e, J), _.length = J);
+    if (ti() && se !== null && !_e && _ !== null && (e.f & (Y | Be | G)) === 0)
+      for (v = 0; v < /** @type {Source[]} */
+      se.length; v++)
+        Pi(
+          se[v],
+          /** @type {Effect} */
+          e
+        );
+    if (r !== null && r !== e) {
+      if (rt++, r.deps !== null)
+        for (let m = 0; m < n; m += 1)
+          r.deps[m].rv = rt;
+      if (t !== null)
+        for (const m of t)
+          m.rv = rt;
+      se !== null && (i === null ? i = se : i.push(.../** @type {Source[]} */
+      se));
+    }
+    return (e.f & Ve) !== 0 && (e.f ^= Ve), h;
+  } catch (m) {
+    return ri(m);
+  } finally {
+    e.f ^= qn, K = t, J = n, se = i, y = r, ce = s, Nt(l), _e = a, ct = o;
+  }
+}
+function hl(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var i = $s.call(n, e);
+    if (i !== -1) {
+      var r = n.length - 1;
+      r === 0 ? n = t.reactions = null : (n[i] = n[r], n.pop());
+    }
+  }
+  if (n === null && (t.f & Y) !== 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
+  (K === null || !Mt.call(K, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & ue) !== 0 && (s.f ^= ue, s.f &= ~dt), ar(s), hi(s), yn(s, 0);
+  }
+}
+function yn(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var i = t; i < n.length; i++)
+      hl(e, n[i]);
+}
+function Xt(e) {
+  var t = e.f;
+  if ((t & Ie) === 0) {
+    D(e, j);
+    var n = T, i = vn;
+    T = e, vn = !0;
+    try {
+      (t & (je | Xr)) !== 0 ? ul(e) : Si(e), Ti(e);
+      var r = Di(e);
+      e.teardown = typeof r == "function" ? r : null, e.wv = Ni;
+      var s;
+      Un && Ys && (e.f & G) !== 0 && e.deps;
+    } finally {
+      vn = i, T = n;
+    }
+  }
+}
+function u(e) {
+  var t = e.f, n = (t & Y) !== 0;
+  if (y !== null && !_e) {
+    var i = T !== null && (T.f & Ie) !== 0;
+    if (!i && (ce === null || !Mt.call(ce, e))) {
+      var r = y.deps;
+      if ((y.f & qn) !== 0)
+        e.rv < rt && (e.rv = rt, K === null && r !== null && r[J] === e ? J++ : K === null ? K = [e] : K.push(e));
+      else {
+        (y.deps ?? (y.deps = [])).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [y] : Mt.call(s, y) || s.push(y);
+      }
+    }
+  }
+  if (Xe && We.has(e))
+    return We.get(e);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (Xe) {
+      var a = l.v;
+      return ((l.f & j) === 0 && l.reactions !== null || Fi(l)) && (a = or(l)), We.set(l, a), a;
+    }
+    var o = (l.f & ue) === 0 && !_e && y !== null && (vn || (y.f & ue) !== 0), c = l.deps === null;
+    rn(l) && (o && (l.f |= ue), vi(l)), o && !c && Ii(l);
+  }
+  if (ve?.has(e))
+    return ve.get(e);
+  if ((e.f & Ve) !== 0)
+    throw e.v;
+  return e.v;
+}
+function Ii(e) {
+  if (e.deps !== null) {
+    e.f |= ue;
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & Y) !== 0 && (t.f & ue) === 0 && Ii(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function Fi(e) {
+  if (e.v === B) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (We.has(t) || (t.f & Y) !== 0 && Fi(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function vr(e) {
+  var t = _e;
+  try {
+    return _e = !0, e();
+  } finally {
+    _e = t;
+  }
+}
+const zi = /* @__PURE__ */ new Set(), er = /* @__PURE__ */ new Set();
+function _r(e) {
+  for (var t = 0; t < e.length; t++)
+    zi.add(e[t]);
+  for (var n of er)
+    n(e);
+}
+let Dr = null;
+function on(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), i = e.type, r = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    r[0] || e.target
+  );
+  Dr = e;
+  var l = 0, a = Dr === e && e.__root;
+  if (a) {
+    var o = r.indexOf(a);
+    if (o !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var c = r.indexOf(t);
+    if (c === -1)
+      return;
+    o <= c && (l = o);
+  }
+  if (s = /** @type {Element} */
+  r[l] || e.target, s !== t) {
+    bn(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var d = y, h = T;
+    de(null), ke(null);
+    try {
+      for (var _, p = []; s !== null; ) {
+        var v = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var g = s["__" + i];
+          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 (m) {
+          _ ? p.push(m) : _ = m;
+        }
+        if (e.cancelBubble || v === t || v === null)
+          break;
+        s = v;
+      }
+      if (_) {
+        for (let m of p)
+          queueMicrotask(() => {
+            throw m;
+          });
+        throw _;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, de(d), ke(h);
+    }
+  }
+}
+function vl(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function yt(e, t) {
+  var n = (
+    /** @type {Effect} */
+    T
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function _t(e, t) {
+  var n = (t & ms) !== 0, i = (t & bs) !== 0, r, s = !e.startsWith("<!>");
+  return () => {
+    if (x)
+      return yt(k, null), k;
+    r === void 0 && (r = vl(s ? e : "<!>" + e), n || (r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Dt(r)));
+    var l = (
+      /** @type {TemplateNode} */
+      i || mi ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    if (n) {
+      var a = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Dt(l)
+      ), o = (
+        /** @type {TemplateNode} */
+        l.lastChild
+      );
+      yt(a, o);
+    } else
+      yt(l, l);
+    return l;
+  };
+}
+function ji() {
+  if (x)
+    return yt(k, null), k;
+  var e = document.createDocumentFragment(), t = document.createComment(""), n = ge();
+  return e.append(t, n), yt(t, n), e;
+}
+function xe(e, t) {
+  if (x) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      T
+    );
+    ((n.f & An) === 0 || n.nodes.end === null) && (n.nodes.end = k), nn();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const _l = ["touchstart", "touchmove"];
+function pl(e) {
+  return _l.includes(e);
+}
+function _n(e, t) {
+  var n = t == null ? "" : typeof t == "object" ? t + "" : t;
+  n !== (e.__t ?? (e.__t = e.nodeValue)) && (e.__t = n, e.nodeValue = n + "");
+}
+function Bi(e, t) {
+  return Yi(e, t);
+}
+function gl(e, t) {
+  Zn(), t.intro = t.intro ?? !1;
+  const n = t.target, i = x, r = k;
+  try {
+    for (var s = /* @__PURE__ */ Dt(n); s && (s.nodeType !== It || /** @type {Comment} */
+    s.data !== Vr); )
+      s = /* @__PURE__ */ Se(s);
+    if (!s)
+      throw Ot;
+    Pe(!0), ne(
+      /** @type {Comment} */
+      s
+    );
+    const l = Yi(e, { ...t, anchor: s });
+    return Pe(!1), /**  @type {Exports} */
+    l;
+  } catch (l) {
+    if (l instanceof Error && l.message.split(`
+`).some((a) => a.startsWith("https://svelte.dev/e/")))
+      throw l;
+    return l !== Ot && console.warn("Failed to hydrate: ", l), t.recover === !1 && Ps(), Zn(), $i(n), Pe(!1), Bi(e, t);
+  } finally {
+    Pe(i), ne(r);
+  }
+}
+const mt = /* @__PURE__ */ new Map();
+function Yi(e, { target: t, anchor: n, props: i = {}, events: r, context: s, intro: l = !0 }) {
+  Zn();
+  var a = /* @__PURE__ */ new Set(), o = (h) => {
+    for (var _ = 0; _ < h.length; _++) {
+      var p = h[_];
+      if (!a.has(p)) {
+        a.add(p);
+        var v = pl(p);
+        t.addEventListener(p, on, { passive: v });
+        var g = mt.get(p);
+        g === void 0 ? (document.addEventListener(p, on, { passive: v }), mt.set(p, 1)) : mt.set(p, g + 1);
+      }
+    }
+  };
+  o(Tn(zi)), er.add(o);
+  var c = void 0, d = ol(() => {
+    var h = n ?? t.appendChild(ge());
+    return Ws(
+      /** @type {TemplateNode} */
+      h,
+      {
+        pending: () => {
+        }
+      },
+      (_) => {
+        if (s) {
+          Mn({});
+          var p = (
+            /** @type {ComponentContext} */
+            re
+          );
+          p.c = s;
+        }
+        if (r && (i.$$events = r), x && yt(
+          /** @type {TemplateNode} */
+          _,
+          null
+        ), c = e(_, i) || {}, x && (T.nodes.end = k, k === null || k.nodeType !== It || /** @type {Comment} */
+        k.data !== ir))
+          throw On(), Ot;
+        s && Rn();
+      }
+    ), () => {
+      for (var _ of a) {
+        t.removeEventListener(_, on);
+        var p = (
+          /** @type {number} */
+          mt.get(_)
+        );
+        --p === 0 ? (document.removeEventListener(_, on), mt.delete(_)) : mt.set(_, p);
+      }
+      er.delete(o), h !== n && h.parentNode?.removeChild(h);
+    };
+  });
+  return tr.set(c, d), c;
+}
+let tr = /* @__PURE__ */ new WeakMap();
+function ml(e, t) {
+  const n = tr.get(e);
+  return n ? (tr.delete(e), n(t)) : Promise.resolve();
+}
+var he, Ee, Z, ft, en, tn, xn;
+class bl {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    /** @type {TemplateNode} */
+    N(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    $(this, he, /* @__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>}
+     */
+    $(this, Ee, /* @__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>}
+     */
+    $(this, Z, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    $(this, ft, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    $(this, en, !0);
+    $(this, tn, () => {
+      var t = (
+        /** @type {Batch} */
+        R
+      );
+      if (f(this, he).has(t)) {
+        var n = (
+          /** @type {Key} */
+          f(this, he).get(t)
+        ), i = f(this, Ee).get(n);
+        if (i)
+          hr(i), f(this, ft).delete(n);
+        else {
+          var r = f(this, Z).get(n);
+          r && (f(this, Ee).set(n, r.effect), f(this, Z).delete(n), r.fragment.lastChild.remove(), this.anchor.before(r.fragment), i = r.effect);
+        }
+        for (const [s, l] of f(this, he)) {
+          if (f(this, he).delete(s), s === t)
+            break;
+          const a = f(this, Z).get(l);
+          a && (V(a.effect), f(this, Z).delete(l));
+        }
+        for (const [s, l] of f(this, Ee)) {
+          if (s === n || f(this, ft).has(s)) continue;
+          const a = () => {
+            if (Array.from(f(this, he).values()).includes(s)) {
+              var c = document.createDocumentFragment();
+              Mi(l, c), c.append(ge()), f(this, Z).set(s, { effect: l, fragment: c });
+            } else
+              V(l);
+            f(this, ft).delete(s), f(this, Ee).delete(s);
+          };
+          f(this, en) || !i ? (f(this, ft).add(s), ut(l, a, !1)) : a();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    $(this, xn, (t) => {
+      f(this, he).delete(t);
+      const n = Array.from(f(this, he).values());
+      for (const [i, r] of f(this, Z))
+        n.includes(i) || (V(r.effect), f(this, Z).delete(i));
+    });
+    this.anchor = t, b(this, en, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var i = (
+      /** @type {Batch} */
+      R
+    ), r = yi();
+    if (n && !f(this, Ee).has(t) && !f(this, Z).has(t))
+      if (r) {
+        var s = document.createDocumentFragment(), l = ge();
+        s.append(l), f(this, Z).set(t, {
+          effect: oe(() => n(l)),
+          fragment: s
+        });
+      } else
+        f(this, Ee).set(
+          t,
+          oe(() => n(this.anchor))
+        );
+    if (f(this, he).set(i, t), r) {
+      for (const [a, o] of f(this, Ee))
+        a === t ? i.skipped_effects.delete(o) : i.skipped_effects.add(o);
+      for (const [a, o] of f(this, Z))
+        a === t ? i.skipped_effects.delete(o.effect) : i.skipped_effects.add(o.effect);
+      i.oncommit(f(this, tn)), i.ondiscard(f(this, xn));
+    } else
+      x && (this.anchor = k), f(this, tn).call(this);
+  }
+}
+he = new WeakMap(), Ee = new WeakMap(), Z = new WeakMap(), ft = new WeakMap(), en = new WeakMap(), tn = new WeakMap(), xn = new WeakMap();
+function Hi(e) {
+  re === null && Cs(), $t(() => {
+    const t = vr(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function pn(e, t, n = !1) {
+  x && nn();
+  var i = new bl(e), r = n ? Rt : 0;
+  function s(l, a) {
+    if (x) {
+      const c = Qr(e) === kn;
+      if (l === c) {
+        var o = $n();
+        ne(o), i.anchor = o, Pe(!1), i.ensure(l, a), Pe(!0);
+        return;
+      }
+    }
+    i.ensure(l, a);
+  }
+  dr(() => {
+    var l = !1;
+    t((a, o = !0) => {
+      l = !0, s(o, a);
+    }), l || s(!1, null);
+  }, r);
+}
+function wl(e, t) {
+  return t;
+}
+function $l(e, t, n) {
+  for (var i = [], r = t.length, s, l = t.length, a = 0; a < r; a++) {
+    let h = t[a];
+    ut(
+      h,
+      () => {
+        if (s) {
+          if (s.pending.delete(h), s.done.add(h), s.pending.size === 0) {
+            var _ = (
+              /** @type {Set<EachOutroGroup>} */
+              e.outrogroups
+            );
+            nr(Tn(s.done)), _.delete(s), _.size === 0 && (e.outrogroups = null);
+          }
+        } else
+          l -= 1;
+      },
+      !1
+    );
+  }
+  if (l === 0) {
+    var o = i.length === 0 && n !== null;
+    if (o) {
+      var c = (
+        /** @type {Element} */
+        n
+      ), d = (
+        /** @type {Element} */
+        c.parentNode
+      );
+      $i(d), d.append(c), e.items.clear();
+    }
+    nr(t, !o);
+  } else
+    s = {
+      pending: new Set(t),
+      done: /* @__PURE__ */ new Set()
+    }, (e.outrogroups ?? (e.outrogroups = /* @__PURE__ */ new Set())).add(s);
+}
+function nr(e, t = !0) {
+  for (var n = 0; n < e.length; n++)
+    V(e[n], t);
+}
+var Ir;
+function yl(e, t, n, i, r, s = null) {
+  var l = e, a = /* @__PURE__ */ new Map();
+  x && nn();
+  var o = null, c = /* @__PURE__ */ el(() => {
+    var g = n();
+    return Gr(g) ? g : g == null ? [] : Tn(g);
+  }), d, h = !0;
+  function _() {
+    v.fallback = o, El(v, d, l, t, i), o !== null && (d.length === 0 ? (o.f & qe) === 0 ? hr(o) : (o.f ^= qe, Gt(o, null, l)) : ut(o, () => {
+      o = null;
+    }));
+  }
+  var p = dr(() => {
+    d = /** @type {V[]} */
+    u(c);
+    var g = d.length;
+    let m = !1;
+    if (x) {
+      var S = Qr(l) === kn;
+      S !== (g === 0) && (l = $n(), ne(l), Pe(!1), m = !0);
+    }
+    for (var C = /* @__PURE__ */ new Set(), ie = (
+      /** @type {Batch} */
+      R
+    ), H = yi(), P = 0; P < g; P += 1) {
+      x && k.nodeType === It && /** @type {Comment} */
+      k.data === ir && (l = /** @type {Comment} */
+      k, m = !0, Pe(!1));
+      var be = d[P], A = i(be, P), I = h ? null : a.get(A);
+      I ? (I.v && Pt(I.v, be), I.i && Pt(I.i, P), H && ie.skipped_effects.delete(I.e)) : (I = xl(
+        a,
+        h ? l : Ir ?? (Ir = ge()),
+        be,
+        A,
+        P,
+        r,
+        t,
+        n
+      ), h || (I.e.f |= qe), a.set(A, I)), C.add(A);
+    }
+    if (g === 0 && s && !o && (h ? o = oe(() => s(l)) : (o = oe(() => s(Ir ?? (Ir = ge()))), o.f |= qe)), x && g > 0 && ne($n()), !h)
+      if (H) {
+        for (const [sn, Pn] of a)
+          C.has(sn) || ie.skipped_effects.add(Pn.e);
+        ie.oncommit(_), ie.ondiscard(() => {
+        });
+      } else
+        _();
+    m && Pe(!0), u(c);
+  }), v = { effect: p, items: a, outrogroups: null, fallback: o };
+  h = !1, x && (l = k);
+}
+function Vt(e) {
+  for (; e !== null && (e.f & me) === 0; )
+    e = e.next;
+  return e;
+}
+function El(e, t, n, i, r) {
+  var s = t.length, l = e.items, a = Vt(e.effect.first), o, c = null, d = [], h = [], _, p, v, g;
+  for (g = 0; g < s; g += 1) {
+    if (_ = t[g], p = r(_, g), v = /** @type {EachItem} */
+    l.get(p).e, e.outrogroups !== null)
+      for (const I of e.outrogroups)
+        I.pending.delete(v), I.done.delete(v);
+    if ((v.f & qe) !== 0)
+      if (v.f ^= qe, v === a)
+        Gt(v, null, n);
+      else {
+        var m = c ? c.next : a;
+        v === e.effect.last && (e.effect.last = v.prev), v.prev && (v.prev.next = v.next), v.next && (v.next.prev = v.prev), Ye(e, c, v), Ye(e, v, m), Gt(v, m, n), c = v, d = [], h = [], a = Vt(c.next);
+        continue;
+      }
+    if ((v.f & te) !== 0 && hr(v), v !== a) {
+      if (o !== void 0 && o.has(v)) {
+        if (d.length < h.length) {
+          var S = h[0], C;
+          c = S.prev;
+          var ie = d[0], H = d[d.length - 1];
+          for (C = 0; C < d.length; C += 1)
+            Gt(d[C], S, n);
+          for (C = 0; C < h.length; C += 1)
+            o.delete(h[C]);
+          Ye(e, ie.prev, H.next), Ye(e, c, ie), Ye(e, H, S), a = S, c = H, g -= 1, d = [], h = [];
+        } else
+          o.delete(v), Gt(v, a, n), Ye(e, v.prev, v.next), Ye(e, v, c === null ? e.effect.first : c.next), Ye(e, c, v), c = v;
+        continue;
+      }
+      for (d = [], h = []; a !== null && a !== v; )
+        (o ?? (o = /* @__PURE__ */ new Set())).add(a), h.push(a), a = Vt(a.next);
+      if (a === null)
+        continue;
+    }
+    (v.f & qe) === 0 && d.push(v), c = v, a = Vt(v.next);
+  }
+  if (e.outrogroups !== null) {
+    for (const I of e.outrogroups)
+      I.pending.size === 0 && (nr(Tn(I.done)), e.outrogroups?.delete(I));
+    e.outrogroups.size === 0 && (e.outrogroups = null);
+  }
+  if (a !== null || o !== void 0) {
+    var P = [];
+    if (o !== void 0)
+      for (v of o)
+        (v.f & te) === 0 && P.push(v);
+    for (; a !== null; )
+      (a.f & te) === 0 && a !== e.fallback && P.push(a), a = Vt(a.next);
+    var be = P.length;
+    if (be > 0) {
+      var A = null;
+      $l(e, P, A);
+    }
+  }
+}
+function xl(e, t, n, i, r, s, l, a) {
+  var o = (l & _s) !== 0 ? (l & gs) === 0 ? /* @__PURE__ */ pi(n, !1, !1) : ht(n) : null, c = (l & ps) !== 0 ? ht(r) : null;
+  return {
+    v: o,
+    i: c,
+    e: oe(() => (s(t, o ?? n, c ?? r, a), () => {
+      e.delete(i);
+    }))
+  };
+}
+function Gt(e, t, n) {
+  if (e.nodes)
+    for (var i = e.nodes.start, r = e.nodes.end, s = t && (t.f & qe) === 0 ? (
+      /** @type {EffectNodes} */
+      t.nodes.start
+    ) : n; i !== null; ) {
+      var l = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Se(i)
+      );
+      if (s.before(i), i === r)
+        return;
+      i = l;
+    }
+}
+function Ye(e, t, n) {
+  t === null ? e.effect.first = n : t.next = n, n === null ? e.effect.last = t : n.prev = t;
+}
+function kl(e, t, n, i, r) {
+  x && nn();
+  var s = t.$$slots?.[n], l = !1;
+  s === !0 && (s = t.children, l = !0), s === void 0 || s(e, l ? () => i : i);
+}
+function Tl(e, t) {
+  ki(() => {
+    var n = e.getRootNode(), i = (
+      /** @type {ShadowRoot} */
+      n.host ? (
+        /** @type {ShadowRoot} */
+        n
+      ) : (
+        /** @type {Document} */
+        n.head ?? /** @type {Document} */
+        n.ownerDocument.head
+      )
+    );
+    if (!i.querySelector("#" + t.hash)) {
+      const r = document.createElement("style");
+      r.id = t.hash, r.textContent = t.code, i.appendChild(r);
+    }
+  });
+}
+const Fr = [...` 	
+\r\f \v\uFEFF`];
+function Sl(e, t, n) {
+  var i = "" + e;
+  if (n) {
+    for (var r in n)
+      if (n[r])
+        i = i ? i + " " + r : r;
+      else if (i.length)
+        for (var s = r.length, l = 0; (l = i.indexOf(r, l)) >= 0; ) {
+          var a = l + s;
+          (l === 0 || Fr.includes(i[l - 1])) && (a === i.length || Fr.includes(i[a])) ? i = (l === 0 ? "" : i.substring(0, l)) + i.substring(a + 1) : l = a;
+        }
+  }
+  return i === "" ? null : i;
+}
+function Al(e, t) {
+  return e == null ? null : String(e);
+}
+function Cl(e, t, n, i, r, s) {
+  var l = e.__className;
+  if (x || l !== n || l === void 0) {
+    var a = Sl(n, i, s);
+    (!x || a !== e.getAttribute("class")) && (a == null ? e.removeAttribute("class") : e.className = a), e.__className = n;
+  } else if (s && r !== s)
+    for (var o in s) {
+      var c = !!s[o];
+      (r == null || c !== !!r[o]) && e.classList.toggle(o, c);
+    }
+  return s;
+}
+function He(e, t, n, i) {
+  var r = e.__style;
+  if (x || r !== t) {
+    var s = Al(t);
+    (!x || s !== e.getAttribute("style")) && (s == null ? e.removeAttribute("style") : e.style.cssText = s), e.__style = t;
+  }
+  return i;
+}
+const Ol = /* @__PURE__ */ Symbol("is custom element"), Ml = /* @__PURE__ */ Symbol("is html");
+function fn(e) {
+  if (x) {
+    var t = !1, n = () => {
+      if (!t) {
+        if (t = !0, e.hasAttribute("value")) {
+          var i = e.value;
+          Ke(e, "value", null), e.value = i;
+        }
+        if (e.hasAttribute("checked")) {
+          var r = e.checked;
+          Ke(e, "checked", null), e.checked = r;
+        }
+      }
+    };
+    e.__on_r = n, Ge(n), rl();
+  }
+}
+function zr(e, t) {
+  var n = pr(e);
+  n.value === (n.value = // treat null and undefined the same for the initial value
+  t ?? void 0) || // @ts-expect-error
+  // `progress` elements always need their value set when it's `0`
+  e.value === t && (t !== 0 || e.nodeName !== "PROGRESS") || (e.value = t ?? "");
+}
+function Hn(e, t) {
+  var n = pr(e);
+  n.checked !== (n.checked = // treat null and undefined the same for the initial value
+  t ?? void 0) && (e.checked = t);
+}
+function Ke(e, t, n, i) {
+  var r = pr(e);
+  x && (r[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === "LINK") || r[t] !== (r[t] = n) && (t === "loading" && (e[As] = n), n == null ? e.removeAttribute(t) : typeof n != "string" && Rl(e).includes(t) ? e[t] = n : e.setAttribute(t, n));
+}
+function pr(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Ol]: e.nodeName.includes("-"),
+      [Ml]: e.namespaceURI === ws
+    })
+  );
+}
+var jr = /* @__PURE__ */ new Map();
+function Rl(e) {
+  var t = e.getAttribute("is") || e.nodeName, n = jr.get(t);
+  if (n) return n;
+  jr.set(t, n = []);
+  for (var i, r = e, s = Element.prototype; s !== r; ) {
+    i = ys(r);
+    for (var l in i)
+      i[l].set && n.push(l);
+    r = Wr(r);
+  }
+  return n;
+}
+function Br(e, t) {
+  return e === t || e?.[un] === t;
+}
+function gr(e = {}, t, n, i) {
+  return ki(() => {
+    var r, s;
+    return cr(() => {
+      r = s, s = [], vr(() => {
+        e !== n(...s) && (t(e, ...s), r && Br(n(...r), e) && t(null, ...r));
+      });
+    }), () => {
+      Ge(() => {
+        s && Br(n(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+function pe(e, t, n, i) {
+  var r = (
+    /** @type {V} */
+    i
+  ), s = !0, l = () => (s && (s = !1, r = /** @type {V} */
+  i), r), a;
+  a = /** @type {V} */
+  e[t], a === void 0 && i !== void 0 && (a = l());
+  var o;
+  o = () => {
+    var _ = (
+      /** @type {V} */
+      e[t]
+    );
+    return _ === void 0 ? l() : (s = !0, _);
+  };
+  var c = !1, d = /* @__PURE__ */ Ln(() => (c = !1, o())), h = (
+    /** @type {Effect} */
+    T
+  );
+  return (
+    /** @type {() => V} */
+    (function(_, p) {
+      if (arguments.length > 0) {
+        const v = p ? u(d) : _;
+        return E(d, v), c = !0, r !== void 0 && (r = v), _;
+      }
+      return Xe && c || (h.f & Ie) !== 0 ? d.v : u(d);
+    })
+  );
+}
+function Nl(e) {
+  return new Ll(e);
+}
+var Le, ae;
+class Ll {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    $(this, Le);
+    /** @type {Record<string, any>} */
+    $(this, ae);
+    var n = /* @__PURE__ */ new Map(), i = (s, l) => {
+      var a = /* @__PURE__ */ pi(l, !1, !1);
+      return n.set(s, a), a;
+    };
+    const r = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return u(n.get(l) ?? i(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === Ss ? !0 : (u(n.get(l) ?? i(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, a) {
+          return E(n.get(l) ?? i(l, a), a), Reflect.set(s, l, a);
+        }
+      }
+    );
+    b(this, ae, (t.hydrate ? gl : Bi)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: r,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover
+    })), (!t?.props?.$$host || t.sync === !1) && fe(), b(this, Le, r.$$events);
+    for (const s of Object.keys(f(this, ae)))
+      s === "$set" || s === "$destroy" || s === "$on" || bn(this, s, {
+        get() {
+          return f(this, ae)[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          f(this, ae)[s] = l;
+        },
+        enumerable: !0
+      });
+    f(this, ae).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(r, s);
+    }, f(this, ae).$destroy = () => {
+      ml(f(this, ae));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    f(this, ae).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, n) {
+    f(this, Le)[t] = f(this, Le)[t] || [];
+    const i = (...r) => n.call(this, ...r);
+    return f(this, Le)[t].push(i), () => {
+      f(this, Le)[t] = f(this, Le)[t].filter(
+        /** @param {any} fn */
+        (r) => r !== i
+      );
+    };
+  }
+  $destroy() {
+    f(this, ae).$destroy();
+  }
+}
+Le = new WeakMap(), ae = new WeakMap();
+let Ui;
+typeof HTMLElement == "function" && (Ui = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(t, n, i) {
+    super();
+    /** The Svelte component constructor */
+    N(this, "$$ctor");
+    /** Slots */
+    N(this, "$$s");
+    /** @type {any} The Svelte component instance */
+    N(this, "$$c");
+    /** Whether or not the custom element is connected */
+    N(this, "$$cn", !1);
+    /** @type {Record<string, any>} Component props data */
+    N(this, "$$d", {});
+    /** `true` if currently in the process of reflecting component props back to attributes */
+    N(this, "$$r", !1);
+    /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+    N(this, "$$p_d", {});
+    /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+    N(this, "$$l", {});
+    /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+    N(this, "$$l_u", /* @__PURE__ */ new Map());
+    /** @type {any} The managed render effect for reflecting attributes */
+    N(this, "$$me");
+    /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+    N(this, "$$shadowRoot", null);
+    this.$$ctor = t, this.$$s = n, i && (this.$$shadowRoot = this.attachShadow(i));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(t, n, i) {
+    if (this.$$l[t] = this.$$l[t] || [], this.$$l[t].push(n), this.$$c) {
+      const r = this.$$c.$on(t, n);
+      this.$$l_u.set(n, r);
+    }
+    super.addEventListener(t, n, i);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(t, n, i) {
+    if (super.removeEventListener(t, n, i), this.$$c) {
+      const r = this.$$l_u.get(n);
+      r && (r(), this.$$l_u.delete(n));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let t = function(r) {
+        return (s) => {
+          const l = document.createElement("slot");
+          r !== "default" && (l.name = r), xe(s, l);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const n = {}, i = Pl(this);
+      for (const r of this.$$s)
+        r in i && (r === "default" && !this.$$d.children ? (this.$$d.children = t(r), n.default = !0) : n[r] = t(r));
+      for (const r of this.attributes) {
+        const s = this.$$g_p(r.name);
+        s in this.$$d || (this.$$d[s] = gn(s, 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 = Nl({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: n,
+          $$host: this
+        }
+      }), this.$$me = al(() => {
+        cr(() => {
+          this.$$r = !0;
+          for (const r of mn(this.$$c)) {
+            if (!this.$$p_d[r]?.reflect) continue;
+            this.$$d[r] = this.$$c[r];
+            const s = gn(
+              r,
+              this.$$d[r],
+              this.$$p_d,
+              "toAttribute"
+            );
+            s == null ? this.removeAttribute(this.$$p_d[r].attribute || r) : this.setAttribute(this.$$p_d[r].attribute || r, s);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const r in this.$$l)
+        for (const s of this.$$l[r]) {
+          const l = this.$$c.$on(r, s);
+          this.$$l_u.set(s, l);
+        }
+      this.$$l = {};
+    }
+  }
+  // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+  // and setting attributes through setAttribute etc, this is helpful
+  /**
+   * @param {string} attr
+   * @param {string} _oldValue
+   * @param {string} newValue
+   */
+  attributeChangedCallback(t, n, i) {
+    this.$$r || (t = this.$$g_p(t), this.$$d[t] = gn(t, i, this.$$p_d, "toProp"), this.$$c?.$set({ [t]: this.$$d[t] }));
+  }
+  disconnectedCallback() {
+    this.$$cn = !1, Promise.resolve().then(() => {
+      !this.$$cn && this.$$c && (this.$$c.$destroy(), this.$$me(), this.$$c = void 0);
+    });
+  }
+  /**
+   * @param {string} attribute_name
+   */
+  $$g_p(t) {
+    return mn(this.$$p_d).find(
+      (n) => this.$$p_d[n].attribute === t || !this.$$p_d[n].attribute && n.toLowerCase() === t
+    ) || t;
+  }
+});
+function gn(e, t, n, i) {
+  const r = n[e]?.type;
+  if (t = r === "Boolean" && typeof t != "boolean" ? t != null : t, !i || !n[e])
+    return t;
+  if (i === "toAttribute")
+    switch (r) {
+      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 (r) {
+      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 Pl(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function mr(e, t, n, i, r, s) {
+  let l = class extends Ui {
+    constructor() {
+      super(e, n, r), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return mn(t).map(
+        (a) => (t[a].attribute || a).toLowerCase()
+      );
+    }
+  };
+  return mn(t).forEach((a) => {
+    bn(l.prototype, a, {
+      get() {
+        return this.$$c && a in this.$$c ? this.$$c[a] : this.$$d[a];
+      },
+      set(o) {
+        o = gn(a, o, t), this.$$d[a] = o;
+        var c = this.$$c;
+        if (c) {
+          var d = wt(c, a)?.get;
+          d ? c[a] = o : c.$set({ [a]: o });
+        }
+      }
+    });
+  }), i.forEach((a) => {
+    bn(l.prototype, a, {
+      get() {
+        return this.$$c?.[a];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+var Yr;
+(function(e) {
+  e.TTS_WORD = "tts-word", e.TTS_SENTENCE = "tts-sentence", e.ANNOTATION = "annotation";
+})(Yr || (Yr = {}));
+var Hr;
+(function(e) {
+  e.YELLOW = "yellow", e.GREEN = "green", e.BLUE = "blue", e.PINK = "pink", e.ORANGE = "orange";
+})(Hr || (Hr = {}));
+const Dl = {
+  // Standard QTI 3.0 PNP supports
+  textToSpeech: "pie-tool-text-to-speech",
+  calculator: "pie-tool-calculator",
+  ruler: "pie-tool-ruler",
+  protractor: "pie-tool-protractor",
+  highlighter: "pie-tool-annotation-toolbar",
+  lineReader: "pie-tool-line-reader",
+  magnifier: "pie-tool-magnifier",
+  colorContrast: "pie-theme-contrast",
+  answerMasking: "pie-tool-answer-eliminator",
+  dictionaryLookup: "pie-tool-dictionary",
+  // Common extensions (not in QTI standard but widely used)
+  graphingCalculator: "pie-tool-calculator",
+  scientificCalculator: "pie-tool-calculator",
+  basicCalculator: "pie-tool-calculator"
+};
+Object.fromEntries(Object.entries(Dl).map(([e, t]) => [t, e]));
+var rr;
+(function(e) {
+  e[e.BASE = 0] = "BASE", e[e.TOOL = 1e3] = "TOOL", e[e.MODAL = 2e3] = "MODAL", e[e.CONTROL = 3e3] = "CONTROL", e[e.HIGHLIGHT = 4e3] = "HIGHLIGHT";
+})(rr || (rr = {}));
+var Ur;
+(function(e) {
+  e.IDLE = "idle", e.LOADING = "loading", e.PLAYING = "playing", e.PAUSED = "paused", e.ERROR = "error";
+})(Ur || (Ur = {}));
+var Il = /* @__PURE__ */ _t('<button type="button" class="btn btn-ghost btn-sm btn-circle"><svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="w-5 h-5"><path stroke-linecap="round" stroke-linejoin="round" d="M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.324.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 011.37.49l1.296 2.247a1.125 1.125 0 01-.26 1.431l-1.003.827c-.293.24-.438.613-.431.992a6.759 6.759 0 010 .255c-.007.378.138.75.43.99l1.005.828c.424.35.534.954.26 1.43l-1.298 2.247a1.125 1.125 0 01-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.57 6.57 0 01-.22.128c-.331.183-.581.495-.644.869l-.213 1.28c-.09.543-.56.941-1.11.941h-2.594c-.55 0-1.02-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 01-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 01-1.369-.49l-1.297-2.247a1.125 1.125 0 01.26-1.431l1.004-.827c.292-.24.437-.613.43-.992a6.932 6.932 0 010-.255c.007-.378-.138-.75-.43-.99l-1.004-.828a1.125 1.125 0 01-.26-1.43l1.297-2.247a1.125 1.125 0 011.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.087.22-.128.332-.183.582-.495.644-.869l.214-1.281z"></path><path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"></path></svg></button>');
+function qi(e, t) {
+  Mn(t, !0);
+  let n = pe(t, "buttonEl", 7, null), i = pe(t, "onClick"), r = pe(t, "ariaLabel", 7, "Settings"), s = pe(t, "active", 7, !1);
+  var l = {
+    get buttonEl() {
+      return n();
+    },
+    set buttonEl(o = null) {
+      n(o), fe();
+    },
+    get onClick() {
+      return i();
+    },
+    set onClick(o) {
+      i(o), fe();
+    },
+    get ariaLabel() {
+      return r();
+    },
+    set ariaLabel(o = "Settings") {
+      r(o), fe();
+    },
+    get active() {
+      return s();
+    },
+    set active(o = !1) {
+      s(o), fe();
+    }
+  }, a = Il();
+  return a.__click = function(...o) {
+    i()?.apply(this, o);
+  }, gr(a, (o) => n(o), () => n()), tt(() => {
+    Ke(a, "aria-label", r()), Ke(a, "aria-pressed", s());
+  }), xe(e, a), Rn(l);
+}
+_r(["click"]);
+mr(qi, { buttonEl: {}, onClick: {}, ariaLabel: {}, active: {} }, [], [], { mode: "open" });
+var Fl = /* @__PURE__ */ _t('<div class="fixed inset-0" aria-hidden="true" style="z-index: 4000;"></div> <div class="tool-settings-panel fixed w-80 rounded-box bg-base-100 shadow p-3 text-base-content" role="dialog" tabindex="-1"><div class="flex items-center justify-between gap-2 mb-2"><h2 class="font-semibold text-sm"> </h2> <button type="button" class="btn btn-ghost btn-xs" aria-label="Close settings">Close</button></div> <div class="text-sm"><!></div></div>', 1);
+function Vi(e, t) {
+  Mn(t, !0);
+  let n = pe(t, "open"), i = pe(t, "title", 7, "Settings"), r = pe(t, "onClose"), s = pe(t, "anchorEl", 7, null), l = /* @__PURE__ */ M(null), a = /* @__PURE__ */ M(null);
+  function o(p) {
+    p.key === "Escape" && r()();
+  }
+  $t(() => {
+    n() && queueMicrotask(() => u(l)?.focus?.());
+  }), $t(() => {
+    if (n() && s()) {
+      const p = s().getBoundingClientRect(), v = 320, g = 8, m = p.right + g;
+      m + v <= window.innerWidth ? E(a, { top: p.top, left: m }, !0) : E(
+        a,
+        {
+          top: p.top,
+          right: window.innerWidth - p.left + g
+        },
+        !0
+      );
+    } else
+      E(a, null);
+  }), Hi(() => {
+    const p = (v) => {
+      if (!n()) return;
+      const g = v.target;
+      g && (u(l)?.contains(g) || s()?.contains(g) || r()());
+    };
+    return document.addEventListener("mousedown", p), () => document.removeEventListener("mousedown", p);
+  });
+  var c = {
+    get open() {
+      return n();
+    },
+    set open(p) {
+      n(p), fe();
+    },
+    get title() {
+      return i();
+    },
+    set title(p = "Settings") {
+      i(p), fe();
+    },
+    get onClose() {
+      return r();
+    },
+    set onClose(p) {
+      r(p), fe();
+    },
+    get anchorEl() {
+      return s();
+    },
+    set anchorEl(p = null) {
+      s(p), fe();
+    }
+  }, d = ji(), h = et(d);
+  {
+    var _ = (p) => {
+      var v = Fl(), g = et(v);
+      g.__mousedown = function(...A) {
+        r()?.apply(this, A);
+      };
+      var m = z(g, 2);
+      m.__keydown = o;
+      var S = q(m), C = q(S), ie = q(C, !0);
+      U(C);
+      var H = z(C, 2);
+      H.__click = function(...A) {
+        r()?.apply(this, A);
+      }, U(S);
+      var P = z(S, 2), be = q(P);
+      kl(be, t, "default", {}), U(P), U(m), gr(m, (A) => E(l, A), () => u(l)), tt(() => {
+        Ke(m, "aria-label", i()), He(m, `z-index: 4100; ${u(a) ? `top: ${u(a).top}px; ${u(a).left !== void 0 ? `left: ${u(a).left}px;` : `right: ${u(a).right}px;`}` : "top: 4rem; right: 1rem;"}`), _n(ie, i());
+      }), xe(p, v);
+    };
+    pn(h, (p) => {
+      n() && p(_);
+    });
+  }
+  return xe(e, d), Rn(c);
+}
+_r(["mousedown", "keydown", "click"]);
+mr(Vi, { open: {}, title: {}, onClose: {}, anchorEl: {} }, ["default"], [], { mode: "open" });
+var zl = /* @__PURE__ */ _t('<div class="line-reader-mask line-reader-mask-top svelte-1a3d6dx" aria-hidden="true"></div> <div class="line-reader-mask line-reader-mask-bottom svelte-1a3d6dx" aria-hidden="true"></div> <div class="line-reader-mask line-reader-mask-left svelte-1a3d6dx" aria-hidden="true"></div> <div class="line-reader-mask line-reader-mask-right svelte-1a3d6dx" aria-hidden="true"></div>', 1), jl = /* @__PURE__ */ _t('<label><input type="radio" name="color"/> <div class="color-swatch"></div> <span> </span></label>'), Bl = /* @__PURE__ */ _t('<fieldset class="setting-group"><legend>Color</legend> <!></fieldset> <div class="setting-group"><div class="setting-label"><span>Opacity</span> <span class="setting-value" aria-live="polite"> </span></div> <input type="range" min="10" max="90" step="5" aria-label="Opacity" aria-valuemin="10" aria-valuemax="90"/></div>', 1), Yl = /* @__PURE__ */ _t('<fieldset class="setting-group"><legend>Mode</legend> <label><input type="radio" name="mode" value="highlight"/> <span>Highlight</span></label> <label><input type="radio" name="mode" value="obscure"/> <span>Masking</span></label></fieldset> <!>', 1), Hl = /* @__PURE__ */ _t('<div class="sr-only svelte-1a3d6dx" role="status" aria-live="polite" aria-atomic="true"> </div> <!>  <div role="application" tabindex="0" aria-roledescription="Draggable and resizable reading guide overlay"><div class="line-reader-container svelte-1a3d6dx"><!></div> <div class="resize-handle resize-handle-bottom svelte-1a3d6dx" title="Drag to resize height" role="button" tabindex="-1" aria-label="Resize handle - drag to adjust height"><svg width="20" height="8" viewBox="0 0 20 8" aria-hidden="true"><rect x="8" y="3" width="4" height="2" fill="#4CAF50" rx="1"></rect></svg></div></div> <!>', 1);
+const Ul = {
+  hash: "svelte-1a3d6dx",
+  code: `.sr-only.svelte-1a3d6dx {position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border-width:0;}.line-reader-frame.svelte-1a3d6dx {border:2px solid rgba(76, 175, 80, 0.8);cursor:move;overflow:visible;position:absolute;transform:translate(-50%, -50%);user-select:none;pointer-events:auto;touch-action:none;}.line-reader-frame.svelte-1a3d6dx:focus {outline:3px solid #4A90E2;outline-offset:2px;}.line-reader-frame.svelte-1a3d6dx:focus-visible {outline:3px solid #4A90E2;outline-offset:2px;}.line-reader-container.svelte-1a3d6dx {width:100%;height:100%;position:relative;transition:background-color 0.2s ease;}.resize-handle.svelte-1a3d6dx {position:absolute;cursor:ns-resize;z-index:10;display:flex;align-items:center;justify-content:center;}.resize-handle-bottom.svelte-1a3d6dx {bottom:-10px;left:50%;transform:translateX(-50%);width:40px;height:16px;background-color:rgba(255, 255, 255, 0.9);border-radius:8px;border:2px solid #4CAF50;}.resize-handle.svelte-1a3d6dx:hover {background-color:rgba(76, 175, 80, 0.2);}.resize-handle.svelte-1a3d6dx:active {cursor:ns-resize;}.line-reader-frame.svelte-1a3d6dx:active {cursor:grabbing;}
+
+	/* Masking overlays for obscure mode - 4 rectangles covering all areas except line reader window */.line-reader-mask.svelte-1a3d6dx {position:fixed;background:rgba(0, 0, 0, 0.85);z-index:999;pointer-events:none;}.line-reader-mask-top.svelte-1a3d6dx {top:0;left:0;right:0;
+		/* Height set via inline style */}.line-reader-mask-bottom.svelte-1a3d6dx {
+		/* Top set via inline style */left:0;right:0;bottom:0;}.line-reader-mask-left.svelte-1a3d6dx {
+		/* Top, height, and width set via inline style */left:0;}.line-reader-mask-right.svelte-1a3d6dx {
+		/* Top, height, and left set via inline style */right:0;}
+
+	/* In masking mode, change the window appearance */.line-reader-frame.masking-mode.svelte-1a3d6dx {border-color:rgba(76, 175, 80, 1);box-shadow:0 0 0 3px rgba(76, 175, 80, 0.8), 0 0 20px rgba(76, 175, 80, 0.4);}
+
+	/* In masking mode, the window should be transparent to show content underneath */.line-reader-frame.masking-mode.svelte-1a3d6dx .line-reader-container:where(.svelte-1a3d6dx) {background-color:transparent !important;}`
+};
+function ql(e, t) {
+  Mn(t, !0), Tl(e, Ul);
+  let n = pe(t, "visible", 7, !1), i = pe(t, "toolId", 7, "lineReader"), r = pe(t, "coordinator");
+  const s = typeof window < "u";
+  let l = /* @__PURE__ */ M(void 0), a = /* @__PURE__ */ M(void 0), o = /* @__PURE__ */ M(!1), c = /* @__PURE__ */ M(!1), d = /* @__PURE__ */ M(De({
+    x: s ? window.innerWidth / 2 : 400,
+    y: s ? window.innerHeight / 2 : 300
+  })), h = /* @__PURE__ */ M(De({ width: 600, height: 60 })), _ = /* @__PURE__ */ M(De({ x: 0, y: 0 })), p = /* @__PURE__ */ M(De({ width: 0, height: 0, mouseY: 0 })), v = /* @__PURE__ */ M(""), g = /* @__PURE__ */ M(
+    "#ffff00"
+    // Yellow
+  ), m = /* @__PURE__ */ M(0.3), S = /* @__PURE__ */ M("highlight"), C = /* @__PURE__ */ M(!1), ie = /* @__PURE__ */ M(!1);
+  const H = [
+    { name: "Yellow", value: "#ffff00" },
+    { name: "Blue", value: "#00bfff" },
+    { name: "Pink", value: "#ff69b4" },
+    { name: "Green", value: "#00ff7f" },
+    { name: "Orange", value: "#ffa500" }
+  ], P = 10, be = 10;
+  function A(w) {
+    E(v, w, !0), setTimeout(() => E(v, ""), 1e3);
+  }
+  function I() {
+    const O = (H.findIndex((Qe) => Qe.value === u(g)) + 1) % H.length;
+    E(g, H[O].value, !0), A(`Color changed to ${H[O].name}`);
+  }
+  function sn(w) {
+    E(m, Math.max(0.1, Math.min(0.9, u(m) + w)), !0), A(`Opacity ${Math.round(u(m) * 100)}%`);
+  }
+  function Pn() {
+    E(S, u(S) === "highlight" ? "obscure" : "highlight", !0), A(`Mode changed to ${u(S) === "highlight" ? "highlight" : "masking"}`);
+  }
+  function Gi() {
+    E(C, !u(C));
+  }
+  function Wi() {
+    E(C, !1);
+  }
+  function Ki(w) {
+    E(g, w, !0);
+    const O = H.find((Qe) => Qe.value === w)?.name || "Unknown";
+    A(`Color changed to ${O}`);
+  }
+  function Xi(w) {
+    const O = w.target;
+    if (O.closest(".resize-handle"))
+      Qi(w);
+    else {
+      if (O.closest(".tool-settings-button") || O.closest(".tool-settings-panel"))
+        return;
+      Ji(w);
+    }
+  }
+  function Ji(w) {
+    u(l) && (u(l).setPointerCapture(w.pointerId), E(o, !0), E(
+      _,
+      {
+        x: w.clientX - u(d).x,
+        y: w.clientY - u(d).y
+      },
+      !0
+    ), r()?.bringToFront(u(l)), u(l).addEventListener("pointermove", Dn), u(l).addEventListener("pointerup", In), w.preventDefault());
+  }
+  function Qi(w) {
+    u(l) && (u(l).setPointerCapture(w.pointerId), E(c, !0), E(
+      p,
+      {
+        width: u(h).width,
+        height: u(h).height,
+        mouseY: w.clientY
+      },
+      !0
+    ), r()?.bringToFront(u(l)), u(l).addEventListener("pointermove", Dn), u(l).addEventListener("pointerup", In), w.preventDefault(), w.stopPropagation());
+  }
+  function Dn(w) {
+    if (u(o))
+      E(
+        d,
+        {
+          x: w.clientX - u(_).x,
+          y: w.clientY - u(_).y
+        },
+        !0
+      );
+    else if (u(c)) {
+      const O = w.clientY - u(p).mouseY;
+      u(h).height = Math.max(20, Math.min(400, u(p).height + O));
+    }
+  }
+  function In(w) {
+    u(l) && (u(l).releasePointerCapture(w.pointerId), u(l).removeEventListener("pointermove", Dn), u(l).removeEventListener("pointerup", In), E(o, !1), E(c, !1));
+  }
+  function Zi(w) {
+    let O = !1;
+    switch (w.key) {
+      case "ArrowUp":
+        u(d).y -= P, A(`Moved up to ${Math.round(u(d).y)}`), O = !0;
+        break;
+      case "ArrowDown":
+        u(d).y += P, A(`Moved down to ${Math.round(u(d).y)}`), O = !0;
+        break;
+      case "ArrowLeft":
+        u(d).x -= P, A(`Moved left to ${Math.round(u(d).x)}`), O = !0;
+        break;
+      case "ArrowRight":
+        u(d).x += P, A(`Moved right to ${Math.round(u(d).x)}`), O = !0;
+        break;
+      case "+":
+      case "=":
+        u(h).height = Math.min(400, u(h).height + be), A(`Height ${u(h).height} pixels`), O = !0;
+        break;
+      case "-":
+      case "_":
+        u(h).height = Math.max(20, u(h).height - be), A(`Height ${u(h).height} pixels`), O = !0;
+        break;
+      case "c":
+      case "C":
+        I(), O = !0;
+        break;
+      case "]":
+        sn(0.1), O = !0;
+        break;
+      case "[":
+        sn(-0.1), O = !0;
+        break;
+      case "m":
+      case "M":
+        Pn(), O = !0;
+        break;
+    }
+    O && w.preventDefault();
+  }
+  $t(() => {
+    r() && i() && !u(ie) && (r().registerTool(i(), "Line Reader", void 0, rr.TOOL), E(ie, !0));
+  }), Hi(() => () => {
+    r() && i() && r().unregisterTool(i());
+  }), $t(() => {
+    r() && u(l) && i() && r().updateToolElement(i(), u(l));
+  }), $t(() => {
+    n() && u(l) && setTimeout(() => u(l)?.focus(), 100);
+  });
+  let es = /* @__PURE__ */ Zs(() => u(g) + Math.round(u(m) * 255).toString(16).padStart(2, "0"));
+  var ts = {
+    get visible() {
+      return n();
+    },
+    set visible(w = !1) {
+      n(w), fe();
+    },
+    get toolId() {
+      return i();
+    },
+    set toolId(w = "lineReader") {
+      i(w), fe();
+    },
+    get coordinator() {
+      return r();
+    },
+    set coordinator(w) {
+      r(w), fe();
+    }
+  }, wr = ji(), ns = et(wr);
+  {
+    var rs = (w) => {
+      var O = Hl(), Qe = et(O), is = q(Qe, !0);
+      U(Qe);
+      var $r = z(Qe, 2);
+      {
+        var ss = (X) => {
+          var Ft = zl(), zt = et(Ft), pt = z(zt, 2), gt = z(pt, 2), jt = z(gt, 2);
+          tt(
+            (ln, Bt) => {
+              He(zt, `height: ${ln ?? ""}px;`), He(pt, `top: ${u(d).y + u(h).height / 2}px;`), He(gt, `top: ${u(d).y - u(h).height / 2}px; height: ${u(h).height ?? ""}px; width: ${Bt ?? ""}px;`), He(jt, `top: ${u(d).y - u(h).height / 2}px; height: ${u(h).height ?? ""}px; left: ${u(d).x + u(h).width / 2}px;`);
+            },
+            [
+              () => Math.max(0, u(d).y - u(h).height / 2),
+              () => Math.max(0, u(d).x - u(h).width / 2)
+            ]
+          ), xe(X, Ft);
+        };
+        pn($r, (X) => {
+          u(S) === "obscure" && X(ss);
+        });
+      }
+      var Ce = z($r, 2);
+      let yr;
+      Ce.__pointerdown = Xi, Ce.__keydown = Zi;
+      var Fn = q(Ce), ls = q(Fn);
+      qi(ls, {
+        onClick: Gi,
+        ariaLabel: "Line reader settings",
+        get active() {
+          return u(C);
+        },
+        get buttonEl() {
+          return u(a);
+        },
+        set buttonEl(X) {
+          E(a, X, !0);
+        }
+      }), U(Fn), cn(2), U(Ce), gr(Ce, (X) => E(l, X), () => u(l));
+      var as = z(Ce, 2);
+      Vi(as, {
+        get open() {
+          return u(C);
+        },
+        title: "Line Reader Settings",
+        onClose: Wi,
+        get anchorEl() {
+          return u(a);
+        },
+        children: (X, Ft) => {
+          var zt = Yl(), pt = et(zt), gt = z(q(pt), 2), jt = q(gt);
+          fn(jt), jt.__change = () => {
+            E(S, "highlight"), A("Mode changed to highlight");
+          }, cn(2), U(gt);
+          var ln = z(gt, 2), Bt = q(ln);
+          fn(Bt), Bt.__change = () => {
+            E(S, "obscure"), A("Mode changed to masking");
+          }, cn(2), U(ln), U(pt);
+          var os = z(pt, 2);
+          {
+            var fs = (zn) => {
+              var Er = Bl(), jn = et(Er), us = z(q(jn), 2);
+              yl(us, 17, () => H, wl, (Ht, Ze) => {
+                var Ut = jl(), qt = q(Ut);
+                fn(qt), qt.__change = () => Ki(u(Ze).value);
+                var Tr = z(qt, 2), Sr = z(Tr, 2), ds = q(Sr, !0);
+                U(Sr), U(Ut), tt(() => {
+                  zr(qt, u(Ze).value), Hn(qt, u(g) === u(Ze).value), He(Tr, `background-color: ${u(Ze).value ?? ""};`), _n(ds, u(Ze).name);
+                }), xe(Ht, Ut);
+              }), U(jn);
+              var xr = z(jn, 2), Bn = q(xr), kr = z(q(Bn), 2), cs = q(kr);
+              U(kr), U(Bn);
+              var Yt = z(Bn, 2);
+              fn(Yt), Yt.__input = (Ht) => {
+                E(m, Number(Ht.currentTarget.value) / 100), A(`Opacity ${Math.round(u(m) * 100)}%`);
+              }, U(xr), tt(
+                (Ht, Ze, Ut) => {
+                  _n(cs, `${Ht ?? ""}%`), zr(Yt, u(m) * 100), Ke(Yt, "aria-valuenow", Ze), Ke(Yt, "aria-valuetext", `${Ut ?? ""} percent`);
+                },
+                [
+                  () => Math.round(u(m) * 100),
+                  () => Math.round(u(m) * 100),
+                  () => Math.round(u(m) * 100)
+                ]
+              ), xe(zn, Er);
+            };
+            pn(os, (zn) => {
+              u(S) === "highlight" && zn(fs);
+            });
+          }
+          tt(() => {
+            Hn(jt, u(S) === "highlight"), Hn(Bt, u(S) === "obscure");
+          }), xe(X, zt);
+        },
+        $$slots: { default: !0 }
+      }), tt(
+        (X, Ft) => {
+          _n(is, u(v)), yr = Cl(Ce, 1, "line-reader-frame svelte-1a3d6dx", null, yr, { "masking-mode": u(S) === "obscure" }), He(Ce, `left: ${u(d).x ?? ""}px; top: ${u(d).y ?? ""}px; width: ${u(h).width ?? ""}px; height: ${u(h).height ?? ""}px;`), Ke(Ce, "aria-label", `Line Reader tool. Mode: ${u(S) === "highlight" ? "Highlight" : "Masking"}. Use arrow keys to move, +/- to resize height, C to change color, [ and ] to adjust opacity, M to toggle mode. Current color: ${X ?? ""}, Opacity: ${Ft ?? ""}%`), He(Fn, `background-color: ${u(es) ?? ""};`);
+        },
+        [
+          () => H.find((X) => X.value === u(g))?.name,
+          () => Math.round(u(m) * 100)
+        ]
+      ), xe(w, O);
+    };
+    pn(ns, (w) => {
+      n() && w(rs);
+    });
+  }
+  return xe(e, wr), Rn(ts);
+}
+_r(["pointerdown", "keydown", "change", "input"]);
+customElements.define("pie-tool-line-reader", mr(
+  ql,
+  {
+    visible: { attribute: "visible", type: "Boolean" },
+    toolId: { attribute: "tool-id", type: "String" },
+    coordinator: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  ql as default
+};
+//# sourceMappingURL=tool-line-reader.js.map