mertani-web-toolkit 0.1.5 → 0.1.7

package/dist/index.es.js

@@ -0,0 +1,1664 @@
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add("5");
+const Be = 2, E = Symbol(), Ye = "http://www.w3.org/1999/xhtml", Ke = "@attach", Xt = !1;
+var Pt = Array.isArray, $e = Array.prototype.indexOf, Tt = Object.defineProperty, yt = Object.getOwnPropertyDescriptor, He = Object.getOwnPropertyDescriptors, We = Object.prototype, ze = Array.prototype, te = Object.getPrototypeOf;
+function Ge(t) {
+  for (var e = 0; e < t.length; e++)
+    t[e]();
+}
+function Ze() {
+  var t, e, r = new Promise((n, i) => {
+    t = n, e = i;
+  });
+  return { promise: r, resolve: t, reject: e };
+}
+const C = 2, Rt = 4, ee = 8, X = 16, tt = 32, et = 64, re = 128, R = 256, vt = 512, T = 1024, I = 2048, B = 4096, _t = 8192, rt = 16384, ne = 32768, xt = 1 << 17, Je = 1 << 18, gt = 1 << 19, Qe = 1 << 20, St = 1 << 21, It = 1 << 22, H = 1 << 23, lt = Symbol("$state"), Xe = Symbol(""), Dt = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}();
+function tr() {
+  throw new Error("https://svelte.dev/e/await_outside_boundary");
+}
+function er() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function rr() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function nr() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function ir() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function ur() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function lr() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+function ie(t) {
+  return t === this.v;
+}
+let fr = !1, F = null;
+function dt(t) {
+  F = t;
+}
+function sr(t, e = !1, r) {
+  F = {
+    p: F,
+    c: null,
+    e: null,
+    s: t,
+    x: null,
+    l: null
+  };
+}
+function ar(t) {
+  var e = (
+    /** @type {ComponentContext} */
+    F
+  ), r = e.e;
+  if (r !== null) {
+    e.e = null;
+    for (var n of r)
+      Or(n);
+  }
+  return F = e.p, /** @type {T} */
+  {};
+}
+function ue() {
+  return !0;
+}
+const or = /* @__PURE__ */ new WeakMap();
+function cr(t) {
+  var e = b;
+  if (e === null)
+    return p.f |= H, t;
+  if ((e.f & ne) === 0) {
+    if ((e.f & re) === 0)
+      throw !e.parent && t instanceof Error && le(t), t;
+    e.b.error(t);
+  } else
+    Lt(t, e);
+}
+function Lt(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & re) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (r) {
+        t = r;
+      }
+    e = e.parent;
+  }
+  throw t instanceof Error && le(t), t;
+}
+function le(t) {
+  const e = or.get(t);
+  e && (Tt(t, "message", {
+    value: e.message
+  }), Tt(t, "stack", {
+    value: e.stack
+  }));
+}
+let ht = [];
+function vr() {
+  var t = ht;
+  ht = [], Ge(t);
+}
+function fe(t) {
+  ht.length === 0 && queueMicrotask(vr), ht.push(t);
+}
+function _r() {
+  for (var t = (
+    /** @type {Effect} */
+    b.b
+  ); t !== null && !t.has_pending_snippet(); )
+    t = t.parent;
+  return t === null && tr(), t;
+}
+// @__NO_SIDE_EFFECTS__
+function se(t) {
+  var e = C | I, r = p !== null && (p.f & C) !== 0 ? (
+    /** @type {Derived} */
+    p
+  ) : null;
+  return b === null || r !== null && (r.f & R) !== 0 ? e |= R : b.f |= gt, {
+    ctx: F,
+    deps: null,
+    effects: null,
+    equals: ie,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      E
+    ),
+    wv: 0,
+    parent: r ?? b,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function dr(t, e) {
+  let r = (
+    /** @type {Effect | null} */
+    b
+  );
+  r === null && er();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), u = de(
+    /** @type {V} */
+    E
+  ), f = null, s = !p;
+  return Nr(() => {
+    try {
+      var l = t();
+      f && Promise.resolve(l).catch(() => {
+      });
+    } catch (_) {
+      l = Promise.reject(_);
+    }
+    var a = () => l;
+    i = f?.then(a, a) ?? Promise.resolve(l), f = i;
+    var o = (
+      /** @type {Batch} */
+      k
+    ), c = n.pending;
+    s && (n.update_pending_count(1), c || o.increment());
+    const v = (_, d = void 0) => {
+      f = null, c || o.activate(), d ? d !== Dt && (u.f |= H, Nt(u, d)) : ((u.f & H) !== 0 && (u.f ^= H), Nt(u, _)), s && (n.update_pending_count(-1), c || o.decrement()), ve();
+    };
+    if (i.then(v, (_) => v(null, _ || "unknown")), o)
+      return () => {
+        queueMicrotask(() => o.neuter());
+      };
+  }), new Promise((l) => {
+    function a(o) {
+      function c() {
+        o === i ? l(u) : a(i);
+      }
+      o.then(c, c);
+    }
+    a(i);
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Vt(t) {
+  const e = /* @__PURE__ */ se(t);
+  return Te(e), e;
+}
+function ae(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var r = 0; r < e.length; r += 1)
+      z(
+        /** @type {Effect} */
+        e[r]
+      );
+  }
+}
+function hr(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & C) === 0)
+      return (
+        /** @type {Effect} */
+        e
+      );
+    e = e.parent;
+  }
+  return null;
+}
+function Mt(t) {
+  var e, r = b;
+  U(hr(t));
+  try {
+    ae(t), e = Ce(t);
+  } finally {
+    U(r);
+  }
+  return e;
+}
+function oe(t) {
+  var e = Mt(t);
+  if (t.equals(e) || (t.v = e, t.wv = Oe()), !ct) {
+    var r = (V || (t.f & R) !== 0) && t.deps !== null ? B : T;
+    N(t, r);
+  }
+}
+function ce(t, e, r) {
+  const n = se;
+  if (e.length === 0) {
+    r(t.map(n));
+    return;
+  }
+  var i = k, u = (
+    /** @type {Effect} */
+    b
+  ), f = pr(), s = _r();
+  Promise.all(e.map((l) => /* @__PURE__ */ dr(l))).then((l) => {
+    i?.activate(), f();
+    try {
+      r([...t.map(n), ...l]);
+    } catch (a) {
+      (u.f & rt) === 0 && Lt(a, u);
+    }
+    i?.deactivate(), ve();
+  }).catch((l) => {
+    s.error(l);
+  });
+}
+function pr() {
+  var t = b, e = p, r = F, n = k;
+  return function() {
+    U(t), L(e), dt(r), n?.activate();
+  };
+}
+function ve() {
+  U(null), L(null), dt(null);
+}
+const Et = /* @__PURE__ */ new Set();
+let k = null, qt = /* @__PURE__ */ new Set(), pt = [];
+function _e() {
+  const t = (
+    /** @type {() => void} */
+    pt.shift()
+  );
+  pt.length > 0 && queueMicrotask(_e), t();
+}
+let ft = [], jt = null, Ot = !1;
+class st {
+  /**
+   * 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>}
+   */
+  #s = /* @__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>}
+   */
+  #i = /* @__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}
+   */
+  #a = null;
+  /**
+   * True if an async effect inside this batch resolved and
+   * its parent branch was already deleted
+   */
+  #o = !1;
+  /**
+   * Async effects (created inside `async_derived`) encountered during processing.
+   * These run after the rest of the batch has updated, since they should
+   * always have the latest values
+   * @type {Effect[]}
+   */
+  #r = [];
+  /**
+   * The same as `#async_effects`, but for effects inside a newly-created
+   * `<svelte:boundary>` — these do not prevent the batch from committing
+   * @type {Effect[]}
+   */
+  #u = [];
+  /**
+   * Template effects and `$effect.pre` effects, which run when
+   * a batch is committed
+   * @type {Effect[]}
+   */
+  #n = [];
+  /**
+   * 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[]}
+   */
+  #l = [];
+  /**
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Effect[]}
+   */
+  #c = [];
+  /**
+   * Deferred effects that are MAYBE_DIRTY
+   * @type {Effect[]}
+   */
+  #v = [];
+  /**
+   * 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) {
+    ft = [];
+    for (const i of e)
+      this.#d(i);
+    if (this.#r.length === 0 && this.#t === 0) {
+      this.#_();
+      var r = this.#n, n = this.#e;
+      this.#n = [], this.#e = [], this.#l = [], k = null, Ut(r), Ut(n), k === null ? k = this : Et.delete(this), this.#a?.resolve();
+    } else
+      this.#f(this.#n), this.#f(this.#e), this.#f(this.#l);
+    for (const i of this.#r)
+      Q(i);
+    for (const i of this.#u)
+      Q(i);
+    this.#r = [], this.#u = [];
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   */
+  #d(e) {
+    e.f ^= T;
+    for (var r = e.first; r !== null; ) {
+      var n = r.f, i = (n & (tt | et)) !== 0, u = i && (n & T) !== 0, f = u || (n & _t) !== 0 || this.skipped_effects.has(r);
+      if (!f && r.fn !== null) {
+        if (i)
+          r.f ^= T;
+        else if ((n & Rt) !== 0)
+          this.#e.push(r);
+        else if ((n & T) === 0)
+          if ((n & It) !== 0) {
+            var s = r.b?.pending ? this.#u : this.#r;
+            s.push(r);
+          } else wt(r) && ((r.f & X) !== 0 && this.#l.push(r), Q(r));
+        var l = r.first;
+        if (l !== null) {
+          r = l;
+          continue;
+        }
+      }
+      var a = r.parent;
+      for (r = r.next; r === null && a !== null; )
+        r = a.next, a = a.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #f(e) {
+    for (const r of e)
+      ((r.f & I) !== 0 ? this.#c : this.#v).push(r), N(r, T);
+    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.#s.has(e) || this.#s.set(e, r), this.current.set(e, e.v);
+  }
+  activate() {
+    k = this;
+  }
+  deactivate() {
+    k = null;
+    for (const e of qt)
+      if (qt.delete(e), e(), k !== null)
+        break;
+  }
+  neuter() {
+    this.#o = !0;
+  }
+  flush() {
+    ft.length > 0 ? br() : this.#_(), k === this && (this.#t === 0 && Et.delete(this), this.deactivate());
+  }
+  /**
+   * Append and remove branches to/from the DOM
+   */
+  #_() {
+    if (!this.#o)
+      for (const e of this.#i)
+        e();
+    this.#i.clear();
+  }
+  increment() {
+    this.#t += 1;
+  }
+  decrement() {
+    if (this.#t -= 1, this.#t === 0) {
+      for (const e of this.#c)
+        N(e, I), at(e);
+      for (const e of this.#v)
+        N(e, B), at(e);
+      this.#n = [], this.#e = [], this.flush();
+    } else
+      this.deactivate();
+  }
+  /** @param {() => void} fn */
+  add_callback(e) {
+    this.#i.add(e);
+  }
+  settled() {
+    return (this.#a ??= Ze()).promise;
+  }
+  static ensure() {
+    if (k === null) {
+      const e = k = new st();
+      Et.add(k), st.enqueue(() => {
+        k === e && e.flush();
+      });
+    }
+    return k;
+  }
+  /** @param {() => void} task */
+  static enqueue(e) {
+    pt.length === 0 && queueMicrotask(_e), pt.unshift(e);
+  }
+}
+function br() {
+  var t = J;
+  Ot = !0;
+  try {
+    var e = 0;
+    for (Yt(!0); ft.length > 0; ) {
+      var r = st.ensure();
+      if (e++ > 1e3) {
+        var n, i;
+        gr();
+      }
+      r.process(ft), q.clear();
+    }
+  } finally {
+    Ot = !1, Yt(t), jt = null;
+  }
+}
+function gr() {
+  try {
+    rr();
+  } catch (t) {
+    Lt(t, jt);
+  }
+}
+let K = null;
+function Ut(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var r = 0; r < e; ) {
+      var n = t[r++];
+      if ((n.f & (rt | _t)) === 0 && wt(n) && (K = [], Q(n), n.deps === null && n.first === null && n.nodes_start === null && (n.teardown === null && n.ac === null ? me(n) : n.fn = null), K?.length > 0)) {
+        q.clear();
+        for (const i of K)
+          Q(i);
+        K = [];
+      }
+    }
+    K = null;
+  }
+}
+function at(t) {
+  for (var e = jt = t; e.parent !== null; ) {
+    e = e.parent;
+    var r = e.f;
+    if (Ot && e === b && (r & X) !== 0)
+      return;
+    if ((r & (et | tt)) !== 0) {
+      if ((r & T) === 0) return;
+      e.f ^= T;
+    }
+  }
+  ft.push(e);
+}
+const q = /* @__PURE__ */ new Map();
+function de(t, e) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: ie,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function M(t, e) {
+  const r = de(t);
+  return Te(r), r;
+}
+function x(t, e, r = !1) {
+  p !== 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
+  (!$ || (p.f & xt) !== 0) && ue() && (p.f & (C | X | It | xt)) !== 0 && !j?.includes(t) && ur();
+  let n = r ? ut(e) : e;
+  return Nt(t, n);
+}
+function Nt(t, e) {
+  if (!t.equals(e)) {
+    var r = t.v;
+    ct ? q.set(t, e) : q.set(t, r), t.v = e;
+    var n = st.ensure();
+    n.capture(t, r), (t.f & C) !== 0 && ((t.f & I) !== 0 && Mt(
+      /** @type {Derived} */
+      t
+    ), N(t, (t.f & R) === 0 ? T : B)), t.wv = Oe(), he(t, I), b !== null && (b.f & T) !== 0 && (b.f & (tt | et)) === 0 && (P === null ? Rr([t]) : P.push(t));
+  }
+  return e;
+}
+function At(t) {
+  x(t, t.v + 1);
+}
+function he(t, e) {
+  var r = t.reactions;
+  if (r !== null)
+    for (var n = r.length, i = 0; i < n; i++) {
+      var u = r[i], f = u.f, s = (f & I) === 0;
+      s && N(u, e), (f & C) !== 0 ? he(
+        /** @type {Derived} */
+        u,
+        B
+      ) : s && ((f & X) !== 0 && K !== null && K.push(
+        /** @type {Effect} */
+        u
+      ), at(
+        /** @type {Effect} */
+        u
+      ));
+    }
+}
+function ut(t) {
+  if (typeof t != "object" || t === null || lt in t)
+    return t;
+  const e = te(t);
+  if (e !== We && e !== ze)
+    return t;
+  var r = /* @__PURE__ */ new Map(), n = Pt(t), i = /* @__PURE__ */ M(0), u = W, f = (s) => {
+    if (W === u)
+      return s();
+    var l = p, a = W;
+    L(null), $t(u);
+    var o = s();
+    return L(l), $t(a), o;
+  };
+  return n && r.set("length", /* @__PURE__ */ M(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(s, l, a) {
+        (!("value" in a) || a.configurable === !1 || a.enumerable === !1 || a.writable === !1) && nr();
+        var o = r.get(l);
+        return o === void 0 ? o = f(() => {
+          var c = /* @__PURE__ */ M(a.value);
+          return r.set(l, c), c;
+        }) : x(o, a.value, !0), !0;
+      },
+      deleteProperty(s, l) {
+        var a = r.get(l);
+        if (a === void 0) {
+          if (l in s) {
+            const o = f(() => /* @__PURE__ */ M(E));
+            r.set(l, o), At(i);
+          }
+        } else
+          x(a, E), At(i);
+        return !0;
+      },
+      get(s, l, a) {
+        if (l === lt)
+          return t;
+        var o = r.get(l), c = l in s;
+        if (o === void 0 && (!c || yt(s, l)?.writable) && (o = f(() => {
+          var _ = ut(c ? s[l] : E), d = /* @__PURE__ */ M(_);
+          return d;
+        }), r.set(l, o)), o !== void 0) {
+          var v = D(o);
+          return v === E ? void 0 : v;
+        }
+        return Reflect.get(s, l, a);
+      },
+      getOwnPropertyDescriptor(s, l) {
+        var a = Reflect.getOwnPropertyDescriptor(s, l);
+        if (a && "value" in a) {
+          var o = r.get(l);
+          o && (a.value = D(o));
+        } else if (a === void 0) {
+          var c = r.get(l), v = c?.v;
+          if (c !== void 0 && v !== E)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: v,
+              writable: !0
+            };
+        }
+        return a;
+      },
+      has(s, l) {
+        if (l === lt)
+          return !0;
+        var a = r.get(l), o = a !== void 0 && a.v !== E || Reflect.has(s, l);
+        if (a !== void 0 || b !== null && (!o || yt(s, l)?.writable)) {
+          a === void 0 && (a = f(() => {
+            var v = o ? ut(s[l]) : E, _ = /* @__PURE__ */ M(v);
+            return _;
+          }), r.set(l, a));
+          var c = D(a);
+          if (c === E)
+            return !1;
+        }
+        return o;
+      },
+      set(s, l, a, o) {
+        var c = r.get(l), v = l in s;
+        if (n && l === "length")
+          for (var _ = a; _ < /** @type {Source<number>} */
+          c.v; _ += 1) {
+            var d = r.get(_ + "");
+            d !== void 0 ? x(d, E) : _ in s && (d = f(() => /* @__PURE__ */ M(E)), r.set(_ + "", d));
+          }
+        if (c === void 0)
+          (!v || yt(s, l)?.writable) && (c = f(() => /* @__PURE__ */ M(void 0)), x(c, ut(a)), r.set(l, c));
+        else {
+          v = c.v !== E;
+          var g = f(() => ut(a));
+          x(c, g);
+        }
+        var y = Reflect.getOwnPropertyDescriptor(s, l);
+        if (y?.set && y.set.call(o, a), !v) {
+          if (n && typeof l == "string") {
+            var Y = (
+              /** @type {Source<number>} */
+              r.get("length")
+            ), h = Number(l);
+            Number.isInteger(h) && h >= Y.v && x(Y, h + 1);
+          }
+          At(i);
+        }
+        return !0;
+      },
+      ownKeys(s) {
+        D(i);
+        var l = Reflect.ownKeys(s).filter((c) => {
+          var v = r.get(c);
+          return v === void 0 || v.v !== E;
+        });
+        for (var [a, o] of r)
+          o.v !== E && !(a in s) && l.push(a);
+        return l;
+      },
+      setPrototypeOf() {
+        ir();
+      }
+    }
+  );
+}
+function Bt(t) {
+  try {
+    if (t !== null && typeof t == "object" && lt in t)
+      return t[lt];
+  } catch {
+  }
+  return t;
+}
+function wr(t, e) {
+  return Object.is(Bt(t), Bt(e));
+}
+var yr, Er, Ar;
+// @__NO_SIDE_EFFECTS__
+function pe(t) {
+  return Er.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function kr(t) {
+  return Ar.call(t);
+}
+function be(t, e) {
+  return /* @__PURE__ */ pe(t);
+}
+function mr(t, e) {
+  if (e) {
+    const r = document.body;
+    t.autofocus = !0, fe(() => {
+      document.activeElement === r && t.focus();
+    });
+  }
+}
+function Ft(t) {
+  var e = p, r = b;
+  L(null), U(null);
+  try {
+    return t();
+  } finally {
+    L(e), U(r);
+  }
+}
+function Tr(t, e) {
+  var r = e.last;
+  r === null ? e.last = e.first = t : (r.next = t, t.prev = r, e.last = t);
+}
+function G(t, e, r, n = !0) {
+  var i = b;
+  i !== null && (i.f & _t) !== 0 && (t |= _t);
+  var u = {
+    ctx: F,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | I,
+    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 {
+      Q(u), u.f |= ne;
+    } catch (l) {
+      throw z(u), l;
+    }
+  else e !== null && at(u);
+  if (n) {
+    var f = u;
+    if (r && f.deps === null && f.teardown === null && f.nodes_start === null && f.first === f.last && // either `null`, or a singular child
+    (f.f & gt) === 0 && (f = f.first), f !== null && (f.parent = i, i !== null && Tr(f, i), p !== null && (p.f & C) !== 0 && (t & et) === 0)) {
+      var s = (
+        /** @type {Derived} */
+        p
+      );
+      (s.effects ??= []).push(f);
+    }
+  }
+  return u;
+}
+function Sr(t) {
+  const e = G(ee, null, !1);
+  return N(e, T), e.teardown = t, e;
+}
+function Or(t) {
+  return G(Rt | Qe, t, !1);
+}
+function ge(t) {
+  return G(Rt, t, !1);
+}
+function Nr(t) {
+  return G(It | gt, t, !0);
+}
+function we(t, e = [], r = []) {
+  ce(e, r, (n) => {
+    G(ee, () => t(...n.map(D)), !0);
+  });
+}
+function ye(t, e = 0) {
+  var r = G(X | e, t, !0);
+  return r;
+}
+function Ee(t, e = !0) {
+  return G(tt | gt, t, !0, e);
+}
+function Ae(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const r = ct, n = p;
+    Kt(!0), L(null);
+    try {
+      e.call(null);
+    } finally {
+      Kt(r), L(n);
+    }
+  }
+}
+function ke(t, e = !1) {
+  var r = t.first;
+  for (t.first = t.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && Ft(() => {
+      i.abort(Dt);
+    });
+    var n = r.next;
+    (r.f & et) !== 0 ? r.parent = null : z(r, e), r = n;
+  }
+}
+function Cr(t) {
+  for (var e = t.first; e !== null; ) {
+    var r = e.next;
+    (e.f & tt) === 0 && z(e), e = r;
+  }
+}
+function z(t, e = !0) {
+  var r = !1;
+  (e || (t.f & Je) !== 0) && t.nodes_start !== null && t.nodes_end !== null && (Pr(
+    t.nodes_start,
+    /** @type {TemplateNode} */
+    t.nodes_end
+  ), r = !0), ke(t, e && !r), bt(t, 0), N(t, rt);
+  var n = t.transitions;
+  if (n !== null)
+    for (const u of n)
+      u.stop();
+  Ae(t);
+  var i = t.parent;
+  i !== null && i.first !== null && me(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes_start = t.nodes_end = t.ac = null;
+}
+function Pr(t, e) {
+  for (; t !== null; ) {
+    var r = t === e ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ kr(t)
+    );
+    t.remove(), t = r;
+  }
+}
+function me(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));
+}
+let J = !1;
+function Yt(t) {
+  J = t;
+}
+let ct = !1;
+function Kt(t) {
+  ct = t;
+}
+let p = null, $ = !1;
+function L(t) {
+  p = t;
+}
+let b = null;
+function U(t) {
+  b = t;
+}
+let j = null;
+function Te(t) {
+  p !== null && (j === null ? j = [t] : j.push(t));
+}
+let m = null, O = 0, P = null;
+function Rr(t) {
+  P = t;
+}
+let Se = 1, ot = 0, W = ot;
+function $t(t) {
+  W = t;
+}
+let V = !1;
+function Oe() {
+  return ++Se;
+}
+function wt(t) {
+  var e = t.f;
+  if ((e & I) !== 0)
+    return !0;
+  if ((e & B) !== 0) {
+    var r = t.deps, n = (e & R) !== 0;
+    if (r !== null) {
+      var i, u, f = (e & vt) !== 0, s = n && b !== null && !V, l = r.length;
+      if ((f || s) && (b === null || (b.f & rt) === 0)) {
+        var a = (
+          /** @type {Derived} */
+          t
+        ), o = a.parent;
+        for (i = 0; i < l; i++)
+          u = r[i], (f || !u?.reactions?.includes(a)) && (u.reactions ??= []).push(a);
+        f && (a.f ^= vt), s && o !== null && (o.f & R) === 0 && (a.f ^= R);
+      }
+      for (i = 0; i < l; i++)
+        if (u = r[i], wt(
+          /** @type {Derived} */
+          u
+        ) && oe(
+          /** @type {Derived} */
+          u
+        ), u.wv > t.wv)
+          return !0;
+    }
+    (!n || b !== null && !V) && N(t, T);
+  }
+  return !1;
+}
+function Ne(t, e, r = !0) {
+  var n = t.reactions;
+  if (n !== null && !j?.includes(t))
+    for (var i = 0; i < n.length; i++) {
+      var u = n[i];
+      (u.f & C) !== 0 ? Ne(
+        /** @type {Derived} */
+        u,
+        e,
+        !1
+      ) : e === u && (r ? N(u, I) : (u.f & T) !== 0 && N(u, B), at(
+        /** @type {Effect} */
+        u
+      ));
+    }
+}
+function Ce(t) {
+  var e = m, r = O, n = P, i = p, u = V, f = j, s = F, l = $, a = W, o = t.f;
+  m = /** @type {null | Value[]} */
+  null, O = 0, P = null, V = (o & R) !== 0 && ($ || !J || p === null), p = (o & (tt | et)) === 0 ? t : null, j = null, dt(t.ctx), $ = !1, W = ++ot, t.ac !== null && (Ft(() => {
+    t.ac.abort(Dt);
+  }), t.ac = null);
+  try {
+    t.f |= St;
+    var c = (
+      /** @type {Function} */
+      t.fn
+    ), v = c(), _ = t.deps;
+    if (m !== null) {
+      var d;
+      if (bt(t, O), _ !== null && O > 0)
+        for (_.length = O + m.length, d = 0; d < m.length; d++)
+          _[O + d] = m[d];
+      else
+        t.deps = _ = m;
+      if (!V || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (o & C) !== 0 && /** @type {import('#client').Derived} */
+      t.reactions !== null)
+        for (d = O; d < _.length; d++)
+          (_[d].reactions ??= []).push(t);
+    } else _ !== null && O < _.length && (bt(t, O), _.length = O);
+    if (ue() && P !== null && !$ && _ !== null && (t.f & (C | B | I)) === 0)
+      for (d = 0; d < /** @type {Source[]} */
+      P.length; d++)
+        Ne(
+          P[d],
+          /** @type {Effect} */
+          t
+        );
+    return i !== null && i !== t && (ot++, P !== null && (n === null ? n = P : n.push(.../** @type {Source[]} */
+    P))), (t.f & H) !== 0 && (t.f ^= H), v;
+  } catch (g) {
+    return cr(g);
+  } finally {
+    t.f ^= St, m = e, O = r, P = n, p = i, V = u, j = f, dt(s), $ = l, W = a;
+  }
+}
+function Ir(t, e) {
+  let r = e.reactions;
+  if (r !== null) {
+    var n = $e.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 & C) !== 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
+  (m === null || !m.includes(e)) && (N(e, B), (e.f & (R | vt)) === 0 && (e.f ^= vt), ae(
+    /** @type {Derived} **/
+    e
+  ), bt(
+    /** @type {Derived} **/
+    e,
+    0
+  ));
+}
+function bt(t, e) {
+  var r = t.deps;
+  if (r !== null)
+    for (var n = e; n < r.length; n++)
+      Ir(t, r[n]);
+}
+function Q(t) {
+  var e = t.f;
+  if ((e & rt) === 0) {
+    N(t, T);
+    var r = b, n = J;
+    b = t, J = !0;
+    try {
+      (e & X) !== 0 ? Cr(t) : ke(t), Ae(t);
+      var i = Ce(t);
+      t.teardown = typeof i == "function" ? i : null, t.wv = Se;
+      var u;
+      Xt && fr && (t.f & I) !== 0 && t.deps;
+    } finally {
+      J = n, b = r;
+    }
+  }
+}
+function D(t) {
+  var e = t.f, r = (e & C) !== 0;
+  if (p !== null && !$) {
+    var n = b !== null && (b.f & rt) !== 0;
+    if (!n && !j?.includes(t)) {
+      var i = p.deps;
+      if ((p.f & St) !== 0)
+        t.rv < ot && (t.rv = ot, m === null && i !== null && i[O] === t ? O++ : m === null ? m = [t] : (!V || !m.includes(t)) && m.push(t));
+      else {
+        (p.deps ??= []).push(t);
+        var u = t.reactions;
+        u === null ? t.reactions = [p] : u.includes(p) || u.push(p);
+      }
+    }
+  } else if (r && /** @type {Derived} */
+  t.deps === null && /** @type {Derived} */
+  t.effects === null) {
+    var f = (
+      /** @type {Derived} */
+      t
+    ), s = f.parent;
+    s !== null && (s.f & R) === 0 && (f.f ^= R);
+  }
+  if (ct) {
+    if (q.has(t))
+      return q.get(t);
+    if (r) {
+      f = /** @type {Derived} */
+      t;
+      var l = f.v;
+      return ((f.f & T) === 0 && f.reactions !== null || Pe(f)) && (l = Mt(f)), q.set(f, l), l;
+    }
+  } else r && (f = /** @type {Derived} */
+  t, wt(f) && oe(f));
+  if ((t.f & H) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Pe(t) {
+  if (t.v === E) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (q.has(e) || (e.f & C) !== 0 && Pe(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+const Dr = -7169;
+function N(t, e) {
+  t.f = t.f & Dr | e;
+}
+const Lr = /* @__PURE__ */ new Set(), Mr = /* @__PURE__ */ new Set();
+function jr(t, e, r, n = {}) {
+  function i(u) {
+    if (n.capture || Fr.call(e, u), !u.cancelBubble)
+      return Ft(() => r?.call(this, u));
+  }
+  return t.startsWith("pointer") || t.startsWith("touch") || t === "wheel" ? fe(() => {
+    e.addEventListener(t, i, n);
+  }) : e.addEventListener(t, i, n), i;
+}
+function Re(t) {
+  for (var e = 0; e < t.length; e++)
+    Lr.add(t[e]);
+  for (var r of Mr)
+    r(t);
+}
+let Ht = null;
+function Fr(t) {
+  var e = this, r = (
+    /** @type {Node} */
+    e.ownerDocument
+  ), n = t.type, i = t.composedPath?.() || [], u = (
+    /** @type {null | Element} */
+    i[0] || t.target
+  );
+  Ht = t;
+  var f = 0, s = Ht === t && t.__root;
+  if (s) {
+    var l = i.indexOf(s);
+    if (l !== -1 && (e === document || e === /** @type {any} */
+    window)) {
+      t.__root = e;
+      return;
+    }
+    var a = i.indexOf(e);
+    if (a === -1)
+      return;
+    l <= a && (f = l);
+  }
+  if (u = /** @type {Element} */
+  i[f] || t.target, u !== e) {
+    Tt(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return u || r;
+      }
+    });
+    var o = p, c = b;
+    L(null), U(null);
+    try {
+      for (var v, _ = []; u !== null; ) {
+        var d = u.assignedSlot || u.parentNode || /** @type {any} */
+        u.host || null;
+        try {
+          var g = u["__" + n];
+          if (g != null && (!/** @type {any} */
+          u.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 === u))
+            if (Pt(g)) {
+              var [y, ...Y] = g;
+              y.apply(u, [t, ...Y]);
+            } else
+              g.call(u, t);
+        } catch (h) {
+          v ? _.push(h) : v = h;
+        }
+        if (t.cancelBubble || d === e || d === null)
+          break;
+        u = d;
+      }
+      if (v) {
+        for (let h of _)
+          queueMicrotask(() => {
+            throw h;
+          });
+        throw v;
+      }
+    } finally {
+      t.__root = e, delete t.currentTarget, L(o), U(c);
+    }
+  }
+}
+function xr(t) {
+  var e = document.createElement("template");
+  return e.innerHTML = t.replaceAll("<!>", "<!---->"), e.content;
+}
+function Vr(t, e) {
+  var r = (
+    /** @type {Effect} */
+    b
+  );
+  r.nodes_start === null && (r.nodes_start = t, r.nodes_end = e);
+}
+// @__NO_SIDE_EFFECTS__
+function Ie(t, e) {
+  var r = (e & Be) !== 0, n, i = !t.startsWith("<!>");
+  return () => {
+    n === void 0 && (n = xr(i ? t : "<!>" + t), n = /** @type {Node} */
+    /* @__PURE__ */ pe(n));
+    var u = (
+      /** @type {TemplateNode} */
+      r || yr ? document.importNode(n, !0) : n.cloneNode(!0)
+    );
+    return Vr(u, u), u;
+  };
+}
+function De(t, e) {
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+function qr(t) {
+  return t.endsWith("capture") && t !== "gotpointercapture" && t !== "lostpointercapture";
+}
+const Ur = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function Br(t) {
+  return Ur.includes(t);
+}
+const Yr = {
+  // 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 Kr(t) {
+  return t = t.toLowerCase(), Yr[t] ?? t;
+}
+function Le(t, e) {
+  var r = e == null ? "" : typeof e == "object" ? e + "" : e;
+  r !== (t.__t ??= t.nodeValue) && (t.__t = r, t.nodeValue = r + "");
+}
+function $r(t, e) {
+  var r = void 0, n;
+  ye(() => {
+    r !== (r = e()) && (n && (z(n), n = null), r && (n = Ee(() => {
+      ge(() => (
+        /** @type {(node: Element) => void} */
+        r(t)
+      ));
+    })));
+  });
+}
+function Me(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 = Me(t[e])) && (n && (n += " "), n += r);
+  } else for (r in t) t[r] && (n && (n += " "), n += r);
+  return n;
+}
+function Hr() {
+  for (var t, e, r = 0, n = "", i = arguments.length; r < i; r++) (t = arguments[r]) && (e = Me(t)) && (n && (n += " "), n += e);
+  return n;
+}
+function Wr(t) {
+  return typeof t == "object" ? Hr(t) : t ?? "";
+}
+const Wt = [...` 	
+\r\f \v\uFEFF`];
+function zr(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 u = i.length, f = 0; (f = n.indexOf(i, f)) >= 0; ) {
+          var s = f + u;
+          (f === 0 || Wt.includes(n[f - 1])) && (s === n.length || Wt.includes(n[s])) ? n = (f === 0 ? "" : n.substring(0, f)) + n.substring(s + 1) : f = s;
+        }
+  }
+  return n === "" ? null : n;
+}
+function zt(t, e = !1) {
+  var r = e ? " !important;" : ";", n = "";
+  for (var i in t) {
+    var u = t[i];
+    u != null && u !== "" && (n += " " + i + ": " + u + r);
+  }
+  return n;
+}
+function kt(t) {
+  return t[0] !== "-" || t[1] !== "-" ? t.toLowerCase() : t;
+}
+function Gr(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 u = !1, f = 0, s = !1, l = [];
+      n && l.push(...Object.keys(n).map(kt)), i && l.push(...Object.keys(i).map(kt));
+      var a = 0, o = -1;
+      const g = t.length;
+      for (var c = 0; c < g; c++) {
+        var v = t[c];
+        if (s ? v === "/" && t[c - 1] === "*" && (s = !1) : u ? u === v && (u = !1) : v === "/" && t[c + 1] === "*" ? s = !0 : v === '"' || v === "'" ? u = v : v === "(" ? f++ : v === ")" && f--, !s && u === !1 && f === 0) {
+          if (v === ":" && o === -1)
+            o = c;
+          else if (v === ";" || c === g - 1) {
+            if (o !== -1) {
+              var _ = kt(t.substring(a, o).trim());
+              if (!l.includes(_)) {
+                v !== ";" && c++;
+                var d = t.substring(a, c).trim();
+                r += " " + d + ";";
+              }
+            }
+            a = c + 1, o = -1;
+          }
+        }
+      }
+    }
+    return n && (r += zt(n)), i && (r += zt(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return t == null ? null : String(t);
+}
+function Zr(t, e, r, n, i, u) {
+  var f = t.__className;
+  if (f !== r || f === void 0) {
+    var s = zr(r, n, u);
+    s == null ? t.removeAttribute("class") : e ? t.className = s : t.setAttribute("class", s), t.__className = r;
+  } else if (u && i !== u)
+    for (var l in u) {
+      var a = !!u[l];
+      (i == null || a !== !!i[l]) && t.classList.toggle(l, a);
+    }
+  return u;
+}
+function mt(t, e = {}, r, n) {
+  for (var i in r) {
+    var u = r[i];
+    e[i] !== u && (r[i] == null ? t.style.removeProperty(i) : t.style.setProperty(i, u, n));
+  }
+}
+function Jr(t, e, r, n) {
+  var i = t.__style;
+  if (i !== e) {
+    var u = Gr(e, n);
+    u == null ? t.removeAttribute("style") : t.style.cssText = u, t.__style = e;
+  } else n && (Array.isArray(n) ? (mt(t, r?.[0], n[0]), mt(t, r?.[1], n[1], "important")) : mt(t, r, n));
+  return n;
+}
+function Ct(t, e, r = !1) {
+  if (t.multiple) {
+    if (e == null)
+      return;
+    if (!Pt(e))
+      return lr();
+    for (var n of t.options)
+      n.selected = e.includes(Gt(n));
+    return;
+  }
+  for (n of t.options) {
+    var i = Gt(n);
+    if (wr(i, e)) {
+      n.selected = !0;
+      return;
+    }
+  }
+  (!r || e !== void 0) && (t.selectedIndex = -1);
+}
+function Qr(t) {
+  var e = new MutationObserver(() => {
+    Ct(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"]
+  }), Sr(() => {
+    e.disconnect();
+  });
+}
+function Gt(t) {
+  return "__value" in t ? t.__value : t.value;
+}
+const nt = Symbol("class"), it = Symbol("style"), je = Symbol("is custom element"), Fe = Symbol("is html");
+function Xr(t, e) {
+  e ? t.hasAttribute("selected") || t.setAttribute("selected", "") : t.removeAttribute("selected");
+}
+function Zt(t, e, r, n) {
+  var i = xe(t);
+  i[e] !== (i[e] = r) && (e === "loading" && (t[Xe] = r), r == null ? t.removeAttribute(e) : typeof r != "string" && Ve(t).includes(e) ? t[e] = r : t.setAttribute(e, r));
+}
+function tn(t, e, r, n, i = !1) {
+  var u = xe(t), f = u[je], s = !u[Fe], l = e || {}, a = t.tagName === "OPTION";
+  for (var o in e)
+    o in r || (r[o] = null);
+  r.class ? r.class = Wr(r.class) : r[nt] && (r.class = null), r[it] && (r.style ??= null);
+  var c = Ve(t);
+  for (const h in r) {
+    let w = r[h];
+    if (a && h === "value" && w == null) {
+      t.value = t.__value = "", l[h] = w;
+      continue;
+    }
+    if (h === "class") {
+      var v = t.namespaceURI === "http://www.w3.org/1999/xhtml";
+      Zr(t, v, w, n, e?.[nt], r[nt]), l[h] = w, l[nt] = r[nt];
+      continue;
+    }
+    if (h === "style") {
+      Jr(t, w, e?.[it], r[it]), l[h] = w, l[it] = r[it];
+      continue;
+    }
+    var _ = l[h];
+    if (!(w === _ && !(w === void 0 && t.hasAttribute(h)))) {
+      l[h] = w;
+      var d = h[0] + h[1];
+      if (d !== "$$")
+        if (d === "on") {
+          const S = {}, Z = "$$" + h;
+          let A = h.slice(2);
+          var g = Br(A);
+          if (qr(A) && (A = A.slice(0, -7), S.capture = !0), !g && _) {
+            if (w != null) continue;
+            t.removeEventListener(A, l[Z], S), l[Z] = null;
+          }
+          if (w != null)
+            if (g)
+              t[`__${A}`] = w, Re([A]);
+            else {
+              let qe = function(Ue) {
+                l[h].call(this, Ue);
+              };
+              l[Z] = jr(A, t, qe, S);
+            }
+          else g && (t[`__${A}`] = void 0);
+        } else if (h === "style")
+          Zt(t, h, w);
+        else if (h === "autofocus")
+          mr(
+            /** @type {HTMLElement} */
+            t,
+            !!w
+          );
+        else if (!f && (h === "__value" || h === "value" && w != null))
+          t.value = t.__value = w;
+        else if (h === "selected" && a)
+          Xr(
+            /** @type {HTMLOptionElement} */
+            t,
+            w
+          );
+        else {
+          var y = h;
+          s || (y = Kr(y));
+          var Y = y === "defaultValue" || y === "defaultChecked";
+          if (w == null && !f && !Y)
+            if (u[h] = null, y === "value" || y === "checked") {
+              let S = (
+                /** @type {HTMLInputElement} */
+                t
+              );
+              const Z = e === void 0;
+              if (y === "value") {
+                let A = S.defaultValue;
+                S.removeAttribute(y), S.defaultValue = A, S.value = S.__value = Z ? A : null;
+              } else {
+                let A = S.defaultChecked;
+                S.removeAttribute(y), S.defaultChecked = A, S.checked = Z ? A : !1;
+              }
+            } else
+              t.removeAttribute(h);
+          else Y || c.includes(y) && (f || typeof w != "string") ? (t[y] = w, y in u && (u[y] = E)) : typeof w != "function" && Zt(t, y, w);
+        }
+    }
+  }
+  return l;
+}
+function en(t, e, r = [], n = [], i, u = !1) {
+  ce(r, n, (f) => {
+    var s = void 0, l = {}, a = t.nodeName === "SELECT", o = !1;
+    if (ye(() => {
+      var v = e(...f.map(D)), _ = tn(t, s, v, i, u);
+      o && a && "value" in v && Ct(
+        /** @type {HTMLSelectElement} */
+        t,
+        v.value
+      );
+      for (let g of Object.getOwnPropertySymbols(l))
+        v[g] || z(l[g]);
+      for (let g of Object.getOwnPropertySymbols(v)) {
+        var d = v[g];
+        g.description === Ke && (!s || d !== s[g]) && (l[g] && z(l[g]), l[g] = Ee(() => $r(t, () => d))), _[g] = d;
+      }
+      s = _;
+    }), a) {
+      var c = (
+        /** @type {HTMLSelectElement} */
+        t
+      );
+      ge(() => {
+        Ct(
+          c,
+          /** @type {Record<string | symbol, any>} */
+          s.value,
+          !0
+        ), Qr(c);
+      });
+    }
+    o = !0;
+  });
+}
+function xe(t) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    t.__attributes ??= {
+      [je]: t.nodeName.includes("-"),
+      [Fe]: t.namespaceURI === Ye
+    }
+  );
+}
+var Jt = /* @__PURE__ */ new Map();
+function Ve(t) {
+  var e = t.getAttribute("is") || t.nodeName, r = Jt.get(e);
+  if (r) return r;
+  Jt.set(e, r = []);
+  for (var n, i = t, u = Element.prototype; u !== i; ) {
+    n = He(i);
+    for (var f in n)
+      n[f].set && r.push(f);
+    i = te(i);
+  }
+  return r;
+}
+const rn = {
+  get(t, e) {
+    if (!t.exclude.includes(e))
+      return t.props[e];
+  },
+  set(t, e) {
+    return !1;
+  },
+  getOwnPropertyDescriptor(t, e) {
+    if (!t.exclude.includes(e) && e in t.props)
+      return {
+        enumerable: !0,
+        configurable: !0,
+        value: t.props[e]
+      };
+  },
+  has(t, e) {
+    return t.exclude.includes(e) ? !1 : e in t.props;
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(t.props).filter((e) => !t.exclude.includes(e));
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function nn(t, e, r) {
+  return new Proxy(
+    { props: t, exclude: e },
+    rn
+  );
+}
+function Qt(t, e, r, n) {
+  var i = (
+    /** @type {V} */
+    n
+  ), u = !0, f = () => (u && (u = !1, i = /** @type {V} */
+  n), i), s;
+  s = /** @type {V} */
+  t[e], s === void 0 && n !== void 0 && (s = f());
+  var l;
+  return l = () => {
+    var a = (
+      /** @type {V} */
+      t[e]
+    );
+    return a === void 0 ? f() : (u = !0, a);
+  }, l;
+}
+const un = (t, e) => {
+  x(e, D(e) + 1);
+};
+var ln = /* @__PURE__ */ Ie("<button> </button>");
+function an(t) {
+  let e = /* @__PURE__ */ M(0);
+  var r = ln();
+  r.__click = [un, e];
+  var n = be(r);
+  we(() => Le(n, `count is ${D(e) ?? ""}`)), De(t, r);
+}
+Re(["click"]);
+var fn = /* @__PURE__ */ Ie("<button> </button>");
+function on(t, e) {
+  sr(e, !0);
+  const r = Qt(e, "primary", 3, !1), n = Qt(e, "size", 3, "medium"), i = /* @__PURE__ */ nn(e, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "primary",
+    "backgroundColor",
+    "size",
+    "label"
+  ]);
+  let u = /* @__PURE__ */ Vt(() => r() ? "storybook-button--primary" : "storybook-button--secondary"), f = /* @__PURE__ */ Vt(() => e.backgroundColor ? `background-color: ${e.backgroundColor}` : "");
+  var s = fn();
+  en(s, (a) => ({ type: "button", class: a, style: D(f), ...i }), [
+    () => [
+      "storybook-button",
+      `storybook-button--${n()}`,
+      D(u)
+    ].join(" ")
+  ]);
+  var l = be(s);
+  we(() => Le(l, e.label)), De(t, s), ar();
+}
+export {
+  on as Button,
+  an as Counter
+};