@pie-players/pie-tool-answer-eliminator 0.2.0

package/dist/tool-answer-eliminator.js

@@ -0,0 +1,2838 @@
+var or = Object.defineProperty;
+var Vt = (t) => {
+  throw TypeError(t);
+};
+var ar = (t, e, n) => e in t ? or(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var g = (t, e, n) => ar(t, typeof e != "symbol" ? e + "" : e, n), xt = (t, e, n) => e.has(t) || Vt("Cannot " + n);
+var o = (t, e, n) => (xt(t, e, "read from private field"), n ? n.call(t) : e.get(t)), b = (t, e, n) => e.has(t) ? Vt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), _ = (t, e, n, r) => (xt(t, e, "write to private field"), r ? r.call(t, n) : e.set(t, n), n), C = (t, e, n) => (xt(t, e, "access private method"), n);
+var ln;
+typeof window < "u" && ((ln = window.__svelte ?? (window.__svelte = {})).v ?? (ln.v = /* @__PURE__ */ new Set())).add("5");
+const on = "[", an = "[!", un = "]", pt = {}, R = /* @__PURE__ */ Symbol(), Rt = !1;
+var ur = Array.isArray, cr = Array.prototype.indexOf, He = Array.prototype.includes, fr = Array.from, gt = Object.keys, _t = Object.defineProperty, Ne = Object.getOwnPropertyDescriptor, hr = Object.prototype, dr = Array.prototype, pr = Object.getPrototypeOf, Wt = Object.isExtensible;
+function gr(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function _r() {
+  var t, e, n = new Promise((r, i) => {
+    t = r, e = i;
+  });
+  return { promise: n, resolve: t, reject: e };
+}
+const x = 2, Ot = 4, cn = 8, fn = 1 << 24, ce = 16, fe = 32, be = 64, Ht = 128, z = 512, O = 1024, F = 2048, he = 4096, pe = 8192, ge = 16384, Et = 32768, vt = 65536, Kt = 1 << 17, hn = 1 << 18, Ye = 1 << 19, vr = 1 << 20, Re = 32768, It = 1 << 21, dn = 1 << 22, Je = 1 << 23, Tt = /* @__PURE__ */ Symbol("$state"), mr = /* @__PURE__ */ Symbol("legacy props"), pn = new class extends Error {
+  constructor() {
+    super(...arguments);
+    g(this, "name", "StaleReactionError");
+    g(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), $t = 8;
+function yr(t) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function br(t) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function wr() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function Er(t) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function $r() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Sr() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function Cr() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Ar() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function kr() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function xr() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function gn(t) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function Tr() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let ee = !1;
+function st(t) {
+  ee = t;
+}
+let M;
+function Xe(t) {
+  if (t === null)
+    throw gn(), pt;
+  return M = t;
+}
+function _n() {
+  return Xe(/* @__PURE__ */ ze(M));
+}
+function Rr(t = 1) {
+  if (ee) {
+    for (var e = t, n = M; e--; )
+      n = /** @type {TemplateNode} */
+      /* @__PURE__ */ ze(n);
+    M = n;
+  }
+}
+function Or(t = !0) {
+  for (var e = 0, n = M; ; ) {
+    if (n.nodeType === $t) {
+      var r = (
+        /** @type {Comment} */
+        n.data
+      );
+      if (r === un) {
+        if (e === 0) return n;
+        e -= 1;
+      } else (r === on || r === an) && (e += 1);
+    }
+    var i = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ ze(n)
+    );
+    t && n.remove(), n = i;
+  }
+}
+function vn(t) {
+  return t === this.v;
+}
+function Ir(t, e) {
+  return t != t ? e == e : t !== e || t !== null && typeof t == "object" || typeof t == "function";
+}
+function Nr(t) {
+  return !Ir(t, this.v);
+}
+let Lr = !1, U = null;
+function mt(t) {
+  U = t;
+}
+function mn(t, e = !1, n) {
+  U = {
+    p: U,
+    i: !1,
+    c: null,
+    e: null,
+    s: t,
+    x: null,
+    l: null
+  };
+}
+function yn(t) {
+  var e = (
+    /** @type {ComponentContext} */
+    U
+  ), n = e.e;
+  if (n !== null) {
+    e.e = null;
+    for (var r of n)
+      Hn(r);
+  }
+  return t !== void 0 && (e.x = t), e.i = !0, U = e.p, t ?? /** @type {T} */
+  {};
+}
+function bn() {
+  return !0;
+}
+let Ee = [];
+function wn() {
+  var t = Ee;
+  Ee = [], gr(t);
+}
+function Le(t) {
+  if (Ee.length === 0 && !Ke) {
+    var e = Ee;
+    queueMicrotask(() => {
+      e === Ee && wn();
+    });
+  }
+  Ee.push(t);
+}
+function Fr() {
+  for (; Ee.length > 0; )
+    wn();
+}
+function En(t) {
+  var e = w;
+  if (e === null)
+    return v.f |= Je, t;
+  if ((e.f & Et) === 0) {
+    if ((e.f & Ht) === 0)
+      throw t;
+    e.b.error(t);
+  } else
+    yt(t, e);
+}
+function yt(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & Ht) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (n) {
+        t = n;
+      }
+    e = e.parent;
+  }
+  throw t;
+}
+const qr = -7169;
+function T(t, e) {
+  t.f = t.f & qr | e;
+}
+function Yt(t) {
+  (t.f & z) !== 0 || t.deps === null ? T(t, O) : T(t, he);
+}
+function $n(t) {
+  if (t !== null)
+    for (const e of t)
+      (e.f & x) === 0 || (e.f & Re) === 0 || (e.f ^= Re, $n(
+        /** @type {Derived} */
+        e.deps
+      ));
+}
+function Sn(t, e, n) {
+  (t.f & F) !== 0 ? e.add(t) : (t.f & he) !== 0 && n.add(t), $n(t.deps), T(t, O);
+}
+const lt = /* @__PURE__ */ new Set();
+let A = null, V = null, D = [], St = null, Nt = !1, Ke = !1;
+var Fe, qe, Se, Be, et, tt, Ce, De, ne, Lt, Ft, Cn;
+const Ut = class Ut {
+  constructor() {
+    b(this, ne);
+    g(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>}
+     */
+    g(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>}
+     */
+    g(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>}
+     */
+    b(this, Fe, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    b(this, qe, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    b(this, Se, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    b(this, Be, 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}
+     */
+    b(this, et, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    b(this, tt, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    b(this, Ce, /* @__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>}
+     */
+    g(this, "skipped_effects", /* @__PURE__ */ new Set());
+    g(this, "is_fork", !1);
+    b(this, De, !1);
+  }
+  is_deferred() {
+    return this.is_fork || o(this, Be) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(e) {
+    D = [], this.apply();
+    var n = [], r = [];
+    for (const i of e)
+      C(this, ne, Lt).call(this, i, n, r);
+    if (this.is_deferred()) {
+      C(this, ne, Ft).call(this, r), C(this, ne, Ft).call(this, n);
+      for (const i of this.skipped_effects)
+        Tn(i);
+    } else {
+      for (const i of o(this, Fe)) i();
+      o(this, Fe).clear(), o(this, Se) === 0 && C(this, ne, Cn).call(this), A = null, Qt(r), Qt(n), o(this, et)?.resolve();
+    }
+    V = 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(e, n) {
+    n !== R && !this.previous.has(e) && this.previous.set(e, n), (e.f & Je) === 0 && (this.current.set(e, e.v), V?.set(e, e.v));
+  }
+  activate() {
+    A = this, this.apply();
+  }
+  deactivate() {
+    A === this && (A = null, V = null);
+  }
+  flush() {
+    if (this.activate(), D.length > 0) {
+      if (An(), A !== null && A !== this)
+        return;
+    } else o(this, Se) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const e of o(this, qe)) e(this);
+    o(this, qe).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(e) {
+    _(this, Se, o(this, Se) + 1), e && _(this, Be, o(this, Be) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(e) {
+    _(this, Se, o(this, Se) - 1), e && _(this, Be, o(this, Be) - 1), !o(this, De) && (_(this, De, !0), Le(() => {
+      _(this, De, !1), this.is_deferred() ? D.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const e of o(this, tt))
+      o(this, Ce).delete(e), T(e, F), ve(e);
+    for (const e of o(this, Ce))
+      T(e, he), ve(e);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(e) {
+    o(this, Fe).add(e);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(e) {
+    o(this, qe).add(e);
+  }
+  settled() {
+    return (o(this, et) ?? _(this, et, _r())).promise;
+  }
+  static ensure() {
+    if (A === null) {
+      const e = A = new Ut();
+      lt.add(A), Ke || Le(() => {
+        A === e && e.flush();
+      });
+    }
+    return A;
+  }
+  apply() {
+  }
+};
+Fe = new WeakMap(), qe = new WeakMap(), Se = new WeakMap(), Be = new WeakMap(), et = new WeakMap(), tt = new WeakMap(), Ce = new WeakMap(), De = new WeakMap(), ne = 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
+ */
+Lt = function(e, n, r) {
+  e.f ^= O;
+  for (var i = e.first, s = null; i !== null; ) {
+    var l = i.f, a = (l & (fe | be)) !== 0, u = a && (l & O) !== 0, c = u || (l & pe) !== 0 || this.skipped_effects.has(i);
+    if (!c && i.fn !== null) {
+      a ? i.f ^= O : s !== null && (l & (Ot | cn | fn)) !== 0 ? s.b.defer_effect(i) : (l & Ot) !== 0 ? n.push(i) : rt(i) && ((l & ce) !== 0 && o(this, Ce).add(i), Ze(i));
+      var h = i.first;
+      if (h !== null) {
+        i = h;
+        continue;
+      }
+    }
+    var f = i.parent;
+    for (i = i.next; i === null && f !== null; )
+      f === s && (s = null), i = f.next, f = f.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+Ft = function(e) {
+  for (var n = 0; n < e.length; n += 1)
+    Sn(e[n], o(this, tt), o(this, Ce));
+}, Cn = function() {
+  var i;
+  if (lt.size > 1) {
+    this.previous.clear();
+    var e = V, n = !0;
+    for (const s of lt) {
+      if (s === this) {
+        n = !1;
+        continue;
+      }
+      const l = [];
+      for (const [u, c] of this.current) {
+        if (s.current.has(u))
+          if (n && c !== s.current.get(u))
+            s.current.set(u, c);
+          else
+            continue;
+        l.push(u);
+      }
+      if (l.length === 0)
+        continue;
+      const a = [...s.current.keys()].filter((u) => !this.current.has(u));
+      if (a.length > 0) {
+        var r = D;
+        D = [];
+        const u = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+        for (const h of l)
+          kn(h, a, u, c);
+        if (D.length > 0) {
+          A = s, s.apply();
+          for (const h of D)
+            C(i = s, ne, Lt).call(i, h, [], []);
+          s.deactivate();
+        }
+        D = r;
+      }
+    }
+    A = null, V = e;
+  }
+  this.committed = !0, lt.delete(this);
+};
+let ue = Ut;
+function Q(t) {
+  var e = Ke;
+  Ke = !0;
+  try {
+    for (var n; ; ) {
+      if (Fr(), D.length === 0 && (A?.flush(), D.length === 0))
+        return St = null, /** @type {T} */
+        n;
+      An();
+    }
+  } finally {
+    Ke = e;
+  }
+}
+function An() {
+  Nt = !0;
+  var t = null;
+  try {
+    for (var e = 0; D.length > 0; ) {
+      var n = ue.ensure();
+      if (e++ > 1e3) {
+        var r, i;
+        Br();
+      }
+      n.process(D), _e.clear();
+    }
+  } finally {
+    Nt = !1, St = null;
+  }
+}
+function Br() {
+  try {
+    $r();
+  } catch (t) {
+    yt(t, St);
+  }
+}
+let ie = null;
+function Qt(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var n = 0; n < e; ) {
+      var r = t[n++];
+      if ((r.f & (ge | pe)) === 0 && rt(r) && (ie = /* @__PURE__ */ new Set(), Ze(r), r.deps === null && r.first === null && r.nodes === null && (r.teardown === null && r.ac === null ? Un(r) : r.fn = null), ie?.size > 0)) {
+        _e.clear();
+        for (const i of ie) {
+          if ((i.f & (ge | pe)) !== 0) continue;
+          const s = [i];
+          let l = i.parent;
+          for (; l !== null; )
+            ie.has(l) && (ie.delete(l), s.push(l)), l = l.parent;
+          for (let a = s.length - 1; a >= 0; a--) {
+            const u = s[a];
+            (u.f & (ge | pe)) === 0 && Ze(u);
+          }
+        }
+        ie.clear();
+      }
+    }
+    ie = null;
+  }
+}
+function kn(t, e, n, r) {
+  if (!n.has(t) && (n.add(t), t.reactions !== null))
+    for (const i of t.reactions) {
+      const s = i.f;
+      (s & x) !== 0 ? kn(
+        /** @type {Derived} */
+        i,
+        e,
+        n,
+        r
+      ) : (s & (dn | ce)) !== 0 && (s & F) === 0 && xn(i, e, r) && (T(i, F), ve(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function xn(t, e, n) {
+  const r = n.get(t);
+  if (r !== void 0) return r;
+  if (t.deps !== null)
+    for (const i of t.deps) {
+      if (He.call(e, i))
+        return !0;
+      if ((i.f & x) !== 0 && xn(
+        /** @type {Derived} */
+        i,
+        e,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return n.set(t, !1), !1;
+}
+function ve(t) {
+  for (var e = St = t; e.parent !== null; ) {
+    e = e.parent;
+    var n = e.f;
+    if (Nt && e === w && (n & ce) !== 0 && (n & hn) === 0)
+      return;
+    if ((n & (be | fe)) !== 0) {
+      if ((n & O) === 0) return;
+      e.f ^= O;
+    }
+  }
+  D.push(e);
+}
+function Tn(t) {
+  if (!((t.f & fe) !== 0 && (t.f & O) !== 0)) {
+    T(t, O);
+    for (var e = t.first; e !== null; )
+      Tn(e), e = e.next;
+  }
+}
+function Dr(t) {
+  let e = 0, n = Ct(0), r;
+  return () => {
+    Gt() && (y(n), Yn(() => (e === 0 && (r = tr(() => t(() => Qe(n)))), e += 1, () => {
+      Le(() => {
+        e -= 1, e === 0 && (r?.(), r = void 0, Qe(n));
+      });
+    })));
+  };
+}
+var Mr = vt | Ye | Ht;
+function Pr(t, e, n) {
+  new jr(t, e, n);
+}
+var B, nt, J, Ae, X, j, N, Z, se, de, ke, le, Me, xe, Pe, je, oe, wt, $, Rn, On, qt, at, ut, Bt;
+class jr {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(e, n, r) {
+    b(this, $);
+    /** @type {Boundary | null} */
+    g(this, "parent");
+    g(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    b(this, B);
+    /** @type {TemplateNode | null} */
+    b(this, nt, ee ? M : null);
+    /** @type {BoundaryProps} */
+    b(this, J);
+    /** @type {((anchor: Node) => void)} */
+    b(this, Ae);
+    /** @type {Effect} */
+    b(this, X);
+    /** @type {Effect | null} */
+    b(this, j, null);
+    /** @type {Effect | null} */
+    b(this, N, null);
+    /** @type {Effect | null} */
+    b(this, Z, null);
+    /** @type {DocumentFragment | null} */
+    b(this, se, null);
+    /** @type {TemplateNode | null} */
+    b(this, de, null);
+    b(this, ke, 0);
+    b(this, le, 0);
+    b(this, Me, !1);
+    b(this, xe, !1);
+    /** @type {Set<Effect>} */
+    b(this, Pe, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    b(this, je, /* @__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}
+     */
+    b(this, oe, null);
+    b(this, wt, Dr(() => (_(this, oe, Ct(o(this, ke))), () => {
+      _(this, oe, null);
+    })));
+    _(this, B, e), _(this, J, n), _(this, Ae, r), this.parent = /** @type {Effect} */
+    w.b, this.is_pending = !!o(this, J).pending, _(this, X, Xr(() => {
+      if (w.b = this, ee) {
+        const s = o(this, nt);
+        _n(), /** @type {Comment} */
+        s.nodeType === $t && /** @type {Comment} */
+        s.data === an ? C(this, $, On).call(this) : (C(this, $, Rn).call(this), o(this, le) === 0 && (this.is_pending = !1));
+      } else {
+        var i = C(this, $, qt).call(this);
+        try {
+          _(this, j, we(() => r(i)));
+        } catch (s) {
+          this.error(s);
+        }
+        o(this, le) > 0 ? C(this, $, ut).call(this) : this.is_pending = !1;
+      }
+      return () => {
+        o(this, de)?.remove();
+      };
+    }, Mr)), ee && _(this, B, M);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(e) {
+    Sn(e, o(this, Pe), o(this, je));
+  }
+  /**
+   * 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 !!o(this, J).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(e) {
+    C(this, $, Bt).call(this, e), _(this, ke, o(this, ke) + e), !(!o(this, oe) || o(this, Me)) && (_(this, Me, !0), Le(() => {
+      _(this, Me, !1), o(this, oe) && qn(o(this, oe), o(this, ke));
+    }));
+  }
+  get_effect_pending() {
+    return o(this, wt).call(this), y(
+      /** @type {Source<number>} */
+      o(this, oe)
+    );
+  }
+  /** @param {unknown} error */
+  error(e) {
+    var n = o(this, J).onerror;
+    let r = o(this, J).failed;
+    if (o(this, xe) || !n && !r)
+      throw e;
+    o(this, j) && (K(o(this, j)), _(this, j, null)), o(this, N) && (K(o(this, N)), _(this, N, null)), o(this, Z) && (K(o(this, Z)), _(this, Z, null)), ee && (Xe(
+      /** @type {TemplateNode} */
+      o(this, nt)
+    ), Rr(), Xe(Or()));
+    var i = !1, s = !1;
+    const l = () => {
+      if (i) {
+        Tr();
+        return;
+      }
+      i = !0, s && xr(), ue.ensure(), _(this, ke, 0), o(this, Z) !== null && ft(o(this, Z), () => {
+        _(this, Z, null);
+      }), this.is_pending = this.has_pending_snippet(), _(this, j, C(this, $, at).call(this, () => (_(this, xe, !1), we(() => o(this, Ae).call(this, o(this, B)))))), o(this, le) > 0 ? C(this, $, ut).call(this) : this.is_pending = !1;
+    };
+    Le(() => {
+      try {
+        s = !0, n?.(e, l), s = !1;
+      } catch (a) {
+        yt(a, o(this, X) && o(this, X).parent);
+      }
+      r && _(this, Z, C(this, $, at).call(this, () => {
+        ue.ensure(), _(this, xe, !0);
+        try {
+          return we(() => {
+            r(
+              o(this, B),
+              () => e,
+              () => l
+            );
+          });
+        } catch (a) {
+          return yt(
+            a,
+            /** @type {Effect} */
+            o(this, X).parent
+          ), null;
+        } finally {
+          _(this, xe, !1);
+        }
+      }));
+    });
+  }
+}
+B = new WeakMap(), nt = new WeakMap(), J = new WeakMap(), Ae = new WeakMap(), X = new WeakMap(), j = new WeakMap(), N = new WeakMap(), Z = new WeakMap(), se = new WeakMap(), de = new WeakMap(), ke = new WeakMap(), le = new WeakMap(), Me = new WeakMap(), xe = new WeakMap(), Pe = new WeakMap(), je = new WeakMap(), oe = new WeakMap(), wt = new WeakMap(), $ = new WeakSet(), Rn = function() {
+  try {
+    _(this, j, we(() => o(this, Ae).call(this, o(this, B))));
+  } catch (e) {
+    this.error(e);
+  }
+}, On = function() {
+  const e = o(this, J).pending;
+  e && (_(this, N, we(() => e(o(this, B)))), Le(() => {
+    var n = C(this, $, qt).call(this);
+    _(this, j, C(this, $, at).call(this, () => (ue.ensure(), we(() => o(this, Ae).call(this, n))))), o(this, le) > 0 ? C(this, $, ut).call(this) : (ft(
+      /** @type {Effect} */
+      o(this, N),
+      () => {
+        _(this, N, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, qt = function() {
+  var e = o(this, B);
+  return this.is_pending && (_(this, de, Pn()), o(this, B).before(o(this, de)), e = o(this, de)), e;
+}, /**
+ * @param {() => Effect | null} fn
+ */
+at = function(e) {
+  var n = w, r = v, i = U;
+  ye(o(this, X)), te(o(this, X)), mt(o(this, X).ctx);
+  try {
+    return e();
+  } catch (s) {
+    return En(s), null;
+  } finally {
+    ye(n), te(r), mt(i);
+  }
+}, ut = function() {
+  const e = (
+    /** @type {(anchor: Node) => void} */
+    o(this, J).pending
+  );
+  o(this, j) !== null && (_(this, se, document.createDocumentFragment()), o(this, se).append(
+    /** @type {TemplateNode} */
+    o(this, de)
+  ), ti(o(this, j), o(this, se))), o(this, N) === null && _(this, N, we(() => e(o(this, B))));
+}, /**
+ * 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
+ */
+Bt = function(e) {
+  var n;
+  if (!this.has_pending_snippet()) {
+    this.parent && C(n = this.parent, $, Bt).call(n, e);
+    return;
+  }
+  if (_(this, le, o(this, le) + e), o(this, le) === 0) {
+    this.is_pending = !1;
+    for (const r of o(this, Pe))
+      T(r, F), ve(r);
+    for (const r of o(this, je))
+      T(r, he), ve(r);
+    o(this, Pe).clear(), o(this, je).clear(), o(this, N) && ft(o(this, N), () => {
+      _(this, N, null);
+    }), o(this, se) && (o(this, B).before(o(this, se)), _(this, se, null));
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function In(t) {
+  var e = x | F, n = v !== null && (v.f & x) !== 0 ? (
+    /** @type {Derived} */
+    v
+  ) : null;
+  return w !== null && (w.f |= Ye), {
+    ctx: U,
+    deps: null,
+    effects: null,
+    equals: vn,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      R
+    ),
+    wv: 0,
+    parent: n ?? w,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Hr(t) {
+  const e = /* @__PURE__ */ In(t);
+  return Wn(e), e;
+}
+function Nn(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var n = 0; n < e.length; n += 1)
+      K(
+        /** @type {Effect} */
+        e[n]
+      );
+  }
+}
+function Yr(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & x) === 0)
+      return (e.f & ge) === 0 ? (
+        /** @type {Effect} */
+        e
+      ) : null;
+    e = e.parent;
+  }
+  return null;
+}
+function zt(t) {
+  var e, n = w;
+  ye(Yr(t));
+  try {
+    t.f &= ~Re, Nn(t), e = Xn(t);
+  } finally {
+    ye(n);
+  }
+  return e;
+}
+function Ln(t) {
+  var e = zt(t);
+  if (!t.equals(e) && (t.wv = Qn(), (!A?.is_fork || t.deps === null) && (t.v = e, t.deps === null))) {
+    T(t, O);
+    return;
+  }
+  me || (V !== null ? (Gt() || A?.is_fork) && V.set(t, e) : Yt(t));
+}
+let Dt = /* @__PURE__ */ new Set();
+const _e = /* @__PURE__ */ new Map();
+let Fn = !1;
+function Ct(t, e) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: vn,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function Y(t, e) {
+  const n = Ct(t);
+  return Wn(n), n;
+}
+// @__NO_SIDE_EFFECTS__
+function zr(t, e = !1, n = !0) {
+  const r = Ct(t);
+  return e || (r.equals = Nr), r;
+}
+function k(t, e, n = !1) {
+  v !== 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
+  (!W || (v.f & Kt) !== 0) && bn() && (v.f & (x | ce | dn | Kt)) !== 0 && (G === null || !He.call(G, t)) && kr();
+  let r = n ? We(e) : e;
+  return qn(t, r);
+}
+function qn(t, e) {
+  if (!t.equals(e)) {
+    var n = t.v;
+    me ? _e.set(t, e) : _e.set(t, n), t.v = e;
+    var r = ue.ensure();
+    if (r.capture(t, n), (t.f & x) !== 0) {
+      const i = (
+        /** @type {Derived} */
+        t
+      );
+      (t.f & F) !== 0 && zt(i), Yt(i);
+    }
+    t.wv = Qn(), Bn(t, F), w !== null && (w.f & O) !== 0 && (w.f & (fe | be)) === 0 && (P === null ? ni([t]) : P.push(t)), !r.is_fork && Dt.size > 0 && !Fn && Gr();
+  }
+  return e;
+}
+function Gr() {
+  Fn = !1;
+  for (const t of Dt)
+    (t.f & O) !== 0 && T(t, he), rt(t) && Ze(t);
+  Dt.clear();
+}
+function Qe(t) {
+  k(t, t.v + 1);
+}
+function Bn(t, e) {
+  var n = t.reactions;
+  if (n !== null)
+    for (var r = n.length, i = 0; i < r; i++) {
+      var s = n[i], l = s.f, a = (l & F) === 0;
+      if (a && T(s, e), (l & x) !== 0) {
+        var u = (
+          /** @type {Derived} */
+          s
+        );
+        V?.delete(u), (l & Re) === 0 && (l & z && (s.f |= Re), Bn(u, he));
+      } else a && ((l & ce) !== 0 && ie !== null && ie.add(
+        /** @type {Effect} */
+        s
+      ), ve(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function We(t) {
+  if (typeof t != "object" || t === null || Tt in t)
+    return t;
+  const e = pr(t);
+  if (e !== hr && e !== dr)
+    return t;
+  var n = /* @__PURE__ */ new Map(), r = ur(t), i = /* @__PURE__ */ Y(0), s = Te, l = (a) => {
+    if (Te === s)
+      return a();
+    var u = v, c = Te;
+    te(null), Zt(s);
+    var h = a();
+    return te(u), Zt(c), h;
+  };
+  return r && n.set("length", /* @__PURE__ */ Y(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(a, u, c) {
+        (!("value" in c) || c.configurable === !1 || c.enumerable === !1 || c.writable === !1) && Cr();
+        var h = n.get(u);
+        return h === void 0 ? h = l(() => {
+          var f = /* @__PURE__ */ Y(c.value);
+          return n.set(u, f), f;
+        }) : k(h, c.value, !0), !0;
+      },
+      deleteProperty(a, u) {
+        var c = n.get(u);
+        if (c === void 0) {
+          if (u in a) {
+            const h = l(() => /* @__PURE__ */ Y(R));
+            n.set(u, h), Qe(i);
+          }
+        } else
+          k(c, R), Qe(i);
+        return !0;
+      },
+      get(a, u, c) {
+        if (u === Tt)
+          return t;
+        var h = n.get(u), f = u in a;
+        if (h === void 0 && (!f || Ne(a, u)?.writable) && (h = l(() => {
+          var p = We(f ? a[u] : R), m = /* @__PURE__ */ Y(p);
+          return m;
+        }), n.set(u, h)), h !== void 0) {
+          var d = y(h);
+          return d === R ? void 0 : d;
+        }
+        return Reflect.get(a, u, c);
+      },
+      getOwnPropertyDescriptor(a, u) {
+        var c = Reflect.getOwnPropertyDescriptor(a, u);
+        if (c && "value" in c) {
+          var h = n.get(u);
+          h && (c.value = y(h));
+        } else if (c === void 0) {
+          var f = n.get(u), d = f?.v;
+          if (f !== void 0 && d !== R)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: d,
+              writable: !0
+            };
+        }
+        return c;
+      },
+      has(a, u) {
+        if (u === Tt)
+          return !0;
+        var c = n.get(u), h = c !== void 0 && c.v !== R || Reflect.has(a, u);
+        if (c !== void 0 || w !== null && (!h || Ne(a, u)?.writable)) {
+          c === void 0 && (c = l(() => {
+            var d = h ? We(a[u]) : R, p = /* @__PURE__ */ Y(d);
+            return p;
+          }), n.set(u, c));
+          var f = y(c);
+          if (f === R)
+            return !1;
+        }
+        return h;
+      },
+      set(a, u, c, h) {
+        var f = n.get(u), d = u in a;
+        if (r && u === "length")
+          for (var p = c; p < /** @type {Source<number>} */
+          f.v; p += 1) {
+            var m = n.get(p + "");
+            m !== void 0 ? k(m, R) : p in a && (m = l(() => /* @__PURE__ */ Y(R)), n.set(p + "", m));
+          }
+        if (f === void 0)
+          (!d || Ne(a, u)?.writable) && (f = l(() => /* @__PURE__ */ Y(void 0)), k(f, We(c)), n.set(u, f));
+        else {
+          d = f.v !== R;
+          var I = l(() => We(c));
+          k(f, I);
+        }
+        var S = Reflect.getOwnPropertyDescriptor(a, u);
+        if (S?.set && S.set.call(h, c), !d) {
+          if (r && typeof u == "string") {
+            var Ue = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), Oe = Number(u);
+            Number.isInteger(Oe) && Oe >= Ue.v && k(Ue, Oe + 1);
+          }
+          Qe(i);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        y(i);
+        var u = Reflect.ownKeys(a).filter((f) => {
+          var d = n.get(f);
+          return d === void 0 || d.v !== R;
+        });
+        for (var [c, h] of n)
+          h.v !== R && !(c in a) && u.push(c);
+        return u;
+      },
+      setPrototypeOf() {
+        Ar();
+      }
+    }
+  );
+}
+var Jt, Dn, Mn;
+function Mt() {
+  if (Jt === void 0) {
+    Jt = window;
+    var t = Element.prototype, e = Node.prototype, n = Text.prototype;
+    Dn = Ne(e, "firstChild").get, Mn = Ne(e, "nextSibling").get, Wt(t) && (t.__click = void 0, t.__className = void 0, t.__attributes = null, t.__style = void 0, t.__e = void 0), Wt(n) && (n.__t = void 0);
+  }
+}
+function Pn(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Ur(t) {
+  return (
+    /** @type {TemplateNode | null} */
+    Dn.call(t)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function ze(t) {
+  return (
+    /** @type {TemplateNode | null} */
+    Mn.call(t)
+  );
+}
+function Vr(t) {
+  t.textContent = "";
+}
+function jn(t) {
+  var e = v, n = w;
+  te(null), ye(null);
+  try {
+    return t();
+  } finally {
+    te(e), ye(n);
+  }
+}
+function Wr(t) {
+  w === null && (v === null && Er(), wr()), me && br();
+}
+function Kr(t, e) {
+  var n = e.last;
+  n === null ? e.last = e.first = t : (n.next = t, t.prev = n, e.last = t);
+}
+function Ge(t, e, n) {
+  var r = w;
+  r !== null && (r.f & pe) !== 0 && (t |= pe);
+  var i = {
+    ctx: U,
+    deps: null,
+    nodes: null,
+    f: t | F | z,
+    first: null,
+    fn: e,
+    last: null,
+    next: null,
+    parent: r,
+    b: r && r.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (n)
+    try {
+      Ze(i), i.f |= Et;
+    } catch (a) {
+      throw K(i), a;
+    }
+  else e !== null && ve(i);
+  var s = i;
+  if (n && s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+  (s.f & Ye) === 0 && (s = s.first, (t & ce) !== 0 && (t & vt) !== 0 && s !== null && (s.f |= vt)), s !== null && (s.parent = r, r !== null && Kr(s, r), v !== null && (v.f & x) !== 0 && (t & be) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      v
+    );
+    (l.effects ?? (l.effects = [])).push(s);
+  }
+  return i;
+}
+function Gt() {
+  return v !== null && !W;
+}
+function ct(t) {
+  Wr();
+  var e = (
+    /** @type {Effect} */
+    w.f
+  ), n = !v && (e & fe) !== 0 && (e & Et) === 0;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      U
+    );
+    (r.e ?? (r.e = [])).push(t);
+  } else
+    return Hn(t);
+}
+function Hn(t) {
+  return Ge(Ot | vr, t, !1);
+}
+function Qr(t) {
+  ue.ensure();
+  const e = Ge(be | Ye, t, !0);
+  return () => {
+    K(e);
+  };
+}
+function Jr(t) {
+  ue.ensure();
+  const e = Ge(be | Ye, t, !0);
+  return (n = {}) => new Promise((r) => {
+    n.outro ? ft(e, () => {
+      K(e), r(void 0);
+    }) : (K(e), r(void 0));
+  });
+}
+function Yn(t, e = 0) {
+  return Ge(cn | e, t, !0);
+}
+function Xr(t, e = 0) {
+  var n = Ge(ce | e, t, !0);
+  return n;
+}
+function we(t) {
+  return Ge(fe | Ye, t, !0);
+}
+function zn(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const n = me, r = v;
+    Xt(!0), te(null);
+    try {
+      e.call(null);
+    } finally {
+      Xt(n), te(r);
+    }
+  }
+}
+function Gn(t, e = !1) {
+  var n = t.first;
+  for (t.first = t.last = null; n !== null; ) {
+    const i = n.ac;
+    i !== null && jn(() => {
+      i.abort(pn);
+    });
+    var r = n.next;
+    (n.f & be) !== 0 ? n.parent = null : K(n, e), n = r;
+  }
+}
+function Zr(t) {
+  for (var e = t.first; e !== null; ) {
+    var n = e.next;
+    (e.f & fe) === 0 && K(e), e = n;
+  }
+}
+function K(t, e = !0) {
+  var n = !1;
+  (e || (t.f & hn) !== 0) && t.nodes !== null && t.nodes.end !== null && (ei(
+    t.nodes.start,
+    /** @type {TemplateNode} */
+    t.nodes.end
+  ), n = !0), Gn(t, e && !n), bt(t, 0), T(t, ge);
+  var r = t.nodes && t.nodes.t;
+  if (r !== null)
+    for (const s of r)
+      s.stop();
+  zn(t);
+  var i = t.parent;
+  i !== null && i.first !== null && Un(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes = t.ac = null;
+}
+function ei(t, e) {
+  for (; t !== null; ) {
+    var n = t === e ? null : /* @__PURE__ */ ze(t);
+    t.remove(), t = n;
+  }
+}
+function Un(t) {
+  var e = t.parent, n = t.prev, r = t.next;
+  n !== null && (n.next = r), r !== null && (r.prev = n), e !== null && (e.first === t && (e.first = r), e.last === t && (e.last = n));
+}
+function ft(t, e, n = !0) {
+  var r = [];
+  Vn(t, r, !0);
+  var i = () => {
+    n && K(t), e && e();
+  }, s = r.length;
+  if (s > 0) {
+    var l = () => --s || i();
+    for (var a of r)
+      a.out(l);
+  } else
+    i();
+}
+function Vn(t, e, n) {
+  if ((t.f & pe) === 0) {
+    t.f ^= pe;
+    var r = t.nodes && t.nodes.t;
+    if (r !== null)
+      for (const a of r)
+        (a.is_global || n) && e.push(a);
+    for (var i = t.first; i !== null; ) {
+      var s = i.next, l = (i.f & vt) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (i.f & fe) !== 0 && (t.f & ce) !== 0;
+      Vn(i, e, l ? n : !1), i = s;
+    }
+  }
+}
+function ti(t, e) {
+  if (t.nodes)
+    for (var n = t.nodes.start, r = t.nodes.end; n !== null; ) {
+      var i = n === r ? null : /* @__PURE__ */ ze(n);
+      e.append(n), n = i;
+    }
+}
+let ht = !1, me = !1;
+function Xt(t) {
+  me = t;
+}
+let v = null, W = !1;
+function te(t) {
+  v = t;
+}
+let w = null;
+function ye(t) {
+  w = t;
+}
+let G = null;
+function Wn(t) {
+  v !== null && (G === null ? G = [t] : G.push(t));
+}
+let L = null, q = 0, P = null;
+function ni(t) {
+  P = t;
+}
+let Kn = 1, $e = 0, Te = $e;
+function Zt(t) {
+  Te = t;
+}
+function Qn() {
+  return ++Kn;
+}
+function rt(t) {
+  var e = t.f;
+  if ((e & F) !== 0)
+    return !0;
+  if (e & x && (t.f &= ~Re), (e & he) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      t.deps
+    ), r = n.length, i = 0; i < r; i++) {
+      var s = n[i];
+      if (rt(
+        /** @type {Derived} */
+        s
+      ) && Ln(
+        /** @type {Derived} */
+        s
+      ), s.wv > t.wv)
+        return !0;
+    }
+    (e & z) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    V === null && T(t, O);
+  }
+  return !1;
+}
+function Jn(t, e, n = !0) {
+  var r = t.reactions;
+  if (r !== null && !(G !== null && He.call(G, t)))
+    for (var i = 0; i < r.length; i++) {
+      var s = r[i];
+      (s.f & x) !== 0 ? Jn(
+        /** @type {Derived} */
+        s,
+        e,
+        !1
+      ) : e === s && (n ? T(s, F) : (s.f & O) !== 0 && T(s, he), ve(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Xn(t) {
+  var I;
+  var e = L, n = q, r = P, i = v, s = G, l = U, a = W, u = Te, c = t.f;
+  L = /** @type {null | Value[]} */
+  null, q = 0, P = null, v = (c & (fe | be)) === 0 ? t : null, G = null, mt(t.ctx), W = !1, Te = ++$e, t.ac !== null && (jn(() => {
+    t.ac.abort(pn);
+  }), t.ac = null);
+  try {
+    t.f |= It;
+    var h = (
+      /** @type {Function} */
+      t.fn
+    ), f = h(), d = t.deps, p = A?.is_fork;
+    if (L !== null) {
+      var m;
+      if (p || bt(t, q), d !== null && q > 0)
+        for (d.length = q + L.length, m = 0; m < L.length; m++)
+          d[q + m] = L[m];
+      else
+        t.deps = d = L;
+      if (Gt() && (t.f & z) !== 0)
+        for (m = q; m < d.length; m++)
+          ((I = d[m]).reactions ?? (I.reactions = [])).push(t);
+    } else !p && d !== null && q < d.length && (bt(t, q), d.length = q);
+    if (bn() && P !== null && !W && d !== null && (t.f & (x | he | F)) === 0)
+      for (m = 0; m < /** @type {Source[]} */
+      P.length; m++)
+        Jn(
+          P[m],
+          /** @type {Effect} */
+          t
+        );
+    if (i !== null && i !== t) {
+      if ($e++, i.deps !== null)
+        for (let S = 0; S < n; S += 1)
+          i.deps[S].rv = $e;
+      if (e !== null)
+        for (const S of e)
+          S.rv = $e;
+      P !== null && (r === null ? r = P : r.push(.../** @type {Source[]} */
+      P));
+    }
+    return (t.f & Je) !== 0 && (t.f ^= Je), f;
+  } catch (S) {
+    return En(S);
+  } finally {
+    t.f ^= It, L = e, q = n, P = r, v = i, G = s, mt(l), W = a, Te = u;
+  }
+}
+function ri(t, e) {
+  let n = e.reactions;
+  if (n !== null) {
+    var r = cr.call(n, t);
+    if (r !== -1) {
+      var i = n.length - 1;
+      i === 0 ? n = e.reactions = null : (n[r] = n[i], n.pop());
+    }
+  }
+  if (n === null && (e.f & x) !== 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
+  (L === null || !He.call(L, e))) {
+    var s = (
+      /** @type {Derived} */
+      e
+    );
+    (s.f & z) !== 0 && (s.f ^= z, s.f &= ~Re), Yt(s), Nn(s), bt(s, 0);
+  }
+}
+function bt(t, e) {
+  var n = t.deps;
+  if (n !== null)
+    for (var r = e; r < n.length; r++)
+      ri(t, n[r]);
+}
+function Ze(t) {
+  var e = t.f;
+  if ((e & ge) === 0) {
+    T(t, O);
+    var n = w, r = ht;
+    w = t, ht = !0;
+    try {
+      (e & (ce | fn)) !== 0 ? Zr(t) : Gn(t), zn(t);
+      var i = Xn(t);
+      t.teardown = typeof i == "function" ? i : null, t.wv = Kn;
+      var s;
+      Rt && Lr && (t.f & F) !== 0 && t.deps;
+    } finally {
+      ht = r, w = n;
+    }
+  }
+}
+function y(t) {
+  var e = t.f, n = (e & x) !== 0;
+  if (v !== null && !W) {
+    var r = w !== null && (w.f & ge) !== 0;
+    if (!r && (G === null || !He.call(G, t))) {
+      var i = v.deps;
+      if ((v.f & It) !== 0)
+        t.rv < $e && (t.rv = $e, L === null && i !== null && i[q] === t ? q++ : L === null ? L = [t] : L.push(t));
+      else {
+        (v.deps ?? (v.deps = [])).push(t);
+        var s = t.reactions;
+        s === null ? t.reactions = [v] : He.call(s, v) || s.push(v);
+      }
+    }
+  }
+  if (me && _e.has(t))
+    return _e.get(t);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      t
+    );
+    if (me) {
+      var a = l.v;
+      return ((l.f & O) === 0 && l.reactions !== null || er(l)) && (a = zt(l)), _e.set(l, a), a;
+    }
+    var u = (l.f & z) === 0 && !W && v !== null && (ht || (v.f & z) !== 0), c = l.deps === null;
+    rt(l) && (u && (l.f |= z), Ln(l)), u && !c && Zn(l);
+  }
+  if (V?.has(t))
+    return V.get(t);
+  if ((t.f & Je) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Zn(t) {
+  if (t.deps !== null) {
+    t.f |= z;
+    for (const e of t.deps)
+      (e.reactions ?? (e.reactions = [])).push(t), (e.f & x) !== 0 && (e.f & z) === 0 && Zn(
+        /** @type {Derived} */
+        e
+      );
+  }
+}
+function er(t) {
+  if (t.v === R) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (_e.has(e) || (e.f & x) !== 0 && er(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+function tr(t) {
+  var e = W;
+  try {
+    return W = !0, t();
+  } finally {
+    W = e;
+  }
+}
+const ii = /* @__PURE__ */ new Set(), en = /* @__PURE__ */ new Set();
+let tn = null;
+function ot(t) {
+  var e = this, n = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), r = t.type, i = t.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    i[0] || t.target
+  );
+  tn = t;
+  var l = 0, a = tn === t && t.__root;
+  if (a) {
+    var u = i.indexOf(a);
+    if (u !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t.__root = e;
+      return;
+    }
+    var c = i.indexOf(e);
+    if (c === -1)
+      return;
+    u <= c && (l = u);
+  }
+  if (s = /** @type {Element} */
+  i[l] || t.target, s !== e) {
+    _t(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || n;
+      }
+    });
+    var h = v, f = w;
+    te(null), ye(null);
+    try {
+      for (var d, p = []; s !== null; ) {
+        var m = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var I = s["__" + r];
+          I != 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
+          t.target === s) && I.call(s, t);
+        } catch (S) {
+          d ? p.push(S) : d = S;
+        }
+        if (t.cancelBubble || m === e || m === null)
+          break;
+        s = m;
+      }
+      if (d) {
+        for (let S of p)
+          queueMicrotask(() => {
+            throw S;
+          });
+        throw d;
+      }
+    } finally {
+      t.__root = e, delete t.currentTarget, te(h), ye(f);
+    }
+  }
+}
+function si(t, e) {
+  var n = (
+    /** @type {Effect} */
+    w
+  );
+  n.nodes === null && (n.nodes = { start: t, end: e, a: null, t: null });
+}
+function li(t, e) {
+  if (ee) {
+    var n = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      w
+    );
+    ((n.f & Et) === 0 || n.nodes.end === null) && (n.nodes.end = M), _n();
+    return;
+  }
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+const oi = ["touchstart", "touchmove"];
+function ai(t) {
+  return oi.includes(t);
+}
+function nr(t, e) {
+  return rr(t, e);
+}
+function ui(t, e) {
+  Mt(), e.intro = e.intro ?? !1;
+  const n = e.target, r = ee, i = M;
+  try {
+    for (var s = /* @__PURE__ */ Ur(n); s && (s.nodeType !== $t || /** @type {Comment} */
+    s.data !== on); )
+      s = /* @__PURE__ */ ze(s);
+    if (!s)
+      throw pt;
+    st(!0), Xe(
+      /** @type {Comment} */
+      s
+    );
+    const l = rr(t, { ...e, anchor: s });
+    return st(!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 !== pt && console.warn("Failed to hydrate: ", l), e.recover === !1 && Sr(), Mt(), Vr(n), st(!1), nr(t, e);
+  } finally {
+    st(r), Xe(i);
+  }
+}
+const Ie = /* @__PURE__ */ new Map();
+function rr(t, { target: e, anchor: n, props: r = {}, events: i, context: s, intro: l = !0 }) {
+  Mt();
+  var a = /* @__PURE__ */ new Set(), u = (f) => {
+    for (var d = 0; d < f.length; d++) {
+      var p = f[d];
+      if (!a.has(p)) {
+        a.add(p);
+        var m = ai(p);
+        e.addEventListener(p, ot, { passive: m });
+        var I = Ie.get(p);
+        I === void 0 ? (document.addEventListener(p, ot, { passive: m }), Ie.set(p, 1)) : Ie.set(p, I + 1);
+      }
+    }
+  };
+  u(fr(ii)), en.add(u);
+  var c = void 0, h = Jr(() => {
+    var f = n ?? e.appendChild(Pn());
+    return Pr(
+      /** @type {TemplateNode} */
+      f,
+      {
+        pending: () => {
+        }
+      },
+      (d) => {
+        if (s) {
+          mn({});
+          var p = (
+            /** @type {ComponentContext} */
+            U
+          );
+          p.c = s;
+        }
+        if (i && (r.$$events = i), ee && si(
+          /** @type {TemplateNode} */
+          d,
+          null
+        ), c = t(d, r) || {}, ee && (w.nodes.end = M, M === null || M.nodeType !== $t || /** @type {Comment} */
+        M.data !== un))
+          throw gn(), pt;
+        s && yn();
+      }
+    ), () => {
+      for (var d of a) {
+        e.removeEventListener(d, ot);
+        var p = (
+          /** @type {number} */
+          Ie.get(d)
+        );
+        --p === 0 ? (document.removeEventListener(d, ot), Ie.delete(d)) : Ie.set(d, p);
+      }
+      en.delete(u), f !== n && f.parentNode?.removeChild(f);
+    };
+  });
+  return Pt.set(c, h), c;
+}
+let Pt = /* @__PURE__ */ new WeakMap();
+function ci(t, e) {
+  const n = Pt.get(t);
+  return n ? (Pt.delete(t), n(e)) : Promise.resolve();
+}
+function fi(t) {
+  U === null && yr(), ct(() => {
+    const e = tr(t);
+    if (typeof e == "function") return (
+      /** @type {() => void} */
+      e
+    );
+  });
+}
+function re(t, e, n, r) {
+  var i = (
+    /** @type {V} */
+    r
+  ), s = !0, l = () => (s && (s = !1, i = /** @type {V} */
+  r), i), a;
+  a = /** @type {V} */
+  t[e], a === void 0 && r !== void 0 && (a = l());
+  var u;
+  u = () => {
+    var d = (
+      /** @type {V} */
+      t[e]
+    );
+    return d === void 0 ? l() : (s = !0, d);
+  };
+  var c = !1, h = /* @__PURE__ */ In(() => (c = !1, u())), f = (
+    /** @type {Effect} */
+    w
+  );
+  return (
+    /** @type {() => V} */
+    (function(d, p) {
+      if (arguments.length > 0) {
+        const m = p ? y(h) : d;
+        return k(h, m), c = !0, i !== void 0 && (i = m), d;
+      }
+      return me && c || (f.f & ge) !== 0 ? h.v : y(h);
+    })
+  );
+}
+function hi(t) {
+  return new di(t);
+}
+var ae, H;
+class di {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(e) {
+    /** @type {any} */
+    b(this, ae);
+    /** @type {Record<string, any>} */
+    b(this, H);
+    var n = /* @__PURE__ */ new Map(), r = (s, l) => {
+      var a = /* @__PURE__ */ zr(l, !1, !1);
+      return n.set(s, a), a;
+    };
+    const i = new Proxy(
+      { ...e.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return y(n.get(l) ?? r(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === mr ? !0 : (y(n.get(l) ?? r(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, a) {
+          return k(n.get(l) ?? r(l, a), a), Reflect.set(s, l, a);
+        }
+      }
+    );
+    _(this, H, (e.hydrate ? ui : nr)(e.component, {
+      target: e.target,
+      anchor: e.anchor,
+      props: i,
+      context: e.context,
+      intro: e.intro ?? !1,
+      recover: e.recover
+    })), (!e?.props?.$$host || e.sync === !1) && Q(), _(this, ae, i.$$events);
+    for (const s of Object.keys(o(this, H)))
+      s === "$set" || s === "$destroy" || s === "$on" || _t(this, s, {
+        get() {
+          return o(this, H)[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          o(this, H)[s] = l;
+        },
+        enumerable: !0
+      });
+    o(this, H).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(i, s);
+    }, o(this, H).$destroy = () => {
+      ci(o(this, H));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(e) {
+    o(this, H).$set(e);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(e, n) {
+    o(this, ae)[e] = o(this, ae)[e] || [];
+    const r = (...i) => n.call(this, ...i);
+    return o(this, ae)[e].push(r), () => {
+      o(this, ae)[e] = o(this, ae)[e].filter(
+        /** @param {any} fn */
+        (i) => i !== r
+      );
+    };
+  }
+  $destroy() {
+    o(this, H).$destroy();
+  }
+}
+ae = new WeakMap(), H = new WeakMap();
+let ir;
+typeof HTMLElement == "function" && (ir = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(e, n, r) {
+    super();
+    /** The Svelte component constructor */
+    g(this, "$$ctor");
+    /** Slots */
+    g(this, "$$s");
+    /** @type {any} The Svelte component instance */
+    g(this, "$$c");
+    /** Whether or not the custom element is connected */
+    g(this, "$$cn", !1);
+    /** @type {Record<string, any>} Component props data */
+    g(this, "$$d", {});
+    /** `true` if currently in the process of reflecting component props back to attributes */
+    g(this, "$$r", !1);
+    /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+    g(this, "$$p_d", {});
+    /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+    g(this, "$$l", {});
+    /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+    g(this, "$$l_u", /* @__PURE__ */ new Map());
+    /** @type {any} The managed render effect for reflecting attributes */
+    g(this, "$$me");
+    /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+    g(this, "$$shadowRoot", null);
+    this.$$ctor = e, this.$$s = n, r && (this.$$shadowRoot = this.attachShadow(r));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(e, n, r) {
+    if (this.$$l[e] = this.$$l[e] || [], this.$$l[e].push(n), this.$$c) {
+      const i = this.$$c.$on(e, n);
+      this.$$l_u.set(n, i);
+    }
+    super.addEventListener(e, n, r);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(e, n, r) {
+    if (super.removeEventListener(e, n, r), this.$$c) {
+      const i = this.$$l_u.get(n);
+      i && (i(), this.$$l_u.delete(n));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let e = function(i) {
+        return (s) => {
+          const l = document.createElement("slot");
+          i !== "default" && (l.name = i), li(s, l);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const n = {}, r = pi(this);
+      for (const i of this.$$s)
+        i in r && (i === "default" && !this.$$d.children ? (this.$$d.children = e(i), n.default = !0) : n[i] = e(i));
+      for (const i of this.attributes) {
+        const s = this.$$g_p(i.name);
+        s in this.$$d || (this.$$d[s] = dt(s, i.value, this.$$p_d, "toProp"));
+      }
+      for (const i in this.$$p_d)
+        !(i in this.$$d) && this[i] !== void 0 && (this.$$d[i] = this[i], delete this[i]);
+      this.$$c = hi({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: n,
+          $$host: this
+        }
+      }), this.$$me = Qr(() => {
+        Yn(() => {
+          this.$$r = !0;
+          for (const i of gt(this.$$c)) {
+            if (!this.$$p_d[i]?.reflect) continue;
+            this.$$d[i] = this.$$c[i];
+            const s = dt(
+              i,
+              this.$$d[i],
+              this.$$p_d,
+              "toAttribute"
+            );
+            s == null ? this.removeAttribute(this.$$p_d[i].attribute || i) : this.setAttribute(this.$$p_d[i].attribute || i, s);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const i in this.$$l)
+        for (const s of this.$$l[i]) {
+          const l = this.$$c.$on(i, s);
+          this.$$l_u.set(s, l);
+        }
+      this.$$l = {};
+    }
+  }
+  // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+  // and setting attributes through setAttribute etc, this is helpful
+  /**
+   * @param {string} attr
+   * @param {string} _oldValue
+   * @param {string} newValue
+   */
+  attributeChangedCallback(e, n, r) {
+    this.$$r || (e = this.$$g_p(e), this.$$d[e] = dt(e, r, this.$$p_d, "toProp"), this.$$c?.$set({ [e]: this.$$d[e] }));
+  }
+  disconnectedCallback() {
+    this.$$cn = !1, Promise.resolve().then(() => {
+      !this.$$cn && this.$$c && (this.$$c.$destroy(), this.$$me(), this.$$c = void 0);
+    });
+  }
+  /**
+   * @param {string} attribute_name
+   */
+  $$g_p(e) {
+    return gt(this.$$p_d).find(
+      (n) => this.$$p_d[n].attribute === e || !this.$$p_d[n].attribute && n.toLowerCase() === e
+    ) || e;
+  }
+});
+function dt(t, e, n, r) {
+  const i = n[t]?.type;
+  if (e = i === "Boolean" && typeof e != "boolean" ? e != null : e, !r || !n[t])
+    return e;
+  if (r === "toAttribute")
+    switch (i) {
+      case "Object":
+      case "Array":
+        return e == null ? null : JSON.stringify(e);
+      case "Boolean":
+        return e ? "" : null;
+      case "Number":
+        return e ?? null;
+      default:
+        return e;
+    }
+  else
+    switch (i) {
+      case "Object":
+      case "Array":
+        return e && JSON.parse(e);
+      case "Boolean":
+        return e;
+      // conversion already handled above
+      case "Number":
+        return e != null ? +e : e;
+      default:
+        return e;
+    }
+}
+function pi(t) {
+  const e = {};
+  return t.childNodes.forEach((n) => {
+    e[
+      /** @type {Element} node */
+      n.slot || "default"
+    ] = !0;
+  }), e;
+}
+function gi(t, e, n, r, i, s) {
+  let l = class extends ir {
+    constructor() {
+      super(t, n, i), this.$$p_d = e;
+    }
+    static get observedAttributes() {
+      return gt(e).map(
+        (a) => (e[a].attribute || a).toLowerCase()
+      );
+    }
+  };
+  return gt(e).forEach((a) => {
+    _t(l.prototype, a, {
+      get() {
+        return this.$$c && a in this.$$c ? this.$$c[a] : this.$$d[a];
+      },
+      set(u) {
+        u = dt(a, u, e), this.$$d[a] = u;
+        var c = this.$$c;
+        if (c) {
+          var h = Ne(c, a)?.get;
+          h ? c[a] = u : c.$set({ [a]: u });
+        }
+      }
+    });
+  }), r.forEach((a) => {
+    _t(l.prototype, a, {
+      get() {
+        return this.$$c?.[a];
+      }
+    });
+  }), t.element = /** @type {any} */
+  l, l;
+}
+var nn;
+(function(t) {
+  t.TTS_WORD = "tts-word", t.TTS_SENTENCE = "tts-sentence", t.ANNOTATION = "annotation";
+})(nn || (nn = {}));
+var rn;
+(function(t) {
+  t.YELLOW = "yellow", t.GREEN = "green", t.BLUE = "blue", t.PINK = "pink", t.ORANGE = "orange";
+})(rn || (rn = {}));
+const _i = {
+  // 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(_i).map(([t, e]) => [e, t]));
+var jt;
+(function(t) {
+  t[t.BASE = 0] = "BASE", t[t.TOOL = 1e3] = "TOOL", t[t.MODAL = 2e3] = "MODAL", t[t.CONTROL = 3e3] = "CONTROL", t[t.HIGHLIGHT = 4e3] = "HIGHLIGHT";
+})(jt || (jt = {}));
+var sn;
+(function(t) {
+  t.IDLE = "idle", t.LOADING = "loading", t.PLAYING = "playing", t.PAUSED = "paused", t.ERROR = "error";
+})(sn || (sn = {}));
+class sr {
+  constructor() {
+    g(this, "elementType", "multiple-choice");
+    g(this, "priority", 100);
+  }
+  canHandle(e) {
+    return e.tagName.toLowerCase() === "multiple-choice" || e.classList.contains("multiple-choice");
+  }
+  findChoices(e) {
+    return Array.from(
+      e.querySelectorAll(
+        ".corespring-checkbox, .corespring-radio-button"
+      )
+    );
+  }
+  createChoiceRange(e) {
+    const n = e.querySelector(".label") || e.querySelector("label") || e.querySelector('[class*="label"]') || e.querySelector("span");
+    if (!n)
+      return null;
+    const r = document.createRange();
+    return r.selectNodeContents(n), r;
+  }
+  getChoiceId(e) {
+    const n = e.querySelector(
+      'input[type="checkbox"], input[type="radio"]'
+    );
+    return n?.getAttribute("value") || n?.id || this.generateFallbackId(e);
+  }
+  getChoiceLabel(e) {
+    return e.querySelector(".label")?.textContent?.trim() || "Unlabeled choice";
+  }
+  canEliminate(e) {
+    const n = e.querySelector(
+      'input[type="checkbox"], input[type="radio"]'
+    );
+    return !(!n || n.getAttribute("aria-checked") === "true" || n.disabled || e.closest(".multiple-choice")?.querySelector(".feedback-tick"));
+  }
+  getButtonContainer(e) {
+    return e;
+  }
+  generateFallbackId(e) {
+    const r = e.closest(".multiple-choice")?.querySelectorAll(".choice-input") || [];
+    return `choice-${Array.from(r).indexOf(e)}`;
+  }
+}
+class vi {
+  constructor() {
+    g(this, "elementType", "ebsr");
+    g(this, "priority", 95);
+    g(this, "mcAdapter", new sr());
+  }
+  canHandle(e) {
+    return e.tagName.toLowerCase() === "ebsr" || e.querySelector("ebsr-multiple-choice") !== null;
+  }
+  findChoices(e) {
+    const n = e.querySelector('ebsr-multiple-choice[id="a"]'), r = e.querySelector('ebsr-multiple-choice[id="b"]'), i = [];
+    return n && i.push(...this.mcAdapter.findChoices(n)), r && i.push(...this.mcAdapter.findChoices(r)), i;
+  }
+  // Delegate all other methods to MultipleChoiceAdapter
+  createChoiceRange(e) {
+    return this.mcAdapter.createChoiceRange(e);
+  }
+  getChoiceId(e) {
+    const n = e.closest("ebsr-multiple-choice")?.id || "unknown", r = this.mcAdapter.getChoiceId(e);
+    return `${n}-${r}`;
+  }
+  getChoiceLabel(e) {
+    return this.mcAdapter.getChoiceLabel(e);
+  }
+  canEliminate(e) {
+    return this.mcAdapter.canEliminate(e);
+  }
+  getButtonContainer(e) {
+    return this.mcAdapter.getButtonContainer(e);
+  }
+}
+class mi {
+  constructor() {
+    g(this, "elementType", "inline-dropdown");
+    g(this, "priority", 90);
+  }
+  canHandle(e) {
+    return e.tagName.toLowerCase() === "inline-dropdown" || e.querySelector('[role="combobox"]') !== null;
+  }
+  findChoices(e) {
+    return Array.from(e.querySelectorAll('[role="option"]'));
+  }
+  createChoiceRange(e) {
+    const n = document.createRange();
+    return n.selectNodeContents(e), n;
+  }
+  getChoiceId(e) {
+    return e.id || e.getAttribute("data-value") || "";
+  }
+  getChoiceLabel(e) {
+    return e.textContent?.trim() || "Unlabeled option";
+  }
+  canEliminate(e) {
+    return e.getAttribute("aria-selected") !== "true";
+  }
+  getButtonContainer(e) {
+    return e;
+  }
+}
+class yi {
+  constructor() {
+    g(this, "adapters");
+    this.adapters = [
+      new sr(),
+      new vi(),
+      new mi()
+    ].sort((e, n) => n.priority - e.priority);
+  }
+  /**
+   * Find the appropriate adapter for an element
+   */
+  findAdapter(e) {
+    return this.adapters.find((n) => n.canHandle(e)) || null;
+  }
+  /**
+   * Find all choices with their adapters within a root element
+   */
+  findAllChoicesWithAdapters(e) {
+    const n = [], r = /* @__PURE__ */ new Set();
+    for (const i of this.adapters) {
+      const s = i.findChoices(e);
+      for (const l of s)
+        r.has(l) || (r.add(l), n.push({ choice: l, adapter: i }));
+    }
+    return n;
+  }
+  /**
+   * Register a custom adapter
+   */
+  registerAdapter(e) {
+    this.adapters.push(e), this.adapters.sort((n, r) => r.priority - n.priority);
+  }
+}
+class bi {
+  constructor() {
+    g(this, "name", "mask");
+    g(this, "highlights", /* @__PURE__ */ new Map());
+    g(this, "ranges", /* @__PURE__ */ new Map());
+  }
+  initialize() {
+    this.injectCSS();
+  }
+  destroy() {
+    this.clearAll(), this.removeCSS();
+  }
+  apply(e, n) {
+    if (!this.isSupported()) {
+      this.applyFallback(e, n);
+      return;
+    }
+    this.injectHighlightCSS(e);
+    const r = new Highlight(n);
+    CSS.highlights.set(`answer-masked-${e}`, r), this.highlights.set(e, r), this.ranges.set(e, n), this.addAriaAttributes(n);
+  }
+  remove(e) {
+    if (!this.isSupported()) {
+      this.removeFallback(e);
+      return;
+    }
+    CSS.highlights.delete(`answer-masked-${e}`), this.removeHighlightCSS(e);
+    const n = this.ranges.get(e);
+    n && this.removeAriaAttributes(n), this.highlights.delete(e), this.ranges.delete(e);
+  }
+  isEliminated(e) {
+    return this.highlights.has(e);
+  }
+  clearAll() {
+    for (const e of this.highlights.keys())
+      this.remove(e);
+  }
+  getEliminatedIds() {
+    return Array.from(this.highlights.keys());
+  }
+  isSupported() {
+    return typeof CSS < "u" && "highlights" in CSS;
+  }
+  injectCSS() {
+    const e = "answer-eliminator-mask-styles";
+    if (document.getElementById(e)) return;
+    const n = document.createElement("style");
+    n.id = e, n.textContent = `
+      /* Fallback */
+      .answer-masked-fallback {
+        opacity: 0.2;
+        filter: blur(2px);
+      }
+    `, document.head.appendChild(n);
+  }
+  injectHighlightCSS(e) {
+    const n = `answer-eliminator-mask-highlight-${e}`;
+    if (document.getElementById(n)) return;
+    const r = document.createElement("style");
+    r.id = n, r.textContent = `
+      ::highlight(answer-masked-${e}) {
+        opacity: 0.2;
+        filter: blur(2px);
+      }
+    `, document.head.appendChild(r);
+  }
+  removeHighlightCSS(e) {
+    document.getElementById(`answer-eliminator-mask-highlight-${e}`)?.remove();
+  }
+  removeCSS() {
+    document.getElementById("answer-eliminator-mask-styles")?.remove();
+  }
+  addAriaAttributes(e) {
+    const n = this.findChoiceContainer(e);
+    n && (n.setAttribute("data-eliminated", "true"), n.setAttribute("aria-hidden", "true"));
+  }
+  removeAriaAttributes(e) {
+    const n = this.findChoiceContainer(e);
+    n && (n.removeAttribute("data-eliminated"), n.removeAttribute("aria-hidden"));
+  }
+  findChoiceContainer(e) {
+    let n = e.startContainer;
+    for (n.nodeType === Node.TEXT_NODE && (n = n.parentElement); n && n !== document.body; ) {
+      if (n.classList?.contains("choice-input"))
+        return n;
+      n = n.parentElement;
+    }
+    return null;
+  }
+  applyFallback(e, n) {
+    const r = this.findChoiceContainer(n);
+    r && (r.classList.add("answer-masked-fallback"), r.setAttribute("data-eliminated", "true"), r.setAttribute("data-eliminated-id", e), this.addAriaAttributes(n));
+  }
+  removeFallback(e) {
+    const n = document.querySelector(
+      `[data-eliminated-id="${e}"]`
+    );
+    if (!n) return;
+    n.classList.remove("answer-masked-fallback"), n.removeAttribute("data-eliminated"), n.removeAttribute("data-eliminated-id");
+    const r = document.createRange();
+    r.selectNodeContents(n), this.removeAriaAttributes(r);
+  }
+}
+class wi {
+  constructor() {
+    g(this, "name", "strikethrough");
+    g(this, "highlights", /* @__PURE__ */ new Map());
+    g(this, "ranges", /* @__PURE__ */ new Map());
+  }
+  initialize() {
+    if (!this.isSupported()) {
+      console.warn("CSS Custom Highlight API not supported, using fallback");
+      return;
+    }
+    this.injectCSS();
+  }
+  destroy() {
+    this.clearAll(), this.removeCSS();
+  }
+  apply(e, n) {
+    if (!this.isSupported()) {
+      this.applyFallback(e, n);
+      return;
+    }
+    this.injectHighlightCSS(e);
+    const r = new Highlight(n);
+    CSS.highlights.set(`answer-eliminated-${e}`, r), this.highlights.set(e, r), this.ranges.set(e, n), this.addAriaAttributes(n);
+  }
+  remove(e) {
+    if (!this.isSupported()) {
+      this.removeFallback(e);
+      return;
+    }
+    CSS.highlights.delete(`answer-eliminated-${e}`), this.removeHighlightCSS(e);
+    const n = this.ranges.get(e);
+    n && this.removeAriaAttributes(n), this.highlights.delete(e), this.ranges.delete(e);
+  }
+  isEliminated(e) {
+    return this.highlights.has(e);
+  }
+  clearAll() {
+    for (const e of this.highlights.keys())
+      this.remove(e);
+  }
+  getEliminatedIds() {
+    return Array.from(this.highlights.keys());
+  }
+  isSupported() {
+    return typeof CSS < "u" && "highlights" in CSS;
+  }
+  injectCSS() {
+    const e = "answer-eliminator-strikethrough-styles";
+    if (document.getElementById(e)) return;
+    const n = document.createElement("style");
+    n.id = e, n.textContent = `
+      /* Fallback for browsers without CSS Highlight API */
+      .answer-eliminated-fallback {
+        text-decoration: line-through;
+        text-decoration-thickness: 2px;
+        text-decoration-color: var(--pie-incorrect, #ff9800);
+        opacity: 0.6;
+      }
+
+      /* Screen reader only text */
+      .sr-announcement {
+        position: absolute;
+        left: -10000px;
+        width: 1px;
+        height: 1px;
+        overflow: hidden;
+      }
+    `, document.head.appendChild(n);
+  }
+  injectHighlightCSS(e) {
+    const n = `answer-eliminator-highlight-${e}`;
+    if (document.getElementById(n)) return;
+    const r = document.createElement("style");
+    r.id = n, r.textContent = `
+      ::highlight(answer-eliminated-${e}) {
+        text-decoration: line-through;
+        text-decoration-thickness: 2px;
+        text-decoration-color: var(--pie-incorrect, #ff9800);
+        opacity: 0.6;
+      }
+    `, document.head.appendChild(r);
+  }
+  removeHighlightCSS(e) {
+    document.getElementById(`answer-eliminator-highlight-${e}`)?.remove();
+  }
+  removeCSS() {
+    document.getElementById(
+      "answer-eliminator-strikethrough-styles"
+    )?.remove();
+  }
+  addAriaAttributes(e) {
+    const n = this.findChoiceContainer(e);
+    if (!n) return;
+    n.setAttribute("data-eliminated", "true"), n.setAttribute("aria-disabled", "true");
+    const r = n.querySelector(".label");
+    if (r && !r.querySelector(".sr-announcement")) {
+      const i = document.createElement("span");
+      i.className = "sr-announcement", i.textContent = " (eliminated)", r.appendChild(i);
+    }
+  }
+  removeAriaAttributes(e) {
+    const n = this.findChoiceContainer(e);
+    if (!n) return;
+    n.removeAttribute("data-eliminated"), n.removeAttribute("aria-disabled"), n.querySelector(".sr-announcement")?.remove();
+  }
+  findChoiceContainer(e) {
+    let n = e.startContainer;
+    for (n.nodeType === Node.TEXT_NODE && (n = n.parentElement); n && n !== document.body; ) {
+      if (n.classList?.contains("choice-input") || n.classList?.contains("corespring-checkbox") || n.classList?.contains("corespring-radio-button"))
+        return n;
+      n = n.parentElement;
+    }
+    return null;
+  }
+  // Fallback for browsers without CSS Highlight API
+  applyFallback(e, n) {
+    const r = this.findChoiceContainer(n);
+    r && (r.classList.add("answer-eliminated-fallback"), r.setAttribute("data-eliminated", "true"), r.setAttribute("data-eliminated-id", e), this.addAriaAttributes(n));
+  }
+  removeFallback(e) {
+    const n = document.querySelector(
+      `[data-eliminated-id="${e}"]`
+    );
+    if (!n) return;
+    n.classList.remove("answer-eliminated-fallback"), n.removeAttribute("data-eliminated"), n.removeAttribute("data-eliminated-id");
+    const r = document.createRange();
+    r.selectNodeContents(n), this.removeAriaAttributes(r);
+  }
+}
+class Ei {
+  constructor(e = "strikethrough", n = "right") {
+    g(this, "registry");
+    g(this, "strategy");
+    g(this, "eliminatedChoices", /* @__PURE__ */ new Set());
+    // Set<choiceId> for current element
+    g(this, "choiceElements", /* @__PURE__ */ new Map());
+    // choiceId -> element
+    g(this, "choiceButtons", /* @__PURE__ */ new Map());
+    // choiceId -> button
+    g(this, "buttonAlignment", "right");
+    g(this, "shouldRestoreState", !0);
+    // Whether to restore eliminations from state storage
+    // Store integration (replaces session/localStorage)
+    g(this, "storeIntegration", null);
+    this.registry = new yi(), this.strategy = this.createStrategy(e), this.strategy.initialize(), this.buttonAlignment = n;
+  }
+  createStrategy(e) {
+    return e === "mask" ? new bi() : new wi();
+  }
+  /**
+   * Initialize eliminator for a question
+   */
+  initializeForQuestion(e) {
+    this.cleanupButtons();
+    const n = this.registry.findAllChoicesWithAdapters(e);
+    for (const { choice: r, adapter: i } of n)
+      this.initializeChoice(r, i);
+    this.shouldRestoreState && this.restoreState();
+  }
+  /**
+   * Initialize a single choice
+   */
+  initializeChoice(e, n) {
+    const r = n.getChoiceId(e);
+    this.choiceElements.set(r, e);
+    const i = this.createToggleButton(e, n);
+    if (!i) return;
+    this.choiceButtons.set(r, i);
+    const s = n.getButtonContainer(e);
+    s && (s.style.position = "relative", s.appendChild(i));
+  }
+  /**
+   * Create elimination toggle button
+   */
+  createToggleButton(e, n) {
+    const r = n.getChoiceId(e), i = n.getChoiceLabel(e), s = document.createElement("button");
+    return s.type = "button", s.className = "answer-eliminator-toggle", s.setAttribute("aria-label", `Toggle elimination for ${i}`), s.setAttribute("data-choice-id", r), s.textContent = "⊗", this.applyButtonAlignment(s), Object.assign(s.style, {
+      width: "28px",
+      height: "28px",
+      padding: "0",
+      border: "1px solid #ccc",
+      borderRadius: "4px",
+      background: "white",
+      cursor: "pointer",
+      fontSize: "18px",
+      lineHeight: "1",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      color: "#666",
+      transition: "all 0.2s ease",
+      zIndex: "10"
+    }), s.addEventListener("mouseenter", () => {
+      s.style.background = "#f0f0f0", s.style.borderColor = "#999", s.style.color = "#333";
+    }), s.addEventListener("mouseleave", () => {
+      this.strategy.isEliminated(r) || (s.style.background = "white", s.style.borderColor = "#ccc", s.style.color = "#666");
+    }), s.addEventListener("click", (l) => {
+      l.preventDefault(), l.stopPropagation(), this.toggleElimination(e, n);
+    }), s;
+  }
+  /**
+   * Toggle elimination for a choice
+   */
+  toggleElimination(e, n) {
+    const r = n.getChoiceId(e);
+    if (this.strategy.isEliminated(r))
+      this.restoreChoice(r);
+    else {
+      if (!n.canEliminate(e)) {
+        console.warn(
+          "Cannot eliminate this choice (already selected or in evaluate mode)"
+        );
+        return;
+      }
+      this.eliminateChoice(e, n);
+    }
+    this.saveState(), this.emitStateChange();
+  }
+  /**
+   * Eliminate a choice
+   */
+  eliminateChoice(e, n) {
+    const r = n.getChoiceId(e), i = n.createChoiceRange(e);
+    if (!i) {
+      console.error("Failed to create range for choice");
+      return;
+    }
+    this.strategy.apply(r, i), this.eliminatedChoices.add(r);
+    const s = this.choiceButtons.get(r);
+    s && (s.classList.add("active"), s.setAttribute("aria-pressed", "true"), s.style.background = "#ff9800", s.style.borderColor = "#ff9800", s.style.color = "white"), this.saveState();
+  }
+  /**
+   * Restore a choice
+   */
+  restoreChoice(e) {
+    this.strategy.remove(e), this.eliminatedChoices.delete(e);
+    const n = this.choiceButtons.get(e);
+    n && (n.classList.remove("active"), n.setAttribute("aria-pressed", "false"), n.style.background = "white", n.style.borderColor = "#ccc", n.style.color = "#666"), this.saveState();
+  }
+  /**
+   * Reset all eliminations for current element
+   */
+  resetAll() {
+    if (this.eliminatedChoices.size !== 0) {
+      for (const e of Array.from(this.eliminatedChoices))
+        this.restoreChoice(e);
+      this.eliminatedChoices.clear(), this.saveState(), this.emitStateChange();
+    }
+  }
+  /**
+   * Get count of eliminated choices for current element
+   */
+  getEliminatedCount() {
+    return this.eliminatedChoices.size;
+  }
+  /**
+   * Set store integration for element-level state
+   * @param store ElementToolStateStore instance
+   * @param globalElementId Composite key: "assessmentId:sectionId:itemId:elementId"
+   */
+  setStoreIntegration(e, n) {
+    this.storeIntegration = { store: e, globalElementId: n };
+  }
+  /**
+   * Save state to ElementToolStateStore
+   */
+  saveState() {
+    if (!this.storeIntegration) return;
+    const e = {
+      eliminatedChoices: Array.from(this.eliminatedChoices)
+    };
+    this.storeIntegration.store.setState(
+      this.storeIntegration.globalElementId,
+      "answerEliminator",
+      e
+    );
+  }
+  /**
+   * Restore state from ElementToolStateStore
+   */
+  restoreState() {
+    if (!this.storeIntegration) return;
+    const e = this.storeIntegration.store.getState(
+      this.storeIntegration.globalElementId,
+      "answerEliminator"
+    );
+    if (!(!e || !e.eliminatedChoices))
+      try {
+        const n = e.eliminatedChoices;
+        if (!n || n.length === 0) return;
+        for (const r of n) {
+          const i = this.choiceElements.get(r);
+          if (!i) continue;
+          const s = this.findAdapterForChoice(i);
+          if (!s) continue;
+          const l = s.createChoiceRange(i);
+          if (l) {
+            this.strategy.apply(r, l), this.eliminatedChoices.add(r);
+            const a = this.choiceButtons.get(r);
+            a && (a.classList.add("active"), a.setAttribute("aria-pressed", "true"), a.style.background = "#ff9800", a.style.borderColor = "#ff9800", a.style.color = "white");
+          }
+        }
+      } catch (n) {
+        console.error("Failed to restore eliminator state:", n);
+      }
+  }
+  /**
+   * Find adapter for a choice element
+   */
+  findAdapterForChoice(e) {
+    let n = e;
+    for (; n && n !== document.body; ) {
+      const r = this.registry.findAdapter(n);
+      if (r) return r;
+      n = n.parentElement;
+    }
+    return null;
+  }
+  /**
+   * Cleanup buttons from previous element
+   */
+  cleanupButtons() {
+    for (const e of this.choiceButtons.values())
+      e.remove();
+    this.choiceButtons.clear(), this.choiceElements.clear();
+  }
+  /**
+   * Apply button positioning based on alignment configuration
+   */
+  applyButtonAlignment(e) {
+    switch (this.buttonAlignment) {
+      case "right":
+        Object.assign(e.style, {
+          position: "absolute",
+          right: "8px",
+          top: "50%",
+          transform: "translateY(-50%)"
+        });
+        break;
+      case "left":
+        Object.assign(e.style, {
+          position: "absolute",
+          left: "8px",
+          top: "50%",
+          transform: "translateY(-50%)"
+        });
+        break;
+      case "inline":
+        Object.assign(e.style, {
+          position: "relative",
+          marginLeft: "8px",
+          marginRight: "8px",
+          display: "inline-flex",
+          verticalAlign: "middle"
+        });
+        break;
+    }
+  }
+  /**
+   * Enable state restoration from localStorage
+   */
+  enableStateRestoration() {
+    this.shouldRestoreState = !0;
+  }
+  /**
+   * Disable state restoration from localStorage
+   */
+  disableStateRestoration() {
+    this.shouldRestoreState = !1;
+  }
+  /**
+   * Cleanup when tool is turned off (but don't destroy strategy)
+   * Hides elimination buttons AND clears all visual eliminations
+   * Note: State is preserved in localStorage for when tool is turned back on
+   */
+  cleanup() {
+    this.disableStateRestoration(), this.cleanupButtons(), this.strategy.clearAll();
+  }
+  /**
+   * Emit state change event for UI updates
+   */
+  emitStateChange() {
+    const e = new CustomEvent("answer-eliminator-state-change", {
+      detail: {
+        questionId: this.currentQuestionId,
+        eliminatedCount: this.getEliminatedCount()
+      },
+      bubbles: !0
+    });
+    document.dispatchEvent(e);
+  }
+  /**
+   * Destroy and cleanup
+   */
+  destroy() {
+    this.cleanupButtons(), this.strategy.destroy();
+  }
+}
+function $i(t, e) {
+  mn(e, !0);
+  let n = re(e, "visible", 7, !1), r = re(e, "toolId", 7, "answerEliminator"), i = re(e, "strategy", 7, "strikethrough"), s = re(
+    e,
+    "alwaysOn",
+    7,
+    !1
+    // Set true for profile-based accommodation
+  ), l = re(
+    e,
+    "buttonAlignment",
+    7,
+    "right"
+    // Button placement: left, right, or inline with checkbox
+  ), a = re(e, "coordinator"), u = re(
+    e,
+    "scopeElement",
+    7,
+    null
+    // Container element to limit DOM queries (for multi-item pages)
+  ), c = re(
+    e,
+    "elementToolStateStore",
+    7,
+    null
+    // ElementToolStateStore instance
+  ), h = re(
+    e,
+    "globalElementId",
+    7,
+    ""
+    // Composite key: "assessmentId:sectionId:itemId:elementId"
+  ), f = /* @__PURE__ */ Y(null), d = /* @__PURE__ */ Y(0), p = /* @__PURE__ */ Y(null), m = /* @__PURE__ */ Y(!1), I = /* @__PURE__ */ Hr(() => s() || n());
+  function S() {
+    if (!y(I) || !y(f)) return;
+    const E = u() || document.body, it = E.querySelector("pie-player") || E.querySelector("multiple-choice") || E.querySelector("ebsr") || E.querySelector("[data-pie-element]") || E;
+    if (!it) {
+      console.warn("[AnswerEliminator] Could not find question root within scope");
+      return;
+    }
+    y(f).initializeForQuestion(it), At();
+  }
+  function Ue(E, it = 5e3) {
+    const Ve = u() || document.body, kt = () => Ve.querySelector("pie-player") || Ve.querySelector("multiple-choice") || Ve.querySelector("ebsr") || Ve.querySelector("[data-pie-element]") ? (y(p) && (y(p).disconnect(), k(p, null)), E(), !0) : !1;
+    kt() || (k(
+      p,
+      new MutationObserver(() => {
+        kt();
+      }),
+      !0
+    ), y(p).observe(Ve, { childList: !0, subtree: !0 }), setTimeout(
+      () => {
+        y(p) && (y(p).disconnect(), k(p, null), kt());
+      },
+      it
+    ));
+  }
+  function Oe() {
+    Ue(() => {
+      S();
+    });
+  }
+  function At() {
+    k(d, y(f)?.getEliminatedCount() || 0, !0);
+  }
+  ct(() => {
+    a() && r() && !y(m) && (a().registerTool(r(), "Answer Eliminator", void 0, jt.MODAL), k(m, !0));
+  }), ct(() => {
+    y(f) && c() && h() && y(f).setStoreIntegration(c(), h());
+  }), fi(() => (k(f, new Ei(i(), l()), !0), y(f) && c() && h() && y(f).setStoreIntegration(c(), h()), document.addEventListener("pie-item-changed", Oe), document.addEventListener("answer-eliminator-state-change", () => {
+    At();
+  }), y(I) ? Ue(() => {
+    S();
+  }) : y(f).cleanup(), () => {
+    y(p) && (y(p).disconnect(), k(p, null)), y(f)?.destroy(), k(f, null), a() && r() && a().unregisterTool(r()), document.removeEventListener("pie-item-changed", Oe), document.removeEventListener("answer-eliminator-state-change", At);
+  })), ct(() => {
+    y(f) && (y(I) ? (y(f).enableStateRestoration(), S()) : y(f).cleanup());
+  });
+  var lr = {
+    get visible() {
+      return n();
+    },
+    set visible(E = !1) {
+      n(E), Q();
+    },
+    get toolId() {
+      return r();
+    },
+    set toolId(E = "answerEliminator") {
+      r(E), Q();
+    },
+    get strategy() {
+      return i();
+    },
+    set strategy(E = "strikethrough") {
+      i(E), Q();
+    },
+    get alwaysOn() {
+      return s();
+    },
+    set alwaysOn(E = !1) {
+      s(E), Q();
+    },
+    get buttonAlignment() {
+      return l();
+    },
+    set buttonAlignment(E = "right") {
+      l(E), Q();
+    },
+    get coordinator() {
+      return a();
+    },
+    set coordinator(E) {
+      a(E), Q();
+    },
+    get scopeElement() {
+      return u();
+    },
+    set scopeElement(E = null) {
+      u(E), Q();
+    },
+    get elementToolStateStore() {
+      return c();
+    },
+    set elementToolStateStore(E = null) {
+      c(E), Q();
+    },
+    get globalElementId() {
+      return h();
+    },
+    set globalElementId(E = "") {
+      h(E), Q();
+    }
+  };
+  return yn(lr);
+}
+customElements.define("pie-tool-answer-eliminator", gi(
+  $i,
+  {
+    visible: { attribute: "visible", type: "Boolean" },
+    toolId: { attribute: "tool-id", type: "String" },
+    strategy: { attribute: "strategy", type: "String" },
+    alwaysOn: { attribute: "always-on", type: "Boolean" },
+    buttonAlignment: { attribute: "button-alignment", type: "String" },
+    coordinator: { type: "Object" },
+    scopeElement: { type: "Object" },
+    elementToolStateStore: { type: "Object" },
+    globalElementId: { type: "String" }
+  },
+  [],
+  []
+));
+export {
+  $i as default
+};
+//# sourceMappingURL=tool-answer-eliminator.js.map