@pie-players/pie-tool-magnifier 0.1.1

package/dist/tool-magnifier.js

@@ -0,0 +1,3064 @@
+var $i = Object.defineProperty;
+var Xn = (e) => {
+  throw TypeError(e);
+};
+var Ei = (e, t, n) => t in e ? $i(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var N = (e, t, n) => Ei(e, typeof t != "symbol" ? t + "" : t, n), gn = (e, t, n) => t.has(e) || Xn("Cannot " + n);
+var u = (e, t, n) => (gn(e, t, "read from private field"), n ? n.call(e) : t.get(e)), y = (e, t, n) => t.has(e) ? Xn("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), m = (e, t, n, r) => (gn(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), M = (e, t, n) => (gn(e, t, "access private method"), n);
+var vr;
+typeof window < "u" && ((vr = window.__svelte ?? (window.__svelte = {})).v ?? (vr.v = /* @__PURE__ */ new Set())).add("5");
+const Ti = 1, Si = 2, Ai = 16, Oi = 1, Ci = 4, xi = 8, Ni = 16, Ri = 2, _r = "[", ln = "[!", Ln = "]", bt = {}, F = /* @__PURE__ */ Symbol(), ki = "http://www.w3.org/1999/xhtml", bn = !1;
+var pr = Array.isArray, Pi = Array.prototype.indexOf, wt = Array.prototype.includes, on = Array.from, Qt = Object.keys, Zt = Object.defineProperty, tt = Object.getOwnPropertyDescriptor, Li = Object.getOwnPropertyDescriptors, Ii = Object.prototype, Mi = Array.prototype, gr = Object.getPrototypeOf, Jn = Object.isExtensible;
+function Di(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function mr() {
+  var e, t, n = new Promise((r, i) => {
+    e = r, t = i;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const q = 2, en = 4, fn = 8, br = 1 << 24, Ie = 16, _e = 32, Ve = 64, In = 128, le = 512, D = 1024, j = 2048, Me = 4096, J = 8192, ke = 16384, un = 32768, yt = 65536, Qn = 1 << 17, wr = 1 << 18, ft = 1 << 19, Fi = 1 << 20, Ue = 1 << 25, lt = 32768, wn = 1 << 21, Mn = 1 << 22, je = 1 << 23, Nt = /* @__PURE__ */ Symbol("$state"), yr = /* @__PURE__ */ Symbol("legacy props"), qi = /* @__PURE__ */ Symbol(""), ct = new class extends Error {
+  constructor() {
+    super(...arguments);
+    N(this, "name", "StaleReactionError");
+    N(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), Dn = 3, At = 8;
+function zi(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function Ui() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Bi(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function ji() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function Hi(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function Yi() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Vi() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function Gi(e) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function Ki() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Wi() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Xi() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Ji() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function an(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function Qi() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let E = !1;
+function Re(e) {
+  E = e;
+}
+let T;
+function Q(e) {
+  if (e === null)
+    throw an(), bt;
+  return T = e;
+}
+function Bt() {
+  return Q(/* @__PURE__ */ Ee(T));
+}
+function Gt(e) {
+  if (E) {
+    if (/* @__PURE__ */ Ee(T) !== null)
+      throw an(), bt;
+    T = e;
+  }
+}
+function Zi(e = 1) {
+  if (E) {
+    for (var t = e, n = T; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ Ee(n);
+    T = n;
+  }
+}
+function tn(e = !0) {
+  for (var t = 0, n = T; ; ) {
+    if (n.nodeType === At) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === Ln) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (r === _r || r === ln) && (t += 1);
+    }
+    var i = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Ee(n)
+    );
+    e && n.remove(), n = i;
+  }
+}
+function $r(e) {
+  if (!e || e.nodeType !== At)
+    throw an(), bt;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function Er(e) {
+  return e === this.v;
+}
+function es(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function Tr(e) {
+  return !es(e, this.v);
+}
+let ts = !1, Z = null;
+function $t(e) {
+  Z = e;
+}
+function Fn(e, t = !1, n) {
+  Z = {
+    p: Z,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function qn(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    Z
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var r of n)
+      Xr(r);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, Z = t.p, e ?? /** @type {T} */
+  {};
+}
+function Sr() {
+  return !0;
+}
+let Ge = [];
+function Ar() {
+  var e = Ge;
+  Ge = [], Di(e);
+}
+function nt(e) {
+  if (Ge.length === 0 && !Rt) {
+    var t = Ge;
+    queueMicrotask(() => {
+      t === Ge && Ar();
+    });
+  }
+  Ge.push(e);
+}
+function ns() {
+  for (; Ge.length > 0; )
+    Ar();
+}
+function Or(e) {
+  var t = S;
+  if (t === null)
+    return $.f |= je, e;
+  if ((t.f & un) === 0) {
+    if ((t.f & In) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    Et(e, t);
+}
+function Et(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & In) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const rs = -7169;
+function I(e, t) {
+  e.f = e.f & rs | t;
+}
+function zn(e) {
+  (e.f & le) !== 0 || e.deps === null ? I(e, D) : I(e, Me);
+}
+function Cr(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & q) === 0 || (t.f & lt) === 0 || (t.f ^= lt, Cr(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function xr(e, t, n) {
+  (e.f & j) !== 0 ? t.add(e) : (e.f & Me) !== 0 && n.add(e), Cr(e.deps), I(e, D);
+}
+const Ht = /* @__PURE__ */ new Set();
+let x = null, de = null, X = [], cn = null, yn = !1, Rt = !1;
+var dt, ht, We, vt, Dt, Ft, Xe, _t, $e, $n, En, Nr;
+const Gn = class Gn {
+  constructor() {
+    y(this, $e);
+    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>}
+     */
+    y(this, dt, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    y(this, ht, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    y(this, We, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    y(this, vt, 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}
+     */
+    y(this, Dt, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, Ft, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, Xe, /* @__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);
+    y(this, _t, !1);
+  }
+  is_deferred() {
+    return this.is_fork || u(this, vt) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    X = [], this.apply();
+    var n = [], r = [];
+    for (const i of t)
+      M(this, $e, $n).call(this, i, n, r);
+    if (this.is_deferred()) {
+      M(this, $e, En).call(this, r), M(this, $e, En).call(this, n);
+      for (const i of this.skipped_effects)
+        Lr(i);
+    } else {
+      for (const i of u(this, dt)) i();
+      u(this, dt).clear(), u(this, We) === 0 && M(this, $e, Nr).call(this), x = null, Zn(r), Zn(n), u(this, Dt)?.resolve();
+    }
+    de = 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 !== F && !this.previous.has(t) && this.previous.set(t, n), (t.f & je) === 0 && (this.current.set(t, t.v), de?.set(t, t.v));
+  }
+  activate() {
+    x = this, this.apply();
+  }
+  deactivate() {
+    x === this && (x = null, de = null);
+  }
+  flush() {
+    if (this.activate(), X.length > 0) {
+      if (Rr(), x !== null && x !== this)
+        return;
+    } else u(this, We) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of u(this, ht)) t(this);
+    u(this, ht).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    m(this, We, u(this, We) + 1), t && m(this, vt, u(this, vt) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    m(this, We, u(this, We) - 1), t && m(this, vt, u(this, vt) - 1), !u(this, _t) && (m(this, _t, !0), nt(() => {
+      m(this, _t, !1), this.is_deferred() ? X.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of u(this, Ft))
+      u(this, Xe).delete(t), I(t, j), Le(t);
+    for (const t of u(this, Xe))
+      I(t, Me), Le(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    u(this, dt).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    u(this, ht).add(t);
+  }
+  settled() {
+    return (u(this, Dt) ?? m(this, Dt, mr())).promise;
+  }
+  static ensure() {
+    if (x === null) {
+      const t = x = new Gn();
+      Ht.add(x), Rt || nt(() => {
+        x === t && t.flush();
+      });
+    }
+    return x;
+  }
+  apply() {
+  }
+};
+dt = new WeakMap(), ht = new WeakMap(), We = new WeakMap(), vt = new WeakMap(), Dt = new WeakMap(), Ft = new WeakMap(), Xe = new WeakMap(), _t = new WeakMap(), $e = 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
+ */
+$n = function(t, n, r) {
+  t.f ^= D;
+  for (var i = t.first, s = null; i !== null; ) {
+    var l = i.f, o = (l & (_e | Ve)) !== 0, a = o && (l & D) !== 0, f = a || (l & J) !== 0 || this.skipped_effects.has(i);
+    if (!f && i.fn !== null) {
+      o ? i.f ^= D : s !== null && (l & (en | fn | br)) !== 0 ? s.b.defer_effect(i) : (l & en) !== 0 ? n.push(i) : jt(i) && ((l & Ie) !== 0 && u(this, Xe).add(i), It(i));
+      var h = i.first;
+      if (h !== null) {
+        i = h;
+        continue;
+      }
+    }
+    var v = i.parent;
+    for (i = i.next; i === null && v !== null; )
+      v === s && (s = null), i = v.next, v = v.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+En = function(t) {
+  for (var n = 0; n < t.length; n += 1)
+    xr(t[n], u(this, Ft), u(this, Xe));
+}, Nr = function() {
+  var i;
+  if (Ht.size > 1) {
+    this.previous.clear();
+    var t = de, n = !0;
+    for (const s of Ht) {
+      if (s === this) {
+        n = !1;
+        continue;
+      }
+      const l = [];
+      for (const [a, f] of this.current) {
+        if (s.current.has(a))
+          if (n && f !== s.current.get(a))
+            s.current.set(a, f);
+          else
+            continue;
+        l.push(a);
+      }
+      if (l.length === 0)
+        continue;
+      const o = [...s.current.keys()].filter((a) => !this.current.has(a));
+      if (o.length > 0) {
+        var r = X;
+        X = [];
+        const a = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map();
+        for (const h of l)
+          kr(h, o, a, f);
+        if (X.length > 0) {
+          x = s, s.apply();
+          for (const h of X)
+            M(i = s, $e, $n).call(i, h, [], []);
+          s.deactivate();
+        }
+        X = r;
+      }
+    }
+    x = null, de = t;
+  }
+  this.committed = !0, Ht.delete(this);
+};
+let Pe = Gn;
+function ce(e) {
+  var t = Rt;
+  Rt = !0;
+  try {
+    for (var n; ; ) {
+      if (ns(), X.length === 0 && (x?.flush(), X.length === 0))
+        return cn = null, /** @type {T} */
+        n;
+      Rr();
+    }
+  } finally {
+    Rt = t;
+  }
+}
+function Rr() {
+  yn = !0;
+  var e = null;
+  try {
+    for (var t = 0; X.length > 0; ) {
+      var n = Pe.ensure();
+      if (t++ > 1e3) {
+        var r, i;
+        is();
+      }
+      n.process(X), He.clear();
+    }
+  } finally {
+    yn = !1, cn = null;
+  }
+}
+function is() {
+  try {
+    Yi();
+  } catch (e) {
+    Et(e, cn);
+  }
+}
+let Ae = null;
+function Zn(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var r = e[n++];
+      if ((r.f & (ke | J)) === 0 && jt(r) && (Ae = /* @__PURE__ */ new Set(), It(r), r.deps === null && r.first === null && r.nodes === null && (r.teardown === null && r.ac === null ? ti(r) : r.fn = null), Ae?.size > 0)) {
+        He.clear();
+        for (const i of Ae) {
+          if ((i.f & (ke | J)) !== 0) continue;
+          const s = [i];
+          let l = i.parent;
+          for (; l !== null; )
+            Ae.has(l) && (Ae.delete(l), s.push(l)), l = l.parent;
+          for (let o = s.length - 1; o >= 0; o--) {
+            const a = s[o];
+            (a.f & (ke | J)) === 0 && It(a);
+          }
+        }
+        Ae.clear();
+      }
+    }
+    Ae = null;
+  }
+}
+function kr(e, t, n, r) {
+  if (!n.has(e) && (n.add(e), e.reactions !== null))
+    for (const i of e.reactions) {
+      const s = i.f;
+      (s & q) !== 0 ? kr(
+        /** @type {Derived} */
+        i,
+        t,
+        n,
+        r
+      ) : (s & (Mn | Ie)) !== 0 && (s & j) === 0 && Pr(i, t, r) && (I(i, j), Le(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function Pr(e, t, n) {
+  const r = n.get(e);
+  if (r !== void 0) return r;
+  if (e.deps !== null)
+    for (const i of e.deps) {
+      if (wt.call(t, i))
+        return !0;
+      if ((i.f & q) !== 0 && Pr(
+        /** @type {Derived} */
+        i,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function Le(e) {
+  for (var t = cn = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (yn && t === S && (n & Ie) !== 0 && (n & wr) === 0)
+      return;
+    if ((n & (Ve | _e)) !== 0) {
+      if ((n & D) === 0) return;
+      t.f ^= D;
+    }
+  }
+  X.push(t);
+}
+function Lr(e) {
+  if (!((e.f & _e) !== 0 && (e.f & D) !== 0)) {
+    I(e, D);
+    for (var t = e.first; t !== null; )
+      Lr(t), t = t.next;
+  }
+}
+function ss(e) {
+  let t = 0, n = ot(0), r;
+  return () => {
+    Bn() && (_(n), jn(() => (t === 0 && (r = st(() => e(() => kt(n)))), t += 1, () => {
+      nt(() => {
+        t -= 1, t === 0 && (r?.(), r = void 0, kt(n));
+      });
+    })));
+  };
+}
+var ls = yt | ft | In;
+function os(e, t, n) {
+  new fs(e, t, n);
+}
+var K, qt, ge, Je, me, re, Y, be, Oe, ze, Qe, Ce, pt, Ze, gt, mt, xe, rn, R, Ir, Mr, Tn, Kt, Wt, Sn;
+class fs {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, r) {
+    y(this, R);
+    /** @type {Boundary | null} */
+    N(this, "parent");
+    N(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    y(this, K);
+    /** @type {TemplateNode | null} */
+    y(this, qt, E ? T : null);
+    /** @type {BoundaryProps} */
+    y(this, ge);
+    /** @type {((anchor: Node) => void)} */
+    y(this, Je);
+    /** @type {Effect} */
+    y(this, me);
+    /** @type {Effect | null} */
+    y(this, re, null);
+    /** @type {Effect | null} */
+    y(this, Y, null);
+    /** @type {Effect | null} */
+    y(this, be, null);
+    /** @type {DocumentFragment | null} */
+    y(this, Oe, null);
+    /** @type {TemplateNode | null} */
+    y(this, ze, null);
+    y(this, Qe, 0);
+    y(this, Ce, 0);
+    y(this, pt, !1);
+    y(this, Ze, !1);
+    /** @type {Set<Effect>} */
+    y(this, gt, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    y(this, mt, /* @__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}
+     */
+    y(this, xe, null);
+    y(this, rn, ss(() => (m(this, xe, ot(u(this, Qe))), () => {
+      m(this, xe, null);
+    })));
+    m(this, K, t), m(this, ge, n), m(this, Je, r), this.parent = /** @type {Effect} */
+    S.b, this.is_pending = !!u(this, ge).pending, m(this, me, Hn(() => {
+      if (S.b = this, E) {
+        const s = u(this, qt);
+        Bt(), /** @type {Comment} */
+        s.nodeType === At && /** @type {Comment} */
+        s.data === ln ? M(this, R, Mr).call(this) : (M(this, R, Ir).call(this), u(this, Ce) === 0 && (this.is_pending = !1));
+      } else {
+        var i = M(this, R, Tn).call(this);
+        try {
+          m(this, re, se(() => r(i)));
+        } catch (s) {
+          this.error(s);
+        }
+        u(this, Ce) > 0 ? M(this, R, Wt).call(this) : this.is_pending = !1;
+      }
+      return () => {
+        u(this, ze)?.remove();
+      };
+    }, ls)), E && m(this, K, T);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    xr(t, u(this, gt), u(this, mt));
+  }
+  /**
+   * 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 !!u(this, ge).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) {
+    M(this, R, Sn).call(this, t), m(this, Qe, u(this, Qe) + t), !(!u(this, xe) || u(this, pt)) && (m(this, pt, !0), nt(() => {
+      m(this, pt, !1), u(this, xe) && Tt(u(this, xe), u(this, Qe));
+    }));
+  }
+  get_effect_pending() {
+    return u(this, rn).call(this), _(
+      /** @type {Source<number>} */
+      u(this, xe)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = u(this, ge).onerror;
+    let r = u(this, ge).failed;
+    if (u(this, Ze) || !n && !r)
+      throw t;
+    u(this, re) && (B(u(this, re)), m(this, re, null)), u(this, Y) && (B(u(this, Y)), m(this, Y, null)), u(this, be) && (B(u(this, be)), m(this, be, null)), E && (Q(
+      /** @type {TemplateNode} */
+      u(this, qt)
+    ), Zi(), Q(tn()));
+    var i = !1, s = !1;
+    const l = () => {
+      if (i) {
+        Qi();
+        return;
+      }
+      i = !0, s && Ji(), Pe.ensure(), m(this, Qe, 0), u(this, be) !== null && rt(u(this, be), () => {
+        m(this, be, null);
+      }), this.is_pending = this.has_pending_snippet(), m(this, re, M(this, R, Kt).call(this, () => (m(this, Ze, !1), se(() => u(this, Je).call(this, u(this, K)))))), u(this, Ce) > 0 ? M(this, R, Wt).call(this) : this.is_pending = !1;
+    };
+    nt(() => {
+      try {
+        s = !0, n?.(t, l), s = !1;
+      } catch (o) {
+        Et(o, u(this, me) && u(this, me).parent);
+      }
+      r && m(this, be, M(this, R, Kt).call(this, () => {
+        Pe.ensure(), m(this, Ze, !0);
+        try {
+          return se(() => {
+            r(
+              u(this, K),
+              () => t,
+              () => l
+            );
+          });
+        } catch (o) {
+          return Et(
+            o,
+            /** @type {Effect} */
+            u(this, me).parent
+          ), null;
+        } finally {
+          m(this, Ze, !1);
+        }
+      }));
+    });
+  }
+}
+K = new WeakMap(), qt = new WeakMap(), ge = new WeakMap(), Je = new WeakMap(), me = new WeakMap(), re = new WeakMap(), Y = new WeakMap(), be = new WeakMap(), Oe = new WeakMap(), ze = new WeakMap(), Qe = new WeakMap(), Ce = new WeakMap(), pt = new WeakMap(), Ze = new WeakMap(), gt = new WeakMap(), mt = new WeakMap(), xe = new WeakMap(), rn = new WeakMap(), R = new WeakSet(), Ir = function() {
+  try {
+    m(this, re, se(() => u(this, Je).call(this, u(this, K))));
+  } catch (t) {
+    this.error(t);
+  }
+}, Mr = function() {
+  const t = u(this, ge).pending;
+  t && (m(this, Y, se(() => t(u(this, K)))), nt(() => {
+    var n = M(this, R, Tn).call(this);
+    m(this, re, M(this, R, Kt).call(this, () => (Pe.ensure(), se(() => u(this, Je).call(this, n))))), u(this, Ce) > 0 ? M(this, R, Wt).call(this) : (rt(
+      /** @type {Effect} */
+      u(this, Y),
+      () => {
+        m(this, Y, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, Tn = function() {
+  var t = u(this, K);
+  return this.is_pending && (m(this, ze, ve()), u(this, K).before(u(this, ze)), t = u(this, ze)), t;
+}, /**
+ * @param {() => Effect | null} fn
+ */
+Kt = function(t) {
+  var n = S, r = $, i = Z;
+  ye(u(this, me)), fe(u(this, me)), $t(u(this, me).ctx);
+  try {
+    return t();
+  } catch (s) {
+    return Or(s), null;
+  } finally {
+    ye(n), fe(r), $t(i);
+  }
+}, Wt = function() {
+  const t = (
+    /** @type {(anchor: Node) => void} */
+    u(this, ge).pending
+  );
+  u(this, re) !== null && (m(this, Oe, document.createDocumentFragment()), u(this, Oe).append(
+    /** @type {TemplateNode} */
+    u(this, ze)
+  ), ii(u(this, re), u(this, Oe))), u(this, Y) === null && m(this, Y, se(() => t(u(this, K))));
+}, /**
+ * 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
+ */
+Sn = function(t) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && M(n = this.parent, R, Sn).call(n, t);
+    return;
+  }
+  if (m(this, Ce, u(this, Ce) + t), u(this, Ce) === 0) {
+    this.is_pending = !1;
+    for (const r of u(this, gt))
+      I(r, j), Le(r);
+    for (const r of u(this, mt))
+      I(r, Me), Le(r);
+    u(this, gt).clear(), u(this, mt).clear(), u(this, Y) && rt(u(this, Y), () => {
+      m(this, Y, null);
+    }), u(this, Oe) && (u(this, K).before(u(this, Oe)), m(this, Oe, null));
+  }
+};
+function us(e, t, n, r) {
+  const i = dn;
+  var s = e.filter((d) => !d.settled);
+  if (n.length === 0 && s.length === 0) {
+    r(t.map(i));
+    return;
+  }
+  var l = x, o = (
+    /** @type {Effect} */
+    S
+  ), a = as(), f = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((d) => d.promise)) : null;
+  function h(d) {
+    a();
+    try {
+      r(d);
+    } catch (p) {
+      (o.f & ke) === 0 && Et(p, o);
+    }
+    l?.deactivate(), An();
+  }
+  if (n.length === 0) {
+    f.then(() => h(t.map(i)));
+    return;
+  }
+  function v() {
+    a(), Promise.all(n.map((d) => /* @__PURE__ */ cs(d))).then((d) => h([...t.map(i), ...d])).catch((d) => Et(d, o));
+  }
+  f ? f.then(v) : v();
+}
+function as() {
+  var e = S, t = $, n = Z, r = x;
+  return function(s = !0) {
+    ye(e), fe(t), $t(n), s && r?.activate();
+  };
+}
+function An() {
+  ye(null), fe(null), $t(null);
+}
+// @__NO_SIDE_EFFECTS__
+function dn(e) {
+  var t = q | j, n = $ !== null && ($.f & q) !== 0 ? (
+    /** @type {Derived} */
+    $
+  ) : null;
+  return S !== null && (S.f |= ft), {
+    ctx: Z,
+    deps: null,
+    effects: null,
+    equals: Er,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      F
+    ),
+    wv: 0,
+    parent: n ?? S,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function cs(e, t, n) {
+  let r = (
+    /** @type {Effect | null} */
+    S
+  );
+  r === null && Ui();
+  var i = (
+    /** @type {Boundary} */
+    r.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = ot(
+    /** @type {V} */
+    F
+  ), o = !$, a = /* @__PURE__ */ new Map();
+  return ys(() => {
+    var f = mr();
+    s = f.promise;
+    try {
+      Promise.resolve(e()).then(f.resolve, f.reject).then(() => {
+        h === x && h.committed && h.deactivate(), An();
+      });
+    } catch (p) {
+      f.reject(p), An();
+    }
+    var h = (
+      /** @type {Batch} */
+      x
+    );
+    if (o) {
+      var v = i.is_rendered();
+      i.update_pending_count(1), h.increment(v), a.get(h)?.reject(ct), a.delete(h), a.set(h, f);
+    }
+    const d = (p, c = void 0) => {
+      if (h.activate(), c)
+        c !== ct && (l.f |= je, Tt(l, c));
+      else {
+        (l.f & je) !== 0 && (l.f ^= je), Tt(l, p);
+        for (const [w, g] of a) {
+          if (a.delete(w), w === h) break;
+          g.reject(ct);
+        }
+      }
+      o && (i.update_pending_count(-1), h.decrement(v));
+    };
+    f.promise.then(d, (p) => d(null, p || "unknown"));
+  }), ms(() => {
+    for (const f of a.values())
+      f.reject(ct);
+  }), new Promise((f) => {
+    function h(v) {
+      function d() {
+        v === s ? f(l) : h(s);
+      }
+      v.then(d, d);
+    }
+    h(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function er(e) {
+  const t = /* @__PURE__ */ dn(e);
+  return si(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function Dr(e) {
+  const t = /* @__PURE__ */ dn(e);
+  return t.equals = Tr, t;
+}
+function Fr(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      B(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function ds(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & q) === 0)
+      return (t.f & ke) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function Un(e) {
+  var t, n = S;
+  ye(ds(e));
+  try {
+    e.f &= ~lt, Fr(e), t = ui(e);
+  } finally {
+    ye(n);
+  }
+  return t;
+}
+function qr(e) {
+  var t = Un(e);
+  if (!e.equals(t) && (e.wv = oi(), (!x?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    I(e, D);
+    return;
+  }
+  Ye || (de !== null ? (Bn() || x?.is_fork) && de.set(e, t) : zn(e));
+}
+let On = /* @__PURE__ */ new Set();
+const He = /* @__PURE__ */ new Map();
+let zr = !1;
+function ot(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Er,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function U(e, t) {
+  const n = ot(e);
+  return si(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function Ur(e, t = !1, n = !0) {
+  const r = ot(e);
+  return t || (r.equals = Tr), r;
+}
+function L(e, t, n = !1) {
+  $ !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
+  // to ensure we error if state is set inside an inspect effect
+  (!he || ($.f & Qn) !== 0) && Sr() && ($.f & (q | Ie | Mn | Qn)) !== 0 && (oe === null || !wt.call(oe, e)) && Xi();
+  let r = n ? Be(t) : t;
+  return Tt(e, r);
+}
+function Tt(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    Ye ? He.set(e, t) : He.set(e, n), e.v = t;
+    var r = Pe.ensure();
+    if (r.capture(e, n), (e.f & q) !== 0) {
+      const i = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & j) !== 0 && Un(i), zn(i);
+    }
+    e.wv = oi(), Br(e, j), S !== null && (S.f & D) !== 0 && (S.f & (_e | Ve)) === 0 && (ne === null ? Ts([e]) : ne.push(e)), !r.is_fork && On.size > 0 && !zr && hs();
+  }
+  return t;
+}
+function hs() {
+  zr = !1;
+  for (const e of On)
+    (e.f & D) !== 0 && I(e, Me), jt(e) && It(e);
+  On.clear();
+}
+function kt(e) {
+  L(e, e.v + 1);
+}
+function Br(e, t) {
+  var n = e.reactions;
+  if (n !== null)
+    for (var r = n.length, i = 0; i < r; i++) {
+      var s = n[i], l = s.f, o = (l & j) === 0;
+      if (o && I(s, t), (l & q) !== 0) {
+        var a = (
+          /** @type {Derived} */
+          s
+        );
+        de?.delete(a), (l & lt) === 0 && (l & le && (s.f |= lt), Br(a, Me));
+      } else o && ((l & Ie) !== 0 && Ae !== null && Ae.add(
+        /** @type {Effect} */
+        s
+      ), Le(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Be(e) {
+  if (typeof e != "object" || e === null || Nt in e)
+    return e;
+  const t = gr(e);
+  if (t !== Ii && t !== Mi)
+    return e;
+  var n = /* @__PURE__ */ new Map(), r = pr(e), i = /* @__PURE__ */ U(0), s = it, l = (o) => {
+    if (it === s)
+      return o();
+    var a = $, f = it;
+    fe(null), rr(s);
+    var h = o();
+    return fe(a), rr(f), h;
+  };
+  return r && n.set("length", /* @__PURE__ */ U(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(o, a, f) {
+        (!("value" in f) || f.configurable === !1 || f.enumerable === !1 || f.writable === !1) && Ki();
+        var h = n.get(a);
+        return h === void 0 ? h = l(() => {
+          var v = /* @__PURE__ */ U(f.value);
+          return n.set(a, v), v;
+        }) : L(h, f.value, !0), !0;
+      },
+      deleteProperty(o, a) {
+        var f = n.get(a);
+        if (f === void 0) {
+          if (a in o) {
+            const h = l(() => /* @__PURE__ */ U(F));
+            n.set(a, h), kt(i);
+          }
+        } else
+          L(f, F), kt(i);
+        return !0;
+      },
+      get(o, a, f) {
+        if (a === Nt)
+          return e;
+        var h = n.get(a), v = a in o;
+        if (h === void 0 && (!v || tt(o, a)?.writable) && (h = l(() => {
+          var p = Be(v ? o[a] : F), c = /* @__PURE__ */ U(p);
+          return c;
+        }), n.set(a, h)), h !== void 0) {
+          var d = _(h);
+          return d === F ? void 0 : d;
+        }
+        return Reflect.get(o, a, f);
+      },
+      getOwnPropertyDescriptor(o, a) {
+        var f = Reflect.getOwnPropertyDescriptor(o, a);
+        if (f && "value" in f) {
+          var h = n.get(a);
+          h && (f.value = _(h));
+        } else if (f === void 0) {
+          var v = n.get(a), d = v?.v;
+          if (v !== void 0 && d !== F)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: d,
+              writable: !0
+            };
+        }
+        return f;
+      },
+      has(o, a) {
+        if (a === Nt)
+          return !0;
+        var f = n.get(a), h = f !== void 0 && f.v !== F || Reflect.has(o, a);
+        if (f !== void 0 || S !== null && (!h || tt(o, a)?.writable)) {
+          f === void 0 && (f = l(() => {
+            var d = h ? Be(o[a]) : F, p = /* @__PURE__ */ U(d);
+            return p;
+          }), n.set(a, f));
+          var v = _(f);
+          if (v === F)
+            return !1;
+        }
+        return h;
+      },
+      set(o, a, f, h) {
+        var v = n.get(a), d = a in o;
+        if (r && a === "length")
+          for (var p = f; p < /** @type {Source<number>} */
+          v.v; p += 1) {
+            var c = n.get(p + "");
+            c !== void 0 ? L(c, F) : p in o && (c = l(() => /* @__PURE__ */ U(F)), n.set(p + "", c));
+          }
+        if (v === void 0)
+          (!d || tt(o, a)?.writable) && (v = l(() => /* @__PURE__ */ U(void 0)), L(v, Be(f)), n.set(a, v));
+        else {
+          d = v.v !== F;
+          var w = l(() => Be(f));
+          L(v, w);
+        }
+        var g = Reflect.getOwnPropertyDescriptor(o, a);
+        if (g?.set && g.set.call(h, f), !d) {
+          if (r && typeof a == "string") {
+            var k = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), A = Number(a);
+            Number.isInteger(A) && A >= k.v && L(k, A + 1);
+          }
+          kt(i);
+        }
+        return !0;
+      },
+      ownKeys(o) {
+        _(i);
+        var a = Reflect.ownKeys(o).filter((v) => {
+          var d = n.get(v);
+          return d === void 0 || d.v !== F;
+        });
+        for (var [f, h] of n)
+          h.v !== F && !(f in o) && a.push(f);
+        return a;
+      },
+      setPrototypeOf() {
+        Wi();
+      }
+    }
+  );
+}
+var tr, jr, Hr, Yr;
+function Cn() {
+  if (tr === void 0) {
+    tr = window, jr = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    Hr = tt(t, "firstChild").get, Yr = tt(t, "nextSibling").get, Jn(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Jn(n) && (n.__t = void 0);
+  }
+}
+function ve(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function St(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Hr.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Ee(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Yr.call(e)
+  );
+}
+function xn(e, t) {
+  if (!E)
+    return /* @__PURE__ */ St(e);
+  var n = /* @__PURE__ */ St(T);
+  return n === null && (n = T.appendChild(ve())), Q(n), n;
+}
+function vs(e, t = !1) {
+  if (!E) {
+    var n = /* @__PURE__ */ St(e);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ Ee(n) : n;
+  }
+  if (t) {
+    if (T?.nodeType !== Dn) {
+      var r = ve();
+      return T?.before(r), Q(r), r;
+    }
+    Kr(
+      /** @type {Text} */
+      T
+    );
+  }
+  return T;
+}
+function _s(e, t = 1, n = !1) {
+  let r = E ? T : e;
+  for (var i; t--; )
+    i = r, r = /** @type {TemplateNode} */
+    /* @__PURE__ */ Ee(r);
+  if (!E)
+    return r;
+  if (n) {
+    if (r?.nodeType !== Dn) {
+      var s = ve();
+      return r === null ? i?.after(s) : r.before(s), Q(s), s;
+    }
+    Kr(
+      /** @type {Text} */
+      r
+    );
+  }
+  return Q(r), r;
+}
+function Vr(e) {
+  e.textContent = "";
+}
+function Gr() {
+  return !1;
+}
+function Kr(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Dn; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function Wr(e) {
+  var t = $, n = S;
+  fe(null), ye(null);
+  try {
+    return e();
+  } finally {
+    fe(t), ye(n);
+  }
+}
+function ps(e) {
+  S === null && ($ === null && Hi(), ji()), Ye && Bi();
+}
+function gs(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function Te(e, t, n) {
+  var r = S;
+  r !== null && (r.f & J) !== 0 && (e |= J);
+  var i = {
+    ctx: Z,
+    deps: null,
+    nodes: null,
+    f: e | j | le,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: r,
+    b: r && r.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (n)
+    try {
+      It(i), i.f |= un;
+    } catch (o) {
+      throw B(i), o;
+    }
+  else t !== null && Le(i);
+  var s = i;
+  if (n && s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+  (s.f & ft) === 0 && (s = s.first, (e & Ie) !== 0 && (e & yt) !== 0 && s !== null && (s.f |= yt)), s !== null && (s.parent = r, r !== null && gs(s, r), $ !== null && ($.f & q) !== 0 && (e & Ve) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      $
+    );
+    (l.effects ?? (l.effects = [])).push(s);
+  }
+  return i;
+}
+function Bn() {
+  return $ !== null && !he;
+}
+function ms(e) {
+  const t = Te(fn, null, !1);
+  return I(t, D), t.teardown = e, t;
+}
+function Lt(e) {
+  ps();
+  var t = (
+    /** @type {Effect} */
+    S.f
+  ), n = !$ && (t & _e) !== 0 && (t & un) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      Z
+    );
+    (r.e ?? (r.e = [])).push(e);
+  } else
+    return Xr(e);
+}
+function Xr(e) {
+  return Te(en | Fi, e, !1);
+}
+function bs(e) {
+  Pe.ensure();
+  const t = Te(Ve | ft, e, !0);
+  return () => {
+    B(t);
+  };
+}
+function ws(e) {
+  Pe.ensure();
+  const t = Te(Ve | ft, e, !0);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? rt(t, () => {
+      B(t), r(void 0);
+    }) : (B(t), r(void 0));
+  });
+}
+function Jr(e) {
+  return Te(en, e, !1);
+}
+function ys(e) {
+  return Te(Mn | ft, e, !0);
+}
+function jn(e, t = 0) {
+  return Te(fn | t, e, !0);
+}
+function Qr(e, t = [], n = [], r = []) {
+  us(r, t, n, (i) => {
+    Te(fn, () => e(...i.map(_)), !0);
+  });
+}
+function Hn(e, t = 0) {
+  var n = Te(Ie | t, e, !0);
+  return n;
+}
+function se(e) {
+  return Te(_e | ft, e, !0);
+}
+function Zr(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = Ye, r = $;
+    nr(!0), fe(null);
+    try {
+      t.call(null);
+    } finally {
+      nr(n), fe(r);
+    }
+  }
+}
+function ei(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const i = n.ac;
+    i !== null && Wr(() => {
+      i.abort(ct);
+    });
+    var r = n.next;
+    (n.f & Ve) !== 0 ? n.parent = null : B(n, t), n = r;
+  }
+}
+function $s(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & _e) === 0 && B(t), t = n;
+  }
+}
+function B(e, t = !0) {
+  var n = !1;
+  (t || (e.f & wr) !== 0) && e.nodes !== null && e.nodes.end !== null && (Es(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), ei(e, t && !n), nn(e, 0), I(e, ke);
+  var r = e.nodes && e.nodes.t;
+  if (r !== null)
+    for (const s of r)
+      s.stop();
+  Zr(e);
+  var i = e.parent;
+  i !== null && i.first !== null && ti(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Es(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ Ee(e);
+    e.remove(), e = n;
+  }
+}
+function ti(e) {
+  var t = e.parent, n = e.prev, r = e.next;
+  n !== null && (n.next = r), r !== null && (r.prev = n), t !== null && (t.first === e && (t.first = r), t.last === e && (t.last = n));
+}
+function rt(e, t, n = !0) {
+  var r = [];
+  ni(e, r, !0);
+  var i = () => {
+    n && B(e), t && t();
+  }, s = r.length;
+  if (s > 0) {
+    var l = () => --s || i();
+    for (var o of r)
+      o.out(l);
+  } else
+    i();
+}
+function ni(e, t, n) {
+  if ((e.f & J) === 0) {
+    e.f ^= J;
+    var r = e.nodes && e.nodes.t;
+    if (r !== null)
+      for (const o of r)
+        (o.is_global || n) && t.push(o);
+    for (var i = e.first; i !== null; ) {
+      var s = i.next, l = (i.f & yt) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (i.f & _e) !== 0 && (e.f & Ie) !== 0;
+      ni(i, t, l ? n : !1), i = s;
+    }
+  }
+}
+function Yn(e) {
+  ri(e, !0);
+}
+function ri(e, t) {
+  if ((e.f & J) !== 0) {
+    e.f ^= J, (e.f & D) === 0 && (I(e, j), Le(e));
+    for (var n = e.first; n !== null; ) {
+      var r = n.next, i = (n.f & yt) !== 0 || (n.f & _e) !== 0;
+      ri(n, i ? t : !1), n = r;
+    }
+    var s = e.nodes && e.nodes.t;
+    if (s !== null)
+      for (const l of s)
+        (l.is_global || t) && l.in();
+  }
+}
+function ii(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, r = e.nodes.end; n !== null; ) {
+      var i = n === r ? null : /* @__PURE__ */ Ee(n);
+      t.append(n), n = i;
+    }
+}
+let Xt = !1, Ye = !1;
+function nr(e) {
+  Ye = e;
+}
+let $ = null, he = !1;
+function fe(e) {
+  $ = e;
+}
+let S = null;
+function ye(e) {
+  S = e;
+}
+let oe = null;
+function si(e) {
+  $ !== null && (oe === null ? oe = [e] : oe.push(e));
+}
+let V = null, G = 0, ne = null;
+function Ts(e) {
+  ne = e;
+}
+let li = 1, Ke = 0, it = Ke;
+function rr(e) {
+  it = e;
+}
+function oi() {
+  return ++li;
+}
+function jt(e) {
+  var t = e.f;
+  if ((t & j) !== 0)
+    return !0;
+  if (t & q && (e.f &= ~lt), (t & Me) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), r = n.length, i = 0; i < r; i++) {
+      var s = n[i];
+      if (jt(
+        /** @type {Derived} */
+        s
+      ) && qr(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & le) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    de === null && I(e, D);
+  }
+  return !1;
+}
+function fi(e, t, n = !0) {
+  var r = e.reactions;
+  if (r !== null && !(oe !== null && wt.call(oe, e)))
+    for (var i = 0; i < r.length; i++) {
+      var s = r[i];
+      (s.f & q) !== 0 ? fi(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (n ? I(s, j) : (s.f & D) !== 0 && I(s, Me), Le(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function ui(e) {
+  var w;
+  var t = V, n = G, r = ne, i = $, s = oe, l = Z, o = he, a = it, f = e.f;
+  V = /** @type {null | Value[]} */
+  null, G = 0, ne = null, $ = (f & (_e | Ve)) === 0 ? e : null, oe = null, $t(e.ctx), he = !1, it = ++Ke, e.ac !== null && (Wr(() => {
+    e.ac.abort(ct);
+  }), e.ac = null);
+  try {
+    e.f |= wn;
+    var h = (
+      /** @type {Function} */
+      e.fn
+    ), v = h(), d = e.deps, p = x?.is_fork;
+    if (V !== null) {
+      var c;
+      if (p || nn(e, G), d !== null && G > 0)
+        for (d.length = G + V.length, c = 0; c < V.length; c++)
+          d[G + c] = V[c];
+      else
+        e.deps = d = V;
+      if (Bn() && (e.f & le) !== 0)
+        for (c = G; c < d.length; c++)
+          ((w = d[c]).reactions ?? (w.reactions = [])).push(e);
+    } else !p && d !== null && G < d.length && (nn(e, G), d.length = G);
+    if (Sr() && ne !== null && !he && d !== null && (e.f & (q | Me | j)) === 0)
+      for (c = 0; c < /** @type {Source[]} */
+      ne.length; c++)
+        fi(
+          ne[c],
+          /** @type {Effect} */
+          e
+        );
+    if (i !== null && i !== e) {
+      if (Ke++, i.deps !== null)
+        for (let g = 0; g < n; g += 1)
+          i.deps[g].rv = Ke;
+      if (t !== null)
+        for (const g of t)
+          g.rv = Ke;
+      ne !== null && (r === null ? r = ne : r.push(.../** @type {Source[]} */
+      ne));
+    }
+    return (e.f & je) !== 0 && (e.f ^= je), v;
+  } catch (g) {
+    return Or(g);
+  } finally {
+    e.f ^= wn, V = t, G = n, ne = r, $ = i, oe = s, $t(l), he = o, it = a;
+  }
+}
+function Ss(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var r = Pi.call(n, e);
+    if (r !== -1) {
+      var i = n.length - 1;
+      i === 0 ? n = t.reactions = null : (n[r] = n[i], n.pop());
+    }
+  }
+  if (n === null && (t.f & q) !== 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
+  (V === null || !wt.call(V, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & le) !== 0 && (s.f ^= le, s.f &= ~lt), zn(s), Fr(s), nn(s, 0);
+  }
+}
+function nn(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var r = t; r < n.length; r++)
+      Ss(e, n[r]);
+}
+function It(e) {
+  var t = e.f;
+  if ((t & ke) === 0) {
+    I(e, D);
+    var n = S, r = Xt;
+    S = e, Xt = !0;
+    try {
+      (t & (Ie | br)) !== 0 ? $s(e) : ei(e), Zr(e);
+      var i = ui(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = li;
+      var s;
+      bn && ts && (e.f & j) !== 0 && e.deps;
+    } finally {
+      Xt = r, S = n;
+    }
+  }
+}
+function _(e) {
+  var t = e.f, n = (t & q) !== 0;
+  if ($ !== null && !he) {
+    var r = S !== null && (S.f & ke) !== 0;
+    if (!r && (oe === null || !wt.call(oe, e))) {
+      var i = $.deps;
+      if (($.f & wn) !== 0)
+        e.rv < Ke && (e.rv = Ke, V === null && i !== null && i[G] === e ? G++ : V === null ? V = [e] : V.push(e));
+      else {
+        ($.deps ?? ($.deps = [])).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [$] : wt.call(s, $) || s.push($);
+      }
+    }
+  }
+  if (Ye && He.has(e))
+    return He.get(e);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (Ye) {
+      var o = l.v;
+      return ((l.f & D) === 0 && l.reactions !== null || ci(l)) && (o = Un(l)), He.set(l, o), o;
+    }
+    var a = (l.f & le) === 0 && !he && $ !== null && (Xt || ($.f & le) !== 0), f = l.deps === null;
+    jt(l) && (a && (l.f |= le), qr(l)), a && !f && ai(l);
+  }
+  if (de?.has(e))
+    return de.get(e);
+  if ((e.f & je) !== 0)
+    throw e.v;
+  return e.v;
+}
+function ai(e) {
+  if (e.deps !== null) {
+    e.f |= le;
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & q) !== 0 && (t.f & le) === 0 && ai(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function ci(e) {
+  if (e.v === F) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (He.has(t) || (t.f & q) !== 0 && ci(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function st(e) {
+  var t = he;
+  try {
+    return he = !0, e();
+  } finally {
+    he = t;
+  }
+}
+const di = /* @__PURE__ */ new Set(), Nn = /* @__PURE__ */ new Set();
+function hi(e) {
+  for (var t = 0; t < e.length; t++)
+    di.add(e[t]);
+  for (var n of Nn)
+    n(e);
+}
+let ir = null;
+function Yt(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), r = e.type, i = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    i[0] || e.target
+  );
+  ir = e;
+  var l = 0, o = ir === e && e.__root;
+  if (o) {
+    var a = i.indexOf(o);
+    if (a !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var f = i.indexOf(t);
+    if (f === -1)
+      return;
+    a <= f && (l = a);
+  }
+  if (s = /** @type {Element} */
+  i[l] || e.target, s !== t) {
+    Zt(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var h = $, v = S;
+    fe(null), ye(null);
+    try {
+      for (var d, p = []; s !== null; ) {
+        var c = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var w = s["__" + r];
+          w != 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) && w.call(s, e);
+        } catch (g) {
+          d ? p.push(g) : d = g;
+        }
+        if (e.cancelBubble || c === t || c === null)
+          break;
+        s = c;
+      }
+      if (d) {
+        for (let g of p)
+          queueMicrotask(() => {
+            throw g;
+          });
+        throw d;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, fe(h), ye(v);
+    }
+  }
+}
+function As(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function Mt(e, t) {
+  var n = (
+    /** @type {Effect} */
+    S
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Vn(e, t) {
+  var n = (t & Ri) !== 0, r, i = !e.startsWith("<!>");
+  return () => {
+    if (E)
+      return Mt(T, null), T;
+    r === void 0 && (r = As(i ? e : "<!>" + e), r = /** @type {TemplateNode} */
+    /* @__PURE__ */ St(r));
+    var s = (
+      /** @type {TemplateNode} */
+      n || jr ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return Mt(s, s), s;
+  };
+}
+function Os() {
+  if (E)
+    return Mt(T, null), T;
+  var e = document.createDocumentFragment(), t = document.createComment(""), n = ve();
+  return e.append(t, n), Mt(t, n), e;
+}
+function Pt(e, t) {
+  if (E) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      S
+    );
+    ((n.f & un) === 0 || n.nodes.end === null) && (n.nodes.end = T), Bt();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const Cs = ["touchstart", "touchmove"];
+function xs(e) {
+  return Cs.includes(e);
+}
+function Ns(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 vi(e, t) {
+  return _i(e, t);
+}
+function Rs(e, t) {
+  Cn(), t.intro = t.intro ?? !1;
+  const n = t.target, r = E, i = T;
+  try {
+    for (var s = /* @__PURE__ */ St(n); s && (s.nodeType !== At || /** @type {Comment} */
+    s.data !== _r); )
+      s = /* @__PURE__ */ Ee(s);
+    if (!s)
+      throw bt;
+    Re(!0), Q(
+      /** @type {Comment} */
+      s
+    );
+    const l = _i(e, { ...t, anchor: s });
+    return Re(!1), /**  @type {Exports} */
+    l;
+  } catch (l) {
+    if (l instanceof Error && l.message.split(`
+`).some((o) => o.startsWith("https://svelte.dev/e/")))
+      throw l;
+    return l !== bt && console.warn("Failed to hydrate: ", l), t.recover === !1 && Vi(), Cn(), Vr(n), Re(!1), vi(e, t);
+  } finally {
+    Re(r), Q(i);
+  }
+}
+const at = /* @__PURE__ */ new Map();
+function _i(e, { target: t, anchor: n, props: r = {}, events: i, context: s, intro: l = !0 }) {
+  Cn();
+  var o = /* @__PURE__ */ new Set(), a = (v) => {
+    for (var d = 0; d < v.length; d++) {
+      var p = v[d];
+      if (!o.has(p)) {
+        o.add(p);
+        var c = xs(p);
+        t.addEventListener(p, Yt, { passive: c });
+        var w = at.get(p);
+        w === void 0 ? (document.addEventListener(p, Yt, { passive: c }), at.set(p, 1)) : at.set(p, w + 1);
+      }
+    }
+  };
+  a(on(di)), Nn.add(a);
+  var f = void 0, h = ws(() => {
+    var v = n ?? t.appendChild(ve());
+    return os(
+      /** @type {TemplateNode} */
+      v,
+      {
+        pending: () => {
+        }
+      },
+      (d) => {
+        if (s) {
+          Fn({});
+          var p = (
+            /** @type {ComponentContext} */
+            Z
+          );
+          p.c = s;
+        }
+        if (i && (r.$$events = i), E && Mt(
+          /** @type {TemplateNode} */
+          d,
+          null
+        ), f = e(d, r) || {}, E && (S.nodes.end = T, T === null || T.nodeType !== At || /** @type {Comment} */
+        T.data !== Ln))
+          throw an(), bt;
+        s && qn();
+      }
+    ), () => {
+      for (var d of o) {
+        t.removeEventListener(d, Yt);
+        var p = (
+          /** @type {number} */
+          at.get(d)
+        );
+        --p === 0 ? (document.removeEventListener(d, Yt), at.delete(d)) : at.set(d, p);
+      }
+      Nn.delete(a), v !== n && v.parentNode?.removeChild(v);
+    };
+  });
+  return Rn.set(f, h), f;
+}
+let Rn = /* @__PURE__ */ new WeakMap();
+function ks(e, t) {
+  const n = Rn.get(e);
+  return n ? (Rn.delete(e), n(t)) : Promise.resolve();
+}
+var ae, we, W, et, zt, Ut, sn;
+class Ps {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    /** @type {TemplateNode} */
+    N(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    y(this, ae, /* @__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>}
+     */
+    y(this, we, /* @__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>}
+     */
+    y(this, W, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    y(this, et, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    y(this, zt, !0);
+    y(this, Ut, () => {
+      var t = (
+        /** @type {Batch} */
+        x
+      );
+      if (u(this, ae).has(t)) {
+        var n = (
+          /** @type {Key} */
+          u(this, ae).get(t)
+        ), r = u(this, we).get(n);
+        if (r)
+          Yn(r), u(this, et).delete(n);
+        else {
+          var i = u(this, W).get(n);
+          i && (u(this, we).set(n, i.effect), u(this, W).delete(n), i.fragment.lastChild.remove(), this.anchor.before(i.fragment), r = i.effect);
+        }
+        for (const [s, l] of u(this, ae)) {
+          if (u(this, ae).delete(s), s === t)
+            break;
+          const o = u(this, W).get(l);
+          o && (B(o.effect), u(this, W).delete(l));
+        }
+        for (const [s, l] of u(this, we)) {
+          if (s === n || u(this, et).has(s)) continue;
+          const o = () => {
+            if (Array.from(u(this, ae).values()).includes(s)) {
+              var f = document.createDocumentFragment();
+              ii(l, f), f.append(ve()), u(this, W).set(s, { effect: l, fragment: f });
+            } else
+              B(l);
+            u(this, et).delete(s), u(this, we).delete(s);
+          };
+          u(this, zt) || !r ? (u(this, et).add(s), rt(l, o, !1)) : o();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    y(this, sn, (t) => {
+      u(this, ae).delete(t);
+      const n = Array.from(u(this, ae).values());
+      for (const [r, i] of u(this, W))
+        n.includes(r) || (B(i.effect), u(this, W).delete(r));
+    });
+    this.anchor = t, m(this, zt, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var r = (
+      /** @type {Batch} */
+      x
+    ), i = Gr();
+    if (n && !u(this, we).has(t) && !u(this, W).has(t))
+      if (i) {
+        var s = document.createDocumentFragment(), l = ve();
+        s.append(l), u(this, W).set(t, {
+          effect: se(() => n(l)),
+          fragment: s
+        });
+      } else
+        u(this, we).set(
+          t,
+          se(() => n(this.anchor))
+        );
+    if (u(this, ae).set(r, t), i) {
+      for (const [o, a] of u(this, we))
+        o === t ? r.skipped_effects.delete(a) : r.skipped_effects.add(a);
+      for (const [o, a] of u(this, W))
+        o === t ? r.skipped_effects.delete(a.effect) : r.skipped_effects.add(a.effect);
+      r.oncommit(u(this, Ut)), r.ondiscard(u(this, sn));
+    } else
+      E && (this.anchor = T), u(this, Ut).call(this);
+  }
+}
+ae = new WeakMap(), we = new WeakMap(), W = new WeakMap(), et = new WeakMap(), zt = new WeakMap(), Ut = new WeakMap(), sn = new WeakMap();
+function Ls(e) {
+  Z === null && zi(), Lt(() => {
+    const t = st(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function Is(e, t, n = !1) {
+  E && Bt();
+  var r = new Ps(e), i = n ? yt : 0;
+  function s(l, o) {
+    if (E) {
+      const f = $r(e) === ln;
+      if (l === f) {
+        var a = tn();
+        Q(a), r.anchor = a, Re(!1), r.ensure(l, o), Re(!0);
+        return;
+      }
+    }
+    r.ensure(l, o);
+  }
+  Hn(() => {
+    var l = !1;
+    t((o, a = !0) => {
+      l = !0, s(a, o);
+    }), l || s(!1, null);
+  }, i);
+}
+function Ms(e, t) {
+  return t;
+}
+function Ds(e, t, n) {
+  for (var r = [], i = t.length, s, l = t.length, o = 0; o < i; o++) {
+    let v = t[o];
+    rt(
+      v,
+      () => {
+        if (s) {
+          if (s.pending.delete(v), s.done.add(v), s.pending.size === 0) {
+            var d = (
+              /** @type {Set<EachOutroGroup>} */
+              e.outrogroups
+            );
+            kn(on(s.done)), d.delete(s), d.size === 0 && (e.outrogroups = null);
+          }
+        } else
+          l -= 1;
+      },
+      !1
+    );
+  }
+  if (l === 0) {
+    var a = r.length === 0 && n !== null;
+    if (a) {
+      var f = (
+        /** @type {Element} */
+        n
+      ), h = (
+        /** @type {Element} */
+        f.parentNode
+      );
+      Vr(h), h.append(f), e.items.clear();
+    }
+    kn(t, !a);
+  } else
+    s = {
+      pending: new Set(t),
+      done: /* @__PURE__ */ new Set()
+    }, (e.outrogroups ?? (e.outrogroups = /* @__PURE__ */ new Set())).add(s);
+}
+function kn(e, t = !0) {
+  for (var n = 0; n < e.length; n++)
+    B(e[n], t);
+}
+var sr;
+function Fs(e, t, n, r, i, s = null) {
+  var l = e, o = /* @__PURE__ */ new Map();
+  {
+    var a = (
+      /** @type {Element} */
+      e
+    );
+    l = E ? Q(/* @__PURE__ */ St(a)) : a.appendChild(ve());
+  }
+  E && Bt();
+  var f = null, h = /* @__PURE__ */ Dr(() => {
+    var g = n();
+    return pr(g) ? g : g == null ? [] : on(g);
+  }), v, d = !0;
+  function p() {
+    w.fallback = f, qs(w, v, l, t, r), f !== null && (v.length === 0 ? (f.f & Ue) === 0 ? Yn(f) : (f.f ^= Ue, xt(f, null, l)) : rt(f, () => {
+      f = null;
+    }));
+  }
+  var c = Hn(() => {
+    v = /** @type {V[]} */
+    _(h);
+    var g = v.length;
+    let k = !1;
+    if (E) {
+      var A = $r(l) === ln;
+      A !== (g === 0) && (l = tn(), Q(l), Re(!1), k = !0);
+    }
+    for (var P = /* @__PURE__ */ new Set(), C = (
+      /** @type {Batch} */
+      x
+    ), ee = Gr(), z = 0; z < g; z += 1) {
+      E && T.nodeType === At && /** @type {Comment} */
+      T.data === Ln && (l = /** @type {Comment} */
+      T, k = !0, Re(!1));
+      var Se = v[z], H = r(Se, z), ue = d ? null : o.get(H);
+      ue ? (ue.v && Tt(ue.v, Se), ue.i && Tt(ue.i, z), ee && C.skipped_effects.delete(ue.e)) : (ue = zs(
+        o,
+        d ? l : sr ?? (sr = ve()),
+        Se,
+        H,
+        z,
+        i,
+        t,
+        n
+      ), d || (ue.e.f |= Ue), o.set(H, ue)), P.add(H);
+    }
+    if (g === 0 && s && !f && (d ? f = se(() => s(l)) : (f = se(() => s(sr ?? (sr = ve()))), f.f |= Ue)), E && g > 0 && Q(tn()), !d)
+      if (ee) {
+        for (const [hn, vn] of o)
+          P.has(hn) || C.skipped_effects.add(vn.e);
+        C.oncommit(p), C.ondiscard(() => {
+        });
+      } else
+        p();
+    k && Re(!0), _(h);
+  }), w = { effect: c, items: o, outrogroups: null, fallback: f };
+  d = !1, E && (l = T);
+}
+function Ct(e) {
+  for (; e !== null && (e.f & _e) === 0; )
+    e = e.next;
+  return e;
+}
+function qs(e, t, n, r, i) {
+  var s = t.length, l = e.items, o = Ct(e.effect.first), a, f = null, h = [], v = [], d, p, c, w;
+  for (w = 0; w < s; w += 1) {
+    if (d = t[w], p = i(d, w), c = /** @type {EachItem} */
+    l.get(p).e, e.outrogroups !== null)
+      for (const H of e.outrogroups)
+        H.pending.delete(c), H.done.delete(c);
+    if ((c.f & Ue) !== 0)
+      if (c.f ^= Ue, c === o)
+        xt(c, null, n);
+      else {
+        var g = f ? f.next : o;
+        c === e.effect.last && (e.effect.last = c.prev), c.prev && (c.prev.next = c.next), c.next && (c.next.prev = c.prev), qe(e, f, c), qe(e, c, g), xt(c, g, n), f = c, h = [], v = [], o = Ct(f.next);
+        continue;
+      }
+    if ((c.f & J) !== 0 && Yn(c), c !== o) {
+      if (a !== void 0 && a.has(c)) {
+        if (h.length < v.length) {
+          var k = v[0], A;
+          f = k.prev;
+          var P = h[0], C = h[h.length - 1];
+          for (A = 0; A < h.length; A += 1)
+            xt(h[A], k, n);
+          for (A = 0; A < v.length; A += 1)
+            a.delete(v[A]);
+          qe(e, P.prev, C.next), qe(e, f, P), qe(e, C, k), o = k, f = C, w -= 1, h = [], v = [];
+        } else
+          a.delete(c), xt(c, o, n), qe(e, c.prev, c.next), qe(e, c, f === null ? e.effect.first : f.next), qe(e, f, c), f = c;
+        continue;
+      }
+      for (h = [], v = []; o !== null && o !== c; )
+        (a ?? (a = /* @__PURE__ */ new Set())).add(o), v.push(o), o = Ct(o.next);
+      if (o === null)
+        continue;
+    }
+    (c.f & Ue) === 0 && h.push(c), f = c, o = Ct(c.next);
+  }
+  if (e.outrogroups !== null) {
+    for (const H of e.outrogroups)
+      H.pending.size === 0 && (kn(on(H.done)), e.outrogroups?.delete(H));
+    e.outrogroups.size === 0 && (e.outrogroups = null);
+  }
+  if (o !== null || a !== void 0) {
+    var ee = [];
+    if (a !== void 0)
+      for (c of a)
+        (c.f & J) === 0 && ee.push(c);
+    for (; o !== null; )
+      (o.f & J) === 0 && o !== e.fallback && ee.push(o), o = Ct(o.next);
+    var z = ee.length;
+    if (z > 0) {
+      var Se = s === 0 ? n : null;
+      Ds(e, ee, Se);
+    }
+  }
+}
+function zs(e, t, n, r, i, s, l, o) {
+  var a = (l & Ti) !== 0 ? (l & Ai) === 0 ? /* @__PURE__ */ Ur(n, !1, !1) : ot(n) : null, f = (l & Si) !== 0 ? ot(i) : null;
+  return {
+    v: a,
+    i: f,
+    e: se(() => (s(t, a ?? n, f ?? i, o), () => {
+      e.delete(r);
+    }))
+  };
+}
+function xt(e, t, n) {
+  if (e.nodes)
+    for (var r = e.nodes.start, i = e.nodes.end, s = t && (t.f & Ue) === 0 ? (
+      /** @type {EffectNodes} */
+      t.nodes.start
+    ) : n; r !== null; ) {
+      var l = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Ee(r)
+      );
+      if (s.before(r), r === i)
+        return;
+      r = l;
+    }
+}
+function qe(e, t, n) {
+  t === null ? e.effect.first = n : t.next = n, n === null ? e.effect.last = t : n.prev = t;
+}
+function Us(e, t, n, r, i) {
+  E && Bt();
+  var s = t.$$slots?.[n], l = !1;
+  s === !0 && (s = t.children, l = !0), s === void 0 || s(e, l ? () => r : r);
+}
+function pi(e, t) {
+  Jr(() => {
+    var n = e.getRootNode(), r = (
+      /** @type {ShadowRoot} */
+      n.host ? (
+        /** @type {ShadowRoot} */
+        n
+      ) : (
+        /** @type {Document} */
+        n.head ?? /** @type {Document} */
+        n.ownerDocument.head
+      )
+    );
+    if (!r.querySelector("#" + t.hash)) {
+      const i = document.createElement("style");
+      i.id = t.hash, i.textContent = t.code, r.appendChild(i);
+    }
+  });
+}
+const lr = [...` 	
+\r\f \v\uFEFF`];
+function Bs(e, t, n) {
+  var r = "" + e;
+  if (n) {
+    for (var i in n)
+      if (n[i])
+        r = r ? r + " " + i : i;
+      else if (r.length)
+        for (var s = i.length, l = 0; (l = r.indexOf(i, l)) >= 0; ) {
+          var o = l + s;
+          (l === 0 || lr.includes(r[l - 1])) && (o === r.length || lr.includes(r[o])) ? r = (l === 0 ? "" : r.substring(0, l)) + r.substring(o + 1) : l = o;
+        }
+  }
+  return r === "" ? null : r;
+}
+function js(e, t) {
+  return e == null ? null : String(e);
+}
+function Hs(e, t, n, r, i, s) {
+  var l = e.__className;
+  if (E || l !== n || l === void 0) {
+    var o = Bs(n, r, s);
+    (!E || o !== e.getAttribute("class")) && (o == null ? e.removeAttribute("class") : e.className = o), e.__className = n;
+  } else if (s && i !== s)
+    for (var a in s) {
+      var f = !!s[a];
+      (i == null || f !== !!i[a]) && e.classList.toggle(a, f);
+    }
+  return s;
+}
+function or(e, t, n, r) {
+  var i = e.__style;
+  if (E || i !== t) {
+    var s = js(t);
+    (!E || s !== e.getAttribute("style")) && (s == null ? e.removeAttribute("style") : e.style.cssText = s), e.__style = t;
+  }
+  return r;
+}
+const Ys = /* @__PURE__ */ Symbol("is custom element"), Vs = /* @__PURE__ */ Symbol("is html");
+function mn(e, t, n, r) {
+  var i = Gs(e);
+  E && (i[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === "LINK") || i[t] !== (i[t] = n) && (t === "loading" && (e[qi] = n), n == null ? e.removeAttribute(t) : typeof n != "string" && Ks(e).includes(t) ? e[t] = n : e.setAttribute(t, n));
+}
+function Gs(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Ys]: e.nodeName.includes("-"),
+      [Vs]: e.namespaceURI === ki
+    })
+  );
+}
+var fr = /* @__PURE__ */ new Map();
+function Ks(e) {
+  var t = e.getAttribute("is") || e.nodeName, n = fr.get(t);
+  if (n) return n;
+  fr.set(t, n = []);
+  for (var r, i = e, s = Element.prototype; s !== i; ) {
+    r = Li(i);
+    for (var l in r)
+      r[l].set && n.push(l);
+    i = gr(i);
+  }
+  return n;
+}
+function ur(e, t) {
+  return e === t || e?.[Nt] === t;
+}
+function ar(e = {}, t, n, r) {
+  return Jr(() => {
+    var i, s;
+    return jn(() => {
+      i = s, s = [], st(() => {
+        e !== n(...s) && (t(e, ...s), i && ur(n(...i), e) && t(null, ...i));
+      });
+    }), () => {
+      nt(() => {
+        s && ur(n(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+let Vt = !1;
+function Ws(e) {
+  var t = Vt;
+  try {
+    return Vt = !1, [e(), Vt];
+  } finally {
+    Vt = t;
+  }
+}
+function pe(e, t, n, r) {
+  var i = (n & xi) !== 0, s = (n & Ni) !== 0, l = (
+    /** @type {V} */
+    r
+  ), o = !0, a = () => (o && (o = !1, l = s ? st(
+    /** @type {() => V} */
+    r
+  ) : (
+    /** @type {V} */
+    r
+  )), l), f;
+  if (i) {
+    var h = Nt in e || yr in e;
+    f = tt(e, t)?.set ?? (h && t in e ? (A) => e[t] = A : void 0);
+  }
+  var v, d = !1;
+  i ? [v, d] = Ws(() => (
+    /** @type {V} */
+    e[t]
+  )) : v = /** @type {V} */
+  e[t], v === void 0 && r !== void 0 && (v = a(), f && (Gi(), f(v)));
+  var p;
+  if (p = () => {
+    var A = (
+      /** @type {V} */
+      e[t]
+    );
+    return A === void 0 ? a() : (o = !0, A);
+  }, (n & Ci) === 0)
+    return p;
+  if (f) {
+    var c = e.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(A, P) {
+        return arguments.length > 0 ? ((!P || c || d) && f(P ? p() : A), A) : p();
+      })
+    );
+  }
+  var w = !1, g = ((n & Oi) !== 0 ? dn : Dr)(() => (w = !1, p()));
+  i && _(g);
+  var k = (
+    /** @type {Effect} */
+    S
+  );
+  return (
+    /** @type {() => V} */
+    (function(A, P) {
+      if (arguments.length > 0) {
+        const C = P ? _(g) : i ? Be(A) : A;
+        return L(g, C), w = !0, l !== void 0 && (l = C), A;
+      }
+      return Ye && w || (k.f & ke) !== 0 ? g.v : _(g);
+    })
+  );
+}
+function Xs(e) {
+  return new Js(e);
+}
+var Ne, ie;
+class Js {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    y(this, Ne);
+    /** @type {Record<string, any>} */
+    y(this, ie);
+    var n = /* @__PURE__ */ new Map(), r = (s, l) => {
+      var o = /* @__PURE__ */ Ur(l, !1, !1);
+      return n.set(s, o), o;
+    };
+    const i = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return _(n.get(l) ?? r(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === yr ? !0 : (_(n.get(l) ?? r(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, o) {
+          return L(n.get(l) ?? r(l, o), o), Reflect.set(s, l, o);
+        }
+      }
+    );
+    m(this, ie, (t.hydrate ? Rs : vi)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: i,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover
+    })), (!t?.props?.$$host || t.sync === !1) && ce(), m(this, Ne, i.$$events);
+    for (const s of Object.keys(u(this, ie)))
+      s === "$set" || s === "$destroy" || s === "$on" || Zt(this, s, {
+        get() {
+          return u(this, ie)[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          u(this, ie)[s] = l;
+        },
+        enumerable: !0
+      });
+    u(this, ie).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(i, s);
+    }, u(this, ie).$destroy = () => {
+      ks(u(this, ie));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    u(this, ie).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, n) {
+    u(this, Ne)[t] = u(this, Ne)[t] || [];
+    const r = (...i) => n.call(this, ...i);
+    return u(this, Ne)[t].push(r), () => {
+      u(this, Ne)[t] = u(this, Ne)[t].filter(
+        /** @param {any} fn */
+        (i) => i !== r
+      );
+    };
+  }
+  $destroy() {
+    u(this, ie).$destroy();
+  }
+}
+Ne = new WeakMap(), ie = new WeakMap();
+let gi;
+typeof HTMLElement == "function" && (gi = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(t, n, r) {
+    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, r && (this.$$shadowRoot = this.attachShadow(r));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(t, n, r) {
+    if (this.$$l[t] = this.$$l[t] || [], this.$$l[t].push(n), this.$$c) {
+      const i = this.$$c.$on(t, n);
+      this.$$l_u.set(n, i);
+    }
+    super.addEventListener(t, n, r);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(t, n, r) {
+    if (super.removeEventListener(t, n, r), this.$$c) {
+      const i = this.$$l_u.get(n);
+      i && (i(), this.$$l_u.delete(n));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let t = function(i) {
+        return (s) => {
+          const l = document.createElement("slot");
+          i !== "default" && (l.name = i), Pt(s, l);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const n = {}, r = Qs(this);
+      for (const i of this.$$s)
+        i in r && (i === "default" && !this.$$d.children ? (this.$$d.children = t(i), n.default = !0) : n[i] = t(i));
+      for (const i of this.attributes) {
+        const s = this.$$g_p(i.name);
+        s in this.$$d || (this.$$d[s] = Jt(s, i.value, this.$$p_d, "toProp"));
+      }
+      for (const i in this.$$p_d)
+        !(i in this.$$d) && this[i] !== void 0 && (this.$$d[i] = this[i], delete this[i]);
+      this.$$c = Xs({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: n,
+          $$host: this
+        }
+      }), this.$$me = bs(() => {
+        jn(() => {
+          this.$$r = !0;
+          for (const i of Qt(this.$$c)) {
+            if (!this.$$p_d[i]?.reflect) continue;
+            this.$$d[i] = this.$$c[i];
+            const s = Jt(
+              i,
+              this.$$d[i],
+              this.$$p_d,
+              "toAttribute"
+            );
+            s == null ? this.removeAttribute(this.$$p_d[i].attribute || i) : this.setAttribute(this.$$p_d[i].attribute || i, s);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const i in this.$$l)
+        for (const s of this.$$l[i]) {
+          const l = this.$$c.$on(i, 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, r) {
+    this.$$r || (t = this.$$g_p(t), this.$$d[t] = Jt(t, r, this.$$p_d, "toProp"), this.$$c?.$set({ [t]: this.$$d[t] }));
+  }
+  disconnectedCallback() {
+    this.$$cn = !1, Promise.resolve().then(() => {
+      !this.$$cn && this.$$c && (this.$$c.$destroy(), this.$$me(), this.$$c = void 0);
+    });
+  }
+  /**
+   * @param {string} attribute_name
+   */
+  $$g_p(t) {
+    return Qt(this.$$p_d).find(
+      (n) => this.$$p_d[n].attribute === t || !this.$$p_d[n].attribute && n.toLowerCase() === t
+    ) || t;
+  }
+});
+function Jt(e, t, n, r) {
+  const i = n[e]?.type;
+  if (t = i === "Boolean" && typeof t != "boolean" ? t != null : t, !r || !n[e])
+    return t;
+  if (r === "toAttribute")
+    switch (i) {
+      case "Object":
+      case "Array":
+        return t == null ? null : JSON.stringify(t);
+      case "Boolean":
+        return t ? "" : null;
+      case "Number":
+        return t ?? null;
+      default:
+        return t;
+    }
+  else
+    switch (i) {
+      case "Object":
+      case "Array":
+        return t && JSON.parse(t);
+      case "Boolean":
+        return t;
+      // conversion already handled above
+      case "Number":
+        return t != null ? +t : t;
+      default:
+        return t;
+    }
+}
+function Qs(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function mi(e, t, n, r, i, s) {
+  let l = class extends gi {
+    constructor() {
+      super(e, n, i), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Qt(t).map(
+        (o) => (t[o].attribute || o).toLowerCase()
+      );
+    }
+  };
+  return Qt(t).forEach((o) => {
+    Zt(l.prototype, o, {
+      get() {
+        return this.$$c && o in this.$$c ? this.$$c[o] : this.$$d[o];
+      },
+      set(a) {
+        a = Jt(o, a, t), this.$$d[o] = a;
+        var f = this.$$c;
+        if (f) {
+          var h = tt(f, o)?.get;
+          h ? f[o] = a : f.$set({ [o]: a });
+        }
+      }
+    });
+  }), r.forEach((o) => {
+    Zt(l.prototype, o, {
+      get() {
+        return this.$$c?.[o];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+var cr;
+(function(e) {
+  e.TTS_WORD = "tts-word", e.TTS_SENTENCE = "tts-sentence", e.ANNOTATION = "annotation";
+})(cr || (cr = {}));
+var dr;
+(function(e) {
+  e.YELLOW = "yellow", e.GREEN = "green", e.BLUE = "blue", e.PINK = "pink", e.ORANGE = "orange";
+})(dr || (dr = {}));
+const Zs = {
+  // 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(Zs).map(([e, t]) => [t, e]));
+var Pn;
+(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";
+})(Pn || (Pn = {}));
+var hr;
+(function(e) {
+  e.IDLE = "idle", e.LOADING = "loading", e.PLAYING = "playing", e.PAUSED = "paused", e.ERROR = "error";
+})(hr || (hr = {}));
+var el = /* @__PURE__ */ Vn('<div class="magnifier svelte-13ngm4o" role="region" aria-label="Content magnifier"><div class="magnifier-content svelte-13ngm4o"></div> <div class="magnifier-glass svelte-13ngm4o"></div> <!></div>');
+const tl = {
+  hash: "svelte-13ngm4o",
+  code: ".magnifier.svelte-13ngm4o {position:fixed;overflow:hidden;background-color:white;border:1px solid #555;border-radius:4px;z-index:10000;cursor:move;touch-action:none;}.magnifier-content.svelte-13ngm4o {position:absolute;top:0;left:0;overflow:visible;display:block;transform-origin:left top;user-select:none;pointer-events:none;}.magnifier-glass.svelte-13ngm4o {position:absolute;top:0;left:0;width:100%;height:100%;opacity:0;background-color:transparent;pointer-events:all;}"
+};
+function bi(e, t) {
+  Fn(t, !0), pi(e, tl);
+  let n = pe(t, "zoom", 7, 2), r = pe(t, "width", 7, 420), i = pe(t, "height", 7, 280), s = pe(t, "shape", 7, "square"), l = pe(t, "visible", 15, !1), o = pe(t, "onPrepareContent", 7), a = pe(t, "onContentUpdated", 7), f = /* @__PURE__ */ U(null), h = /* @__PURE__ */ U(null), v = /* @__PURE__ */ U(null), d = /* @__PURE__ */ U(Be({ x: 200, y: 200 })), p = /* @__PURE__ */ U(!1), c = /* @__PURE__ */ U(Be({ x: 0, y: 0 })), w = null, g = null, k = /* @__PURE__ */ er(() => `
+		left: ${_(d).x}px;
+		top: ${_(d).y}px;
+		width: ${r()}px;
+		height: ${i()}px;
+		${s() === "circle" ? "border-radius: 50%;" : ""}
+		display: ${l() ? "block" : "none"};
+	`), A = /* @__PURE__ */ er(() => `
+		transform: scale(${n()});
+		left: ${-_(d).x * n() - window.scrollX * n()}px;
+		top: ${-_(d).y * n() - window.scrollY * n()}px;
+		width: ${document.body.scrollWidth}px;
+		height: ${document.body.scrollHeight}px;
+	`);
+  function P() {
+    const b = document.body, O = b.cloneNode(!0), Fe = getComputedStyle(b).backgroundColor;
+    Fe && _(f) && (_(f).style.backgroundColor = Fe), O.style.cursor = "auto", O.style.paddingTop = "0px", O.setAttribute("unselectable", "on");
+    const te = b.querySelectorAll("canvas"), Ot = O.querySelectorAll("canvas");
+    if (te.length > 0 && te.length === Ot.length)
+      for (let ut = 0; ut < te.length; ut++) {
+        const Wn = Ot[ut].getContext("2d");
+        if (Wn)
+          try {
+            Wn.drawImage(te[ut], 0, 0);
+          } catch {
+          }
+      }
+    return [
+      ...O.querySelectorAll("script"),
+      ...O.querySelectorAll("audio"),
+      ...O.querySelectorAll("video"),
+      ...O.querySelectorAll(".magnifier"),
+      ...O.querySelectorAll(".magnifier-clone-ignore"),
+      ...O.querySelectorAll("[data-magnifier-ignore]")
+    ].forEach((ut) => ut.remove()), o() && o()(O), O;
+  }
+  function C() {
+    if (!(!l() || !_(h)) && (_(h).innerHTML = "", L(v, P(), !0), _(h).appendChild(_(v)), ee(), a() && _(v))) {
+      const b = _(v).querySelector("body");
+      b && a()(b);
+    }
+  }
+  function ee() {
+    if (!_(v)) return;
+    Array.from(document.querySelectorAll("div")).filter((O) => O.scrollTop > 0 && !_(f)?.contains(O)).forEach((O) => {
+      const Fe = [];
+      O.id && Fe.push("#" + O.id), O.className && Fe.push("." + O.className.split(" ").join(".")), Fe.forEach((te) => {
+        const Ot = _(v).querySelectorAll(te);
+        if (Ot.length === 1) {
+          const pn = Ot[0];
+          pn.scrollTop = O.scrollTop, pn.scrollLeft = O.scrollLeft;
+        }
+      });
+    });
+  }
+  function z() {
+    g !== null && clearTimeout(g), g = window.setTimeout(
+      () => {
+        C();
+      },
+      100
+    );
+  }
+  function Se() {
+    w || (w = new MutationObserver((b) => {
+      for (const O of b)
+        if (!(_(f) && _(f).contains(O.target))) {
+          z();
+          break;
+        }
+    }), w.observe(document.body, {
+      childList: !0,
+      subtree: !0,
+      attributes: !0,
+      attributeFilter: ["class", "width", "height", "style"],
+      attributeOldValue: !0
+    }));
+  }
+  function H() {
+    w && (w.disconnect(), w = null), g !== null && (clearTimeout(g), g = null);
+  }
+  function ue(b) {
+    const O = b.target, Fe = ["INPUT", "TEXTAREA", "SELECT", "BUTTON", "A"];
+    let te = O;
+    for (; te && te !== _(f); ) {
+      if (Fe.includes(te.tagName.toUpperCase()))
+        return;
+      te = te.parentElement;
+    }
+    L(p, !0), L(
+      c,
+      {
+        x: b.clientX - _(d).x,
+        y: b.clientY - _(d).y
+      },
+      !0
+    ), _(f) && _(f).setPointerCapture(b.pointerId);
+  }
+  function hn(b) {
+    _(p) && L(
+      d,
+      {
+        x: b.clientX - _(c).x,
+        y: b.clientY - _(c).y
+      },
+      !0
+    );
+  }
+  function vn(b) {
+    _(p) && _(f) && _(f).releasePointerCapture(b.pointerId), L(p, !1);
+  }
+  function Kn(b) {
+    if (!l()) return;
+    const O = b.target;
+    _(f)?.contains(O) || z();
+  }
+  Lt(() => {
+    l() ? st(() => {
+      C(), Se();
+    }) : st(() => {
+      H();
+    });
+  }), Lt(() => {
+    n(), l() && st(() => {
+      C();
+    });
+  }), Ls(() => (window.addEventListener("scroll", Kn, !0), window.addEventListener("resize", z), () => {
+    H(), window.removeEventListener("scroll", Kn, !0), window.removeEventListener("resize", z);
+  }));
+  var wi = {
+    get zoom() {
+      return n();
+    },
+    set zoom(b = 2) {
+      n(b), ce();
+    },
+    get width() {
+      return r();
+    },
+    set width(b = 420) {
+      r(b), ce();
+    },
+    get height() {
+      return i();
+    },
+    set height(b = 280) {
+      i(b), ce();
+    },
+    get shape() {
+      return s();
+    },
+    set shape(b = "square") {
+      s(b), ce();
+    },
+    get visible() {
+      return l();
+    },
+    set visible(b = !1) {
+      l(b), ce();
+    },
+    get onPrepareContent() {
+      return o();
+    },
+    set onPrepareContent(b) {
+      o(b), ce();
+    },
+    get onContentUpdated() {
+      return a();
+    },
+    set onContentUpdated(b) {
+      a(b), ce();
+    }
+  }, De = el();
+  De.__pointerdown = ue, De.__pointermove = hn, De.__pointerup = vn;
+  var _n = xn(De);
+  ar(_n, (b) => L(h, b), () => _(h));
+  var yi = _s(_n, 4);
+  return Us(yi, t, "default", {}), Gt(De), ar(De, (b) => L(f, b), () => _(f)), Qr(() => {
+    or(De, _(k)), or(_n, _(A));
+  }), Pt(e, De), qn(wi);
+}
+hi(["pointerdown", "pointermove", "pointerup"]);
+mi(
+  bi,
+  {
+    zoom: {},
+    width: {},
+    height: {},
+    shape: {},
+    visible: {},
+    onPrepareContent: {},
+    onContentUpdated: {}
+  },
+  ["default"],
+  [],
+  { mode: "open" }
+);
+var nl = /* @__PURE__ */ Vn('<button><span class="btn-label svelte-1um3llb"> </span></button>'), rl = /* @__PURE__ */ Vn('<div class="btn-group magnifier-clone-ignore svelte-1um3llb" data-magnifier-ignore="true"></div>');
+const il = {
+  hash: "svelte-1um3llb",
+  code: ".btn-group.svelte-1um3llb {background-color:rgba(255, 255, 255, 0.8);border:1px solid var(--pie-primary, #007bff);border-radius:4px;bottom:0.5rem;left:0.5rem;position:absolute;z-index:1001;display:flex;overflow:hidden;}.zoom-btn.svelte-1um3llb {background:white;border:none;border-right:1px solid var(--pie-primary, #007bff);color:var(--pie-primary, #007bff);cursor:pointer;padding:4px 8px;font-size:12px;transition:background-color 0.2s, color 0.2s;}.zoom-btn.svelte-1um3llb:last-child {border-right:none;}.zoom-btn.svelte-1um3llb:hover {background-color:rgba(0, 123, 255, 0.1);}.zoom-btn.active.svelte-1um3llb {background-color:var(--pie-primary, #007bff);color:white;}.zoom-btn.svelte-1um3llb:focus-visible {outline:2px solid var(--pie-primary, #007bff);outline-offset:2px;}.btn-label.svelte-1um3llb {font-size:0.8em;}"
+};
+function sl(e, t) {
+  Fn(t, !0), pi(e, il);
+  let n = pe(t, "visible", 7, !1), r = pe(t, "toolId", 7, "magnifier"), i = pe(t, "coordinator", 7);
+  const s = typeof window < "u";
+  let l = /* @__PURE__ */ U(!1), o = /* @__PURE__ */ U(1.5);
+  const a = [1.5, 2, 3];
+  function f(c) {
+    L(o, c, !0);
+  }
+  Lt(() => {
+    i() && r() && !_(l) && (i().registerTool(r(), "Magnifier", void 0, Pn.TOOL), L(l, !0));
+  }), Lt(() => () => {
+    i() && r() && _(l) && (i().unregisterTool(r()), L(l, !1));
+  });
+  var h = {
+    get visible() {
+      return n();
+    },
+    set visible(c = !1) {
+      n(c), ce();
+    },
+    get toolId() {
+      return r();
+    },
+    set toolId(c = "magnifier") {
+      r(c), ce();
+    },
+    get coordinator() {
+      return i();
+    },
+    set coordinator(c) {
+      i(c), ce();
+    }
+  }, v = Os(), d = vs(v);
+  {
+    var p = (c) => {
+      bi(c, {
+        get zoom() {
+          return _(o);
+        },
+        width: 420,
+        height: 280,
+        shape: "square",
+        get visible() {
+          return n();
+        },
+        set visible(w) {
+          n(w);
+        },
+        children: (w, g) => {
+          var k = rl();
+          Fs(k, 21, () => a, Ms, (A, P) => {
+            var C = nl();
+            let ee;
+            C.__click = () => f(_(P));
+            var z = xn(C), Se = xn(z);
+            Gt(z), Gt(C), Qr(() => {
+              ee = Hs(C, 1, "zoom-btn svelte-1um3llb", null, ee, { active: _(o) === _(P) }), mn(C, "data-zoom", _(P)), mn(C, "title", `${_(P) ?? ""}x zoom`), mn(C, "aria-label", `Set zoom to ${_(P) ?? ""}x`), Ns(Se, `${_(P) ?? ""}x`);
+            }), Pt(A, C);
+          }), Gt(k), Pt(w, k);
+        },
+        $$slots: { default: !0 }
+      });
+    };
+    Is(d, (c) => {
+      s && c(p);
+    });
+  }
+  return Pt(e, v), qn(h);
+}
+hi(["click"]);
+customElements.define("pie-tool-magnifier", mi(
+  sl,
+  {
+    visible: { attribute: "visible", type: "Boolean" },
+    toolId: { attribute: "tool-id", type: "String" },
+    coordinator: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  sl as default
+};
+//# sourceMappingURL=tool-magnifier.js.map