mertani-web-toolkit 0.1.0

package/dist/index.es.js

@@ -0,0 +1,1092 @@
+typeof window < "u" && ((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add("5");
+const Xt = 2, w = Symbol(), Pt = !1;
+var te = Array.isArray, ee = Array.prototype.indexOf, xt = Object.defineProperty, ut = Object.getOwnPropertyDescriptor, ne = Object.prototype, re = Array.prototype, le = Object.getPrototypeOf;
+function se() {
+  var t, e, n = new Promise((r, l) => {
+    t = r, e = l;
+  });
+  return { promise: n, resolve: t, reject: e };
+}
+const E = 2, ie = 4, fe = 8, z = 16, G = 32, Y = 64, At = 128, T = 256, Q = 512, b = 1024, O = 2048, D = 4096, X = 8192, B = 16384, Ct = 32768, kt = 1 << 17, ue = 1 << 18, dt = 1 << 19, vt = 1 << 21, pt = 1 << 22, M = 1 << 23, at = Symbol("$state"), wt = new class extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}();
+function ae() {
+  throw new Error("https://svelte.dev/e/await_outside_boundary");
+}
+function oe() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function ce() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function ve() {
+  throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+}
+function _e() {
+  throw new Error("https://svelte.dev/e/state_prototype_fixed");
+}
+function he() {
+  throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+}
+function Dt(t) {
+  return t === this.v;
+}
+let de = !1, Z = null;
+function tt(t) {
+  Z = t;
+}
+function Ft() {
+  return !0;
+}
+const pe = /* @__PURE__ */ new WeakMap();
+function we(t) {
+  var e = _;
+  if (e === null)
+    return v.f |= M, t;
+  if ((e.f & Ct) === 0) {
+    if ((e.f & At) === 0)
+      throw !e.parent && t instanceof Error && It(t), t;
+    e.b.error(t);
+  } else
+    gt(t, e);
+}
+function gt(t, e) {
+  for (; e !== null; ) {
+    if ((e.f & At) !== 0)
+      try {
+        e.b.error(t);
+        return;
+      } catch (n) {
+        t = n;
+      }
+    e = e.parent;
+  }
+  throw t instanceof Error && It(t), t;
+}
+function It(t) {
+  const e = pe.get(t);
+  e && (xt(t, "message", {
+    value: e.message
+  }), xt(t, "stack", {
+    value: e.stack
+  }));
+}
+function ge() {
+  for (var t = (
+    /** @type {Effect} */
+    _.b
+  ); t !== null && !t.has_pending_snippet(); )
+    t = t.parent;
+  return t === null && ae(), t;
+}
+// @__NO_SIDE_EFFECTS__
+function ye(t) {
+  var e = E | O, n = v !== null && (v.f & E) !== 0 ? (
+    /** @type {Derived} */
+    v
+  ) : null;
+  return _ === null || n !== null && (n.f & T) !== 0 ? e |= T : _.f |= dt, {
+    ctx: Z,
+    deps: null,
+    effects: null,
+    equals: Dt,
+    f: e,
+    fn: t,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      w
+    ),
+    wv: 0,
+    parent: n ?? _,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function be(t, e) {
+  let n = (
+    /** @type {Effect | null} */
+    _
+  );
+  n === null && oe();
+  var r = (
+    /** @type {Boundary} */
+    n.b
+  ), l = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), f = Ut(
+    /** @type {V} */
+    w
+  ), u = null, a = !v;
+  return Ce(() => {
+    try {
+      var s = t();
+      u && Promise.resolve(s).catch(() => {
+      });
+    } catch (h) {
+      s = Promise.reject(h);
+    }
+    var i = () => s;
+    l = u?.then(i, i) ?? Promise.resolve(s), u = l;
+    var o = (
+      /** @type {Batch} */
+      g
+    ), c = r.pending;
+    a && (r.update_pending_count(1), c || o.increment());
+    const p = (h, d = void 0) => {
+      u = null, c || o.activate(), d ? d !== wt && (f.f |= M, ht(f, d)) : ((f.f & M) !== 0 && (f.f ^= M), ht(f, h)), a && (r.update_pending_count(-1), c || o.decrement()), qt();
+    };
+    if (l.then(p, (h) => p(null, h || "unknown")), o)
+      return () => {
+        queueMicrotask(() => o.neuter());
+      };
+  }), new Promise((s) => {
+    function i(o) {
+      function c() {
+        o === l ? s(f) : i(l);
+      }
+      o.then(c, c);
+    }
+    i(l);
+  });
+}
+function jt(t) {
+  var e = t.effects;
+  if (e !== null) {
+    t.effects = null;
+    for (var n = 0; n < e.length; n += 1)
+      lt(
+        /** @type {Effect} */
+        e[n]
+      );
+  }
+}
+function me(t) {
+  for (var e = t.parent; e !== null; ) {
+    if ((e.f & E) === 0)
+      return (
+        /** @type {Effect} */
+        e
+      );
+    e = e.parent;
+  }
+  return null;
+}
+function yt(t) {
+  var e, n = _;
+  V(me(t));
+  try {
+    jt(t), e = Jt(t);
+  } finally {
+    V(n);
+  }
+  return e;
+}
+function Mt(t) {
+  var e = yt(t);
+  if (t.equals(e) || (t.v = e, t.wv = Gt()), !J) {
+    var n = (P || (t.f & T) !== 0) && t.deps !== null ? D : b;
+    k(t, n);
+  }
+}
+function Ee(t, e, n) {
+  const r = ye;
+  if (e.length === 0) {
+    n(t.map(r));
+    return;
+  }
+  var l = g, f = (
+    /** @type {Effect} */
+    _
+  ), u = xe(), a = ge();
+  Promise.all(e.map((s) => /* @__PURE__ */ be(s))).then((s) => {
+    l?.activate(), u();
+    try {
+      n([...t.map(r), ...s]);
+    } catch (i) {
+      (f.f & B) === 0 && gt(i, f);
+    }
+    l?.deactivate(), qt();
+  }).catch((s) => {
+    a.error(s);
+  });
+}
+function xe() {
+  var t = _, e = v, n = Z, r = g;
+  return function() {
+    V(t), C(e), tt(n), r?.activate();
+  };
+}
+function qt() {
+  V(null), C(null), tt(null);
+}
+const ot = /* @__PURE__ */ new Set();
+let g = null, Tt = /* @__PURE__ */ new Set(), et = [];
+function Lt() {
+  const t = (
+    /** @type {() => void} */
+    et.shift()
+  );
+  et.length > 0 && queueMicrotask(Lt), t();
+}
+let H = [], bt = null, _t = !1;
+class W {
+  /**
+   * 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>}
+   */
+  #u = /* @__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[]}
+   */
+  #n = [];
+  /**
+   * The same as `#async_effects`, but for effects inside a newly-created
+   * `<svelte:boundary>` — these do not prevent the batch from committing
+   * @type {Effect[]}
+   */
+  #s = [];
+  /**
+   * Template effects and `$effect.pre` effects, which run when
+   * a batch is committed
+   * @type {Effect[]}
+   */
+  #r = [];
+  /**
+   * 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) {
+    H = [];
+    for (const l of e)
+      this.#h(l);
+    if (this.#n.length === 0 && this.#t === 0) {
+      this.#_();
+      var n = this.#r, r = this.#e;
+      this.#r = [], this.#e = [], this.#i = [], g = null, Ot(n), Ot(r), g === null ? g = this : ot.delete(this), this.#a?.resolve();
+    } else
+      this.#f(this.#r), this.#f(this.#e), this.#f(this.#i);
+    for (const l of this.#n)
+      U(l);
+    for (const l of this.#s)
+      U(l);
+    this.#n = [], this.#s = [];
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   */
+  #h(e) {
+    e.f ^= b;
+    for (var n = e.first; n !== null; ) {
+      var r = n.f, l = (r & (G | Y)) !== 0, f = l && (r & b) !== 0, u = f || (r & X) !== 0 || this.skipped_effects.has(n);
+      if (!u && n.fn !== null) {
+        if (l)
+          n.f ^= b;
+        else if ((r & ie) !== 0)
+          this.#e.push(n);
+        else if ((r & b) === 0)
+          if ((r & pt) !== 0) {
+            var a = n.b?.pending ? this.#s : this.#n;
+            a.push(n);
+          } else st(n) && ((n.f & z) !== 0 && this.#i.push(n), U(n));
+        var s = n.first;
+        if (s !== null) {
+          n = s;
+          continue;
+        }
+      }
+      var i = n.parent;
+      for (n = n.next; n === null && i !== null; )
+        n = i.next, i = i.parent;
+    }
+  }
+  /**
+   * @param {Effect[]} effects
+   */
+  #f(e) {
+    for (const n of e)
+      ((n.f & O) !== 0 ? this.#c : this.#v).push(n), k(n, b);
+    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, n) {
+    this.#u.has(e) || this.#u.set(e, n), this.current.set(e, e.v);
+  }
+  activate() {
+    g = this;
+  }
+  deactivate() {
+    g = null;
+    for (const e of Tt)
+      if (Tt.delete(e), e(), g !== null)
+        break;
+  }
+  neuter() {
+    this.#o = !0;
+  }
+  flush() {
+    H.length > 0 ? ke() : this.#_(), g === this && (this.#t === 0 && ot.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)
+        k(e, O), nt(e);
+      for (const e of this.#v)
+        k(e, D), nt(e);
+      this.#r = [], this.#e = [], this.flush();
+    } else
+      this.deactivate();
+  }
+  /** @param {() => void} fn */
+  add_callback(e) {
+    this.#l.add(e);
+  }
+  settled() {
+    return (this.#a ??= se()).promise;
+  }
+  static ensure() {
+    if (g === null) {
+      const e = g = new W();
+      ot.add(g), W.enqueue(() => {
+        g === e && e.flush();
+      });
+    }
+    return g;
+  }
+  /** @param {() => void} task */
+  static enqueue(e) {
+    et.length === 0 && queueMicrotask(Lt), et.unshift(e);
+  }
+}
+function ke() {
+  var t = L;
+  _t = !0;
+  try {
+    var e = 0;
+    for (St(!0); H.length > 0; ) {
+      var n = W.ensure();
+      if (e++ > 1e3) {
+        var r, l;
+        Te();
+      }
+      n.process(H), A.clear();
+    }
+  } finally {
+    _t = !1, St(t), bt = null;
+  }
+}
+function Te() {
+  try {
+    ce();
+  } catch (t) {
+    gt(t, bt);
+  }
+}
+let F = null;
+function Ot(t) {
+  var e = t.length;
+  if (e !== 0) {
+    for (var n = 0; n < e; ) {
+      var r = t[n++];
+      if ((r.f & (B | X)) === 0 && st(r) && (F = [], U(r), r.deps === null && r.first === null && r.nodes_start === null && (r.teardown === null && r.ac === null ? $t(r) : r.fn = null), F?.length > 0)) {
+        A.clear();
+        for (const l of F)
+          U(l);
+        F = [];
+      }
+    }
+    F = null;
+  }
+}
+function nt(t) {
+  for (var e = bt = t; e.parent !== null; ) {
+    e = e.parent;
+    var n = e.f;
+    if (_t && e === _ && (n & z) !== 0)
+      return;
+    if ((n & (Y | G)) !== 0) {
+      if ((n & b) === 0) return;
+      e.f ^= b;
+    }
+  }
+  H.push(e);
+}
+const A = /* @__PURE__ */ new Map();
+function Ut(t, e) {
+  var n = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: Dt,
+    rv: 0,
+    wv: 0
+  };
+  return n;
+}
+// @__NO_SIDE_EFFECTS__
+function S(t, e) {
+  const n = Ut(t);
+  return je(n), n;
+}
+function N(t, e, n = !1) {
+  v !== 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
+  (!I || (v.f & kt) !== 0) && Ft() && (v.f & (E | z | pt | kt)) !== 0 && !R?.includes(t) && he();
+  let r = n ? K(e) : e;
+  return ht(t, r);
+}
+function ht(t, e) {
+  if (!t.equals(e)) {
+    var n = t.v;
+    J ? A.set(t, e) : A.set(t, n), t.v = e;
+    var r = W.ensure();
+    r.capture(t, n), (t.f & E) !== 0 && ((t.f & O) !== 0 && yt(
+      /** @type {Derived} */
+      t
+    ), k(t, (t.f & T) === 0 ? b : D)), t.wv = Gt(), Vt(t, O), _ !== null && (_.f & b) !== 0 && (_.f & (G | Y)) === 0 && (x === null ? Me([t]) : x.push(t));
+  }
+  return e;
+}
+function ct(t) {
+  N(t, t.v + 1);
+}
+function Vt(t, e) {
+  var n = t.reactions;
+  if (n !== null)
+    for (var r = n.length, l = 0; l < r; l++) {
+      var f = n[l], u = f.f, a = (u & O) === 0;
+      a && k(f, e), (u & E) !== 0 ? Vt(
+        /** @type {Derived} */
+        f,
+        D
+      ) : a && ((u & z) !== 0 && F !== null && F.push(
+        /** @type {Effect} */
+        f
+      ), nt(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function K(t) {
+  if (typeof t != "object" || t === null || at in t)
+    return t;
+  const e = le(t);
+  if (e !== ne && e !== re)
+    return t;
+  var n = /* @__PURE__ */ new Map(), r = te(t), l = /* @__PURE__ */ S(0), f = q, u = (a) => {
+    if (q === f)
+      return a();
+    var s = v, i = q;
+    C(null), Nt(f);
+    var o = a();
+    return C(s), Nt(i), o;
+  };
+  return r && n.set("length", /* @__PURE__ */ S(
+    /** @type {any[]} */
+    t.length
+  )), new Proxy(
+    /** @type {any} */
+    t,
+    {
+      defineProperty(a, s, i) {
+        (!("value" in i) || i.configurable === !1 || i.enumerable === !1 || i.writable === !1) && ve();
+        var o = n.get(s);
+        return o === void 0 ? o = u(() => {
+          var c = /* @__PURE__ */ S(i.value);
+          return n.set(s, c), c;
+        }) : N(o, i.value, !0), !0;
+      },
+      deleteProperty(a, s) {
+        var i = n.get(s);
+        if (i === void 0) {
+          if (s in a) {
+            const o = u(() => /* @__PURE__ */ S(w));
+            n.set(s, o), ct(l);
+          }
+        } else
+          N(i, w), ct(l);
+        return !0;
+      },
+      get(a, s, i) {
+        if (s === at)
+          return t;
+        var o = n.get(s), c = s in a;
+        if (o === void 0 && (!c || ut(a, s)?.writable) && (o = u(() => {
+          var h = K(c ? a[s] : w), d = /* @__PURE__ */ S(h);
+          return d;
+        }), n.set(s, o)), o !== void 0) {
+          var p = j(o);
+          return p === w ? void 0 : p;
+        }
+        return Reflect.get(a, s, i);
+      },
+      getOwnPropertyDescriptor(a, s) {
+        var i = Reflect.getOwnPropertyDescriptor(a, s);
+        if (i && "value" in i) {
+          var o = n.get(s);
+          o && (i.value = j(o));
+        } else if (i === void 0) {
+          var c = n.get(s), p = c?.v;
+          if (c !== void 0 && p !== w)
+            return {
+              enumerable: !0,
+              configurable: !0,
+              value: p,
+              writable: !0
+            };
+        }
+        return i;
+      },
+      has(a, s) {
+        if (s === at)
+          return !0;
+        var i = n.get(s), o = i !== void 0 && i.v !== w || Reflect.has(a, s);
+        if (i !== void 0 || _ !== null && (!o || ut(a, s)?.writable)) {
+          i === void 0 && (i = u(() => {
+            var p = o ? K(a[s]) : w, h = /* @__PURE__ */ S(p);
+            return h;
+          }), n.set(s, i));
+          var c = j(i);
+          if (c === w)
+            return !1;
+        }
+        return o;
+      },
+      set(a, s, i, o) {
+        var c = n.get(s), p = s in a;
+        if (r && s === "length")
+          for (var h = i; h < /** @type {Source<number>} */
+          c.v; h += 1) {
+            var d = n.get(h + "");
+            d !== void 0 ? N(d, w) : h in a && (d = u(() => /* @__PURE__ */ S(w)), n.set(h + "", d));
+          }
+        if (c === void 0)
+          (!p || ut(a, s)?.writable) && (c = u(() => /* @__PURE__ */ S(void 0)), N(c, K(i)), n.set(s, c));
+        else {
+          p = c.v !== w;
+          var it = u(() => K(i));
+          N(c, it);
+        }
+        var mt = Reflect.getOwnPropertyDescriptor(a, s);
+        if (mt?.set && mt.set.call(o, i), !p) {
+          if (r && typeof s == "string") {
+            var Et = (
+              /** @type {Source<number>} */
+              n.get("length")
+            ), ft = Number(s);
+            Number.isInteger(ft) && ft >= Et.v && N(Et, ft + 1);
+          }
+          ct(l);
+        }
+        return !0;
+      },
+      ownKeys(a) {
+        j(l);
+        var s = Reflect.ownKeys(a).filter((c) => {
+          var p = n.get(c);
+          return p === void 0 || p.v !== w;
+        });
+        for (var [i, o] of n)
+          o.v !== w && !(i in a) && s.push(i);
+        return s;
+      },
+      setPrototypeOf() {
+        _e();
+      }
+    }
+  );
+}
+var Oe, Se, Re;
+// @__NO_SIDE_EFFECTS__
+function Yt(t) {
+  return Se.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Ne(t) {
+  return Re.call(t);
+}
+function Pe(t, e) {
+  return /* @__PURE__ */ Yt(t);
+}
+function Bt(t) {
+  var e = v, n = _;
+  C(null), V(null);
+  try {
+    return t();
+  } finally {
+    C(e), V(n);
+  }
+}
+function Ae(t, e) {
+  var n = e.last;
+  n === null ? e.last = e.first = t : (n.next = t, t.prev = n, e.last = t);
+}
+function Kt(t, e, n, r = !0) {
+  var l = _;
+  l !== null && (l.f & X) !== 0 && (t |= X);
+  var f = {
+    ctx: Z,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | O,
+    first: null,
+    fn: e,
+    last: null,
+    next: null,
+    parent: l,
+    b: l && l.b,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    wv: 0,
+    ac: null
+  };
+  try {
+    U(f), f.f |= Ct;
+  } catch (s) {
+    throw lt(f), s;
+  }
+  if (r) {
+    var u = f;
+    if (u.deps === null && u.teardown === null && u.nodes_start === null && u.first === u.last && // either `null`, or a singular child
+    (u.f & dt) === 0 && (u = u.first), u !== null && (u.parent = l, l !== null && Ae(u, l), v !== null && (v.f & E) !== 0 && (t & Y) === 0)) {
+      var a = (
+        /** @type {Derived} */
+        v
+      );
+      (a.effects ??= []).push(u);
+    }
+  }
+  return f;
+}
+function Ce(t) {
+  return Kt(pt | dt, t);
+}
+function De(t, e = [], n = []) {
+  Ee(e, n, (r) => {
+    Kt(fe, () => t(...r.map(j)), !0);
+  });
+}
+function Ht(t) {
+  var e = t.teardown;
+  if (e !== null) {
+    const n = J, r = v;
+    Rt(!0), C(null);
+    try {
+      e.call(null);
+    } finally {
+      Rt(n), C(r);
+    }
+  }
+}
+function Wt(t, e = !1) {
+  var n = t.first;
+  for (t.first = t.last = null; n !== null; ) {
+    const l = n.ac;
+    l !== null && Bt(() => {
+      l.abort(wt);
+    });
+    var r = n.next;
+    (n.f & Y) !== 0 ? n.parent = null : lt(n, e), n = r;
+  }
+}
+function Fe(t) {
+  for (var e = t.first; e !== null; ) {
+    var n = e.next;
+    (e.f & G) === 0 && lt(e), e = n;
+  }
+}
+function lt(t, e = !0) {
+  var n = !1;
+  (e || (t.f & ue) !== 0) && t.nodes_start !== null && t.nodes_end !== null && (Ie(
+    t.nodes_start,
+    /** @type {TemplateNode} */
+    t.nodes_end
+  ), n = !0), Wt(t, e && !n), rt(t, 0), k(t, B);
+  var r = t.transitions;
+  if (r !== null)
+    for (const f of r)
+      f.stop();
+  Ht(t);
+  var l = t.parent;
+  l !== null && l.first !== null && $t(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.fn = t.nodes_start = t.nodes_end = t.ac = null;
+}
+function Ie(t, e) {
+  for (; t !== null; ) {
+    var n = t === e ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ Ne(t)
+    );
+    t.remove(), t = n;
+  }
+}
+function $t(t) {
+  var e = t.parent, n = t.prev, r = t.next;
+  n !== null && (n.next = r), r !== null && (r.prev = n), e !== null && (e.first === t && (e.first = r), e.last === t && (e.last = n));
+}
+let L = !1;
+function St(t) {
+  L = t;
+}
+let J = !1;
+function Rt(t) {
+  J = t;
+}
+let v = null, I = !1;
+function C(t) {
+  v = t;
+}
+let _ = null;
+function V(t) {
+  _ = t;
+}
+let R = null;
+function je(t) {
+  v !== null && (R === null ? R = [t] : R.push(t));
+}
+let y = null, m = 0, x = null;
+function Me(t) {
+  x = t;
+}
+let zt = 1, $ = 0, q = $;
+function Nt(t) {
+  q = t;
+}
+let P = !1;
+function Gt() {
+  return ++zt;
+}
+function st(t) {
+  var e = t.f;
+  if ((e & O) !== 0)
+    return !0;
+  if ((e & D) !== 0) {
+    var n = t.deps, r = (e & T) !== 0;
+    if (n !== null) {
+      var l, f, u = (e & Q) !== 0, a = r && _ !== null && !P, s = n.length;
+      if ((u || a) && (_ === null || (_.f & B) === 0)) {
+        var i = (
+          /** @type {Derived} */
+          t
+        ), o = i.parent;
+        for (l = 0; l < s; l++)
+          f = n[l], (u || !f?.reactions?.includes(i)) && (f.reactions ??= []).push(i);
+        u && (i.f ^= Q), a && o !== null && (o.f & T) === 0 && (i.f ^= T);
+      }
+      for (l = 0; l < s; l++)
+        if (f = n[l], st(
+          /** @type {Derived} */
+          f
+        ) && Mt(
+          /** @type {Derived} */
+          f
+        ), f.wv > t.wv)
+          return !0;
+    }
+    (!r || _ !== null && !P) && k(t, b);
+  }
+  return !1;
+}
+function Zt(t, e, n = !0) {
+  var r = t.reactions;
+  if (r !== null && !R?.includes(t))
+    for (var l = 0; l < r.length; l++) {
+      var f = r[l];
+      (f.f & E) !== 0 ? Zt(
+        /** @type {Derived} */
+        f,
+        e,
+        !1
+      ) : e === f && (n ? k(f, O) : (f.f & b) !== 0 && k(f, D), nt(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function Jt(t) {
+  var e = y, n = m, r = x, l = v, f = P, u = R, a = Z, s = I, i = q, o = t.f;
+  y = /** @type {null | Value[]} */
+  null, m = 0, x = null, P = (o & T) !== 0 && (I || !L || v === null), v = (o & (G | Y)) === 0 ? t : null, R = null, tt(t.ctx), I = !1, q = ++$, t.ac !== null && (Bt(() => {
+    t.ac.abort(wt);
+  }), t.ac = null);
+  try {
+    t.f |= vt;
+    var c = (
+      /** @type {Function} */
+      t.fn
+    ), p = c(), h = t.deps;
+    if (y !== null) {
+      var d;
+      if (rt(t, m), h !== null && m > 0)
+        for (h.length = m + y.length, d = 0; d < y.length; d++)
+          h[m + d] = y[d];
+      else
+        t.deps = h = y;
+      if (!P || // Deriveds that already have reactions can cleanup, so we still add them as reactions
+      (o & E) !== 0 && /** @type {import('#client').Derived} */
+      t.reactions !== null)
+        for (d = m; d < h.length; d++)
+          (h[d].reactions ??= []).push(t);
+    } else h !== null && m < h.length && (rt(t, m), h.length = m);
+    if (Ft() && x !== null && !I && h !== null && (t.f & (E | D | O)) === 0)
+      for (d = 0; d < /** @type {Source[]} */
+      x.length; d++)
+        Zt(
+          x[d],
+          /** @type {Effect} */
+          t
+        );
+    return l !== null && l !== t && ($++, x !== null && (r === null ? r = x : r.push(.../** @type {Source[]} */
+    x))), (t.f & M) !== 0 && (t.f ^= M), p;
+  } catch (it) {
+    return we(it);
+  } finally {
+    t.f ^= vt, y = e, m = n, x = r, v = l, P = f, R = u, tt(a), I = s, q = i;
+  }
+}
+function qe(t, e) {
+  let n = e.reactions;
+  if (n !== null) {
+    var r = ee.call(n, t);
+    if (r !== -1) {
+      var l = n.length - 1;
+      l === 0 ? n = e.reactions = null : (n[r] = n[l], n.pop());
+    }
+  }
+  n === null && (e.f & E) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (y === null || !y.includes(e)) && (k(e, D), (e.f & (T | Q)) === 0 && (e.f ^= Q), jt(
+    /** @type {Derived} **/
+    e
+  ), rt(
+    /** @type {Derived} **/
+    e,
+    0
+  ));
+}
+function rt(t, e) {
+  var n = t.deps;
+  if (n !== null)
+    for (var r = e; r < n.length; r++)
+      qe(t, n[r]);
+}
+function U(t) {
+  var e = t.f;
+  if ((e & B) === 0) {
+    k(t, b);
+    var n = _, r = L;
+    _ = t, L = !0;
+    try {
+      (e & z) !== 0 ? Fe(t) : Wt(t), Ht(t);
+      var l = Jt(t);
+      t.teardown = typeof l == "function" ? l : null, t.wv = zt;
+      var f;
+      Pt && de && (t.f & O) !== 0 && t.deps;
+    } finally {
+      L = r, _ = n;
+    }
+  }
+}
+function j(t) {
+  var e = t.f, n = (e & E) !== 0;
+  if (v !== null && !I) {
+    var r = _ !== null && (_.f & B) !== 0;
+    if (!r && !R?.includes(t)) {
+      var l = v.deps;
+      if ((v.f & vt) !== 0)
+        t.rv < $ && (t.rv = $, y === null && l !== null && l[m] === t ? m++ : y === null ? y = [t] : (!P || !y.includes(t)) && y.push(t));
+      else {
+        (v.deps ??= []).push(t);
+        var f = t.reactions;
+        f === null ? t.reactions = [v] : f.includes(v) || f.push(v);
+      }
+    }
+  } else if (n && /** @type {Derived} */
+  t.deps === null && /** @type {Derived} */
+  t.effects === null) {
+    var u = (
+      /** @type {Derived} */
+      t
+    ), a = u.parent;
+    a !== null && (a.f & T) === 0 && (u.f ^= T);
+  }
+  if (J) {
+    if (A.has(t))
+      return A.get(t);
+    if (n) {
+      u = /** @type {Derived} */
+      t;
+      var s = u.v;
+      return ((u.f & b) === 0 && u.reactions !== null || Qt(u)) && (s = yt(u)), A.set(u, s), s;
+    }
+  } else n && (u = /** @type {Derived} */
+  t, st(u) && Mt(u));
+  if ((t.f & M) !== 0)
+    throw t.v;
+  return t.v;
+}
+function Qt(t) {
+  if (t.v === w) return !0;
+  if (t.deps === null) return !1;
+  for (const e of t.deps)
+    if (A.has(e) || (e.f & E) !== 0 && Qt(
+      /** @type {Derived} */
+      e
+    ))
+      return !0;
+  return !1;
+}
+const Le = -7169;
+function k(t, e) {
+  t.f = t.f & Le | e;
+}
+const Ue = /* @__PURE__ */ new Set(), Ve = /* @__PURE__ */ new Set();
+function Ye(t) {
+  for (var e = 0; e < t.length; e++)
+    Ue.add(t[e]);
+  for (var n of Ve)
+    n(t);
+}
+function Be(t) {
+  var e = document.createElement("template");
+  return e.innerHTML = t.replaceAll("<!>", "<!---->"), e.content;
+}
+function Ke(t, e) {
+  var n = (
+    /** @type {Effect} */
+    _
+  );
+  n.nodes_start === null && (n.nodes_start = t, n.nodes_end = e);
+}
+// @__NO_SIDE_EFFECTS__
+function He(t, e) {
+  var n = (e & Xt) !== 0, r, l = !t.startsWith("<!>");
+  return () => {
+    r === void 0 && (r = Be(l ? t : "<!>" + t), r = /** @type {Node} */
+    /* @__PURE__ */ Yt(r));
+    var f = (
+      /** @type {TemplateNode} */
+      n || Oe ? document.importNode(r, !0) : r.cloneNode(!0)
+    );
+    return Ke(f, f), f;
+  };
+}
+function We(t, e) {
+  t !== null && t.before(
+    /** @type {Node} */
+    e
+  );
+}
+function $e(t, e) {
+  var n = e == null ? "" : typeof e == "object" ? e + "" : e;
+  n !== (t.__t ??= t.nodeValue) && (t.__t = n, t.nodeValue = n + "");
+}
+const ze = (t, e) => {
+  N(e, j(e) + 1);
+};
+var Ge = /* @__PURE__ */ He("<button> </button>");
+function Ze(t) {
+  let e = /* @__PURE__ */ S(0);
+  var n = Ge();
+  n.__click = [ze, e];
+  var r = Pe(n);
+  De(() => $e(r, `count is ${j(e) ?? ""}`)), We(t, n);
+}
+Ye(["click"]);
+const Je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Ze
+}, Symbol.toStringTag, { value: "Module" })), Xe = Object.fromEntries(
+  Object.entries(/* @__PURE__ */ Object.assign({ "./lib/Counter.svelte": Je })).map(
+    ([t, e]) => [t.replace("./lib/", ""), e.default]
+  )
+);
+export {
+  Ze as Counter,
+  Xe as components
+};