@pie-players/pie-tool-calculator-desmos 0.3.3

package/dist/pie-tool-calculator.js

@@ -0,0 +1,2955 @@
+var $i = Object.defineProperty;
+var Fr = (e) => {
+  throw TypeError(e);
+};
+var Ei = (e, t, r) => t in e ? $i(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var k = (e, t, r) => Ei(e, typeof t != "symbol" ? t + "" : t, r), or = (e, t, r) => t.has(e) || Fr("Cannot " + r);
+var l = (e, t, r) => (or(e, t, "read from private field"), r ? r.call(e) : t.get(e)), y = (e, t, r) => t.has(e) ? Fr("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), w = (e, t, r, i) => (or(e, t, "write to private field"), i ? i.call(e, r) : t.set(e, r), r), S = (e, t, r) => (or(e, t, "access private method"), r);
+import { connectToolRuntimeContext as Ti } from "@pie-players/pie-assessment-toolkit";
+const Ci = "5";
+var on;
+typeof window < "u" && ((on = window.__svelte ?? (window.__svelte = {})).v ?? (on.v = /* @__PURE__ */ new Set())).add(Ci);
+const Ri = 1, Ai = 4, ki = 8, Si = 16, Ii = 2, an = "[", fn = "[!", Ur = "[?", un = "]", dt = {}, M = /* @__PURE__ */ Symbol(), cn = "http://www.w3.org/1999/xhtml", ur = !1;
+var Ni = Array.isArray, Oi = Array.prototype.indexOf, ht = Array.prototype.includes, xi = Array.from, Vt = Object.keys, Yt = Object.defineProperty, Ye = Object.getOwnPropertyDescriptor, Li = Object.getOwnPropertyDescriptors, Pi = Object.prototype, Di = Array.prototype, dn = Object.getPrototypeOf, Br = Object.isExtensible;
+const Mi = () => {
+};
+function Fi(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function hn() {
+  var e, t, r = new Promise((i, n) => {
+    e = i, t = n;
+  });
+  return { promise: r, resolve: e, reject: t };
+}
+const B = 2, yt = 4, _t = 8, Cr = 1 << 24, De = 16, we = 32, Me = 64, cr = 128, te = 512, F = 1024, U = 2048, ue = 4096, re = 8192, Ae = 16384, Ze = 32768, vt = 65536, jr = 1 << 17, Ui = 1 << 18, Qe = 1 << 19, Bi = 1 << 20, Je = 65536, dr = 1 << 21, Rr = 1 << 22, xe = 1 << 23, $t = /* @__PURE__ */ Symbol("$state"), _n = /* @__PURE__ */ Symbol("legacy props"), ji = /* @__PURE__ */ Symbol(""), Ue = new class extends Error {
+  constructor() {
+    super(...arguments);
+    k(this, "name", "StaleReactionError");
+    k(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}(), zi = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  !!globalThis.document?.contentType && /* @__PURE__ */ globalThis.document.contentType.includes("xml")
+), Ar = 3, Zt = 8;
+function qi(e) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+function Hi() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function Gi(e) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function Vi() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function Yi(e) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function Ki() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Wi() {
+  throw new Error("https://svelte.dev/e/hydration_failed");
+}
+function Ji(e) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function Xi() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function Zi() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Qi() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function es() {
+  throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror");
+}
+function Qt(e) {
+  console.warn("https://svelte.dev/e/hydration_mismatch");
+}
+function ts() {
+  console.warn("https://svelte.dev/e/svelte_boundary_reset_noop");
+}
+let D = !1;
+function nt(e) {
+  D = e;
+}
+let N;
+function pe(e) {
+  if (e === null)
+    throw Qt(), dt;
+  return N = e;
+}
+function kr() {
+  return pe(/* @__PURE__ */ Fe(N));
+}
+function Pt(e) {
+  if (D) {
+    if (/* @__PURE__ */ Fe(N) !== null)
+      throw Qt(), dt;
+    N = e;
+  }
+}
+function rs(e = 1) {
+  if (D) {
+    for (var t = e, r = N; t--; )
+      r = /** @type {TemplateNode} */
+      /* @__PURE__ */ Fe(r);
+    N = r;
+  }
+}
+function vn(e = !0) {
+  for (var t = 0, r = N; ; ) {
+    if (r.nodeType === Zt) {
+      var i = (
+        /** @type {Comment} */
+        r.data
+      );
+      if (i === un) {
+        if (t === 0) return r;
+        t -= 1;
+      } else (i === an || i === fn || // "[1", "[2", etc. for if blocks
+      i[0] === "[" && !isNaN(Number(i.slice(1)))) && (t += 1);
+    }
+    var n = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Fe(r)
+    );
+    e && r.remove(), r = n;
+  }
+}
+function ns(e) {
+  if (!e || e.nodeType !== Zt)
+    throw Qt(), dt;
+  return (
+    /** @type {Comment} */
+    e.data
+  );
+}
+function pn(e) {
+  return e === this.v;
+}
+function is(e, t) {
+  return e != e ? t == t : e !== t || e !== null && typeof e == "object" || typeof e == "function";
+}
+function gn(e) {
+  return !is(e, this.v);
+}
+let ss = !1, Z = null;
+function pt(e) {
+  Z = e;
+}
+function wn(e, t = !1, r) {
+  Z = {
+    p: Z,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function yn(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    Z
+  ), r = t.e;
+  if (r !== null) {
+    t.e = null;
+    for (var i of r)
+      jn(i);
+  }
+  return e !== void 0 && (t.x = e), t.i = !0, Z = t.p, e ?? /** @type {T} */
+  {};
+}
+function mn() {
+  return !0;
+}
+let Be = [];
+function bn() {
+  var e = Be;
+  Be = [], Fi(e);
+}
+function Ke(e) {
+  if (Be.length === 0 && !Et) {
+    var t = Be;
+    queueMicrotask(() => {
+      t === Be && bn();
+    });
+  }
+  Be.push(e);
+}
+function ls() {
+  for (; Be.length > 0; )
+    bn();
+}
+function $n(e) {
+  var t = E;
+  if (t === null)
+    return m.f |= xe, e;
+  if ((t.f & Ze) === 0 && (t.f & yt) === 0)
+    throw e;
+  Oe(e, t);
+}
+function Oe(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & cr) !== 0) {
+      if ((t.f & Ze) === 0)
+        throw e;
+      try {
+        t.b.error(e);
+        return;
+      } catch (r) {
+        e = r;
+      }
+    }
+    t = t.parent;
+  }
+  throw e;
+}
+const os = -7169;
+function P(e, t) {
+  e.f = e.f & os | t;
+}
+function Sr(e) {
+  (e.f & te) !== 0 || e.deps === null ? P(e, F) : P(e, ue);
+}
+function En(e) {
+  if (e !== null)
+    for (const t of e)
+      (t.f & B) === 0 || (t.f & Je) === 0 || (t.f ^= Je, En(
+        /** @type {Derived} */
+        t.deps
+      ));
+}
+function Tn(e, t, r) {
+  (e.f & U) !== 0 ? t.add(e) : (e.f & ue) !== 0 && r.add(e), En(e.deps), P(e, F);
+}
+const Dt = /* @__PURE__ */ new Set();
+let I = null, ae = null, H = [], er = null, Et = !1, gt = null, as = 1;
+var Se, it, qe, st, lt, ot, Ie, ce, at, Y, hr, _r, vr, pr;
+const Pr = class Pr {
+  constructor() {
+    y(this, Y);
+    // for debugging. TODO remove once async is stable
+    k(this, "id", as++);
+    /**
+     * 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<(batch: Batch) => void>}
+     */
+    y(this, Se, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    y(this, it, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    y(this, qe, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    y(this, st, 0);
+    /**
+     * A deferred that resolves when the batch is committed, used with `settled()`
+     * TODO replace with Promise.withResolvers once supported widely enough
+     * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
+     */
+    y(this, lt, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, ot, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    y(this, Ie, /* @__PURE__ */ new Set());
+    /**
+     * A map of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`.
+     * The value contains child effects that were dirty/maybe_dirty before being reset,
+     * so they can be rescheduled if the branch survives.
+     * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
+     */
+    y(this, ce, /* @__PURE__ */ new Map());
+    k(this, "is_fork", !1);
+    y(this, at, !1);
+  }
+  /**
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
+   */
+  skip_effect(t) {
+    l(this, ce).has(t) || l(this, ce).set(t, { d: [], m: [] });
+  }
+  /**
+   * Remove an effect from the #skipped_branches map and reschedule
+   * any tracked dirty/maybe_dirty child effects
+   * @param {Effect} effect
+   */
+  unskip_effect(t) {
+    var r = l(this, ce).get(t);
+    if (r) {
+      l(this, ce).delete(t);
+      for (var i of r.d)
+        P(i, U), ve(i);
+      for (i of r.m)
+        P(i, ue), ve(i);
+    }
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    H = [], this.apply();
+    var r = gt = [], i = [];
+    for (const n of t)
+      S(this, Y, _r).call(this, n, r, i);
+    if (gt = null, S(this, Y, hr).call(this)) {
+      S(this, Y, vr).call(this, i), S(this, Y, vr).call(this, r);
+      for (const [n, s] of l(this, ce))
+        kn(n, s);
+    } else {
+      I = null;
+      for (const n of l(this, Se)) n(this);
+      l(this, Se).clear(), l(this, qe) === 0 && S(this, Y, pr).call(this), zr(i), zr(r), l(this, ot).clear(), l(this, Ie).clear(), l(this, lt)?.resolve();
+    }
+    ae = null;
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(t, r) {
+    r !== M && !this.previous.has(t) && this.previous.set(t, r), (t.f & xe) === 0 && (this.current.set(t, t.v), ae?.set(t, t.v));
+  }
+  activate() {
+    I = this, this.apply();
+  }
+  deactivate() {
+    I === this && (I = null, ae = null);
+  }
+  flush() {
+    if (H.length > 0)
+      I = this, Cn();
+    else if (l(this, qe) === 0 && !this.is_fork) {
+      for (const t of l(this, Se)) t(this);
+      l(this, Se).clear(), S(this, Y, pr).call(this), l(this, lt)?.resolve();
+    }
+    this.deactivate();
+  }
+  discard() {
+    for (const t of l(this, it)) t(this);
+    l(this, it).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    w(this, qe, l(this, qe) + 1), t && w(this, st, l(this, st) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    w(this, qe, l(this, qe) - 1), t && w(this, st, l(this, st) - 1), !l(this, at) && (w(this, at, !0), Ke(() => {
+      w(this, at, !1), S(this, Y, hr).call(this) ? H.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const t of l(this, ot))
+      l(this, Ie).delete(t), P(t, U), ve(t);
+    for (const t of l(this, Ie))
+      P(t, ue), ve(t);
+    this.flush();
+  }
+  /** @param {(batch: Batch) => void} fn */
+  oncommit(t) {
+    l(this, Se).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    l(this, it).add(t);
+  }
+  settled() {
+    return (l(this, lt) ?? w(this, lt, hn())).promise;
+  }
+  static ensure() {
+    if (I === null) {
+      const t = I = new Pr();
+      Dt.add(I), Et || Ke(() => {
+        I === t && t.flush();
+      });
+    }
+    return I;
+  }
+  apply() {
+  }
+};
+Se = new WeakMap(), it = new WeakMap(), qe = new WeakMap(), st = new WeakMap(), lt = new WeakMap(), ot = new WeakMap(), Ie = new WeakMap(), ce = new WeakMap(), at = new WeakMap(), Y = new WeakSet(), hr = function() {
+  return this.is_fork || l(this, st) > 0;
+}, /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ * @param {Effect[]} effects
+ * @param {Effect[]} render_effects
+ */
+_r = function(t, r, i) {
+  t.f ^= F;
+  for (var n = t.first; n !== null; ) {
+    var s = n.f, o = (s & (we | Me)) !== 0, a = o && (s & F) !== 0, f = (s & re) !== 0, u = a || l(this, ce).has(n);
+    if (!u && n.fn !== null) {
+      o ? f || (n.f ^= F) : (s & yt) !== 0 ? r.push(n) : (s & (_t | Cr)) !== 0 && f ? i.push(n) : Nt(n) && (wt(n), (s & De) !== 0 && (l(this, Ie).add(n), f && P(n, U)));
+      var _ = n.first;
+      if (_ !== null) {
+        n = _;
+        continue;
+      }
+    }
+    for (; n !== null; ) {
+      var h = n.next;
+      if (h !== null) {
+        n = h;
+        break;
+      }
+      n = n.parent;
+    }
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+vr = function(t) {
+  for (var r = 0; r < t.length; r += 1)
+    Tn(t[r], l(this, ot), l(this, Ie));
+}, pr = function() {
+  var s;
+  if (Dt.size > 1) {
+    this.previous.clear();
+    var t = I, r = ae, i = !0;
+    for (const o of Dt) {
+      if (o === this) {
+        i = !1;
+        continue;
+      }
+      const a = [];
+      for (const [u, _] of this.current) {
+        if (o.current.has(u))
+          if (i && _ !== o.current.get(u))
+            o.current.set(u, _);
+          else
+            continue;
+        a.push(u);
+      }
+      if (a.length === 0)
+        continue;
+      const f = [...o.current.keys()].filter((u) => !this.current.has(u));
+      if (f.length > 0) {
+        var n = H;
+        H = [];
+        const u = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Map();
+        for (const h of a)
+          Rn(h, f, u, _);
+        if (H.length > 0) {
+          I = o, o.apply();
+          for (const h of H)
+            S(s = o, Y, _r).call(s, h, [], []);
+          o.deactivate();
+        }
+        H = n;
+      }
+    }
+    I = t, ae = r;
+  }
+  l(this, ce).clear(), Dt.delete(this);
+};
+let ke = Pr;
+function et(e) {
+  var t = Et;
+  Et = !0;
+  try {
+    for (var r; ; ) {
+      if (ls(), H.length === 0 && (I?.flush(), H.length === 0))
+        return er = null, /** @type {T} */
+        r;
+      Cn();
+    }
+  } finally {
+    Et = t;
+  }
+}
+function Cn() {
+  var e = null;
+  try {
+    for (var t = 0; H.length > 0; ) {
+      var r = ke.ensure();
+      if (t++ > 1e3) {
+        var i, n;
+        fs();
+      }
+      r.process(H), Le.clear();
+    }
+  } finally {
+    H = [], er = null, gt = null;
+  }
+}
+function fs() {
+  try {
+    Ki();
+  } catch (e) {
+    Oe(e, er);
+  }
+}
+let $e = null;
+function zr(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var r = 0; r < t; ) {
+      var i = e[r++];
+      if ((i.f & (Ae | re)) === 0 && Nt(i) && ($e = /* @__PURE__ */ new Set(), wt(i), i.deps === null && i.first === null && i.nodes === null && i.teardown === null && i.ac === null && Gn(i), $e?.size > 0)) {
+        Le.clear();
+        for (const n of $e) {
+          if ((n.f & (Ae | re)) !== 0) continue;
+          const s = [n];
+          let o = n.parent;
+          for (; o !== null; )
+            $e.has(o) && ($e.delete(o), s.push(o)), o = o.parent;
+          for (let a = s.length - 1; a >= 0; a--) {
+            const f = s[a];
+            (f.f & (Ae | re)) === 0 && wt(f);
+          }
+        }
+        $e.clear();
+      }
+    }
+    $e = null;
+  }
+}
+function Rn(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 & B) !== 0 ? Rn(
+        /** @type {Derived} */
+        n,
+        t,
+        r,
+        i
+      ) : (s & (Rr | De)) !== 0 && (s & U) === 0 && An(n, t, i) && (P(n, U), ve(
+        /** @type {Effect} */
+        n
+      ));
+    }
+}
+function An(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 (ht.call(t, n))
+        return !0;
+      if ((n.f & B) !== 0 && An(
+        /** @type {Derived} */
+        n,
+        t,
+        r
+      ))
+        return r.set(
+          /** @type {Derived} */
+          n,
+          !0
+        ), !0;
+    }
+  return r.set(e, !1), !1;
+}
+function ve(e) {
+  var t = er = e, r = t.b;
+  if (r?.is_pending && (e.f & (yt | _t | Cr)) !== 0 && (e.f & Ze) === 0) {
+    r.defer_effect(e);
+    return;
+  }
+  for (; t.parent !== null; ) {
+    t = t.parent;
+    var i = t.f;
+    if (gt !== null && t === E && (e.f & _t) === 0)
+      return;
+    if ((i & (Me | we)) !== 0) {
+      if ((i & F) === 0)
+        return;
+      t.f ^= F;
+    }
+  }
+  H.push(t);
+}
+function kn(e, t) {
+  if (!((e.f & we) !== 0 && (e.f & F) !== 0)) {
+    (e.f & U) !== 0 ? t.d.push(e) : (e.f & ue) !== 0 && t.m.push(e), P(e, F);
+    for (var r = e.first; r !== null; )
+      kn(r, t), r = r.next;
+  }
+}
+function us(e) {
+  let t = 0, r = It(0), i;
+  return () => {
+    Or() && (c(r), xr(() => (t === 0 && (i = rr(() => e(() => Tt(r)))), t += 1, () => {
+      Ke(() => {
+        t -= 1, t === 0 && (i?.(), i = void 0, Tt(r));
+      });
+    })));
+  };
+}
+var cs = vt | Qe;
+function ds(e, t, r, i) {
+  new hs(e, t, r, i);
+}
+var W, At, de, He, q, he, J, le, Te, Ge, Ne, ft, ut, ct, Ce, Jt, O, Sn, In, Nn, gr, zt, qt, wr;
+class hs {
+  /**
+   * @param {TemplateNode} node
+   * @param {BoundaryProps} props
+   * @param {((anchor: Node) => void)} children
+   * @param {((error: unknown) => unknown) | undefined} [transform_error]
+   */
+  constructor(t, r, i, n) {
+    y(this, O);
+    /** @type {Boundary | null} */
+    k(this, "parent");
+    k(this, "is_pending", !1);
+    /**
+     * API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
+     * Inherited from parent boundary, or defaults to identity.
+     * @type {(error: unknown) => unknown}
+     */
+    k(this, "transform_error");
+    /** @type {TemplateNode} */
+    y(this, W);
+    /** @type {TemplateNode | null} */
+    y(this, At, D ? N : null);
+    /** @type {BoundaryProps} */
+    y(this, de);
+    /** @type {((anchor: Node) => void)} */
+    y(this, He);
+    /** @type {Effect} */
+    y(this, q);
+    /** @type {Effect | null} */
+    y(this, he, null);
+    /** @type {Effect | null} */
+    y(this, J, null);
+    /** @type {Effect | null} */
+    y(this, le, null);
+    /** @type {DocumentFragment | null} */
+    y(this, Te, null);
+    y(this, Ge, 0);
+    y(this, Ne, 0);
+    y(this, ft, !1);
+    /** @type {Set<Effect>} */
+    y(this, ut, /* @__PURE__ */ new Set());
+    /** @type {Set<Effect>} */
+    y(this, ct, /* @__PURE__ */ new Set());
+    /**
+     * A source containing the number of pending async deriveds/expressions.
+     * Only created if `$effect.pending()` is used inside the boundary,
+     * otherwise updating the source results in needless `Batch.ensure()`
+     * calls followed by no-op flushes
+     * @type {Source<number> | null}
+     */
+    y(this, Ce, null);
+    y(this, Jt, us(() => (w(this, Ce, It(l(this, Ge))), () => {
+      w(this, Ce, null);
+    })));
+    w(this, W, t), w(this, de, r), w(this, He, (s) => {
+      var o = (
+        /** @type {Effect} */
+        E
+      );
+      o.b = this, o.f |= cr, i(s);
+    }), this.parent = /** @type {Effect} */
+    E.b, this.transform_error = n ?? this.parent?.transform_error ?? ((s) => s), w(this, q, qn(() => {
+      if (D) {
+        const s = (
+          /** @type {Comment} */
+          l(this, At)
+        );
+        kr();
+        const o = s.data === fn;
+        if (s.data.startsWith(Ur)) {
+          const f = JSON.parse(s.data.slice(Ur.length));
+          S(this, O, In).call(this, f);
+        } else o ? S(this, O, Nn).call(this) : S(this, O, Sn).call(this);
+      } else
+        S(this, O, gr).call(this);
+    }, cs)), D && w(this, W, N);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    Tn(t, l(this, ut), l(this, ct));
+  }
+  /**
+   * Returns `false` if the effect exists inside a boundary whose pending snippet is shown
+   * @returns {boolean}
+   */
+  is_rendered() {
+    return !this.is_pending && (!this.parent || this.parent.is_rendered());
+  }
+  has_pending_snippet() {
+    return !!l(this, de).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) {
+    S(this, O, wr).call(this, t), w(this, Ge, l(this, Ge) + t), !(!l(this, Ce) || l(this, ft)) && (w(this, ft, !0), Ke(() => {
+      w(this, ft, !1), l(this, Ce) && Kt(l(this, Ce), l(this, Ge));
+    }));
+  }
+  get_effect_pending() {
+    return l(this, Jt).call(this), c(
+      /** @type {Source<number>} */
+      l(this, Ce)
+    );
+  }
+  /** @param {unknown} error */
+  error(t) {
+    var r = l(this, de).onerror;
+    let i = l(this, de).failed;
+    if (!r && !i)
+      throw t;
+    l(this, he) && (V(l(this, he)), w(this, he, null)), l(this, J) && (V(l(this, J)), w(this, J, null)), l(this, le) && (V(l(this, le)), w(this, le, null)), D && (pe(
+      /** @type {TemplateNode} */
+      l(this, At)
+    ), rs(), pe(vn()));
+    var n = !1, s = !1;
+    const o = () => {
+      if (n) {
+        ts();
+        return;
+      }
+      n = !0, s && es(), l(this, le) !== null && Ct(l(this, le), () => {
+        w(this, le, null);
+      }), S(this, O, qt).call(this, () => {
+        ke.ensure(), S(this, O, gr).call(this);
+      });
+    }, a = (f) => {
+      try {
+        s = !0, r?.(f, o), s = !1;
+      } catch (u) {
+        Oe(u, l(this, q) && l(this, q).parent);
+      }
+      i && w(this, le, S(this, O, qt).call(this, () => {
+        ke.ensure();
+        try {
+          return Ee(() => {
+            var u = (
+              /** @type {Effect} */
+              E
+            );
+            u.b = this, u.f |= cr, i(
+              l(this, W),
+              () => f,
+              () => o
+            );
+          });
+        } catch (u) {
+          return Oe(
+            u,
+            /** @type {Effect} */
+            l(this, q).parent
+          ), null;
+        }
+      }));
+    };
+    Ke(() => {
+      var f;
+      try {
+        f = this.transform_error(t);
+      } catch (u) {
+        Oe(u, l(this, q) && l(this, q).parent);
+        return;
+      }
+      f !== null && typeof f == "object" && typeof /** @type {any} */
+      f.then == "function" ? f.then(
+        a,
+        /** @param {unknown} e */
+        (u) => Oe(u, l(this, q) && l(this, q).parent)
+      ) : a(f);
+    });
+  }
+}
+W = new WeakMap(), At = new WeakMap(), de = new WeakMap(), He = new WeakMap(), q = new WeakMap(), he = new WeakMap(), J = new WeakMap(), le = new WeakMap(), Te = new WeakMap(), Ge = new WeakMap(), Ne = new WeakMap(), ft = new WeakMap(), ut = new WeakMap(), ct = new WeakMap(), Ce = new WeakMap(), Jt = new WeakMap(), O = new WeakSet(), Sn = function() {
+  try {
+    w(this, he, Ee(() => l(this, He).call(this, l(this, W))));
+  } catch (t) {
+    this.error(t);
+  }
+}, /**
+ * @param {unknown} error The deserialized error from the server's hydration comment
+ */
+In = function(t) {
+  const r = l(this, de).failed;
+  r && w(this, le, Ee(() => {
+    r(
+      l(this, W),
+      () => t,
+      () => () => {
+      }
+    );
+  }));
+}, Nn = function() {
+  const t = l(this, de).pending;
+  t && (this.is_pending = !0, w(this, J, Ee(() => t(l(this, W)))), Ke(() => {
+    var r = w(this, Te, document.createDocumentFragment()), i = Xe();
+    r.append(i), w(this, he, S(this, O, qt).call(this, () => (ke.ensure(), Ee(() => l(this, He).call(this, i))))), l(this, Ne) === 0 && (l(this, W).before(r), w(this, Te, null), Ct(
+      /** @type {Effect} */
+      l(this, J),
+      () => {
+        w(this, J, null);
+      }
+    ), S(this, O, zt).call(this));
+  }));
+}, gr = function() {
+  try {
+    if (this.is_pending = this.has_pending_snippet(), w(this, Ne, 0), w(this, Ge, 0), w(this, he, Ee(() => {
+      l(this, He).call(this, l(this, W));
+    })), l(this, Ne) > 0) {
+      var t = w(this, Te, document.createDocumentFragment());
+      Kn(l(this, he), t);
+      const r = (
+        /** @type {(anchor: Node) => void} */
+        l(this, de).pending
+      );
+      w(this, J, Ee(() => r(l(this, W))));
+    } else
+      S(this, O, zt).call(this);
+  } catch (r) {
+    this.error(r);
+  }
+}, zt = function() {
+  this.is_pending = !1;
+  for (const t of l(this, ut))
+    P(t, U), ve(t);
+  for (const t of l(this, ct))
+    P(t, ue), ve(t);
+  l(this, ut).clear(), l(this, ct).clear();
+}, /**
+ * @template T
+ * @param {() => T} fn
+ */
+qt = function(t) {
+  var r = E, i = m, n = Z;
+  ge(l(this, q)), ie(l(this, q)), pt(l(this, q).ctx);
+  try {
+    return t();
+  } catch (s) {
+    return $n(s), null;
+  } finally {
+    ge(r), ie(i), pt(n);
+  }
+}, /**
+ * 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
+ */
+wr = function(t) {
+  var r;
+  if (!this.has_pending_snippet()) {
+    this.parent && S(r = this.parent, O, wr).call(r, t);
+    return;
+  }
+  w(this, Ne, l(this, Ne) + t), l(this, Ne) === 0 && (S(this, O, zt).call(this), l(this, J) && Ct(l(this, J), () => {
+    w(this, J, null);
+  }), l(this, Te) && (l(this, W).before(l(this, Te)), w(this, Te, null)));
+};
+function _s(e, t, r, i) {
+  const n = tr;
+  var s = e.filter((h) => !h.settled);
+  if (r.length === 0 && s.length === 0) {
+    i(t.map(n));
+    return;
+  }
+  var o = (
+    /** @type {Effect} */
+    E
+  ), a = vs(), f = s.length === 1 ? s[0].promise : s.length > 1 ? Promise.all(s.map((h) => h.promise)) : null;
+  function u(h) {
+    a();
+    try {
+      i(h);
+    } catch (d) {
+      (o.f & Ae) === 0 && Oe(d, o);
+    }
+    yr();
+  }
+  if (r.length === 0) {
+    f.then(() => u(t.map(n)));
+    return;
+  }
+  function _() {
+    a(), Promise.all(r.map((h) => /* @__PURE__ */ gs(h))).then((h) => u([...t.map(n), ...h])).catch((h) => Oe(h, o));
+  }
+  f ? f.then(_) : _();
+}
+function vs() {
+  var e = E, t = m, r = Z, i = I;
+  return function(s = !0) {
+    ge(e), ie(t), pt(r), s && i?.activate();
+  };
+}
+function yr(e = !0) {
+  ge(null), ie(null), pt(null), e && I?.deactivate();
+}
+function ps() {
+  var e = (
+    /** @type {Boundary} */
+    /** @type {Effect} */
+    E.b
+  ), t = (
+    /** @type {Batch} */
+    I
+  ), r = e.is_rendered();
+  return e.update_pending_count(1), t.increment(r), () => {
+    e.update_pending_count(-1), t.decrement(r);
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function tr(e) {
+  var t = B | U, r = m !== null && (m.f & B) !== 0 ? (
+    /** @type {Derived} */
+    m
+  ) : null;
+  return E !== null && (E.f |= Qe), {
+    ctx: Z,
+    deps: null,
+    effects: null,
+    equals: pn,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      M
+    ),
+    wv: 0,
+    parent: r ?? E,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function gs(e, t, r) {
+  /** @type {Effect | null} */
+  E === null && Hi();
+  var n = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), s = It(
+    /** @type {V} */
+    M
+  ), o = !m, a = /* @__PURE__ */ new Map();
+  return Ns(() => {
+    var f = hn();
+    n = f.promise;
+    try {
+      Promise.resolve(e()).then(f.resolve, f.reject).finally(yr);
+    } catch (d) {
+      f.reject(d), yr();
+    }
+    var u = (
+      /** @type {Batch} */
+      I
+    );
+    if (o) {
+      var _ = ps();
+      a.get(u)?.reject(Ue), a.delete(u), a.set(u, f);
+    }
+    const h = (d, v = void 0) => {
+      if (u.activate(), v)
+        v !== Ue && (s.f |= xe, Kt(s, v));
+      else {
+        (s.f & xe) !== 0 && (s.f ^= xe), Kt(s, d);
+        for (const [g, T] of a) {
+          if (a.delete(g), g === u) break;
+          T.reject(Ue);
+        }
+      }
+      _ && _();
+    };
+    f.promise.then(h, (d) => h(null, d || "unknown"));
+  }), ks(() => {
+    for (const f of a.values())
+      f.reject(Ue);
+  }), new Promise((f) => {
+    function u(_) {
+      function h() {
+        _ === n ? f(s) : u(n);
+      }
+      _.then(h, h);
+    }
+    u(n);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function qr(e) {
+  const t = /* @__PURE__ */ tr(e);
+  return Wn(t), t;
+}
+// @__NO_SIDE_EFFECTS__
+function ws(e) {
+  const t = /* @__PURE__ */ tr(e);
+  return t.equals = gn, t;
+}
+function ys(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var r = 0; r < t.length; r += 1)
+      V(
+        /** @type {Effect} */
+        t[r]
+      );
+  }
+}
+function ms(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & B) === 0)
+      return (t.f & Ae) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function Ir(e) {
+  var t, r = E;
+  ge(ms(e));
+  try {
+    e.f &= ~Je, ys(e), t = Qn(e);
+  } finally {
+    ge(r);
+  }
+  return t;
+}
+function On(e) {
+  var t = Ir(e);
+  if (!e.equals(t) && (e.wv = Xn(), (!I?.is_fork || e.deps === null) && (e.v = t, e.deps === null))) {
+    P(e, F);
+    return;
+  }
+  Pe || (ae !== null ? (Or() || I?.is_fork) && ae.set(e, t) : Sr(e));
+}
+function bs(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      (t.teardown || t.ac) && (t.teardown?.(), t.ac?.abort(Ue), t.teardown = Mi, t.ac = null, Rt(t, 0), Lr(t));
+}
+function xn(e) {
+  if (e.effects !== null)
+    for (const t of e.effects)
+      t.teardown && wt(t);
+}
+let mr = /* @__PURE__ */ new Set();
+const Le = /* @__PURE__ */ new Map();
+let Ln = !1;
+function It(e, t) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: pn,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function L(e, t) {
+  const r = It(e);
+  return Wn(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function $s(e, t = !1, r = !0) {
+  const i = It(e);
+  return t || (i.equals = gn), i;
+}
+function $(e, t, r = !1) {
+  m !== 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
+  (!fe || (m.f & jr) !== 0) && mn() && (m.f & (B | De | Rr | jr)) !== 0 && (ne === null || !ht.call(ne, e)) && Qi();
+  let i = r ? je(t) : t;
+  return Kt(e, i);
+}
+function Kt(e, t) {
+  if (!e.equals(t)) {
+    var r = e.v;
+    Pe ? Le.set(e, t) : Le.set(e, r), e.v = t;
+    var i = ke.ensure();
+    if (i.capture(e, r), (e.f & B) !== 0) {
+      const n = (
+        /** @type {Derived} */
+        e
+      );
+      (e.f & U) !== 0 && Ir(n), Sr(n);
+    }
+    e.wv = Xn(), Pn(e, U), E !== null && (E.f & F) !== 0 && (E.f & (we | Me)) === 0 && (Q === null ? Ps([e]) : Q.push(e)), !i.is_fork && mr.size > 0 && !Ln && Es();
+  }
+  return t;
+}
+function Es() {
+  Ln = !1;
+  for (const e of mr)
+    (e.f & F) !== 0 && P(e, ue), Nt(e) && wt(e);
+  mr.clear();
+}
+function Tt(e) {
+  $(e, e.v + 1);
+}
+function Pn(e, t) {
+  var r = e.reactions;
+  if (r !== null)
+    for (var i = r.length, n = 0; n < i; n++) {
+      var s = r[n], o = s.f, a = (o & U) === 0;
+      if (a && P(s, t), (o & B) !== 0) {
+        var f = (
+          /** @type {Derived} */
+          s
+        );
+        ae?.delete(f), (o & Je) === 0 && (o & te && (s.f |= Je), Pn(f, ue));
+      } else a && ((o & De) !== 0 && $e !== null && $e.add(
+        /** @type {Effect} */
+        s
+      ), ve(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function je(e) {
+  if (typeof e != "object" || e === null || $t in e)
+    return e;
+  const t = dn(e);
+  if (t !== Pi && t !== Di)
+    return e;
+  var r = /* @__PURE__ */ new Map(), i = Ni(e), n = /* @__PURE__ */ L(0), s = We, o = (a) => {
+    if (We === s)
+      return a();
+    var f = m, u = We;
+    ie(null), Yr(s);
+    var _ = a();
+    return ie(f), Yr(u), _;
+  };
+  return i && r.set("length", /* @__PURE__ */ L(
+    /** @type {any[]} */
+    e.length
+  )), new Proxy(
+    /** @type {any} */
+    e,
+    {
+      defineProperty(a, f, u) {
+        (!("value" in u) || u.configurable === !1 || u.enumerable === !1 || u.writable === !1) && Xi();
+        var _ = r.get(f);
+        return _ === void 0 ? o(() => {
+          var h = /* @__PURE__ */ L(u.value);
+          return r.set(f, h), h;
+        }) : $(_, u.value, !0), !0;
+      },
+      deleteProperty(a, f) {
+        var u = r.get(f);
+        if (u === void 0) {
+          if (f in a) {
+            const _ = o(() => /* @__PURE__ */ L(M));
+            r.set(f, _), Tt(n);
+          }
+        } else
+          $(u, M), Tt(n);
+        return !0;
+      },
+      get(a, f, u) {
+        if (f === $t)
+          return e;
+        var _ = r.get(f), h = f in a;
+        if (_ === void 0 && (!h || Ye(a, f)?.writable) && (_ = o(() => {
+          var v = je(h ? a[f] : M), g = /* @__PURE__ */ L(v);
+          return g;
+        }), r.set(f, _)), _ !== void 0) {
+          var d = c(_);
+          return d === M ? void 0 : d;
+        }
+        return Reflect.get(a, f, u);
+      },
+      getOwnPropertyDescriptor(a, f) {
+        var u = Reflect.getOwnPropertyDescriptor(a, f);
+        if (u && "value" in u) {
+          var _ = r.get(f);
+          _ && (u.value = c(_));
+        } else if (u === void 0) {
+          var h = r.get(f), d = h?.v;
+          if (h !== void 0 && d !== M)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: d,
+              writable: !0
+            };
+        }
+        return u;
+      },
+      has(a, f) {
+        if (f === $t)
+          return !0;
+        var u = r.get(f), _ = u !== void 0 && u.v !== M || Reflect.has(a, f);
+        if (u !== void 0 || E !== null && (!_ || Ye(a, f)?.writable)) {
+          u === void 0 && (u = o(() => {
+            var d = _ ? je(a[f]) : M, v = /* @__PURE__ */ L(d);
+            return v;
+          }), r.set(f, u));
+          var h = c(u);
+          if (h === M)
+            return !1;
+        }
+        return _;
+      },
+      set(a, f, u, _) {
+        var h = r.get(f), d = f in a;
+        if (i && f === "length")
+          for (var v = u; v < /** @type {Source<number>} */
+          h.v; v += 1) {
+            var g = r.get(v + "");
+            g !== void 0 ? $(g, M) : v in a && (g = o(() => /* @__PURE__ */ L(M)), r.set(v + "", g));
+          }
+        if (h === void 0)
+          (!d || Ye(a, f)?.writable) && (h = o(() => /* @__PURE__ */ L(void 0)), $(h, je(u)), r.set(f, h));
+        else {
+          d = h.v !== M;
+          var T = o(() => je(u));
+          $(h, T);
+        }
+        var b = Reflect.getOwnPropertyDescriptor(a, f);
+        if (b?.set && b.set.call(_, u), !d) {
+          if (i && typeof f == "string") {
+            var x = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), R = Number(f);
+            Number.isInteger(R) && R >= x.v && $(x, R + 1);
+          }
+          Tt(n);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        c(n);
+        var f = Reflect.ownKeys(a).filter((h) => {
+          var d = r.get(h);
+          return d === void 0 || d.v !== M;
+        });
+        for (var [u, _] of r)
+          _.v !== M && !(u in a) && f.push(u);
+        return f;
+      },
+      setPrototypeOf() {
+        Zi();
+      }
+    }
+  );
+}
+var Hr, Dn, Mn, Fn;
+function br() {
+  if (Hr === void 0) {
+    Hr = window, Dn = /Firefox/.test(navigator.userAgent);
+    var e = Element.prototype, t = Node.prototype, r = Text.prototype;
+    Mn = Ye(t, "firstChild").get, Fn = Ye(t, "nextSibling").get, Br(e) && (e.__click = void 0, e.__className = void 0, e.__attributes = null, e.__style = void 0, e.__e = void 0), Br(r) && (r.__t = void 0);
+  }
+}
+function Xe(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Wt(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Mn.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Fe(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Fn.call(e)
+  );
+}
+function Mt(e, t) {
+  if (!D)
+    return /* @__PURE__ */ Wt(e);
+  var r = /* @__PURE__ */ Wt(N);
+  if (r === null)
+    r = N.appendChild(Xe());
+  else if (t && r.nodeType !== Ar) {
+    var i = Xe();
+    return r?.before(i), pe(i), i;
+  }
+  return t && Un(
+    /** @type {Text} */
+    r
+  ), pe(r), r;
+}
+function ar(e, t = 1, r = !1) {
+  let i = D ? N : e;
+  for (var n; t--; )
+    n = i, i = /** @type {TemplateNode} */
+    /* @__PURE__ */ Fe(i);
+  if (!D)
+    return i;
+  if (r) {
+    if (i?.nodeType !== Ar) {
+      var s = Xe();
+      return i === null ? n?.after(s) : i.before(s), pe(s), s;
+    }
+    Un(
+      /** @type {Text} */
+      i
+    );
+  }
+  return pe(i), i;
+}
+function Ts(e) {
+  e.textContent = "";
+}
+function Cs() {
+  return !1;
+}
+function Nr(e, t, r) {
+  return (
+    /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
+    document.createElementNS(cn, e, void 0)
+  );
+}
+function Un(e) {
+  if (
+    /** @type {string} */
+    e.nodeValue.length < 65536
+  )
+    return;
+  let t = e.nextSibling;
+  for (; t !== null && t.nodeType === Ar; )
+    t.remove(), e.nodeValue += /** @type {string} */
+    t.nodeValue, t = e.nextSibling;
+}
+function Bn(e) {
+  var t = m, r = E;
+  ie(null), ge(null);
+  try {
+    return e();
+  } finally {
+    ie(t), ge(r);
+  }
+}
+function Rs(e) {
+  E === null && (m === null && Yi(), Vi()), Pe && Gi();
+}
+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 ye(e, t) {
+  var r = E;
+  r !== null && (r.f & re) !== 0 && (e |= re);
+  var i = {
+    ctx: Z,
+    deps: null,
+    nodes: null,
+    f: e | U | te,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: r,
+    b: r && r.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  }, n = i;
+  if ((e & yt) !== 0)
+    gt !== null ? gt.push(i) : ve(i);
+  else if (t !== null) {
+    try {
+      wt(i);
+    } catch (o) {
+      throw V(i), o;
+    }
+    n.deps === null && n.teardown === null && n.nodes === null && n.first === n.last && // either `null`, or a singular child
+    (n.f & Qe) === 0 && (n = n.first, (e & De) !== 0 && (e & vt) !== 0 && n !== null && (n.f |= vt));
+  }
+  if (n !== null && (n.parent = r, r !== null && As(n, r), m !== null && (m.f & B) !== 0 && (e & Me) === 0)) {
+    var s = (
+      /** @type {Derived} */
+      m
+    );
+    (s.effects ?? (s.effects = [])).push(n);
+  }
+  return i;
+}
+function Or() {
+  return m !== null && !fe;
+}
+function ks(e) {
+  const t = ye(_t, null);
+  return P(t, F), t.teardown = e, t;
+}
+function tt(e) {
+  Rs();
+  var t = (
+    /** @type {Effect} */
+    E.f
+  ), r = !m && (t & we) !== 0 && (t & Ze) === 0;
+  if (r) {
+    var i = (
+      /** @type {ComponentContext} */
+      Z
+    );
+    (i.e ?? (i.e = [])).push(e);
+  } else
+    return jn(e);
+}
+function jn(e) {
+  return ye(yt | Bi, e);
+}
+function Ss(e) {
+  ke.ensure();
+  const t = ye(Me | Qe, e);
+  return () => {
+    V(t);
+  };
+}
+function Is(e) {
+  ke.ensure();
+  const t = ye(Me | Qe, e);
+  return (r = {}) => new Promise((i) => {
+    r.outro ? Ct(t, () => {
+      V(t), i(void 0);
+    }) : (V(t), i(void 0));
+  });
+}
+function zn(e) {
+  return ye(yt, e);
+}
+function Ns(e) {
+  return ye(Rr | Qe, e);
+}
+function xr(e, t = 0) {
+  return ye(_t | t, e);
+}
+function Gr(e, t = [], r = [], i = []) {
+  _s(i, t, r, (n) => {
+    ye(_t, () => e(...n.map(c)));
+  });
+}
+function qn(e, t = 0) {
+  var r = ye(De | t, e);
+  return r;
+}
+function Ee(e) {
+  return ye(we | Qe, e);
+}
+function Hn(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const r = Pe, i = m;
+    Vr(!0), ie(null);
+    try {
+      t.call(null);
+    } finally {
+      Vr(r), ie(i);
+    }
+  }
+}
+function Lr(e, t = !1) {
+  var r = e.first;
+  for (e.first = e.last = null; r !== null; ) {
+    const n = r.ac;
+    n !== null && Bn(() => {
+      n.abort(Ue);
+    });
+    var i = r.next;
+    (r.f & Me) !== 0 ? r.parent = null : V(r, t), r = i;
+  }
+}
+function Os(e) {
+  for (var t = e.first; t !== null; ) {
+    var r = t.next;
+    (t.f & we) === 0 && V(t), t = r;
+  }
+}
+function V(e, t = !0) {
+  var r = !1;
+  (t || (e.f & Ui) !== 0) && e.nodes !== null && e.nodes.end !== null && (xs(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), r = !0), Lr(e, t && !r), Rt(e, 0), P(e, Ae);
+  var i = e.nodes && e.nodes.t;
+  if (i !== null)
+    for (const s of i)
+      s.stop();
+  Hn(e);
+  var n = e.parent;
+  n !== null && n.first !== null && Gn(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function xs(e, t) {
+  for (; e !== null; ) {
+    var r = e === t ? null : /* @__PURE__ */ Fe(e);
+    e.remove(), e = r;
+  }
+}
+function Gn(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 Ct(e, t, r = !0) {
+  var i = [];
+  Vn(e, i, !0);
+  var n = () => {
+    r && V(e), t && t();
+  }, s = i.length;
+  if (s > 0) {
+    var o = () => --s || n();
+    for (var a of i)
+      a.out(o);
+  } else
+    n();
+}
+function Vn(e, t, r) {
+  if ((e.f & re) === 0) {
+    e.f ^= re;
+    var i = e.nodes && e.nodes.t;
+    if (i !== null)
+      for (const a of i)
+        (a.is_global || r) && t.push(a);
+    for (var n = e.first; n !== null; ) {
+      var s = n.next, o = (n.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.
+      (n.f & we) !== 0 && (e.f & De) !== 0;
+      Vn(n, t, o ? r : !1), n = s;
+    }
+  }
+}
+function Ls(e) {
+  Yn(e, !0);
+}
+function Yn(e, t) {
+  if ((e.f & re) !== 0) {
+    e.f ^= re;
+    for (var r = e.first; r !== null; ) {
+      var i = r.next, n = (r.f & vt) !== 0 || (r.f & we) !== 0;
+      Yn(r, n ? t : !1), r = i;
+    }
+    var s = e.nodes && e.nodes.t;
+    if (s !== null)
+      for (const o of s)
+        (o.is_global || t) && o.in();
+  }
+}
+function Kn(e, t) {
+  if (e.nodes)
+    for (var r = e.nodes.start, i = e.nodes.end; r !== null; ) {
+      var n = r === i ? null : /* @__PURE__ */ Fe(r);
+      t.append(r), r = n;
+    }
+}
+let Ht = !1, Pe = !1;
+function Vr(e) {
+  Pe = e;
+}
+let m = null, fe = !1;
+function ie(e) {
+  m = e;
+}
+let E = null;
+function ge(e) {
+  E = e;
+}
+let ne = null;
+function Wn(e) {
+  m !== null && (ne === null ? ne = [e] : ne.push(e));
+}
+let G = null, K = 0, Q = null;
+function Ps(e) {
+  Q = e;
+}
+let Jn = 1, ze = 0, We = ze;
+function Yr(e) {
+  We = e;
+}
+function Xn() {
+  return ++Jn;
+}
+function Nt(e) {
+  var t = e.f;
+  if ((t & U) !== 0)
+    return !0;
+  if (t & B && (e.f &= ~Je), (t & ue) !== 0) {
+    for (var r = (
+      /** @type {Value[]} */
+      e.deps
+    ), i = r.length, n = 0; n < i; n++) {
+      var s = r[n];
+      if (Nt(
+        /** @type {Derived} */
+        s
+      ) && On(
+        /** @type {Derived} */
+        s
+      ), s.wv > e.wv)
+        return !0;
+    }
+    (t & te) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    ae === null && P(e, F);
+  }
+  return !1;
+}
+function Zn(e, t, r = !0) {
+  var i = e.reactions;
+  if (i !== null && !(ne !== null && ht.call(ne, e)))
+    for (var n = 0; n < i.length; n++) {
+      var s = i[n];
+      (s.f & B) !== 0 ? Zn(
+        /** @type {Derived} */
+        s,
+        t,
+        !1
+      ) : t === s && (r ? P(s, U) : (s.f & F) !== 0 && P(s, ue), ve(
+        /** @type {Effect} */
+        s
+      ));
+    }
+}
+function Qn(e) {
+  var T;
+  var t = G, r = K, i = Q, n = m, s = ne, o = Z, a = fe, f = We, u = e.f;
+  G = /** @type {null | Value[]} */
+  null, K = 0, Q = null, m = (u & (we | Me)) === 0 ? e : null, ne = null, pt(e.ctx), fe = !1, We = ++ze, e.ac !== null && (Bn(() => {
+    e.ac.abort(Ue);
+  }), e.ac = null);
+  try {
+    e.f |= dr;
+    var _ = (
+      /** @type {Function} */
+      e.fn
+    ), h = _();
+    e.f |= Ze;
+    var d = e.deps, v = I?.is_fork;
+    if (G !== null) {
+      var g;
+      if (v || Rt(e, K), d !== null && K > 0)
+        for (d.length = K + G.length, g = 0; g < G.length; g++)
+          d[K + g] = G[g];
+      else
+        e.deps = d = G;
+      if (Or() && (e.f & te) !== 0)
+        for (g = K; g < d.length; g++)
+          ((T = d[g]).reactions ?? (T.reactions = [])).push(e);
+    } else !v && d !== null && K < d.length && (Rt(e, K), d.length = K);
+    if (mn() && Q !== null && !fe && d !== null && (e.f & (B | ue | U)) === 0)
+      for (g = 0; g < /** @type {Source[]} */
+      Q.length; g++)
+        Zn(
+          Q[g],
+          /** @type {Effect} */
+          e
+        );
+    if (n !== null && n !== e) {
+      if (ze++, n.deps !== null)
+        for (let b = 0; b < r; b += 1)
+          n.deps[b].rv = ze;
+      if (t !== null)
+        for (const b of t)
+          b.rv = ze;
+      Q !== null && (i === null ? i = Q : i.push(.../** @type {Source[]} */
+      Q));
+    }
+    return (e.f & xe) !== 0 && (e.f ^= xe), h;
+  } catch (b) {
+    return $n(b);
+  } finally {
+    e.f ^= dr, G = t, K = r, Q = i, m = n, ne = s, pt(o), fe = a, We = f;
+  }
+}
+function Ds(e, t) {
+  let r = t.reactions;
+  if (r !== null) {
+    var i = Oi.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 & B) !== 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
+  (G === null || !ht.call(G, t))) {
+    var s = (
+      /** @type {Derived} */
+      t
+    );
+    (s.f & te) !== 0 && (s.f ^= te, s.f &= ~Je), Sr(s), bs(s), Rt(s, 0);
+  }
+}
+function Rt(e, t) {
+  var r = e.deps;
+  if (r !== null)
+    for (var i = t; i < r.length; i++)
+      Ds(e, r[i]);
+}
+function wt(e) {
+  var t = e.f;
+  if ((t & Ae) === 0) {
+    P(e, F);
+    var r = E, i = Ht;
+    E = e, Ht = !0;
+    try {
+      (t & (De | Cr)) !== 0 ? Os(e) : Lr(e), Hn(e);
+      var n = Qn(e);
+      e.teardown = typeof n == "function" ? n : null, e.wv = Jn;
+      var s;
+      ur && ss && (e.f & U) !== 0 && e.deps;
+    } finally {
+      Ht = i, E = r;
+    }
+  }
+}
+function c(e) {
+  var t = e.f, r = (t & B) !== 0;
+  if (m !== null && !fe) {
+    var i = E !== null && (E.f & Ae) !== 0;
+    if (!i && (ne === null || !ht.call(ne, e))) {
+      var n = m.deps;
+      if ((m.f & dr) !== 0)
+        e.rv < ze && (e.rv = ze, G === null && n !== null && n[K] === e ? K++ : G === null ? G = [e] : G.push(e));
+      else {
+        (m.deps ?? (m.deps = [])).push(e);
+        var s = e.reactions;
+        s === null ? e.reactions = [m] : ht.call(s, m) || s.push(m);
+      }
+    }
+  }
+  if (Pe && Le.has(e))
+    return Le.get(e);
+  if (r) {
+    var o = (
+      /** @type {Derived} */
+      e
+    );
+    if (Pe) {
+      var a = o.v;
+      return ((o.f & F) === 0 && o.reactions !== null || ti(o)) && (a = Ir(o)), Le.set(o, a), a;
+    }
+    var f = (o.f & te) === 0 && !fe && m !== null && (Ht || (m.f & te) !== 0), u = (o.f & Ze) === 0;
+    Nt(o) && (f && (o.f |= te), On(o)), f && !u && (xn(o), ei(o));
+  }
+  if (ae?.has(e))
+    return ae.get(e);
+  if ((e.f & xe) !== 0)
+    throw e.v;
+  return e.v;
+}
+function ei(e) {
+  if (e.f |= te, e.deps !== null)
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & B) !== 0 && (t.f & te) === 0 && (xn(
+        /** @type {Derived} */
+        t
+      ), ei(
+        /** @type {Derived} */
+        t
+      ));
+}
+function ti(e) {
+  if (e.v === M) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (Le.has(t) || (t.f & B) !== 0 && ti(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+function rr(e) {
+  var t = fe;
+  try {
+    return fe = !0, e();
+  } finally {
+    fe = t;
+  }
+}
+const Ft = /* @__PURE__ */ Symbol("events"), Ms = /* @__PURE__ */ new Set(), Kr = /* @__PURE__ */ new Set();
+let Wr = null;
+function Jr(e) {
+  var t = this, r = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), i = e.type, n = e.composedPath?.() || [], s = (
+    /** @type {null | Element} */
+    n[0] || e.target
+  );
+  Wr = e;
+  var o = 0, a = Wr === e && e[Ft];
+  if (a) {
+    var f = n.indexOf(a);
+    if (f !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e[Ft] = t;
+      return;
+    }
+    var u = n.indexOf(t);
+    if (u === -1)
+      return;
+    f <= u && (o = f);
+  }
+  if (s = /** @type {Element} */
+  n[o] || e.target, s !== t) {
+    Yt(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return s || r;
+      }
+    });
+    var _ = m, h = E;
+    ie(null), ge(null);
+    try {
+      for (var d, v = []; s !== null; ) {
+        var g = s.assignedSlot || s.parentNode || /** @type {any} */
+        s.host || null;
+        try {
+          var T = s[Ft]?.[i];
+          T != 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) && T.call(s, e);
+        } catch (b) {
+          d ? v.push(b) : d = b;
+        }
+        if (e.cancelBubble || g === t || g === null)
+          break;
+        s = g;
+      }
+      if (d) {
+        for (let b of v)
+          queueMicrotask(() => {
+            throw b;
+          });
+        throw d;
+      }
+    } finally {
+      e[Ft] = t, delete e.currentTarget, ie(_), ge(h);
+    }
+  }
+}
+const Fs = (
+  // We gotta write it like this because after downleveling the pure comment may end up in the wrong location
+  globalThis?.window?.trustedTypes && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", {
+    /** @param {string} html */
+    createHTML: (e) => e
+  })
+);
+function Us(e) {
+  return (
+    /** @type {string} */
+    Fs?.createHTML(e) ?? e
+  );
+}
+function Bs(e) {
+  var t = Nr("template");
+  return t.innerHTML = Us(e.replaceAll("<!>", "<!---->")), t.content;
+}
+function $r(e, t) {
+  var r = (
+    /** @type {Effect} */
+    E
+  );
+  r.nodes === null && (r.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Ot(e, t) {
+  var r = (t & Ii) !== 0, i, n = !e.startsWith("<!>");
+  return () => {
+    if (D)
+      return $r(N, null), N;
+    i === void 0 && (i = Bs(n ? e : "<!>" + e), i = /** @type {TemplateNode} */
+    /* @__PURE__ */ Wt(i));
+    var s = (
+      /** @type {TemplateNode} */
+      r || Dn ? document.importNode(i, !0) : i.cloneNode(!0)
+    );
+    return $r(s, s), s;
+  };
+}
+function rt(e, t) {
+  if (D) {
+    var r = (
+      /** @type {Effect & { nodes: EffectNodes }} */
+      E
+    );
+    ((r.f & Ze) === 0 || r.nodes.end === null) && (r.nodes.end = N), kr();
+    return;
+  }
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+const js = ["touchstart", "touchmove"];
+function zs(e) {
+  return js.includes(e);
+}
+function qs(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 ri(e, t) {
+  return ni(e, t);
+}
+function Hs(e, t) {
+  br(), t.intro = t.intro ?? !1;
+  const r = t.target, i = D, n = N;
+  try {
+    for (var s = /* @__PURE__ */ Wt(r); s && (s.nodeType !== Zt || /** @type {Comment} */
+    s.data !== an); )
+      s = /* @__PURE__ */ Fe(s);
+    if (!s)
+      throw dt;
+    nt(!0), pe(
+      /** @type {Comment} */
+      s
+    );
+    const o = ni(e, { ...t, anchor: s });
+    return nt(!1), /**  @type {Exports} */
+    o;
+  } catch (o) {
+    if (o instanceof Error && o.message.split(`
+`).some((a) => a.startsWith("https://svelte.dev/e/")))
+      throw o;
+    return o !== dt && console.warn("Failed to hydrate: ", o), t.recover === !1 && Wi(), br(), Ts(r), nt(!1), ri(e, t);
+  } finally {
+    nt(i), pe(n);
+  }
+}
+const Ut = /* @__PURE__ */ new Map();
+function ni(e, { target: t, anchor: r, props: i = {}, events: n, context: s, intro: o = !0, transformError: a }) {
+  br();
+  var f = void 0, u = Is(() => {
+    var _ = r ?? t.appendChild(Xe());
+    ds(
+      /** @type {TemplateNode} */
+      _,
+      {
+        pending: () => {
+        }
+      },
+      (v) => {
+        wn({});
+        var g = (
+          /** @type {ComponentContext} */
+          Z
+        );
+        if (s && (g.c = s), n && (i.$$events = n), D && $r(
+          /** @type {TemplateNode} */
+          v,
+          null
+        ), f = e(v, i) || {}, D && (E.nodes.end = N, N === null || N.nodeType !== Zt || /** @type {Comment} */
+        N.data !== un))
+          throw Qt(), dt;
+        yn();
+      },
+      a
+    );
+    var h = /* @__PURE__ */ new Set(), d = (v) => {
+      for (var g = 0; g < v.length; g++) {
+        var T = v[g];
+        if (!h.has(T)) {
+          h.add(T);
+          var b = zs(T);
+          for (const j of [t, document]) {
+            var x = Ut.get(j);
+            x === void 0 && (x = /* @__PURE__ */ new Map(), Ut.set(j, x));
+            var R = x.get(T);
+            R === void 0 ? (j.addEventListener(T, Jr, { passive: b }), x.set(T, 1)) : x.set(T, R + 1);
+          }
+        }
+      }
+    };
+    return d(xi(Ms)), Kr.add(d), () => {
+      for (var v of h)
+        for (const b of [t, document]) {
+          var g = (
+            /** @type {Map<string, number>} */
+            Ut.get(b)
+          ), T = (
+            /** @type {number} */
+            g.get(v)
+          );
+          --T == 0 ? (b.removeEventListener(v, Jr), g.delete(v), g.size === 0 && Ut.delete(b)) : g.set(v, T);
+        }
+      Kr.delete(d), _ !== r && _.parentNode?.removeChild(_);
+    };
+  });
+  return Er.set(f, u), f;
+}
+let Er = /* @__PURE__ */ new WeakMap();
+function Gs(e, t) {
+  const r = Er.get(e);
+  return r ? (Er.delete(e), r(t)) : Promise.resolve();
+}
+var oe, _e, X, Ve, kt, St, Xt;
+class Vs {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, r = !0) {
+    /** @type {TemplateNode} */
+    k(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    y(this, oe, /* @__PURE__ */ new Map());
+    /**
+     * Map of keys to effects that are currently rendered in the DOM.
+     * These effects are visible and actively part of the document tree.
+     * Example:
+     * ```
+     * {#if condition}
+     * 	foo
+     * {:else}
+     * 	bar
+     * {/if}
+     * ```
+     * Can result in the entries `true->Effect` and `false->Effect`
+     * @type {Map<Key, Effect>}
+     */
+    y(this, _e, /* @__PURE__ */ new Map());
+    /**
+     * Similar to #onscreen with respect to the keys, but contains branches that are not yet
+     * in the DOM, because their insertion is deferred.
+     * @type {Map<Key, Branch>}
+     */
+    y(this, X, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    y(this, Ve, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    y(this, kt, !0);
+    /**
+     * @param {Batch} batch
+     */
+    y(this, St, (t) => {
+      if (l(this, oe).has(t)) {
+        var r = (
+          /** @type {Key} */
+          l(this, oe).get(t)
+        ), i = l(this, _e).get(r);
+        if (i)
+          Ls(i), l(this, Ve).delete(r);
+        else {
+          var n = l(this, X).get(r);
+          n && (n.effect.f & re) === 0 && (l(this, _e).set(r, n.effect), l(this, X).delete(r), n.fragment.lastChild.remove(), this.anchor.before(n.fragment), i = n.effect);
+        }
+        for (const [s, o] of l(this, oe)) {
+          if (l(this, oe).delete(s), s === t)
+            break;
+          const a = l(this, X).get(o);
+          a && (V(a.effect), l(this, X).delete(o));
+        }
+        for (const [s, o] of l(this, _e)) {
+          if (s === r || l(this, Ve).has(s) || (o.f & re) !== 0) continue;
+          const a = () => {
+            if (Array.from(l(this, oe).values()).includes(s)) {
+              var u = document.createDocumentFragment();
+              Kn(o, u), u.append(Xe()), l(this, X).set(s, { effect: o, fragment: u });
+            } else
+              V(o);
+            l(this, Ve).delete(s), l(this, _e).delete(s);
+          };
+          l(this, kt) || !i ? (l(this, Ve).add(s), Ct(o, a, !1)) : a();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    y(this, Xt, (t) => {
+      l(this, oe).delete(t);
+      const r = Array.from(l(this, oe).values());
+      for (const [i, n] of l(this, X))
+        r.includes(i) || (V(n.effect), l(this, X).delete(i));
+    });
+    this.anchor = t, w(this, kt, r);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, r) {
+    var i = (
+      /** @type {Batch} */
+      I
+    ), n = Cs();
+    if (r && !l(this, _e).has(t) && !l(this, X).has(t))
+      if (n) {
+        var s = document.createDocumentFragment(), o = Xe();
+        s.append(o), l(this, X).set(t, {
+          effect: Ee(() => r(o)),
+          fragment: s
+        });
+      } else
+        l(this, _e).set(
+          t,
+          Ee(() => r(this.anchor))
+        );
+    if (l(this, oe).set(i, t), n) {
+      for (const [a, f] of l(this, _e))
+        a === t ? i.unskip_effect(f) : i.skip_effect(f);
+      for (const [a, f] of l(this, X))
+        a === t ? i.unskip_effect(f.effect) : i.skip_effect(f.effect);
+      i.oncommit(l(this, St)), i.ondiscard(l(this, Xt));
+    } else
+      D && (this.anchor = N), l(this, St).call(this, i);
+  }
+}
+oe = new WeakMap(), _e = new WeakMap(), X = new WeakMap(), Ve = new WeakMap(), kt = new WeakMap(), St = new WeakMap(), Xt = new WeakMap();
+function Ys(e) {
+  Z === null && qi(), tt(() => {
+    const t = rr(e);
+    if (typeof t == "function") return (
+      /** @type {() => void} */
+      t
+    );
+  });
+}
+function Bt(e, t, r = !1) {
+  var i;
+  D && (i = N, kr());
+  var n = new Vs(e), s = r ? vt : 0;
+  function o(a, f) {
+    if (D) {
+      var u = ns(
+        /** @type {TemplateNode} */
+        i
+      );
+      if (a !== parseInt(u.substring(1))) {
+        var _ = vn();
+        pe(_), n.anchor = _, nt(!1), n.ensure(a, f), nt(!0);
+        return;
+      }
+    }
+    n.ensure(a, f);
+  }
+  qn(() => {
+    var a = !1;
+    t((f, u = 0) => {
+      a = !0, o(u, f);
+    }), a || o(-1, null);
+  }, s);
+}
+function Ks(e, t) {
+  zn(() => {
+    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 = Nr("style");
+      n.id = t.hash, n.textContent = t.code, i.appendChild(n);
+    }
+  });
+}
+const Ws = /* @__PURE__ */ Symbol("is custom element"), Js = /* @__PURE__ */ Symbol("is html"), Xs = zi ? "link" : "LINK";
+function Xr(e, t, r, i) {
+  var n = Zs(e);
+  D && (n[t] = e.getAttribute(t), t === "src" || t === "srcset" || t === "href" && e.nodeName === Xs) || n[t] !== (n[t] = r) && (t === "loading" && (e[ji] = r), r == null ? e.removeAttribute(t) : typeof r != "string" && Qs(e).includes(t) ? e[t] = r : e.setAttribute(t, r));
+}
+function Zs(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Ws]: e.nodeName.includes("-"),
+      [Js]: e.namespaceURI === cn
+    })
+  );
+}
+var Zr = /* @__PURE__ */ new Map();
+function Qs(e) {
+  var t = e.getAttribute("is") || e.nodeName, r = Zr.get(t);
+  if (r) return r;
+  Zr.set(t, r = []);
+  for (var i, n = e, s = Element.prototype; s !== n; ) {
+    i = Li(n);
+    for (var o in i)
+      i[o].set && r.push(o);
+    n = dn(n);
+  }
+  return r;
+}
+function Qr(e, t) {
+  return e === t || e?.[$t] === t;
+}
+function fr(e = {}, t, r, i) {
+  return zn(() => {
+    var n, s;
+    return xr(() => {
+      n = s, s = [], rr(() => {
+        e !== r(...s) && (t(e, ...s), n && Qr(r(...n), e) && t(null, ...n));
+      });
+    }), () => {
+      Ke(() => {
+        s && Qr(r(...s), e) && t(null, ...s);
+      });
+    };
+  }), e;
+}
+let jt = !1;
+function el(e) {
+  var t = jt;
+  try {
+    return jt = !1, [e(), jt];
+  } finally {
+    jt = t;
+  }
+}
+function bt(e, t, r, i) {
+  var n = (r & ki) !== 0, s = (r & Si) !== 0, o = (
+    /** @type {V} */
+    i
+  ), a = !0, f = () => (a && (a = !1, o = s ? rr(
+    /** @type {() => V} */
+    i
+  ) : (
+    /** @type {V} */
+    i
+  )), o), u;
+  if (n) {
+    var _ = $t in e || _n in e;
+    u = Ye(e, t)?.set ?? (_ && t in e ? (R) => e[t] = R : void 0);
+  }
+  var h, d = !1;
+  n ? [h, d] = el(() => (
+    /** @type {V} */
+    e[t]
+  )) : h = /** @type {V} */
+  e[t], h === void 0 && i !== void 0 && (h = f(), u && (Ji(), u(h)));
+  var v;
+  if (v = () => {
+    var R = (
+      /** @type {V} */
+      e[t]
+    );
+    return R === void 0 ? f() : (a = !0, R);
+  }, (r & Ai) === 0)
+    return v;
+  if (u) {
+    var g = e.$$legacy;
+    return (
+      /** @type {() => V} */
+      (function(R, j) {
+        return arguments.length > 0 ? ((!j || g || d) && u(j ? v() : R), R) : v();
+      })
+    );
+  }
+  var T = !1, b = ((r & Ri) !== 0 ? tr : ws)(() => (T = !1, v()));
+  n && c(b);
+  var x = (
+    /** @type {Effect} */
+    E
+  );
+  return (
+    /** @type {() => V} */
+    (function(R, j) {
+      if (arguments.length > 0) {
+        const me = j ? c(b) : n ? je(R) : R;
+        return $(b, me), T = !0, o !== void 0 && (o = me), R;
+      }
+      return Pe && T || (x.f & Ae) !== 0 ? b.v : c(b);
+    })
+  );
+}
+function tl(e) {
+  return new rl(e);
+}
+var Re, ee;
+class rl {
+  /**
+   * @param {ComponentConstructorOptions & {
+   *  component: any;
+   * }} options
+   */
+  constructor(t) {
+    /** @type {any} */
+    y(this, Re);
+    /** @type {Record<string, any>} */
+    y(this, ee);
+    var r = /* @__PURE__ */ new Map(), i = (s, o) => {
+      var a = /* @__PURE__ */ $s(o, !1, !1);
+      return r.set(s, a), a;
+    };
+    const n = new Proxy(
+      { ...t.props || {}, $$events: {} },
+      {
+        get(s, o) {
+          return c(r.get(o) ?? i(o, Reflect.get(s, o)));
+        },
+        has(s, o) {
+          return o === _n ? !0 : (c(r.get(o) ?? i(o, Reflect.get(s, o))), Reflect.has(s, o));
+        },
+        set(s, o, a) {
+          return $(r.get(o) ?? i(o, a), a), Reflect.set(s, o, a);
+        }
+      }
+    );
+    w(this, ee, (t.hydrate ? Hs : ri)(t.component, {
+      target: t.target,
+      anchor: t.anchor,
+      props: n,
+      context: t.context,
+      intro: t.intro ?? !1,
+      recover: t.recover,
+      transformError: t.transformError
+    })), (!t?.props?.$$host || t.sync === !1) && et(), w(this, Re, n.$$events);
+    for (const s of Object.keys(l(this, ee)))
+      s === "$set" || s === "$destroy" || s === "$on" || Yt(this, s, {
+        get() {
+          return l(this, ee)[s];
+        },
+        /** @param {any} value */
+        set(o) {
+          l(this, ee)[s] = o;
+        },
+        enumerable: !0
+      });
+    l(this, ee).$set = /** @param {Record<string, any>} next */
+    (s) => {
+      Object.assign(n, s);
+    }, l(this, ee).$destroy = () => {
+      Gs(l(this, ee));
+    };
+  }
+  /** @param {Record<string, any>} props */
+  $set(t) {
+    l(this, ee).$set(t);
+  }
+  /**
+   * @param {string} event
+   * @param {(...args: any[]) => any} callback
+   * @returns {any}
+   */
+  $on(t, r) {
+    l(this, Re)[t] = l(this, Re)[t] || [];
+    const i = (...n) => r.call(this, ...n);
+    return l(this, Re)[t].push(i), () => {
+      l(this, Re)[t] = l(this, Re)[t].filter(
+        /** @param {any} fn */
+        (n) => n !== i
+      );
+    };
+  }
+  $destroy() {
+    l(this, ee).$destroy();
+  }
+}
+Re = new WeakMap(), ee = new WeakMap();
+let ii;
+typeof HTMLElement == "function" && (ii = 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 o = Nr("slot");
+          n !== "default" && (o.name = n), rt(s, o);
+        };
+      };
+      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] = Gt(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 = Ss(() => {
+        xr(() => {
+          this.$$r = !0;
+          for (const n of Vt(this.$$c)) {
+            if (!this.$$p_d[n]?.reflect) continue;
+            this.$$d[n] = this.$$c[n];
+            const s = Gt(
+              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 o = this.$$c.$on(n, s);
+          this.$$l_u.set(s, o);
+        }
+      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] = Gt(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 Vt(this.$$p_d).find(
+      (r) => this.$$p_d[r].attribute === t || !this.$$p_d[r].attribute && r.toLowerCase() === t
+    ) || t;
+  }
+});
+function Gt(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 o = class extends ii {
+    constructor() {
+      super(e, r, n), this.$$p_d = t;
+    }
+    static get observedAttributes() {
+      return Vt(t).map(
+        (a) => (t[a].attribute || a).toLowerCase()
+      );
+    }
+  };
+  return Vt(t).forEach((a) => {
+    Yt(o.prototype, a, {
+      get() {
+        return this.$$c && a in this.$$c ? this.$$c[a] : this.$$d[a];
+      },
+      set(f) {
+        f = Gt(a, f, t), this.$$d[a] = f;
+        var u = this.$$c;
+        if (u) {
+          var _ = Ye(u, a)?.get;
+          _ ? u[a] = f : u.$set({ [a]: f });
+        }
+      }
+    });
+  }), i.forEach((a) => {
+    Yt(o.prototype, a, {
+      get() {
+        return this.$$c?.[a];
+      }
+    });
+  }), e.element = /** @type {any} */
+  o, o;
+}
+const sl = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 }, si = "https://proxy.pie-api.com", ll = `${si}/bundles/`;
+function li(e) {
+  try {
+    const t = sl?.[e];
+    if (typeof t == "string" && t.length > 0)
+      return t;
+  } catch {
+  }
+}
+typeof window < "u" && window.PIE_BUILDER_ORIGIN_URL || li("PUBLIC_BUILDER_ORIGIN_URL");
+typeof window < "u" && window.PIE_BUILDER_BUNDLE_URL || li("PUBLIC_BUILDER_BUNDLE_URL");
+var Tr;
+(function(e) {
+  e.player = "player.js", e.clientPlayer = "client-player.js", e.editor = "editor.js";
+})(Tr || (Tr = {}));
+var en;
+(function(e) {
+  e.loading = "loading", e.loaded = "loaded";
+})(en || (en = {}));
+typeof window < "u" && !window.pieHelpers && (window.pieHelpers = {
+  loadingScripts: {},
+  loadingPromises: {}
+});
+var tn;
+(function(e) {
+  e.SAVE = "save", e.MODEL = "model", e.SCORE = "score", e.MANUAL_SCORE = "manual-score";
+})(tn || (tn = {}));
+var rn;
+(function(e) {
+  e.AUTO = "auto", e.MANUAL = "manual";
+})(rn || (rn = {}));
+var nn;
+(function(e) {
+  e.GATHER = "gather", e.VIEW = "view", e.EVALUATE = "evaluate";
+})(nn || (nn = {}));
+var sn;
+(function(e) {
+  e.PENDING = "pending", e.IN_PROGRESS = "in_progress", e.COMPLETED = "completed", e.FAILED = "failed";
+})(sn || (sn = {}));
+var ln;
+(function(e) {
+  e[e.ROOT = 0] = "ROOT", e[e.SUBJECT = 1] = "SUBJECT", e[e.LEVEL = 2] = "LEVEL", e[e.STANDARD = 3] = "STANDARD";
+})(ln || (ln = {}));
+Tr.player;
+function ol(e) {
+  const t = typeof document < "u" ? document.activeElement : null;
+  return queueMicrotask(() => {
+    try {
+      e.focus?.();
+    } catch {
+    }
+  }), () => {
+    try {
+      t?.focus?.();
+    } catch {
+    }
+  };
+}
+var al = /* @__PURE__ */ Ot('<div class="pie-tool-calculator__loading svelte-sun9kf">Loading calculator...</div>'), fl = /* @__PURE__ */ Ot('<div class="pie-tool-calculator__error-details svelte-sun9kf"> </div>'), ul = /* @__PURE__ */ Ot('<div class="pie-tool-calculator__loading pie-tool-calculator__loading--error svelte-sun9kf">Calculator failed to initialize. <!></div>'), cl = /* @__PURE__ */ Ot('<div class="pie-tool-calculator notranslate svelte-sun9kf" role="region" tabindex="-1" aria-label="Calculator tool" translate="no" style="width: 100%; height: 100%;"><div class="pie-tool-calculator__container svelte-sun9kf"></div> <!> <!></div>'), dl = /* @__PURE__ */ Ot('<div class="pie-tool-calculator__context-host svelte-sun9kf"><!></div>');
+const hl = {
+  hash: "svelte-sun9kf",
+  code: ".pie-tool-calculator__context-host.svelte-sun9kf {width:100%;height:100%;display:flex;min-height:0;}.pie-tool-calculator.svelte-sun9kf {position:relative;background:white;overflow:hidden;min-width:100%;min-height:0;display:flex;flex-direction:column;flex:1 1 auto;}.pie-tool-calculator__container.svelte-sun9kf {background:white;width:100%;height:100%;min-width:100%;min-height:100%;position:relative;overflow:hidden;}.pie-tool-calculator__loading.svelte-sun9kf {position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(255, 255, 255, 0.9);color:#334155;font-size:0.9rem;z-index:2;}.pie-tool-calculator__loading--error.svelte-sun9kf {color:#b91c1c;flex-direction:column;gap:0.5rem;padding:0.75rem;text-align:center;}.pie-tool-calculator__error-details.svelte-sun9kf {font-size:0.8rem;line-height:1.2;color:#7f1d1d;max-width:95%;word-break:break-word;}.pie-tool-calculator__container .dcg-container {width:100% !important;height:100% !important;}"
+};
+function _l(e, t) {
+  wn(t, !0), Ks(e, hl);
+  let r = bt(t, "visible", 7, !1), i = bt(t, "toolId", 7, "calculator"), n = bt(t, "calculatorType", 7, "basic"), s = bt(t, "availableTypes", 23, () => ["basic", "scientific", "graphing"]), o = bt(t, "toolkitCoordinator", 7, null), a = /* @__PURE__ */ L(null), f = /* @__PURE__ */ L(null);
+  const u = /* @__PURE__ */ qr(() => o() ?? c(f)?.toolkitCoordinator);
+  let _ = /* @__PURE__ */ qr(() => typeof s() == "string" ? s().split(",").map((p) => p.trim()) : s()), h = /* @__PURE__ */ L(void 0), d = /* @__PURE__ */ L(void 0), v = /* @__PURE__ */ L(null), g = /* @__PURE__ */ L("basic"), T = /* @__PURE__ */ L(!1), b = /* @__PURE__ */ L(!1), x = /* @__PURE__ */ L(!1), R = /* @__PURE__ */ L(null), j = /* @__PURE__ */ L(!1), me = /* @__PURE__ */ L(null);
+  const oi = ".dcg-container,.dcg-calculator-api-container,iframe,canvas";
+  tt(() => {
+    if (c(a))
+      return Ti(c(a), (p) => {
+        $(f, p, !0);
+      });
+  });
+  function ai() {
+    return "calculator-desmos";
+  }
+  async function fi(p) {
+    if (console.log("[ToolCalculator] getProvider called", {
+      type: p,
+      hasToolkitCoordinator: !!c(u),
+      hasRegistry: !!c(u)?.toolProviderRegistry
+    }), !c(u)?.toolProviderRegistry)
+      return console.warn("[ToolCalculator] No toolkitCoordinator or registry available"), null;
+    try {
+      const C = ai();
+      console.log(`[ToolCalculator] Requesting ${C} provider from registry`);
+      const A = await c(u).toolProviderRegistry.getProvider(C);
+      return console.log("[ToolCalculator] Got provider from registry:", A), A;
+    } catch (C) {
+      return console.error("[ToolCalculator] Failed to get provider:", C), null;
+    }
+  }
+  function nr(p) {
+    return p ? p.childElementCount > 0 || !!p.querySelector(oi) : !1;
+  }
+  function ui(p) {
+    if (!p) return;
+    const C = [60, 250, 1e3, 2500];
+    for (const A of C)
+      setTimeout(
+        () => {
+          try {
+            p.resize?.();
+          } catch {
+          }
+        },
+        A
+      );
+  }
+  async function Dr(p, C, A = 8e3) {
+    if (!p || !await ci(p, A)) return !1;
+    $(j, !0);
+    try {
+      C?.resize?.();
+    } catch {
+    }
+    return !0;
+  }
+  async function ci(p, C = 3e3) {
+    if (!p) return !1;
+    const A = Date.now();
+    for (; Date.now() - A < C; ) {
+      if (!p.isConnected) return !1;
+      if (nr(p)) return !0;
+      await new Promise((be) => setTimeout(be, 100));
+    }
+    return nr(p);
+  }
+  function di(p, C) {
+    return new Promise((A) => {
+      let be = p;
+      function Lt() {
+        if (be <= 0) {
+          A();
+          return;
+        }
+        be--, requestAnimationFrame(Lt);
+      }
+      Lt();
+    });
+  }
+  function hi(p) {
+    const C = p === "graphing";
+    return {
+      theme: "light",
+      restrictedMode: !1,
+      desmos: {
+        degreeMode: !0,
+        settingsMenu: C,
+        qwertyKeyboard: !1,
+        notes: C,
+        folders: C,
+        sliders: C,
+        tables: C
+      }
+    };
+  }
+  let Mr = /* @__PURE__ */ L(je(hi("basic")));
+  async function ir() {
+    if (console.log("[ToolCalculator] initCalculator called", {
+      isInitializing: c(T),
+      isSwitching: c(b),
+      hasCalculatorInstance: !!c(v),
+      hasContainerEl: !!c(d),
+      initializationFailed: c(x),
+      hasToolkitCoordinator: !!c(u),
+      hasRegistry: !!c(u)?.toolProviderRegistry
+    }), c(T) || c(b) || c(v) || !c(d) || c(x)) {
+      console.log("[ToolCalculator] Early return from initCalculator");
+      return;
+    }
+    $(T, !0);
+    try {
+      c(_).includes(c(g)) || (console.log("[ToolCalculator] Calculator type not available, using fallback", {
+        requested: c(g),
+        availableTypes: c(_),
+        fallback: c(_)[0] || "basic"
+      }), $(g, c(_)[0] || "basic", !0)), console.log("[ToolCalculator] Getting provider for type:", c(g));
+      const p = await fi(c(g));
+      if (console.log("[ToolCalculator] Got tool provider:", p), !p)
+        throw new Error("Desmos calculator tool provider not available");
+      console.log("[ToolCalculator] Creating calculator provider instance");
+      const C = await p.createInstance();
+      if (console.log("[ToolCalculator] Got calculator provider:", C), !c(d) || c(v) || c(b)) {
+        console.log("[ToolCalculator] Aborting due to state change");
+        return;
+      }
+      console.log("[ToolCalculator] Creating calculator with config:", {
+        type: c(g),
+        hasContainer: !!c(d),
+        config: c(Mr)
+      });
+      const A = c(d);
+      if (!A || !A.isConnected) {
+        console.warn("[ToolCalculator] Calculator container unavailable before mount");
+        return;
+      }
+      if (!A.isConnected) {
+        console.warn("[ToolCalculator] Calculator container disconnected before init");
+        return;
+      }
+      $(v, await C.createCalculator(c(g), A, c(Mr)), !0), await di(2), c(v)?.resize?.(), ui(c(v)), $(j, !1), await Dr(A, c(v), 4e3) || (console.warn("[ToolCalculator] Calculator mount pending after init; keeping instance and monitoring"), Dr(A, c(v), 12e3)), console.log("[ToolCalculator] Calculator instance created:", c(v)), $(x, !1), $(R, null), $(j, nr(A), !0), console.log(`[ToolCalculator] ${c(g)} calculator initialized successfully`);
+    } catch (p) {
+      $(x, !0), $(R, p instanceof Error ? p.message : String(p), !0), console.error("[ToolCalculator] Failed to initialize calculator:", p), $(v, null), $(j, !1);
+    } finally {
+      $(T, !1);
+    }
+  }
+  tt(() => {
+    !n() || !c(_).includes(n()) || $(g, n());
+  }), Ys(() => (r() && ir(), () => {
+    c(me)?.(), c(v)?.destroy();
+  })), tt(() => {
+    if (!r()) {
+      if (c(v))
+        try {
+          c(v).destroy();
+        } catch (p) {
+          console.warn("[ToolCalculator] Error destroying calculator on hide:", p);
+        } finally {
+          $(v, null);
+        }
+      $(x, !1), $(R, null), $(j, !1);
+      return;
+    }
+    !c(v) && !c(T) && !c(b) && !c(x) && (c(d)?.isConnected ? ir() : queueMicrotask(() => {
+      r() && c(d)?.isConnected && !c(v) && !c(T) && !c(b) && !c(x) && ir();
+    }));
+  });
+  let z = null;
+  tt(() => {
+    if (r() && c(d) && c(v) && c(d).isConnected)
+      return z || (z = new ResizeObserver((p) => {
+        for (const C of p)
+          if (!C.target.isConnected) {
+            z?.unobserve(C.target);
+            return;
+          }
+        if (c(v)?.resize && c(d)?.isConnected && r())
+          try {
+            c(v).resize();
+          } catch (C) {
+            console.warn("[ToolCalculator] Error during resize:", C), z && c(d) && z.unobserve(c(d));
+          }
+      })), z.observe(c(d)), () => {
+        z && c(d) && z.unobserve(c(d)), z?.disconnect(), z = null;
+      };
+    z && (c(d) && z.unobserve(c(d)), z.disconnect(), z = null);
+  }), tt(() => {
+    c(h) && r() ? c(me) || $(me, ol(c(h)), !0) : !r() && c(me) && (c(me)(), $(me, null));
+  });
+  var _i = {
+    get visible() {
+      return r();
+    },
+    set visible(p = !1) {
+      r(p), et();
+    },
+    get toolId() {
+      return i();
+    },
+    set toolId(p = "calculator") {
+      i(p), et();
+    },
+    get calculatorType() {
+      return n();
+    },
+    set calculatorType(p = "basic") {
+      n(p), et();
+    },
+    get availableTypes() {
+      return s();
+    },
+    set availableTypes(p = ["basic", "scientific", "graphing"]) {
+      s(p), et();
+    },
+    get toolkitCoordinator() {
+      return o();
+    },
+    set toolkitCoordinator(p = null) {
+      o(p), et();
+    }
+  }, xt = dl(), vi = Mt(xt);
+  {
+    var pi = (p) => {
+      var C = cl(), A = Mt(C);
+      fr(A, (se) => $(d, se), () => c(d));
+      var be = ar(A, 2);
+      {
+        var Lt = (se) => {
+          var mt = al();
+          rt(se, mt);
+        };
+        Bt(be, (se) => {
+          (c(T) || c(b) || r() && !c(x) && !c(j)) && se(Lt);
+        });
+      }
+      var gi = ar(be, 2);
+      {
+        var wi = (se) => {
+          var mt = ul(), yi = ar(Mt(mt));
+          {
+            var mi = (sr) => {
+              var lr = fl(), bi = Mt(lr, !0);
+              Pt(lr), Gr(() => qs(bi, c(R))), rt(sr, lr);
+            };
+            Bt(yi, (sr) => {
+              c(R) && sr(mi);
+            });
+          }
+          Pt(mt), rt(se, mt);
+        };
+        Bt(gi, (se) => {
+          c(x) && se(wi);
+        });
+      }
+      Pt(C), fr(C, (se) => $(h, se), () => c(h)), Gr(() => {
+        Xr(C, "data-tool-id", i()), Xr(A, "data-calculator-type", c(g));
+      }), rt(p, C);
+    };
+    Bt(vi, (p) => {
+      r() && p(pi);
+    });
+  }
+  return Pt(xt), fr(xt, (p) => $(a, p), () => c(a)), rt(e, xt), yn(_i);
+}
+customElements.define("pie-tool-calculator", il(
+  _l,
+  {
+    visible: { attribute: "visible", type: "Boolean" },
+    toolId: { attribute: "tool-id", type: "String" },
+    calculatorType: { attribute: "calculator-type", type: "String" },
+    availableTypes: { attribute: "available-types", type: "Array" },
+    toolkitCoordinator: { type: "Object" }
+  },
+  [],
+  []
+));
+export {
+  _l as default
+};