atomirx 0.0.8 → 0.1.0

package/dist/index-BbPZhsDl.js

@@ -0,0 +1,1653 @@
+var wt = Object.defineProperty;
+var Tt = (e, t, r) => t in e ? wt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var O = (e, t, r) => Tt(e, typeof t != "symbol" ? t + "" : t, r);
+import { h as ye, o as Z, a as St } from "./onErrorHook-BGGy3tqK.js";
+const Ct = () => {
+};
+class Et {
+  constructor(t) {
+    /** Set of registered listeners */
+    O(this, "_listeners");
+    /** Settled payload (if settled) */
+    O(this, "_settledPayload");
+    /** Whether the emitter has been settled */
+    O(this, "_isSettled", !1);
+    O(this, "size", () => this._listeners.size);
+    O(this, "settled", () => this._isSettled);
+    O(this, "forEach", (t) => {
+      this._listeners.forEach(t);
+    });
+    O(this, "on", (t, r) => {
+      let a;
+      if (r === void 0)
+        a = Array.isArray(t) ? t : [t];
+      else {
+        const n = t, c = Array.isArray(r) ? r : [r];
+        a = [
+          (i) => {
+            const f = n(i);
+            if (f)
+              for (let v = 0; v < c.length; v++)
+                c[v](f.value);
+          }
+        ];
+      }
+      if (this._isSettled) {
+        const n = this._settledPayload;
+        for (let c = 0; c < a.length; c++)
+          a[c](n);
+        return Ct;
+      }
+      const o = this._listeners;
+      for (let n = 0; n < a.length; n++)
+        o.add(a[n]);
+      return () => {
+        for (let n = 0; n < a.length; n++)
+          o.delete(a[n]);
+      };
+    });
+    O(this, "emit", (t) => {
+      this._isSettled || this._doEmit(t, !1, !1);
+    });
+    O(this, "emitLifo", (t) => {
+      this._isSettled || this._doEmit(t, !1, !0);
+    });
+    O(this, "clear", () => {
+      this._listeners.clear();
+    });
+    O(this, "emitAndClear", (t) => {
+      this._isSettled || this._doEmit(t, !0, !1);
+    });
+    O(this, "emitAndClearLifo", (t) => {
+      this._isSettled || this._doEmit(t, !0, !0);
+    });
+    O(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.
+     */
+    O(this, "_doEmit", (t, r, a) => {
+      const o = this._listeners, n = o.size;
+      if (n === 0) return;
+      const c = Array.from(o);
+      if (r && o.clear(), a)
+        for (let i = n - 1; i >= 0; i--)
+          c[i](t);
+      else
+        for (let i = 0; i < n; i++)
+          c[i](t);
+    });
+    this._listeners = new Set(t);
+  }
+}
+function B(e) {
+  return new Et(e);
+}
+var Q = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function jt(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function Ot() {
+  this.__data__ = [], this.size = 0;
+}
+var Pt = Ot;
+function Dt(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var ct = Dt, xt = ct;
+function It(e, t) {
+  for (var r = e.length; r--; )
+    if (xt(e[r][0], t))
+      return r;
+  return -1;
+}
+var ce = It, Lt = ce, Mt = Array.prototype, kt = Mt.splice;
+function Gt(e) {
+  var t = this.__data__, r = Lt(t, e);
+  if (r < 0)
+    return !1;
+  var a = t.length - 1;
+  return r == a ? t.pop() : kt.call(t, r, 1), --this.size, !0;
+}
+var Rt = Gt, qt = ce;
+function Ft(e) {
+  var t = this.__data__, r = qt(t, e);
+  return r < 0 ? void 0 : t[r][1];
+}
+var Ht = Ft, Bt = ce;
+function zt(e) {
+  return Bt(this.__data__, e) > -1;
+}
+var Nt = zt, Ut = ce;
+function Kt(e, t) {
+  var r = this.__data__, a = Ut(r, e);
+  return a < 0 ? (++this.size, r.push([e, t])) : r[a][1] = t, this;
+}
+var Vt = Kt, Wt = Pt, Yt = Rt, Jt = Ht, Xt = Nt, Zt = Vt;
+function z(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]);
+  }
+}
+z.prototype.clear = Wt;
+z.prototype.delete = Yt;
+z.prototype.get = Jt;
+z.prototype.has = Xt;
+z.prototype.set = Zt;
+var ue = z, Qt = ue;
+function er() {
+  this.__data__ = new Qt(), this.size = 0;
+}
+var tr = er;
+function rr(e) {
+  var t = this.__data__, r = t.delete(e);
+  return this.size = t.size, r;
+}
+var ar = rr;
+function nr(e) {
+  return this.__data__.get(e);
+}
+var sr = nr;
+function or(e) {
+  return this.__data__.has(e);
+}
+var ir = or, cr = typeof Q == "object" && Q && Q.Object === Object && Q, ut = cr, ur = ut, lr = typeof self == "object" && self && self.Object === Object && self, fr = ur || lr || Function("return this")(), M = fr, dr = M, vr = dr.Symbol, Ee = vr, xe = Ee, lt = Object.prototype, hr = lt.hasOwnProperty, gr = lt.toString, Y = xe ? xe.toStringTag : void 0;
+function pr(e) {
+  var t = hr.call(e, Y), r = e[Y];
+  try {
+    e[Y] = void 0;
+    var a = !0;
+  } catch {
+  }
+  var o = gr.call(e);
+  return a && (t ? e[Y] = r : delete e[Y]), o;
+}
+var yr = pr, _r = Object.prototype, br = _r.toString;
+function mr(e) {
+  return br.call(e);
+}
+var $r = mr, Ie = Ee, Ar = yr, wr = $r, Tr = "[object Null]", Sr = "[object Undefined]", Le = Ie ? Ie.toStringTag : void 0;
+function Cr(e) {
+  return e == null ? e === void 0 ? Sr : Tr : Le && Le in Object(e) ? Ar(e) : wr(e);
+}
+var le = Cr;
+function Er(e) {
+  var t = typeof e;
+  return e != null && (t == "object" || t == "function");
+}
+var ft = Er, jr = le, Or = ft, Pr = "[object AsyncFunction]", Dr = "[object Function]", xr = "[object GeneratorFunction]", Ir = "[object Proxy]";
+function Lr(e) {
+  if (!Or(e))
+    return !1;
+  var t = jr(e);
+  return t == Dr || t == xr || t == Pr || t == Ir;
+}
+var dt = Lr, Mr = M, kr = Mr["__core-js_shared__"], Gr = kr, he = Gr, Me = function() {
+  var e = /[^.]+$/.exec(he && he.keys && he.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+}();
+function Rr(e) {
+  return !!Me && Me in e;
+}
+var qr = Rr, Fr = Function.prototype, Hr = Fr.toString;
+function Br(e) {
+  if (e != null) {
+    try {
+      return Hr.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var vt = Br, zr = dt, Nr = qr, Ur = ft, Kr = vt, Vr = /[\\^$.*+?()[\]{}|]/g, Wr = /^\[object .+?Constructor\]$/, Yr = Function.prototype, Jr = Object.prototype, Xr = Yr.toString, Zr = Jr.hasOwnProperty, Qr = RegExp(
+  "^" + Xr.call(Zr).replace(Vr, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function ea(e) {
+  if (!Ur(e) || Nr(e))
+    return !1;
+  var t = zr(e) ? Qr : Wr;
+  return t.test(Kr(e));
+}
+var ta = ea;
+function ra(e, t) {
+  return e == null ? void 0 : e[t];
+}
+var aa = ra, na = ta, sa = aa;
+function oa(e, t) {
+  var r = sa(e, t);
+  return na(r) ? r : void 0;
+}
+var N = oa, ia = N, ca = M, ua = ia(ca, "Map"), je = ua, la = N, fa = la(Object, "create"), fe = fa, ke = fe;
+function da() {
+  this.__data__ = ke ? ke(null) : {}, this.size = 0;
+}
+var va = da;
+function ha(e) {
+  var t = this.has(e) && delete this.__data__[e];
+  return this.size -= t ? 1 : 0, t;
+}
+var ga = ha, pa = fe, ya = "__lodash_hash_undefined__", _a = Object.prototype, ba = _a.hasOwnProperty;
+function ma(e) {
+  var t = this.__data__;
+  if (pa) {
+    var r = t[e];
+    return r === ya ? void 0 : r;
+  }
+  return ba.call(t, e) ? t[e] : void 0;
+}
+var $a = ma, Aa = fe, wa = Object.prototype, Ta = wa.hasOwnProperty;
+function Sa(e) {
+  var t = this.__data__;
+  return Aa ? t[e] !== void 0 : Ta.call(t, e);
+}
+var Ca = Sa, Ea = fe, ja = "__lodash_hash_undefined__";
+function Oa(e, t) {
+  var r = this.__data__;
+  return this.size += this.has(e) ? 0 : 1, r[e] = Ea && t === void 0 ? ja : t, this;
+}
+var Pa = Oa, Da = va, xa = ga, Ia = $a, La = Ca, Ma = Pa;
+function U(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]);
+  }
+}
+U.prototype.clear = Da;
+U.prototype.delete = xa;
+U.prototype.get = Ia;
+U.prototype.has = La;
+U.prototype.set = Ma;
+var ka = U, Ge = ka, Ga = ue, Ra = je;
+function qa() {
+  this.size = 0, this.__data__ = {
+    hash: new Ge(),
+    map: new (Ra || Ga)(),
+    string: new Ge()
+  };
+}
+var Fa = qa;
+function Ha(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+var Ba = Ha, za = Ba;
+function Na(e, t) {
+  var r = e.__data__;
+  return za(t) ? r[typeof t == "string" ? "string" : "hash"] : r.map;
+}
+var de = Na, Ua = de;
+function Ka(e) {
+  var t = Ua(this, e).delete(e);
+  return this.size -= t ? 1 : 0, t;
+}
+var Va = Ka, Wa = de;
+function Ya(e) {
+  return Wa(this, e).get(e);
+}
+var Ja = Ya, Xa = de;
+function Za(e) {
+  return Xa(this, e).has(e);
+}
+var Qa = Za, en = de;
+function tn(e, t) {
+  var r = en(this, e), a = r.size;
+  return r.set(e, t), this.size += r.size == a ? 0 : 1, this;
+}
+var rn = tn, an = Fa, nn = Va, sn = Ja, on = Qa, cn = rn;
+function K(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]);
+  }
+}
+K.prototype.clear = an;
+K.prototype.delete = nn;
+K.prototype.get = sn;
+K.prototype.has = on;
+K.prototype.set = cn;
+var ht = K, un = ue, ln = je, fn = ht, dn = 200;
+function vn(e, t) {
+  var r = this.__data__;
+  if (r instanceof un) {
+    var a = r.__data__;
+    if (!ln || a.length < dn - 1)
+      return a.push([e, t]), this.size = ++r.size, this;
+    r = this.__data__ = new fn(a);
+  }
+  return r.set(e, t), this.size = r.size, this;
+}
+var hn = vn, gn = ue, pn = tr, yn = ar, _n = sr, bn = ir, mn = hn;
+function V(e) {
+  var t = this.__data__ = new gn(e);
+  this.size = t.size;
+}
+V.prototype.clear = pn;
+V.prototype.delete = yn;
+V.prototype.get = _n;
+V.prototype.has = bn;
+V.prototype.set = mn;
+var $n = V, An = "__lodash_hash_undefined__";
+function wn(e) {
+  return this.__data__.set(e, An), this;
+}
+var Tn = wn;
+function Sn(e) {
+  return this.__data__.has(e);
+}
+var Cn = Sn, En = ht, jn = Tn, On = Cn;
+function ae(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.__data__ = new En(); ++t < r; )
+    this.add(e[t]);
+}
+ae.prototype.add = ae.prototype.push = jn;
+ae.prototype.has = On;
+var Pn = ae;
+function Dn(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 xn = Dn;
+function In(e, t) {
+  return e.has(t);
+}
+var Ln = In, Mn = Pn, kn = xn, Gn = Ln, Rn = 1, qn = 2;
+function Fn(e, t, r, a, o, n) {
+  var c = r & Rn, i = e.length, f = t.length;
+  if (i != f && !(c && f > i))
+    return !1;
+  var v = n.get(e), w = n.get(t);
+  if (v && w)
+    return v == t && w == e;
+  var y = -1, _ = !0, $ = r & qn ? new Mn() : void 0;
+  for (n.set(e, t), n.set(t, e); ++y < i; ) {
+    var m = e[y], T = t[y];
+    if (a)
+      var u = c ? a(T, m, y, t, e, n) : a(m, T, y, e, t, n);
+    if (u !== void 0) {
+      if (u)
+        continue;
+      _ = !1;
+      break;
+    }
+    if ($) {
+      if (!kn(t, function(d, p) {
+        if (!Gn($, p) && (m === d || o(m, d, r, a, n)))
+          return $.push(p);
+      })) {
+        _ = !1;
+        break;
+      }
+    } else if (!(m === T || o(m, T, r, a, n))) {
+      _ = !1;
+      break;
+    }
+  }
+  return n.delete(e), n.delete(t), _;
+}
+var gt = Fn, Hn = M, Bn = Hn.Uint8Array, zn = Bn;
+function Nn(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(a, o) {
+    r[++t] = [o, a];
+  }), r;
+}
+var Un = Nn;
+function Kn(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(a) {
+    r[++t] = a;
+  }), r;
+}
+var Vn = Kn, Re = Ee, qe = zn, Wn = ct, Yn = gt, Jn = Un, Xn = Vn, Zn = 1, Qn = 2, es = "[object Boolean]", ts = "[object Date]", rs = "[object Error]", as = "[object Map]", ns = "[object Number]", ss = "[object RegExp]", os = "[object Set]", is = "[object String]", cs = "[object Symbol]", us = "[object ArrayBuffer]", ls = "[object DataView]", Fe = Re ? Re.prototype : void 0, ge = Fe ? Fe.valueOf : void 0;
+function fs(e, t, r, a, o, n, c) {
+  switch (r) {
+    case ls:
+      if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset)
+        return !1;
+      e = e.buffer, t = t.buffer;
+    case us:
+      return !(e.byteLength != t.byteLength || !n(new qe(e), new qe(t)));
+    case es:
+    case ts:
+    case ns:
+      return Wn(+e, +t);
+    case rs:
+      return e.name == t.name && e.message == t.message;
+    case ss:
+    case is:
+      return e == t + "";
+    case as:
+      var i = Jn;
+    case os:
+      var f = a & Zn;
+      if (i || (i = Xn), e.size != t.size && !f)
+        return !1;
+      var v = c.get(e);
+      if (v)
+        return v == t;
+      a |= Qn, c.set(e, t);
+      var w = Yn(i(e), i(t), a, o, n, c);
+      return c.delete(e), w;
+    case cs:
+      if (ge)
+        return ge.call(e) == ge.call(t);
+  }
+  return !1;
+}
+var ds = fs;
+function vs(e, t) {
+  for (var r = -1, a = t.length, o = e.length; ++r < a; )
+    e[o + r] = t[r];
+  return e;
+}
+var hs = vs, gs = Array.isArray, Oe = gs, ps = hs, ys = Oe;
+function _s(e, t, r) {
+  var a = t(e);
+  return ys(e) ? a : ps(a, r(e));
+}
+var bs = _s;
+function ms(e, t) {
+  for (var r = -1, a = e == null ? 0 : e.length, o = 0, n = []; ++r < a; ) {
+    var c = e[r];
+    t(c, r, e) && (n[o++] = c);
+  }
+  return n;
+}
+var $s = ms;
+function As() {
+  return [];
+}
+var ws = As, Ts = $s, Ss = ws, Cs = Object.prototype, Es = Cs.propertyIsEnumerable, He = Object.getOwnPropertySymbols, js = He ? function(e) {
+  return e == null ? [] : (e = Object(e), Ts(He(e), function(t) {
+    return Es.call(e, t);
+  }));
+} : Ss, Os = js;
+function Ps(e, t) {
+  for (var r = -1, a = Array(e); ++r < e; )
+    a[r] = t(r);
+  return a;
+}
+var Ds = Ps;
+function xs(e) {
+  return e != null && typeof e == "object";
+}
+var ve = xs, Is = le, Ls = ve, Ms = "[object Arguments]";
+function ks(e) {
+  return Ls(e) && Is(e) == Ms;
+}
+var Gs = ks, Be = Gs, Rs = ve, pt = Object.prototype, qs = pt.hasOwnProperty, Fs = pt.propertyIsEnumerable, Hs = Be(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? Be : function(e) {
+  return Rs(e) && qs.call(e, "callee") && !Fs.call(e, "callee");
+}, Bs = Hs, ne = { exports: {} };
+function zs() {
+  return !1;
+}
+var Ns = zs;
+ne.exports;
+(function(e, t) {
+  var r = M, a = Ns, o = t && !t.nodeType && t, n = o && !0 && e && !e.nodeType && e, c = n && n.exports === o, i = c ? r.Buffer : void 0, f = i ? i.isBuffer : void 0, v = f || a;
+  e.exports = v;
+})(ne, ne.exports);
+var yt = ne.exports, Us = 9007199254740991, Ks = /^(?:0|[1-9]\d*)$/;
+function Vs(e, t) {
+  var r = typeof e;
+  return t = t ?? Us, !!t && (r == "number" || r != "symbol" && Ks.test(e)) && e > -1 && e % 1 == 0 && e < t;
+}
+var Ws = Vs, Ys = 9007199254740991;
+function Js(e) {
+  return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Ys;
+}
+var _t = Js, Xs = le, Zs = _t, Qs = ve, eo = "[object Arguments]", to = "[object Array]", ro = "[object Boolean]", ao = "[object Date]", no = "[object Error]", so = "[object Function]", oo = "[object Map]", io = "[object Number]", co = "[object Object]", uo = "[object RegExp]", lo = "[object Set]", fo = "[object String]", vo = "[object WeakMap]", ho = "[object ArrayBuffer]", go = "[object DataView]", po = "[object Float32Array]", yo = "[object Float64Array]", _o = "[object Int8Array]", bo = "[object Int16Array]", mo = "[object Int32Array]", $o = "[object Uint8Array]", Ao = "[object Uint8ClampedArray]", wo = "[object Uint16Array]", To = "[object Uint32Array]", S = {};
+S[po] = S[yo] = S[_o] = S[bo] = S[mo] = S[$o] = S[Ao] = S[wo] = S[To] = !0;
+S[eo] = S[to] = S[ho] = S[ro] = S[go] = S[ao] = S[no] = S[so] = S[oo] = S[io] = S[co] = S[uo] = S[lo] = S[fo] = S[vo] = !1;
+function So(e) {
+  return Qs(e) && Zs(e.length) && !!S[Xs(e)];
+}
+var Co = So;
+function Eo(e) {
+  return function(t) {
+    return e(t);
+  };
+}
+var jo = Eo, se = { exports: {} };
+se.exports;
+(function(e, t) {
+  var r = ut, a = t && !t.nodeType && t, o = a && !0 && e && !e.nodeType && e, n = o && o.exports === a, c = n && r.process, i = function() {
+    try {
+      var f = o && o.require && o.require("util").types;
+      return f || c && c.binding && c.binding("util");
+    } catch {
+    }
+  }();
+  e.exports = i;
+})(se, se.exports);
+var Oo = se.exports, Po = Co, Do = jo, ze = Oo, Ne = ze && ze.isTypedArray, xo = Ne ? Do(Ne) : Po, bt = xo, Io = Ds, Lo = Bs, Mo = Oe, ko = yt, Go = Ws, Ro = bt, qo = Object.prototype, Fo = qo.hasOwnProperty;
+function Ho(e, t) {
+  var r = Mo(e), a = !r && Lo(e), o = !r && !a && ko(e), n = !r && !a && !o && Ro(e), c = r || a || o || n, i = c ? Io(e.length, String) : [], f = i.length;
+  for (var v in e)
+    (t || Fo.call(e, v)) && !(c && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (v == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    o && (v == "offset" || v == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    n && (v == "buffer" || v == "byteLength" || v == "byteOffset") || // Skip index properties.
+    Go(v, f))) && i.push(v);
+  return i;
+}
+var Bo = Ho, zo = Object.prototype;
+function No(e) {
+  var t = e && e.constructor, r = typeof t == "function" && t.prototype || zo;
+  return e === r;
+}
+var Uo = No;
+function Ko(e, t) {
+  return function(r) {
+    return e(t(r));
+  };
+}
+var Vo = Ko, Wo = Vo, Yo = Wo(Object.keys, Object), Jo = Yo, Xo = Uo, Zo = Jo, Qo = Object.prototype, ei = Qo.hasOwnProperty;
+function ti(e) {
+  if (!Xo(e))
+    return Zo(e);
+  var t = [];
+  for (var r in Object(e))
+    ei.call(e, r) && r != "constructor" && t.push(r);
+  return t;
+}
+var ri = ti, ai = dt, ni = _t;
+function si(e) {
+  return e != null && ni(e.length) && !ai(e);
+}
+var oi = si, ii = Bo, ci = ri, ui = oi;
+function li(e) {
+  return ui(e) ? ii(e) : ci(e);
+}
+var fi = li, di = bs, vi = Os, hi = fi;
+function gi(e) {
+  return di(e, hi, vi);
+}
+var pi = gi, Ue = pi, yi = 1, _i = Object.prototype, bi = _i.hasOwnProperty;
+function mi(e, t, r, a, o, n) {
+  var c = r & yi, i = Ue(e), f = i.length, v = Ue(t), w = v.length;
+  if (f != w && !c)
+    return !1;
+  for (var y = f; y--; ) {
+    var _ = i[y];
+    if (!(c ? _ in t : bi.call(t, _)))
+      return !1;
+  }
+  var $ = n.get(e), m = n.get(t);
+  if ($ && m)
+    return $ == t && m == e;
+  var T = !0;
+  n.set(e, t), n.set(t, e);
+  for (var u = c; ++y < f; ) {
+    _ = i[y];
+    var d = e[_], p = t[_];
+    if (a)
+      var C = c ? a(p, d, _, t, e, n) : a(d, p, _, e, t, n);
+    if (!(C === void 0 ? d === p || o(d, p, r, a, n) : C)) {
+      T = !1;
+      break;
+    }
+    u || (u = _ == "constructor");
+  }
+  if (T && !u) {
+    var P = e.constructor, j = t.constructor;
+    P != j && "constructor" in e && "constructor" in t && !(typeof P == "function" && P instanceof P && typeof j == "function" && j instanceof j) && (T = !1);
+  }
+  return n.delete(e), n.delete(t), T;
+}
+var $i = mi, Ai = N, wi = M, Ti = Ai(wi, "DataView"), Si = Ti, Ci = N, Ei = M, ji = Ci(Ei, "Promise"), Oi = ji, Pi = N, Di = M, xi = Pi(Di, "Set"), Ii = xi, Li = N, Mi = M, ki = Li(Mi, "WeakMap"), Gi = ki, _e = Si, be = je, me = Oi, $e = Ii, Ae = Gi, mt = le, W = vt, Ke = "[object Map]", Ri = "[object Object]", Ve = "[object Promise]", We = "[object Set]", Ye = "[object WeakMap]", Je = "[object DataView]", qi = W(_e), Fi = W(be), Hi = W(me), Bi = W($e), zi = W(Ae), F = mt;
+(_e && F(new _e(new ArrayBuffer(1))) != Je || be && F(new be()) != Ke || me && F(me.resolve()) != Ve || $e && F(new $e()) != We || Ae && F(new Ae()) != Ye) && (F = function(e) {
+  var t = mt(e), r = t == Ri ? e.constructor : void 0, a = r ? W(r) : "";
+  if (a)
+    switch (a) {
+      case qi:
+        return Je;
+      case Fi:
+        return Ke;
+      case Hi:
+        return Ve;
+      case Bi:
+        return We;
+      case zi:
+        return Ye;
+    }
+  return t;
+});
+var Ni = F, pe = $n, Ui = gt, Ki = ds, Vi = $i, Xe = Ni, Ze = Oe, Qe = yt, Wi = bt, Yi = 1, et = "[object Arguments]", tt = "[object Array]", ee = "[object Object]", Ji = Object.prototype, rt = Ji.hasOwnProperty;
+function Xi(e, t, r, a, o, n) {
+  var c = Ze(e), i = Ze(t), f = c ? tt : Xe(e), v = i ? tt : Xe(t);
+  f = f == et ? ee : f, v = v == et ? ee : v;
+  var w = f == ee, y = v == ee, _ = f == v;
+  if (_ && Qe(e)) {
+    if (!Qe(t))
+      return !1;
+    c = !0, w = !1;
+  }
+  if (_ && !w)
+    return n || (n = new pe()), c || Wi(e) ? Ui(e, t, r, a, o, n) : Ki(e, t, f, r, a, o, n);
+  if (!(r & Yi)) {
+    var $ = w && rt.call(e, "__wrapped__"), m = y && rt.call(t, "__wrapped__");
+    if ($ || m) {
+      var T = $ ? e.value() : e, u = m ? t.value() : t;
+      return n || (n = new pe()), o(T, u, r, a, n);
+    }
+  }
+  return _ ? (n || (n = new pe()), Vi(e, t, r, a, o, n)) : !1;
+}
+var Zi = Xi, Qi = Zi, at = ve;
+function $t(e, t, r, a, o) {
+  return e === t ? !0 : e == null || t == null || !at(e) && !at(t) ? e !== e && t !== t : Qi(e, t, r, a, $t, o);
+}
+var ec = $t, tc = ec;
+function rc(e, t) {
+  return tc(e, t);
+}
+var ac = rc;
+const nc = /* @__PURE__ */ jt(ac);
+function sc(e, t) {
+  return Object.is(e, t);
+}
+function oe(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), o = Object.keys(t);
+  if (a.length !== o.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 Pe(e, t) {
+  return oe(e, t, oe);
+}
+function oc(e, t) {
+  return oe(e, t, Pe);
+}
+const ic = nc;
+function De(e) {
+  return !e || e === "strict" ? sc : e === "shallow" ? oe : e === "shallow2" ? Pe : e === "shallow3" ? oc : e === "deep" ? ic : e;
+}
+function nt(e) {
+  const t = e;
+  let r = e;
+  return Object.assign(
+    (...a) => r(...a),
+    {
+      getOriginal: () => t,
+      getCurrent: () => r,
+      setCurrent(a) {
+        r = a;
+      }
+    }
+  );
+}
+function cc(e) {
+  return typeof e == "function" && "getOriginal" in e && "getCurrent" in e && "setCurrent" in e;
+}
+function mc(e, t, r) {
+  return e ? typeof t == "function" ? cc(e.value) ? (e.value.setCurrent(t), [e.value, !0]) : [nt(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" ? [nt(t), !1] : [t, !1];
+}
+const ie = ye((e) => e()), J = Symbol.for("atomirx.atom"), we = Symbol.for("atomirx.derived"), Te = Symbol.for("atomirx.scoped"), Se = Symbol.for("atomirx.pool");
+function X(e) {
+  return Object.assign(e, {
+    use(t) {
+      if (typeof t != "function")
+        return X(Object.assign({}, e, t));
+      const r = t(e);
+      return r ? typeof r == "object" || typeof r == "function" ? X(r) : r : e;
+    }
+  });
+}
+function I(e) {
+  return e !== null && typeof e == "object" && "then" in e && typeof e.then == "function";
+}
+const Ce = /* @__PURE__ */ new WeakMap();
+function st(e) {
+  return Ce.get(e);
+}
+function te(e, t) {
+  if (t.length === 1) {
+    if (e === "allSettled") {
+      const a = Promise.allSettled(t).then(() => {
+      });
+      return Ce.set(a, { type: e, promises: t }), a;
+    }
+    return t[0];
+  }
+  const r = Promise[e](t);
+  return r.catch(() => {
+  }), Ce.set(r, { type: e, promises: t }), r;
+}
+function $c(e, t) {
+  if (e === t) return !0;
+  if (!e || !t) return !1;
+  const r = st(e), a = st(t);
+  return !!r && !!a && Pe(r, a);
+}
+const H = /* @__PURE__ */ new WeakMap();
+function L(e) {
+  const t = H.get(e);
+  if (t)
+    return t;
+  const r = { status: "pending", promise: e };
+  return H.set(e, r), e.then(
+    (a) => {
+      const o = H.get(e);
+      (o == null ? void 0 : o.status) === "pending" && H.set(e, { status: "fulfilled", value: a });
+    },
+    (a) => {
+      const o = H.get(e);
+      (o == null ? void 0 : o.status) === "pending" && H.set(e, { status: "rejected", error: a });
+    }
+  ), r;
+}
+function Ac(e) {
+  if (!I(e))
+    return e;
+  const r = L(e);
+  switch (r.status) {
+    case "pending":
+      throw r.promise;
+    case "rejected":
+      throw r.error;
+    case "fulfilled":
+      return r.value;
+  }
+}
+function wc(e) {
+  return I(e) ? L(e).status === "pending" : !1;
+}
+function Tc(e) {
+  return I(e) ? L(e).status === "fulfilled" : !1;
+}
+function Sc(e) {
+  return I(e) ? L(e).status === "rejected" : !1;
+}
+function uc(e, t = {}) {
+  var j, D, k;
+  const r = B(), a = De(t.equals);
+  let o = null;
+  const n = B();
+  let c = !1;
+  const i = (s) => {
+    o && (o.abort(s), o = null), n.emitAndClear();
+  }, f = () => (o = new AbortController(), X({
+    signal: o.signal,
+    onCleanup: n.on
+  })), v = typeof e == "function";
+  let y = v ? e(f()) : e, _ = !1;
+  I(y) && L(y);
+  const $ = () => {
+    r.forEach((s) => {
+      ie.current(s);
+    });
+  }, m = (s) => {
+    if (c) return;
+    let l;
+    typeof s == "function" ? l = s(y) : l = s, !a(l, y) && (i("value changed"), y = l, _ = !0, I(y) && L(y), $());
+  }, T = () => {
+    if (c) return;
+    i("reset");
+    const s = v ? e(f()) : e;
+    I(s) && L(s);
+    const l = !a(s, y);
+    y = s, _ = !1, l && $();
+  }, u = () => _, d = () => {
+    c || (c = !0, i("disposed"), r.clear());
+  }, p = () => {
+  }, C = (s) => c ? p : r.on(s), P = X({
+    [J]: !0,
+    meta: t.meta,
+    /**
+     * Get the current value (raw, including Promises).
+     */
+    get() {
+      return y;
+    },
+    use: void 0,
+    set: m,
+    reset: T,
+    dirty: u,
+    _dispose: d,
+    on: C
+  });
+  return (k = (D = Z).current) == null || k.call(D, {
+    type: "mutable",
+    key: (j = t.meta) == null ? void 0 : j.key,
+    meta: t.meta,
+    instance: P
+  }), P;
+}
+function Cc(e) {
+  return e;
+}
+let re = 0;
+function lc(e) {
+  if (re++, re === 1) {
+    let t = /* @__PURE__ */ new Set();
+    const r = (a) => {
+      t.add(a);
+    };
+    try {
+      return ye.use([ie(() => r)], e);
+    } finally {
+      re--, ye.use([ie(() => r)], () => {
+        for (; t.size > 0; ) {
+          const a = t;
+          t = /* @__PURE__ */ new Set();
+          for (const o of a)
+            o();
+        }
+      });
+    }
+  }
+  try {
+    return e();
+  } finally {
+    re--;
+  }
+}
+function Ec(e, t) {
+  let r, a;
+  const o = (i) => {
+    i && typeof i == "object" && "dispose" in i && typeof i.dispose == "function" && i.dispose();
+  }, n = () => {
+    o(r), r = void 0;
+  };
+  return Object.assign(() => {
+    var i, f;
+    return r || (a ? r = a(e) : r = e(), (f = (i = Z).current) == null || f.call(i, {
+      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
+  });
+}
+function ot(e) {
+  return e !== null && typeof e == "object" && J in e && e[J] === !0;
+}
+function fc(e) {
+  return e !== null && typeof e == "object" && we in e && e[we] === !0;
+}
+function q(e) {
+  if (fc(e))
+    return e.state();
+  const t = e.get();
+  if (!I(t))
+    return {
+      status: "ready",
+      value: t
+    };
+  const r = L(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 dc = typeof AggregateError < "u" ? AggregateError : class extends Error {
+  constructor(r, a) {
+    super(a);
+    O(this, "errors");
+    this.name = "AggregateError", this.errors = r;
+  }
+};
+class Oc extends Error {
+  constructor(r, a = "All atoms rejected") {
+    super(a);
+    O(this, "errors");
+    this.name = "AllAtomsRejectedError", this.errors = r;
+  }
+}
+function vc(e) {
+  let t = e;
+  const r = (n) => {
+    throw new Error(
+      `ScopedAtom.${n}() is not allowed. ScopedAtom cannot be accessed directly - use read(virtualAtom) in select context instead. This prevents orphan atom references and ensures proper reactive tracking.`
+    );
+  }, a = () => {
+    if (!t)
+      throw new Error(
+        "ScopedAtom._getAtom() was called after disposal. ScopedAtoms are only valid during select() execution. Always use from(pool, params) inside the computation, not outside."
+      );
+    return t;
+  };
+  return {
+    [J]: !0,
+    [Te]: !0,
+    get meta() {
+      return r("meta");
+    },
+    get() {
+      return r("get");
+    },
+    on(n) {
+      return r("on");
+    },
+    _getAtom() {
+      return a();
+    },
+    _dispose() {
+      t = void 0;
+    }
+  };
+}
+function G(e) {
+  return e !== null && typeof e == "object" && Te in e && e[Te] === !0;
+}
+function hc(e, t = null) {
+  const r = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  let n = !0, c = !1;
+  const i = (s) => {
+    if (!n)
+      throw new Error(
+        `${s}() 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.`
+      );
+  }, f = (s) => {
+    i("track"), !c && (G(s) ? r.add(s._getAtom()) : r.add(s));
+  }, v = (s, l) => {
+    i("from"), a.has(s) || a.set(s, /* @__PURE__ */ new Set()), a.get(s).add(l);
+    const g = s._getAtom(l);
+    if (o.has(g))
+      return o.get(g);
+    const h = vc(g);
+    return o.set(g, h), h;
+  }, w = (s) => {
+    i("read"), f(s);
+    const l = G(s) ? s._getAtom() : s, g = q(l);
+    switch (g.status) {
+      case "ready":
+        return g.value;
+      case "error":
+        throw g.error;
+      case "loading":
+        throw g.promise;
+    }
+  }, y = (s) => {
+    i("all");
+    const l = [], g = [];
+    for (const h of s) {
+      f(h);
+      const E = G(h) ? h._getAtom() : h, b = q(E);
+      switch (b.status) {
+        case "ready":
+          l.push(b.value);
+          break;
+        case "error":
+          throw b.error;
+        case "loading":
+          g.push(b.promise);
+          break;
+      }
+    }
+    if (g.length > 0)
+      throw te("all", g);
+    return l;
+  }, _ = (s) => {
+    i("race");
+    const l = [], g = Object.entries(s);
+    for (const [h, E] of g) {
+      f(E);
+      const b = G(E) ? E._getAtom() : E, A = q(b);
+      switch (A.status) {
+        case "ready":
+          return {
+            key: h,
+            value: A.value
+          };
+        case "error":
+          throw A.error;
+        case "loading":
+          l.push(A.promise);
+          break;
+      }
+    }
+    throw l.length > 0 ? te("race", l) : new Error("race() called with no atoms");
+  }, $ = (s) => {
+    i("any");
+    const l = [], g = [], h = Object.entries(s);
+    for (const [E, b] of h) {
+      f(b);
+      const A = G(b) ? b._getAtom() : b, x = q(A);
+      switch (x.status) {
+        case "ready":
+          return {
+            key: E,
+            value: x.value
+          };
+        case "error":
+          l.push(x.error);
+          break;
+        case "loading":
+          g.push(x.promise);
+          break;
+      }
+    }
+    throw g.length > 0 ? te("race", g) : new dc(l, "All atoms rejected");
+  }, m = (s) => {
+    i("settled");
+    const l = [], g = [];
+    for (const h of s) {
+      f(h);
+      const E = G(h) ? h._getAtom() : h, b = q(E);
+      switch (b.status) {
+        case "ready":
+          l.push({ status: "ready", value: b.value });
+          break;
+        case "error":
+          l.push({ status: "error", error: b.error });
+          break;
+        case "loading":
+          g.push(b.promise);
+          break;
+      }
+    }
+    if (g.length > 0)
+      throw te("allSettled", g);
+    return l;
+  }, T = (s) => {
+    i("safe");
+    try {
+      return [void 0, s()];
+    } catch (l) {
+      if (I(l))
+        throw l;
+      return [l, void 0];
+    }
+  };
+  function u(s) {
+    if (i("state"), ot(s)) {
+      f(s);
+      const l = G(s) ? s._getAtom() : s, g = q(l);
+      switch (g.status) {
+        case "ready":
+          return {
+            status: "ready",
+            value: g.value,
+            error: void 0
+          };
+        case "error":
+          return {
+            status: "error",
+            value: void 0,
+            error: g.error
+          };
+        case "loading":
+          return {
+            status: "loading",
+            value: void 0,
+            error: void 0
+          };
+      }
+    }
+    try {
+      return {
+        status: "ready",
+        value: s(),
+        error: void 0
+      };
+    } catch (l) {
+      return I(l) ? {
+        status: "loading",
+        value: void 0,
+        error: void 0
+      } : {
+        status: "error",
+        value: void 0,
+        error: l
+      };
+    }
+  }
+  const d = (s) => {
+    if (typeof s == "boolean")
+      return s;
+    if (typeof s == "function") {
+      const l = s();
+      return typeof l == "boolean" ? l : !!w(l);
+    }
+    return !!w(s);
+  }, p = (s) => {
+    i("and");
+    for (const l of s)
+      if (!d(l))
+        return !1;
+    return !0;
+  }, C = (s) => {
+    i("or");
+    for (const l of s)
+      if (d(l))
+        return !0;
+    return !1;
+  };
+  function P(s) {
+    if (i("untrack"), ot(s)) {
+      const g = G(s) ? s._getAtom() : s, h = q(g);
+      switch (h.status) {
+        case "ready":
+          return h.value;
+        case "error":
+          throw h.error;
+        case "loading":
+          throw h.promise;
+      }
+    }
+    const l = c;
+    c = !0;
+    try {
+      return s();
+    } finally {
+      c = l;
+    }
+  }
+  const j = X({
+    read: w,
+    from: v,
+    track: f,
+    all: y,
+    any: $,
+    race: _,
+    settled: m,
+    safe: T,
+    state: u,
+    and: p,
+    or: C,
+    untrack: P
+  });
+  let D;
+  try {
+    const s = e(j);
+    if (I(s))
+      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 read() to read it."
+      );
+    D = {
+      value: s,
+      error: void 0,
+      promise: void 0,
+      dependencies: r,
+      // Backward compatibility
+      _atomDeps: r,
+      _poolDeps: a
+    };
+  } catch (s) {
+    I(s) ? D = {
+      value: void 0,
+      error: void 0,
+      promise: s,
+      dependencies: r,
+      _atomDeps: r,
+      _poolDeps: a
+    } : D = {
+      value: void 0,
+      error: s,
+      promise: void 0,
+      dependencies: r,
+      _atomDeps: r,
+      _poolDeps: a
+    };
+  } finally {
+    n = !1;
+    for (const s of o.values())
+      s._dispose();
+    o.clear();
+  }
+  return { result: D, startTracking: (s) => {
+    const l = [];
+    for (const g of r)
+      l.push(g.on(s));
+    for (const [g, h] of a)
+      for (const E of h)
+        l.push(g._onRemove(E, s));
+    return () => {
+      for (const g of l)
+        g();
+    };
+  } };
+}
+function it(e) {
+  if (e == null)
+    throw new Promise(() => {
+    });
+  if (I(e)) {
+    const t = L(e);
+    if (t.status === "pending")
+      throw t.promise;
+    if (t.status === "fulfilled")
+      return t.value;
+    throw t.error;
+  }
+  return e;
+}
+function gc() {
+  return (e) => ({
+    ...e,
+    ready: (t, r) => {
+      if (typeof t == "function") {
+        const n = t();
+        if (I(n))
+          throw new Error(
+            "ready(callback) overload does not support async callbacks. Use ready(atom, selector?) instead."
+          );
+        return it(n);
+      }
+      const a = e.read(t), o = r ? r(a) : a;
+      return it(o);
+    }
+  });
+}
+function pc(e, t = {}) {
+  var s, l, g;
+  const r = B(), a = De(t.equals), o = "fallback" in t, n = t.fallback;
+  let c, i, f = null, v = !1, w = !1, y = !1, _ = 0, $ = null, m = null;
+  const T = /* @__PURE__ */ new Map();
+  let u = [], d;
+  const p = (h) => {
+    var b, A, x;
+    (b = t.onError) == null || b.call(t, h);
+    const E = t._errorSource ?? d;
+    (x = (A = St).current) == null || x.call(A, { source: E, error: h });
+  }, C = () => {
+    r.forEach((h) => {
+      ie.current(h);
+    });
+  }, P = (h) => {
+    const E = h._atomDeps, b = h._poolDeps;
+    for (const [A, x] of T)
+      E.has(A) || (x(), T.delete(A));
+    for (const A of E)
+      if (!T.has(A)) {
+        const x = A.on(() => {
+          j();
+        });
+        T.set(A, x);
+      }
+    for (const A of u)
+      A();
+    u = [];
+    for (const [A, x] of b)
+      for (const R of x) {
+        const At = A._onRemove(R, () => {
+          j();
+        });
+        u.push(At);
+      }
+  }, j = (h = !1) => {
+    const E = ++_;
+    return w = !0, i = void 0, $ || (f = new Promise((b, A) => {
+      $ = b, m = A;
+    }), f.catch(() => {
+    })), (async () => {
+      for (; ; ) {
+        if (_ !== E) return;
+        const { result: b } = hc((R) => e(R.use(gc())));
+        if (P(b), b.promise) {
+          h || C();
+          try {
+            if (await b.promise, _ !== E) return;
+            continue;
+          } catch (R) {
+            if (_ !== E) return;
+            w = !1, i = R, m == null || m(R), $ = null, m = null, p(R), C();
+            return;
+          }
+        }
+        if (b.error !== void 0) {
+          w = !1, i = b.error, m == null || m(b.error), $ = null, m = null, p(b.error), h || C();
+          return;
+        }
+        const A = b.value, x = !c;
+        w = !1, i = void 0, (!c || !a(A, c.value)) && (c = { value: A }, (x || !h) && C()), $ == null || $(A), $ = null, m = null;
+        return;
+      }
+    })(), f;
+  }, D = () => {
+    v || (v = !0, j(!0));
+  }, k = {
+    [J]: !0,
+    [we]: !0,
+    meta: t.meta,
+    /**
+     * Get the computed value as a Promise.
+     * Always returns Promise<T>, even for sync computations.
+     */
+    get() {
+      return D(), f;
+    },
+    /**
+     * The stale value - fallback or last resolved value.
+     * - Without fallback: T | undefined
+     * - With fallback: T (guaranteed)
+     */
+    get staleValue() {
+      if (D(), c)
+        return c.value;
+      if (o)
+        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 D(), w ? { status: "loading", promise: f } : i !== void 0 ? { status: "error", error: i } : c ? { status: "ready", value: c.value } : { status: "loading", promise: f };
+    },
+    /**
+     * Re-run the computation.
+     */
+    refresh() {
+      y || (v ? j() : D());
+    },
+    /**
+     * Subscribe to value changes.
+     * Returns no-op unsubscribe if atom is disposed.
+     */
+    on(h) {
+      return y ? () => {
+      } : (D(), r.on(h));
+    },
+    /**
+     * Dispose the derived atom, cleaning up all subscriptions.
+     * After disposal, refresh is a no-op and new subscriptions return no-op unsubscribe.
+     * @internal - Reserved for future use.
+     */
+    _dispose() {
+      if (!y) {
+        y = !0;
+        for (const h of T.values())
+          h();
+        T.clear();
+        for (const h of u)
+          h();
+        u = [], r.clear();
+      }
+    }
+  };
+  return d = {
+    type: "derived",
+    key: (s = t.meta) == null ? void 0 : s.key,
+    meta: t.meta,
+    instance: k
+  }, (g = (l = Z).current) == null || g.call(l, d), k;
+}
+function yc(e) {
+  return (t) => {
+    const r = new AbortController();
+    return e(() => r.abort()), {
+      ...t,
+      signal: r.signal,
+      // Safe abort - no-op if already aborted
+      abort: () => !r.signal.aborted && r.abort()
+    };
+  };
+}
+function Pc(e, t) {
+  var i, f, v;
+  let r = !1;
+  const a = B(), o = {
+    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: o
+  };
+  return pc(
+    (w) => {
+      if (a.emitAndClear(), r) return;
+      const y = a.on, _ = w.use({ onCleanup: y }).use(yc(y));
+      lc(() => e(_));
+    },
+    {
+      onError: t == null ? void 0 : t.onError,
+      _errorSource: n
+    }
+  ).get(), (v = (f = Z).current) == null || v.call(f, n), o;
+}
+function Dc(e, t) {
+  var m, T;
+  const { gcTime: r, meta: a } = t, o = De(t.equals ?? "shallow"), n = [], c = /* @__PURE__ */ new WeakMap(), i = B(), f = (u) => u !== null && (typeof u == "object" || typeof u == "function"), v = (u) => {
+    if (f(u)) {
+      const d = c.get(u);
+      if (d) {
+        const p = n.indexOf(d);
+        if (p !== -1)
+          return { entry: d, index: p };
+        c.delete(u);
+      }
+    }
+    for (let d = 0; d < n.length; d++)
+      if (o(n[d].params, u))
+        return f(u) && c.set(u, n[d]), { entry: n[d], index: d };
+  }, w = (u) => {
+    const d = uc((s) => e(u, s));
+    let p = {}, C = null;
+    const P = (s) => {
+      C && (clearTimeout(C), C = null);
+      const l = p = {};
+      if (I(s) && L(s).status === "pending") {
+        const h = () => {
+          p === l && P(s);
+        };
+        s.then(h, h);
+        return;
+      }
+      C = setTimeout(() => {
+        p === l && _(u);
+      }, r);
+    }, j = () => P(d.get()), D = () => {
+      C && (clearTimeout(C), C = null), k();
+    }, k = d.on(() => {
+      p = {};
+      const s = d.get();
+      j(), i.emit({ type: "change", params: u, value: s });
+    });
+    return j(), {
+      atom: d,
+      params: u,
+      disposeEmitter: B(),
+      // For entry-specific removal listeners
+      resetGC: j,
+      cleanup: D
+    };
+  }, y = (u) => {
+    const d = v(u);
+    if (d)
+      return d.entry;
+    const p = w(u);
+    return n.push(p), i.emit({ type: "create", params: u, value: p.atom.get() }), p;
+  }, _ = (u) => {
+    const d = v(u);
+    if (!d) return;
+    const { entry: p, index: C } = d;
+    p.atom._dispose(), p.cleanup();
+    const P = p.atom.get(), j = p.params;
+    p.disposeEmitter.emitAndClear(), n.splice(C, 1), i.emit({
+      type: "remove",
+      params: j,
+      value: P
+    });
+  }, $ = {
+    // Symbol marker for type identification
+    [Se]: !0,
+    // User-provided metadata (for devtools, debugging)
+    meta: a,
+    /**
+     * Returns the number of entries in the pool.
+     */
+    size() {
+      return n.length;
+    },
+    /**
+     * Gets the value for params.
+     * Creates entry if it doesn't exist.
+     * Resets GC timer on access (keeps entry alive).
+     */
+    get(u) {
+      const d = y(u);
+      return d.resetGC(), d.atom.get();
+    },
+    /**
+     * Sets the value for params.
+     * Creates entry if it doesn't exist.
+     * Resets GC timer on access.
+     *
+     * Accepts either a direct value or an updater function.
+     */
+    set(u, d) {
+      const p = y(u);
+      p.resetGC(), p.atom.set(d);
+    },
+    /**
+     * Checks if an entry exists for params.
+     * Does NOT create entry or reset GC timer.
+     */
+    has(u) {
+      return v(u) !== void 0;
+    },
+    /**
+     * Removes an entry from the pool.
+     * Triggers "remove" event and cleanup.
+     */
+    remove(u) {
+      _(u);
+    },
+    /**
+     * Removes all entries from the pool.
+     * Triggers "remove" event for each entry.
+     */
+    clear() {
+      const u = [...n];
+      for (const d of u)
+        _(d.params);
+    },
+    /**
+     * Iterates over all entries in the pool.
+     * Callback receives (value, params) for each entry.
+     */
+    forEach(u) {
+      for (const d of n)
+        u(d.atom.get(), d.params);
+    },
+    /**
+     * Subscribes to pool events.
+     *
+     * Events:
+     * - "create": New entry created
+     * - "change": Entry value changed
+     * - "remove": Entry removed (manual or GC)
+     *
+     * @returns Unsubscribe function
+     */
+    on(u) {
+      return i.on(u);
+    },
+    // =========================================================================
+    // Internal API (used by SelectContext)
+    // =========================================================================
+    /**
+     * Gets the underlying atom for params.
+     * @internal Used by SelectContext.from() to create ScopedAtom
+     */
+    _getAtom(u) {
+      return y(u).atom;
+    },
+    /**
+     * Subscribes to removal of a specific entry.
+     * @internal Used by SelectContext for automatic recomputation
+     *
+     * When an entry is removed while a derived/effect depends on it,
+     * this listener triggers recomputation to get a fresh entry.
+     */
+    _onRemove(u, d) {
+      const p = v(u);
+      return p ? p.entry.disposeEmitter.on(d) : () => {
+      };
+    }
+  };
+  return (T = (m = Z).current) == null || T.call(m, {
+    type: "pool",
+    key: a == null ? void 0 : a.key,
+    meta: a,
+    instance: $
+  }), $;
+}
+function xc(e) {
+  return e !== null && typeof e == "object" && Se in e && e[Se] === !0;
+}
+export {
+  Oc as A,
+  oe as a,
+  I as b,
+  uc as c,
+  ic as d,
+  Cc as e,
+  lc as f,
+  Ec as g,
+  pc as h,
+  ot as i,
+  Pc as j,
+  B as k,
+  fc as l,
+  xc as m,
+  G as n,
+  q as o,
+  Dc as p,
+  wc as q,
+  De as r,
+  hc as s,
+  mc as t,
+  Tc as u,
+  Sc as v,
+  X as w,
+  L as x,
+  Ac as y,
+  $c as z
+};