@pie-players/pie-section-player-tools-shared 0.3.3

package/dist/index.js

@@ -0,0 +1,1562 @@
+var Je = Object.defineProperty;
+var ce = (t) => {
+  throw TypeError(t);
+};
+var Qe = (t, e, n) => e in t ? Je(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var z = (t, e, n) => Qe(t, typeof e != "symbol" ? e + "" : e, n), qt = (t, e, n) => e.has(t) || ce("Cannot " + n);
+var o = (t, e, n) => (qt(t, e, "read from private field"), n ? n.call(t) : e.get(t)), w = (t, e, n) => e.has(t) ? ce("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), X = (t, e, n, s) => (qt(t, e, "write to private field"), s ? s.call(t, n) : e.set(t, n), n), j = (t, e, n) => (qt(t, e, "access private method"), n);
+var ge;
+typeof window < "u" && ((ge = window.__svelte ?? (window.__svelte = {})).v ?? (ge.v = /* @__PURE__ */ new Set())).add("5");
+const $e = 1, tn = 2, Ot = /* @__PURE__ */ Symbol(), be = "http://www.w3.org/1999/xhtml", Gt = !1;
+var en = Array.prototype.indexOf, gt = Array.prototype.includes, nn = Object.getOwnPropertyDescriptors, rn = Object.getPrototypeOf;
+const sn = () => {
+};
+function ln(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function Ee() {
+  var t, e, n = new Promise((s, r) => {
+    t = s, e = r;
+  });
+  return { promise: n, resolve: t, reject: e };
+}
+const E = 2, Xt = 4, bt = 8, ie = 1 << 24, st = 16, W = 32, wt = 64, on = 128, D = 512, g = 1024, b = 2048, Y = 4096, F = 8192, Z = 16384, Mt = 32768, Et = 65536, fn = 1 << 18, jt = 1 << 19, rt = 65536, Kt = 1 << 21, xe = 1 << 22, G = 1 << 23, Q = new class extends Error {
+  constructor() {
+    super(...arguments);
+    z(this, "name", "StaleReactionError");
+    z(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}();
+function an() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function un() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function ye(t) {
+  return t === this.v;
+}
+let cn = !1, St = null;
+function Dt(t) {
+  St = t;
+}
+function hn() {
+  return !0;
+}
+let it = [];
+function vn() {
+  var t = it;
+  it = [], ln(t);
+}
+function he(t) {
+  if (it.length === 0) {
+    var e = it;
+    queueMicrotask(() => {
+      e === it && vn();
+    });
+  }
+  it.push(t);
+}
+function dn(t) {
+  var e = _;
+  if (e === null)
+    return v.f |= G, t;
+  if ((e.f & Mt) === 0 && (e.f & Xt) === 0)
+    throw t;
+  Ft(t, e);
+}
+function Ft(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & on) !== 0) {
+      if ((e.f & Mt) === 0)
+        throw t;
+      try {
+        e.b.error(t);
+        return;
+      } catch (n) {
+        t = n;
+      }
+    }
+    e = e.parent;
+  }
+  throw t;
+}
+const _n = -7169;
+function m(t, e) {
+  t.f = t.f & _n | e;
+}
+function le(t) {
+  (t.f & D) !== 0 || t.deps === null ? m(t, g) : m(t, Y);
+}
+function ke(t) {
+  if (t !== null)
+    for (const e of t)
+      (e.f & E) === 0 || (e.f & rt) === 0 || (e.f ^= rt, ke(
+        /** @type {Derived} */
+        e.deps
+      ));
+}
+function pn(t, e, n) {
+  (t.f & b) !== 0 ? e.add(t) : (t.f & Y) !== 0 && n.add(t), ke(t.deps), m(t, g);
+}
+const At = /* @__PURE__ */ new Set();
+let p = null, I = null, N = [], oe = null, ht = null, mn = 1;
+var B, ot, tt, ft, at, ut, U, L, ct, k, Jt, Qt, $t, te;
+const ue = class ue {
+  constructor() {
+    w(this, k);
+    // for debugging. TODO remove once async is stable
+    z(this, "id", mn++);
+    /**
+     * 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>}
+     */
+    z(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>}
+     */
+    z(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>}
+     */
+    w(this, B, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    w(this, ot, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    w(this, tt, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    w(this, ft, 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}
+     */
+    w(this, at, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Set<Effect>}
+     */
+    w(this, ut, /* @__PURE__ */ new Set());
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Set<Effect>}
+     */
+    w(this, U, /* @__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[] }>}
+     */
+    w(this, L, /* @__PURE__ */ new Map());
+    z(this, "is_fork", !1);
+    w(this, ct, !1);
+  }
+  /**
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
+   */
+  skip_effect(e) {
+    o(this, L).has(e) || o(this, L).set(e, { d: [], m: [] });
+  }
+  /**
+   * Remove an effect from the #skipped_branches map and reschedule
+   * any tracked dirty/maybe_dirty child effects
+   * @param {Effect} effect
+   */
+  unskip_effect(e) {
+    var n = o(this, L).get(e);
+    if (n) {
+      o(this, L).delete(e);
+      for (var s of n.d)
+        m(s, b), q(s);
+      for (s of n.m)
+        m(s, Y), q(s);
+    }
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(e) {
+    N = [], this.apply();
+    var n = ht = [], s = [];
+    for (const r of e)
+      j(this, k, Qt).call(this, r, n, s);
+    if (ht = null, j(this, k, Jt).call(this)) {
+      j(this, k, $t).call(this, s), j(this, k, $t).call(this, n);
+      for (const [r, i] of o(this, L))
+        Te(r, i);
+    } else {
+      p = null;
+      for (const r of o(this, B)) r(this);
+      o(this, B).clear(), o(this, tt) === 0 && j(this, k, te).call(this), ve(s), ve(n), o(this, ut).clear(), o(this, U).clear(), o(this, at)?.resolve();
+    }
+    I = null;
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(e, n) {
+    n !== Ot && !this.previous.has(e) && this.previous.set(e, n), (e.f & G) === 0 && (this.current.set(e, e.v), I?.set(e, e.v));
+  }
+  activate() {
+    p = this, this.apply();
+  }
+  deactivate() {
+    p === this && (p = null, I = null);
+  }
+  flush() {
+    if (N.length > 0)
+      p = this, wn();
+    else if (o(this, tt) === 0 && !this.is_fork) {
+      for (const e of o(this, B)) e(this);
+      o(this, B).clear(), j(this, k, te).call(this), o(this, at)?.resolve();
+    }
+    this.deactivate();
+  }
+  discard() {
+    for (const e of o(this, ot)) e(this);
+    o(this, ot).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(e) {
+    X(this, tt, o(this, tt) + 1), e && X(this, ft, o(this, ft) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(e) {
+    X(this, tt, o(this, tt) - 1), e && X(this, ft, o(this, ft) - 1), !o(this, ct) && (X(this, ct, !0), he(() => {
+      X(this, ct, !1), j(this, k, Jt).call(this) ? N.length > 0 && this.flush() : this.revive();
+    }));
+  }
+  revive() {
+    for (const e of o(this, ut))
+      o(this, U).delete(e), m(e, b), q(e);
+    for (const e of o(this, U))
+      m(e, Y), q(e);
+    this.flush();
+  }
+  /** @param {(batch: Batch) => void} fn */
+  oncommit(e) {
+    o(this, B).add(e);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(e) {
+    o(this, ot).add(e);
+  }
+  settled() {
+    return (o(this, at) ?? X(this, at, Ee())).promise;
+  }
+  static ensure() {
+    if (p === null) {
+      const e = p = new ue();
+      At.add(p), he(() => {
+        p === e && e.flush();
+      });
+    }
+    return p;
+  }
+  apply() {
+  }
+};
+B = new WeakMap(), ot = new WeakMap(), tt = new WeakMap(), ft = new WeakMap(), at = new WeakMap(), ut = new WeakMap(), U = new WeakMap(), L = new WeakMap(), ct = new WeakMap(), k = new WeakSet(), Jt = function() {
+  return this.is_fork || o(this, ft) > 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
+ */
+Qt = function(e, n, s) {
+  e.f ^= g;
+  for (var r = e.first; r !== null; ) {
+    var i = r.f, l = (i & (W | wt)) !== 0, f = l && (i & g) !== 0, a = (i & F) !== 0, c = f || o(this, L).has(r);
+    if (!c && r.fn !== null) {
+      l ? a || (r.f ^= g) : (i & Xt) !== 0 ? n.push(r) : (i & (bt | ie)) !== 0 && a ? s.push(r) : Ct(r) && (mt(r), (i & st) !== 0 && (o(this, U).add(r), a && m(r, b)));
+      var h = r.first;
+      if (h !== null) {
+        r = h;
+        continue;
+      }
+    }
+    for (; r !== null; ) {
+      var u = r.next;
+      if (u !== null) {
+        r = u;
+        break;
+      }
+      r = r.parent;
+    }
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+$t = function(e) {
+  for (var n = 0; n < e.length; n += 1)
+    pn(e[n], o(this, ut), o(this, U));
+}, te = function() {
+  var i;
+  if (At.size > 1) {
+    this.previous.clear();
+    var e = p, n = I, s = !0;
+    for (const l of At) {
+      if (l === this) {
+        s = !1;
+        continue;
+      }
+      const f = [];
+      for (const [c, h] of this.current) {
+        if (l.current.has(c))
+          if (s && h !== l.current.get(c))
+            l.current.set(c, h);
+          else
+            continue;
+        f.push(c);
+      }
+      if (f.length === 0)
+        continue;
+      const a = [...l.current.keys()].filter((c) => !this.current.has(c));
+      if (a.length > 0) {
+        var r = N;
+        N = [];
+        const c = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map();
+        for (const u of f)
+          Me(u, a, c, h);
+        if (N.length > 0) {
+          p = l, l.apply();
+          for (const u of N)
+            j(i = l, k, Qt).call(i, u, [], []);
+          l.deactivate();
+        }
+        N = r;
+      }
+    }
+    p = e, I = n;
+  }
+  o(this, L).clear(), At.delete(this);
+};
+let Pt = ue;
+function wn() {
+  var t = null;
+  try {
+    for (var e = 0; N.length > 0; ) {
+      var n = Pt.ensure();
+      if (e++ > 1e3) {
+        var s, r;
+        gn();
+      }
+      n.process(N), K.clear();
+    }
+  } finally {
+    N = [], oe = null, ht = null;
+  }
+}
+function gn() {
+  try {
+    un();
+  } catch (t) {
+    Ft(t, oe);
+  }
+}
+let V = null;
+function ve(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var n = 0; n < e; ) {
+      var s = t[n++];
+      if ((s.f & (Z | F)) === 0 && Ct(s) && (V = /* @__PURE__ */ new Set(), mt(s), s.deps === null && s.first === null && s.nodes === null && s.teardown === null && s.ac === null && He(s), V?.size > 0)) {
+        K.clear();
+        for (const r of V) {
+          if ((r.f & (Z | F)) !== 0) continue;
+          const i = [r];
+          let l = r.parent;
+          for (; l !== null; )
+            V.has(l) && (V.delete(l), i.push(l)), l = l.parent;
+          for (let f = i.length - 1; f >= 0; f--) {
+            const a = i[f];
+            (a.f & (Z | F)) === 0 && mt(a);
+          }
+        }
+        V.clear();
+      }
+    }
+    V = null;
+  }
+}
+function Me(t, e, n, s) {
+  if (!n.has(t) && (n.add(t), t.reactions !== null))
+    for (const r of t.reactions) {
+      const i = r.f;
+      (i & E) !== 0 ? Me(
+        /** @type {Derived} */
+        r,
+        e,
+        n,
+        s
+      ) : (i & (xe | st)) !== 0 && (i & b) === 0 && Se(r, e, s) && (m(r, b), q(
+        /** @type {Effect} */
+        r
+      ));
+    }
+}
+function Se(t, e, n) {
+  const s = n.get(t);
+  if (s !== void 0) return s;
+  if (t.deps !== null)
+    for (const r of t.deps) {
+      if (gt.call(e, r))
+        return !0;
+      if ((r.f & E) !== 0 && Se(
+        /** @type {Derived} */
+        r,
+        e,
+        n
+      ))
+        return n.set(
+          /** @type {Derived} */
+          r,
+          !0
+        ), !0;
+    }
+  return n.set(t, !1), !1;
+}
+function q(t) {
+  var e = oe = t, n = e.b;
+  if (n?.is_pending && (t.f & (Xt | bt | ie)) !== 0 && (t.f & Mt) === 0) {
+    n.defer_effect(t);
+    return;
+  }
+  for (; e.parent !== null; ) {
+    e = e.parent;
+    var s = e.f;
+    if (ht !== null && e === _ && (t.f & bt) === 0)
+      return;
+    if ((s & (wt | W)) !== 0) {
+      if ((s & g) === 0)
+        return;
+      e.f ^= g;
+    }
+  }
+  N.push(e);
+}
+function Te(t, e) {
+  if (!((t.f & W) !== 0 && (t.f & g) !== 0)) {
+    (t.f & b) !== 0 ? e.d.push(t) : (t.f & Y) !== 0 && e.m.push(t), m(t, g);
+    for (var n = t.first; n !== null; )
+      Te(n, e), n = n.next;
+  }
+}
+function bn(t, e, n, s) {
+  const r = yn;
+  var i = t.filter((u) => !u.settled);
+  if (n.length === 0 && i.length === 0) {
+    s(e.map(r));
+    return;
+  }
+  var l = (
+    /** @type {Effect} */
+    _
+  ), f = En(), a = i.length === 1 ? i[0].promise : i.length > 1 ? Promise.all(i.map((u) => u.promise)) : null;
+  function c(u) {
+    f();
+    try {
+      s(u);
+    } catch (x) {
+      (l.f & Z) === 0 && Ft(x, l);
+    }
+    ee();
+  }
+  if (n.length === 0) {
+    a.then(() => c(e.map(r)));
+    return;
+  }
+  function h() {
+    f(), Promise.all(n.map((u) => /* @__PURE__ */ kn(u))).then((u) => c([...e.map(r), ...u])).catch((u) => Ft(u, l));
+  }
+  a ? a.then(h) : h();
+}
+function En() {
+  var t = _, e = v, n = St, s = p;
+  return function(i = !0) {
+    pt(t), _t(e), Dt(n), i && s?.activate();
+  };
+}
+function ee(t = !0) {
+  pt(null), _t(null), Dt(null), t && p?.deactivate();
+}
+function xn() {
+  var t = (
+    /** @type {Boundary} */
+    /** @type {Effect} */
+    _.b
+  ), e = (
+    /** @type {Batch} */
+    p
+  ), n = t.is_rendered();
+  return t.update_pending_count(1), e.increment(n), () => {
+    t.update_pending_count(-1), e.decrement(n);
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function yn(t) {
+  var e = E | b, n = v !== null && (v.f & E) !== 0 ? (
+    /** @type {Derived} */
+    v
+  ) : null;
+  return _ !== null && (_.f |= jt), {
+    ctx: St,
+    deps: null,
+    effects: null,
+    equals: ye,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      Ot
+    ),
+    wv: 0,
+    parent: n ?? _,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function kn(t, e, n) {
+  /** @type {Effect | null} */
+  _ === null && an();
+  var r = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), i = Cn(
+    /** @type {V} */
+    Ot
+  ), l = !v, f = /* @__PURE__ */ new Map();
+  return On(() => {
+    var a = Ee();
+    r = a.promise;
+    try {
+      Promise.resolve(t()).then(a.resolve, a.reject).finally(ee);
+    } catch (x) {
+      a.reject(x), ee();
+    }
+    var c = (
+      /** @type {Batch} */
+      p
+    );
+    if (l) {
+      var h = xn();
+      f.get(c)?.reject(Q), f.delete(c), f.set(c, a);
+    }
+    const u = (x, d = void 0) => {
+      if (c.activate(), d)
+        d !== Q && (i.f |= G, de(i, d));
+      else {
+        (i.f & G) !== 0 && (i.f ^= G), de(i, x);
+        for (const [O, M] of f) {
+          if (f.delete(O), O === c) break;
+          M.reject(Q);
+        }
+      }
+      h && h();
+    };
+    a.promise.then(u, (x) => u(null, x || "unknown"));
+  }), Yn(() => {
+    for (const a of f.values())
+      a.reject(Q);
+  }), new Promise((a) => {
+    function c(h) {
+      function u() {
+        h === r ? a(i) : c(r);
+      }
+      h.then(u, u);
+    }
+    c(r);
+  });
+}
+function Mn(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var n = 0; n < e.length; n += 1)
+      J(
+        /** @type {Effect} */
+        e[n]
+      );
+  }
+}
+function Sn(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & E) === 0)
+      return (e.f & Z) === 0 ? (
+        /** @type {Effect} */
+        e
+      ) : null;
+    e = e.parent;
+  }
+  return null;
+}
+function fe(t) {
+  var e, n = _;
+  pt(Sn(t));
+  try {
+    t.f &= ~rt, Mn(t), e = We(t);
+  } finally {
+    pt(n);
+  }
+  return e;
+}
+function Ce(t) {
+  var e = fe(t);
+  if (!t.equals(e) && (t.wv = je(), (!p?.is_fork || t.deps === null) && (t.v = e, t.deps === null))) {
+    m(t, g);
+    return;
+  }
+  dt || (I !== null ? (Pe() || p?.is_fork) && I.set(t, e) : le(t));
+}
+function Tn(t) {
+  if (t.effects !== null)
+    for (const e of t.effects)
+      (e.teardown || e.ac) && (e.teardown?.(), e.ac?.abort(Q), e.teardown = sn, e.ac = null, xt(e, 0), ae(e));
+}
+function Ae(t) {
+  if (t.effects !== null)
+    for (const e of t.effects)
+      e.teardown && mt(e);
+}
+let ne = /* @__PURE__ */ new Set();
+const K = /* @__PURE__ */ new Map();
+let Re = !1;
+function Cn(t, e) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: ye,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+function de(t, e) {
+  if (!t.equals(e)) {
+    var n = t.v;
+    dt ? K.set(t, e) : K.set(t, n), t.v = e;
+    var s = Pt.ensure();
+    if (s.capture(t, n), (t.f & E) !== 0) {
+      const r = (
+        /** @type {Derived} */
+        t
+      );
+      (t.f & b) !== 0 && fe(r), le(r);
+    }
+    t.wv = je(), Ne(t, b), _ !== null && (_.f & g) !== 0 && (_.f & (W | wt)) === 0 && (R === null ? Un([t]) : R.push(t)), !s.is_fork && ne.size > 0 && !Re && An();
+  }
+  return e;
+}
+function An() {
+  Re = !1;
+  for (const t of ne)
+    (t.f & g) !== 0 && m(t, Y), Ct(t) && mt(t);
+  ne.clear();
+}
+function Ne(t, e) {
+  var n = t.reactions;
+  if (n !== null)
+    for (var s = n.length, r = 0; r < s; r++) {
+      var i = n[r], l = i.f, f = (l & b) === 0;
+      if (f && m(i, e), (l & E) !== 0) {
+        var a = (
+          /** @type {Derived} */
+          i
+        );
+        I?.delete(a), (l & rt) === 0 && (l & D && (i.f |= rt), Ne(a, Y));
+      } else f && ((l & st) !== 0 && V !== null && V.add(
+        /** @type {Effect} */
+        i
+      ), q(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+var Rn, Nn, Dn;
+function _e(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function vt(t) {
+  return (
+    /** @type {TemplateNode | null} */
+    Nn.call(t)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Vt(t) {
+  return (
+    /** @type {TemplateNode | null} */
+    Dn.call(t)
+  );
+}
+function De(t, e) {
+  return /* @__PURE__ */ vt(t);
+}
+function Fn(t, e = !1) {
+  {
+    var n = /* @__PURE__ */ vt(t);
+    return n instanceof Comment && n.data === "" ? /* @__PURE__ */ Vt(n) : n;
+  }
+}
+function Pn(t, e = 1, n = !1) {
+  let s = t;
+  for (; e--; )
+    s = /** @type {TemplateNode} */
+    /* @__PURE__ */ Vt(s);
+  return s;
+}
+function In() {
+  return !1;
+}
+function Ln(t, e, n) {
+  return (
+    /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
+    document.createElementNS(be, t, void 0)
+  );
+}
+function Fe(t) {
+  var e = v, n = _;
+  _t(null), pt(null);
+  try {
+    return t();
+  } finally {
+    _t(e), pt(n);
+  }
+}
+function Hn(t, e) {
+  var n = e.last;
+  n === null ? e.last = e.first = t : (n.next = t, t.prev = n, e.last = t);
+}
+function Tt(t, e) {
+  var n = _;
+  n !== null && (n.f & F) !== 0 && (t |= F);
+  var s = {
+    ctx: St,
+    deps: null,
+    nodes: null,
+    f: t | b | D,
+    first: null,
+    fn: e,
+    last: null,
+    next: null,
+    parent: n,
+    b: n && n.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
+  }, r = s;
+  if ((t & Xt) !== 0)
+    ht !== null ? ht.push(s) : q(s);
+  else if (e !== null) {
+    try {
+      mt(s);
+    } catch (l) {
+      throw J(s), l;
+    }
+    r.deps === null && r.teardown === null && r.nodes === null && r.first === r.last && // either `null`, or a singular child
+    (r.f & jt) === 0 && (r = r.first, (t & st) !== 0 && (t & Et) !== 0 && r !== null && (r.f |= Et));
+  }
+  if (r !== null && (r.parent = n, n !== null && Hn(r, n), v !== null && (v.f & E) !== 0 && (t & wt) === 0)) {
+    var i = (
+      /** @type {Derived} */
+      v
+    );
+    (i.effects ?? (i.effects = [])).push(r);
+  }
+  return s;
+}
+function Pe() {
+  return v !== null && !$;
+}
+function Yn(t) {
+  const e = Tt(bt, null);
+  return m(e, g), e.teardown = t, e;
+}
+function On(t) {
+  return Tt(xe | jt, t);
+}
+function Ie(t, e = [], n = [], s = []) {
+  bn(s, e, n, (r) => {
+    Tt(bt, () => t(...r.map(Zn)));
+  });
+}
+function Xn(t, e = 0) {
+  var n = Tt(st | e, t);
+  return n;
+}
+function pe(t) {
+  return Tt(W | jt, t);
+}
+function Le(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const n = dt, s = v;
+    me(!0), _t(null);
+    try {
+      e.call(null);
+    } finally {
+      me(n), _t(s);
+    }
+  }
+}
+function ae(t, e = !1) {
+  var n = t.first;
+  for (t.first = t.last = null; n !== null; ) {
+    const r = n.ac;
+    r !== null && Fe(() => {
+      r.abort(Q);
+    });
+    var s = n.next;
+    (n.f & wt) !== 0 ? n.parent = null : J(n, e), n = s;
+  }
+}
+function jn(t) {
+  for (var e = t.first; e !== null; ) {
+    var n = e.next;
+    (e.f & W) === 0 && J(e), e = n;
+  }
+}
+function J(t, e = !0) {
+  var n = !1;
+  (e || (t.f & fn) !== 0) && t.nodes !== null && t.nodes.end !== null && (Vn(
+    t.nodes.start,
+    /** @type {TemplateNode} */
+    t.nodes.end
+  ), n = !0), ae(t, e && !n), xt(t, 0), m(t, Z);
+  var s = t.nodes && t.nodes.t;
+  if (s !== null)
+    for (const i of s)
+      i.stop();
+  Le(t);
+  var r = t.parent;
+  r !== null && r.first !== null && He(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes = t.ac = null;
+}
+function Vn(t, e) {
+  for (; t !== null; ) {
+    var n = t === e ? null : /* @__PURE__ */ Vt(t);
+    t.remove(), t = n;
+  }
+}
+function He(t) {
+  var e = t.parent, n = t.prev, s = t.next;
+  n !== null && (n.next = s), s !== null && (s.prev = n), e !== null && (e.first === t && (e.first = s), e.last === t && (e.last = n));
+}
+function Wn(t, e, n = !0) {
+  var s = [];
+  Ye(t, s, !0);
+  var r = () => {
+    n && J(t), e && e();
+  }, i = s.length;
+  if (i > 0) {
+    var l = () => --i || r();
+    for (var f of s)
+      f.out(l);
+  } else
+    r();
+}
+function Ye(t, e, n) {
+  if ((t.f & F) === 0) {
+    t.f ^= F;
+    var s = t.nodes && t.nodes.t;
+    if (s !== null)
+      for (const f of s)
+        (f.is_global || n) && e.push(f);
+    for (var r = t.first; r !== null; ) {
+      var i = r.next, l = (r.f & Et) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (r.f & W) !== 0 && (t.f & st) !== 0;
+      Ye(r, e, l ? n : !1), r = i;
+    }
+  }
+}
+function zn(t) {
+  Oe(t, !0);
+}
+function Oe(t, e) {
+  if ((t.f & F) !== 0) {
+    t.f ^= F;
+    for (var n = t.first; n !== null; ) {
+      var s = n.next, r = (n.f & Et) !== 0 || (n.f & W) !== 0;
+      Oe(n, r ? e : !1), n = s;
+    }
+    var i = t.nodes && t.nodes.t;
+    if (i !== null)
+      for (const l of i)
+        (l.is_global || e) && l.in();
+  }
+}
+function Bn(t, e) {
+  if (t.nodes)
+    for (var n = t.nodes.start, s = t.nodes.end; n !== null; ) {
+      var r = n === s ? null : /* @__PURE__ */ Vt(n);
+      e.append(n), n = r;
+    }
+}
+let Rt = !1, dt = !1;
+function me(t) {
+  dt = t;
+}
+let v = null, $ = !1;
+function _t(t) {
+  v = t;
+}
+let _ = null;
+function pt(t) {
+  _ = t;
+}
+let nt = null, y = null, T = 0, R = null;
+function Un(t) {
+  R = t;
+}
+let Xe = 1, lt = 0;
+function je() {
+  return ++Xe;
+}
+function Ct(t) {
+  var e = t.f;
+  if ((e & b) !== 0)
+    return !0;
+  if (e & E && (t.f &= ~rt), (e & Y) !== 0) {
+    for (var n = (
+      /** @type {Value[]} */
+      t.deps
+    ), s = n.length, r = 0; r < s; r++) {
+      var i = n[r];
+      if (Ct(
+        /** @type {Derived} */
+        i
+      ) && Ce(
+        /** @type {Derived} */
+        i
+      ), i.wv > t.wv)
+        return !0;
+    }
+    (e & D) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    I === null && m(t, g);
+  }
+  return !1;
+}
+function Ve(t, e, n = !0) {
+  var s = t.reactions;
+  if (s !== null && !(nt !== null && gt.call(nt, t)))
+    for (var r = 0; r < s.length; r++) {
+      var i = s[r];
+      (i.f & E) !== 0 ? Ve(
+        /** @type {Derived} */
+        i,
+        e,
+        !1
+      ) : e === i && (n ? m(i, b) : (i.f & g) !== 0 && m(i, Y), q(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function We(t) {
+  var O;
+  var e = y, n = T, s = R, r = v, i = nt, l = St, f = $, a = t.f;
+  y = /** @type {null | Value[]} */
+  null, T = 0, R = null, v = (a & (W | wt)) === 0 ? t : null, nt = null, Dt(t.ctx), $ = !1, ++lt, t.ac !== null && (Fe(() => {
+    t.ac.abort(Q);
+  }), t.ac = null);
+  try {
+    t.f |= Kt;
+    var c = (
+      /** @type {Function} */
+      t.fn
+    ), h = c();
+    t.f |= Mt;
+    var u = t.deps, x = p?.is_fork;
+    if (y !== null) {
+      var d;
+      if (x || xt(t, T), u !== null && T > 0)
+        for (u.length = T + y.length, d = 0; d < y.length; d++)
+          u[T + d] = y[d];
+      else
+        t.deps = u = y;
+      if (Pe() && (t.f & D) !== 0)
+        for (d = T; d < u.length; d++)
+          ((O = u[d]).reactions ?? (O.reactions = [])).push(t);
+    } else !x && u !== null && T < u.length && (xt(t, T), u.length = T);
+    if (hn() && R !== null && !$ && u !== null && (t.f & (E | Y | b)) === 0)
+      for (d = 0; d < /** @type {Source[]} */
+      R.length; d++)
+        Ve(
+          R[d],
+          /** @type {Effect} */
+          t
+        );
+    if (r !== null && r !== t) {
+      if (lt++, r.deps !== null)
+        for (let M = 0; M < n; M += 1)
+          r.deps[M].rv = lt;
+      if (e !== null)
+        for (const M of e)
+          M.rv = lt;
+      R !== null && (s === null ? s = R : s.push(.../** @type {Source[]} */
+      R));
+    }
+    return (t.f & G) !== 0 && (t.f ^= G), h;
+  } catch (M) {
+    return dn(M);
+  } finally {
+    t.f ^= Kt, y = e, T = n, R = s, v = r, nt = i, Dt(l), $ = f;
+  }
+}
+function qn(t, e) {
+  let n = e.reactions;
+  if (n !== null) {
+    var s = en.call(n, t);
+    if (s !== -1) {
+      var r = n.length - 1;
+      r === 0 ? n = e.reactions = null : (n[s] = n[r], n.pop());
+    }
+  }
+  if (n === null && (e.f & E) !== 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
+  (y === null || !gt.call(y, e))) {
+    var i = (
+      /** @type {Derived} */
+      e
+    );
+    (i.f & D) !== 0 && (i.f ^= D, i.f &= ~rt), le(i), Tn(i), xt(i, 0);
+  }
+}
+function xt(t, e) {
+  var n = t.deps;
+  if (n !== null)
+    for (var s = e; s < n.length; s++)
+      qn(t, n[s]);
+}
+function mt(t) {
+  var e = t.f;
+  if ((e & Z) === 0) {
+    m(t, g);
+    var n = _, s = Rt;
+    _ = t, Rt = !0;
+    try {
+      (e & (st | ie)) !== 0 ? jn(t) : ae(t), Le(t);
+      var r = We(t);
+      t.teardown = typeof r == "function" ? r : null, t.wv = Xe;
+      var i;
+      Gt && cn && (t.f & b) !== 0 && t.deps;
+    } finally {
+      Rt = s, _ = n;
+    }
+  }
+}
+function Zn(t) {
+  var e = t.f, n = (e & E) !== 0;
+  if (v !== null && !$) {
+    var s = _ !== null && (_.f & Z) !== 0;
+    if (!s && (nt === null || !gt.call(nt, t))) {
+      var r = v.deps;
+      if ((v.f & Kt) !== 0)
+        t.rv < lt && (t.rv = lt, y === null && r !== null && r[T] === t ? T++ : y === null ? y = [t] : y.push(t));
+      else {
+        (v.deps ?? (v.deps = [])).push(t);
+        var i = t.reactions;
+        i === null ? t.reactions = [v] : gt.call(i, v) || i.push(v);
+      }
+    }
+  }
+  if (dt && K.has(t))
+    return K.get(t);
+  if (n) {
+    var l = (
+      /** @type {Derived} */
+      t
+    );
+    if (dt) {
+      var f = l.v;
+      return ((l.f & g) === 0 && l.reactions !== null || Be(l)) && (f = fe(l)), K.set(l, f), f;
+    }
+    var a = (l.f & D) === 0 && !$ && v !== null && (Rt || (v.f & D) !== 0), c = (l.f & Mt) === 0;
+    Ct(l) && (a && (l.f |= D), Ce(l)), a && !c && (Ae(l), ze(l));
+  }
+  if (I?.has(t))
+    return I.get(t);
+  if ((t.f & G) !== 0)
+    throw t.v;
+  return t.v;
+}
+function ze(t) {
+  if (t.f |= D, t.deps !== null)
+    for (const e of t.deps)
+      (e.reactions ?? (e.reactions = [])).push(t), (e.f & E) !== 0 && (e.f & D) === 0 && (Ae(
+        /** @type {Derived} */
+        e
+      ), ze(
+        /** @type {Derived} */
+        e
+      ));
+}
+function Be(t) {
+  if (t.v === Ot) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (K.has(e) || (e.f & E) !== 0 && Be(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+const Zt = /* @__PURE__ */ Symbol("events"), Gn = /* @__PURE__ */ new Set(), Kn = /* @__PURE__ */ new Set();
+function re(t, e, n) {
+  (e[Zt] ?? (e[Zt] = {}))[t] = n;
+}
+function Ue(t) {
+  for (var e = 0; e < t.length; e++)
+    Gn.add(t[e]);
+  for (var n of Kn)
+    n(t);
+}
+const Jn = (
+  // 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: (t) => t
+  })
+);
+function Qn(t) {
+  return (
+    /** @type {string} */
+    Jn?.createHTML(t) ?? t
+  );
+}
+function qe(t) {
+  var e = Ln("template");
+  return e.innerHTML = Qn(t.replaceAll("<!>", "<!---->")), e.content;
+}
+function se(t, e) {
+  var n = (
+    /** @type {Effect} */
+    _
+  );
+  n.nodes === null && (n.nodes = { start: t, end: e, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function Ze(t, e) {
+  var n = (e & $e) !== 0, s = (e & tn) !== 0, r, i = !t.startsWith("<!>");
+  return () => {
+    r === void 0 && (r = qe(i ? t : "<!>" + t), n || (r = /** @type {TemplateNode} */
+    /* @__PURE__ */ vt(r)));
+    var l = (
+      /** @type {TemplateNode} */
+      s || Rn ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    if (n) {
+      var f = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ vt(l)
+      ), a = (
+        /** @type {TemplateNode} */
+        l.lastChild
+      );
+      se(f, a);
+    } else
+      se(l, l);
+    return l;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function $n(t, e, n = "svg") {
+  var s = !t.startsWith("<!>"), r = `<${n}>${s ? t : "<!>" + t}</${n}>`, i;
+  return () => {
+    if (!i) {
+      var l = (
+        /** @type {DocumentFragment} */
+        qe(r)
+      ), f = (
+        /** @type {Element} */
+        /* @__PURE__ */ vt(l)
+      );
+      i = /** @type {Element} */
+      /* @__PURE__ */ vt(f);
+    }
+    var a = (
+      /** @type {TemplateNode} */
+      i.cloneNode(!0)
+    );
+    return se(a, a), a;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ge(t, e) {
+  return /* @__PURE__ */ $n(t, e, "svg");
+}
+function Nt(t, e) {
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+var P, H, C, et, yt, kt, Yt;
+class tr {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(e, n = !0) {
+    /** @type {TemplateNode} */
+    z(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    w(this, P, /* @__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>}
+     */
+    w(this, H, /* @__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>}
+     */
+    w(this, C, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    w(this, et, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    w(this, yt, !0);
+    /**
+     * @param {Batch} batch
+     */
+    w(this, kt, (e) => {
+      if (o(this, P).has(e)) {
+        var n = (
+          /** @type {Key} */
+          o(this, P).get(e)
+        ), s = o(this, H).get(n);
+        if (s)
+          zn(s), o(this, et).delete(n);
+        else {
+          var r = o(this, C).get(n);
+          r && (r.effect.f & F) === 0 && (o(this, H).set(n, r.effect), o(this, C).delete(n), r.fragment.lastChild.remove(), this.anchor.before(r.fragment), s = r.effect);
+        }
+        for (const [i, l] of o(this, P)) {
+          if (o(this, P).delete(i), i === e)
+            break;
+          const f = o(this, C).get(l);
+          f && (J(f.effect), o(this, C).delete(l));
+        }
+        for (const [i, l] of o(this, H)) {
+          if (i === n || o(this, et).has(i) || (l.f & F) !== 0) continue;
+          const f = () => {
+            if (Array.from(o(this, P).values()).includes(i)) {
+              var c = document.createDocumentFragment();
+              Bn(l, c), c.append(_e()), o(this, C).set(i, { effect: l, fragment: c });
+            } else
+              J(l);
+            o(this, et).delete(i), o(this, H).delete(i);
+          };
+          o(this, yt) || !s ? (o(this, et).add(i), Wn(l, f, !1)) : f();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    w(this, Yt, (e) => {
+      o(this, P).delete(e);
+      const n = Array.from(o(this, P).values());
+      for (const [s, r] of o(this, C))
+        n.includes(s) || (J(r.effect), o(this, C).delete(s));
+    });
+    this.anchor = e, X(this, yt, n);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(e, n) {
+    var s = (
+      /** @type {Batch} */
+      p
+    ), r = In();
+    if (n && !o(this, H).has(e) && !o(this, C).has(e))
+      if (r) {
+        var i = document.createDocumentFragment(), l = _e();
+        i.append(l), o(this, C).set(e, {
+          effect: pe(() => n(l)),
+          fragment: i
+        });
+      } else
+        o(this, H).set(
+          e,
+          pe(() => n(this.anchor))
+        );
+    if (o(this, P).set(s, e), r) {
+      for (const [f, a] of o(this, H))
+        f === e ? s.unskip_effect(a) : s.skip_effect(a);
+      for (const [f, a] of o(this, C))
+        f === e ? s.unskip_effect(a.effect) : s.skip_effect(a.effect);
+      s.oncommit(o(this, kt)), s.ondiscard(o(this, Yt));
+    } else
+      o(this, kt).call(this, s);
+  }
+}
+P = new WeakMap(), H = new WeakMap(), C = new WeakMap(), et = new WeakMap(), yt = new WeakMap(), kt = new WeakMap(), Yt = new WeakMap();
+function er(t, e, n = !1) {
+  var s = new tr(t), r = n ? Et : 0;
+  function i(l, f) {
+    s.ensure(l, f);
+  }
+  Xn(() => {
+    var l = !1;
+    e((f, a = 0) => {
+      l = !0, i(a, f);
+    }), l || i(-1, null);
+  }, r);
+}
+function Ke(t) {
+  var e, n, s = "";
+  if (typeof t == "string" || typeof t == "number") s += t;
+  else if (typeof t == "object") if (Array.isArray(t)) {
+    var r = t.length;
+    for (e = 0; e < r; e++) t[e] && (n = Ke(t[e])) && (s && (s += " "), s += n);
+  } else for (n in t) t[n] && (s && (s += " "), s += n);
+  return s;
+}
+function nr() {
+  for (var t, e, n = 0, s = "", r = arguments.length; n < r; n++) (t = arguments[n]) && (e = Ke(t)) && (s && (s += " "), s += e);
+  return s;
+}
+function It(t) {
+  return typeof t == "object" ? nr(t) : t ?? "";
+}
+function rr(t, e, n) {
+  var s = t == null ? "" : "" + t;
+  return s === "" ? null : s;
+}
+function Lt(t, e, n, s, r, i) {
+  var l = t.__className;
+  if (l !== n || l === void 0) {
+    var f = rr(n);
+    f == null ? t.removeAttribute("class") : e ? t.className = f : t.setAttribute("class", f), t.__className = n;
+  }
+  return i;
+}
+const sr = /* @__PURE__ */ Symbol("is custom element"), ir = /* @__PURE__ */ Symbol("is html");
+function lr(t, e, n, s) {
+  var r = or(t);
+  r[e] !== (r[e] = n) && (n == null ? t.removeAttribute(e) : typeof n != "string" && fr(t).includes(e) ? t[e] = n : t.setAttribute(e, n));
+}
+function or(t) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    t.__attributes ?? (t.__attributes = {
+      [sr]: t.nodeName.includes("-"),
+      [ir]: t.namespaceURI === be
+    })
+  );
+}
+var we = /* @__PURE__ */ new Map();
+function fr(t) {
+  var e = t.getAttribute("is") || t.nodeName, n = we.get(e);
+  if (n) return n;
+  we.set(e, n = []);
+  for (var s, r = t, i = Element.prototype; i !== r; ) {
+    s = nn(r);
+    for (var l in s)
+      s[l].set && n.push(l);
+    r = rn(r);
+  }
+  return n;
+}
+function Ht(t, e, n, s) {
+  var r = (
+    /** @type {V} */
+    s
+  ), i = !0, l = () => (i && (i = !1, r = /** @type {V} */
+  s), r), f;
+  f = /** @type {V} */
+  t[e], f === void 0 && s !== void 0 && (f = l());
+  var a;
+  return a = () => {
+    var c = (
+      /** @type {V} */
+      t[e]
+    );
+    return c === void 0 ? l() : (i = !0, c);
+  }, a;
+}
+var ar = /* @__PURE__ */ Ge('<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 15l7-7 7 7"></path></svg>'), ur = /* @__PURE__ */ Ge('<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path></svg>'), cr = /* @__PURE__ */ Ze('<button><!></button> <button title="Close"><svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg></button>', 1);
+function pr(t, e) {
+  let n = Ht(e, "minimized", 3, !1), s = Ht(e, "buttonClass", 3, "btn btn-xs btn-ghost btn-circle");
+  var r = cr(), i = Fn(r), l = De(i);
+  {
+    var f = (h) => {
+      var u = ar();
+      Nt(h, u);
+    }, a = (h) => {
+      var u = ur();
+      Nt(h, u);
+    };
+    er(l, (h) => {
+      n() ? h(f) : h(a, -1);
+    });
+  }
+  var c = Pn(i, 2);
+  Ie(() => {
+    Lt(i, 1, It(s())), lr(i, "title", n() ? "Maximize" : "Minimize"), Lt(c, 1, It(s()));
+  }), re("click", i, function(...h) {
+    e.onToggle?.apply(this, h);
+  }), re("click", c, function(...h) {
+    e.onClose?.apply(this, h);
+  }), Nt(t, r);
+}
+Ue(["click"]);
+var hr = /* @__PURE__ */ Ze('<div role="button" tabindex="0" title="Resize window"><svg viewBox="0 0 16 16" fill="currentColor"><path d="M16 16V14H14V16H16Z"></path><path d="M16 11V9H14V11H16Z"></path><path d="M13 16V14H11V16H13Z"></path></svg></div>');
+function mr(t, e) {
+  let n = Ht(e, "handleClass", 3, "absolute bottom-0 right-0 w-4 h-4 cursor-se-resize"), s = Ht(e, "iconClass", 3, "w-full h-full text-base-content/30");
+  var r = hr(), i = De(r);
+  Ie(() => {
+    Lt(r, 1, It(n())), Lt(i, 0, It(s()));
+  }), re("mousedown", r, function(...l) {
+    e.onPointerDown?.apply(this, l);
+  }), Nt(t, r);
+}
+Ue(["mousedown"]);
+function wr(t, e) {
+  const n = (u, x, d) => Math.max(x, Math.min(u, d)), s = n(
+    Math.round(t.width * e.widthRatio),
+    e.minWidth,
+    e.maxWidth
+  ), r = n(
+    Math.round(t.height * e.heightRatio),
+    e.minHeight,
+    e.maxHeight
+  ), i = e.paddingX ?? 16, l = e.paddingY ?? 16, f = Math.max(i, t.width - s - i), a = Math.max(l, t.height - r - l), c = e.alignX === "left" ? i : e.alignX === "right" ? f : Math.max(i, Math.round((t.width - s) / 2)), h = e.alignY === "top" ? l : e.alignY === "bottom" ? a : Math.max(l, Math.round((t.height - r) / 2));
+  return { x: c, y: h, width: s, height: r };
+}
+function gr(t) {
+  const e = t.padding ?? 0;
+  let n = !1, s = !1, r = 0, i = 0, l = 0, f = 0, a = 0, c = 0, h = 0, u = 0;
+  const x = (S) => {
+    if (!n) return;
+    const A = t.getState(), Wt = S.clientX - r, zt = S.clientY - i, Bt = Math.max(e, window.innerWidth - A.width - e), Ut = Math.max(e, window.innerHeight - 100 - e);
+    t.setState({
+      ...A,
+      x: Math.max(e, Math.min(l + Wt, Bt)),
+      y: Math.max(e, Math.min(f + zt, Ut))
+    });
+  }, d = (S) => {
+    if (!s) return;
+    const A = t.getState(), Wt = S.clientX - a, zt = S.clientY - c, Bt = Math.max(
+      t.minWidth,
+      window.innerWidth - A.x - e
+    ), Ut = Math.max(
+      t.minHeight,
+      window.innerHeight - A.y - e
+    );
+    t.setState({
+      ...A,
+      width: Math.max(
+        t.minWidth,
+        Math.min(h + Wt, Bt)
+      ),
+      height: Math.max(
+        t.minHeight,
+        Math.min(u + zt, Ut)
+      )
+    });
+  }, O = () => {
+    n = !1, document.removeEventListener("mousemove", x), document.removeEventListener("mouseup", O);
+  }, M = () => {
+    s = !1, document.removeEventListener("mousemove", d), document.removeEventListener("mouseup", M);
+  };
+  return {
+    startDrag(S) {
+      n = !0, r = S.clientX, i = S.clientY;
+      const A = t.getState();
+      l = A.x, f = A.y, document.addEventListener("mousemove", x), document.addEventListener("mouseup", O);
+    },
+    startResize(S) {
+      s = !0, a = S.clientX, c = S.clientY;
+      const A = t.getState();
+      h = A.width, u = A.height, document.addEventListener("mousemove", d), document.addEventListener("mouseup", M), S.preventDefault(), S.stopPropagation();
+    },
+    stop() {
+      O(), M();
+    }
+  };
+}
+function vr(t, e) {
+  return (t || void 0) === (e || void 0);
+}
+function br(t, e, n) {
+  const s = t?.key?.sectionId || "", r = t?.key?.attemptId || void 0;
+  return s !== e ? !1 : vr(r, n);
+}
+function Er(t, e, n) {
+  return !t?.getSectionController || !e ? null : t.getSectionController({
+    sectionId: e,
+    attemptId: n
+  }) || null;
+}
+export {
+  mr as PanelResizeHandle,
+  pr as PanelWindowControls,
+  wr as computePanelSizeFromViewport,
+  gr as createFloatingPanelPointerController,
+  Er as getSectionControllerFromCoordinator,
+  br as isMatchingSectionControllerLifecycleEvent,
+  vr as optionalIdsEqual
+};