atomirx 0.0.2 → 0.0.5

package/dist/index-CBVj1kSj.js

@@ -0,0 +1,1350 @@
+var yt = Object.defineProperty;
+var _t = (e, t, r) => t in e ? yt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var A = (e, t, r) => _t(e, typeof t != "symbol" ? t + "" : t, r);
+function pt(e) {
+  const t = Object.assign(
+    (r) => () => {
+      const a = t.current;
+      return t.current = r(a), () => {
+        t.current = a;
+      };
+    },
+    {
+      current: e,
+      // Override method for direct mutation using reducer
+      override: (r) => {
+        t.current = r(t.current);
+      },
+      reset: () => {
+        t.current = e;
+      }
+    }
+  );
+  return t;
+}
+function bt(e, t) {
+  const r = [];
+  for (const a of e)
+    r.push(a());
+  try {
+    return t();
+  } finally {
+    for (const a of r.reverse())
+      a();
+  }
+}
+const U = Object.assign(pt, { use: bt }), j = U(), $t = () => {
+};
+class mt {
+  constructor(t) {
+    /** Set of registered listeners */
+    A(this, "_listeners");
+    /** Settled payload (if settled) */
+    A(this, "_settledPayload");
+    /** Whether the emitter has been settled */
+    A(this, "_isSettled", !1);
+    A(this, "size", () => this._listeners.size);
+    A(this, "settled", () => this._isSettled);
+    A(this, "forEach", (t) => {
+      this._listeners.forEach(t);
+    });
+    A(this, "on", (t, r) => {
+      let a;
+      if (r === void 0)
+        a = Array.isArray(t) ? t : [t];
+      else {
+        const n = t, u = Array.isArray(r) ? r : [r];
+        a = [
+          (i) => {
+            const l = n(i);
+            if (l)
+              for (let f = 0; f < u.length; f++)
+                u[f](l.value);
+          }
+        ];
+      }
+      if (this._isSettled) {
+        const n = this._settledPayload;
+        for (let u = 0; u < a.length; u++)
+          a[u](n);
+        return $t;
+      }
+      const s = this._listeners;
+      for (let n = 0; n < a.length; n++)
+        s.add(a[n]);
+      return () => {
+        for (let n = 0; n < a.length; n++)
+          s.delete(a[n]);
+      };
+    });
+    A(this, "emit", (t) => {
+      this._isSettled || this._doEmit(t, !1, !1);
+    });
+    A(this, "emitLifo", (t) => {
+      this._isSettled || this._doEmit(t, !1, !0);
+    });
+    A(this, "clear", () => {
+      this._listeners.clear();
+    });
+    A(this, "emitAndClear", (t) => {
+      this._isSettled || this._doEmit(t, !0, !1);
+    });
+    A(this, "emitAndClearLifo", (t) => {
+      this._isSettled || this._doEmit(t, !0, !0);
+    });
+    A(this, "settle", (t) => {
+      this._isSettled || (this._settledPayload = t, this._isSettled = !0, this._doEmit(t, !0, !1));
+    });
+    /**
+     * Internal emit implementation.
+     * Creates snapshot to handle modifications during iteration.
+     */
+    A(this, "_doEmit", (t, r, a) => {
+      const s = this._listeners, n = s.size;
+      if (n === 0) return;
+      const u = Array.from(s);
+      if (r && s.clear(), a)
+        for (let i = n - 1; i >= 0; i--)
+          u[i](t);
+      else
+        for (let i = 0; i < n; i++)
+          u[i](t);
+    });
+    this._listeners = new Set(t);
+  }
+}
+function W(e) {
+  return new mt(e);
+}
+var k = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function At(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function wt() {
+  this.__data__ = [], this.size = 0;
+}
+var Tt = wt;
+function St(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var et = St, jt = et;
+function Ct(e, t) {
+  for (var r = e.length; r--; )
+    if (jt(e[r][0], t))
+      return r;
+  return -1;
+}
+var re = Ct, Et = re, Ot = Array.prototype, Pt = Ot.splice;
+function It(e) {
+  var t = this.__data__, r = Et(t, e);
+  if (r < 0)
+    return !1;
+  var a = t.length - 1;
+  return r == a ? t.pop() : Pt.call(t, r, 1), --this.size, !0;
+}
+var Dt = It, xt = re;
+function Lt(e) {
+  var t = this.__data__, r = xt(t, e);
+  return r < 0 ? void 0 : t[r][1];
+}
+var Mt = Lt, Gt = re;
+function Ft(e) {
+  return Gt(this.__data__, e) > -1;
+}
+var Rt = Ft, qt = re;
+function Nt(e, t) {
+  var r = this.__data__, a = qt(r, e);
+  return a < 0 ? (++this.size, r.push([e, t])) : r[a][1] = t, this;
+}
+var zt = Nt, Bt = Tt, Ut = Dt, kt = Mt, Ht = Rt, Kt = zt;
+function G(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var a = e[t];
+    this.set(a[0], a[1]);
+  }
+}
+G.prototype.clear = Bt;
+G.prototype.delete = Ut;
+G.prototype.get = kt;
+G.prototype.has = Ht;
+G.prototype.set = Kt;
+var ae = G, Vt = ae;
+function Wt() {
+  this.__data__ = new Vt(), this.size = 0;
+}
+var Jt = Wt;
+function Yt(e) {
+  var t = this.__data__, r = t.delete(e);
+  return this.size = t.size, r;
+}
+var Xt = Yt;
+function Zt(e) {
+  return this.__data__.get(e);
+}
+var Qt = Zt;
+function er(e) {
+  return this.__data__.has(e);
+}
+var tr = er, rr = typeof k == "object" && k && k.Object === Object && k, tt = rr, ar = tt, nr = typeof self == "object" && self && self.Object === Object && self, sr = ar || nr || Function("return this")(), I = sr, ir = I, or = ir.Symbol, be = or, Se = be, rt = Object.prototype, ur = rt.hasOwnProperty, cr = rt.toString, B = Se ? Se.toStringTag : void 0;
+function lr(e) {
+  var t = ur.call(e, B), r = e[B];
+  try {
+    e[B] = void 0;
+    var a = !0;
+  } catch {
+  }
+  var s = cr.call(e);
+  return a && (t ? e[B] = r : delete e[B]), s;
+}
+var fr = lr, dr = Object.prototype, vr = dr.toString;
+function hr(e) {
+  return vr.call(e);
+}
+var gr = hr, je = be, yr = fr, _r = gr, pr = "[object Null]", br = "[object Undefined]", Ce = je ? je.toStringTag : void 0;
+function $r(e) {
+  return e == null ? e === void 0 ? br : pr : Ce && Ce in Object(e) ? yr(e) : _r(e);
+}
+var ne = $r;
+function mr(e) {
+  var t = typeof e;
+  return e != null && (t == "object" || t == "function");
+}
+var at = mr, Ar = ne, wr = at, Tr = "[object AsyncFunction]", Sr = "[object Function]", jr = "[object GeneratorFunction]", Cr = "[object Proxy]";
+function Er(e) {
+  if (!wr(e))
+    return !1;
+  var t = Ar(e);
+  return t == Sr || t == jr || t == Tr || t == Cr;
+}
+var nt = Er, Or = I, Pr = Or["__core-js_shared__"], Ir = Pr, ue = Ir, Ee = function() {
+  var e = /[^.]+$/.exec(ue && ue.keys && ue.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+}();
+function Dr(e) {
+  return !!Ee && Ee in e;
+}
+var xr = Dr, Lr = Function.prototype, Mr = Lr.toString;
+function Gr(e) {
+  if (e != null) {
+    try {
+      return Mr.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var st = Gr, Fr = nt, Rr = xr, qr = at, Nr = st, zr = /[\\^$.*+?()[\]{}|]/g, Br = /^\[object .+?Constructor\]$/, Ur = Function.prototype, kr = Object.prototype, Hr = Ur.toString, Kr = kr.hasOwnProperty, Vr = RegExp(
+  "^" + Hr.call(Kr).replace(zr, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Wr(e) {
+  if (!qr(e) || Rr(e))
+    return !1;
+  var t = Fr(e) ? Vr : Br;
+  return t.test(Nr(e));
+}
+var Jr = Wr;
+function Yr(e, t) {
+  return e == null ? void 0 : e[t];
+}
+var Xr = Yr, Zr = Jr, Qr = Xr;
+function ea(e, t) {
+  var r = Qr(e, t);
+  return Zr(r) ? r : void 0;
+}
+var F = ea, ta = F, ra = I, aa = ta(ra, "Map"), $e = aa, na = F, sa = na(Object, "create"), se = sa, Oe = se;
+function ia() {
+  this.__data__ = Oe ? Oe(null) : {}, this.size = 0;
+}
+var oa = ia;
+function ua(e) {
+  var t = this.has(e) && delete this.__data__[e];
+  return this.size -= t ? 1 : 0, t;
+}
+var ca = ua, la = se, fa = "__lodash_hash_undefined__", da = Object.prototype, va = da.hasOwnProperty;
+function ha(e) {
+  var t = this.__data__;
+  if (la) {
+    var r = t[e];
+    return r === fa ? void 0 : r;
+  }
+  return va.call(t, e) ? t[e] : void 0;
+}
+var ga = ha, ya = se, _a = Object.prototype, pa = _a.hasOwnProperty;
+function ba(e) {
+  var t = this.__data__;
+  return ya ? t[e] !== void 0 : pa.call(t, e);
+}
+var $a = ba, ma = se, Aa = "__lodash_hash_undefined__";
+function wa(e, t) {
+  var r = this.__data__;
+  return this.size += this.has(e) ? 0 : 1, r[e] = ma && t === void 0 ? Aa : t, this;
+}
+var Ta = wa, Sa = oa, ja = ca, Ca = ga, Ea = $a, Oa = Ta;
+function R(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var a = e[t];
+    this.set(a[0], a[1]);
+  }
+}
+R.prototype.clear = Sa;
+R.prototype.delete = ja;
+R.prototype.get = Ca;
+R.prototype.has = Ea;
+R.prototype.set = Oa;
+var Pa = R, Pe = Pa, Ia = ae, Da = $e;
+function xa() {
+  this.size = 0, this.__data__ = {
+    hash: new Pe(),
+    map: new (Da || Ia)(),
+    string: new Pe()
+  };
+}
+var La = xa;
+function Ma(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+var Ga = Ma, Fa = Ga;
+function Ra(e, t) {
+  var r = e.__data__;
+  return Fa(t) ? r[typeof t == "string" ? "string" : "hash"] : r.map;
+}
+var ie = Ra, qa = ie;
+function Na(e) {
+  var t = qa(this, e).delete(e);
+  return this.size -= t ? 1 : 0, t;
+}
+var za = Na, Ba = ie;
+function Ua(e) {
+  return Ba(this, e).get(e);
+}
+var ka = Ua, Ha = ie;
+function Ka(e) {
+  return Ha(this, e).has(e);
+}
+var Va = Ka, Wa = ie;
+function Ja(e, t) {
+  var r = Wa(this, e), a = r.size;
+  return r.set(e, t), this.size += r.size == a ? 0 : 1, this;
+}
+var Ya = Ja, Xa = La, Za = za, Qa = ka, en = Va, tn = Ya;
+function q(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var a = e[t];
+    this.set(a[0], a[1]);
+  }
+}
+q.prototype.clear = Xa;
+q.prototype.delete = Za;
+q.prototype.get = Qa;
+q.prototype.has = en;
+q.prototype.set = tn;
+var it = q, rn = ae, an = $e, nn = it, sn = 200;
+function on(e, t) {
+  var r = this.__data__;
+  if (r instanceof rn) {
+    var a = r.__data__;
+    if (!an || a.length < sn - 1)
+      return a.push([e, t]), this.size = ++r.size, this;
+    r = this.__data__ = new nn(a);
+  }
+  return r.set(e, t), this.size = r.size, this;
+}
+var un = on, cn = ae, ln = Jt, fn = Xt, dn = Qt, vn = tr, hn = un;
+function N(e) {
+  var t = this.__data__ = new cn(e);
+  this.size = t.size;
+}
+N.prototype.clear = ln;
+N.prototype.delete = fn;
+N.prototype.get = dn;
+N.prototype.has = vn;
+N.prototype.set = hn;
+var gn = N, yn = "__lodash_hash_undefined__";
+function _n(e) {
+  return this.__data__.set(e, yn), this;
+}
+var pn = _n;
+function bn(e) {
+  return this.__data__.has(e);
+}
+var $n = bn, mn = it, An = pn, wn = $n;
+function J(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.__data__ = new mn(); ++t < r; )
+    this.add(e[t]);
+}
+J.prototype.add = J.prototype.push = An;
+J.prototype.has = wn;
+var Tn = J;
+function Sn(e, t) {
+  for (var r = -1, a = e == null ? 0 : e.length; ++r < a; )
+    if (t(e[r], r, e))
+      return !0;
+  return !1;
+}
+var jn = Sn;
+function Cn(e, t) {
+  return e.has(t);
+}
+var En = Cn, On = Tn, Pn = jn, In = En, Dn = 1, xn = 2;
+function Ln(e, t, r, a, s, n) {
+  var u = r & Dn, i = e.length, l = t.length;
+  if (i != l && !(u && l > i))
+    return !1;
+  var f = n.get(e), v = n.get(t);
+  if (f && v)
+    return f == t && v == e;
+  var p = -1, o = !0, c = r & xn ? new On() : void 0;
+  for (n.set(e, t), n.set(t, e); ++p < i; ) {
+    var d = e[p], g = t[p];
+    if (a)
+      var h = u ? a(g, d, p, t, e, n) : a(d, g, p, e, t, n);
+    if (h !== void 0) {
+      if (h)
+        continue;
+      o = !1;
+      break;
+    }
+    if (c) {
+      if (!Pn(t, function(_, $) {
+        if (!In(c, $) && (d === _ || s(d, _, r, a, n)))
+          return c.push($);
+      })) {
+        o = !1;
+        break;
+      }
+    } else if (!(d === g || s(d, g, r, a, n))) {
+      o = !1;
+      break;
+    }
+  }
+  return n.delete(e), n.delete(t), o;
+}
+var ot = Ln, Mn = I, Gn = Mn.Uint8Array, Fn = Gn;
+function Rn(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(a, s) {
+    r[++t] = [s, a];
+  }), r;
+}
+var qn = Rn;
+function Nn(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(a) {
+    r[++t] = a;
+  }), r;
+}
+var zn = Nn, Ie = be, De = Fn, Bn = et, Un = ot, kn = qn, Hn = zn, Kn = 1, Vn = 2, Wn = "[object Boolean]", Jn = "[object Date]", Yn = "[object Error]", Xn = "[object Map]", Zn = "[object Number]", Qn = "[object RegExp]", es = "[object Set]", ts = "[object String]", rs = "[object Symbol]", as = "[object ArrayBuffer]", ns = "[object DataView]", xe = Ie ? Ie.prototype : void 0, ce = xe ? xe.valueOf : void 0;
+function ss(e, t, r, a, s, n, u) {
+  switch (r) {
+    case ns:
+      if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset)
+        return !1;
+      e = e.buffer, t = t.buffer;
+    case as:
+      return !(e.byteLength != t.byteLength || !n(new De(e), new De(t)));
+    case Wn:
+    case Jn:
+    case Zn:
+      return Bn(+e, +t);
+    case Yn:
+      return e.name == t.name && e.message == t.message;
+    case Qn:
+    case ts:
+      return e == t + "";
+    case Xn:
+      var i = kn;
+    case es:
+      var l = a & Kn;
+      if (i || (i = Hn), e.size != t.size && !l)
+        return !1;
+      var f = u.get(e);
+      if (f)
+        return f == t;
+      a |= Vn, u.set(e, t);
+      var v = Un(i(e), i(t), a, s, n, u);
+      return u.delete(e), v;
+    case rs:
+      if (ce)
+        return ce.call(e) == ce.call(t);
+  }
+  return !1;
+}
+var is = ss;
+function os(e, t) {
+  for (var r = -1, a = t.length, s = e.length; ++r < a; )
+    e[s + r] = t[r];
+  return e;
+}
+var us = os, cs = Array.isArray, me = cs, ls = us, fs = me;
+function ds(e, t, r) {
+  var a = t(e);
+  return fs(e) ? a : ls(a, r(e));
+}
+var vs = ds;
+function hs(e, t) {
+  for (var r = -1, a = e == null ? 0 : e.length, s = 0, n = []; ++r < a; ) {
+    var u = e[r];
+    t(u, r, e) && (n[s++] = u);
+  }
+  return n;
+}
+var gs = hs;
+function ys() {
+  return [];
+}
+var _s = ys, ps = gs, bs = _s, $s = Object.prototype, ms = $s.propertyIsEnumerable, Le = Object.getOwnPropertySymbols, As = Le ? function(e) {
+  return e == null ? [] : (e = Object(e), ps(Le(e), function(t) {
+    return ms.call(e, t);
+  }));
+} : bs, ws = As;
+function Ts(e, t) {
+  for (var r = -1, a = Array(e); ++r < e; )
+    a[r] = t(r);
+  return a;
+}
+var Ss = Ts;
+function js(e) {
+  return e != null && typeof e == "object";
+}
+var oe = js, Cs = ne, Es = oe, Os = "[object Arguments]";
+function Ps(e) {
+  return Es(e) && Cs(e) == Os;
+}
+var Is = Ps, Me = Is, Ds = oe, ut = Object.prototype, xs = ut.hasOwnProperty, Ls = ut.propertyIsEnumerable, Ms = Me(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? Me : function(e) {
+  return Ds(e) && xs.call(e, "callee") && !Ls.call(e, "callee");
+}, Gs = Ms, Y = { exports: {} };
+function Fs() {
+  return !1;
+}
+var Rs = Fs;
+Y.exports;
+(function(e, t) {
+  var r = I, a = Rs, s = t && !t.nodeType && t, n = s && !0 && e && !e.nodeType && e, u = n && n.exports === s, i = u ? r.Buffer : void 0, l = i ? i.isBuffer : void 0, f = l || a;
+  e.exports = f;
+})(Y, Y.exports);
+var ct = Y.exports, qs = 9007199254740991, Ns = /^(?:0|[1-9]\d*)$/;
+function zs(e, t) {
+  var r = typeof e;
+  return t = t ?? qs, !!t && (r == "number" || r != "symbol" && Ns.test(e)) && e > -1 && e % 1 == 0 && e < t;
+}
+var Bs = zs, Us = 9007199254740991;
+function ks(e) {
+  return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Us;
+}
+var lt = ks, Hs = ne, Ks = lt, Vs = oe, Ws = "[object Arguments]", Js = "[object Array]", Ys = "[object Boolean]", Xs = "[object Date]", Zs = "[object Error]", Qs = "[object Function]", ei = "[object Map]", ti = "[object Number]", ri = "[object Object]", ai = "[object RegExp]", ni = "[object Set]", si = "[object String]", ii = "[object WeakMap]", oi = "[object ArrayBuffer]", ui = "[object DataView]", ci = "[object Float32Array]", li = "[object Float64Array]", fi = "[object Int8Array]", di = "[object Int16Array]", vi = "[object Int32Array]", hi = "[object Uint8Array]", gi = "[object Uint8ClampedArray]", yi = "[object Uint16Array]", _i = "[object Uint32Array]", y = {};
+y[ci] = y[li] = y[fi] = y[di] = y[vi] = y[hi] = y[gi] = y[yi] = y[_i] = !0;
+y[Ws] = y[Js] = y[oi] = y[Ys] = y[ui] = y[Xs] = y[Zs] = y[Qs] = y[ei] = y[ti] = y[ri] = y[ai] = y[ni] = y[si] = y[ii] = !1;
+function pi(e) {
+  return Vs(e) && Ks(e.length) && !!y[Hs(e)];
+}
+var bi = pi;
+function $i(e) {
+  return function(t) {
+    return e(t);
+  };
+}
+var mi = $i, X = { exports: {} };
+X.exports;
+(function(e, t) {
+  var r = tt, a = t && !t.nodeType && t, s = a && !0 && e && !e.nodeType && e, n = s && s.exports === a, u = n && r.process, i = function() {
+    try {
+      var l = s && s.require && s.require("util").types;
+      return l || u && u.binding && u.binding("util");
+    } catch {
+    }
+  }();
+  e.exports = i;
+})(X, X.exports);
+var Ai = X.exports, wi = bi, Ti = mi, Ge = Ai, Fe = Ge && Ge.isTypedArray, Si = Fe ? Ti(Fe) : wi, ft = Si, ji = Ss, Ci = Gs, Ei = me, Oi = ct, Pi = Bs, Ii = ft, Di = Object.prototype, xi = Di.hasOwnProperty;
+function Li(e, t) {
+  var r = Ei(e), a = !r && Ci(e), s = !r && !a && Oi(e), n = !r && !a && !s && Ii(e), u = r || a || s || n, i = u ? ji(e.length, String) : [], l = i.length;
+  for (var f in e)
+    (t || xi.call(e, f)) && !(u && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (f == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    s && (f == "offset" || f == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    n && (f == "buffer" || f == "byteLength" || f == "byteOffset") || // Skip index properties.
+    Pi(f, l))) && i.push(f);
+  return i;
+}
+var Mi = Li, Gi = Object.prototype;
+function Fi(e) {
+  var t = e && e.constructor, r = typeof t == "function" && t.prototype || Gi;
+  return e === r;
+}
+var Ri = Fi;
+function qi(e, t) {
+  return function(r) {
+    return e(t(r));
+  };
+}
+var Ni = qi, zi = Ni, Bi = zi(Object.keys, Object), Ui = Bi, ki = Ri, Hi = Ui, Ki = Object.prototype, Vi = Ki.hasOwnProperty;
+function Wi(e) {
+  if (!ki(e))
+    return Hi(e);
+  var t = [];
+  for (var r in Object(e))
+    Vi.call(e, r) && r != "constructor" && t.push(r);
+  return t;
+}
+var Ji = Wi, Yi = nt, Xi = lt;
+function Zi(e) {
+  return e != null && Xi(e.length) && !Yi(e);
+}
+var Qi = Zi, eo = Mi, to = Ji, ro = Qi;
+function ao(e) {
+  return ro(e) ? eo(e) : to(e);
+}
+var no = ao, so = vs, io = ws, oo = no;
+function uo(e) {
+  return so(e, oo, io);
+}
+var co = uo, Re = co, lo = 1, fo = Object.prototype, vo = fo.hasOwnProperty;
+function ho(e, t, r, a, s, n) {
+  var u = r & lo, i = Re(e), l = i.length, f = Re(t), v = f.length;
+  if (l != v && !u)
+    return !1;
+  for (var p = l; p--; ) {
+    var o = i[p];
+    if (!(u ? o in t : vo.call(t, o)))
+      return !1;
+  }
+  var c = n.get(e), d = n.get(t);
+  if (c && d)
+    return c == t && d == e;
+  var g = !0;
+  n.set(e, t), n.set(t, e);
+  for (var h = u; ++p < l; ) {
+    o = i[p];
+    var _ = e[o], $ = t[o];
+    if (a)
+      var b = u ? a($, _, o, t, e, n) : a(_, $, o, e, t, n);
+    if (!(b === void 0 ? _ === $ || s(_, $, r, a, n) : b)) {
+      g = !1;
+      break;
+    }
+    h || (h = o == "constructor");
+  }
+  if (g && !h) {
+    var m = e.constructor, D = t.constructor;
+    m != D && "constructor" in e && "constructor" in t && !(typeof m == "function" && m instanceof m && typeof D == "function" && D instanceof D) && (g = !1);
+  }
+  return n.delete(e), n.delete(t), g;
+}
+var go = ho, yo = F, _o = I, po = yo(_o, "DataView"), bo = po, $o = F, mo = I, Ao = $o(mo, "Promise"), wo = Ao, To = F, So = I, jo = To(So, "Set"), Co = jo, Eo = F, Oo = I, Po = Eo(Oo, "WeakMap"), Io = Po, de = bo, ve = $e, he = wo, ge = Co, ye = Io, dt = ne, z = st, qe = "[object Map]", Do = "[object Object]", Ne = "[object Promise]", ze = "[object Set]", Be = "[object WeakMap]", Ue = "[object DataView]", xo = z(de), Lo = z(ve), Mo = z(he), Go = z(ge), Fo = z(ye), x = dt;
+(de && x(new de(new ArrayBuffer(1))) != Ue || ve && x(new ve()) != qe || he && x(he.resolve()) != Ne || ge && x(new ge()) != ze || ye && x(new ye()) != Be) && (x = function(e) {
+  var t = dt(e), r = t == Do ? e.constructor : void 0, a = r ? z(r) : "";
+  if (a)
+    switch (a) {
+      case xo:
+        return Ue;
+      case Lo:
+        return qe;
+      case Mo:
+        return Ne;
+      case Go:
+        return ze;
+      case Fo:
+        return Be;
+    }
+  return t;
+});
+var Ro = x, le = gn, qo = ot, No = is, zo = go, ke = Ro, He = me, Ke = ct, Bo = ft, Uo = 1, Ve = "[object Arguments]", We = "[object Array]", H = "[object Object]", ko = Object.prototype, Je = ko.hasOwnProperty;
+function Ho(e, t, r, a, s, n) {
+  var u = He(e), i = He(t), l = u ? We : ke(e), f = i ? We : ke(t);
+  l = l == Ve ? H : l, f = f == Ve ? H : f;
+  var v = l == H, p = f == H, o = l == f;
+  if (o && Ke(e)) {
+    if (!Ke(t))
+      return !1;
+    u = !0, v = !1;
+  }
+  if (o && !v)
+    return n || (n = new le()), u || Bo(e) ? qo(e, t, r, a, s, n) : No(e, t, l, r, a, s, n);
+  if (!(r & Uo)) {
+    var c = v && Je.call(e, "__wrapped__"), d = p && Je.call(t, "__wrapped__");
+    if (c || d) {
+      var g = c ? e.value() : e, h = d ? t.value() : t;
+      return n || (n = new le()), s(g, h, r, a, n);
+    }
+  }
+  return o ? (n || (n = new le()), zo(e, t, r, a, s, n)) : !1;
+}
+var Ko = Ho, Vo = Ko, Ye = oe;
+function vt(e, t, r, a, s) {
+  return e === t ? !0 : e == null || t == null || !Ye(e) && !Ye(t) ? e !== e && t !== t : Vo(e, t, r, a, vt, s);
+}
+var Wo = vt, Jo = Wo;
+function Yo(e, t) {
+  return Jo(e, t);
+}
+var Xo = Yo;
+const Zo = /* @__PURE__ */ At(Xo);
+function Qo(e, t) {
+  return Object.is(e, t);
+}
+function Z(e, t, r = Object.is) {
+  if (Object.is(e, t)) return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null) return !1;
+  const a = Object.keys(e), s = Object.keys(t);
+  if (a.length !== s.length) return !1;
+  for (const n of a)
+    if (!Object.prototype.hasOwnProperty.call(t, n) || !r(e[n], t[n])) return !1;
+  return !0;
+}
+function Ae(e, t) {
+  return Z(e, t, Z);
+}
+function eu(e, t) {
+  return Z(e, t, Ae);
+}
+const tu = Zo;
+function ht(e) {
+  return !e || e === "strict" ? Qo : e === "shallow" ? Z : e === "shallow2" ? Ae : e === "shallow3" ? eu : e === "deep" ? tu : e;
+}
+function Xe(e) {
+  const t = e;
+  let r = e;
+  return Object.assign(
+    (...a) => r(...a),
+    {
+      getOriginal: () => t,
+      getCurrent: () => r,
+      setCurrent(a) {
+        r = a;
+      }
+    }
+  );
+}
+function ru(e) {
+  return typeof e == "function" && "getOriginal" in e && "getCurrent" in e && "setCurrent" in e;
+}
+function fu(e, t, r) {
+  return e ? typeof t == "function" ? ru(e.value) ? (e.value.setCurrent(t), [e.value, !0]) : [Xe(t), !1] : t && t instanceof Date ? e.value && e.value instanceof Date && t.getTime() === e.value.getTime() ? [e.value, !0] : [t, !1] : r(e.value, t) ? [e.value, !0] : [t, !1] : typeof t == "function" ? [Xe(t), !1] : [t, !1];
+}
+const Q = U((e) => e()), ee = Symbol.for("atomirx.atom"), _e = Symbol.for("atomirx.derived");
+function te(e) {
+  return Object.assign(e, {
+    use(t) {
+      const r = t(e);
+      return r ? typeof r == "object" || typeof r == "function" ? "use" in r ? r : te(r) : r : e;
+    }
+  });
+}
+function w(e) {
+  return e !== null && typeof e == "object" && "then" in e && typeof e.then == "function";
+}
+const pe = /* @__PURE__ */ new WeakMap();
+function Ze(e) {
+  return pe.get(e);
+}
+function K(e, t) {
+  if (t.length === 1) {
+    if (e === "allSettled") {
+      const a = Promise.allSettled(t).then(() => {
+      });
+      return pe.set(a, { type: e, promises: t }), a;
+    }
+    return t[0];
+  }
+  const r = Promise[e](t);
+  return r.catch(() => {
+  }), pe.set(r, { type: e, promises: t }), r;
+}
+function du(e, t) {
+  if (e === t) return !0;
+  if (!e || !t) return !1;
+  const r = Ze(e), a = Ze(t);
+  return !!r && !!a && Ae(r, a);
+}
+const L = /* @__PURE__ */ new WeakMap();
+function P(e) {
+  const t = L.get(e);
+  if (t)
+    return t;
+  const r = { status: "pending", promise: e };
+  return L.set(e, r), e.then(
+    (a) => {
+      const s = L.get(e);
+      (s == null ? void 0 : s.status) === "pending" && L.set(e, { status: "fulfilled", value: a });
+    },
+    (a) => {
+      const s = L.get(e);
+      (s == null ? void 0 : s.status) === "pending" && L.set(e, { status: "rejected", error: a });
+    }
+  ), r;
+}
+function vu(e) {
+  if (!w(e))
+    return e;
+  const r = P(e);
+  switch (r.status) {
+    case "pending":
+      throw r.promise;
+    case "rejected":
+      throw r.error;
+    case "fulfilled":
+      return r.value;
+  }
+}
+function hu(e) {
+  return w(e) ? P(e).status === "pending" : !1;
+}
+function gu(e) {
+  return w(e) ? P(e).status === "fulfilled" : !1;
+}
+function yu(e) {
+  return w(e) ? P(e).status === "rejected" : !1;
+}
+function _u(e, t = {}) {
+  var _, $;
+  const r = W(), a = ht(t.equals);
+  let s = null;
+  const n = W(), u = (b) => {
+    s && (s.abort(b), s = null), n.emitAndClear();
+  }, i = () => (s = new AbortController(), te({
+    signal: s.signal,
+    onCleanup: n.on
+  })), l = typeof e == "function";
+  let v = l ? e(i()) : e, p = !1;
+  w(v) && P(v);
+  const o = () => {
+    r.forEach((b) => {
+      Q.current(b);
+    });
+  }, c = (b) => {
+    let m;
+    typeof b == "function" ? m = b(v) : m = b, !a(m, v) && (u("value changed"), v = m, p = !0, w(v) && P(v), o());
+  }, d = () => {
+    u("reset");
+    const b = l ? e(i()) : e;
+    w(b) && P(b);
+    const m = !a(b, v);
+    v = b, p = !1, m && o();
+  }, g = () => p, h = te({
+    [ee]: !0,
+    meta: t.meta,
+    /**
+     * Get the current value (raw, including Promises).
+     */
+    get() {
+      return v;
+    },
+    use: void 0,
+    set: c,
+    reset: d,
+    dirty: g,
+    /**
+     * Subscribe to value changes.
+     */
+    on: r.on
+  });
+  return ($ = j.current) == null || $.call(j, {
+    type: "mutable",
+    key: (_ = t.meta) == null ? void 0 : _.key,
+    meta: t.meta,
+    instance: h
+  }), h;
+}
+function pu(e) {
+  return e;
+}
+let V = 0;
+function au(e) {
+  if (V++, V === 1) {
+    let t = /* @__PURE__ */ new Set();
+    const r = (a) => {
+      t.add(a);
+    };
+    try {
+      return U.use([Q(() => r)], e);
+    } finally {
+      V--, U.use([Q(() => r)], () => {
+        for (; t.size > 0; ) {
+          const a = t;
+          t = /* @__PURE__ */ new Set();
+          for (const s of a)
+            s();
+        }
+      });
+    }
+  }
+  try {
+    return e();
+  } finally {
+    V--;
+  }
+}
+function bu(e, t) {
+  let r, a;
+  const s = (i) => {
+    i && typeof i == "object" && "dispose" in i && typeof i.dispose == "function" && i.dispose();
+  }, n = () => {
+    s(r), r = void 0;
+  };
+  return Object.assign(() => {
+    var i;
+    return r || (a ? r = a(e) : r = e(), (i = j.current) == null || i.call(j, {
+      type: "module",
+      key: t == null ? void 0 : t.key,
+      meta: t == null ? void 0 : t.meta,
+      instance: r
+    })), r;
+  }, {
+    key: t == null ? void 0 : t.key,
+    override: (i) => {
+      if (r !== void 0)
+        throw new Error(
+          "Cannot override after initialization. Call override() before accessing the service."
+        );
+      a = i;
+    },
+    reset: () => {
+      a = void 0, n();
+    },
+    invalidate: () => {
+      a = void 0, n();
+    },
+    isOverridden: () => a !== void 0,
+    isInitialized: () => r !== void 0
+  });
+}
+const fe = U();
+function nu(e) {
+  return e !== null && typeof e == "object" && ee in e && e[ee] === !0;
+}
+function su(e) {
+  return e !== null && typeof e == "object" && _e in e && e[_e] === !0;
+}
+function M(e) {
+  if (su(e))
+    return e.state();
+  const t = e.get();
+  if (!w(t))
+    return {
+      status: "ready",
+      value: t
+    };
+  const r = P(t);
+  switch (r.status) {
+    case "fulfilled":
+      return {
+        status: "ready",
+        value: r.value
+      };
+    case "rejected":
+      return {
+        status: "error",
+        error: r.error
+      };
+    case "pending":
+      return {
+        status: "loading",
+        promise: r.promise
+      };
+  }
+}
+const iu = typeof AggregateError < "u" ? AggregateError : class extends Error {
+  constructor(r, a) {
+    super(a);
+    A(this, "errors");
+    this.name = "AggregateError", this.errors = r;
+  }
+};
+class mu extends Error {
+  constructor(r, a = "All atoms rejected") {
+    super(a);
+    A(this, "errors");
+    this.name = "AllAtomsRejectedError", this.errors = r;
+  }
+}
+function ou(e) {
+  const t = /* @__PURE__ */ new Set();
+  let r = !0;
+  const a = (o) => {
+    if (!r)
+      throw new Error(
+        `${o}() was called outside of the selection context. This usually happens when calling context methods in async callbacks (setTimeout, Promise.then, etc.). All atom reads must happen synchronously during selector execution. For async access, use atom.get() directly (e.g., myMutableAtom$.get() or await myDerivedAtom$.get()).`
+      );
+  }, s = (o) => {
+    a("read"), t.add(o);
+    const c = M(o);
+    switch (c.status) {
+      case "ready":
+        return c.value;
+      case "error":
+        throw c.error;
+      case "loading":
+        throw c.promise;
+    }
+  }, n = (o) => {
+    a("all");
+    const c = [], d = [];
+    for (const g of o) {
+      t.add(g);
+      const h = M(g);
+      switch (h.status) {
+        case "ready":
+          c.push(h.value);
+          break;
+        case "error":
+          throw h.error;
+        case "loading":
+          d.push(h.promise);
+          break;
+      }
+    }
+    if (d.length > 0)
+      throw K("all", d);
+    return c;
+  }, u = (o) => {
+    a("race");
+    const c = [], d = Object.entries(o);
+    for (const [g, h] of d) {
+      t.add(h);
+      const _ = M(h);
+      switch (_.status) {
+        case "ready":
+          return {
+            key: g,
+            value: _.value
+          };
+        case "error":
+          throw _.error;
+        case "loading":
+          c.push(_.promise);
+          break;
+      }
+    }
+    throw c.length > 0 ? K("race", c) : new Error("race() called with no atoms");
+  }, i = (o) => {
+    a("any");
+    const c = [], d = [], g = Object.entries(o);
+    for (const [h, _] of g) {
+      t.add(_);
+      const $ = M(_);
+      switch ($.status) {
+        case "ready":
+          return {
+            key: h,
+            value: $.value
+          };
+        case "error":
+          c.push($.error);
+          break;
+        case "loading":
+          d.push($.promise);
+          break;
+      }
+    }
+    throw d.length > 0 ? K("race", d) : new iu(c, "All atoms rejected");
+  }, l = (o) => {
+    a("settled");
+    const c = [], d = [];
+    for (const g of o) {
+      t.add(g);
+      const h = M(g);
+      switch (h.status) {
+        case "ready":
+          c.push({ status: "ready", value: h.value });
+          break;
+        case "error":
+          c.push({ status: "error", error: h.error });
+          break;
+        case "loading":
+          d.push(h.promise);
+          break;
+      }
+    }
+    if (d.length > 0)
+      throw K("allSettled", d);
+    return c;
+  }, f = (o) => {
+    a("safe");
+    try {
+      return [void 0, o()];
+    } catch (c) {
+      if (w(c))
+        throw c;
+      return [c, void 0];
+    }
+  };
+  function v(o) {
+    if (a("state"), nu(o)) {
+      t.add(o);
+      const c = M(o);
+      switch (c.status) {
+        case "ready":
+          return {
+            status: "ready",
+            value: c.value,
+            error: void 0
+          };
+        case "error":
+          return {
+            status: "error",
+            value: void 0,
+            error: c.error
+          };
+        case "loading":
+          return {
+            status: "loading",
+            value: void 0,
+            error: void 0
+          };
+      }
+    }
+    try {
+      return {
+        status: "ready",
+        value: o(),
+        error: void 0
+      };
+    } catch (c) {
+      return w(c) ? {
+        status: "loading",
+        value: void 0,
+        error: void 0
+      } : {
+        status: "error",
+        value: void 0,
+        error: c
+      };
+    }
+  }
+  const p = te({
+    read: s,
+    all: n,
+    any: i,
+    race: u,
+    settled: l,
+    safe: f,
+    state: v
+  });
+  try {
+    const o = e(p);
+    if (w(o))
+      throw new Error(
+        "select() selector must return a synchronous value, not a Promise. For async data, create an async atom with atom(Promise) and use get() to read it."
+      );
+    return {
+      value: o,
+      error: void 0,
+      promise: void 0,
+      dependencies: t
+    };
+  } catch (o) {
+    return w(o) ? {
+      value: void 0,
+      error: void 0,
+      promise: o,
+      dependencies: t
+    } : {
+      value: void 0,
+      error: o,
+      promise: void 0,
+      dependencies: t
+    };
+  } finally {
+    r = !1;
+  }
+}
+function Qe(e) {
+  if (e == null)
+    throw new Promise(() => {
+    });
+  if (w(e)) {
+    const t = P(e);
+    if (t.status === "pending")
+      throw t.promise;
+    if (t.status === "fulfilled")
+      return t.value;
+    throw t.error;
+  }
+  return e;
+}
+function uu() {
+  return (e) => ({
+    ...e,
+    ready: (t, r) => {
+      if (typeof t == "function") {
+        const n = t();
+        if (w(n))
+          throw new Error(
+            "ready(callback) overload does not support async callbacks. Use ready(atom, selector?) instead."
+          );
+        return Qe(n);
+      }
+      const a = e.read(t), s = r ? r(a) : a;
+      return Qe(s);
+    }
+  });
+}
+function cu(e, t = {}) {
+  var we, Te;
+  const r = W(), a = ht(t.equals), s = "fallback" in t, n = t.fallback;
+  let u, i, l = null, f = !1, v = !1, p = 0, o = null, c = null;
+  const d = /* @__PURE__ */ new Map();
+  let g;
+  const h = (T) => {
+    var O, S;
+    (O = t.onError) == null || O.call(t, T);
+    const C = t._errorSource ?? g;
+    (S = fe.current) == null || S.call(fe, { source: C, error: T });
+  }, _ = () => {
+    r.forEach((T) => {
+      Q.current(T);
+    });
+  }, $ = (T) => {
+    for (const [C, O] of d)
+      T.has(C) || (O(), d.delete(C));
+    for (const C of T)
+      if (!d.has(C)) {
+        const O = C.on(() => {
+          b();
+        });
+        d.set(C, O);
+      }
+  }, b = (T = !1) => {
+    const C = ++p;
+    v = !0, i = void 0, o || (l = new Promise((S, E) => {
+      o = S, c = E;
+    }), l.catch(() => {
+    }));
+    const O = () => {
+      const S = ou((E) => e(E.use(uu())));
+      if ($(S.dependencies), S.promise)
+        T || _(), S.promise.then(
+          () => {
+            p === C && O();
+          },
+          (E) => {
+            p === C && (v = !1, i = E, c == null || c(E), o = null, c = null, h(E), _());
+          }
+        );
+      else if (S.error !== void 0)
+        v = !1, i = S.error, c == null || c(S.error), o = null, c = null, h(S.error), T || _();
+      else {
+        const E = S.value, gt = !u;
+        v = !1, i = void 0, (!u || !a(E, u.value)) && (u = { value: E }, (gt || !T) && _()), o == null || o(E), o = null, c = null;
+      }
+    };
+    return O(), l;
+  }, m = () => {
+    f || (f = !0, b(!0));
+  }, D = {
+    [ee]: !0,
+    [_e]: !0,
+    meta: t.meta,
+    /**
+     * Get the computed value as a Promise.
+     * Always returns Promise<T>, even for sync computations.
+     */
+    get() {
+      return m(), l;
+    },
+    /**
+     * The stale value - fallback or last resolved value.
+     * - Without fallback: T | undefined
+     * - With fallback: T (guaranteed)
+     */
+    get staleValue() {
+      if (m(), u)
+        return u.value;
+      if (s)
+        return n;
+    },
+    /**
+     * Get the current state of the derived atom.
+     * Returns the actual underlying state (loading/ready/error).
+     * Use staleValue if you need fallback/cached value during loading.
+     */
+    state() {
+      return m(), v ? { status: "loading", promise: l } : i !== void 0 ? { status: "error", error: i } : u ? { status: "ready", value: u.value } : { status: "loading", promise: l };
+    },
+    /**
+     * Re-run the computation.
+     */
+    refresh() {
+      f ? b() : m();
+    },
+    /**
+     * Subscribe to value changes.
+     */
+    on(T) {
+      return m(), r.on(T);
+    }
+  };
+  return g = {
+    type: "derived",
+    key: (we = t.meta) == null ? void 0 : we.key,
+    meta: t.meta,
+    instance: D
+  }, (Te = j.current) == null || Te.call(j, g), D;
+}
+function Au(e, t) {
+  var i, l;
+  let r = !1;
+  const a = W(), s = {
+    meta: t == null ? void 0 : t.meta,
+    dispose: () => {
+      r || (r = !0, a.emitAndClear());
+    }
+  }, n = {
+    type: "effect",
+    key: (i = t == null ? void 0 : t.meta) == null ? void 0 : i.key,
+    meta: t == null ? void 0 : t.meta,
+    instance: s
+  };
+  return cu(
+    (f) => {
+      if (a.emitAndClear(), r) return;
+      const v = {
+        ...f,
+        onCleanup: a.on
+      };
+      au(() => e(v));
+    },
+    {
+      onError: t == null ? void 0 : t.onError,
+      _errorSource: n
+    }
+  ).get(), (l = j.current) == null || l.call(j, n), s;
+}
+export {
+  mu as A,
+  w as a,
+  Z as b,
+  _u as c,
+  pu as d,
+  au as e,
+  bu as f,
+  cu as g,
+  Au as h,
+  nu as i,
+  W as j,
+  su as k,
+  M as l,
+  hu as m,
+  gu as n,
+  yu as o,
+  P as p,
+  j as q,
+  ht as r,
+  ou as s,
+  fu as t,
+  vu as u,
+  fe as v,
+  te as w,
+  du as x
+};