agnosticui-core 2.0.0-alpha.2

package/dist/lifecycle-BbESl1Js.js

@@ -0,0 +1,1938 @@
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add("5");
+let St = !1, er = !1;
+function rr() {
+  St = !0;
+}
+rr();
+const hn = 1, dn = 2, gn = 16, bn = 1, wn = 2, En = 4, yn = 8, An = 16, nr = 1, ir = 2, T = Symbol(), fr = "http://www.w3.org/1999/xhtml", sr = "@attach", de = !1;
+var Vt = Array.isArray, lr = Array.prototype.indexOf, Tn = Array.from, Rt = Object.defineProperty, kt = Object.getOwnPropertyDescriptor, ge = Object.getOwnPropertyDescriptors, ur = Object.prototype, ar = Array.prototype, Yt = Object.getPrototypeOf;
+function or(t) {
+  return t();
+}
+function Ct(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function be() {
+  var t, e, r = new Promise((n, i) => {
+    t = n, e = i;
+  });
+  return { promise: r, resolve: t, reject: e };
+}
+const I = 2, $t = 4, mt = 8, nt = 16, Y = 32, ut = 64, we = 128, M = 256, Et = 512, m = 1024, C = 2048, $ = 4096, Z = 8192, at = 16384, Ht = 32768, Ee = 65536, re = 1 << 17, cr = 1 << 18, Ot = 1 << 19, ye = 1 << 20, Lt = 1 << 21, Wt = 1 << 22, Q = 1 << 23, tt = Symbol("$state"), Sn = Symbol("legacy props"), vr = Symbol(""), ft = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}();
+function _r() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function pr(t) {
+  throw new Error("https://svelte.dev/e/effect_in_teardown");
+}
+function hr() {
+  throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+}
+function dr(t) {
+  throw new Error("https://svelte.dev/e/effect_orphan");
+}
+function gr() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function On(t) {
+  throw new Error("https://svelte.dev/e/props_invalid_value");
+}
+function br() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function wr() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function Er() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function yr() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+function Ae(t) {
+  return t === this.v;
+}
+function Ar(t, e) {
+  return t != t ? e == e : t !== e || t !== null && typeof t == "object" || typeof t == "function";
+}
+function Te(t) {
+  return !Ar(t, this.v);
+}
+let A = null;
+function yt(t) {
+  A = t;
+}
+function kn(t, e = !1, r) {
+  A = {
+    p: A,
+    c: null,
+    e: null,
+    s: t,
+    x: null,
+    l: St && !e ? { s: null, u: null, $: [] } : null
+  };
+}
+function Nn(t) {
+  var e = (
+    /** @type {ComponentContext} */
+    A
+  ), r = e.e;
+  if (r !== null) {
+    e.e = null;
+    for (var n of r)
+      Le(n);
+  }
+  return A = e.p, /** @type {T} */
+  {};
+}
+function gt() {
+  return !St || A !== null && A.l === null;
+}
+let st = [];
+function Tr() {
+  var t = st;
+  st = [], Ct(t);
+}
+function Gt(t) {
+  if (st.length === 0) {
+    var e = st;
+    queueMicrotask(() => {
+      e === st && Tr();
+    });
+  }
+  st.push(t);
+}
+const Sr = /* @__PURE__ */ new WeakMap();
+function mr(t) {
+  var e = d;
+  if (e === null)
+    return h.f |= Q, t;
+  if ((e.f & Ht) === 0) {
+    if ((e.f & we) === 0)
+      throw !e.parent && t instanceof Error && Se(t), t;
+    e.b.error(t);
+  } else
+    At(t, e);
+}
+function At(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & we) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (r) {
+        t = r;
+      }
+    e = e.parent;
+  }
+  throw t instanceof Error && Se(t), t;
+}
+function Se(t) {
+  const e = Sr.get(t);
+  e && (Rt(t, "message", {
+    value: e.message
+  }), Rt(t, "stack", {
+    value: e.stack
+  }));
+}
+const wt = /* @__PURE__ */ new Set();
+let S = null, F = null, ne = /* @__PURE__ */ new Set(), G = [], Kt = null, Mt = !1;
+class pt {
+  /**
+   * 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>}
+   */
+  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>}
+   */
+  #r = /* @__PURE__ */ new Map();
+  /**
+   * When the batch is committed (and the DOM is updated), we need to remove old branches
+   * and append new ones by calling the functions added inside (if/each/key/etc) blocks
+   * @type {Set<() => void>}
+   */
+  #n = /* @__PURE__ */ new Set();
+  /**
+   * The number of async effects that are currently in flight
+   */
+  #t = 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}
+   */
+  #l = null;
+  /**
+   * Template effects and `$effect.pre` effects, which run when
+   * a batch is committed
+   * @type {Effect[]}
+   */
+  #i = [];
+  /**
+   * The same as `#render_effects`, but for `$effect` (which runs after)
+   * @type {Effect[]}
+   */
+  #e = [];
+  /**
+   * Block effects, which may need to re-run on subsequent flushes
+   * in order to update internal sources (e.g. each block items)
+   * @type {Effect[]}
+   */
+  #f = [];
+  /**
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Effect[]}
+   */
+  #u = [];
+  /**
+   * Deferred effects that are MAYBE_DIRTY
+   * @type {Effect[]}
+   */
+  #a = [];
+  /**
+   * A set of branches that still exist, but will be destroyed when this batch
+   * is committed — we skip over these during `process`
+   * @type {Set<Effect>}
+   */
+  skipped_effects = /* @__PURE__ */ new Set();
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(e) {
+    G = [], this.apply();
+    for (const f of e)
+      this.#o(f);
+    if (this.#t === 0) {
+      var r = F;
+      this.#c();
+      var n = this.#i, i = this.#e;
+      this.#i = [], this.#e = [], this.#f = [], S = null, F = r, ie(n), ie(i), this.#l?.resolve();
+    } else
+      this.#s(this.#i), this.#s(this.#e), this.#s(this.#f);
+    F = null;
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   */
+  #o(e) {
+    e.f ^= m;
+    for (var r = e.first; r !== null; ) {
+      var n = r.f, i = (n & (Y | ut)) !== 0, f = i && (n & m) !== 0, s = f || (n & Z) !== 0 || this.skipped_effects.has(r);
+      if (!s && r.fn !== null) {
+        i ? r.f ^= m : (n & $t) !== 0 ? this.#e.push(r) : bt(r) && ((r.f & nt) !== 0 && this.#f.push(r), dt(r));
+        var a = r.first;
+        if (a !== null) {
+          r = a;
+          continue;
+        }
+      }
+      var l = r.parent;
+      for (r = r.next; r === null && l !== null; )
+        r = l.next, l = l.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #s(e) {
+    for (const r of e)
+      ((r.f & C) !== 0 ? this.#u : this.#a).push(r), O(r, m);
+    e.length = 0;
+  }
+  /**
+   * 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, r) {
+    this.#r.has(e) || this.#r.set(e, r), this.current.set(e, e.v), F?.set(e, e.v);
+  }
+  activate() {
+    S = this;
+  }
+  deactivate() {
+    S = null, F = null;
+  }
+  flush() {
+    if (G.length > 0) {
+      if (this.activate(), Or(), S !== null && S !== this)
+        return;
+    } else this.#t === 0 && this.#c();
+    this.deactivate();
+    for (const e of ne)
+      if (ne.delete(e), e(), S !== null)
+        break;
+  }
+  /**
+   * Append and remove branches to/from the DOM
+   */
+  #c() {
+    for (const e of this.#n)
+      e();
+    if (this.#n.clear(), wt.size > 1) {
+      this.#r.clear();
+      let e = !0;
+      for (const r of wt) {
+        if (r === this) {
+          e = !1;
+          continue;
+        }
+        const n = [];
+        for (const [f, s] of this.current) {
+          if (r.current.has(f))
+            if (e && s !== r.current.get(f))
+              r.current.set(f, s);
+            else
+              continue;
+          n.push(f);
+        }
+        if (n.length === 0)
+          continue;
+        const i = [...r.current.keys()].filter((f) => !this.current.has(f));
+        if (i.length > 0) {
+          for (const f of n)
+            me(f, i);
+          if (G.length > 0) {
+            S = r, r.apply();
+            for (const f of G)
+              r.#o(f);
+            G = [], r.deactivate();
+          }
+        }
+      }
+      S = null;
+    }
+    wt.delete(this);
+  }
+  increment() {
+    this.#t += 1;
+  }
+  decrement() {
+    this.#t -= 1;
+    for (const e of this.#u)
+      O(e, C), rt(e);
+    for (const e of this.#a)
+      O(e, $), rt(e);
+    this.flush();
+  }
+  /** @param {() => void} fn */
+  add_callback(e) {
+    this.#n.add(e);
+  }
+  settled() {
+    return (this.#l ??= be()).promise;
+  }
+  static ensure() {
+    if (S === null) {
+      const e = S = new pt();
+      wt.add(S), pt.enqueue(() => {
+        S === e && e.flush();
+      });
+    }
+    return S;
+  }
+  /** @param {() => void} task */
+  static enqueue(e) {
+    Gt(e);
+  }
+  apply() {
+  }
+}
+function Or() {
+  var t = lt;
+  Mt = !0;
+  try {
+    var e = 0;
+    for (le(!0); G.length > 0; ) {
+      var r = pt.ensure();
+      if (e++ > 1e3) {
+        var n, i;
+        kr();
+      }
+      r.process(G), z.clear();
+    }
+  } finally {
+    Mt = !1, le(t), Kt = null;
+  }
+}
+function kr() {
+  try {
+    gr();
+  } catch (t) {
+    At(t, Kt);
+  }
+}
+let J = null;
+function ie(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var r = 0; r < e; ) {
+      var n = t[r++];
+      if ((n.f & (at | Z)) === 0 && bt(n) && (J = [], dt(n), n.deps === null && n.first === null && n.nodes_start === null && (n.teardown === null && n.ac === null ? qe(n) : n.fn = null), J?.length > 0)) {
+        z.clear();
+        for (const i of J)
+          dt(i);
+        J = [];
+      }
+    }
+    J = null;
+  }
+}
+function me(t, e) {
+  if (t.reactions !== null)
+    for (const r of t.reactions) {
+      const n = r.f;
+      (n & I) !== 0 ? me(
+        /** @type {Derived} */
+        r,
+        e
+      ) : (n & (Wt | nt)) !== 0 && Oe(r, e) && (O(r, C), rt(
+        /** @type {Effect} */
+        r
+      ));
+    }
+}
+function Oe(t, e) {
+  if (t.deps !== null) {
+    for (const r of t.deps)
+      if (e.includes(r) || (r.f & I) !== 0 && Oe(
+        /** @type {Derived} */
+        r,
+        e
+      ))
+        return !0;
+  }
+  return !1;
+}
+function rt(t) {
+  for (var e = Kt = t; e.parent !== null; ) {
+    e = e.parent;
+    var r = e.f;
+    if (Mt && e === d && (r & nt) !== 0)
+      return;
+    if ((r & (ut | Y)) !== 0) {
+      if ((r & m) === 0) return;
+      e.f ^= m;
+    }
+  }
+  G.push(e);
+}
+function ke(t, e, r) {
+  const n = gt() ? zt : Pr;
+  if (e.length === 0) {
+    r(t.map(n));
+    return;
+  }
+  var i = S, f = (
+    /** @type {Effect} */
+    d
+  ), s = Nr();
+  Promise.all(e.map((a) => /* @__PURE__ */ Ir(a))).then((a) => {
+    s();
+    try {
+      r([...t.map(n), ...a]);
+    } catch (l) {
+      (f.f & at) === 0 && At(l, f);
+    }
+    i?.deactivate(), jt();
+  }).catch((a) => {
+    At(a, f);
+  });
+}
+function Nr() {
+  var t = d, e = h, r = A, n = S;
+  return function() {
+    q(t), j(e), yt(r), n?.activate();
+  };
+}
+function jt() {
+  q(null), j(null), yt(null);
+}
+// @__NO_SIDE_EFFECTS__
+function zt(t) {
+  var e = I | C, r = h !== null && (h.f & I) !== 0 ? (
+    /** @type {Derived} */
+    h
+  ) : null;
+  return d === null || r !== null && (r.f & M) !== 0 ? e |= M : d.f |= Ot, {
+    ctx: A,
+    deps: null,
+    effects: null,
+    equals: Ae,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      T
+    ),
+    wv: 0,
+    parent: r ?? d,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ir(t, e) {
+  let r = (
+    /** @type {Effect | null} */
+    d
+  );
+  r === null && _r();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), f = Xt(
+    /** @type {V} */
+    T
+  ), s = !h, a = /* @__PURE__ */ new Map();
+  return Ur(() => {
+    var l = be();
+    i = l.promise;
+    try {
+      Promise.resolve(t()).then(l.resolve, l.reject).then(jt);
+    } catch (v) {
+      l.reject(v), jt();
+    }
+    var u = (
+      /** @type {Batch} */
+      S
+    ), o = n.is_pending();
+    s && (n.update_pending_count(1), o || (u.increment(), a.get(u)?.reject(ft), a.delete(u), a.set(u, l)));
+    const c = (v, _ = void 0) => {
+      if (o || u.activate(), _)
+        _ !== ft && (f.f |= Q, Dt(f, _));
+      else {
+        (f.f & Q) !== 0 && (f.f ^= Q), Dt(f, v);
+        for (const [p, w] of a) {
+          if (a.delete(p), p === u) break;
+          w.reject(ft);
+        }
+      }
+      s && (n.update_pending_count(-1), o || u.decrement());
+    };
+    l.promise.then(c, (v) => c(null, v || "unknown"));
+  }), Qt(() => {
+    for (const l of a.values())
+      l.reject(ft);
+  }), new Promise((l) => {
+    function u(o) {
+      function c() {
+        o === i ? l(f) : u(i);
+      }
+      o.then(c, c);
+    }
+    u(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Pr(t) {
+  const e = /* @__PURE__ */ zt(t);
+  return e.equals = Te, e;
+}
+function Ne(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var r = 0; r < e.length; r += 1)
+      X(
+        /** @type {Effect} */
+        e[r]
+      );
+  }
+}
+function Rr(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & I) === 0)
+      return (
+        /** @type {Effect} */
+        e
+      );
+    e = e.parent;
+  }
+  return null;
+}
+function Zt(t) {
+  var e, r = d;
+  q(Rr(t));
+  try {
+    Ne(t), e = We(t);
+  } finally {
+    q(r);
+  }
+  return e;
+}
+function Ie(t) {
+  var e = Zt(t);
+  if (t.equals(e) || (t.v = e, t.wv = $e()), !ot)
+    if (F !== null)
+      F.set(t, t.v);
+    else {
+      var r = (K || (t.f & M) !== 0) && t.deps !== null ? $ : m;
+      O(t, r);
+    }
+}
+const z = /* @__PURE__ */ new Map();
+function Xt(t, e) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: Ae,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function W(t, e) {
+  const r = Xt(t);
+  return Yr(r), r;
+}
+// @__NO_SIDE_EFFECTS__
+function In(t, e = !1, r = !0) {
+  const n = Xt(t);
+  return e || (n.equals = Te), St && r && A !== null && A.l !== null && (A.l.s ??= []).push(n), n;
+}
+function Pn(t, e) {
+  return B(
+    t,
+    te(() => U(t))
+  ), e;
+}
+function B(t, e, r = !1) {
+  h !== 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
+  (!x || (h.f & re) !== 0) && gt() && (h.f & (I | nt | Wt | re)) !== 0 && !V?.includes(t) && Er();
+  let n = r ? _t(e) : e;
+  return Dt(t, n);
+}
+function Dt(t, e) {
+  if (!t.equals(e)) {
+    var r = t.v;
+    ot ? z.set(t, e) : z.set(t, r), t.v = e;
+    var n = pt.ensure();
+    n.capture(t, r), (t.f & I) !== 0 && ((t.f & C) !== 0 && Zt(
+      /** @type {Derived} */
+      t
+    ), O(t, (t.f & M) === 0 ? m : $)), t.wv = $e(), Pe(t, C), gt() && d !== null && (d.f & m) !== 0 && (d.f & (Y | ut)) === 0 && (L === null ? $r([t]) : L.push(t));
+  }
+  return e;
+}
+function Rn(t, e = 1) {
+  var r = U(t), n = e === 1 ? r++ : r--;
+  return B(t, r), n;
+}
+function Nt(t) {
+  B(t, t.v + 1);
+}
+function Pe(t, e) {
+  var r = t.reactions;
+  if (r !== null)
+    for (var n = gt(), i = r.length, f = 0; f < i; f++) {
+      var s = r[f], a = s.f;
+      if (!(!n && s === d)) {
+        var l = (a & C) === 0;
+        l && O(s, e), (a & I) !== 0 ? Pe(
+          /** @type {Derived} */
+          s,
+          $
+        ) : l && ((a & nt) !== 0 && J !== null && J.push(
+          /** @type {Effect} */
+          s
+        ), rt(
+          /** @type {Effect} */
+          s
+        ));
+      }
+    }
+}
+function _t(t) {
+  if (typeof t != "object" || t === null || tt in t)
+    return t;
+  const e = Yt(t);
+  if (e !== ur && e !== ar)
+    return t;
+  var r = /* @__PURE__ */ new Map(), n = Vt(t), i = /* @__PURE__ */ W(0), f = et, s = (a) => {
+    if (et === f)
+      return a();
+    var l = h, u = et;
+    j(null), ae(f);
+    var o = a();
+    return j(l), ae(u), o;
+  };
+  return n && r.set("length", /* @__PURE__ */ W(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(a, l, u) {
+        (!("value" in u) || u.configurable === !1 || u.enumerable === !1 || u.writable === !1) && br();
+        var o = r.get(l);
+        return o === void 0 ? o = s(() => {
+          var c = /* @__PURE__ */ W(u.value);
+          return r.set(l, c), c;
+        }) : B(o, u.value, !0), !0;
+      },
+      deleteProperty(a, l) {
+        var u = r.get(l);
+        if (u === void 0) {
+          if (l in a) {
+            const o = s(() => /* @__PURE__ */ W(T));
+            r.set(l, o), Nt(i);
+          }
+        } else
+          B(u, T), Nt(i);
+        return !0;
+      },
+      get(a, l, u) {
+        if (l === tt)
+          return t;
+        var o = r.get(l), c = l in a;
+        if (o === void 0 && (!c || kt(a, l)?.writable) && (o = s(() => {
+          var _ = _t(c ? a[l] : T), p = /* @__PURE__ */ W(_);
+          return p;
+        }), r.set(l, o)), o !== void 0) {
+          var v = U(o);
+          return v === T ? void 0 : v;
+        }
+        return Reflect.get(a, l, u);
+      },
+      getOwnPropertyDescriptor(a, l) {
+        var u = Reflect.getOwnPropertyDescriptor(a, l);
+        if (u && "value" in u) {
+          var o = r.get(l);
+          o && (u.value = U(o));
+        } else if (u === void 0) {
+          var c = r.get(l), v = c?.v;
+          if (c !== void 0 && v !== T)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: v,
+              writable: !0
+            };
+        }
+        return u;
+      },
+      has(a, l) {
+        if (l === tt)
+          return !0;
+        var u = r.get(l), o = u !== void 0 && u.v !== T || Reflect.has(a, l);
+        if (u !== void 0 || d !== null && (!o || kt(a, l)?.writable)) {
+          u === void 0 && (u = s(() => {
+            var v = o ? _t(a[l]) : T, _ = /* @__PURE__ */ W(v);
+            return _;
+          }), r.set(l, u));
+          var c = U(u);
+          if (c === T)
+            return !1;
+        }
+        return o;
+      },
+      set(a, l, u, o) {
+        var c = r.get(l), v = l in a;
+        if (n && l === "length")
+          for (var _ = u; _ < /** @type {Source<number>} */
+          c.v; _ += 1) {
+            var p = r.get(_ + "");
+            p !== void 0 ? B(p, T) : _ in a && (p = s(() => /* @__PURE__ */ W(T)), r.set(_ + "", p));
+          }
+        if (c === void 0)
+          (!v || kt(a, l)?.writable) && (c = s(() => /* @__PURE__ */ W(void 0)), B(c, _t(u)), r.set(l, c));
+        else {
+          v = c.v !== T;
+          var w = s(() => _t(u));
+          B(c, w);
+        }
+        var E = Reflect.getOwnPropertyDescriptor(a, l);
+        if (E?.set && E.set.call(o, u), !v) {
+          if (n && typeof l == "string") {
+            var y = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), D = Number(l);
+            Number.isInteger(D) && D >= y.v && B(y, D + 1);
+          }
+          Nt(i);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        U(i);
+        var l = Reflect.ownKeys(a).filter((c) => {
+          var v = r.get(c);
+          return v === void 0 || v.v !== T;
+        });
+        for (var [u, o] of r)
+          o.v !== T && !(u in a) && l.push(u);
+        return l;
+      },
+      setPrototypeOf() {
+        wr();
+      }
+    }
+  );
+}
+function fe(t) {
+  try {
+    if (t !== null && typeof t == "object" && tt in t)
+      return t[tt];
+  } catch {
+  }
+  return t;
+}
+function Cr(t, e) {
+  return Object.is(fe(t), fe(e));
+}
+var Lr, Mr, jr;
+function Cn(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Ft(t) {
+  return Mr.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Re(t) {
+  return jr.call(t);
+}
+function Ln(t, e) {
+  return /* @__PURE__ */ Ft(t);
+}
+function Mn(t, e = 1, r = !1) {
+  let n = t;
+  for (; e--; )
+    n = /** @type {TemplateNode} */
+    /* @__PURE__ */ Re(n);
+  return n;
+}
+function jn(t) {
+  t.textContent = "";
+}
+function Dn() {
+  return !1;
+}
+function Dr(t, e) {
+  if (e) {
+    const r = document.body;
+    t.autofocus = !0, Gt(() => {
+      document.activeElement === r && t.focus();
+    });
+  }
+}
+function Jt(t) {
+  var e = h, r = d;
+  j(null), q(null);
+  try {
+    return t();
+  } finally {
+    j(e), q(r);
+  }
+}
+function Ce(t) {
+  d === null && h === null && dr(), h !== null && (h.f & M) !== 0 && d === null && hr(), ot && pr();
+}
+function Fr(t, e) {
+  var r = e.last;
+  r === null ? e.last = e.first = t : (r.next = t, t.prev = r, e.last = t);
+}
+function H(t, e, r, n = !0) {
+  var i = d;
+  i !== null && (i.f & Z) !== 0 && (t |= Z);
+  var f = {
+    ctx: A,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | C,
+    first: null,
+    fn: e,
+    last: null,
+    next: null,
+    parent: i,
+    b: i && i.b,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    wv: 0,
+    ac: null
+  };
+  if (r)
+    try {
+      dt(f), f.f |= Ht;
+    } catch (l) {
+      throw X(f), l;
+    }
+  else e !== null && rt(f);
+  if (n) {
+    var s = f;
+    if (r && s.deps === null && s.teardown === null && s.nodes_start === null && s.first === s.last && // either `null`, or a singular child
+    (s.f & Ot) === 0 && (s = s.first), s !== null && (s.parent = i, i !== null && Fr(s, i), h !== null && (h.f & I) !== 0 && (t & ut) === 0)) {
+      var a = (
+        /** @type {Derived} */
+        h
+      );
+      (a.effects ??= []).push(s);
+    }
+  }
+  return f;
+}
+function Qt(t) {
+  const e = H(mt, null, !1);
+  return O(e, m), e.teardown = t, e;
+}
+function se(t) {
+  Ce();
+  var e = (
+    /** @type {Effect} */
+    d.f
+  ), r = !h && (e & Y) !== 0 && (e & Ht) === 0;
+  if (r) {
+    var n = (
+      /** @type {ComponentContext} */
+      A
+    );
+    (n.e ??= []).push(t);
+  } else
+    return Le(t);
+}
+function Le(t) {
+  return H($t | ye, t, !1);
+}
+function xr(t) {
+  return Ce(), H(mt | ye, t, !0);
+}
+function Me(t) {
+  return H($t, t, !1);
+}
+function Fn(t, e) {
+  var r = (
+    /** @type {ComponentContextLegacy} */
+    A
+  ), n = { effect: null, ran: !1, deps: t };
+  r.l.$.push(n), n.effect = je(() => {
+    t(), !n.ran && (n.ran = !0, te(e));
+  });
+}
+function xn() {
+  var t = (
+    /** @type {ComponentContextLegacy} */
+    A
+  );
+  je(() => {
+    for (var e of t.l.$) {
+      e.deps();
+      var r = e.effect;
+      (r.f & m) !== 0 && O(r, $), bt(r) && dt(r), e.ran = !1;
+    }
+  });
+}
+function Ur(t) {
+  return H(Wt | Ot, t, !0);
+}
+function je(t, e = 0) {
+  return H(mt | e, t, !0);
+}
+function Un(t, e = [], r = []) {
+  ke(e, r, (n) => {
+    H(mt, () => t(...n.map(U)), !0);
+  });
+}
+function De(t, e = 0) {
+  var r = H(nt | e, t, !0);
+  return r;
+}
+function Fe(t, e = !0) {
+  return H(Y | Ot, t, !0, e);
+}
+function xe(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const r = ot, n = h;
+    ue(!0), j(null);
+    try {
+      e.call(null);
+    } finally {
+      ue(r), j(n);
+    }
+  }
+}
+function Ue(t, e = !1) {
+  var r = t.first;
+  for (t.first = t.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && Jt(() => {
+      i.abort(ft);
+    });
+    var n = r.next;
+    (r.f & ut) !== 0 ? r.parent = null : X(r, e), r = n;
+  }
+}
+function qr(t) {
+  for (var e = t.first; e !== null; ) {
+    var r = e.next;
+    (e.f & Y) === 0 && X(e), e = r;
+  }
+}
+function X(t, e = !0) {
+  var r = !1;
+  (e || (t.f & cr) !== 0) && t.nodes_start !== null && t.nodes_end !== null && (Br(
+    t.nodes_start,
+    /** @type {TemplateNode} */
+    t.nodes_end
+  ), r = !0), Ue(t, e && !r), Tt(t, 0), O(t, at);
+  var n = t.transitions;
+  if (n !== null)
+    for (const f of n)
+      f.stop();
+  xe(t);
+  var i = t.parent;
+  i !== null && i.first !== null && qe(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes_start = t.nodes_end = t.ac = null;
+}
+function Br(t, e) {
+  for (; t !== null; ) {
+    var r = t === e ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Re(t)
+    );
+    t.remove(), t = r;
+  }
+}
+function qe(t) {
+  var e = t.parent, r = t.prev, n = t.next;
+  r !== null && (r.next = n), n !== null && (n.prev = r), e !== null && (e.first === t && (e.first = n), e.last === t && (e.last = r));
+}
+function qn(t, e) {
+  var r = [];
+  Be(t, r, !0), Vr(r, () => {
+    X(t), e && e();
+  });
+}
+function Vr(t, e) {
+  var r = t.length;
+  if (r > 0) {
+    var n = () => --r || e();
+    for (var i of t)
+      i.out(n);
+  } else
+    e();
+}
+function Be(t, e, r) {
+  if ((t.f & Z) === 0) {
+    if (t.f ^= Z, t.transitions !== null)
+      for (const s of t.transitions)
+        (s.is_global || r) && e.push(s);
+    for (var n = t.first; n !== null; ) {
+      var i = n.next, f = (n.f & Ee) !== 0 || (n.f & Y) !== 0;
+      Be(n, e, f ? r : !1), n = i;
+    }
+  }
+}
+function Bn(t) {
+  Ve(t, !0);
+}
+function Ve(t, e) {
+  if ((t.f & Z) !== 0) {
+    t.f ^= Z, (t.f & m) === 0 && (O(t, C), rt(t));
+    for (var r = t.first; r !== null; ) {
+      var n = r.next, i = (r.f & Ee) !== 0 || (r.f & Y) !== 0;
+      Ve(r, i ? e : !1), r = n;
+    }
+    if (t.transitions !== null)
+      for (const f of t.transitions)
+        (f.is_global || e) && f.in();
+  }
+}
+let lt = !1;
+function le(t) {
+  lt = t;
+}
+let ot = !1;
+function ue(t) {
+  ot = t;
+}
+let h = null, x = !1;
+function j(t) {
+  h = t;
+}
+let d = null;
+function q(t) {
+  d = t;
+}
+let V = null;
+function Yr(t) {
+  h !== null && (V === null ? V = [t] : V.push(t));
+}
+let N = null, R = 0, L = null;
+function $r(t) {
+  L = t;
+}
+let Ye = 1, ht = 0, et = ht;
+function ae(t) {
+  et = t;
+}
+let K = !1;
+function $e() {
+  return ++Ye;
+}
+function bt(t) {
+  var e = t.f;
+  if ((e & C) !== 0)
+    return !0;
+  if ((e & $) !== 0) {
+    var r = t.deps, n = (e & M) !== 0;
+    if (r !== null) {
+      var i, f, s = (e & Et) !== 0, a = n && d !== null && !K, l = r.length;
+      if ((s || a) && (d === null || (d.f & at) === 0)) {
+        var u = (
+          /** @type {Derived} */
+          t
+        ), o = u.parent;
+        for (i = 0; i < l; i++)
+          f = r[i], (s || !f?.reactions?.includes(u)) && (f.reactions ??= []).push(u);
+        s && (u.f ^= Et), a && o !== null && (o.f & M) === 0 && (u.f ^= M);
+      }
+      for (i = 0; i < l; i++)
+        if (f = r[i], bt(
+          /** @type {Derived} */
+          f
+        ) && Ie(
+          /** @type {Derived} */
+          f
+        ), f.wv > t.wv)
+          return !0;
+    }
+    (!n || d !== null && !K) && O(t, m);
+  }
+  return !1;
+}
+function He(t, e, r = !0) {
+  var n = t.reactions;
+  if (n !== null && !V?.includes(t))
+    for (var i = 0; i < n.length; i++) {
+      var f = n[i];
+      (f.f & I) !== 0 ? He(
+        /** @type {Derived} */
+        f,
+        e,
+        !1
+      ) : e === f && (r ? O(f, C) : (f.f & m) !== 0 && O(f, $), rt(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function We(t) {
+  var e = N, r = R, n = L, i = h, f = K, s = V, a = A, l = x, u = et, o = t.f;
+  N = /** @type {null | Value[]} */
+  null, R = 0, L = null, K = (o & M) !== 0 && (x || !lt || h === null), h = (o & (Y | ut)) === 0 ? t : null, V = null, yt(t.ctx), x = !1, et = ++ht, t.ac !== null && (Jt(() => {
+    t.ac.abort(ft);
+  }), t.ac = null);
+  try {
+    t.f |= Lt;
+    var c = (
+      /** @type {Function} */
+      t.fn
+    ), v = c(), _ = t.deps;
+    if (N !== null) {
+      var p;
+      if (Tt(t, R), _ !== null && R > 0)
+        for (_.length = R + N.length, p = 0; p < N.length; p++)
+          _[R + p] = N[p];
+      else
+        t.deps = _ = N;
+      if (!K || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (o & I) !== 0 && /** @type {import('#client').Derived} */
+      t.reactions !== null)
+        for (p = R; p < _.length; p++)
+          (_[p].reactions ??= []).push(t);
+    } else _ !== null && R < _.length && (Tt(t, R), _.length = R);
+    if (gt() && L !== null && !x && _ !== null && (t.f & (I | $ | C)) === 0)
+      for (p = 0; p < /** @type {Source[]} */
+      L.length; p++)
+        He(
+          L[p],
+          /** @type {Effect} */
+          t
+        );
+    return i !== null && i !== t && (ht++, L !== null && (n === null ? n = L : n.push(.../** @type {Source[]} */
+    L))), (t.f & Q) !== 0 && (t.f ^= Q), v;
+  } catch (w) {
+    return mr(w);
+  } finally {
+    t.f ^= Lt, N = e, R = r, L = n, h = i, K = f, V = s, yt(a), x = l, et = u;
+  }
+}
+function Hr(t, e) {
+  let r = e.reactions;
+  if (r !== null) {
+    var n = lr.call(r, t);
+    if (n !== -1) {
+      var i = r.length - 1;
+      i === 0 ? r = e.reactions = null : (r[n] = r[i], r.pop());
+    }
+  }
+  r === null && (e.f & I) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (N === null || !N.includes(e)) && (O(e, $), (e.f & (M | Et)) === 0 && (e.f ^= Et), Ne(
+    /** @type {Derived} **/
+    e
+  ), Tt(
+    /** @type {Derived} **/
+    e,
+    0
+  ));
+}
+function Tt(t, e) {
+  var r = t.deps;
+  if (r !== null)
+    for (var n = e; n < r.length; n++)
+      Hr(t, r[n]);
+}
+function dt(t) {
+  var e = t.f;
+  if ((e & at) === 0) {
+    O(t, m);
+    var r = d, n = lt;
+    d = t, lt = !0;
+    try {
+      (e & nt) !== 0 ? qr(t) : Ue(t), xe(t);
+      var i = We(t);
+      t.teardown = typeof i == "function" ? i : null, t.wv = Ye;
+      var f;
+      de && er && (t.f & C) !== 0 && t.deps;
+    } finally {
+      lt = n, d = r;
+    }
+  }
+}
+function U(t) {
+  var e = t.f, r = (e & I) !== 0;
+  if (h !== null && !x) {
+    var n = d !== null && (d.f & at) !== 0;
+    if (!n && !V?.includes(t)) {
+      var i = h.deps;
+      if ((h.f & Lt) !== 0)
+        t.rv < ht && (t.rv = ht, N === null && i !== null && i[R] === t ? R++ : N === null ? N = [t] : (!K || !N.includes(t)) && N.push(t));
+      else {
+        (h.deps ??= []).push(t);
+        var f = t.reactions;
+        f === null ? t.reactions = [h] : f.includes(h) || f.push(h);
+      }
+    }
+  } else if (r && /** @type {Derived} */
+  t.deps === null && /** @type {Derived} */
+  t.effects === null) {
+    var s = (
+      /** @type {Derived} */
+      t
+    ), a = s.parent;
+    a !== null && (a.f & M) === 0 && (s.f ^= M);
+  }
+  if (ot) {
+    if (z.has(t))
+      return z.get(t);
+    if (r) {
+      s = /** @type {Derived} */
+      t;
+      var l = s.v;
+      return ((s.f & m) === 0 && s.reactions !== null || Ge(s)) && (l = Zt(s)), z.set(s, l), l;
+    }
+  } else if (r) {
+    if (s = /** @type {Derived} */
+    t, F?.has(s))
+      return F.get(s);
+    bt(s) && Ie(s);
+  }
+  if (F?.has(t))
+    return F.get(t);
+  if ((t.f & Q) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Ge(t) {
+  if (t.v === T) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (z.has(e) || (e.f & I) !== 0 && Ge(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+function te(t) {
+  var e = x;
+  try {
+    return x = !0, t();
+  } finally {
+    x = e;
+  }
+}
+const Wr = -7169;
+function O(t, e) {
+  t.f = t.f & Wr | e;
+}
+function Gr(t) {
+  if (!(typeof t != "object" || !t || t instanceof EventTarget)) {
+    if (tt in t)
+      xt(t);
+    else if (!Array.isArray(t))
+      for (let e in t) {
+        const r = t[e];
+        typeof r == "object" && r && tt in r && xt(r);
+      }
+  }
+}
+function xt(t, e = /* @__PURE__ */ new Set()) {
+  if (typeof t == "object" && t !== null && // We don't want to traverse DOM elements
+  !(t instanceof EventTarget) && !e.has(t)) {
+    e.add(t), t instanceof Date && t.getTime();
+    for (let n in t)
+      try {
+        xt(t[n], e);
+      } catch {
+      }
+    const r = Yt(t);
+    if (r !== Object.prototype && r !== Array.prototype && r !== Map.prototype && r !== Set.prototype && r !== Date.prototype) {
+      const n = ge(r);
+      for (let i in n) {
+        const f = n[i].get;
+        if (f)
+          try {
+            f.call(t);
+          } catch {
+          }
+      }
+    }
+  }
+}
+const Kr = /* @__PURE__ */ new Set(), zr = /* @__PURE__ */ new Set();
+function Ke(t, e, r, n = {}) {
+  function i(f) {
+    if (n.capture || Xr.call(e, f), !f.cancelBubble)
+      return Jt(() => r?.call(this, f));
+  }
+  return t.startsWith("pointer") || t.startsWith("touch") || t === "wheel" ? Gt(() => {
+    e.addEventListener(t, i, n);
+  }) : e.addEventListener(t, i, n), i;
+}
+function Vn(t, e, r, n, i) {
+  var f = { capture: n, passive: i }, s = Ke(t, e, r, f);
+  (e === document.body || // @ts-ignore
+  e === window || // @ts-ignore
+  e === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+  e instanceof HTMLMediaElement) && Qt(() => {
+    e.removeEventListener(t, s, f);
+  });
+}
+function Zr(t) {
+  for (var e = 0; e < t.length; e++)
+    Kr.add(t[e]);
+  for (var r of zr)
+    r(t);
+}
+let oe = null;
+function Xr(t) {
+  var e = this, r = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), n = t.type, i = t.composedPath?.() || [], f = (
+    /** @type {null | Element} */
+    i[0] || t.target
+  );
+  oe = t;
+  var s = 0, a = oe === t && t.__root;
+  if (a) {
+    var l = i.indexOf(a);
+    if (l !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t.__root = e;
+      return;
+    }
+    var u = i.indexOf(e);
+    if (u === -1)
+      return;
+    l <= u && (s = l);
+  }
+  if (f = /** @type {Element} */
+  i[s] || t.target, f !== e) {
+    Rt(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return f || r;
+      }
+    });
+    var o = h, c = d;
+    j(null), q(null);
+    try {
+      for (var v, _ = []; f !== null; ) {
+        var p = f.assignedSlot || f.parentNode || /** @type {any} */
+        f.host || null;
+        try {
+          var w = f["__" + n];
+          if (w != null && (!/** @type {any} */
+          f.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          t.target === f))
+            if (Vt(w)) {
+              var [E, ...y] = w;
+              E.apply(f, [t, ...y]);
+            } else
+              w.call(f, t);
+        } catch (D) {
+          v ? _.push(D) : v = D;
+        }
+        if (t.cancelBubble || p === e || p === null)
+          break;
+        f = p;
+      }
+      if (v) {
+        for (let D of _)
+          queueMicrotask(() => {
+            throw D;
+          });
+        throw v;
+      }
+    } finally {
+      t.__root = e, delete t.currentTarget, j(o), q(c);
+    }
+  }
+}
+function Jr(t) {
+  var e = document.createElement("template");
+  return e.innerHTML = t.replaceAll("<!>", "<!---->"), e.content;
+}
+function ce(t, e) {
+  var r = (
+    /** @type {Effect} */
+    d
+  );
+  r.nodes_start === null && (r.nodes_start = t, r.nodes_end = e);
+}
+// @__NO_SIDE_EFFECTS__
+function Yn(t, e) {
+  var r = (e & nr) !== 0, n = (e & ir) !== 0, i, f = !t.startsWith("<!>");
+  return () => {
+    i === void 0 && (i = Jr(f ? t : "<!>" + t), r || (i = /** @type {Node} */
+    /* @__PURE__ */ Ft(i)));
+    var s = (
+      /** @type {TemplateNode} */
+      n || Lr ? document.importNode(i, !0) : i.cloneNode(!0)
+    );
+    if (r) {
+      var a = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Ft(s)
+      ), l = (
+        /** @type {TemplateNode} */
+        s.lastChild
+      );
+      ce(a, l);
+    } else
+      ce(s, s);
+    return s;
+  };
+}
+function $n(t, e) {
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+function Qr(t) {
+  return t.endsWith("capture") && t !== "gotpointercapture" && t !== "lostpointercapture";
+}
+const tn = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function en(t) {
+  return tn.includes(t);
+}
+const rn = {
+  // no `class: 'className'` because we handle that separately
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
+  readonly: "readOnly",
+  defaultvalue: "defaultValue",
+  defaultchecked: "defaultChecked",
+  srcobject: "srcObject",
+  novalidate: "noValidate",
+  allowfullscreen: "allowFullscreen",
+  disablepictureinpicture: "disablePictureInPicture",
+  disableremoteplayback: "disableRemotePlayback"
+};
+function nn(t) {
+  return t = t.toLowerCase(), rn[t] ?? t;
+}
+function fn(t, e) {
+  var r = void 0, n;
+  De(() => {
+    r !== (r = e()) && (n && (X(n), n = null), r && (n = Fe(() => {
+      Me(() => (
+        /** @type {(node: Element) => void} */
+        r(t)
+      ));
+    })));
+  });
+}
+function ze(t) {
+  var e, r, n = "";
+  if (typeof t == "string" || typeof t == "number") n += t;
+  else if (typeof t == "object") if (Array.isArray(t)) {
+    var i = t.length;
+    for (e = 0; e < i; e++) t[e] && (r = ze(t[e])) && (n && (n += " "), n += r);
+  } else for (r in t) t[r] && (n && (n += " "), n += r);
+  return n;
+}
+function sn() {
+  for (var t, e, r = 0, n = "", i = arguments.length; r < i; r++) (t = arguments[r]) && (e = ze(t)) && (n && (n += " "), n += e);
+  return n;
+}
+function ln(t) {
+  return typeof t == "object" ? sn(t) : t ?? "";
+}
+const ve = [...` 	
+\r\f \v\uFEFF`];
+function un(t, e, r) {
+  var n = t == null ? "" : "" + t;
+  if (r) {
+    for (var i in r)
+      if (r[i])
+        n = n ? n + " " + i : i;
+      else if (n.length)
+        for (var f = i.length, s = 0; (s = n.indexOf(i, s)) >= 0; ) {
+          var a = s + f;
+          (s === 0 || ve.includes(n[s - 1])) && (a === n.length || ve.includes(n[a])) ? n = (s === 0 ? "" : n.substring(0, s)) + n.substring(a + 1) : s = a;
+        }
+  }
+  return n === "" ? null : n;
+}
+function _e(t, e = !1) {
+  var r = e ? " !important;" : ";", n = "";
+  for (var i in t) {
+    var f = t[i];
+    f != null && f !== "" && (n += " " + i + ": " + f + r);
+  }
+  return n;
+}
+function It(t) {
+  return t[0] !== "-" || t[1] !== "-" ? t.toLowerCase() : t;
+}
+function an(t, e) {
+  if (e) {
+    var r = "", n, i;
+    if (Array.isArray(e) ? (n = e[0], i = e[1]) : n = e, t) {
+      t = String(t).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
+      var f = !1, s = 0, a = !1, l = [];
+      n && l.push(...Object.keys(n).map(It)), i && l.push(...Object.keys(i).map(It));
+      var u = 0, o = -1;
+      const w = t.length;
+      for (var c = 0; c < w; c++) {
+        var v = t[c];
+        if (a ? v === "/" && t[c - 1] === "*" && (a = !1) : f ? f === v && (f = !1) : v === "/" && t[c + 1] === "*" ? a = !0 : v === '"' || v === "'" ? f = v : v === "(" ? s++ : v === ")" && s--, !a && f === !1 && s === 0) {
+          if (v === ":" && o === -1)
+            o = c;
+          else if (v === ";" || c === w - 1) {
+            if (o !== -1) {
+              var _ = It(t.substring(u, o).trim());
+              if (!l.includes(_)) {
+                v !== ";" && c++;
+                var p = t.substring(u, c).trim();
+                r += " " + p + ";";
+              }
+            }
+            u = c + 1, o = -1;
+          }
+        }
+      }
+    }
+    return n && (r += _e(n)), i && (r += _e(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return t == null ? null : String(t);
+}
+function on(t, e, r, n, i, f) {
+  var s = t.__className;
+  if (s !== r || s === void 0) {
+    var a = un(r, n, f);
+    a == null ? t.removeAttribute("class") : e ? t.className = a : t.setAttribute("class", a), t.__className = r;
+  } else if (f && i !== f)
+    for (var l in f) {
+      var u = !!f[l];
+      (i == null || u !== !!i[l]) && t.classList.toggle(l, u);
+    }
+  return f;
+}
+function Pt(t, e = {}, r, n) {
+  for (var i in r) {
+    var f = r[i];
+    e[i] !== f && (r[i] == null ? t.style.removeProperty(i) : t.style.setProperty(i, f, n));
+  }
+}
+function cn(t, e, r, n) {
+  var i = t.__style;
+  if (i !== e) {
+    var f = an(e, n);
+    f == null ? t.removeAttribute("style") : t.style.cssText = f, t.__style = e;
+  } else n && (Array.isArray(n) ? (Pt(t, r?.[0], n[0]), Pt(t, r?.[1], n[1], "important")) : Pt(t, r, n));
+  return n;
+}
+function Ut(t, e, r = !1) {
+  if (t.multiple) {
+    if (e == null)
+      return;
+    if (!Vt(e))
+      return yr();
+    for (var n of t.options)
+      n.selected = e.includes(pe(n));
+    return;
+  }
+  for (n of t.options) {
+    var i = pe(n);
+    if (Cr(i, e)) {
+      n.selected = !0;
+      return;
+    }
+  }
+  (!r || e !== void 0) && (t.selectedIndex = -1);
+}
+function vn(t) {
+  var e = new MutationObserver(() => {
+    Ut(t, t.__value);
+  });
+  e.observe(t, {
+    // Listen to option element changes
+    childList: !0,
+    subtree: !0,
+    // because of <optgroup>
+    // Listen to option element value attribute changes
+    // (doesn't get notified of select value changes,
+    // because that property is not reflected as an attribute)
+    attributes: !0,
+    attributeFilter: ["value"]
+  }), Qt(() => {
+    e.disconnect();
+  });
+}
+function pe(t) {
+  return "__value" in t ? t.__value : t.value;
+}
+const ct = Symbol("class"), vt = Symbol("style"), Ze = Symbol("is custom element"), Xe = Symbol("is html");
+function _n(t, e) {
+  e ? t.hasAttribute("selected") || t.setAttribute("selected", "") : t.removeAttribute("selected");
+}
+function qt(t, e, r, n) {
+  var i = Je(t);
+  i[e] !== (i[e] = r) && (e === "loading" && (t[vr] = r), r == null ? t.removeAttribute(e) : typeof r != "string" && ee(t).includes(e) ? t[e] = r : t.setAttribute(e, r));
+}
+function Hn(t, e, r) {
+  var n = h, i = d;
+  j(null), q(null);
+  try {
+    // `style` should use `set_attribute` rather than the setter
+    e !== "style" && // Don't compute setters for custom elements while they aren't registered yet,
+    // because during their upgrade/instantiation they might add more setters.
+    // Instead, fall back to a simple "an object, then set as property" heuristic.
+    (Bt.has(t.getAttribute("is") || t.nodeName) || // customElements may not be available in browser extension contexts
+    !customElements || customElements.get(t.getAttribute("is") || t.tagName.toLowerCase()) ? ee(t).includes(e) : r && typeof r == "object") ? t[e] = r : qt(t, e, r == null ? r : String(r));
+  } finally {
+    j(n), q(i);
+  }
+}
+function pn(t, e, r, n, i = !1, f = !1) {
+  var s = Je(t), a = s[Ze], l = !s[Xe], u = e || {}, o = t.tagName === "OPTION";
+  for (var c in e)
+    c in r || (r[c] = null);
+  r.class ? r.class = ln(r.class) : r[ct] && (r.class = null), r[vt] && (r.style ??= null);
+  var v = ee(t);
+  for (const g in r) {
+    let b = r[g];
+    if (o && g === "value" && b == null) {
+      t.value = t.__value = "", u[g] = b;
+      continue;
+    }
+    if (g === "class") {
+      var _ = t.namespaceURI === "http://www.w3.org/1999/xhtml";
+      on(t, _, b, n, e?.[ct], r[ct]), u[g] = b, u[ct] = r[ct];
+      continue;
+    }
+    if (g === "style") {
+      cn(t, b, e?.[vt], r[vt]), u[g] = b, u[vt] = r[vt];
+      continue;
+    }
+    var p = u[g];
+    if (!(b === p && !(b === void 0 && t.hasAttribute(g)))) {
+      u[g] = b;
+      var w = g[0] + g[1];
+      if (w !== "$$")
+        if (w === "on") {
+          const P = {}, it = "$$" + g;
+          let k = g.slice(2);
+          var E = en(k);
+          if (Qr(k) && (k = k.slice(0, -7), P.capture = !0), !E && p) {
+            if (b != null) continue;
+            t.removeEventListener(k, u[it], P), u[it] = null;
+          }
+          if (b != null)
+            if (E)
+              t[`__${k}`] = b, Zr([k]);
+            else {
+              let Qe = function(tr) {
+                u[g].call(this, tr);
+              };
+              u[it] = Ke(k, t, Qe, P);
+            }
+          else E && (t[`__${k}`] = void 0);
+        } else if (g === "style")
+          qt(t, g, b);
+        else if (g === "autofocus")
+          Dr(
+            /** @type {HTMLElement} */
+            t,
+            !!b
+          );
+        else if (!a && (g === "__value" || g === "value" && b != null))
+          t.value = t.__value = b;
+        else if (g === "selected" && o)
+          _n(
+            /** @type {HTMLOptionElement} */
+            t,
+            b
+          );
+        else {
+          var y = g;
+          l || (y = nn(y));
+          var D = y === "defaultValue" || y === "defaultChecked";
+          if (b == null && !a && !D)
+            if (s[g] = null, y === "value" || y === "checked") {
+              let P = (
+                /** @type {HTMLInputElement} */
+                t
+              );
+              const it = e === void 0;
+              if (y === "value") {
+                let k = P.defaultValue;
+                P.removeAttribute(y), P.defaultValue = k, P.value = P.__value = it ? k : null;
+              } else {
+                let k = P.defaultChecked;
+                P.removeAttribute(y), P.defaultChecked = k, P.checked = it ? k : !1;
+              }
+            } else
+              t.removeAttribute(g);
+          else D || v.includes(y) && (a || typeof b != "string") ? (t[y] = b, y in s && (s[y] = T)) : typeof b != "function" && qt(t, y, b);
+        }
+    }
+  }
+  return u;
+}
+function Wn(t, e, r = [], n = [], i, f = !1, s = !1) {
+  ke(r, n, (a) => {
+    var l = void 0, u = {}, o = t.nodeName === "SELECT", c = !1;
+    if (De(() => {
+      var _ = e(...a.map(U)), p = pn(
+        t,
+        l,
+        _,
+        i,
+        f,
+        s
+      );
+      c && o && "value" in _ && Ut(
+        /** @type {HTMLSelectElement} */
+        t,
+        _.value
+      );
+      for (let E of Object.getOwnPropertySymbols(u))
+        _[E] || X(u[E]);
+      for (let E of Object.getOwnPropertySymbols(_)) {
+        var w = _[E];
+        E.description === sr && (!l || w !== l[E]) && (u[E] && X(u[E]), u[E] = Fe(() => fn(t, () => w))), p[E] = w;
+      }
+      l = p;
+    }), o) {
+      var v = (
+        /** @type {HTMLSelectElement} */
+        t
+      );
+      Me(() => {
+        Ut(
+          v,
+          /** @type {Record<string | symbol, any>} */
+          l.value,
+          !0
+        ), vn(v);
+      });
+    }
+    c = !0;
+  });
+}
+function Je(t) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    t.__attributes ??= {
+      [Ze]: t.nodeName.includes("-"),
+      [Xe]: t.namespaceURI === fr
+    }
+  );
+}
+var Bt = /* @__PURE__ */ new Map();
+function ee(t) {
+  var e = t.getAttribute("is") || t.nodeName, r = Bt.get(e);
+  if (r) return r;
+  Bt.set(e, r = []);
+  for (var n, i = t, f = Element.prototype; f !== i; ) {
+    n = ge(i);
+    for (var s in n)
+      n[s].set && r.push(s);
+    i = Yt(i);
+  }
+  return r;
+}
+function Gn(t = !1) {
+  const e = (
+    /** @type {ComponentContextLegacy} */
+    A
+  ), r = e.l.u;
+  if (!r) return;
+  let n = () => Gr(e.s);
+  if (t) {
+    let i = 0, f = (
+      /** @type {Record<string, any>} */
+      {}
+    );
+    const s = /* @__PURE__ */ zt(() => {
+      let a = !1;
+      const l = e.s;
+      for (const u in l)
+        l[u] !== f[u] && (f[u] = l[u], a = !0);
+      return a && i++, i;
+    });
+    n = () => U(s);
+  }
+  r.b.length && xr(() => {
+    he(e, n), Ct(r.b);
+  }), se(() => {
+    const i = te(() => r.m.map(or));
+    return () => {
+      for (const f of i)
+        typeof f == "function" && f();
+    };
+  }), r.a.length && se(() => {
+    he(e, n), Ct(r.a);
+  });
+}
+function he(t, e) {
+  if (t.l.s)
+    for (const r of t.l.s) U(r);
+  e();
+}
+export {
+  Re as $,
+  Wn as A,
+  $n as B,
+  Nn as C,
+  at as D,
+  kn as E,
+  In as F,
+  Gr as G,
+  De as H,
+  Ee as I,
+  Cn as J,
+  Fe as K,
+  Sn as L,
+  S as M,
+  Dn as N,
+  Bn as O,
+  En as P,
+  qn as Q,
+  Tn as R,
+  tt as S,
+  Vt as T,
+  T as U,
+  Dt as V,
+  dn as W,
+  Z as X,
+  X as Y,
+  hn as Z,
+  gn as _,
+  d as a,
+  Be as a0,
+  jn as a1,
+  Vr as a2,
+  Hn as a3,
+  Un as a4,
+  Vn as a5,
+  Ln as a6,
+  Mn as a7,
+  U as b,
+  _t as c,
+  B as d,
+  Me as e,
+  zt as f,
+  kt as g,
+  Pr as h,
+  Rn as i,
+  q as j,
+  yn as k,
+  St as l,
+  wn as m,
+  bn as n,
+  An as o,
+  On as p,
+  Gt as q,
+  je as r,
+  Xt as s,
+  ot as t,
+  te as u,
+  Pn as v,
+  Fn as w,
+  xn as x,
+  Gn as y,
+  Yn as z
+};