atomirx 0.0.1 → 0.0.4

package/dist/index-D8RDOTB_.js

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