atomirx 0.0.1

package/dist/index-2ok7ilik.js

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