atomirx 0.1.0 → 0.1.2

package/dist/index-DbZ2r2Im.js

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