@pie-players/pie-tool-graph 0.1.1

package/dist/tool-graph.js

@@ -0,0 +1,3489 @@
+var Bs = Object.defineProperty;
+var Ur = (e) => {
+  throw TypeError(e);
+};
+var Gs = (e, t, n) => t in e ? Bs(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var j = (e, t, n) => Gs(e, typeof t != "symbol" ? t + "" : t, n), ur = (e, t, n) => t.has(e) || Ur("Cannot " + n);
+var u = (e, t, n) => (ur(e, t, "read from private field"), n ? n.call(e) : t.get(e)), T = (e, t, n) => t.has(e) ? Ur("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), E = (e, t, n, i) => (ur(e, t, "write to private field"), i ? i.call(e, n) : t.set(e, n), n), U = (e, t, n) => (ur(e, t, "access private method"), n);
+var hi;
+typeof window < "u" && ((hi = window.__svelte ?? (window.__svelte = {})).v ?? (hi.v = /* @__PURE__ */ new Set())).add("5");
+const Ws = 1, qs = 2, vi = 4, Ys = 8, Us = 16, Xs = 1, Ks = 2, pi = "[", Yn = "[!", Cr = "]", Jt = {}, Q = /* @__PURE__ */ Symbol(), Js = "http://www.w3.org/1999/xhtml", hr = !1;
+var _i = Array.isArray, Qs = Array.prototype.indexOf, Qt = Array.prototype.includes, Un = Array.from, Fn = Object.keys, jn = Object.defineProperty, Ht = Object.getOwnPropertyDescriptor, Zs = Object.getOwnPropertyDescriptors, el = Object.prototype, tl = Array.prototype, gi = Object.getPrototypeOf, Xr = Object.isExtensible;
+function nl(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function mi() {
+  var e, t, n = new Promise((i, r) => {
+    e = i, t = r;
+  });
+  return { promise: n, resolve: e, reject: t };
+}
+const ee = 2, Vn = 4, Xn = 8, wi = 1 << 24, lt = 16, ze = 32, wt = 64, Ar = 128, Ee = 512, K = 1024, ie = 2048, at = 4096, _e = 8192, nt = 16384, Kn = 32768, Zt = 65536, Kr = 1 << 17, bi = 1 << 18, Lt = 1 << 19, rl = 1 << 20, Ze = 1 << 25, Rt = 32768, vr = 1 << 21, Or = 1 << 22, pt = 1 << 23, In = /* @__PURE__ */ Symbol("$state"), il = /* @__PURE__ */ Symbol("legacy props"), sl = /* @__PURE__ */ Symbol(""), Vt = new class extends Error {
+  constructor() {
+    super(...arguments);
+    j(this, "name", "StaleReactionError");
+    j(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), Jn = 3, rn = 8;
+function ll(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function al() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function ol(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function fl() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function ul(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function cl() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function dl() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function hl() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function vl() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function pl() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function _l() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function Qn(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function gl() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let O = !1;
+function et(e) {
+  O = e;
+}
+let M;
+function ue(e) {
+  if (e === null)
+    throw Qn(), Jt;
+  return M = e;
+}
+function En() {
+  return ue(/* @__PURE__ */ He(M));
+}
+function H(e) {
+  if (O) {
+    if (/* @__PURE__ */ He(M) !== null)
+      throw Qn(), Jt;
+    M = e;
+  }
+}
+function ml(e = 1) {
+  if (O) {
+    for (var t = e, n = M; t--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ He(n);
+    M = n;
+  }
+}
+function Hn(e = !0) {
+  for (var t = 0, n = M; ; ) {
+    if (n.nodeType === rn) {
+      var i = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (i === Cr) {
+        if (t === 0) return n;
+        t -= 1;
+      } else (i === pi || i === Yn) && (t += 1);
+    }
+    var r = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ He(n)
+    );
+    e && n.remove(), n = r;
+  }
+}
+function yi(e) {
+  if (!e || e.nodeType !== rn)
+    throw Qn(), Jt;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function Ei(e) {
+  return e === this.v;
+}
+function wl(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function $i(e) {
+  return !wl(e, this.v);
+}
+let bl = !1, ge = null;
+function en(e) {
+  ge = e;
+}
+function Zn(e, t = !1, n) {
+  ge = {
+    p: ge,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function er(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    ge
+  ), n = t.e;
+  if (n !== null) {
+    t.e = null;
+    for (var i of n)
+      Ui(i);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, ge = t.p, e ?? /** @type {T} */
+  {};
+}
+function xi() {
+  return !0;
+}
+let $t = [];
+function ki() {
+  var e = $t;
+  $t = [], nl(e);
+}
+function Fe(e) {
+  if ($t.length === 0 && !hn) {
+    var t = $t;
+    queueMicrotask(() => {
+      t === $t && ki();
+    });
+  }
+  $t.push(e);
+}
+function yl() {
+  for (; $t.length > 0; )
+    ki();
+}
+function Ti(e) {
+  var t = z;
+  if (t === null)
+    return A.f |= pt, e;
+  if ((t.f & Kn) === 0) {
+    if ((t.f & Ar) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    tn(e, t);
+}
+function tn(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & Ar) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (n) {
+        e = n;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const El = -7169;
+function W(e, t) {
+  e.f = e.f & El | t;
+}
+function Mr(e) {
+  (e.f & Ee) !== 0 || e.deps === null ? W(e, K) : W(e, at);
+}
+function Si(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & ee) === 0 || (t.f & Rt) === 0 || (t.f ^= Rt, Si(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function Ci(e, t, n) {
+  (e.f & ie) !== 0 ? t.add(e) : (e.f & at) !== 0 && n.add(e), Si(e.deps), W(e, K);
+}
+const zn = /* @__PURE__ */ new Set();
+let N = null, pr = null, Ae = null, ve = [], tr = null, _r = !1, hn = !1;
+var Gt, Wt, kt, qt, gn, mn, Tt, Yt, Ve, gr, mr, Ai;
+const Fr = class Fr {
+  constructor() {
+    T(this, Ve);
+    j(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>}
+     */
+    j(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>}
+     */
+    j(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>}
+     */
+    T(this, Gt, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    T(this, Wt, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    T(this, kt, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    T(this, qt, 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}
+     */
+    T(this, gn, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    T(this, mn, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    T(this, Tt, /* @__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>}
+     */
+    j(this, "skipped_effects", /* @__PURE__ */ new Set());
+    j(this, "is_fork", !1);
+    T(this, Yt, !1);
+  }
+  is_deferred() {
+    return this.is_fork || u(this, qt) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    ve = [], this.apply();
+    var n = [], i = [];
+    for (const r of t)
+      U(this, Ve, gr).call(this, r, n, i);
+    if (this.is_deferred()) {
+      U(this, Ve, mr).call(this, i), U(this, Ve, mr).call(this, n);
+      for (const r of this.skipped_effects)
+        Ri(r);
+    } else {
+      for (const r of u(this, Gt)) r();
+      u(this, Gt).clear(), u(this, kt) === 0 && U(this, Ve, Ai).call(this), pr = this, N = null, Jr(i), Jr(n), pr = null, u(this, gn)?.resolve();
+    }
+    Ae = 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 !== Q && !this.previous.has(t) && this.previous.set(t, n), (t.f & pt) === 0 && (this.current.set(t, t.v), Ae?.set(t, t.v));
+  }
+  activate() {
+    N = this, this.apply();
+  }
+  deactivate() {
+    N === this && (N = null, Ae = null);
+  }
+  flush() {
+    if (this.activate(), ve.length > 0) {
+      if (Oi(), N !== null && N !== this)
+        return;
+    } else u(this, kt) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of u(this, Wt)) t(this);
+    u(this, Wt).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    E(this, kt, u(this, kt) + 1), t && E(this, qt, u(this, qt) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    E(this, kt, u(this, kt) - 1), t && E(this, qt, u(this, qt) - 1), !u(this, Yt) && (E(this, Yt, !0), Fe(() => {
+      E(this, Yt, !1), this.is_deferred() ? ve.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of u(this, mn))
+      u(this, Tt).delete(t), W(t, ie), it(t);
+    for (const t of u(this, Tt))
+      W(t, at), it(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    u(this, Gt).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    u(this, Wt).add(t);
+  }
+  settled() {
+    return (u(this, gn) ?? E(this, gn, mi())).promise;
+  }
+  static ensure() {
+    if (N === null) {
+      const t = N = new Fr();
+      zn.add(N), hn || Fe(() => {
+        N === t && t.flush();
+      });
+    }
+    return N;
+  }
+  apply() {
+  }
+};
+Gt = new WeakMap(), Wt = new WeakMap(), kt = new WeakMap(), qt = new WeakMap(), gn = new WeakMap(), mn = new WeakMap(), Tt = new WeakMap(), Yt = new WeakMap(), Ve = 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
+ */
+gr = function(t, n, i) {
+  t.f ^= K;
+  for (var r = t.first, s = null; r !== null; ) {
+    var l = r.f, a = (l & (ze | wt)) !== 0, o = a && (l & K) !== 0, c = o || (l & _e) !== 0 || this.skipped_effects.has(r);
+    if (!c && r.fn !== null) {
+      a ? r.f ^= K : s !== null && (l & (Vn | Xn | wi)) !== 0 ? s.b.defer_effect(r) : (l & Vn) !== 0 ? n.push(r) : $n(r) && ((l & lt) !== 0 && u(this, Tt).add(r), _n(r));
+      var d = r.first;
+      if (d !== null) {
+        r = d;
+        continue;
+      }
+    }
+    var _ = r.parent;
+    for (r = r.next; r === null && _ !== null; )
+      _ === s && (s = null), r = _.next, _ = _.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+mr = function(t) {
+  for (var n = 0; n < t.length; n += 1)
+    Ci(t[n], u(this, mn), u(this, Tt));
+}, Ai = function() {
+  var r;
+  if (zn.size > 1) {
+    this.previous.clear();
+    var t = Ae, n = !0;
+    for (const s of zn) {
+      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 = ve;
+        ve = [];
+        const o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+        for (const d of l)
+          Mi(d, a, o, c);
+        if (ve.length > 0) {
+          N = s, s.apply();
+          for (const d of ve)
+            U(r = s, Ve, gr).call(r, d, [], []);
+          s.deactivate();
+        }
+        ve = i;
+      }
+    }
+    N = null, Ae = t;
+  }
+  this.committed = !0, zn.delete(this);
+};
+let rt = Fr;
+function pe(e) {
+  var t = hn;
+  hn = !0;
+  try {
+    for (var n; ; ) {
+      if (yl(), ve.length === 0 && (N?.flush(), ve.length === 0))
+        return tr = null, /** @type {T} */
+        n;
+      Oi();
+    }
+  } finally {
+    hn = t;
+  }
+}
+function Oi() {
+  _r = !0;
+  var e = null;
+  try {
+    for (var t = 0; ve.length > 0; ) {
+      var n = rt.ensure();
+      if (t++ > 1e3) {
+        var i, r;
+        $l();
+      }
+      n.process(ve), _t.clear();
+    }
+  } finally {
+    _r = !1, tr = null;
+  }
+}
+function $l() {
+  try {
+    cl();
+  } catch (e) {
+    tn(e, tr);
+  }
+}
+let Ye = null;
+function Jr(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var n = 0; n < t; ) {
+      var i = e[n++];
+      if ((i.f & (nt | _e)) === 0 && $n(i) && (Ye = /* @__PURE__ */ new Set(), _n(i), i.deps === null && i.first === null && i.nodes === null && (i.teardown === null && i.ac === null ? Qi(i) : i.fn = null), Ye?.size > 0)) {
+        _t.clear();
+        for (const r of Ye) {
+          if ((r.f & (nt | _e)) !== 0) continue;
+          const s = [r];
+          let l = r.parent;
+          for (; l !== null; )
+            Ye.has(l) && (Ye.delete(l), s.push(l)), l = l.parent;
+          for (let a = s.length - 1; a >= 0; a--) {
+            const o = s[a];
+            (o.f & (nt | _e)) === 0 && _n(o);
+          }
+        }
+        Ye.clear();
+      }
+    }
+    Ye = null;
+  }
+}
+function Mi(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 & ee) !== 0 ? Mi(
+        /** @type {Derived} */
+        r,
+        t,
+        n,
+        i
+      ) : (s & (Or | lt)) !== 0 && (s & ie) === 0 && zi(r, t, i) && (W(r, ie), it(
+        /** @type {Effect} */
+        r
+      ));
+    }
+}
+function zi(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 (Qt.call(t, r))
+        return !0;
+      if ((r.f & ee) !== 0 && zi(
+        /** @type {Derived} */
+        r,
+        t,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          r,
+          !0
+        ), !0;
+    }
+  return n.set(e, !1), !1;
+}
+function it(e) {
+  for (var t = tr = e; t.parent !== null; ) {
+    t = t.parent;
+    var n = t.f;
+    if (_r && t === z && (n & lt) !== 0 && (n & bi) === 0)
+      return;
+    if ((n & (wt | ze)) !== 0) {
+      if ((n & K) === 0) return;
+      t.f ^= K;
+    }
+  }
+  ve.push(t);
+}
+function Ri(e) {
+  if (!((e.f & ze) !== 0 && (e.f & K) !== 0)) {
+    W(e, K);
+    for (var t = e.first; t !== null; )
+      Ri(t), t = t.next;
+  }
+}
+function xl(e) {
+  let t = 0, n = It(0), i;
+  return () => {
+    Ir() && (f(n), ir(() => (t === 0 && (i = sr(() => e(() => vn(n)))), t += 1, () => {
+      Fe(() => {
+        t -= 1, t === 0 && (i?.(), i = void 0, vn(n));
+      });
+    })));
+  };
+}
+var kl = Zt | Lt | Ar;
+function Tl(e, t, n) {
+  new Sl(e, t, n);
+}
+var de, wn, Le, St, Ne, we, oe, Pe, Xe, vt, Ct, Ke, Ut, At, Xt, Kt, Je, Wn, B, Ii, Li, wr, Ln, Nn, br;
+class Sl {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, n, i) {
+    T(this, B);
+    /** @type {Boundary | null} */
+    j(this, "parent");
+    j(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    T(this, de);
+    /** @type {TemplateNode | null} */
+    T(this, wn, O ? M : null);
+    /** @type {BoundaryProps} */
+    T(this, Le);
+    /** @type {((anchor: Node) => void)} */
+    T(this, St);
+    /** @type {Effect} */
+    T(this, Ne);
+    /** @type {Effect | null} */
+    T(this, we, null);
+    /** @type {Effect | null} */
+    T(this, oe, null);
+    /** @type {Effect | null} */
+    T(this, Pe, null);
+    /** @type {DocumentFragment | null} */
+    T(this, Xe, null);
+    /** @type {TemplateNode | null} */
+    T(this, vt, null);
+    T(this, Ct, 0);
+    T(this, Ke, 0);
+    T(this, Ut, !1);
+    T(this, At, !1);
+    /** @type {Set<Effect>} */
+    T(this, Xt, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    T(this, Kt, /* @__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}
+     */
+    T(this, Je, null);
+    T(this, Wn, xl(() => (E(this, Je, It(u(this, Ct))), () => {
+      E(this, Je, null);
+    })));
+    E(this, de, t), E(this, Le, n), E(this, St, i), this.parent = /** @type {Effect} */
+    z.b, this.is_pending = !!u(this, Le).pending, E(this, Ne, Lr(() => {
+      if (z.b = this, O) {
+        const s = u(this, wn);
+        En(), /** @type {Comment} */
+        s.nodeType === rn && /** @type {Comment} */
+        s.data === Yn ? U(this, B, Li).call(this) : (U(this, B, Ii).call(this), u(this, Ke) === 0 && (this.is_pending = !1));
+      } else {
+        var r = U(this, B, wr).call(this);
+        try {
+          E(this, we, ye(() => i(r)));
+        } catch (s) {
+          this.error(s);
+        }
+        u(this, Ke) > 0 ? U(this, B, Nn).call(this) : this.is_pending = !1;
+      }
+      return () => {
+        u(this, vt)?.remove();
+      };
+    }, kl)), O && E(this, de, M);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    Ci(t, u(this, Xt), u(this, Kt));
+  }
+  /**
+   * 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, Le).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) {
+    U(this, B, br).call(this, t), E(this, Ct, u(this, Ct) + t), !(!u(this, Je) || u(this, Ut)) && (E(this, Ut, !0), Fe(() => {
+      E(this, Ut, !1), u(this, Je) && nn(u(this, Je), u(this, Ct));
+    }));
+  }
+  get_effect_pending() {
+    return u(this, Wn).call(this), f(
+      /** @type {Source<number>} */
+      u(this, Je)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var n = u(this, Le).onerror;
+    let i = u(this, Le).failed;
+    if (u(this, At) || !n && !i)
+      throw t;
+    u(this, we) && (re(u(this, we)), E(this, we, null)), u(this, oe) && (re(u(this, oe)), E(this, oe, null)), u(this, Pe) && (re(u(this, Pe)), E(this, Pe, null)), O && (ue(
+      /** @type {TemplateNode} */
+      u(this, wn)
+    ), ml(), ue(Hn()));
+    var r = !1, s = !1;
+    const l = () => {
+      if (r) {
+        gl();
+        return;
+      }
+      r = !0, s && _l(), rt.ensure(), E(this, Ct, 0), u(this, Pe) !== null && Mt(u(this, Pe), () => {
+        E(this, Pe, null);
+      }), this.is_pending = this.has_pending_snippet(), E(this, we, U(this, B, Ln).call(this, () => (E(this, At, !1), ye(() => u(this, St).call(this, u(this, de)))))), u(this, Ke) > 0 ? U(this, B, Nn).call(this) : this.is_pending = !1;
+    };
+    Fe(() => {
+      try {
+        s = !0, n?.(t, l), s = !1;
+      } catch (a) {
+        tn(a, u(this, Ne) && u(this, Ne).parent);
+      }
+      i && E(this, Pe, U(this, B, Ln).call(this, () => {
+        rt.ensure(), E(this, At, !0);
+        try {
+          return ye(() => {
+            i(
+              u(this, de),
+              () => t,
+              () => l
+            );
+          });
+        } catch (a) {
+          return tn(
+            a,
+            /** @type {Effect} */
+            u(this, Ne).parent
+          ), null;
+        } finally {
+          E(this, At, !1);
+        }
+      }));
+    });
+  }
+}
+de = new WeakMap(), wn = new WeakMap(), Le = new WeakMap(), St = new WeakMap(), Ne = new WeakMap(), we = new WeakMap(), oe = new WeakMap(), Pe = new WeakMap(), Xe = new WeakMap(), vt = new WeakMap(), Ct = new WeakMap(), Ke = new WeakMap(), Ut = new WeakMap(), At = new WeakMap(), Xt = new WeakMap(), Kt = new WeakMap(), Je = new WeakMap(), Wn = new WeakMap(), B = new WeakSet(), Ii = function() {
+  try {
+    E(this, we, ye(() => u(this, St).call(this, u(this, de))));
+  } catch (t) {
+    this.error(t);
+  }
+}, Li = function() {
+  const t = u(this, Le).pending;
+  t && (E(this, oe, ye(() => t(u(this, de)))), Fe(() => {
+    var n = U(this, B, wr).call(this);
+    E(this, we, U(this, B, Ln).call(this, () => (rt.ensure(), ye(() => u(this, St).call(this, n))))), u(this, Ke) > 0 ? U(this, B, Nn).call(this) : (Mt(
+      /** @type {Effect} */
+      u(this, oe),
+      () => {
+        E(this, oe, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, wr = function() {
+  var t = u(this, de);
+  return this.is_pending && (E(this, vt, $e()), u(this, de).before(u(this, vt)), t = u(this, vt)), t;
+}, /**
+ * @param {() => Effect | null} fn
+ */
+Ln = function(t) {
+  var n = z, i = A, r = ge;
+  je(u(this, Ne)), ke(u(this, Ne)), en(u(this, Ne).ctx);
+  try {
+    return t();
+  } catch (s) {
+    return Ti(s), null;
+  } finally {
+    je(n), ke(i), en(r);
+  }
+}, Nn = function() {
+  const t = (
+    /** @type {(anchor: Node) => void} */
+    u(this, Le).pending
+  );
+  u(this, we) !== null && (E(this, Xe, document.createDocumentFragment()), u(this, Xe).append(
+    /** @type {TemplateNode} */
+    u(this, vt)
+  ), ts(u(this, we), u(this, Xe))), u(this, oe) === null && E(this, oe, ye(() => t(u(this, de))));
+}, /**
+ * 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
+ */
+br = function(t) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && U(n = this.parent, B, br).call(n, t);
+    return;
+  }
+  if (E(this, Ke, u(this, Ke) + t), u(this, Ke) === 0) {
+    this.is_pending = !1;
+    for (const i of u(this, Xt))
+      W(i, ie), it(i);
+    for (const i of u(this, Kt))
+      W(i, at), it(i);
+    u(this, Xt).clear(), u(this, Kt).clear(), u(this, oe) && Mt(u(this, oe), () => {
+      E(this, oe, null);
+    }), u(this, Xe) && (u(this, de).before(u(this, Xe)), E(this, Xe, null));
+  }
+};
+function Cl(e, t, n, i) {
+  const r = nr;
+  var s = e.filter((h) => !h.settled);
+  if (n.length === 0 && s.length === 0) {
+    i(t.map(r));
+    return;
+  }
+  var l = N, a = (
+    /** @type {Effect} */
+    z
+  ), o = Al(), c = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((h) => h.promise)) : null;
+  function d(h) {
+    o();
+    try {
+      i(h);
+    } catch (p) {
+      (a.f & nt) === 0 && tn(p, a);
+    }
+    l?.deactivate(), yr();
+  }
+  if (n.length === 0) {
+    c.then(() => d(t.map(r)));
+    return;
+  }
+  function _() {
+    o(), Promise.all(n.map((h) => /* @__PURE__ */ Ol(h))).then((h) => d([...t.map(r), ...h])).catch((h) => tn(h, a));
+  }
+  c ? c.then(_) : _();
+}
+function Al() {
+  var e = z, t = A, n = ge, i = N;
+  return function(s = !0) {
+    je(e), ke(t), en(n), s && i?.activate();
+  };
+}
+function yr() {
+  je(null), ke(null), en(null);
+}
+// @__NO_SIDE_EFFECTS__
+function nr(e) {
+  var t = ee | ie, n = A !== null && (A.f & ee) !== 0 ? (
+    /** @type {Derived} */
+    A
+  ) : null;
+  return z !== null && (z.f |= Lt), {
+    ctx: ge,
+    deps: null,
+    effects: null,
+    equals: Ei,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      Q
+    ),
+    wv: 0,
+    parent: n ?? z,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ol(e, t, n) {
+  let i = (
+    /** @type {Effect | null} */
+    z
+  );
+  i === null && al();
+  var r = (
+    /** @type {Boundary} */
+    i.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = It(
+    /** @type {V} */
+    Q
+  ), a = !A, o = /* @__PURE__ */ new Map();
+  return jl(() => {
+    var c = mi();
+    s = c.promise;
+    try {
+      Promise.resolve(e()).then(c.resolve, c.reject).then(() => {
+        d === N && d.committed && d.deactivate(), yr();
+      });
+    } catch (p) {
+      c.reject(p), yr();
+    }
+    var d = (
+      /** @type {Batch} */
+      N
+    );
+    if (a) {
+      var _ = r.is_rendered();
+      r.update_pending_count(1), d.increment(_), o.get(d)?.reject(Vt), o.delete(d), o.set(d, c);
+    }
+    const h = (p, g = void 0) => {
+      if (d.activate(), g)
+        g !== Vt && (l.f |= pt, nn(l, g));
+      else {
+        (l.f & pt) !== 0 && (l.f ^= pt), nn(l, p);
+        for (const [x, v] of o) {
+          if (o.delete(x), x === d) break;
+          v.reject(Vt);
+        }
+      }
+      a && (r.update_pending_count(-1), d.decrement(_));
+    };
+    c.promise.then(h, (p) => h(null, p || "unknown"));
+  }), Yi(() => {
+    for (const c of o.values())
+      c.reject(Vt);
+  }), new Promise((c) => {
+    function d(_) {
+      function h() {
+        _ === s ? c(l) : d(s);
+      }
+      _.then(h, h);
+    }
+    d(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function fn(e) {
+  const t = /* @__PURE__ */ nr(e);
+  return ns(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function Ml(e) {
+  const t = /* @__PURE__ */ nr(e);
+  return t.equals = $i, t;
+}
+function Ni(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var n = 0; n < t.length; n += 1)
+      re(
+        /** @type {Effect} */
+        t[n]
+      );
+  }
+}
+function zl(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & ee) === 0)
+      return (t.f & nt) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function zr(e) {
+  var t, n = z;
+  je(zl(e));
+  try {
+    e.f &= ~Rt, Ni(e), t = ls(e);
+  } finally {
+    je(n);
+  }
+  return t;
+}
+function Pi(e) {
+  var t = zr(e);
+  if (!e.equals(t) && (e.wv = is(), (!N?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    W(e, K);
+    return;
+  }
+  mt || (Ae !== null ? (Ir() || N?.is_fork) && Ae.set(e, t) : Mr(e));
+}
+let Er = /* @__PURE__ */ new Set();
+const _t = /* @__PURE__ */ new Map();
+let Di = !1;
+function It(e, t) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Ei,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function I(e, t) {
+  const n = It(e);
+  return ns(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function Fi(e, t = !1, n = !0) {
+  const i = It(e);
+  return t || (i.equals = $i), i;
+}
+function w(e, t, n = !1) {
+  A !== 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
+  (!Oe || (A.f & Kr) !== 0) && xi() && (A.f & (ee | lt | Or | Kr)) !== 0 && (xe === null || !Qt.call(xe, e)) && pl();
+  let i = n ? tt(t) : t;
+  return nn(e, i);
+}
+function nn(e, t) {
+  if (!e.equals(t)) {
+    var n = e.v;
+    mt ? _t.set(e, t) : _t.set(e, n), e.v = t;
+    var i = rt.ensure();
+    if (i.capture(e, n), (e.f & ee) !== 0) {
+      const r = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & ie) !== 0 && zr(r), Mr(r);
+    }
+    e.wv = is(), ji(e, ie), z !== null && (z.f & K) !== 0 && (z.f & (ze | wt)) === 0 && (me === null ? Bl([e]) : me.push(e)), !i.is_fork && Er.size > 0 && !Di && Rl();
+  }
+  return t;
+}
+function Rl() {
+  Di = !1;
+  for (const e of Er)
+    (e.f & K) !== 0 && W(e, at), $n(e) && _n(e);
+  Er.clear();
+}
+function Il(e, t = 1) {
+  var n = f(e), i = t === 1 ? n++ : n--;
+  return w(e, n), i;
+}
+function vn(e) {
+  w(e, e.v + 1);
+}
+function ji(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 & ie) === 0;
+      if (a && W(s, t), (l & ee) !== 0) {
+        var o = (
+          /** @type {Derived} */
+          s
+        );
+        Ae?.delete(o), (l & Rt) === 0 && (l & Ee && (s.f |= Rt), ji(o, at));
+      } else a && ((l & lt) !== 0 && Ye !== null && Ye.add(
+        /** @type {Effect} */
+        s
+      ), it(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function tt(e) {
+  if (typeof e != "object" || e === null || In in e)
+    return e;
+  const t = gi(e);
+  if (t !== el && t !== tl)
+    return e;
+  var n = /* @__PURE__ */ new Map(), i = _i(e), r = /* @__PURE__ */ I(0), s = zt, l = (a) => {
+    if (zt === s)
+      return a();
+    var o = A, c = zt;
+    ke(null), ti(s);
+    var d = a();
+    return ke(o), ti(c), d;
+  };
+  return i && n.set("length", /* @__PURE__ */ I(
+    /** @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) && hl();
+        var d = n.get(o);
+        return d === void 0 ? d = l(() => {
+          var _ = /* @__PURE__ */ I(c.value);
+          return n.set(o, _), _;
+        }) : w(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__ */ I(Q));
+            n.set(o, d), vn(r);
+          }
+        } else
+          w(c, Q), vn(r);
+        return !0;
+      },
+      get(a, o, c) {
+        if (o === In)
+          return e;
+        var d = n.get(o), _ = o in a;
+        if (d === void 0 && (!_ || Ht(a, o)?.writable) && (d = l(() => {
+          var p = tt(_ ? a[o] : Q), g = /* @__PURE__ */ I(p);
+          return g;
+        }), n.set(o, d)), d !== void 0) {
+          var h = f(d);
+          return h === Q ? void 0 : h;
+        }
+        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 = f(d));
+        } else if (c === void 0) {
+          var _ = n.get(o), h = _?.v;
+          if (_ !== void 0 && h !== Q)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: h,
+              writable: !0
+            };
+        }
+        return c;
+      },
+      has(a, o) {
+        if (o === In)
+          return !0;
+        var c = n.get(o), d = c !== void 0 && c.v !== Q || Reflect.has(a, o);
+        if (c !== void 0 || z !== null && (!d || Ht(a, o)?.writable)) {
+          c === void 0 && (c = l(() => {
+            var h = d ? tt(a[o]) : Q, p = /* @__PURE__ */ I(h);
+            return p;
+          }), n.set(o, c));
+          var _ = f(c);
+          if (_ === Q)
+            return !1;
+        }
+        return d;
+      },
+      set(a, o, c, d) {
+        var _ = n.get(o), h = o in a;
+        if (i && o === "length")
+          for (var p = c; p < /** @type {Source<number>} */
+          _.v; p += 1) {
+            var g = n.get(p + "");
+            g !== void 0 ? w(g, Q) : p in a && (g = l(() => /* @__PURE__ */ I(Q)), n.set(p + "", g));
+          }
+        if (_ === void 0)
+          (!h || Ht(a, o)?.writable) && (_ = l(() => /* @__PURE__ */ I(void 0)), w(_, tt(c)), n.set(o, _));
+        else {
+          h = _.v !== Q;
+          var x = l(() => tt(c));
+          w(_, x);
+        }
+        var v = Reflect.getOwnPropertyDescriptor(a, o);
+        if (v?.set && v.set.call(d, c), !h) {
+          if (i && typeof o == "string") {
+            var b = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), te = Number(o);
+            Number.isInteger(te) && te >= b.v && w(b, te + 1);
+          }
+          vn(r);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        f(r);
+        var o = Reflect.ownKeys(a).filter((_) => {
+          var h = n.get(_);
+          return h === void 0 || h.v !== Q;
+        });
+        for (var [c, d] of n)
+          d.v !== Q && !(c in a) && o.push(c);
+        return o;
+      },
+      setPrototypeOf() {
+        vl();
+      }
+    }
+  );
+}
+var Qr, Vi, Hi, Bi;
+function $r() {
+  if (Qr === void 0) {
+    Qr = window, Vi = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, n = Text.prototype;
+    Hi = Ht(t, "firstChild").get, Bi = Ht(t, "nextSibling").get, Xr(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Xr(n) && (n.__t = void 0);
+  }
+}
+function $e(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function st(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Hi.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function He(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Bi.call(e)
+  );
+}
+function Z(e, t) {
+  if (!O)
+    return /* @__PURE__ */ st(e);
+  var n = /* @__PURE__ */ st(M);
+  if (n === null)
+    n = M.appendChild($e());
+  else if (t && n.nodeType !== Jn) {
+    var i = $e();
+    return n?.before(i), ue(i), i;
+  }
+  return t && Rr(
+    /** @type {Text} */
+    n
+  ), ue(n), n;
+}
+function Ue(e, t = !1) {
+  if (!O) {
+    var n = /* @__PURE__ */ st(e);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ He(n) : n;
+  }
+  if (t) {
+    if (M?.nodeType !== Jn) {
+      var i = $e();
+      return M?.before(i), ue(i), i;
+    }
+    Rr(
+      /** @type {Text} */
+      M
+    );
+  }
+  return M;
+}
+function X(e, t = 1, n = !1) {
+  let i = O ? M : e;
+  for (var r; t--; )
+    r = i, i = /** @type {TemplateNode} */
+    /* @__PURE__ */ He(i);
+  if (!O)
+    return i;
+  if (n) {
+    if (i?.nodeType !== Jn) {
+      var s = $e();
+      return i === null ? r?.after(s) : i.before(s), ue(s), s;
+    }
+    Rr(
+      /** @type {Text} */
+      i
+    );
+  }
+  return ue(i), i;
+}
+function Gi(e) {
+  e.textContent = "";
+}
+function Wi() {
+  return !1;
+}
+function Rr(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Jn; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+let Zr = !1;
+function qi() {
+  Zr || (Zr = !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 rr(e) {
+  var t = A, n = z;
+  ke(null), je(null);
+  try {
+    return e();
+  } finally {
+    ke(t), je(n);
+  }
+}
+function Ll(e, t, n, i = n) {
+  e.addEventListener(t, () => rr(n));
+  const r = e.__on_r;
+  r ? e.__on_r = () => {
+    r(), i(!0);
+  } : e.__on_r = () => i(!0), qi();
+}
+function Nl(e) {
+  z === null && (A === null && ul(), fl()), mt && ol();
+}
+function Pl(e, t) {
+  var n = t.last;
+  n === null ? t.last = t.first = e : (n.next = e, e.prev = n, t.last = e);
+}
+function Be(e, t, n) {
+  var i = z;
+  i !== null && (i.f & _e) !== 0 && (e |= _e);
+  var r = {
+    ctx: ge,
+    deps: null,
+    nodes: null,
+    f: e | ie | Ee,
+    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 {
+      _n(r), r.f |= Kn;
+    } catch (a) {
+      throw re(r), a;
+    }
+  else t !== null && it(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 & Lt) === 0 && (s = s.first, (e & lt) !== 0 && (e & Zt) !== 0 && s !== null && (s.f |= Zt)), s !== null && (s.parent = i, i !== null && Pl(s, i), A !== null && (A.f & ee) !== 0 && (e & wt) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      A
+    );
+    (l.effects ?? (l.effects = [])).push(s);
+  }
+  return r;
+}
+function Ir() {
+  return A !== null && !Oe;
+}
+function Yi(e) {
+  const t = Be(Xn, null, !1);
+  return W(t, K), t.teardown = e, t;
+}
+function Bt(e) {
+  Nl();
+  var t = (
+    /** @type {Effect} */
+    z.f
+  ), n = !A && (t & ze) !== 0 && (t & Kn) === 0;
+  if (n) {
+    var i = (
+      /** @type {ComponentContext} */
+      ge
+    );
+    (i.e ?? (i.e = [])).push(e);
+  } else
+    return Ui(e);
+}
+function Ui(e) {
+  return Be(Vn | rl, e, !1);
+}
+function Dl(e) {
+  rt.ensure();
+  const t = Be(wt | Lt, e, !0);
+  return () => {
+    re(t);
+  };
+}
+function Fl(e) {
+  rt.ensure();
+  const t = Be(wt | Lt, e, !0);
+  return (n = {}) => new Promise((i) => {
+    n.outro ? Mt(t, () => {
+      re(t), i(void 0);
+    }) : (re(t), i(void 0));
+  });
+}
+function Xi(e) {
+  return Be(Vn, e, !1);
+}
+function jl(e) {
+  return Be(Or | Lt, e, !0);
+}
+function ir(e, t = 0) {
+  return Be(Xn | t, e, !0);
+}
+function Se(e, t = [], n = [], i = []) {
+  Cl(i, t, n, (r) => {
+    Be(Xn, () => e(...r.map(f)), !0);
+  });
+}
+function Lr(e, t = 0) {
+  var n = Be(lt | t, e, !0);
+  return n;
+}
+function ye(e) {
+  return Be(ze | Lt, e, !0);
+}
+function Ki(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const n = mt, i = A;
+    ei(!0), ke(null);
+    try {
+      t.call(null);
+    } finally {
+      ei(n), ke(i);
+    }
+  }
+}
+function Ji(e, t = !1) {
+  var n = e.first;
+  for (e.first = e.last = null; n !== null; ) {
+    const r = n.ac;
+    r !== null && rr(() => {
+      r.abort(Vt);
+    });
+    var i = n.next;
+    (n.f & wt) !== 0 ? n.parent = null : re(n, t), n = i;
+  }
+}
+function Vl(e) {
+  for (var t = e.first; t !== null; ) {
+    var n = t.next;
+    (t.f & ze) === 0 && re(t), t = n;
+  }
+}
+function re(e, t = !0) {
+  var n = !1;
+  (t || (e.f & bi) !== 0) && e.nodes !== null && e.nodes.end !== null && (Hl(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), n = !0), Ji(e, t && !n), Bn(e, 0), W(e, nt);
+  var i = e.nodes && e.nodes.t;
+  if (i !== null)
+    for (const s of i)
+      s.stop();
+  Ki(e);
+  var r = e.parent;
+  r !== null && r.first !== null && Qi(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Hl(e, t) {
+  for (; e !== null; ) {
+    var n = e === t ? null : /* @__PURE__ */ He(e);
+    e.remove(), e = n;
+  }
+}
+function Qi(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 Mt(e, t, n = !0) {
+  var i = [];
+  Zi(e, i, !0);
+  var r = () => {
+    n && re(e), t && t();
+  }, s = i.length;
+  if (s > 0) {
+    var l = () => --s || r();
+    for (var a of i)
+      a.out(l);
+  } else
+    r();
+}
+function Zi(e, t, n) {
+  if ((e.f & _e) === 0) {
+    e.f ^= _e;
+    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 & Zt) !== 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 & ze) !== 0 && (e.f & lt) !== 0;
+      Zi(r, t, l ? n : !1), r = s;
+    }
+  }
+}
+function Nr(e) {
+  es(e, !0);
+}
+function es(e, t) {
+  if ((e.f & _e) !== 0) {
+    e.f ^= _e, (e.f & K) === 0 && (W(e, ie), it(e));
+    for (var n = e.first; n !== null; ) {
+      var i = n.next, r = (n.f & Zt) !== 0 || (n.f & ze) !== 0;
+      es(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 ts(e, t) {
+  if (e.nodes)
+    for (var n = e.nodes.start, i = e.nodes.end; n !== null; ) {
+      var r = n === i ? null : /* @__PURE__ */ He(n);
+      t.append(n), n = r;
+    }
+}
+let Pn = !1, mt = !1;
+function ei(e) {
+  mt = e;
+}
+let A = null, Oe = !1;
+function ke(e) {
+  A = e;
+}
+let z = null;
+function je(e) {
+  z = e;
+}
+let xe = null;
+function ns(e) {
+  A !== null && (xe === null ? xe = [e] : xe.push(e));
+}
+let fe = null, ce = 0, me = null;
+function Bl(e) {
+  me = e;
+}
+let rs = 1, xt = 0, zt = xt;
+function ti(e) {
+  zt = e;
+}
+function is() {
+  return ++rs;
+}
+function $n(e) {
+  var t = e.f;
+  if ((t & ie) !== 0)
+    return !0;
+  if (t & ee && (e.f &= ~Rt), (t & at) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      e.deps
+    ), i = n.length, r = 0; r < i; r++) {
+      var s = n[r];
+      if ($n(
+        /** @type {Derived} */
+        s
+      ) && Pi(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & Ee) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    Ae === null && W(e, K);
+  }
+  return !1;
+}
+function ss(e, t, n = !0) {
+  var i = e.reactions;
+  if (i !== null && !(xe !== null && Qt.call(xe, e)))
+    for (var r = 0; r < i.length; r++) {
+      var s = i[r];
+      (s.f & ee) !== 0 ? ss(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (n ? W(s, ie) : (s.f & K) !== 0 && W(s, at), it(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function ls(e) {
+  var x;
+  var t = fe, n = ce, i = me, r = A, s = xe, l = ge, a = Oe, o = zt, c = e.f;
+  fe = /** @type {null | Value[]} */
+  null, ce = 0, me = null, A = (c & (ze | wt)) === 0 ? e : null, xe = null, en(e.ctx), Oe = !1, zt = ++xt, e.ac !== null && (rr(() => {
+    e.ac.abort(Vt);
+  }), e.ac = null);
+  try {
+    e.f |= vr;
+    var d = (
+      /** @type {Function} */
+      e.fn
+    ), _ = d(), h = e.deps, p = N?.is_fork;
+    if (fe !== null) {
+      var g;
+      if (p || Bn(e, ce), h !== null && ce > 0)
+        for (h.length = ce + fe.length, g = 0; g < fe.length; g++)
+          h[ce + g] = fe[g];
+      else
+        e.deps = h = fe;
+      if (Ir() && (e.f & Ee) !== 0)
+        for (g = ce; g < h.length; g++)
+          ((x = h[g]).reactions ?? (x.reactions = [])).push(e);
+    } else !p && h !== null && ce < h.length && (Bn(e, ce), h.length = ce);
+    if (xi() && me !== null && !Oe && h !== null && (e.f & (ee | at | ie)) === 0)
+      for (g = 0; g < /** @type {Source[]} */
+      me.length; g++)
+        ss(
+          me[g],
+          /** @type {Effect} */
+          e
+        );
+    if (r !== null && r !== e) {
+      if (xt++, r.deps !== null)
+        for (let v = 0; v < n; v += 1)
+          r.deps[v].rv = xt;
+      if (t !== null)
+        for (const v of t)
+          v.rv = xt;
+      me !== null && (i === null ? i = me : i.push(.../** @type {Source[]} */
+      me));
+    }
+    return (e.f & pt) !== 0 && (e.f ^= pt), _;
+  } catch (v) {
+    return Ti(v);
+  } finally {
+    e.f ^= vr, fe = t, ce = n, me = i, A = r, xe = s, en(l), Oe = a, zt = o;
+  }
+}
+function Gl(e, t) {
+  let n = t.reactions;
+  if (n !== null) {
+    var i = Qs.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 & ee) !== 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
+  (fe === null || !Qt.call(fe, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & Ee) !== 0 && (s.f ^= Ee, s.f &= ~Rt), Mr(s), Ni(s), Bn(s, 0);
+  }
+}
+function Bn(e, t) {
+  var n = e.deps;
+  if (n !== null)
+    for (var i = t; i < n.length; i++)
+      Gl(e, n[i]);
+}
+function _n(e) {
+  var t = e.f;
+  if ((t & nt) === 0) {
+    W(e, K);
+    var n = z, i = Pn;
+    z = e, Pn = !0;
+    try {
+      (t & (lt | wi)) !== 0 ? Vl(e) : Ji(e), Ki(e);
+      var r = ls(e);
+      e.teardown = typeof r == "function" ? r : null, e.wv = rs;
+      var s;
+      hr && bl && (e.f & ie) !== 0 && e.deps;
+    } finally {
+      Pn = i, z = n;
+    }
+  }
+}
+async function Wl() {
+  await Promise.resolve(), pe();
+}
+function f(e) {
+  var t = e.f, n = (t & ee) !== 0;
+  if (A !== null && !Oe) {
+    var i = z !== null && (z.f & nt) !== 0;
+    if (!i && (xe === null || !Qt.call(xe, e))) {
+      var r = A.deps;
+      if ((A.f & vr) !== 0)
+        e.rv < xt && (e.rv = xt, fe === null && r !== null && r[ce] === e ? ce++ : fe === null ? fe = [e] : fe.push(e));
+      else {
+        (A.deps ?? (A.deps = [])).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [A] : Qt.call(s, A) || s.push(A);
+      }
+    }
+  }
+  if (mt && _t.has(e))
+    return _t.get(e);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (mt) {
+      var a = l.v;
+      return ((l.f & K) === 0 && l.reactions !== null || os(l)) && (a = zr(l)), _t.set(l, a), a;
+    }
+    var o = (l.f & Ee) === 0 && !Oe && A !== null && (Pn || (A.f & Ee) !== 0), c = l.deps === null;
+    $n(l) && (o && (l.f |= Ee), Pi(l)), o && !c && as(l);
+  }
+  if (Ae?.has(e))
+    return Ae.get(e);
+  if ((e.f & pt) !== 0)
+    throw e.v;
+  return e.v;
+}
+function as(e) {
+  if (e.deps !== null) {
+    e.f |= Ee;
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & ee) !== 0 && (t.f & Ee) === 0 && as(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function os(e) {
+  if (e.v === Q) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (_t.has(t) || (t.f & ee) !== 0 && os(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function sr(e) {
+  var t = Oe;
+  try {
+    return Oe = !0, e();
+  } finally {
+    Oe = t;
+  }
+}
+const fs = /* @__PURE__ */ new Set(), xr = /* @__PURE__ */ new Set();
+function ql(e, t, n, i = {}) {
+  function r(s) {
+    if (i.capture || cn.call(t, s), !s.cancelBubble)
+      return rr(() => n?.call(this, s));
+  }
+  return e.startsWith("pointer") || e.startsWith("touch") || e === "wheel" ? Fe(() => {
+    t.addEventListener(e, r, i);
+  }) : t.addEventListener(e, r, i), r;
+}
+function Yl(e, t, n, i, r) {
+  var s = { capture: i, passive: r }, l = ql(e, t, n, s);
+  (t === document.body || // @ts-ignore
+  t === window || // @ts-ignore
+  t === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+  t instanceof HTMLMediaElement) && Yi(() => {
+    t.removeEventListener(e, l, s);
+  });
+}
+function Pr(e) {
+  for (var t = 0; t < e.length; t++)
+    fs.add(e[t]);
+  for (var n of xr)
+    n(e);
+}
+let ni = null;
+function cn(e) {
+  var t = this, n = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), i = e.type, r = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    r[0] || e.target
+  );
+  ni = e;
+  var l = 0, a = ni === 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) {
+    jn(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var d = A, _ = z;
+    ke(null), je(null);
+    try {
+      for (var h, p = []; s !== null; ) {
+        var g = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var x = s["__" + i];
+          x != 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) && x.call(s, e);
+        } catch (v) {
+          h ? p.push(v) : h = v;
+        }
+        if (e.cancelBubble || g === t || g === null)
+          break;
+        s = g;
+      }
+      if (h) {
+        for (let v of p)
+          queueMicrotask(() => {
+            throw v;
+          });
+        throw h;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, ke(d), je(_);
+    }
+  }
+}
+function us(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function gt(e, t) {
+  var n = (
+    /** @type {Effect} */
+    z
+  );
+  n.nodes === null && (n.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function xn(e, t) {
+  var n = (t & Xs) !== 0, i = (t & Ks) !== 0, r, s = !e.startsWith("<!>");
+  return () => {
+    if (O)
+      return gt(M, null), M;
+    r === void 0 && (r = us(s ? e : "<!>" + e), n || (r = /** @type {TemplateNode} */
+    /* @__PURE__ */ st(r)));
+    var l = (
+      /** @type {TemplateNode} */
+      i || Vi ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    if (n) {
+      var a = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ st(l)
+      ), o = (
+        /** @type {TemplateNode} */
+        l.lastChild
+      );
+      gt(a, o);
+    } else
+      gt(l, l);
+    return l;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ul(e, t, n = "svg") {
+  var i = !e.startsWith("<!>"), r = `<${n}>${i ? e : "<!>" + e}</${n}>`, s;
+  return () => {
+    if (O)
+      return gt(M, null), M;
+    if (!s) {
+      var l = (
+        /** @type {DocumentFragment} */
+        us(r)
+      ), a = (
+        /** @type {Element} */
+        /* @__PURE__ */ st(l)
+      );
+      s = /** @type {Element} */
+      /* @__PURE__ */ st(a);
+    }
+    var o = (
+      /** @type {TemplateNode} */
+      s.cloneNode(!0)
+    );
+    return gt(o, o), o;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Re(e, t) {
+  return /* @__PURE__ */ Ul(e, t, "svg");
+}
+function Et() {
+  if (O)
+    return gt(M, null), M;
+  var e = document.createDocumentFragment(), t = document.createComment(""), n = $e();
+  return e.append(t, n), gt(t, n), e;
+}
+function D(e, t) {
+  if (O) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      z
+    );
+    ((n.f & Kn) === 0 || n.nodes.end === null) && (n.nodes.end = M), En();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const Xl = ["touchstart", "touchmove"];
+function Kl(e) {
+  return Xl.includes(e);
+}
+function cs(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 ds(e, t) {
+  return hs(e, t);
+}
+function Jl(e, t) {
+  $r(), t.intro = t.intro ?? !1;
+  const n = t.target, i = O, r = M;
+  try {
+    for (var s = /* @__PURE__ */ st(n); s && (s.nodeType !== rn || /** @type {Comment} */
+    s.data !== pi); )
+      s = /* @__PURE__ */ He(s);
+    if (!s)
+      throw Jt;
+    et(!0), ue(
+      /** @type {Comment} */
+      s
+    );
+    const l = hs(e, { ...t, anchor: s });
+    return et(!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 !== Jt && console.warn("Failed to hydrate: ", l), t.recover === !1 && dl(), $r(), Gi(n), et(!1), ds(e, t);
+  } finally {
+    et(i), ue(r);
+  }
+}
+const jt = /* @__PURE__ */ new Map();
+function hs(e, { target: t, anchor: n, props: i = {}, events: r, context: s, intro: l = !0 }) {
+  $r();
+  var a = /* @__PURE__ */ new Set(), o = (_) => {
+    for (var h = 0; h < _.length; h++) {
+      var p = _[h];
+      if (!a.has(p)) {
+        a.add(p);
+        var g = Kl(p);
+        t.addEventListener(p, cn, { passive: g });
+        var x = jt.get(p);
+        x === void 0 ? (document.addEventListener(p, cn, { passive: g }), jt.set(p, 1)) : jt.set(p, x + 1);
+      }
+    }
+  };
+  o(Un(fs)), xr.add(o);
+  var c = void 0, d = Fl(() => {
+    var _ = n ?? t.appendChild($e());
+    return Tl(
+      /** @type {TemplateNode} */
+      _,
+      {
+        pending: () => {
+        }
+      },
+      (h) => {
+        if (s) {
+          Zn({});
+          var p = (
+            /** @type {ComponentContext} */
+            ge
+          );
+          p.c = s;
+        }
+        if (r && (i.$$events = r), O && gt(
+          /** @type {TemplateNode} */
+          h,
+          null
+        ), c = e(h, i) || {}, O && (z.nodes.end = M, M === null || M.nodeType !== rn || /** @type {Comment} */
+        M.data !== Cr))
+          throw Qn(), Jt;
+        s && er();
+      }
+    ), () => {
+      for (var h of a) {
+        t.removeEventListener(h, cn);
+        var p = (
+          /** @type {number} */
+          jt.get(h)
+        );
+        --p === 0 ? (document.removeEventListener(h, cn), jt.delete(h)) : jt.set(h, p);
+      }
+      xr.delete(o), _ !== n && _.parentNode?.removeChild(_);
+    };
+  });
+  return kr.set(c, d), c;
+}
+let kr = /* @__PURE__ */ new WeakMap();
+function Ql(e, t) {
+  const n = kr.get(e);
+  return n ? (kr.delete(e), n(t)) : Promise.resolve();
+}
+var Ce, De, he, Ot, bn, yn, qn;
+class Zl {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, n = !0) {
+    /** @type {TemplateNode} */
+    j(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    T(this, Ce, /* @__PURE__ */ new Map());
+    /**
+     * Map of keys to effects that are currently rendered in the DOM.
+     * These effects are visible and actively part of the document tree.
+     * Example:
+     * ```
+     * {#if condition}
+     * 	foo
+     * {:else}
+     * 	bar
+     * {/if}
+     * ```
+     * Can result in the entries `true->Effect` and `false->Effect`
+     * @type {Map<Key, Effect>}
+     */
+    T(this, De, /* @__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>}
+     */
+    T(this, he, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    T(this, Ot, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    T(this, bn, !0);
+    T(this, yn, () => {
+      var t = (
+        /** @type {Batch} */
+        N
+      );
+      if (u(this, Ce).has(t)) {
+        var n = (
+          /** @type {Key} */
+          u(this, Ce).get(t)
+        ), i = u(this, De).get(n);
+        if (i)
+          Nr(i), u(this, Ot).delete(n);
+        else {
+          var r = u(this, he).get(n);
+          r && (u(this, De).set(n, r.effect), u(this, he).delete(n), r.fragment.lastChild.remove(), this.anchor.before(r.fragment), i = r.effect);
+        }
+        for (const [s, l] of u(this, Ce)) {
+          if (u(this, Ce).delete(s), s === t)
+            break;
+          const a = u(this, he).get(l);
+          a && (re(a.effect), u(this, he).delete(l));
+        }
+        for (const [s, l] of u(this, De)) {
+          if (s === n || u(this, Ot).has(s)) continue;
+          const a = () => {
+            if (Array.from(u(this, Ce).values()).includes(s)) {
+              var c = document.createDocumentFragment();
+              ts(l, c), c.append($e()), u(this, he).set(s, { effect: l, fragment: c });
+            } else
+              re(l);
+            u(this, Ot).delete(s), u(this, De).delete(s);
+          };
+          u(this, bn) || !i ? (u(this, Ot).add(s), Mt(l, a, !1)) : a();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    T(this, qn, (t) => {
+      u(this, Ce).delete(t);
+      const n = Array.from(u(this, Ce).values());
+      for (const [i, r] of u(this, he))
+        n.includes(i) || (re(r.effect), u(this, he).delete(i));
+    });
+    this.anchor = t, E(this, bn, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, n) {
+    var i = (
+      /** @type {Batch} */
+      N
+    ), r = Wi();
+    if (n && !u(this, De).has(t) && !u(this, he).has(t))
+      if (r) {
+        var s = document.createDocumentFragment(), l = $e();
+        s.append(l), u(this, he).set(t, {
+          effect: ye(() => n(l)),
+          fragment: s
+        });
+      } else
+        u(this, De).set(
+          t,
+          ye(() => n(this.anchor))
+        );
+    if (u(this, Ce).set(i, t), r) {
+      for (const [a, o] of u(this, De))
+        a === t ? i.skipped_effects.delete(o) : i.skipped_effects.add(o);
+      for (const [a, o] of u(this, he))
+        a === t ? i.skipped_effects.delete(o.effect) : i.skipped_effects.add(o.effect);
+      i.oncommit(u(this, yn)), i.ondiscard(u(this, qn));
+    } else
+      O && (this.anchor = M), u(this, yn).call(this);
+  }
+}
+Ce = new WeakMap(), De = new WeakMap(), he = new WeakMap(), Ot = new WeakMap(), bn = new WeakMap(), yn = new WeakMap(), qn = new WeakMap();
+function vs(e) {
+  ge === null && ll(), Bt(() => {
+    const t = sr(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function qe(e, t, n = !1) {
+  O && En();
+  var i = new Zl(e), r = n ? Zt : 0;
+  function s(l, a) {
+    if (O) {
+      const c = yi(e) === Yn;
+      if (l === c) {
+        var o = Hn();
+        ue(o), i.anchor = o, et(!1), i.ensure(l, a), et(!0);
+        return;
+      }
+    }
+    i.ensure(l, a);
+  }
+  Lr(() => {
+    var l = !1;
+    t((a, o = !0) => {
+      l = !0, s(o, a);
+    }), l || s(!1, null);
+  }, r);
+}
+function Rn(e, t) {
+  return t;
+}
+function ea(e, t, n) {
+  for (var i = [], r = t.length, s, l = t.length, a = 0; a < r; a++) {
+    let _ = t[a];
+    Mt(
+      _,
+      () => {
+        if (s) {
+          if (s.pending.delete(_), s.done.add(_), s.pending.size === 0) {
+            var h = (
+              /** @type {Set<EachOutroGroup>} */
+              e.outrogroups
+            );
+            Tr(Un(s.done)), h.delete(s), h.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
+      );
+      Gi(d), d.append(c), e.items.clear();
+    }
+    Tr(t, !o);
+  } else
+    s = {
+      pending: new Set(t),
+      done: /* @__PURE__ */ new Set()
+    }, (e.outrogroups ?? (e.outrogroups = /* @__PURE__ */ new Set())).add(s);
+}
+function Tr(e, t = !0) {
+  for (var n = 0; n < e.length; n++)
+    re(e[n], t);
+}
+var ri;
+function yt(e, t, n, i, r, s = null) {
+  var l = e, a = /* @__PURE__ */ new Map(), o = (t & vi) !== 0;
+  if (o) {
+    var c = (
+      /** @type {Element} */
+      e
+    );
+    l = O ? ue(/* @__PURE__ */ st(c)) : c.appendChild($e());
+  }
+  O && En();
+  var d = null, _ = /* @__PURE__ */ Ml(() => {
+    var b = n();
+    return _i(b) ? b : b == null ? [] : Un(b);
+  }), h, p = !0;
+  function g() {
+    v.fallback = d, ta(v, h, l, t, i), d !== null && (h.length === 0 ? (d.f & Ze) === 0 ? Nr(d) : (d.f ^= Ze, dn(d, null, l)) : Mt(d, () => {
+      d = null;
+    }));
+  }
+  var x = Lr(() => {
+    h = /** @type {V[]} */
+    f(_);
+    var b = h.length;
+    let te = !1;
+    if (O) {
+      var se = yi(l) === Yn;
+      se !== (b === 0) && (l = Hn(), ue(l), et(!1), te = !0);
+    }
+    for (var P = /* @__PURE__ */ new Set(), q = (
+      /** @type {Batch} */
+      N
+    ), J = Wi(), F = 0; F < b; F += 1) {
+      O && M.nodeType === rn && /** @type {Comment} */
+      M.data === Cr && (l = /** @type {Comment} */
+      M, te = !0, et(!1));
+      var Te = h[F], Ie = i(Te, F), V = p ? null : a.get(Ie);
+      V ? (V.v && nn(V.v, Te), V.i && nn(V.i, F), J && q.skipped_effects.delete(V.e)) : (V = na(
+        a,
+        p ? l : ri ?? (ri = $e()),
+        Te,
+        Ie,
+        F,
+        r,
+        t,
+        n
+      ), p || (V.e.f |= Ze), a.set(Ie, V)), P.add(Ie);
+    }
+    if (b === 0 && s && !d && (p ? d = ye(() => s(l)) : (d = ye(() => s(ri ?? (ri = $e()))), d.f |= Ze)), O && b > 0 && ue(Hn()), !p)
+      if (J) {
+        for (const [sn, Nt] of a)
+          P.has(sn) || q.skipped_effects.add(Nt.e);
+        q.oncommit(g), q.ondiscard(() => {
+        });
+      } else
+        g();
+    te && et(!0), f(_);
+  }), v = { effect: x, items: a, outrogroups: null, fallback: d };
+  p = !1, O && (l = M);
+}
+function un(e) {
+  for (; e !== null && (e.f & ze) === 0; )
+    e = e.next;
+  return e;
+}
+function ta(e, t, n, i, r) {
+  var s = (i & Ys) !== 0, l = t.length, a = e.items, o = un(e.effect.first), c, d = null, _, h = [], p = [], g, x, v, b;
+  if (s)
+    for (b = 0; b < l; b += 1)
+      g = t[b], x = r(g, b), v = /** @type {EachItem} */
+      a.get(x).e, (v.f & Ze) === 0 && (v.nodes?.a?.measure(), (_ ?? (_ = /* @__PURE__ */ new Set())).add(v));
+  for (b = 0; b < l; b += 1) {
+    if (g = t[b], x = r(g, b), v = /** @type {EachItem} */
+    a.get(x).e, e.outrogroups !== null)
+      for (const V of e.outrogroups)
+        V.pending.delete(v), V.done.delete(v);
+    if ((v.f & Ze) !== 0)
+      if (v.f ^= Ze, v === o)
+        dn(v, null, n);
+      else {
+        var te = d ? d.next : o;
+        v === e.effect.last && (e.effect.last = v.prev), v.prev && (v.prev.next = v.next), v.next && (v.next.prev = v.prev), ht(e, d, v), ht(e, v, te), dn(v, te, n), d = v, h = [], p = [], o = un(d.next);
+        continue;
+      }
+    if ((v.f & _e) !== 0 && (Nr(v), s && (v.nodes?.a?.unfix(), (_ ?? (_ = /* @__PURE__ */ new Set())).delete(v))), v !== o) {
+      if (c !== void 0 && c.has(v)) {
+        if (h.length < p.length) {
+          var se = p[0], P;
+          d = se.prev;
+          var q = h[0], J = h[h.length - 1];
+          for (P = 0; P < h.length; P += 1)
+            dn(h[P], se, n);
+          for (P = 0; P < p.length; P += 1)
+            c.delete(p[P]);
+          ht(e, q.prev, J.next), ht(e, d, q), ht(e, J, se), o = se, d = J, b -= 1, h = [], p = [];
+        } else
+          c.delete(v), dn(v, o, n), ht(e, v.prev, v.next), ht(e, v, d === null ? e.effect.first : d.next), ht(e, d, v), d = v;
+        continue;
+      }
+      for (h = [], p = []; o !== null && o !== v; )
+        (c ?? (c = /* @__PURE__ */ new Set())).add(o), p.push(o), o = un(o.next);
+      if (o === null)
+        continue;
+    }
+    (v.f & Ze) === 0 && h.push(v), d = v, o = un(v.next);
+  }
+  if (e.outrogroups !== null) {
+    for (const V of e.outrogroups)
+      V.pending.size === 0 && (Tr(Un(V.done)), e.outrogroups?.delete(V));
+    e.outrogroups.size === 0 && (e.outrogroups = null);
+  }
+  if (o !== null || c !== void 0) {
+    var F = [];
+    if (c !== void 0)
+      for (v of c)
+        (v.f & _e) === 0 && F.push(v);
+    for (; o !== null; )
+      (o.f & _e) === 0 && o !== e.fallback && F.push(o), o = un(o.next);
+    var Te = F.length;
+    if (Te > 0) {
+      var Ie = (i & vi) !== 0 && l === 0 ? n : null;
+      if (s) {
+        for (b = 0; b < Te; b += 1)
+          F[b].nodes?.a?.measure();
+        for (b = 0; b < Te; b += 1)
+          F[b].nodes?.a?.fix();
+      }
+      ea(e, F, Ie);
+    }
+  }
+  s && Fe(() => {
+    if (_ !== void 0)
+      for (v of _)
+        v.nodes?.a?.apply();
+  });
+}
+function na(e, t, n, i, r, s, l, a) {
+  var o = (l & Ws) !== 0 ? (l & Us) === 0 ? /* @__PURE__ */ Fi(n, !1, !1) : It(n) : null, c = (l & qs) !== 0 ? It(r) : null;
+  return {
+    v: o,
+    i: c,
+    e: ye(() => (s(t, o ?? n, c ?? r, a), () => {
+      e.delete(i);
+    }))
+  };
+}
+function dn(e, t, n) {
+  if (e.nodes)
+    for (var i = e.nodes.start, r = e.nodes.end, s = t && (t.f & Ze) === 0 ? (
+      /** @type {EffectNodes} */
+      t.nodes.start
+    ) : n; i !== null; ) {
+      var l = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ He(i)
+      );
+      if (s.before(i), i === r)
+        return;
+      i = l;
+    }
+}
+function ht(e, t, n) {
+  t === null ? e.effect.first = n : t.next = n, n === null ? e.effect.last = t : n.prev = t;
+}
+function ra(e, t, n, i, r) {
+  O && En();
+  var s = t.$$slots?.[n], l = !1;
+  s === !0 && (s = t.children, l = !0), s === void 0 || s(e, l ? () => i : i);
+}
+function ia(e, t) {
+  Xi(() => {
+    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 ii = [...` 	
+\r\f \v\uFEFF`];
+function sa(e, t, n) {
+  var i = e == null ? "" : "" + 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 || ii.includes(i[l - 1])) && (a === i.length || ii.includes(i[a])) ? i = (l === 0 ? "" : i.substring(0, l)) + i.substring(a + 1) : l = a;
+        }
+  }
+  return i === "" ? null : i;
+}
+function la(e, t) {
+  return e == null ? null : String(e);
+}
+function si(e, t, n, i, r, s) {
+  var l = e.__className;
+  if (O || l !== n || l === void 0) {
+    var a = sa(n, i, s);
+    (!O || a !== e.getAttribute("class")) && (a == null ? e.removeAttribute("class") : t ? e.className = a : e.setAttribute("class", 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 Sr(e, t, n, i) {
+  var r = e.__style;
+  if (O || r !== t) {
+    var s = la(t);
+    (!O || s !== e.getAttribute("style")) && (s == null ? e.removeAttribute("style") : e.style.cssText = s), e.__style = t;
+  }
+  return i;
+}
+const aa = /* @__PURE__ */ Symbol("is custom element"), oa = /* @__PURE__ */ Symbol("is html");
+function li(e) {
+  if (O) {
+    var t = !1, n = () => {
+      if (!t) {
+        if (t = !0, e.hasAttribute("value")) {
+          var i = e.value;
+          R(e, "value", null), e.value = i;
+        }
+        if (e.hasAttribute("checked")) {
+          var r = e.checked;
+          R(e, "checked", null), e.checked = r;
+        }
+      }
+    };
+    e.__on_r = n, Fe(n), qi();
+  }
+}
+function R(e, t, n, i) {
+  var r = fa(e);
+  O && (r[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === "LINK") || r[t] !== (r[t] = n) && (t === "loading" && (e[sl] = n), n == null ? e.removeAttribute(t) : typeof n != "string" && ua(e).includes(t) ? e[t] = n : e.setAttribute(t, n));
+}
+function fa(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [aa]: e.nodeName.includes("-"),
+      [oa]: e.namespaceURI === Js
+    })
+  );
+}
+var ai = /* @__PURE__ */ new Map();
+function ua(e) {
+  var t = e.getAttribute("is") || e.nodeName, n = ai.get(t);
+  if (n) return n;
+  ai.set(t, n = []);
+  for (var i, r = e, s = Element.prototype; s !== r; ) {
+    i = Zs(r);
+    for (var l in i)
+      i[l].set && n.push(l);
+    r = gi(r);
+  }
+  return n;
+}
+function oi(e, t, n = t) {
+  var i = /* @__PURE__ */ new WeakSet();
+  Ll(e, "input", async (r) => {
+    var s = r ? e.defaultValue : e.value;
+    if (s = cr(e) ? dr(s) : s, n(s), N !== null && i.add(N), await Wl(), s !== (s = t())) {
+      var l = e.selectionStart, a = e.selectionEnd, o = e.value.length;
+      if (e.value = s ?? "", a !== null) {
+        var c = e.value.length;
+        l === a && a === o && c > o ? (e.selectionStart = c, e.selectionEnd = c) : (e.selectionStart = l, e.selectionEnd = Math.min(a, c));
+      }
+    }
+  }), // If we are hydrating and the value has since changed,
+  // then use the updated value from the input instead.
+  (O && e.defaultValue !== e.value || // If defaultValue is set, then value == defaultValue
+  // TODO Svelte 6: remove input.value check and set to empty string?
+  sr(t) == null && e.value) && (n(cr(e) ? dr(e.value) : e.value), N !== null && i.add(N)), ir(() => {
+    var r = t();
+    if (e === document.activeElement) {
+      var s = (
+        /** @type {Batch} */
+        pr ?? N
+      );
+      if (i.has(s))
+        return;
+    }
+    cr(e) && r === dr(e.value) || e.type === "date" && !r && !e.value || r !== e.value && (e.value = r ?? "");
+  });
+}
+function cr(e) {
+  var t = e.type;
+  return t === "number" || t === "range";
+}
+function dr(e) {
+  return e === "" ? null : +e;
+}
+function fi(e, t) {
+  return e === t || e?.[In] === t;
+}
+function pn(e = {}, t, n, i) {
+  return Xi(() => {
+    var r, s;
+    return ir(() => {
+      r = s, s = [], sr(() => {
+        e !== n(...s) && (t(e, ...s), r && fi(n(...r), e) && t(null, ...r));
+      });
+    }), () => {
+      Fe(() => {
+        s && fi(n(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+function Me(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 h = (
+      /** @type {V} */
+      e[t]
+    );
+    return h === void 0 ? l() : (s = !0, h);
+  };
+  var c = !1, d = /* @__PURE__ */ nr(() => (c = !1, o())), _ = (
+    /** @type {Effect} */
+    z
+  );
+  return (
+    /** @type {() => V} */
+    (function(h, p) {
+      if (arguments.length > 0) {
+        const g = p ? f(d) : h;
+        return w(d, g), c = !0, r !== void 0 && (r = g), h;
+      }
+      return mt && c || (_.f & nt) !== 0 ? d.v : f(d);
+    })
+  );
+}
+function ca(e) {
+  return new da(e);
+}
+var Qe, be;
+class da {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    T(this, Qe);
+    /** @type {Record<string, any>} */
+    T(this, be);
+    var n = /* @__PURE__ */ new Map(), i = (s, l) => {
+      var a = /* @__PURE__ */ Fi(l, !1, !1);
+      return n.set(s, a), a;
+    };
+    const r = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return f(n.get(l) ?? i(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === il ? !0 : (f(n.get(l) ?? i(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, a) {
+          return w(n.get(l) ?? i(l, a), a), Reflect.set(s, l, a);
+        }
+      }
+    );
+    E(this, be, (t.hydrate ? Jl : ds)(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) && pe(), E(this, Qe, r.$$events);
+    for (const s of Object.keys(u(this, be)))
+      s === "$set" || s === "$destroy" || s === "$on" || jn(this, s, {
+        get() {
+          return u(this, be)[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          u(this, be)[s] = l;
+        },
+        enumerable: !0
+      });
+    u(this, be).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(r, s);
+    }, u(this, be).$destroy = () => {
+      Ql(u(this, be));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    u(this, be).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, n) {
+    u(this, Qe)[t] = u(this, Qe)[t] || [];
+    const i = (...r) => n.call(this, ...r);
+    return u(this, Qe)[t].push(i), () => {
+      u(this, Qe)[t] = u(this, Qe)[t].filter(
+        /** @param {any} fn */
+        (r) => r !== i
+      );
+    };
+  }
+  $destroy() {
+    u(this, be).$destroy();
+  }
+}
+Qe = new WeakMap(), be = new WeakMap();
+let ps;
+typeof HTMLElement == "function" && (ps = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(t, n, i) {
+    super();
+    /** The Svelte component constructor */
+    j(this, "$$ctor");
+    /** Slots */
+    j(this, "$$s");
+    /** @type {any} The Svelte component instance */
+    j(this, "$$c");
+    /** Whether or not the custom element is connected */
+    j(this, "$$cn", !1);
+    /** @type {Record<string, any>} Component props data */
+    j(this, "$$d", {});
+    /** `true` if currently in the process of reflecting component props back to attributes */
+    j(this, "$$r", !1);
+    /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+    j(this, "$$p_d", {});
+    /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+    j(this, "$$l", {});
+    /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+    j(this, "$$l_u", /* @__PURE__ */ new Map());
+    /** @type {any} The managed render effect for reflecting attributes */
+    j(this, "$$me");
+    /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+    j(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), D(s, l);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const n = {}, i = ha(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] = Dn(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 = ca({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: n,
+          $$host: this
+        }
+      }), this.$$me = Dl(() => {
+        ir(() => {
+          this.$$r = !0;
+          for (const r of Fn(this.$$c)) {
+            if (!this.$$p_d[r]?.reflect) continue;
+            this.$$d[r] = this.$$c[r];
+            const s = Dn(
+              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] = Dn(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 Fn(this.$$p_d).find(
+      (n) => this.$$p_d[n].attribute === t || !this.$$p_d[n].attribute && n.toLowerCase() === t
+    ) || t;
+  }
+});
+function Dn(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 ha(e) {
+  const t = {};
+  return e.childNodes.forEach((n) => {
+    t[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), t;
+}
+function Dr(e, t, n, i, r, s) {
+  let l = class extends ps {
+    constructor() {
+      super(e, n, r), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Fn(t).map(
+        (a) => (t[a].attribute || a).toLowerCase()
+      );
+    }
+  };
+  return Fn(t).forEach((a) => {
+    jn(l.prototype, a, {
+      get() {
+        return this.$$c && a in this.$$c ? this.$$c[a] : this.$$d[a];
+      },
+      set(o) {
+        o = Dn(a, o, t), this.$$d[a] = o;
+        var c = this.$$c;
+        if (c) {
+          var d = Ht(c, a)?.get;
+          d ? c[a] = o : c.$set({ [a]: o });
+        }
+      }
+    });
+  }), i.forEach((a) => {
+    jn(l.prototype, a, {
+      get() {
+        return this.$$c?.[a];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+var ui;
+(function(e) {
+  e.TTS_WORD = "tts-word", e.TTS_SENTENCE = "tts-sentence", e.ANNOTATION = "annotation";
+})(ui || (ui = {}));
+var ci;
+(function(e) {
+  e.YELLOW = "yellow", e.GREEN = "green", e.BLUE = "blue", e.PINK = "pink", e.ORANGE = "orange";
+})(ci || (ci = {}));
+const va = {
+  // 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(va).map(([e, t]) => [t, e]));
+var Gn;
+(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";
+})(Gn || (Gn = {}));
+var di;
+(function(e) {
+  e.IDLE = "idle", e.LOADING = "loading", e.PLAYING = "playing", e.PAUSED = "paused", e.ERROR = "error";
+})(di || (di = {}));
+var pa = /* @__PURE__ */ xn('<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 _s(e, t) {
+  Zn(t, !0);
+  let n = Me(t, "buttonEl", 7, null), i = Me(t, "onClick"), r = Me(t, "ariaLabel", 7, "Settings"), s = Me(t, "active", 7, !1);
+  var l = {
+    get buttonEl() {
+      return n();
+    },
+    set buttonEl(o = null) {
+      n(o), pe();
+    },
+    get onClick() {
+      return i();
+    },
+    set onClick(o) {
+      i(o), pe();
+    },
+    get ariaLabel() {
+      return r();
+    },
+    set ariaLabel(o = "Settings") {
+      r(o), pe();
+    },
+    get active() {
+      return s();
+    },
+    set active(o = !1) {
+      s(o), pe();
+    }
+  }, a = pa();
+  return a.__click = function(...o) {
+    i()?.apply(this, o);
+  }, pn(a, (o) => n(o), () => n()), Se(() => {
+    R(a, "aria-label", r()), R(a, "aria-pressed", s());
+  }), D(e, a), er(l);
+}
+Pr(["click"]);
+Dr(_s, { buttonEl: {}, onClick: {}, ariaLabel: {}, active: {} }, [], [], { mode: "open" });
+var _a = /* @__PURE__ */ xn('<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 gs(e, t) {
+  Zn(t, !0);
+  let n = Me(t, "open"), i = Me(t, "title", 7, "Settings"), r = Me(t, "onClose"), s = Me(t, "anchorEl", 7, null), l = /* @__PURE__ */ I(null), a = /* @__PURE__ */ I(null);
+  function o(p) {
+    p.key === "Escape" && r()();
+  }
+  Bt(() => {
+    n() && queueMicrotask(() => f(l)?.focus?.());
+  }), Bt(() => {
+    if (n() && s()) {
+      const p = s().getBoundingClientRect(), g = 320, x = 8, v = p.right + x;
+      v + g <= window.innerWidth ? w(a, { top: p.top, left: v }, !0) : w(
+        a,
+        {
+          top: p.top,
+          right: window.innerWidth - p.left + x
+        },
+        !0
+      );
+    } else
+      w(a, null);
+  }), vs(() => {
+    const p = (g) => {
+      if (!n()) return;
+      const x = g.target;
+      x && (f(l)?.contains(x) || s()?.contains(x) || r()());
+    };
+    return document.addEventListener("mousedown", p), () => document.removeEventListener("mousedown", p);
+  });
+  var c = {
+    get open() {
+      return n();
+    },
+    set open(p) {
+      n(p), pe();
+    },
+    get title() {
+      return i();
+    },
+    set title(p = "Settings") {
+      i(p), pe();
+    },
+    get onClose() {
+      return r();
+    },
+    set onClose(p) {
+      r(p), pe();
+    },
+    get anchorEl() {
+      return s();
+    },
+    set anchorEl(p = null) {
+      s(p), pe();
+    }
+  }, d = Et(), _ = Ue(d);
+  {
+    var h = (p) => {
+      var g = _a(), x = Ue(g);
+      x.__mousedown = function(...F) {
+        r()?.apply(this, F);
+      };
+      var v = X(x, 2);
+      v.__keydown = o;
+      var b = Z(v), te = Z(b), se = Z(te, !0);
+      H(te);
+      var P = X(te, 2);
+      P.__click = function(...F) {
+        r()?.apply(this, F);
+      }, H(b);
+      var q = X(b, 2), J = Z(q);
+      ra(J, t, "default", {}), H(q), H(v), pn(v, (F) => w(l, F), () => f(l)), Se(() => {
+        R(v, "aria-label", i()), Sr(v, `z-index: 4100; ${f(a) ? `top: ${f(a).top}px; ${f(a).left !== void 0 ? `left: ${f(a).left}px;` : `right: ${f(a).right}px;`}` : "top: 4rem; right: 1rem;"}`), cs(se, i());
+      }), D(p, g);
+    };
+    qe(_, (p) => {
+      n() && p(h);
+    });
+  }
+  return D(e, d), er(c);
+}
+Pr(["mousedown", "keydown", "click"]);
+Dr(gs, { open: {}, title: {}, onClose: {}, anchorEl: {} }, ["default"], [], { mode: "open" });
+var ga = /* @__PURE__ */ Re('<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z"></path></svg>'), ma = /* @__PURE__ */ Re('<svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></svg>'), wa = /* @__PURE__ */ Re('<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"></path></svg>'), ba = /* @__PURE__ */ Re('<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path></svg>'), ya = /* @__PURE__ */ xn('<button type="button"><span class="tool-icon svelte-7afz7f" aria-hidden="true"><!></span> <span class="tool-label svelte-7afz7f"> </span></button>'), Ea = /* @__PURE__ */ Re('<line x1="0" class="grid-line grid-line-minor svelte-7afz7f"></line>'), $a = /* @__PURE__ */ Re('<line x1="0" class="grid-line grid-line-major svelte-7afz7f"></line>'), xa = /* @__PURE__ */ Re('<line y1="0" y2="100" class="grid-line grid-line-minor svelte-7afz7f"></line>'), ka = /* @__PURE__ */ Re('<line y1="0" y2="100" class="grid-line grid-line-major svelte-7afz7f"></line>'), Ta = /* @__PURE__ */ Re('<line class="user-line svelte-7afz7f"></line>'), Sa = /* @__PURE__ */ Re('<circle r="2"></circle>'), Ca = /* @__PURE__ */ Re('<line class="temp-line svelte-7afz7f"></line>'), Aa = /* @__PURE__ */ xn('<fieldset class="setting-group svelte-7afz7f"><legend class="svelte-7afz7f">Canvas</legend> <label><span class="setting-label svelte-7afz7f">Grid Opacity</span> <input type="range" min="0" max="1" step="0.1" aria-label="Grid opacity"/></label></fieldset>'), Oa = /* @__PURE__ */ xn('<div class="graph-tool-container svelte-7afz7f" role="dialog" tabindex="-1" aria-label="Graph Tool - Draw points and lines on a coordinate grid"><div class="graph-header svelte-7afz7f"><h3 id="graph-tool-title" class="graph-title svelte-7afz7f">Graph Tool</h3> <div class="header-controls svelte-7afz7f"><!></div></div> <div class="graph-toolbar svelte-7afz7f"><div class="tool-buttons svelte-7afz7f"></div> <div class="transparency-control svelte-7afz7f"><label for="grid-opacity" class="svelte-7afz7f">Grid:</label> <input type="range" id="grid-opacity" min="0" max="1" step="0.1" aria-label="Grid opacity" class="svelte-7afz7f"/></div></div>  <div class="graph-canvas-wrapper svelte-7afz7f" role="img" tabindex="0" aria-label="Graph canvas - Use tools to add points and draw lines"><svg class="graph-canvas svelte-7afz7f" preserveAspectRatio="xMinYMin meet" aria-hidden="true"><g class="grid-lines" aria-hidden="true"><!><!><!><!></g><g class="lines"></g><g class="points"></g><!></svg></div></div> <!>', 1);
+const Ma = {
+  hash: "svelte-7afz7f",
+  code: `.graph-tool-container.svelte-7afz7f {position:fixed;background:white;box-shadow:0 10px 40px rgba(0, 0, 0, 0.3);user-select:none;touch-action:none;border-radius:12px;overflow:hidden;z-index:2000; /* ZIndexLayer.MODAL */min-width:500px;display:flex;flex-direction:column;}
+
+	/* Header (matching production implementation: dark teal) */.graph-header.svelte-7afz7f {padding:12px 16px;background:var(--pie-primary-dark, #2c3e50); /* Dark teal-like color */color:var(--pie-white, white);display:flex;justify-content:space-between;align-items:center;cursor:move;user-select:none;border-radius:12px 12px 0 0;}.graph-title.svelte-7afz7f {font-weight:600;font-size:16px;color:var(--pie-white, white);margin:0;}.header-controls.svelte-7afz7f {display:flex;gap:8px;align-items:center;}
+
+	/* Toolbar (matching production implementation: lighter teal) */.graph-toolbar.svelte-7afz7f {padding:8px;background:var(--pie-primary-light, #5a7fa3); /* Lighter teal-like color */display:flex;gap:16px;align-items:center;flex-wrap:wrap;}.tool-buttons.svelte-7afz7f {display:flex;gap:4px;flex:1;}.tool-button.svelte-7afz7f {flex:1;display:flex;flex-direction:column;align-items:center;gap:4px;padding:8px 12px;background:rgba(255, 255, 255, 0.2);border:2px solid transparent;border-radius:4px;cursor:pointer;color:white;font-size:12px;transition:all 0.2s;}.tool-button.svelte-7afz7f:hover {background:rgba(255, 255, 255, 0.3);}.tool-button.active.svelte-7afz7f {background:white;color:var(--pie-primary-dark, #2c3e50);border-color:var(--pie-primary-dark, #2c3e50);}.tool-icon.svelte-7afz7f {width:20px;height:20px;display:flex;align-items:center;justify-content:center;}.tool-label.svelte-7afz7f {font-size:11px;font-weight:500;}.transparency-control.svelte-7afz7f {display:flex;align-items:center;gap:8px;color:white;font-size:12px;padding-left:8px;}.transparency-control.svelte-7afz7f label:where(.svelte-7afz7f) {font-weight:500;}.transparency-control.svelte-7afz7f input[type='range']:where(.svelte-7afz7f) {width:100px;cursor:pointer;}
+
+	/* Canvas wrapper */.graph-canvas-wrapper.svelte-7afz7f {flex:1;background:white;display:flex;align-items:center;justify-content:center;overflow:hidden;}.graph-canvas.svelte-7afz7f {display:block;width:100%;height:100%;}
+
+	/* Grid lines (matching production implementation: dark gray) */.grid-line.svelte-7afz7f {stroke:var(--pie-primary-console, #666);vector-effect:non-scaling-stroke;}.grid-line-major.svelte-7afz7f {stroke:var(--pie-primary-dark-console, #333);stroke-width:0.75;}.grid-line-minor.svelte-7afz7f {stroke:var(--pie-primary-light-console, #ccc);stroke-width:0.5;}
+
+	/* User drawing styles */.user-point.svelte-7afz7f {cursor:pointer;fill:var(--pie-primary, #3f51b5);stroke:var(--pie-primary-dark, #2c3e50);stroke-width:0.5;vector-effect:non-scaling-stroke;}.user-point.highlight.svelte-7afz7f {fill:var(--pie-warning, #ffc107);stroke:var(--pie-warning-dark, #ff9800);}.user-line.svelte-7afz7f {stroke:var(--pie-dark-gray, #333);stroke-linecap:round;stroke-width:1;vector-effect:non-scaling-stroke;}.temp-line.svelte-7afz7f {pointer-events:none;stroke:var(--pie-success, #4caf50);stroke-dasharray:2, 2;stroke-width:0.75;vector-effect:non-scaling-stroke;}.setting-group.svelte-7afz7f {border:1px solid var(--pie-border, #ccc);border-radius:4px;padding:12px;margin-bottom:16px;}.setting-group.svelte-7afz7f legend:where(.svelte-7afz7f) {font-weight:600;padding:0 8px;}.setting-label.svelte-7afz7f {display:block;margin-bottom:8px;font-weight:500;}`
+};
+function za(e, t) {
+  Zn(t, !0), ia(e, Ma);
+  let n = Me(t, "visible", 7, !1), i = Me(t, "toolId", 7, "graph"), r = Me(t, "coordinator");
+  const s = typeof window < "u";
+  let l = /* @__PURE__ */ I(void 0), a = /* @__PURE__ */ I(void 0), o = /* @__PURE__ */ I(void 0), c = /* @__PURE__ */ I(void 0), d = /* @__PURE__ */ I(!1), _ = /* @__PURE__ */ I(tt(s ? window.innerWidth / 2 : 400)), h = /* @__PURE__ */ I(tt(s ? window.innerHeight / 2 : 300)), p = /* @__PURE__ */ I(700), g = /* @__PURE__ */ I(
+    550
+    // Production implementation uses 550px height
+  ), x = /* @__PURE__ */ I("selector"), v = /* @__PURE__ */ I(tt([])), b = /* @__PURE__ */ I(tt([])), te = /* @__PURE__ */ I(1), se = /* @__PURE__ */ I(1), P = /* @__PURE__ */ I(null), q = /* @__PURE__ */ I(null), J = /* @__PURE__ */ I(null), F = /* @__PURE__ */ I(!1);
+  const Te = 5, Ie = 5, V = 100 / Te, sn = V / Ie;
+  let Nt = /* @__PURE__ */ I(0), kn = /* @__PURE__ */ I(0), ln = /* @__PURE__ */ fn(() => {
+    if (f(kn) <= 0 || f(Nt) <= 0)
+      return 100;
+    const m = f(
+      kn
+      // (viewBox height is 100)
+    ) / 100, k = f(Nt) / m;
+    return Math.max(100, k);
+  });
+  const ms = [
+    {
+      name: "selector",
+      icon: "selector",
+      label: "Selector",
+      title: "Selector: Click and drag points to move them or associated lines."
+    },
+    {
+      name: "point",
+      icon: "point",
+      label: "Point",
+      title: "Point: Click on the grid to add points."
+    },
+    {
+      name: "line",
+      icon: "line",
+      label: "Line",
+      title: "Line: Click a starting point, then an ending point to draw a line."
+    },
+    {
+      name: "delete",
+      icon: "delete",
+      label: "Delete",
+      title: "Delete: Click on a point to delete it and any connected lines."
+    }
+  ];
+  function lr() {
+    return Il(te);
+  }
+  function Tn(m) {
+    if (m !== null)
+      return f(v).find((k) => k.id === m);
+  }
+  function jr(m) {
+    if (!f(o)) return null;
+    const k = f(o).createSVGPoint();
+    k.x = m.clientX, k.y = m.clientY;
+    const L = f(o).getScreenCTM();
+    if (!L) return null;
+    try {
+      const S = k.matrixTransform(L.inverse());
+      return S.y = Math.max(0, Math.min(100, S.y)), S.x = Math.max(0, Math.min(f(ln), S.x)), { x: S.x, y: S.y };
+    } catch (S) {
+      return console.error("Error transforming point:", S), null;
+    }
+  }
+  function Vr(m, k = 5) {
+    const L = k * k;
+    let S = null, G = 1 / 0;
+    for (const Y of f(v)) {
+      const le = Y.x - m.x, ft = Y.y - m.y, ut = le * le + ft * ft;
+      ut < G && ut < L && (G = ut, S = Y);
+    }
+    return S;
+  }
+  function ws(m) {
+    return m === f(P) || m === f(q);
+  }
+  let Sn = /* @__PURE__ */ fn(() => {
+    const m = {
+      majorVertical: [],
+      majorHorizontal: [],
+      minorVertical: [],
+      minorHorizontal: []
+    }, k = f(ln);
+    for (let S = 0; S <= Te; S++) {
+      const G = S * V;
+      if (m.majorHorizontal.push(G), S < Te)
+        for (let Y = 1; Y < Ie; Y++)
+          m.minorHorizontal.push(G + Y * sn);
+    }
+    let L = 0;
+    for (; L <= k; ) {
+      if (m.majorVertical.push(L), L < k)
+        for (let S = 1; S < Ie; S++) {
+          const G = L + S * sn;
+          if (G <= k)
+            m.minorVertical.push(G);
+          else
+            break;
+        }
+      L += V;
+    }
+    return m;
+  });
+  function bs(m) {
+    w(x, m, !0), w(P, null), w(q, null), w(J, null);
+  }
+  function Hr(m) {
+    const k = jr(m);
+    if (!k) return;
+    const L = Vr(k, sn);
+    switch (f(x)) {
+      case "point":
+        w(
+          v,
+          [
+            ...f(v),
+            { id: lr(), x: k.x, y: k.y }
+          ],
+          !0
+        );
+        break;
+      case "line":
+        const S = L ?? { id: lr(), x: k.x, y: k.y };
+        L || w(v, [...f(
+          v
+          // Add if it's a new location
+        ), S], !0), f(P) === null ? w(P, S.id, !0) : (f(P) !== S.id && (f(b).some((le) => le.p1Id === f(P) && le.p2Id === S.id || le.p1Id === S.id && le.p2Id === f(P)) || w(
+          b,
+          [
+            ...f(b),
+            {
+              id: lr(),
+              p1Id: f(P),
+              p2Id: S.id
+            }
+          ],
+          !0
+        )), w(P, null), w(J, null));
+        break;
+      case "delete":
+        const G = Vr(k, 2);
+        G && (w(v, f(v).filter((Y) => Y.id !== G.id), !0), w(b, f(b).filter((Y) => Y.p1Id !== G.id && Y.p2Id !== G.id), !0));
+        break;
+      case "selector":
+        w(
+          P,
+          null
+          // Cancel line drawing if clicking away
+        ), w(J, null);
+        break;
+    }
+  }
+  function ys(m, k) {
+    f(x) === "selector" && (w(q, m, !0), k.target.setPointerCapture(k.pointerId));
+  }
+  function Es(m) {
+    const k = jr(m);
+    if (k && (w(
+      J,
+      k,
+      // Update for temp line drawing
+      !0
+    ), f(q) !== null && f(x) === "selector")) {
+      const L = Tn(f(q));
+      L && (L.x = k.x, L.y = k.y, w(
+        v,
+        // Trigger reactivity
+        f(v),
+        !0
+      ));
+    }
+  }
+  function Br(m) {
+    f(q) !== null && (m.target?.hasPointerCapture(m.pointerId) && m.target.releasePointerCapture(m.pointerId), w(q, null)), (f(x) !== "line" || f(P) === null) && w(J, null);
+  }
+  function $s() {
+    w(d, !f(d));
+  }
+  function xs() {
+    w(d, !1);
+  }
+  function ks(m) {
+    const k = m.target;
+    if (k.closest(".graph-header") && !k.closest(".tool-settings-button") && f(l)) {
+      let G = function(le) {
+        let ft = le.clientX - L, ut = le.clientY - S;
+        const an = (f(l)?.offsetWidth || f(p)) / 2, ct = (f(l)?.offsetHeight || f(g)) / 2;
+        w(_, Math.max(an, Math.min(ft, window.innerWidth - an)), !0), w(h, Math.max(ct, Math.min(ut, window.innerHeight - ct)), !0);
+      }, Y = function() {
+        f(l) && f(l).releasePointerCapture(m.pointerId), f(l)?.removeEventListener("pointermove", G), f(l)?.removeEventListener("pointerup", Y);
+      };
+      f(l).setPointerCapture(m.pointerId);
+      const L = m.clientX - f(_), S = m.clientY - f(h);
+      f(l).addEventListener("pointermove", G), f(l).addEventListener("pointerup", Y), r()?.bringToFront(f(l));
+    }
+  }
+  let ot = null;
+  Bt(() => {
+    if (f(a))
+      return ot || (ot = new ResizeObserver((m) => {
+        const k = m[0], { width: L, height: S } = k.contentRect;
+        (Math.abs(f(Nt) - L) > 0.1 || Math.abs(f(kn) - S) > 0.1) && (w(Nt, L, !0), w(kn, S, !0));
+      })), ot.observe(f(a)), () => {
+        ot && ot.disconnect();
+      };
+  }), Bt(() => {
+    r() && i() && !f(F) && (f(l) ? r().registerTool(i(), "Graph Tool", f(l), Gn.MODAL) : r().registerTool(i(), "Graph Tool", void 0, Gn.MODAL), w(F, !0));
+  }), Bt(() => {
+    r() && f(l) && i() && (r().updateToolElement(i(), f(l)), r().bringToFront(f(l)));
+  }), vs(() => () => {
+    ot && (ot.disconnect(), ot = null), r() && i() && r().unregisterTool(i());
+  });
+  var Ts = {
+    get visible() {
+      return n();
+    },
+    set visible(m = !1) {
+      n(m), pe();
+    },
+    get toolId() {
+      return i();
+    },
+    set toolId(m = "graph") {
+      i(m), pe();
+    },
+    get coordinator() {
+      return r();
+    },
+    set coordinator(m) {
+      r(m), pe();
+    }
+  }, Gr = Et(), Ss = Ue(Gr);
+  {
+    var Cs = (m) => {
+      var k = Oa(), L = Ue(k);
+      L.__pointerdown = ks;
+      var S = Z(L), G = X(Z(S), 2), Y = Z(G);
+      _s(Y, {
+        onClick: $s,
+        ariaLabel: "Graph tool settings",
+        get active() {
+          return f(d);
+        },
+        get buttonEl() {
+          return f(c);
+        },
+        set buttonEl($) {
+          w(c, $, !0);
+        }
+      }), H(G), H(S);
+      var le = X(S, 2), ft = Z(le);
+      yt(ft, 21, () => ms, ($) => $.name, ($, C) => {
+        var y = ya();
+        let ae;
+        y.__click = () => bs(f(C).name);
+        var ne = Z(y), Ge = Z(ne);
+        {
+          var We = (Pt) => {
+            var An = ga();
+            D(Pt, An);
+          }, on = (Pt) => {
+            var An = Et(), Is = Ue(An);
+            {
+              var Ls = (Dt) => {
+                var On = ma();
+                D(Dt, On);
+              }, Ns = (Dt) => {
+                var On = Et(), Ps = Ue(On);
+                {
+                  var Ds = (Ft) => {
+                    var Mn = wa();
+                    D(Ft, Mn);
+                  }, Fs = (Ft) => {
+                    var Mn = Et(), js = Ue(Mn);
+                    {
+                      var Vs = (fr) => {
+                        var Hs = ba();
+                        D(fr, Hs);
+                      };
+                      qe(
+                        js,
+                        (fr) => {
+                          f(C).name === "delete" && fr(Vs);
+                        },
+                        !0
+                      );
+                    }
+                    D(Ft, Mn);
+                  };
+                  qe(
+                    Ps,
+                    (Ft) => {
+                      f(C).name === "line" ? Ft(Ds) : Ft(Fs, !1);
+                    },
+                    !0
+                  );
+                }
+                D(Dt, On);
+              };
+              qe(
+                Is,
+                (Dt) => {
+                  f(C).name === "point" ? Dt(Ls) : Dt(Ns, !1);
+                },
+                !0
+              );
+            }
+            D(Pt, An);
+          };
+          qe(Ge, (Pt) => {
+            f(C).name === "selector" ? Pt(We) : Pt(on, !1);
+          });
+        }
+        H(ne);
+        var dt = X(ne, 2), Rs = Z(dt, !0);
+        H(dt), H(y), Se(() => {
+          ae = si(y, 1, "tool-button svelte-7afz7f", null, ae, { active: f(x) === f(C).name }), R(y, "title", f(C).title), R(y, "aria-label", f(C).title), R(y, "aria-pressed", f(x) === f(C).name), cs(Rs, f(C).label);
+        }), D($, y);
+      }), H(ft);
+      var ut = X(ft, 2), an = X(Z(ut), 2);
+      li(an), H(ut), H(le);
+      var ct = X(le, 2);
+      ct.__click = Hr, ct.__keydown = ($) => {
+        ($.key === "Enter" || $.key === " ") && ($.preventDefault(), Hr($));
+      };
+      var bt = Z(ct);
+      bt.__pointermove = Es, bt.__pointerup = Br;
+      var Cn = Z(bt), Wr = Z(Cn);
+      yt(Wr, 17, () => f(Sn).minorHorizontal, Rn, ($, C) => {
+        var y = Ea();
+        Se(() => {
+          R(y, "y1", f(C)), R(y, "x2", f(ln)), R(y, "y2", f(C));
+        }), D($, y);
+      });
+      var qr = X(Wr);
+      yt(qr, 17, () => f(Sn).majorHorizontal, Rn, ($, C) => {
+        var y = $a();
+        Se(() => {
+          R(y, "y1", f(C)), R(y, "x2", f(ln)), R(y, "y2", f(C));
+        }), D($, y);
+      });
+      var Yr = X(qr);
+      yt(Yr, 17, () => f(Sn).minorVertical, Rn, ($, C) => {
+        var y = xa();
+        Se(() => {
+          R(y, "x1", f(C)), R(y, "x2", f(C));
+        }), D($, y);
+      });
+      var As = X(Yr);
+      yt(As, 17, () => f(Sn).majorVertical, Rn, ($, C) => {
+        var y = ka();
+        Se(() => {
+          R(y, "x1", f(C)), R(y, "x2", f(C));
+        }), D($, y);
+      }), H(Cn);
+      var ar = X(Cn);
+      yt(ar, 21, () => f(b), ($) => $.id, ($, C) => {
+        const y = /* @__PURE__ */ fn(() => Tn(f(C).p1Id)), ae = /* @__PURE__ */ fn(() => Tn(f(C).p2Id));
+        var ne = Et(), Ge = Ue(ne);
+        {
+          var We = (on) => {
+            var dt = Ta();
+            Se(() => {
+              R(dt, "x1", f(y).x), R(dt, "y1", f(y).y), R(dt, "x2", f(ae).x), R(dt, "y2", f(ae).y);
+            }), D(on, dt);
+          };
+          qe(Ge, (on) => {
+            f(y) && f(ae) && on(We);
+          });
+        }
+        D($, ne);
+      }), H(ar);
+      var or = X(ar);
+      yt(or, 21, () => f(v), ($) => $.id, ($, C) => {
+        var y = Sa();
+        let ae;
+        y.__pointerdown = (ne) => {
+          ne.stopPropagation(), ys(f(C).id, ne);
+        }, Se(
+          (ne) => {
+            R(y, "cx", f(C).x), R(y, "cy", f(C).y), ae = si(y, 0, "user-point svelte-7afz7f", null, ae, ne), R(y, "data-id", f(C).id);
+          },
+          [() => ({ highlight: ws(f(C).id) })]
+        ), D($, y);
+      }), H(or);
+      var Os = X(or);
+      {
+        var Ms = ($) => {
+          const C = /* @__PURE__ */ fn(() => Tn(f(P)));
+          var y = Et(), ae = Ue(y);
+          {
+            var ne = (Ge) => {
+              var We = Ca();
+              Se(() => {
+                R(We, "x1", f(C).x), R(We, "y1", f(C).y), R(We, "x2", f(J).x), R(We, "y2", f(J).y);
+              }), D(Ge, We);
+            };
+            qe(ae, (Ge) => {
+              f(C) && Ge(ne);
+            });
+          }
+          D($, y);
+        };
+        qe(Os, ($) => {
+          f(P) && f(J) && $(Ms);
+        });
+      }
+      H(bt), pn(bt, ($) => w(o, $), () => f(o)), H(ct), pn(ct, ($) => w(a, $), () => f(a)), H(L), pn(L, ($) => w(l, $), () => f(l));
+      var zs = X(L, 2);
+      gs(zs, {
+        get open() {
+          return f(d);
+        },
+        title: "Graph Tool Settings",
+        onClose: xs,
+        get anchorEl() {
+          return f(c);
+        },
+        children: ($, C) => {
+          var y = Aa(), ae = X(Z(y), 2), ne = X(Z(ae), 2);
+          li(ne), H(ae), H(y), oi(ne, () => f(se), (Ge) => w(se, Ge)), D($, y);
+        },
+        $$slots: { default: !0 }
+      }), Se(() => {
+        Sr(L, `left: ${f(_) ?? ""}px; top: ${f(h) ?? ""}px; width: ${f(p) ?? ""}px; height: ${f(g) ?? ""}px; transform: translate(-50%, -50%);`), R(bt, "viewBox", `0 0 ${f(ln) ?? ""} 100`), Sr(Cn, `opacity: ${f(se) ?? ""}`);
+      }), oi(an, () => f(se), ($) => w(se, $)), Yl("pointerleave", bt, Br), D(m, k);
+    };
+    qe(Ss, (m) => {
+      n() && m(Cs);
+    });
+  }
+  return D(e, Gr), er(Ts);
+}
+Pr([
+  "pointerdown",
+  "click",
+  "keydown",
+  "pointermove",
+  "pointerup"
+]);
+customElements.define("pie-tool-graph", Dr(
+  za,
+  {
+    visible: { attribute: "visible", type: "Boolean" },
+    toolId: { attribute: "tool-id", type: "String" },
+    coordinator: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  za as default
+};
+//# sourceMappingURL=tool-graph.js.map