@pie-players/pie-section-tools-toolbar 0.2.0

package/dist/section-tools-toolbar.js

@@ -0,0 +1,2957 @@
+var Fi = Object.defineProperty;
+var on = (e) => {
+  throw TypeError(e);
+};
+var Ii = (e, t, r) => t in e ? Fi(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var k = (e, t, r) => Ii(e, typeof t != "symbol" ? t + "" : t, r), $r = (e, t, r) => t.has(e) || on("Cannot " + r);
+var a = (e, t, r) => ($r(e, t, "read from private field"), r ? r.call(e) : t.get(e)), m = (e, t, r) => t.has(e) ? on("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), b = (e, t, r, i) => ($r(e, t, "write to private field"), i ? i.call(e, r) : t.set(e, r), r), M = (e, t, r) => ($r(e, t, "access private method"), r);
+import "@pie-players/pie-tool-calculator";
+import "@pie-players/pie-tool-graph";
+import "@pie-players/pie-tool-periodic-table";
+import "@pie-players/pie-tool-protractor";
+import "@pie-players/pie-tool-line-reader";
+import "@pie-players/pie-tool-magnifier";
+import "@pie-players/pie-tool-ruler";
+const Vi = "5";
+var $n;
+typeof window < "u" && (($n = window.__svelte ?? (window.__svelte = {})).v ?? ($n.v = /* @__PURE__ */ new Set())).add(Vi);
+const ji = 1, qi = 2, Bi = 16, Hi = 1, Yi = 2, yn = "[", or = "[!", Vr = "]", Et = {}, F = /* @__PURE__ */ Symbol(), Ui = "http://www.w3.org/1999/xhtml", Tr = !1;
+var En = Array.isArray, zi = Array.prototype.indexOf, Tt = Array.prototype.includes, ar = Array.from, er = Object.keys, tr = Object.defineProperty, vt = Object.getOwnPropertyDescriptor, Gi = Object.getOwnPropertyDescriptors, Ki = Object.prototype, Wi = Array.prototype, Tn = Object.getPrototypeOf, an = Object.isExtensible;
+function Ji(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function xn() {
+  var e, t, r = new Promise((i, n) => {
+    e = i, t = n;
+  });
+  return { promise: r, resolve: e, reject: t };
+}
+const I = 2, rr = 4, fr = 8, Sn = 1 << 24, Ie = 16, be = 32, We = 64, jr = 128, fe = 512, D = 1024, H = 2048, Ve = 4096, re = 8192, Me = 16384, ur = 32768, xt = 65536, fn = 1 << 17, Rn = 1 << 18, ct = 1 << 19, Xi = 1 << 20, Ue = 1 << 25, at = 32768, xr = 1 << 21, qr = 1 << 22, ze = 1 << 23, Gt = /* @__PURE__ */ Symbol("$state"), Zi = /* @__PURE__ */ Symbol("legacy props"), Qi = /* @__PURE__ */ Symbol(""), ht = new class extends Error {
+  constructor() {
+    super(...arguments);
+    k(this, "name", "StaleReactionError");
+    k(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), cr = 3, kt = 8;
+function An(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function es() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function ts(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function rs() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function ns(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function is() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function ss() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function ls() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function os() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function as() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function fs() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function dr(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function us() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let T = !1;
+function pe(e) {
+  T = e;
+}
+let x;
+function z(e) {
+  if (e === null)
+    throw dr(), Et;
+  return x = e;
+}
+function hr() {
+  return z(/* @__PURE__ */ Se(x));
+}
+function Ct(e) {
+  if (T) {
+    if (/* @__PURE__ */ Se(x) !== null)
+      throw dr(), Et;
+    x = e;
+  }
+}
+function cs(e = 1) {
+  if (T) {
+    for (var t = e, r = x; t--; )
+      r = /** @type {TemplateNode} */
+      /* @__PURE__ */ Se(r);
+    x = r;
+  }
+}
+function nr(e = !0) {
+  for (var t = 0, r = x; ; ) {
+    if (r.nodeType === kt) {
+      var i = (
+        /** @type {Comment} */
+        r.data
+      );
+      if (i === Vr) {
+        if (t === 0) return r;
+        t -= 1;
+      } else (i === yn || i === or) && (t += 1);
+    }
+    var n = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Se(r)
+    );
+    e && r.remove(), r = n;
+  }
+}
+function kn(e) {
+  if (!e || e.nodeType !== kt)
+    throw dr(), Et;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function Cn(e) {
+  return e === this.v;
+}
+function ds(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function Nn(e) {
+  return !ds(e, this.v);
+}
+let hs = !1, G = null;
+function St(e) {
+  G = e;
+}
+function On(e, t = !1, r) {
+  G = {
+    p: G,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function Pn(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    G
+  ), r = t.e;
+  if (r !== null) {
+    t.e = null;
+    for (var i of r)
+      ni(i);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, G = t.p, e ?? /** @type {T} */
+  {};
+}
+function Ln() {
+  return !0;
+}
+let Xe = [];
+function Mn() {
+  var e = Xe;
+  Xe = [], Ji(e);
+}
+function st(e) {
+  if (Xe.length === 0 && !Lt) {
+    var t = Xe;
+    queueMicrotask(() => {
+      t === Xe && Mn();
+    });
+  }
+  Xe.push(e);
+}
+function vs() {
+  for (; Xe.length > 0; )
+    Mn();
+}
+function Dn(e) {
+  var t = y;
+  if (t === null)
+    return w.f |= ze, e;
+  if ((t.f & ur) === 0) {
+    if ((t.f & jr) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    Rt(e, t);
+}
+function Rt(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & jr) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (r) {
+        e = r;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const _s = -7169;
+function P(e, t) {
+  e.f = e.f & _s | t;
+}
+function Br(e) {
+  (e.f & fe) !== 0 || e.deps === null ? P(e, D) : P(e, Ve);
+}
+function Fn(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & I) === 0 || (t.f & at) === 0 || (t.f ^= at, Fn(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function In(e, t, r) {
+  (e.f & H) !== 0 ? t.add(e) : (e.f & Ve) !== 0 && r.add(e), Fn(e.deps), P(e, D);
+}
+const Yt = /* @__PURE__ */ new Set();
+let R = null, _e = null, te = [], vr = null, Sr = !1, Lt = !1;
+var pt, gt, Qe, bt, Ft, It, et, mt, xe, Rr, Ar, Vn;
+const Wr = class Wr {
+  constructor() {
+    m(this, xe);
+    k(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>}
+     */
+    k(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>}
+     */
+    k(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>}
+     */
+    m(this, pt, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    m(this, gt, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    m(this, Qe, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    m(this, bt, 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}
+     */
+    m(this, Ft, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    m(this, It, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    m(this, et, /* @__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>}
+     */
+    k(this, "skipped_effects", /* @__PURE__ */ new Set());
+    k(this, "is_fork", !1);
+    m(this, mt, !1);
+  }
+  is_deferred() {
+    return this.is_fork || a(this, bt) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    te = [], this.apply();
+    var r = [], i = [];
+    for (const n of t)
+      M(this, xe, Rr).call(this, n, r, i);
+    if (this.is_deferred()) {
+      M(this, xe, Ar).call(this, i), M(this, xe, Ar).call(this, r);
+      for (const n of this.skipped_effects)
+        Hn(n);
+    } else {
+      for (const n of a(this, pt)) n();
+      a(this, pt).clear(), a(this, Qe) === 0 && M(this, xe, Vn).call(this), R = null, un(i), un(r), a(this, Ft)?.resolve();
+    }
+    _e = 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, r) {
+    r !== F && !this.previous.has(t) && this.previous.set(t, r), (t.f & ze) === 0 && (this.current.set(t, t.v), _e?.set(t, t.v));
+  }
+  activate() {
+    R = this, this.apply();
+  }
+  deactivate() {
+    R === this && (R = null, _e = null);
+  }
+  flush() {
+    if (this.activate(), te.length > 0) {
+      if (jn(), R !== null && R !== this)
+        return;
+    } else a(this, Qe) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of a(this, gt)) t(this);
+    a(this, gt).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    b(this, Qe, a(this, Qe) + 1), t && b(this, bt, a(this, bt) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    b(this, Qe, a(this, Qe) - 1), t && b(this, bt, a(this, bt) - 1), !a(this, mt) && (b(this, mt, !0), st(() => {
+      b(this, mt, !1), this.is_deferred() ? te.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of a(this, It))
+      a(this, et).delete(t), P(t, H), Fe(t);
+    for (const t of a(this, et))
+      P(t, Ve), Fe(t);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    a(this, pt).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    a(this, gt).add(t);
+  }
+  settled() {
+    return (a(this, Ft) ?? b(this, Ft, xn())).promise;
+  }
+  static ensure() {
+    if (R === null) {
+      const t = R = new Wr();
+      Yt.add(R), Lt || st(() => {
+        R === t && t.flush();
+      });
+    }
+    return R;
+  }
+  apply() {
+  }
+};
+pt = new WeakMap(), gt = new WeakMap(), Qe = new WeakMap(), bt = new WeakMap(), Ft = new WeakMap(), It = new WeakMap(), et = new WeakMap(), mt = new WeakMap(), xe = 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
+ */
+Rr = function(t, r, i) {
+  t.f ^= D;
+  for (var n = t.first, s = null; n !== null; ) {
+    var l = n.f, o = (l & (be | We)) !== 0, f = o && (l & D) !== 0, u = f || (l & re) !== 0 || this.skipped_effects.has(n);
+    if (!u && n.fn !== null) {
+      o ? n.f ^= D : s !== null && (l & (rr | fr | Sn)) !== 0 ? s.b.defer_effect(n) : (l & rr) !== 0 ? r.push(n) : Bt(n) && ((l & Ie) !== 0 && a(this, et).add(n), Dt(n));
+      var d = n.first;
+      if (d !== null) {
+        n = d;
+        continue;
+      }
+    }
+    var v = n.parent;
+    for (n = n.next; n === null && v !== null; )
+      v === s && (s = null), n = v.next, v = v.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+Ar = function(t) {
+  for (var r = 0; r < t.length; r += 1)
+    In(t[r], a(this, It), a(this, et));
+}, Vn = function() {
+  var n;
+  if (Yt.size > 1) {
+    this.previous.clear();
+    var t = _e, r = !0;
+    for (const s of Yt) {
+      if (s === this) {
+        r = !1;
+        continue;
+      }
+      const l = [];
+      for (const [f, u] of this.current) {
+        if (s.current.has(f))
+          if (r && u !== s.current.get(f))
+            s.current.set(f, u);
+          else
+            continue;
+        l.push(f);
+      }
+      if (l.length === 0)
+        continue;
+      const o = [...s.current.keys()].filter((f) => !this.current.has(f));
+      if (o.length > 0) {
+        var i = te;
+        te = [];
+        const f = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map();
+        for (const d of l)
+          qn(d, o, f, u);
+        if (te.length > 0) {
+          R = s, s.apply();
+          for (const d of te)
+            M(n = s, xe, Rr).call(n, d, [], []);
+          s.deactivate();
+        }
+        te = i;
+      }
+    }
+    R = null, _e = t;
+  }
+  this.committed = !0, Yt.delete(this);
+};
+let De = Wr;
+function Kt(e) {
+  var t = Lt;
+  Lt = !0;
+  try {
+    for (var r; ; ) {
+      if (vs(), te.length === 0 && (R?.flush(), te.length === 0))
+        return vr = null, /** @type {T} */
+        r;
+      jn();
+    }
+  } finally {
+    Lt = t;
+  }
+}
+function jn() {
+  Sr = !0;
+  var e = null;
+  try {
+    for (var t = 0; te.length > 0; ) {
+      var r = De.ensure();
+      if (t++ > 1e3) {
+        var i, n;
+        ps();
+      }
+      r.process(te), Ge.clear();
+    }
+  } finally {
+    Sr = !1, vr = null;
+  }
+}
+function ps() {
+  try {
+    is();
+  } catch (e) {
+    Rt(e, vr);
+  }
+}
+let Ce = null;
+function un(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var r = 0; r < t; ) {
+      var i = e[r++];
+      if ((i.f & (Me | re)) === 0 && Bt(i) && (Ce = /* @__PURE__ */ new Set(), Dt(i), i.deps === null && i.first === null && i.nodes === null && (i.teardown === null && i.ac === null ? oi(i) : i.fn = null), Ce?.size > 0)) {
+        Ge.clear();
+        for (const n of Ce) {
+          if ((n.f & (Me | re)) !== 0) continue;
+          const s = [n];
+          let l = n.parent;
+          for (; l !== null; )
+            Ce.has(l) && (Ce.delete(l), s.push(l)), l = l.parent;
+          for (let o = s.length - 1; o >= 0; o--) {
+            const f = s[o];
+            (f.f & (Me | re)) === 0 && Dt(f);
+          }
+        }
+        Ce.clear();
+      }
+    }
+    Ce = null;
+  }
+}
+function qn(e, t, r, i) {
+  if (!r.has(e) && (r.add(e), e.reactions !== null))
+    for (const n of e.reactions) {
+      const s = n.f;
+      (s & I) !== 0 ? qn(
+        /** @type {Derived} */
+        n,
+        t,
+        r,
+        i
+      ) : (s & (qr | Ie)) !== 0 && (s & H) === 0 && Bn(n, t, i) && (P(n, H), Fe(
+        /** @type {Effect} */
+        n
+      ));
+    }
+}
+function Bn(e, t, r) {
+  const i = r.get(e);
+  if (i !== void 0) return i;
+  if (e.deps !== null)
+    for (const n of e.deps) {
+      if (Tt.call(t, n))
+        return !0;
+      if ((n.f & I) !== 0 && Bn(
+        /** @type {Derived} */
+        n,
+        t,
+        r
+      ))
+        return r.set(
+          /** @type {Derived} */
+          n,
+          !0
+        ), !0;
+    }
+  return r.set(e, !1), !1;
+}
+function Fe(e) {
+  for (var t = vr = e; t.parent !== null; ) {
+    t = t.parent;
+    var r = t.f;
+    if (Sr && t === y && (r & Ie) !== 0 && (r & Rn) === 0)
+      return;
+    if ((r & (We | be)) !== 0) {
+      if ((r & D) === 0) return;
+      t.f ^= D;
+    }
+  }
+  te.push(t);
+}
+function Hn(e) {
+  if (!((e.f & be) !== 0 && (e.f & D) !== 0)) {
+    P(e, D);
+    for (var t = e.first; t !== null; )
+      Hn(t), t = t.next;
+  }
+}
+function gs(e) {
+  let t = 0, r = ft(0), i;
+  return () => {
+    Ur() && (_(r), zr(() => (t === 0 && (i = pr(() => e(() => Mt(r)))), t += 1, () => {
+      st(() => {
+        t -= 1, t === 0 && (i?.(), i = void 0, Mt(r));
+      });
+    })));
+  };
+}
+var bs = xt | ct | jr;
+function ms(e, t, r) {
+  new ws(e, t, r);
+}
+var Q, Vt, $e, tt, ye, le, Y, Ee, Ne, Ye, rt, Oe, wt, nt, $t, yt, Pe, sr, N, Yn, Un, kr, Wt, Jt, Cr;
+class ws {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   */
+  constructor(t, r, i) {
+    m(this, N);
+    /** @type {Boundary | null} */
+    k(this, "parent");
+    k(this, "is_pending", !1);
+    /** @type {TemplateNode} */
+    m(this, Q);
+    /** @type {TemplateNode | null} */
+    m(this, Vt, T ? x : null);
+    /** @type {BoundaryProps} */
+    m(this, $e);
+    /** @type {((anchor: Node) => void)} */
+    m(this, tt);
+    /** @type {Effect} */
+    m(this, ye);
+    /** @type {Effect | null} */
+    m(this, le, null);
+    /** @type {Effect | null} */
+    m(this, Y, null);
+    /** @type {Effect | null} */
+    m(this, Ee, null);
+    /** @type {DocumentFragment | null} */
+    m(this, Ne, null);
+    /** @type {TemplateNode | null} */
+    m(this, Ye, null);
+    m(this, rt, 0);
+    m(this, Oe, 0);
+    m(this, wt, !1);
+    m(this, nt, !1);
+    /** @type {Set<Effect>} */
+    m(this, $t, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    m(this, yt, /* @__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}
+     */
+    m(this, Pe, null);
+    m(this, sr, gs(() => (b(this, Pe, ft(a(this, rt))), () => {
+      b(this, Pe, null);
+    })));
+    b(this, Q, t), b(this, $e, r), b(this, tt, i), this.parent = /** @type {Effect} */
+    y.b, this.is_pending = !!a(this, $e).pending, b(this, ye, Gr(() => {
+      if (y.b = this, T) {
+        const s = a(this, Vt);
+        hr(), /** @type {Comment} */
+        s.nodeType === kt && /** @type {Comment} */
+        s.data === or ? M(this, N, Un).call(this) : (M(this, N, Yn).call(this), a(this, Oe) === 0 && (this.is_pending = !1));
+      } else {
+        var n = M(this, N, kr).call(this);
+        try {
+          b(this, le, ae(() => i(n)));
+        } catch (s) {
+          this.error(s);
+        }
+        a(this, Oe) > 0 ? M(this, N, Jt).call(this) : this.is_pending = !1;
+      }
+      return () => {
+        a(this, Ye)?.remove();
+      };
+    }, bs)), T && b(this, Q, x);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    In(t, a(this, $t), a(this, yt));
+  }
+  /**
+   * 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 !!a(this, $e).pending;
+  }
+  /**
+   * Update the source that powers `$effect.pending()` inside this boundary,
+   * and controls when the current `pending` snippet (if any) is removed.
+   * Do not call from inside the class
+   * @param {1 | -1} d
+   */
+  update_pending_count(t) {
+    M(this, N, Cr).call(this, t), b(this, rt, a(this, rt) + t), !(!a(this, Pe) || a(this, wt)) && (b(this, wt, !0), st(() => {
+      b(this, wt, !1), a(this, Pe) && At(a(this, Pe), a(this, rt));
+    }));
+  }
+  get_effect_pending() {
+    return a(this, sr).call(this), _(
+      /** @type {Source<number>} */
+      a(this, Pe)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var r = a(this, $e).onerror;
+    let i = a(this, $e).failed;
+    if (a(this, nt) || !r && !i)
+      throw t;
+    a(this, le) && (B(a(this, le)), b(this, le, null)), a(this, Y) && (B(a(this, Y)), b(this, Y, null)), a(this, Ee) && (B(a(this, Ee)), b(this, Ee, null)), T && (z(
+      /** @type {TemplateNode} */
+      a(this, Vt)
+    ), cs(), z(nr()));
+    var n = !1, s = !1;
+    const l = () => {
+      if (n) {
+        us();
+        return;
+      }
+      n = !0, s && fs(), De.ensure(), b(this, rt, 0), a(this, Ee) !== null && lt(a(this, Ee), () => {
+        b(this, Ee, null);
+      }), this.is_pending = this.has_pending_snippet(), b(this, le, M(this, N, Wt).call(this, () => (b(this, nt, !1), ae(() => a(this, tt).call(this, a(this, Q)))))), a(this, Oe) > 0 ? M(this, N, Jt).call(this) : this.is_pending = !1;
+    };
+    st(() => {
+      try {
+        s = !0, r?.(t, l), s = !1;
+      } catch (o) {
+        Rt(o, a(this, ye) && a(this, ye).parent);
+      }
+      i && b(this, Ee, M(this, N, Wt).call(this, () => {
+        De.ensure(), b(this, nt, !0);
+        try {
+          return ae(() => {
+            i(
+              a(this, Q),
+              () => t,
+              () => l
+            );
+          });
+        } catch (o) {
+          return Rt(
+            o,
+            /** @type {Effect} */
+            a(this, ye).parent
+          ), null;
+        } finally {
+          b(this, nt, !1);
+        }
+      }));
+    });
+  }
+}
+Q = new WeakMap(), Vt = new WeakMap(), $e = new WeakMap(), tt = new WeakMap(), ye = new WeakMap(), le = new WeakMap(), Y = new WeakMap(), Ee = new WeakMap(), Ne = new WeakMap(), Ye = new WeakMap(), rt = new WeakMap(), Oe = new WeakMap(), wt = new WeakMap(), nt = new WeakMap(), $t = new WeakMap(), yt = new WeakMap(), Pe = new WeakMap(), sr = new WeakMap(), N = new WeakSet(), Yn = function() {
+  try {
+    b(this, le, ae(() => a(this, tt).call(this, a(this, Q))));
+  } catch (t) {
+    this.error(t);
+  }
+}, Un = function() {
+  const t = a(this, $e).pending;
+  t && (b(this, Y, ae(() => t(a(this, Q)))), st(() => {
+    var r = M(this, N, kr).call(this);
+    b(this, le, M(this, N, Wt).call(this, () => (De.ensure(), ae(() => a(this, tt).call(this, r))))), a(this, Oe) > 0 ? M(this, N, Jt).call(this) : (lt(
+      /** @type {Effect} */
+      a(this, Y),
+      () => {
+        b(this, Y, null);
+      }
+    ), this.is_pending = !1);
+  }));
+}, kr = function() {
+  var t = a(this, Q);
+  return this.is_pending && (b(this, Ye, ue()), a(this, Q).before(a(this, Ye)), t = a(this, Ye)), t;
+}, /**
+ * @param {() => Effect | null} fn
+ */
+Wt = function(t) {
+  var r = y, i = w, n = G;
+  de(a(this, ye)), K(a(this, ye)), St(a(this, ye).ctx);
+  try {
+    return t();
+  } catch (s) {
+    return Dn(s), null;
+  } finally {
+    de(r), K(i), St(n);
+  }
+}, Jt = function() {
+  const t = (
+    /** @type {(anchor: Node) => void} */
+    a(this, $e).pending
+  );
+  a(this, le) !== null && (b(this, Ne, document.createDocumentFragment()), a(this, Ne).append(
+    /** @type {TemplateNode} */
+    a(this, Ye)
+  ), ui(a(this, le), a(this, Ne))), a(this, Y) === null && b(this, Y, ae(() => t(a(this, Q))));
+}, /**
+ * Updates the pending count associated with the currently visible pending snippet,
+ * if any, such that we can replace the snippet with content once work is done
+ * @param {1 | -1} d
+ */
+Cr = function(t) {
+  var r;
+  if (!this.has_pending_snippet()) {
+    this.parent && M(r = this.parent, N, Cr).call(r, t);
+    return;
+  }
+  if (b(this, Oe, a(this, Oe) + t), a(this, Oe) === 0) {
+    this.is_pending = !1;
+    for (const i of a(this, $t))
+      P(i, H), Fe(i);
+    for (const i of a(this, yt))
+      P(i, Ve), Fe(i);
+    a(this, $t).clear(), a(this, yt).clear(), a(this, Y) && lt(a(this, Y), () => {
+      b(this, Y, null);
+    }), a(this, Ne) && (a(this, Q).before(a(this, Ne)), b(this, Ne, null));
+  }
+};
+function $s(e, t, r, i) {
+  const n = _r;
+  var s = e.filter((c) => !c.settled);
+  if (r.length === 0 && s.length === 0) {
+    i(t.map(n));
+    return;
+  }
+  var l = R, o = (
+    /** @type {Effect} */
+    y
+  ), f = ys(), u = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((c) => c.promise)) : null;
+  function d(c) {
+    f();
+    try {
+      i(c);
+    } catch (p) {
+      (o.f & Me) === 0 && Rt(p, o);
+    }
+    l?.deactivate(), Nr();
+  }
+  if (r.length === 0) {
+    u.then(() => d(t.map(n)));
+    return;
+  }
+  function v() {
+    f(), Promise.all(r.map((c) => /* @__PURE__ */ Es(c))).then((c) => d([...t.map(n), ...c])).catch((c) => Rt(c, o));
+  }
+  u ? u.then(v) : v();
+}
+function ys() {
+  var e = y, t = w, r = G, i = R;
+  return function(s = !0) {
+    de(e), K(t), St(r), s && i?.activate();
+  };
+}
+function Nr() {
+  de(null), K(null), St(null);
+}
+// @__NO_SIDE_EFFECTS__
+function _r(e) {
+  var t = I | H, r = w !== null && (w.f & I) !== 0 ? (
+    /** @type {Derived} */
+    w
+  ) : null;
+  return y !== null && (y.f |= ct), {
+    ctx: G,
+    deps: null,
+    effects: null,
+    equals: Cn,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      F
+    ),
+    wv: 0,
+    parent: r ?? y,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Es(e, t, r) {
+  let i = (
+    /** @type {Effect | null} */
+    y
+  );
+  i === null && es();
+  var n = (
+    /** @type {Boundary} */
+    i.b
+  ), s = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), l = ft(
+    /** @type {V} */
+    F
+  ), o = !w, f = /* @__PURE__ */ new Map();
+  return Os(() => {
+    var u = xn();
+    s = u.promise;
+    try {
+      Promise.resolve(e()).then(u.resolve, u.reject).then(() => {
+        d === R && d.committed && d.deactivate(), Nr();
+      });
+    } catch (p) {
+      u.reject(p), Nr();
+    }
+    var d = (
+      /** @type {Batch} */
+      R
+    );
+    if (o) {
+      var v = n.is_rendered();
+      n.update_pending_count(1), d.increment(v), f.get(d)?.reject(ht), f.delete(d), f.set(d, u);
+    }
+    const c = (p, h = void 0) => {
+      if (d.activate(), h)
+        h !== ht && (l.f |= ze, At(l, h));
+      else {
+        (l.f & ze) !== 0 && (l.f ^= ze), At(l, p);
+        for (const [S, $] of f) {
+          if (f.delete(S), S === d) break;
+          $.reject(ht);
+        }
+      }
+      o && (n.update_pending_count(-1), d.decrement(v));
+    };
+    u.promise.then(c, (p) => c(null, p || "unknown"));
+  }), ks(() => {
+    for (const u of f.values())
+      u.reject(ht);
+  }), new Promise((u) => {
+    function d(v) {
+      function c() {
+        v === s ? u(l) : d(s);
+      }
+      v.then(c, c);
+    }
+    d(s);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function cn(e) {
+  const t = /* @__PURE__ */ _r(e);
+  return ci(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function Ts(e) {
+  const t = /* @__PURE__ */ _r(e);
+  return t.equals = Nn, t;
+}
+function zn(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var r = 0; r < t.length; r += 1)
+      B(
+        /** @type {Effect} */
+        t[r]
+      );
+  }
+}
+function xs(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & I) === 0)
+      return (t.f & Me) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function Hr(e) {
+  var t, r = y;
+  de(xs(e));
+  try {
+    e.f &= ~at, zn(e), t = _i(e);
+  } finally {
+    de(r);
+  }
+  return t;
+}
+function Gn(e) {
+  var t = Hr(e);
+  if (!e.equals(t) && (e.wv = hi(), (!R?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    P(e, D);
+    return;
+  }
+  Ke || (_e !== null ? (Ur() || R?.is_fork) && _e.set(e, t) : Br(e));
+}
+let Or = /* @__PURE__ */ new Set();
+const Ge = /* @__PURE__ */ new Map();
+let Kn = !1;
+function ft(e, t) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: Cn,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function C(e, t) {
+  const r = ft(e);
+  return ci(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function Wn(e, t = !1, r = !0) {
+  const i = ft(e);
+  return t || (i.equals = Nn), i;
+}
+function A(e, t, r = !1) {
+  w !== 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
+  (!ge || (w.f & fn) !== 0) && Ln() && (w.f & (I | Ie | qr | fn)) !== 0 && (ce === null || !Tt.call(ce, e)) && as();
+  let i = r ? Ot(t) : t;
+  return At(e, i);
+}
+function At(e, t) {
+  if (!e.equals(t)) {
+    var r = e.v;
+    Ke ? Ge.set(e, t) : Ge.set(e, r), e.v = t;
+    var i = De.ensure();
+    if (i.capture(e, r), (e.f & I) !== 0) {
+      const n = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & H) !== 0 && Hr(n), Br(n);
+    }
+    e.wv = hi(), Jn(e, H), y !== null && (y.f & D) !== 0 && (y.f & (be | We)) === 0 && (se === null ? Ms([e]) : se.push(e)), !i.is_fork && Or.size > 0 && !Kn && Ss();
+  }
+  return t;
+}
+function Ss() {
+  Kn = !1;
+  for (const e of Or)
+    (e.f & D) !== 0 && P(e, Ve), Bt(e) && Dt(e);
+  Or.clear();
+}
+function Mt(e) {
+  A(e, e.v + 1);
+}
+function Jn(e, t) {
+  var r = e.reactions;
+  if (r !== null)
+    for (var i = r.length, n = 0; n < i; n++) {
+      var s = r[n], l = s.f, o = (l & H) === 0;
+      if (o && P(s, t), (l & I) !== 0) {
+        var f = (
+          /** @type {Derived} */
+          s
+        );
+        _e?.delete(f), (l & at) === 0 && (l & fe && (s.f |= at), Jn(f, Ve));
+      } else o && ((l & Ie) !== 0 && Ce !== null && Ce.add(
+        /** @type {Effect} */
+        s
+      ), Fe(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Ot(e) {
+  if (typeof e != "object" || e === null || Gt in e)
+    return e;
+  const t = Tn(e);
+  if (t !== Ki && t !== Wi)
+    return e;
+  var r = /* @__PURE__ */ new Map(), i = En(e), n = /* @__PURE__ */ C(0), s = ot, l = (o) => {
+    if (ot === s)
+      return o();
+    var f = w, u = ot;
+    K(null), vn(s);
+    var d = o();
+    return K(f), vn(u), d;
+  };
+  return i && r.set("length", /* @__PURE__ */ C(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(o, f, u) {
+        (!("value" in u) || u.configurable === !1 || u.enumerable === !1 || u.writable === !1) && ls();
+        var d = r.get(f);
+        return d === void 0 ? d = l(() => {
+          var v = /* @__PURE__ */ C(u.value);
+          return r.set(f, v), v;
+        }) : A(d, u.value, !0), !0;
+      },
+      deleteProperty(o, f) {
+        var u = r.get(f);
+        if (u === void 0) {
+          if (f in o) {
+            const d = l(() => /* @__PURE__ */ C(F));
+            r.set(f, d), Mt(n);
+          }
+        } else
+          A(u, F), Mt(n);
+        return !0;
+      },
+      get(o, f, u) {
+        if (f === Gt)
+          return e;
+        var d = r.get(f), v = f in o;
+        if (d === void 0 && (!v || vt(o, f)?.writable) && (d = l(() => {
+          var p = Ot(v ? o[f] : F), h = /* @__PURE__ */ C(p);
+          return h;
+        }), r.set(f, d)), d !== void 0) {
+          var c = _(d);
+          return c === F ? void 0 : c;
+        }
+        return Reflect.get(o, f, u);
+      },
+      getOwnPropertyDescriptor(o, f) {
+        var u = Reflect.getOwnPropertyDescriptor(o, f);
+        if (u && "value" in u) {
+          var d = r.get(f);
+          d && (u.value = _(d));
+        } else if (u === void 0) {
+          var v = r.get(f), c = v?.v;
+          if (v !== void 0 && c !== F)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: c,
+              writable: !0
+            };
+        }
+        return u;
+      },
+      has(o, f) {
+        if (f === Gt)
+          return !0;
+        var u = r.get(f), d = u !== void 0 && u.v !== F || Reflect.has(o, f);
+        if (u !== void 0 || y !== null && (!d || vt(o, f)?.writable)) {
+          u === void 0 && (u = l(() => {
+            var c = d ? Ot(o[f]) : F, p = /* @__PURE__ */ C(c);
+            return p;
+          }), r.set(f, u));
+          var v = _(u);
+          if (v === F)
+            return !1;
+        }
+        return d;
+      },
+      set(o, f, u, d) {
+        var v = r.get(f), c = f in o;
+        if (i && f === "length")
+          for (var p = u; p < /** @type {Source<number>} */
+          v.v; p += 1) {
+            var h = r.get(p + "");
+            h !== void 0 ? A(h, F) : p in o && (h = l(() => /* @__PURE__ */ C(F)), r.set(p + "", h));
+          }
+        if (v === void 0)
+          (!c || vt(o, f)?.writable) && (v = l(() => /* @__PURE__ */ C(void 0)), A(v, Ot(u)), r.set(f, v));
+        else {
+          c = v.v !== F;
+          var S = l(() => Ot(u));
+          A(v, S);
+        }
+        var $ = Reflect.getOwnPropertyDescriptor(o, f);
+        if ($?.set && $.set.call(d, u), !c) {
+          if (i && typeof f == "string") {
+            var W = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), O = Number(f);
+            Number.isInteger(O) && O >= W.v && A(W, O + 1);
+          }
+          Mt(n);
+        }
+        return !0;
+      },
+      ownKeys(o) {
+        _(n);
+        var f = Reflect.ownKeys(o).filter((v) => {
+          var c = r.get(v);
+          return c === void 0 || c.v !== F;
+        });
+        for (var [u, d] of r)
+          d.v !== F && !(u in o) && f.push(u);
+        return f;
+      },
+      setPrototypeOf() {
+        os();
+      }
+    }
+  );
+}
+var dn, Xn, Zn, Qn;
+function Pr() {
+  if (dn === void 0) {
+    dn = window, Xn = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, r = Text.prototype;
+    Zn = vt(t, "firstChild").get, Qn = vt(t, "nextSibling").get, an(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), an(r) && (r.__t = void 0);
+  }
+}
+function ue(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function ut(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Zn.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Se(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Qn.call(e)
+  );
+}
+function Ut(e, t) {
+  if (!T)
+    return /* @__PURE__ */ ut(e);
+  var r = /* @__PURE__ */ ut(x);
+  if (r === null)
+    r = x.appendChild(ue());
+  else if (t && r.nodeType !== cr) {
+    var i = ue();
+    return r?.before(i), z(i), i;
+  }
+  return t && Yr(
+    /** @type {Text} */
+    r
+  ), z(r), r;
+}
+function yr(e, t = !1) {
+  if (!T) {
+    var r = /* @__PURE__ */ ut(e);
+    return r instanceof Comment && r.data === "" ? /* @__PURE__ */ Se(r) : r;
+  }
+  if (t) {
+    if (x?.nodeType !== cr) {
+      var i = ue();
+      return x?.before(i), z(i), i;
+    }
+    Yr(
+      /** @type {Text} */
+      x
+    );
+  }
+  return x;
+}
+function Be(e, t = 1, r = !1) {
+  let i = T ? x : e;
+  for (var n; t--; )
+    n = i, i = /** @type {TemplateNode} */
+    /* @__PURE__ */ Se(i);
+  if (!T)
+    return i;
+  if (r) {
+    if (i?.nodeType !== cr) {
+      var s = ue();
+      return i === null ? n?.after(s) : i.before(s), z(s), s;
+    }
+    Yr(
+      /** @type {Text} */
+      i
+    );
+  }
+  return z(i), i;
+}
+function ei(e) {
+  e.textContent = "";
+}
+function ti() {
+  return !1;
+}
+function Yr(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === cr; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function ri(e) {
+  var t = w, r = y;
+  K(null), de(null);
+  try {
+    return e();
+  } finally {
+    K(t), de(r);
+  }
+}
+function Rs(e) {
+  y === null && (w === null && ns(), rs()), Ke && ts();
+}
+function As(e, t) {
+  var r = t.last;
+  r === null ? t.last = t.first = e : (r.next = e, e.prev = r, t.last = e);
+}
+function Re(e, t, r) {
+  var i = y;
+  i !== null && (i.f & re) !== 0 && (e |= re);
+  var n = {
+    ctx: G,
+    deps: null,
+    nodes: null,
+    f: e | H | fe,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: i,
+    b: i && i.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  };
+  if (r)
+    try {
+      Dt(n), n.f |= ur;
+    } catch (o) {
+      throw B(n), o;
+    }
+  else t !== null && Fe(n);
+  var s = n;
+  if (r && s.deps === null && s.teardown === null && s.nodes === null && s.first === s.last && // either `null`, or a singular child
+  (s.f & ct) === 0 && (s = s.first, (e & Ie) !== 0 && (e & xt) !== 0 && s !== null && (s.f |= xt)), s !== null && (s.parent = i, i !== null && As(s, i), w !== null && (w.f & I) !== 0 && (e & We) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      w
+    );
+    (l.effects ?? (l.effects = [])).push(s);
+  }
+  return n;
+}
+function Ur() {
+  return w !== null && !ge;
+}
+function ks(e) {
+  const t = Re(fr, null, !1);
+  return P(t, D), t.teardown = e, t;
+}
+function Lr(e) {
+  Rs();
+  var t = (
+    /** @type {Effect} */
+    y.f
+  ), r = !w && (t & be) !== 0 && (t & ur) === 0;
+  if (r) {
+    var i = (
+      /** @type {ComponentContext} */
+      G
+    );
+    (i.e ?? (i.e = [])).push(e);
+  } else
+    return ni(e);
+}
+function ni(e) {
+  return Re(rr | Xi, e, !1);
+}
+function Cs(e) {
+  De.ensure();
+  const t = Re(We | ct, e, !0);
+  return () => {
+    B(t);
+  };
+}
+function Ns(e) {
+  De.ensure();
+  const t = Re(We | ct, e, !0);
+  return (r = {}) => new Promise((i) => {
+    r.outro ? lt(t, () => {
+      B(t), i(void 0);
+    }) : (B(t), i(void 0));
+  });
+}
+function ii(e) {
+  return Re(rr, e, !1);
+}
+function Os(e) {
+  return Re(qr | ct, e, !0);
+}
+function zr(e, t = 0) {
+  return Re(fr | t, e, !0);
+}
+function Ae(e, t = [], r = [], i = []) {
+  $s(i, t, r, (n) => {
+    Re(fr, () => e(...n.map(_)), !0);
+  });
+}
+function Gr(e, t = 0) {
+  var r = Re(Ie | t, e, !0);
+  return r;
+}
+function ae(e) {
+  return Re(be | ct, e, !0);
+}
+function si(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const r = Ke, i = w;
+    hn(!0), K(null);
+    try {
+      t.call(null);
+    } finally {
+      hn(r), K(i);
+    }
+  }
+}
+function li(e, t = !1) {
+  var r = e.first;
+  for (e.first = e.last = null; r !== null; ) {
+    const n = r.ac;
+    n !== null && ri(() => {
+      n.abort(ht);
+    });
+    var i = r.next;
+    (r.f & We) !== 0 ? r.parent = null : B(r, t), r = i;
+  }
+}
+function Ps(e) {
+  for (var t = e.first; t !== null; ) {
+    var r = t.next;
+    (t.f & be) === 0 && B(t), t = r;
+  }
+}
+function B(e, t = !0) {
+  var r = !1;
+  (t || (e.f & Rn) !== 0) && e.nodes !== null && e.nodes.end !== null && (Ls(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), r = !0), li(e, t && !r), ir(e, 0), P(e, Me);
+  var i = e.nodes && e.nodes.t;
+  if (i !== null)
+    for (const s of i)
+      s.stop();
+  si(e);
+  var n = e.parent;
+  n !== null && n.first !== null && oi(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Ls(e, t) {
+  for (; e !== null; ) {
+    var r = e === t ? null : /* @__PURE__ */ Se(e);
+    e.remove(), e = r;
+  }
+}
+function oi(e) {
+  var t = e.parent, r = e.prev, i = e.next;
+  r !== null && (r.next = i), i !== null && (i.prev = r), t !== null && (t.first === e && (t.first = i), t.last === e && (t.last = r));
+}
+function lt(e, t, r = !0) {
+  var i = [];
+  ai(e, i, !0);
+  var n = () => {
+    r && B(e), t && t();
+  }, s = i.length;
+  if (s > 0) {
+    var l = () => --s || n();
+    for (var o of i)
+      o.out(l);
+  } else
+    n();
+}
+function ai(e, t, r) {
+  if ((e.f & re) === 0) {
+    e.f ^= re;
+    var i = e.nodes && e.nodes.t;
+    if (i !== null)
+      for (const o of i)
+        (o.is_global || r) && t.push(o);
+    for (var n = e.first; n !== null; ) {
+      var s = n.next, l = (n.f & xt) !== 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.
+      (n.f & be) !== 0 && (e.f & Ie) !== 0;
+      ai(n, t, l ? r : !1), n = s;
+    }
+  }
+}
+function Kr(e) {
+  fi(e, !0);
+}
+function fi(e, t) {
+  if ((e.f & re) !== 0) {
+    e.f ^= re, (e.f & D) === 0 && (P(e, H), Fe(e));
+    for (var r = e.first; r !== null; ) {
+      var i = r.next, n = (r.f & xt) !== 0 || (r.f & be) !== 0;
+      fi(r, n ? t : !1), r = i;
+    }
+    var s = e.nodes && e.nodes.t;
+    if (s !== null)
+      for (const l of s)
+        (l.is_global || t) && l.in();
+  }
+}
+function ui(e, t) {
+  if (e.nodes)
+    for (var r = e.nodes.start, i = e.nodes.end; r !== null; ) {
+      var n = r === i ? null : /* @__PURE__ */ Se(r);
+      t.append(r), r = n;
+    }
+}
+let Xt = !1, Ke = !1;
+function hn(e) {
+  Ke = e;
+}
+let w = null, ge = !1;
+function K(e) {
+  w = e;
+}
+let y = null;
+function de(e) {
+  y = e;
+}
+let ce = null;
+function ci(e) {
+  w !== null && (ce === null ? ce = [e] : ce.push(e));
+}
+let U = null, Z = 0, se = null;
+function Ms(e) {
+  se = e;
+}
+let di = 1, Ze = 0, ot = Ze;
+function vn(e) {
+  ot = e;
+}
+function hi() {
+  return ++di;
+}
+function Bt(e) {
+  var t = e.f;
+  if ((t & H) !== 0)
+    return !0;
+  if (t & I && (e.f &= ~at), (t & Ve) !== 0) {
+    for (var r = (
+      /** @type {Value[]} */
+      e.deps
+    ), i = r.length, n = 0; n < i; n++) {
+      var s = r[n];
+      if (Bt(
+        /** @type {Derived} */
+        s
+      ) && Gn(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & fe) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    _e === null && P(e, D);
+  }
+  return !1;
+}
+function vi(e, t, r = !0) {
+  var i = e.reactions;
+  if (i !== null && !(ce !== null && Tt.call(ce, e)))
+    for (var n = 0; n < i.length; n++) {
+      var s = i[n];
+      (s.f & I) !== 0 ? vi(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (r ? P(s, H) : (s.f & D) !== 0 && P(s, Ve), Fe(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function _i(e) {
+  var S;
+  var t = U, r = Z, i = se, n = w, s = ce, l = G, o = ge, f = ot, u = e.f;
+  U = /** @type {null | Value[]} */
+  null, Z = 0, se = null, w = (u & (be | We)) === 0 ? e : null, ce = null, St(e.ctx), ge = !1, ot = ++Ze, e.ac !== null && (ri(() => {
+    e.ac.abort(ht);
+  }), e.ac = null);
+  try {
+    e.f |= xr;
+    var d = (
+      /** @type {Function} */
+      e.fn
+    ), v = d(), c = e.deps, p = R?.is_fork;
+    if (U !== null) {
+      var h;
+      if (p || ir(e, Z), c !== null && Z > 0)
+        for (c.length = Z + U.length, h = 0; h < U.length; h++)
+          c[Z + h] = U[h];
+      else
+        e.deps = c = U;
+      if (Ur() && (e.f & fe) !== 0)
+        for (h = Z; h < c.length; h++)
+          ((S = c[h]).reactions ?? (S.reactions = [])).push(e);
+    } else !p && c !== null && Z < c.length && (ir(e, Z), c.length = Z);
+    if (Ln() && se !== null && !ge && c !== null && (e.f & (I | Ve | H)) === 0)
+      for (h = 0; h < /** @type {Source[]} */
+      se.length; h++)
+        vi(
+          se[h],
+          /** @type {Effect} */
+          e
+        );
+    if (n !== null && n !== e) {
+      if (Ze++, n.deps !== null)
+        for (let $ = 0; $ < r; $ += 1)
+          n.deps[$].rv = Ze;
+      if (t !== null)
+        for (const $ of t)
+          $.rv = Ze;
+      se !== null && (i === null ? i = se : i.push(.../** @type {Source[]} */
+      se));
+    }
+    return (e.f & ze) !== 0 && (e.f ^= ze), v;
+  } catch ($) {
+    return Dn($);
+  } finally {
+    e.f ^= xr, U = t, Z = r, se = i, w = n, ce = s, St(l), ge = o, ot = f;
+  }
+}
+function Ds(e, t) {
+  let r = t.reactions;
+  if (r !== null) {
+    var i = zi.call(r, e);
+    if (i !== -1) {
+      var n = r.length - 1;
+      n === 0 ? r = t.reactions = null : (r[i] = r[n], r.pop());
+    }
+  }
+  if (r === null && (t.f & I) !== 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
+  (U === null || !Tt.call(U, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & fe) !== 0 && (s.f ^= fe, s.f &= ~at), Br(s), zn(s), ir(s, 0);
+  }
+}
+function ir(e, t) {
+  var r = e.deps;
+  if (r !== null)
+    for (var i = t; i < r.length; i++)
+      Ds(e, r[i]);
+}
+function Dt(e) {
+  var t = e.f;
+  if ((t & Me) === 0) {
+    P(e, D);
+    var r = y, i = Xt;
+    y = e, Xt = !0;
+    try {
+      (t & (Ie | Sn)) !== 0 ? Ps(e) : li(e), si(e);
+      var n = _i(e);
+      e.teardown = typeof n == "function" ? n : null, e.wv = di;
+      var s;
+      Tr && hs && (e.f & H) !== 0 && e.deps;
+    } finally {
+      Xt = i, y = r;
+    }
+  }
+}
+function _(e) {
+  var t = e.f, r = (t & I) !== 0;
+  if (w !== null && !ge) {
+    var i = y !== null && (y.f & Me) !== 0;
+    if (!i && (ce === null || !Tt.call(ce, e))) {
+      var n = w.deps;
+      if ((w.f & xr) !== 0)
+        e.rv < Ze && (e.rv = Ze, U === null && n !== null && n[Z] === e ? Z++ : U === null ? U = [e] : U.push(e));
+      else {
+        (w.deps ?? (w.deps = [])).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [w] : Tt.call(s, w) || s.push(w);
+      }
+    }
+  }
+  if (Ke && Ge.has(e))
+    return Ge.get(e);
+  if (r) {
+    var l = (
+      /** @type {Derived} */
+      e
+    );
+    if (Ke) {
+      var o = l.v;
+      return ((l.f & D) === 0 && l.reactions !== null || gi(l)) && (o = Hr(l)), Ge.set(l, o), o;
+    }
+    var f = (l.f & fe) === 0 && !ge && w !== null && (Xt || (w.f & fe) !== 0), u = l.deps === null;
+    Bt(l) && (f && (l.f |= fe), Gn(l)), f && !u && pi(l);
+  }
+  if (_e?.has(e))
+    return _e.get(e);
+  if ((e.f & ze) !== 0)
+    throw e.v;
+  return e.v;
+}
+function pi(e) {
+  if (e.deps !== null) {
+    e.f |= fe;
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & I) !== 0 && (t.f & fe) === 0 && pi(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function gi(e) {
+  if (e.v === F) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (Ge.has(t) || (t.f & I) !== 0 && gi(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function pr(e) {
+  var t = ge;
+  try {
+    return ge = !0, e();
+  } finally {
+    ge = t;
+  }
+}
+const bi = /* @__PURE__ */ new Set(), Mr = /* @__PURE__ */ new Set();
+function Fs(e) {
+  for (var t = 0; t < e.length; t++)
+    bi.add(e[t]);
+  for (var r of Mr)
+    r(e);
+}
+let _n = null;
+function zt(e) {
+  var t = this, r = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), i = e.type, n = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    n[0] || e.target
+  );
+  _n = e;
+  var l = 0, o = _n === e && e.__root;
+  if (o) {
+    var f = n.indexOf(o);
+    if (f !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var u = n.indexOf(t);
+    if (u === -1)
+      return;
+    f <= u && (l = f);
+  }
+  if (s = /** @type {Element} */
+  n[l] || e.target, s !== t) {
+    tr(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || r;
+      }
+    });
+    var d = w, v = y;
+    K(null), de(null);
+    try {
+      for (var c, p = []; s !== null; ) {
+        var h = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var S = s["__" + i];
+          S != 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) && S.call(s, e);
+        } catch ($) {
+          c ? p.push($) : c = $;
+        }
+        if (e.cancelBubble || h === t || h === null)
+          break;
+        s = h;
+      }
+      if (c) {
+        for (let $ of p)
+          queueMicrotask(() => {
+            throw $;
+          });
+        throw c;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, K(d), de(v);
+    }
+  }
+}
+function Is(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function _t(e, t) {
+  var r = (
+    /** @type {Effect} */
+    y
+  );
+  r.nodes === null && (r.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function je(e, t) {
+  var r = (t & Hi) !== 0, i = (t & Yi) !== 0, n, s = !e.startsWith("<!>");
+  return () => {
+    if (T)
+      return _t(x, null), x;
+    n === void 0 && (n = Is(s ? e : "<!>" + e), r || (n = /** @type {TemplateNode} */
+    /* @__PURE__ */ ut(n)));
+    var l = (
+      /** @type {TemplateNode} */
+      i || Xn ? document.importNode(n, !0) : n.cloneNode(!0)
+    );
+    if (r) {
+      var o = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ ut(l)
+      ), f = (
+        /** @type {TemplateNode} */
+        l.lastChild
+      );
+      _t(o, f);
+    } else
+      _t(l, l);
+    return l;
+  };
+}
+function pn() {
+  if (T)
+    return _t(x, null), x;
+  var e = document.createDocumentFragment(), t = document.createComment(""), r = ue();
+  return e.append(t, r), _t(t, r), e;
+}
+function ie(e, t) {
+  if (T) {
+    var r = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      y
+    );
+    ((r.f & ur) === 0 || r.nodes.end === null) && (r.nodes.end = x), hr();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const Vs = ["touchstart", "touchmove"];
+function js(e) {
+  return Vs.includes(e);
+}
+function gn(e, t) {
+  var r = t == null ? "" : typeof t == "object" ? t + "" : t;
+  r !== (e.__t ?? (e.__t = e.nodeValue)) && (e.__t = r, e.nodeValue = r + "");
+}
+function mi(e, t) {
+  return wi(e, t);
+}
+function qs(e, t) {
+  Pr(), t.intro = t.intro ?? !1;
+  const r = t.target, i = T, n = x;
+  try {
+    for (var s = /* @__PURE__ */ ut(r); s && (s.nodeType !== kt || /** @type {Comment} */
+    s.data !== yn); )
+      s = /* @__PURE__ */ Se(s);
+    if (!s)
+      throw Et;
+    pe(!0), z(
+      /** @type {Comment} */
+      s
+    );
+    const l = wi(e, { ...t, anchor: s });
+    return pe(!1), /**  @type {Exports} */
+    l;
+  } catch (l) {
+    if (l instanceof Error && l.message.split(`
+`).some((o) => o.startsWith("https://svelte.dev/e/")))
+      throw l;
+    return l !== Et && console.warn("Failed to hydrate: ", l), t.recover === !1 && ss(), Pr(), ei(r), pe(!1), mi(e, t);
+  } finally {
+    pe(i), z(n);
+  }
+}
+const dt = /* @__PURE__ */ new Map();
+function wi(e, { target: t, anchor: r, props: i = {}, events: n, context: s, intro: l = !0 }) {
+  Pr();
+  var o = /* @__PURE__ */ new Set(), f = (v) => {
+    for (var c = 0; c < v.length; c++) {
+      var p = v[c];
+      if (!o.has(p)) {
+        o.add(p);
+        var h = js(p);
+        t.addEventListener(p, zt, { passive: h });
+        var S = dt.get(p);
+        S === void 0 ? (document.addEventListener(p, zt, { passive: h }), dt.set(p, 1)) : dt.set(p, S + 1);
+      }
+    }
+  };
+  f(ar(bi)), Mr.add(f);
+  var u = void 0, d = Ns(() => {
+    var v = r ?? t.appendChild(ue());
+    return ms(
+      /** @type {TemplateNode} */
+      v,
+      {
+        pending: () => {
+        }
+      },
+      (c) => {
+        if (s) {
+          On({});
+          var p = (
+            /** @type {ComponentContext} */
+            G
+          );
+          p.c = s;
+        }
+        if (n && (i.$$events = n), T && _t(
+          /** @type {TemplateNode} */
+          c,
+          null
+        ), u = e(c, i) || {}, T && (y.nodes.end = x, x === null || x.nodeType !== kt || /** @type {Comment} */
+        x.data !== Vr))
+          throw dr(), Et;
+        s && Pn();
+      }
+    ), () => {
+      for (var c of o) {
+        t.removeEventListener(c, zt);
+        var p = (
+          /** @type {number} */
+          dt.get(c)
+        );
+        --p === 0 ? (document.removeEventListener(c, zt), dt.delete(c)) : dt.set(c, p);
+      }
+      Mr.delete(f), v !== r && v.parentNode?.removeChild(v);
+    };
+  });
+  return Dr.set(u, d), u;
+}
+let Dr = /* @__PURE__ */ new WeakMap();
+function Bs(e, t) {
+  const r = Dr.get(e);
+  return r ? (Dr.delete(e), r(t)) : Promise.resolve();
+}
+var ve, Te, ee, it, jt, qt, lr;
+class Hs {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, r = !0) {
+    /** @type {TemplateNode} */
+    k(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    m(this, ve, /* @__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>}
+     */
+    m(this, Te, /* @__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>}
+     */
+    m(this, ee, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    m(this, it, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    m(this, jt, !0);
+    m(this, qt, () => {
+      var t = (
+        /** @type {Batch} */
+        R
+      );
+      if (a(this, ve).has(t)) {
+        var r = (
+          /** @type {Key} */
+          a(this, ve).get(t)
+        ), i = a(this, Te).get(r);
+        if (i)
+          Kr(i), a(this, it).delete(r);
+        else {
+          var n = a(this, ee).get(r);
+          n && (a(this, Te).set(r, n.effect), a(this, ee).delete(r), n.fragment.lastChild.remove(), this.anchor.before(n.fragment), i = n.effect);
+        }
+        for (const [s, l] of a(this, ve)) {
+          if (a(this, ve).delete(s), s === t)
+            break;
+          const o = a(this, ee).get(l);
+          o && (B(o.effect), a(this, ee).delete(l));
+        }
+        for (const [s, l] of a(this, Te)) {
+          if (s === r || a(this, it).has(s)) continue;
+          const o = () => {
+            if (Array.from(a(this, ve).values()).includes(s)) {
+              var u = document.createDocumentFragment();
+              ui(l, u), u.append(ue()), a(this, ee).set(s, { effect: l, fragment: u });
+            } else
+              B(l);
+            a(this, it).delete(s), a(this, Te).delete(s);
+          };
+          a(this, jt) || !i ? (a(this, it).add(s), lt(l, o, !1)) : o();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    m(this, lr, (t) => {
+      a(this, ve).delete(t);
+      const r = Array.from(a(this, ve).values());
+      for (const [i, n] of a(this, ee))
+        r.includes(i) || (B(n.effect), a(this, ee).delete(i));
+    });
+    this.anchor = t, b(this, jt, r);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, r) {
+    var i = (
+      /** @type {Batch} */
+      R
+    ), n = ti();
+    if (r && !a(this, Te).has(t) && !a(this, ee).has(t))
+      if (n) {
+        var s = document.createDocumentFragment(), l = ue();
+        s.append(l), a(this, ee).set(t, {
+          effect: ae(() => r(l)),
+          fragment: s
+        });
+      } else
+        a(this, Te).set(
+          t,
+          ae(() => r(this.anchor))
+        );
+    if (a(this, ve).set(i, t), n) {
+      for (const [o, f] of a(this, Te))
+        o === t ? i.skipped_effects.delete(f) : i.skipped_effects.add(f);
+      for (const [o, f] of a(this, ee))
+        o === t ? i.skipped_effects.delete(f.effect) : i.skipped_effects.add(f.effect);
+      i.oncommit(a(this, qt)), i.ondiscard(a(this, lr));
+    } else
+      T && (this.anchor = x), a(this, qt).call(this);
+  }
+}
+ve = new WeakMap(), Te = new WeakMap(), ee = new WeakMap(), it = new WeakMap(), jt = new WeakMap(), qt = new WeakMap(), lr = new WeakMap();
+function $i(e) {
+  G === null && An(), Lr(() => {
+    const t = pr(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function Ys(e) {
+  G === null && An(), $i(() => () => pr(e));
+}
+function ke(e, t, r = !1) {
+  T && hr();
+  var i = new Hs(e), n = r ? xt : 0;
+  function s(l, o) {
+    if (T) {
+      const u = kn(e) === or;
+      if (l === u) {
+        var f = nr();
+        z(f), i.anchor = f, pe(!1), i.ensure(l, o), pe(!0);
+        return;
+      }
+    }
+    i.ensure(l, o);
+  }
+  Gr(() => {
+    var l = !1;
+    t((o, f = !0) => {
+      l = !0, s(f, o);
+    }), l || s(!1, null);
+  }, n);
+}
+function Us(e, t, r) {
+  for (var i = [], n = t.length, s, l = t.length, o = 0; o < n; o++) {
+    let v = t[o];
+    lt(
+      v,
+      () => {
+        if (s) {
+          if (s.pending.delete(v), s.done.add(v), s.pending.size === 0) {
+            var c = (
+              /** @type {Set<EachOutroGroup>} */
+              e.outrogroups
+            );
+            Fr(ar(s.done)), c.delete(s), c.size === 0 && (e.outrogroups = null);
+          }
+        } else
+          l -= 1;
+      },
+      !1
+    );
+  }
+  if (l === 0) {
+    var f = i.length === 0 && r !== null;
+    if (f) {
+      var u = (
+        /** @type {Element} */
+        r
+      ), d = (
+        /** @type {Element} */
+        u.parentNode
+      );
+      ei(d), d.append(u), e.items.clear();
+    }
+    Fr(t, !f);
+  } else
+    s = {
+      pending: new Set(t),
+      done: /* @__PURE__ */ new Set()
+    }, (e.outrogroups ?? (e.outrogroups = /* @__PURE__ */ new Set())).add(s);
+}
+function Fr(e, t = !0) {
+  for (var r = 0; r < e.length; r++)
+    B(e[r], t);
+}
+var bn;
+function zs(e, t, r, i, n, s = null) {
+  var l = e, o = /* @__PURE__ */ new Map();
+  {
+    var f = (
+      /** @type {Element} */
+      e
+    );
+    l = T ? z(/* @__PURE__ */ ut(f)) : f.appendChild(ue());
+  }
+  T && hr();
+  var u = null, d = /* @__PURE__ */ Ts(() => {
+    var $ = r();
+    return En($) ? $ : $ == null ? [] : ar($);
+  }), v, c = !0;
+  function p() {
+    S.fallback = u, Gs(S, v, l, t, i), u !== null && (v.length === 0 ? (u.f & Ue) === 0 ? Kr(u) : (u.f ^= Ue, Pt(u, null, l)) : lt(u, () => {
+      u = null;
+    }));
+  }
+  var h = Gr(() => {
+    v = /** @type {V[]} */
+    _(d);
+    var $ = v.length;
+    let W = !1;
+    if (T) {
+      var O = kn(l) === or;
+      O !== ($ === 0) && (l = nr(), z(l), pe(!1), W = !0);
+    }
+    for (var me = /* @__PURE__ */ new Set(), J = (
+      /** @type {Batch} */
+      R
+    ), ne = ti(), X = 0; X < $; X += 1) {
+      T && x.nodeType === kt && /** @type {Comment} */
+      x.data === Vr && (l = /** @type {Comment} */
+      x, W = !0, pe(!1));
+      var we = v[X], V = i(we, X), he = c ? null : o.get(V);
+      he ? (he.v && At(he.v, we), he.i && At(he.i, X), ne && J.skipped_effects.delete(he.e)) : (he = Ks(
+        o,
+        c ? l : bn ?? (bn = ue()),
+        we,
+        V,
+        X,
+        n,
+        t,
+        r
+      ), c || (he.e.f |= Ue), o.set(V, he)), me.add(V);
+    }
+    if ($ === 0 && s && !u && (c ? u = ae(() => s(l)) : (u = ae(() => s(bn ?? (bn = ue()))), u.f |= Ue)), T && $ > 0 && z(nr()), !c)
+      if (ne) {
+        for (const [Ht, gr] of o)
+          me.has(Ht) || J.skipped_effects.add(gr.e);
+        J.oncommit(p), J.ondiscard(() => {
+        });
+      } else
+        p();
+    W && pe(!0), _(d);
+  }), S = { effect: h, items: o, outrogroups: null, fallback: u };
+  c = !1, T && (l = x);
+}
+function Nt(e) {
+  for (; e !== null && (e.f & be) === 0; )
+    e = e.next;
+  return e;
+}
+function Gs(e, t, r, i, n) {
+  var s = t.length, l = e.items, o = Nt(e.effect.first), f, u = null, d = [], v = [], c, p, h, S;
+  for (S = 0; S < s; S += 1) {
+    if (c = t[S], p = n(c, S), h = /** @type {EachItem} */
+    l.get(p).e, e.outrogroups !== null)
+      for (const V of e.outrogroups)
+        V.pending.delete(h), V.done.delete(h);
+    if ((h.f & Ue) !== 0)
+      if (h.f ^= Ue, h === o)
+        Pt(h, null, r);
+      else {
+        var $ = u ? u.next : o;
+        h === e.effect.last && (e.effect.last = h.prev), h.prev && (h.prev.next = h.next), h.next && (h.next.prev = h.prev), He(e, u, h), He(e, h, $), Pt(h, $, r), u = h, d = [], v = [], o = Nt(u.next);
+        continue;
+      }
+    if ((h.f & re) !== 0 && Kr(h), h !== o) {
+      if (f !== void 0 && f.has(h)) {
+        if (d.length < v.length) {
+          var W = v[0], O;
+          u = W.prev;
+          var me = d[0], J = d[d.length - 1];
+          for (O = 0; O < d.length; O += 1)
+            Pt(d[O], W, r);
+          for (O = 0; O < v.length; O += 1)
+            f.delete(v[O]);
+          He(e, me.prev, J.next), He(e, u, me), He(e, J, W), o = W, u = J, S -= 1, d = [], v = [];
+        } else
+          f.delete(h), Pt(h, o, r), He(e, h.prev, h.next), He(e, h, u === null ? e.effect.first : u.next), He(e, u, h), u = h;
+        continue;
+      }
+      for (d = [], v = []; o !== null && o !== h; )
+        (f ?? (f = /* @__PURE__ */ new Set())).add(o), v.push(o), o = Nt(o.next);
+      if (o === null)
+        continue;
+    }
+    (h.f & Ue) === 0 && d.push(h), u = h, o = Nt(h.next);
+  }
+  if (e.outrogroups !== null) {
+    for (const V of e.outrogroups)
+      V.pending.size === 0 && (Fr(ar(V.done)), e.outrogroups?.delete(V));
+    e.outrogroups.size === 0 && (e.outrogroups = null);
+  }
+  if (o !== null || f !== void 0) {
+    var ne = [];
+    if (f !== void 0)
+      for (h of f)
+        (h.f & re) === 0 && ne.push(h);
+    for (; o !== null; )
+      (o.f & re) === 0 && o !== e.fallback && ne.push(o), o = Nt(o.next);
+    var X = ne.length;
+    if (X > 0) {
+      var we = s === 0 ? r : null;
+      Us(e, ne, we);
+    }
+  }
+}
+function Ks(e, t, r, i, n, s, l, o) {
+  var f = (l & ji) !== 0 ? (l & Bi) === 0 ? /* @__PURE__ */ Wn(r, !1, !1) : ft(r) : null, u = (l & qi) !== 0 ? ft(n) : null;
+  return {
+    v: f,
+    i: u,
+    e: ae(() => (s(t, f ?? r, u ?? n, o), () => {
+      e.delete(i);
+    }))
+  };
+}
+function Pt(e, t, r) {
+  if (e.nodes)
+    for (var i = e.nodes.start, n = e.nodes.end, s = t && (t.f & Ue) === 0 ? (
+      /** @type {EffectNodes} */
+      t.nodes.start
+    ) : r; i !== null; ) {
+      var l = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Se(i)
+      );
+      if (s.before(i), i === n)
+        return;
+      i = l;
+    }
+}
+function He(e, t, r) {
+  t === null ? e.effect.first = r : t.next = r, r === null ? e.effect.last = t : r.prev = t;
+}
+function Ws(e, t) {
+  ii(() => {
+    var r = e.getRootNode(), i = (
+      /** @type {ShadowRoot} */
+      r.host ? (
+        /** @type {ShadowRoot} */
+        r
+      ) : (
+        /** @type {Document} */
+        r.head ?? /** @type {Document} */
+        r.ownerDocument.head
+      )
+    );
+    if (!i.querySelector("#" + t.hash)) {
+      const n = document.createElement("style");
+      n.id = t.hash, n.textContent = t.code, i.appendChild(n);
+    }
+  });
+}
+const mn = [...` 	
+\r\f \v\uFEFF`];
+function Js(e, t, r) {
+  var i = "" + e;
+  if (r) {
+    for (var n in r)
+      if (r[n])
+        i = i ? i + " " + n : n;
+      else if (i.length)
+        for (var s = n.length, l = 0; (l = i.indexOf(n, l)) >= 0; ) {
+          var o = l + s;
+          (l === 0 || mn.includes(i[l - 1])) && (o === i.length || mn.includes(i[o])) ? i = (l === 0 ? "" : i.substring(0, l)) + i.substring(o + 1) : l = o;
+        }
+  }
+  return i === "" ? null : i;
+}
+function Xs(e, t, r, i, n, s) {
+  var l = e.__className;
+  if (T || l !== r || l === void 0) {
+    var o = Js(r, i, s);
+    (!T || o !== e.getAttribute("class")) && (o == null ? e.removeAttribute("class") : e.className = o), e.__className = r;
+  } else if (s && n !== s)
+    for (var f in s) {
+      var u = !!s[f];
+      (n == null || u !== !!n[f]) && e.classList.toggle(f, u);
+    }
+  return s;
+}
+const Zs = /* @__PURE__ */ Symbol("is custom element"), Qs = /* @__PURE__ */ Symbol("is html");
+function Zt(e, t, r, i) {
+  var n = el(e);
+  T && (n[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === "LINK") || n[t] !== (n[t] = r) && (t === "loading" && (e[Qi] = r), r == null ? e.removeAttribute(t) : typeof r != "string" && yi(e).includes(t) ? e[t] = r : e.setAttribute(t, r));
+}
+function q(e, t, r) {
+  var i = w, n = y;
+  let s = T;
+  T && pe(!1), K(null), de(null);
+  try {
+    // `style` should use `set_attribute` rather than the setter
+    t !== "style" && // Don't compute setters for custom elements while they aren't registered yet,
+    // because during their upgrade/instantiation they might add more setters.
+    // Instead, fall back to a simple "an object, then set as property" heuristic.
+    (Ir.has(e.getAttribute("is") || e.nodeName) || // customElements may not be available in browser extension contexts
+    !customElements || customElements.get(e.getAttribute("is") || e.tagName.toLowerCase()) ? yi(e).includes(t) : r && typeof r == "object") ? e[t] = r : Zt(e, t, r == null ? r : String(r));
+  } finally {
+    K(i), de(n), s && pe(!0);
+  }
+}
+function el(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Zs]: e.nodeName.includes("-"),
+      [Qs]: e.namespaceURI === Ui
+    })
+  );
+}
+var Ir = /* @__PURE__ */ new Map();
+function yi(e) {
+  var t = e.getAttribute("is") || e.nodeName, r = Ir.get(t);
+  if (r) return r;
+  Ir.set(t, r = []);
+  for (var i, n = e, s = Element.prototype; s !== n; ) {
+    i = Gi(n);
+    for (var l in i)
+      i[l].set && r.push(l);
+    n = Tn(n);
+  }
+  return r;
+}
+function wn(e, t) {
+  return e === t || e?.[Gt] === t;
+}
+function Je(e = {}, t, r, i) {
+  return ii(() => {
+    var n, s;
+    return zr(() => {
+      n = s, s = [], pr(() => {
+        e !== r(...s) && (t(e, ...s), n && wn(r(...n), e) && t(null, ...n));
+      });
+    }), () => {
+      st(() => {
+        s && wn(r(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+function Er(e, t, r, i) {
+  var n = (
+    /** @type {V} */
+    i
+  ), s = !0, l = () => (s && (s = !1, n = /** @type {V} */
+  i), n), o;
+  o = /** @type {V} */
+  e[t], o === void 0 && i !== void 0 && (o = l());
+  var f;
+  f = () => {
+    var c = (
+      /** @type {V} */
+      e[t]
+    );
+    return c === void 0 ? l() : (s = !0, c);
+  };
+  var u = !1, d = /* @__PURE__ */ _r(() => (u = !1, f())), v = (
+    /** @type {Effect} */
+    y
+  );
+  return (
+    /** @type {() => V} */
+    (function(c, p) {
+      if (arguments.length > 0) {
+        const h = p ? _(d) : c;
+        return A(d, h), u = !0, n !== void 0 && (n = h), c;
+      }
+      return Ke && u || (v.f & Me) !== 0 ? d.v : _(d);
+    })
+  );
+}
+function tl(e) {
+  return new rl(e);
+}
+var Le, oe;
+class rl {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    m(this, Le);
+    /** @type {Record<string, any>} */
+    m(this, oe);
+    var r = /* @__PURE__ */ new Map(), i = (s, l) => {
+      var o = /* @__PURE__ */ Wn(l, !1, !1);
+      return r.set(s, o), o;
+    };
+    const n = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, l) {
+          return _(r.get(l) ?? i(l, Reflect.get(s, l)));
+        },
+        has(s, l) {
+          return l === Zi ? !0 : (_(r.get(l) ?? i(l, Reflect.get(s, l))), Reflect.has(s, l));
+        },
+        set(s, l, o) {
+          return A(r.get(l) ?? i(l, o), o), Reflect.set(s, l, o);
+        }
+      }
+    );
+    b(this, oe, (t.hydrate ? qs : mi)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: n,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover
+    })), (!t?.props?.$$host || t.sync === !1) && Kt(), b(this, Le, n.$$events);
+    for (const s of Object.keys(a(this, oe)))
+      s === "$set" || s === "$destroy" || s === "$on" || tr(this, s, {
+        get() {
+          return a(this, oe)[s];
+        },
+        /** @param {any} value */
+        set(l) {
+          a(this, oe)[s] = l;
+        },
+        enumerable: !0
+      });
+    a(this, oe).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(n, s);
+    }, a(this, oe).$destroy = () => {
+      Bs(a(this, oe));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    a(this, oe).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, r) {
+    a(this, Le)[t] = a(this, Le)[t] || [];
+    const i = (...n) => r.call(this, ...n);
+    return a(this, Le)[t].push(i), () => {
+      a(this, Le)[t] = a(this, Le)[t].filter(
+        /** @param {any} fn */
+        (n) => n !== i
+      );
+    };
+  }
+  $destroy() {
+    a(this, oe).$destroy();
+  }
+}
+Le = new WeakMap(), oe = new WeakMap();
+let Ei;
+typeof HTMLElement == "function" && (Ei = class extends HTMLElement {
+  /**
+   * @param {*} $$componentCtor
+   * @param {*} $$slots
+   * @param {ShadowRootInit | undefined} shadow_root_init
+   */
+  constructor(t, r, i) {
+    super();
+    /** The Svelte component constructor */
+    k(this, "$$ctor");
+    /** Slots */
+    k(this, "$$s");
+    /** @type {any} The Svelte component instance */
+    k(this, "$$c");
+    /** Whether or not the custom element is connected */
+    k(this, "$$cn", !1);
+    /** @type {Record<string, any>} Component props data */
+    k(this, "$$d", {});
+    /** `true` if currently in the process of reflecting component props back to attributes */
+    k(this, "$$r", !1);
+    /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+    k(this, "$$p_d", {});
+    /** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
+    k(this, "$$l", {});
+    /** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
+    k(this, "$$l_u", /* @__PURE__ */ new Map());
+    /** @type {any} The managed render effect for reflecting attributes */
+    k(this, "$$me");
+    /** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+    k(this, "$$shadowRoot", null);
+    this.$$ctor = t, this.$$s = r, i && (this.$$shadowRoot = this.attachShadow(i));
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  addEventListener(t, r, i) {
+    if (this.$$l[t] = this.$$l[t] || [], this.$$l[t].push(r), this.$$c) {
+      const n = this.$$c.$on(t, r);
+      this.$$l_u.set(r, n);
+    }
+    super.addEventListener(t, r, i);
+  }
+  /**
+   * @param {string} type
+   * @param {EventListenerOrEventListenerObject} listener
+   * @param {boolean | AddEventListenerOptions} [options]
+   */
+  removeEventListener(t, r, i) {
+    if (super.removeEventListener(t, r, i), this.$$c) {
+      const n = this.$$l_u.get(r);
+      n && (n(), this.$$l_u.delete(r));
+    }
+  }
+  async connectedCallback() {
+    if (this.$$cn = !0, !this.$$c) {
+      let t = function(n) {
+        return (s) => {
+          const l = document.createElement("slot");
+          n !== "default" && (l.name = n), ie(s, l);
+        };
+      };
+      if (await Promise.resolve(), !this.$$cn || this.$$c)
+        return;
+      const r = {}, i = nl(this);
+      for (const n of this.$$s)
+        n in i && (n === "default" && !this.$$d.children ? (this.$$d.children = t(n), r.default = !0) : r[n] = t(n));
+      for (const n of this.attributes) {
+        const s = this.$$g_p(n.name);
+        s in this.$$d || (this.$$d[s] = Qt(s, n.value, this.$$p_d, "toProp"));
+      }
+      for (const n in this.$$p_d)
+        !(n in this.$$d) && this[n] !== void 0 && (this.$$d[n] = this[n], delete this[n]);
+      this.$$c = tl({
+        component: this.$$ctor,
+        target: this.$$shadowRoot || this,
+        props: {
+          ...this.$$d,
+          $$slots: r,
+          $$host: this
+        }
+      }), this.$$me = Cs(() => {
+        zr(() => {
+          this.$$r = !0;
+          for (const n of er(this.$$c)) {
+            if (!this.$$p_d[n]?.reflect) continue;
+            this.$$d[n] = this.$$c[n];
+            const s = Qt(
+              n,
+              this.$$d[n],
+              this.$$p_d,
+              "toAttribute"
+            );
+            s == null ? this.removeAttribute(this.$$p_d[n].attribute || n) : this.setAttribute(this.$$p_d[n].attribute || n, s);
+          }
+          this.$$r = !1;
+        });
+      });
+      for (const n in this.$$l)
+        for (const s of this.$$l[n]) {
+          const l = this.$$c.$on(n, 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, r, i) {
+    this.$$r || (t = this.$$g_p(t), this.$$d[t] = Qt(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 er(this.$$p_d).find(
+      (r) => this.$$p_d[r].attribute === t || !this.$$p_d[r].attribute && r.toLowerCase() === t
+    ) || t;
+  }
+});
+function Qt(e, t, r, i) {
+  const n = r[e]?.type;
+  if (t = n === "Boolean" && typeof t != "boolean" ? t != null : t, !i || !r[e])
+    return t;
+  if (i === "toAttribute")
+    switch (n) {
+      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 (n) {
+      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 nl(e) {
+  const t = {};
+  return e.childNodes.forEach((r) => {
+    t[
+      /** @type {Element} node */
+      r.slot || "default"
+    ] = !0;
+  }), t;
+}
+function il(e, t, r, i, n, s) {
+  let l = class extends Ei {
+    constructor() {
+      super(e, r, n), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return er(t).map(
+        (o) => (t[o].attribute || o).toLowerCase()
+      );
+    }
+  };
+  return er(t).forEach((o) => {
+    tr(l.prototype, o, {
+      get() {
+        return this.$$c && o in this.$$c ? this.$$c[o] : this.$$d[o];
+      },
+      set(f) {
+        f = Qt(o, f, t), this.$$d[o] = f;
+        var u = this.$$c;
+        if (u) {
+          var d = vt(u, o)?.get;
+          d ? u[o] = f : u.$set({ [o]: f });
+        }
+      }
+    });
+  }), i.forEach((o) => {
+    tr(l.prototype, o, {
+      get() {
+        return this.$$c?.[o];
+      }
+    });
+  }), e.element = /** @type {any} */
+  l, l;
+}
+var sl = /* @__PURE__ */ je('<button type="button"><span class="tool-icon svelte-x5tssx" aria-hidden="true"> </span> <span class="tool-label svelte-x5tssx"> </span></button>'), ll = /* @__PURE__ */ je("<pie-tool-calculator></pie-tool-calculator>", 2), ol = /* @__PURE__ */ je("<pie-tool-graph></pie-tool-graph>", 2), al = /* @__PURE__ */ je("<pie-tool-periodic-table></pie-tool-periodic-table>", 2), fl = /* @__PURE__ */ je("<pie-tool-protractor></pie-tool-protractor>", 2), ul = /* @__PURE__ */ je("<pie-tool-line-reader></pie-tool-line-reader>", 2), cl = /* @__PURE__ */ je("<pie-tool-magnifier></pie-tool-magnifier>", 2), dl = /* @__PURE__ */ je("<pie-tool-ruler></pie-tool-ruler>", 2), hl = /* @__PURE__ */ je('<div class="section-tools-toolbar svelte-x5tssx" role="toolbar" aria-label="Assessment tools"><div class="tools-buttons svelte-x5tssx"></div></div>  <!> <!> <!> <!> <!> <!> <!>', 1);
+const vl = {
+  hash: "svelte-x5tssx",
+  code: `.section-tools-toolbar.svelte-x5tssx {display:flex;align-items:center;padding:0.75rem 1rem;background-color:var(--pie-background, #ffffff);border-top:1px solid var(--pie-border, #e0e0e0);min-height:60px;gap:1rem;}.tools-buttons.svelte-x5tssx {display:flex;gap:0.5rem;flex-wrap:wrap;align-items:center;}.tool-button.svelte-x5tssx {display:flex;align-items:center;gap:0.5rem;padding:0.5rem 1rem;background-color:var(--pie-background, #ffffff);border:1px solid var(--pie-border, #d0d0d0);border-radius:4px;cursor:pointer;font-size:0.875rem;color:var(--pie-text, #333);white-space:nowrap;transition:all 0.15s ease;}.tool-button.svelte-x5tssx:hover:not(:disabled) {background-color:var(--pie-secondary-background, #f5f5f5);transform:translateY(-1px);box-shadow:0 2px 4px rgba(0, 0, 0, 0.1);}.tool-button.svelte-x5tssx:active:not(:disabled) {transform:translateY(0);box-shadow:none;}.tool-button.active.svelte-x5tssx {background-color:var(--pie-primary, #1976d2);color:white;border-color:var(--pie-primary, #1976d2);}.tool-button.active.svelte-x5tssx:hover:not(:disabled) {background-color:var(--pie-primary-dark, #1565c0);}.tool-button.svelte-x5tssx:focus-visible {outline:2px solid var(--pie-primary, #1976d2);outline-offset:2px;}.tool-button.svelte-x5tssx:disabled {opacity:0.5;cursor:not-allowed;}.tool-icon.svelte-x5tssx {font-size:1.25rem;line-height:1;}.tool-label.svelte-x5tssx {font-size:0.875rem;font-weight:500;}
+
+	/* Responsive: Hide labels on narrow screens */
+	@media (max-width: 640px) {.tool-label.svelte-x5tssx {display:none;}.tool-button.svelte-x5tssx {padding:0.5rem;}
+	}`
+};
+function _l(e, t) {
+  On(t, !0), Ws(e, vl);
+  const r = typeof window < "u";
+  let i = Er(t, "enabledTools", 7, "calculator,graph,periodicTable,protractor,lineReader,magnifier,ruler"), n = Er(t, "toolCoordinator"), s = Er(t, "toolProviderRegistry"), l = /* @__PURE__ */ cn(() => i().split(",").map((j) => j.trim()).filter(Boolean)), o = /* @__PURE__ */ C(!1), f = /* @__PURE__ */ C(!1), u = /* @__PURE__ */ C(!1), d = /* @__PURE__ */ C(!1), v = /* @__PURE__ */ C(!1), c = /* @__PURE__ */ C(!1), p = /* @__PURE__ */ C(!1);
+  function h() {
+    n() && (A(o, n().isToolVisible("calculator"), !0), A(f, n().isToolVisible("graph"), !0), A(u, n().isToolVisible("periodicTable"), !0), A(d, n().isToolVisible("protractor"), !0), A(v, n().isToolVisible("lineReader"), !0), A(c, n().isToolVisible("magnifier"), !0), A(p, n().isToolVisible("ruler"), !0));
+  }
+  function S(j) {
+    n() && (n().toggleTool(j), h());
+  }
+  let $ = null;
+  $i(() => {
+    n() && (h(), $ = n().subscribe(() => {
+      h();
+    }));
+  }), Ys(() => {
+    $?.();
+  });
+  const W = /* @__PURE__ */ cn(() => [
+    {
+      id: "calculator",
+      label: "Calculator",
+      icon: "🔢",
+      ariaLabel: "Scientific calculator",
+      visible: _(o),
+      enabled: _(l).includes("calculator")
+    },
+    {
+      id: "graph",
+      label: "Graph",
+      icon: "📈",
+      ariaLabel: "Graphing tool",
+      visible: _(f),
+      enabled: _(l).includes("graph")
+    },
+    {
+      id: "periodicTable",
+      label: "Periodic Table",
+      icon: "⚛️",
+      ariaLabel: "Periodic table of elements",
+      visible: _(u),
+      enabled: _(l).includes("periodicTable")
+    },
+    {
+      id: "protractor",
+      label: "Protractor",
+      icon: "📐",
+      ariaLabel: "Angle measurement tool",
+      visible: _(d),
+      enabled: _(l).includes("protractor")
+    },
+    {
+      id: "lineReader",
+      label: "Line Reader",
+      icon: "📏",
+      ariaLabel: "Line reading guide",
+      visible: _(v),
+      enabled: _(l).includes("lineReader")
+    },
+    {
+      id: "magnifier",
+      label: "Magnifier",
+      icon: "🔍",
+      ariaLabel: "Text magnification tool",
+      visible: _(c),
+      enabled: _(l).includes("magnifier")
+    },
+    {
+      id: "ruler",
+      label: "Ruler",
+      icon: "📏",
+      ariaLabel: "Measurement ruler",
+      visible: _(p),
+      enabled: _(l).includes("ruler")
+    }
+  ]);
+  let O = /* @__PURE__ */ C(null), me = /* @__PURE__ */ C(null), J = /* @__PURE__ */ C(null), ne = /* @__PURE__ */ C(null), X = /* @__PURE__ */ C(null), we = /* @__PURE__ */ C(null), V = /* @__PURE__ */ C(null);
+  Lr(() => {
+    n() && (_(O) && (_(O).coordinator = n()), _(me) && (_(me).coordinator = n()), _(J) && (_(J).coordinator = n()), _(ne) && (_(ne).coordinator = n()), _(X) && (_(X).coordinator = n()), _(we) && (_(we).coordinator = n()), _(V) && (_(V).coordinator = n()));
+  }), Lr(() => {
+    r && s() && _(l).includes("calculator") && s().getProvider("calculator-desmos").catch((j) => {
+      console.warn("[SectionToolsToolbar] Calculator provider not available:", j);
+    });
+  });
+  var he = {
+    get enabledTools() {
+      return i();
+    },
+    set enabledTools(j = "calculator,graph,periodicTable,protractor,lineReader,magnifier,ruler") {
+      i(j), Kt();
+    },
+    get toolCoordinator() {
+      return n();
+    },
+    set toolCoordinator(j) {
+      n(j), Kt();
+    },
+    get toolProviderRegistry() {
+      return s();
+    },
+    set toolProviderRegistry(j) {
+      s(j), Kt();
+    }
+  }, Ht = pn(), gr = yr(Ht);
+  {
+    var Ti = (j) => {
+      var Jr = hl(), br = yr(Jr), Xr = Ut(br);
+      zs(Xr, 21, () => _(W), (E) => E.id, (E, g) => {
+        var L = pn(), Pi = yr(L);
+        {
+          var Li = (mr) => {
+            var qe = sl();
+            let sn;
+            qe.__click = () => S(_(g).id);
+            var wr = Ut(qe), Mi = Ut(wr, !0);
+            Ct(wr);
+            var ln = Be(wr, 2), Di = Ut(ln, !0);
+            Ct(ln), Ct(qe), Ae(() => {
+              sn = Xs(qe, 1, "tool-button svelte-x5tssx", null, sn, { active: _(g).visible }), Zt(qe, "title", _(g).ariaLabel), Zt(qe, "aria-label", _(g).ariaLabel), Zt(qe, "aria-pressed", _(g).visible), gn(Mi, _(g).icon), gn(Di, _(g).label);
+            }), ie(mr, qe);
+          };
+          ke(Pi, (mr) => {
+            _(g).enabled && mr(Li);
+          });
+        }
+        ie(E, L);
+      }), Ct(Xr), Ct(br);
+      var Zr = Be(br, 2);
+      {
+        var xi = (E) => {
+          var g = ll();
+          Ae(() => q(g, "visible", _(o))), Ae(() => q(g, "coordinator", s() ? {
+            getToolProvider: (L) => s().getProvider(L)
+          } : void 0)), q(g, "tool-id", "calculator"), Je(g, (L) => A(O, L), () => _(O)), ie(E, g);
+        };
+        ke(Zr, (E) => {
+          _(l).includes("calculator") && E(xi);
+        });
+      }
+      var Qr = Be(Zr, 2);
+      {
+        var Si = (E) => {
+          var g = ol();
+          Ae(() => q(g, "visible", _(f))), q(g, "tool-id", "graph"), Je(g, (L) => A(me, L), () => _(me)), ie(E, g);
+        };
+        ke(Qr, (E) => {
+          _(l).includes("graph") && E(Si);
+        });
+      }
+      var en = Be(Qr, 2);
+      {
+        var Ri = (E) => {
+          var g = al();
+          Ae(() => q(g, "visible", _(u))), q(g, "tool-id", "periodicTable"), Je(g, (L) => A(J, L), () => _(J)), ie(E, g);
+        };
+        ke(en, (E) => {
+          _(l).includes("periodicTable") && E(Ri);
+        });
+      }
+      var tn = Be(en, 2);
+      {
+        var Ai = (E) => {
+          var g = fl();
+          Ae(() => q(g, "visible", _(d))), q(g, "tool-id", "protractor"), Je(g, (L) => A(ne, L), () => _(ne)), ie(E, g);
+        };
+        ke(tn, (E) => {
+          _(l).includes("protractor") && E(Ai);
+        });
+      }
+      var rn = Be(tn, 2);
+      {
+        var ki = (E) => {
+          var g = ul();
+          Ae(() => q(g, "visible", _(v))), q(g, "tool-id", "lineReader"), Je(g, (L) => A(X, L), () => _(X)), ie(E, g);
+        };
+        ke(rn, (E) => {
+          _(l).includes("lineReader") && E(ki);
+        });
+      }
+      var nn = Be(rn, 2);
+      {
+        var Ci = (E) => {
+          var g = cl();
+          Ae(() => q(g, "visible", _(c))), q(g, "tool-id", "magnifier"), Je(g, (L) => A(we, L), () => _(we)), ie(E, g);
+        };
+        ke(nn, (E) => {
+          _(l).includes("magnifier") && E(Ci);
+        });
+      }
+      var Ni = Be(nn, 2);
+      {
+        var Oi = (E) => {
+          var g = dl();
+          Ae(() => q(g, "visible", _(p))), q(g, "tool-id", "ruler"), Je(g, (L) => A(V, L), () => _(V)), ie(E, g);
+        };
+        ke(Ni, (E) => {
+          _(l).includes("ruler") && E(Oi);
+        });
+      }
+      ie(j, Jr);
+    };
+    ke(gr, (j) => {
+      r && j(Ti);
+    });
+  }
+  return ie(e, Ht), Pn(he);
+}
+Fs(["click"]);
+customElements.define("pie-section-tools-toolbar", il(
+  _l,
+  {
+    enabledTools: { attribute: "enabled-tools", type: "String" },
+    toolCoordinator: { type: "Object" },
+    toolProviderRegistry: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  _l as default
+};
+//# sourceMappingURL=section-tools-toolbar.js.map