mertani-web-toolkit 0.1.12 → 0.1.14

package/dist/index.esm.js

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