@but212/atom-effect-jquery 0.15.1 → 0.15.2

package/dist/index.mjs

@@ -1,22 +1,22 @@
 import h from "jquery";
-import { default as vt } from "jquery";
-const $e = {
+import { default as Ut } from "jquery";
+const ze = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, ae = {
+}, le = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, A = {
+}, v = {
   DISPOSED: 1,
   HAS_FN_SUBS: 2,
   HAS_OBJ_SUBS: 4
 }, O = {
-  ...A,
+  ...v,
   EXECUTING: 8
 }, l = {
-  ...A,
+  ...v,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -24,11 +24,11 @@ const $e = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, v = {
-  ...A,
+}, U = {
+  ...v,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, V = {
+}, j = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /**
@@ -47,13 +47,13 @@ const $e = {
   MIN_FLUSH_ITERATIONS: 10,
   /** Threshold for shrinking the batch queue to assist GC */
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, Ce = {
+}, Ne = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, $ = 1073741823, C = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ze = Object.freeze([]);
-class L extends Error {
+}, z = 1073741823, N = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", Xe = Object.freeze([]);
+class P extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -64,7 +64,7 @@ class L extends Error {
     super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class M extends L {
+class V extends P {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -74,7 +74,7 @@ class M extends L {
     super(e, s, !0), this.name = "ComputedError";
   }
 }
-class J extends L {
+class J extends P {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -84,7 +84,7 @@ class J extends L {
     super(e, s, !1), this.name = "EffectError";
   }
 }
-class re extends L {
+class ce extends P {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -94,7 +94,7 @@ class re extends L {
     super(e, s, !1), this.name = "SchedulerError";
   }
 }
-const p = {
+const E = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -186,28 +186,28 @@ const p = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, _e = /* @__PURE__ */ Symbol("debugName"), Xe = /* @__PURE__ */ Symbol("id"), pe = /* @__PURE__ */ Symbol("type"), Ne = /* @__PURE__ */ Symbol("noDefaultValue");
-function qe(t) {
+}, pe = /* @__PURE__ */ Symbol("debugName"), qe = /* @__PURE__ */ Symbol("id"), Ee = /* @__PURE__ */ Symbol("type"), Te = /* @__PURE__ */ Symbol("noDefaultValue");
+function Ge(t) {
   return "dependencies" in t && Array.isArray(t.dependencies);
 }
-let Te = 0;
-function Ue(t, e, s) {
+let xe = 0;
+function we(t, e, s) {
   if (t._visitedEpoch !== s) {
     if (t._visitedEpoch = s, t === e)
-      throw new M("Indirect circular dependency detected");
-    if (qe(t)) {
+      throw new V("Indirect circular dependency detected");
+    if (Ge(t)) {
       const n = t.dependencies;
       for (let i = 0; i < n.length; i++) {
         const o = n[i];
-        o && Ue(o, e, s);
+        o && we(o, e, s);
       }
     }
   }
 }
-const U = {
+const w = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: Ce.MAX_DEPENDENCIES,
-  warnInfiniteLoop: Ce.WARN_INFINITE_LOOP,
+  maxDependencies: Ne.MAX_DEPENDENCIES,
+  warnInfiniteLoop: Ne.WARN_INFINITE_LOOP,
   warn(t, e) {
     this.enabled && t && console.warn(`[Atom Effect] ${e}`);
   },
@@ -218,38 +218,38 @@ const U = {
    */
   checkCircular(t, e) {
     if (t === e)
-      throw new M("Direct circular dependency detected");
-    this.enabled && (Te++, Ue(t, e, Te));
+      throw new V("Direct circular dependency detected");
+    this.enabled && (xe++, we(t, e, xe));
   },
   attachDebugInfo(t, e, s) {
     if (!this.enabled)
       return;
     const n = t;
-    n[_e] = `${e}_${s}`, n[Xe] = s, n[pe] = e;
+    n[pe] = `${e}_${s}`, n[qe] = s, n[Ee] = e;
   },
   getDebugName(t) {
-    if (t != null && _e in t)
-      return t[_e];
-  },
-  getDebugType(t) {
     if (t != null && pe in t)
       return t[pe];
+  },
+  getDebugType(t) {
+    if (t != null && Ee in t)
+      return t[Ee];
   }
 };
-let Ge = 1;
-const Ye = () => Ge++;
-class we {
+let Ye = 1;
+const Qe = () => Ye++;
+class Le {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = Ye() & $, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = Qe() & z, this._tempUnsub = void 0;
   }
   /**
    * Calculates the logical distance (shift) between current and cached version.
    */
   getShift(e) {
-    return this.version - e & $;
+    return this.version - e & z;
   }
 }
-class Fe extends we {
+class Fe extends Le {
   /**
    * Subscribes a listener function or Subscriber object to value changes.
    */
@@ -258,11 +258,11 @@ class Fe extends we {
       return this._addSubscriber(
         this._fnSubs,
         e,
-        A.HAS_FN_SUBS
+        v.HAS_FN_SUBS
       );
     if (e !== null && typeof e == "object" && "execute" in e)
-      return this._addSubscriber(this._objSubs, e, A.HAS_OBJ_SUBS);
-    throw new L(p.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      return this._addSubscriber(this._objSubs, e, v.HAS_OBJ_SUBS);
+    throw new P(E.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
   }
   /**
    * Gets the total number of active subscribers.
@@ -276,7 +276,7 @@ class Fe extends we {
    */
   _addSubscriber(e, s, n) {
     if (e.indexOf(s) !== -1)
-      return C && console.warn(
+      return N && console.warn(
         "Attempted to subscribe the same listener twice. Ignoring duplicate subscription."
       ), () => {
       };
@@ -296,9 +296,9 @@ class Fe extends we {
    * Notifies all subscribers of a change.
    */
   _notifySubscribers(e, s) {
-    const n = this.flags, i = A.HAS_FN_SUBS | A.HAS_OBJ_SUBS;
+    const n = this.flags, i = v.HAS_FN_SUBS | v.HAS_OBJ_SUBS;
     if (n & i) {
-      if (n & A.HAS_FN_SUBS) {
+      if (n & v.HAS_FN_SUBS) {
         const o = this._fnSubs;
         for (let r = 0, c = o.length; r < c; r++) {
           const u = o[r];
@@ -307,12 +307,12 @@ class Fe extends we {
               u(e, s);
             } catch (a) {
               console.error(
-                new L(p.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+                new P(E.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
               );
             }
         }
       }
-      if (n & A.HAS_OBJ_SUBS) {
+      if (n & v.HAS_OBJ_SUBS) {
         const o = this._objSubs;
         for (let r = 0, c = o.length; r < c; r++) {
           const u = o[r];
@@ -321,7 +321,7 @@ class Fe extends we {
               u.execute();
             } catch (a) {
               console.error(
-                new L(p.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+                new P(E.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
               );
             }
         }
@@ -329,24 +329,24 @@ class Fe extends we {
     }
   }
 }
-class Qe {
+class Je {
   constructor() {
-    this.acquired = 0, this.released = 0, this.rejected = new Je();
+    this.acquired = 0, this.released = 0, this.rejected = new Ke();
   }
 }
-class Je {
+class Ke {
   constructor() {
     this.frozen = 0, this.tooLarge = 0, this.poolFull = 0;
   }
 }
-class be {
+class me {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = C ? new Qe() : null;
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = N ? new Je() : null;
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
     const e = this.stats;
-    return C && e && e.acquired++, this.pool.pop() ?? [];
+    return N && e && e.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -355,23 +355,23 @@ class be {
   release(e, s) {
     if (s && e === s || Object.isFrozen(e)) {
       const c = this.stats;
-      C && c && e !== s && c.rejected.frozen++;
+      N && c && e !== s && c.rejected.frozen++;
       return;
     }
     const n = e.length, i = this.pool, o = i.length;
     if (n > this.maxReusableCapacity || o >= this.maxPoolSize) {
       const c = this.stats;
-      C && c && (n > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
+      N && c && (n > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
       return;
     }
     e.length = 0, i.push(e);
     const r = this.stats;
-    C && r && r.released++;
+    N && r && r.released++;
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
     const e = this.stats;
-    if (!C || !e) return null;
+    if (!N || !e) return null;
     const { acquired: s, released: n, rejected: i } = e, o = i.frozen + i.tooLarge + i.poolFull;
     return {
       acquired: s,
@@ -389,10 +389,10 @@ class be {
   reset() {
     this.pool.length = 0;
     const e = this.stats;
-    C && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
+    N && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
   }
 }
-const N = Object.freeze([]), j = Object.freeze([]), x = Object.freeze([]), H = new be(), K = new be(), F = new be();
+const T = Object.freeze([]), H = Object.freeze([]), R = Object.freeze([]), $ = new me(), K = new me(), F = new me();
 function B(t, e, s, n) {
   if (e != null) {
     if ((typeof e == "object" || typeof e == "function") && typeof e.addDependency == "function") {
@@ -401,14 +401,14 @@ function B(t, e, s, n) {
     }
     if (typeof e == "function") {
       const i = e;
-      s.indexOf(i) === -1 && (s.push(i), t.flags |= A.HAS_FN_SUBS);
+      s.indexOf(i) === -1 && (s.push(i), t.flags |= v.HAS_FN_SUBS);
       return;
     }
-    typeof e == "object" && typeof e.execute == "function" && n.indexOf(e) === -1 && (n.push(e), t.flags |= A.HAS_OBJ_SUBS);
+    typeof e == "object" && typeof e.execute == "function" && n.indexOf(e) === -1 && (n.push(e), t.flags |= v.HAS_OBJ_SUBS);
   }
 }
-function xe(t, e, s, n) {
-  const i = t.length, o = e.length, r = e !== N && o > 0;
+function Re(t, e, s, n) {
+  const i = t.length, o = e.length, r = e !== T && o > 0;
   if (r)
     for (let u = 0; u < o; u++) {
       const a = e[u];
@@ -419,61 +419,67 @@ function xe(t, e, s, n) {
   for (let u = 0; u < i; u++) {
     const a = t[u];
     if (!a) continue;
-    const d = a._tempUnsub;
-    d ? (c[u] = d, a._tempUnsub = void 0) : (U.checkCircular(a, n), c[u] = a.subscribe(n));
+    const _ = a._tempUnsub;
+    _ ? (c[u] = _, a._tempUnsub = void 0) : (w.checkCircular(a, n), c[u] = a.subscribe(n));
   }
   if (r)
     for (let u = 0; u < o; u++) {
       const a = e[u];
       if (a) {
-        const d = a._tempUnsub;
-        d && (d(), a._tempUnsub = void 0);
+        const _ = a._tempUnsub;
+        _ && (_(), a._tempUnsub = void 0);
       }
     }
-  return s !== j && K.release(s), c;
+  return s !== H && K.release(s), c;
 }
-let ce = 0;
-function Le() {
-  return ce = ce + 1 & $ || 1, ce;
+let ue = 0;
+function Pe() {
+  return ue = ue + 1 & z || 1, ue;
 }
-function Ke() {
-  return ce;
+function We() {
+  return ue;
 }
-let Ee = 0, me = 0, he = !1;
-function Re() {
-  return he ? (C && console.warn(
+let ge = 0, Se = 0, ae = !1;
+function Ae() {
+  return ae ? (N && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (he = !0, Ee = Ee + 1 & $ || 1, me = 0, !0);
+  ), !1) : (ae = !0, ge = ge + 1 & z || 1, Se = 0, !0);
 }
 function Oe() {
-  he = !1;
+  ae = !1;
 }
-function We() {
-  return he ? ++me : 0;
+function Ze() {
+  return ae ? ++Se : 0;
 }
-class Ze {
+class et {
   constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = V.MAX_FLUSH_ITERATIONS;
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this.isProcessing = !1, this._isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = j.MAX_FLUSH_ITERATIONS;
   }
   /**
    * Returns the current operational phase of the scheduler.
    */
   get phase() {
-    return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
+    return this.isProcessing || this.isFlushingSync ? 2 : this._isBatching ? 1 : 0;
   }
   /** Current number of pending jobs. */
   get queueSize() {
     return this._size;
   }
+  /**
+   * Returns whether the scheduler is currently batching updates.
+   */
+  get isBatching() {
+    return this._isBatching;
+  }
   /**
    * Schedules a task for execution.
    */
   schedule(e) {
-    if (C && typeof e != "function")
-      throw new re("Scheduler callback must be a function");
+    if (N && typeof e != "function")
+      throw new ce("Scheduler callback must be a function");
     const s = this._epoch;
     if (e._nextEpoch !== s) {
-      if (e._nextEpoch = s, this.isBatching || this.isFlushingSync) {
+      if (e._nextEpoch = s, this._isBatching || this.isFlushingSync) {
         this.batchQueue[this.batchQueueSize++] = e;
         return;
       }
@@ -488,10 +494,10 @@ class Ze {
     this.isProcessing || this._size === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
         if (this._size === 0) return;
-        const e = Re();
+        const e = Ae();
         this._drainQueue(), e && Oe();
       } finally {
-        this.isProcessing = !1, this._size > 0 && !this.isBatching && this.flush();
+        this.isProcessing = !1, this._size > 0 && !this._isBatching && this.flush();
       }
     }));
   }
@@ -501,7 +507,7 @@ class Ze {
    */
   flushSync() {
     this.isFlushingSync = !0;
-    const e = Re();
+    const e = Ae();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
@@ -521,7 +527,7 @@ class Ze {
       const c = n[r];
       c._nextEpoch !== s && (c._nextEpoch = s, i[o++] = c);
     }
-    this._size = o, this.batchQueueSize = 0, n.length > V.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
+    this._size = o, this.batchQueueSize = 0, n.length > j.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
   }
   _drainQueue() {
     let e = 0;
@@ -540,7 +546,7 @@ class Ze {
   }
   _handleFlushOverflow() {
     console.error(
-      new re(
+      new ce(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this.batchQueueSize = 0;
@@ -551,31 +557,31 @@ class Ze {
         e[n]();
       } catch (i) {
         console.error(
-          new re("Error occurred during scheduler execution", i)
+          new ce("Error occurred during scheduler execution", i)
         );
       }
     e.length = 0;
   }
   startBatch() {
-    this.batchDepth++, this.isBatching = !0;
+    this.batchDepth++, this._isBatching = !0;
   }
   endBatch() {
     if (this.batchDepth === 0) {
-      C && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      N && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
-    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
+    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(e) {
-    if (e < V.MIN_FLUSH_ITERATIONS)
-      throw new re(
-        `Max flush iterations must be at least ${V.MIN_FLUSH_ITERATIONS}`
+    if (e < j.MIN_FLUSH_ITERATIONS)
+      throw new ce(
+        `Max flush iterations must be at least ${j.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const ie = new Ze();
-class et {
+const oe = new et();
+class tt {
   constructor() {
     this.current = null;
   }
@@ -602,27 +608,27 @@ class et {
     return this.current;
   }
 }
-const D = new et();
-function Pe(t) {
+const C = new tt();
+function ke(t) {
   if (typeof t != "function")
-    throw new L("Untracked callback must be a function");
-  const e = D.current;
-  D.current = null;
+    throw new P("Untracked callback must be a function");
+  const e = C.current;
+  C.current = null;
   try {
     return t();
   } finally {
-    D.current = e;
+    C.current = e;
   }
 }
-class tt extends Fe {
+class st extends Fe {
   constructor(e, s) {
-    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], s && (this.flags |= v.SYNC), U.attachDebugInfo(this, "atom", this.id);
+    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], s && (this.flags |= U.SYNC), w.attachDebugInfo(this, "atom", this.id);
   }
   /**
    * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = D.current;
+    const e = C.current;
     return e && B(this, e, this._fnSubs, this._objSubs), this._value;
   }
   /**
@@ -631,8 +637,8 @@ class tt extends Fe {
   set value(e) {
     const s = this._value;
     if (Object.is(s, e)) return;
-    this._value = e, this.version = this.version + 1 & $;
-    const n = this.flags, i = v.HAS_FN_SUBS | v.HAS_OBJ_SUBS;
+    this._value = e, this.version = this.version + 1 & z;
+    const n = this.flags, i = U.HAS_FN_SUBS | U.HAS_OBJ_SUBS;
     n & i && this._scheduleNotification(s);
   }
   /**
@@ -640,19 +646,19 @@ class tt extends Fe {
    */
   _scheduleNotification(e) {
     let s = this.flags;
-    if (s & v.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = s |= v.NOTIFICATION_SCHEDULED), s & v.SYNC && !ie.isBatching) {
+    if (s & U.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = s |= U.NOTIFICATION_SCHEDULED), s & U.SYNC && !oe.isBatching) {
       this._flushNotifications();
       return;
     }
     let n = this._notifyTask;
-    n || (n = this._notifyTask = () => this._flushNotifications()), ie.schedule(n);
+    n || (n = this._notifyTask = () => this._flushNotifications()), oe.schedule(n);
   }
   /**
    * Flushes scheduled notifications and resets state for the next cycle.
    */
   _flushNotifications() {
     const e = this.flags;
-    if (!(e & v.NOTIFICATION_SCHEDULED) || e & v.DISPOSED)
+    if (!(e & U.NOTIFICATION_SCHEDULED) || e & U.DISPOSED)
       return;
     const s = this._pendingOldValue, n = this._value;
     this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(n, s);
@@ -667,43 +673,43 @@ class tt extends Fe {
    * Disposes of the atom and releases all subscribers and tasks.
    */
   dispose() {
-    this.flags & v.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= v.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & U.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= U.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function st(t, e = {}) {
-  return new tt(t, e.sync ?? !1);
+function nt(t, e = {}) {
+  return new st(t, e.sync ?? !1);
 }
-function se(t, e, s) {
+function ne(t, e, s) {
   if (t instanceof TypeError)
     return new e(`Type error (${s}): ${t.message}`, t);
   if (t instanceof ReferenceError)
     return new e(`Reference error (${s}): ${t.message}`, t);
-  if (t instanceof L)
+  if (t instanceof P)
     return t;
   const n = t instanceof Error ? t.message : String(t), i = t instanceof Error ? t : null;
   return new e(`Unexpected error (${s}): ${n}`, i);
 }
-function ge(t) {
+function be(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
 }
-function Ae(t) {
-  if (U.enabled && t != null && typeof t == "object") {
-    const e = U.getDebugType(t);
+function ve(t) {
+  if (w.enabled && t != null && typeof t == "object") {
+    const e = w.getDebugType(t);
     if (e)
       return e === "computed";
   }
-  return ge(t) && "invalidate" in t && typeof t.invalidate == "function";
+  return be(t) && "invalidate" in t && typeof t.invalidate == "function";
 }
-function ke(t) {
+function Me(t) {
   return t != null && typeof t.then == "function";
 }
-const Be = l.RESOLVED | l.PENDING | l.REJECTED, le = Array(Be + 1).fill(ae.IDLE);
-le[l.RESOLVED] = ae.RESOLVED;
-le[l.PENDING] = ae.PENDING;
-le[l.REJECTED] = ae.REJECTED;
-class nt {
+const Be = l.RESOLVED | l.PENDING | l.REJECTED, fe = Array(Be + 1).fill(le.IDLE);
+fe[l.RESOLVED] = le.RESOLVED;
+fe[l.PENDING] = le.PENDING;
+fe[l.REJECTED] = le.REJECTED;
+class it {
   constructor(e) {
-    this._owner = e, this._epoch = -1, this._nextDeps = N, this._nextVersions = x, this._depCount = 0;
+    this._owner = e, this._epoch = -1, this._nextDeps = T, this._nextVersions = R, this._depCount = 0;
   }
   execute() {
     this._owner._markDirty();
@@ -716,14 +722,14 @@ class nt {
     s < n.length ? (n[s] = e, i[s] = e.version) : (n.push(e), i.push(e.version)), this._depCount = s + 1;
   }
   reset() {
-    this._epoch = -1, this._nextDeps = N, this._nextVersions = x, this._depCount = 0;
+    this._epoch = -1, this._nextDeps = T, this._nextVersions = R, this._depCount = 0;
   }
 }
-class Me extends Fe {
+class Ve extends Fe {
   constructor(e, s = {}) {
     if (typeof e != "function")
-      throw new M(p.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = l.DIRTY | l.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : Ne, this._hasDefaultValue = this._defaultValue !== Ne, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = N, this._dependencyVersions = x, this._unsubscribes = j, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new nt(this), U.attachDebugInfo(this, "computed", this.id), U.enabled) {
+      throw new V(E.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = l.DIRTY | l.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : Te, this._hasDefaultValue = this._defaultValue !== Te, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = T, this._dependencyVersions = R, this._unsubscribes = H, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new it(this), w.attachDebugInfo(this, "computed", this.id), w.enabled) {
       const n = this;
       n.subscriberCount = this.subscriberCount.bind(this), n.isDirty = () => (this.flags & l.DIRTY) !== 0, n.dependencies = this._dependencies, n.stateFlags = "";
     }
@@ -734,12 +740,12 @@ class Me extends Fe {
       }
   }
   get value() {
-    const e = D.current;
+    const e = C.current;
     e && B(this, e, this._fnSubs, this._objSubs);
     const s = this.flags;
     if (s & l.RECOMPUTING) {
       if (this._hasDefaultValue) return this._defaultValue;
-      throw new M(p.COMPUTED_CIRCULAR_DEPENDENCY);
+      throw new V(E.COMPUTED_CIRCULAR_DEPENDENCY);
     }
     s & (l.DIRTY | l.IDLE) && this._recompute();
     const n = this.flags;
@@ -749,11 +755,11 @@ class Me extends Fe {
     return this._value;
   }
   get state() {
-    const e = D.current;
-    return e && B(this, e, this._fnSubs, this._objSubs), le[this.flags & Be];
+    const e = C.current;
+    return e && B(this, e, this._fnSubs, this._objSubs), fe[this.flags & Be];
   }
   get hasError() {
-    const e = D.current;
+    const e = C.current;
     if (e && B(this, e, this._fnSubs, this._objSubs), this.flags & (l.REJECTED | l.HAS_ERROR)) return !0;
     const s = this._dependencies;
     for (let n = 0, i = s.length; n < i; n++) {
@@ -766,9 +772,9 @@ class Me extends Fe {
     return !this.hasError;
   }
   get errors() {
-    const e = D.current;
-    if (e && B(this, e, this._fnSubs, this._objSubs), !this.hasError) return ze;
-    const s = Ke();
+    const e = C.current;
+    if (e && B(this, e, this._fnSubs, this._objSubs), !this.hasError) return Xe;
+    const s = We();
     if (this._errorCacheEpoch === s && this._cachedErrors !== null)
       return this._cachedErrors;
     const n = /* @__PURE__ */ new Set();
@@ -778,9 +784,9 @@ class Me extends Fe {
       const u = i[r];
       if (u && "errors" in u) {
         const a = u.errors;
-        for (let d = 0, P = a.length; d < P; d++) {
-          const S = a[d];
-          S && n.add(S);
+        for (let _ = 0, k = a.length; _ < k; _++) {
+          const y = a[_];
+          y && n.add(y);
         }
       }
     }
@@ -788,35 +794,35 @@ class Me extends Fe {
     return this._cachedErrors = o, this._errorCacheEpoch = s, o;
   }
   get lastError() {
-    const e = D.current;
+    const e = C.current;
     return e && B(this, e, this._fnSubs, this._objSubs), this._error;
   }
   get isPending() {
-    const e = D.current;
+    const e = C.current;
     return e && B(this, e, this._fnSubs, this._objSubs), (this.flags & l.PENDING) !== 0;
   }
   get isResolved() {
-    const e = D.current;
+    const e = C.current;
     return e && B(this, e, this._fnSubs, this._objSubs), (this.flags & l.RESOLVED) !== 0;
   }
   invalidate() {
     this._markDirty();
     const e = this._dependencyVersions;
-    e !== x && (F.release(e), this._dependencyVersions = x), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    e !== R && (F.release(e), this._dependencyVersions = R), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
     const e = this._unsubscribes;
-    if (e !== j) {
+    if (e !== H) {
       for (let i = 0, o = e.length; i < o; i++) {
         const r = e[i];
         r && r();
       }
-      K.release(e), this._unsubscribes = j;
+      K.release(e), this._unsubscribes = H;
     }
     const s = this._dependencies;
-    s !== N && (H.release(s), this._dependencies = N);
+    s !== T && ($.release(s), this._dependencies = T);
     const n = this._dependencyVersions;
-    n !== x && (F.release(n), this._dependencyVersions = x), this._fnSubs = [], this._objSubs = [], this.flags = l.DISPOSED | l.DIRTY | l.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    n !== R && (F.release(n), this._dependencyVersions = R), this._fnSubs = [], this._objSubs = [], this.flags = l.DISPOSED | l.DIRTY | l.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _clearDirty() {
     this.flags &= -9;
@@ -845,23 +851,23 @@ class Me extends Fe {
       return;
     this._setRecomputing(!0);
     const e = this._trackable, s = this._dependencies, n = this._dependencyVersions;
-    e._epoch = Le(), e._nextDeps = H.acquire(), e._nextVersions = F.acquire(), e._depCount = 0;
+    e._epoch = Pe(), e._nextDeps = $.acquire(), e._nextVersions = F.acquire(), e._depCount = 0;
     let i = !1;
     try {
-      const o = D.run(e, this._fn), r = e._nextDeps, c = e._nextVersions, u = e._depCount;
-      r.length = u, c.length = u, this._unsubscribes = xe(r, s, this._unsubscribes, this), this._dependencies = r, this._dependencyVersions = c, i = !0, ke(o) ? this._handleAsyncComputation(o) : this._finalizeResolution(o);
+      const o = C.run(e, this._fn), r = e._nextDeps, c = e._nextVersions, u = e._depCount;
+      r.length = u, c.length = u, this._unsubscribes = Re(r, s, this._unsubscribes, this), this._dependencies = r, this._dependencyVersions = c, i = !0, Me(o) ? this._handleAsyncComputation(o) : this._finalizeResolution(o);
     } catch (o) {
       let r = o;
       if (!i)
         try {
           const c = e._nextDeps, u = e._nextVersions, a = e._depCount;
-          c.length = a, u.length = a, this._unsubscribes = xe(c, s, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = u, i = !0;
+          c.length = a, u.length = a, this._unsubscribes = Re(c, s, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = u, i = !0;
         } catch (c) {
           r = c;
         }
       this._handleComputationError(r);
     } finally {
-      i ? (s !== N && H.release(s), n !== x && F.release(n)) : (H.release(e._nextDeps), F.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
+      i ? (s !== T && $.release(s), n !== R && F.release(n)) : ($.release(e._nextDeps), F.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
     }
   }
   _handleAsyncComputation(e) {
@@ -874,7 +880,7 @@ class Me extends Fe {
             this._asyncRetryCount++, this._markDirty();
             return;
           }
-          const i = new M(
+          const i = new V(
             `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
           );
           this._handleAsyncRejection(i);
@@ -893,42 +899,42 @@ class Me extends Fe {
       const o = s[n];
       if (o) {
         const r = o.version;
-        e = ((e << 5) - e | 0) + r & $;
+        e = ((e << 5) - e | 0) + r & z;
       }
     }
     return e;
   }
   _handleAsyncRejection(e) {
-    const s = se(e, M, p.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    this.flags & l.REJECTED || (this.version = this.version + 1 & $), this._error = s, this._setRejected(), this._clearDirty();
+    const s = ne(e, V, E.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    this.flags & l.REJECTED || (this.version = this.version + 1 & z), this._error = s, this._setRejected(), this._clearDirty();
     const n = this._onError;
     if (n)
       try {
         n(s);
       } catch (i) {
-        console.error(p.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        console.error(E.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(e) {
-    (!(this.flags & l.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & $), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!(this.flags & l.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & z), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleComputationError(e) {
-    const s = se(e, M, p.COMPUTED_COMPUTATION_FAILED);
+    const s = ne(e, V, E.COMPUTED_COMPUTATION_FAILED);
     this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
     const n = this._onError;
     if (n)
       try {
         n(s);
       } catch (i) {
-        console.error(p.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        console.error(E.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw s;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new M(p.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new V(E.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     const e = this._error;
@@ -945,19 +951,19 @@ class Me extends Fe {
     e & (l.RECOMPUTING | l.DIRTY) || (this.flags = e | l.DIRTY, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Me.prototype);
-function it(t, e = {}) {
-  return new Me(t, e);
+Object.freeze(Ve.prototype);
+function ot(t, e = {}) {
+  return new Ve(t, e);
 }
-class ot extends we {
+class rt extends Le {
   constructor(e, s = {}) {
-    super(), this._cleanup = null, this._dependencies = N, this._dependencyVersions = x, this._unsubscribes = j, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = s.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? V.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? V.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
-    const n = Number.isFinite(this._maxExecutions), i = n ? Math.min(this._maxExecutions + 1, V.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
-    this._historyCapacity = i, this._history = C && n && i > 0 ? new Array(i).fill(0) : null, this._execId = 0, U.attachDebugInfo(this, "effect", this.id);
+    super(), this._cleanup = null, this._dependencies = T, this._dependencyVersions = R, this._unsubscribes = H, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = s.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? j.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? j.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
+    const n = Number.isFinite(this._maxExecutions), i = n ? Math.min(this._maxExecutions + 1, j.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
+    this._historyCapacity = i, this._history = N && n && i > 0 ? new Array(i).fill(0) : null, this._execId = 0, w.attachDebugInfo(this, "effect", this.id);
   }
   run() {
     if (this.flags & O.DISPOSED)
-      throw new J(p.EFFECT_DISPOSED);
+      throw new J(E.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
@@ -965,17 +971,17 @@ class ot extends we {
     if (e & O.DISPOSED) return;
     this.flags = e | O.DISPOSED, this._safeCleanup();
     const s = this._unsubscribes;
-    if (s !== j) {
+    if (s !== H) {
       for (let o = 0, r = s.length; o < r; o++) {
         const c = s[o];
         c && c();
       }
-      K.release(s), this._unsubscribes = j;
+      K.release(s), this._unsubscribes = H;
     }
     const n = this._dependencies;
-    n !== N && (H.release(n), this._dependencies = N);
+    n !== T && ($.release(n), this._dependencies = T);
     const i = this._dependencyVersions;
-    i !== x && (F.release(i), this._dependencyVersions = x), this._executeTask = void 0;
+    i !== R && (F.release(i), this._dependencyVersions = R), this._executeTask = void 0;
   }
   addDependency(e) {
     if (!(this.flags & O.EXECUTING)) return;
@@ -994,17 +1000,17 @@ class ot extends we {
     const s = this._prepareEffectExecutionContext();
     let n = !1;
     try {
-      const i = D.run(this, this._fn), o = s.nextDeps.length;
+      const i = C.run(this, this._fn), o = s.nextDeps.length;
       s.nextDeps.length = o, s.nextVersions.length = o, this._dependencies = s.nextDeps, this._dependencyVersions = s.nextVersions, this._unsubscribes = s.nextUnsubs, n = !0, this._checkLoopWarnings();
       const r = ++this._execId;
-      ke(i) ? i.then((c) => {
+      Me(i) ? i.then((c) => {
         const u = r !== this._execId, a = this.flags & O.DISPOSED;
         if (u || a) {
           if (typeof c == "function")
             try {
               c();
-            } catch (d) {
-              this._handleExecutionError(d, p.EFFECT_CLEANUP_FAILED);
+            } catch (_) {
+              this._handleExecutionError(_, E.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
@@ -1019,11 +1025,11 @@ class ot extends we {
     }
   }
   _prepareEffectExecutionContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = H.acquire(), o = F.acquire(), r = K.acquire(), c = Le();
-    if (e !== N)
+    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = $.acquire(), o = F.acquire(), r = K.acquire(), c = Pe();
+    if (e !== T)
       for (let u = 0, a = e.length; u < a; u++) {
-        const d = e[u];
-        d && (d._tempUnsub = n[u]);
+        const _ = e[u];
+        _ && (_._tempUnsub = n[u]);
       }
     return this._nextDeps = i, this._nextVersions = o, this._nextUnsubs = r, this._currentEpoch = c, { prevDeps: e, prevVersions: s, prevUnsubs: n, nextDeps: i, nextVersions: o, nextUnsubs: r };
   }
@@ -1031,20 +1037,20 @@ class ot extends we {
     this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null;
     const n = e.prevDeps;
     if (s) {
-      if (n !== N) {
+      if (n !== T) {
         for (let i = 0, o = n.length; i < o; i++) {
           const r = n[i], c = r ? r._tempUnsub : void 0;
           c && (c(), r && (r._tempUnsub = void 0));
         }
-        H.release(n);
+        $.release(n);
       }
-      e.prevUnsubs !== j && K.release(e.prevUnsubs), e.prevVersions !== x && F.release(e.prevVersions);
+      e.prevUnsubs !== H && K.release(e.prevUnsubs), e.prevVersions !== R && F.release(e.prevVersions);
     } else {
-      H.release(e.nextDeps), F.release(e.nextVersions);
+      $.release(e.nextDeps), F.release(e.nextVersions);
       const i = e.nextUnsubs;
       for (let o = 0, r = i.length; o < r; o++)
         i[o]?.();
-      if (K.release(i), n !== N)
+      if (K.release(i), n !== T)
         for (let o = 0, r = n.length; o < r; o++) {
           const c = n[o];
           c && (c._tempUnsub = void 0);
@@ -1059,11 +1065,11 @@ class ot extends we {
           return;
         }
         let i = this._executeTask;
-        i || (i = this._executeTask = () => this.execute()), ie.schedule(i);
+        i || (i = this._executeTask = () => this.execute()), oe.schedule(i);
       }), n = this._nextUnsubs;
       n && n.push(s);
     } catch (s) {
-      console.error(se(s, J, p.EFFECT_EXECUTION_FAILED));
+      console.error(ne(s, J, E.EFFECT_EXECUTION_FAILED));
       const n = this._nextUnsubs;
       n && n.push(() => {
       });
@@ -1088,14 +1094,14 @@ class ot extends we {
       try {
         e();
       } catch (s) {
-        this._handleExecutionError(s, p.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(s, E.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoop() {
-    const e = Ee;
-    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), We() > V.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    const e = ge;
+    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Ze() > j.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
     const s = this._history;
     if (s) {
       const n = Date.now(), i = this._historyPtr, o = this._historyCapacity;
@@ -1103,18 +1109,18 @@ class ot extends we {
       const r = (i + 1) % o;
       this._historyPtr = r;
       const c = s[r] ?? 0;
-      if (c > 0 && n - c < $e.ONE_SECOND_MS) {
+      if (c > 0 && n - c < ze.ONE_SECOND_MS) {
         const u = new J(
           `Effect executed ${o} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(u), this._onError && this._onError(u), C) throw u;
+        if (this.dispose(), console.error(u), this._onError && this._onError(u), N) throw u;
         return;
       }
     }
   }
   _throwInfiniteLoopError(e) {
     const s = new J(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${me}`
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Se}`
     );
     throw this.dispose(), console.error(s), s;
   }
@@ -1128,7 +1134,7 @@ class ot extends we {
         if (o.version !== s[n]) return !0;
         if ("value" in o)
           try {
-            Pe(() => o.value);
+            ke(() => o.value);
           } catch {
             return !0;
           }
@@ -1136,25 +1142,25 @@ class ot extends we {
     }
     return !1;
   }
-  _handleExecutionError(e, s = p.EFFECT_EXECUTION_FAILED) {
-    const n = se(e, J, s);
+  _handleExecutionError(e, s = E.EFFECT_EXECUTION_FAILED) {
+    const n = ne(e, J, s);
     console.error(n);
     const i = this._onError;
     if (i)
       try {
         i(n);
       } catch (o) {
-        console.error(se(o, J, p.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(ne(o, J, E.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
   _checkLoopWarnings() {
-    if (this._trackModifications && U.enabled) {
+    if (this._trackModifications && w.enabled) {
       const e = this._dependencies, s = this._currentEpoch;
       for (let n = 0, i = e.length; n < i; n++) {
         const o = e[n];
-        o && o._modifiedAtEpoch === s && U.warn(
+        o && o._modifiedAtEpoch === s && w.warn(
           !0,
-          `Effect is reading a dependency (${U.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${w.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
@@ -1162,24 +1168,24 @@ class ot extends we {
 }
 function W(t, e = {}) {
   if (typeof t != "function")
-    throw new J(p.EFFECT_MUST_BE_FUNCTION);
-  const s = new ot(t, e);
+    throw new J(E.EFFECT_MUST_BE_FUNCTION);
+  const s = new rt(t, e);
   return s.execute(), s;
 }
-function Se(t) {
+function ye(t) {
   if (typeof t != "function")
-    throw new L("Batch callback must be a function");
-  ie.startBatch();
+    throw new P("Batch callback must be a function");
+  oe.startBatch();
   try {
     return t();
   } finally {
-    ie.endBatch();
+    oe.endBatch();
   }
 }
-function rt(t) {
+function ct(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
 }
-function fe(t) {
+function _e(t) {
   if (!t) return "unknown";
   const e = "jquery" in t ? t[0] : t;
   if (!e) return "unknown";
@@ -1190,7 +1196,7 @@ function fe(t) {
   }
   return e.tagName.toLowerCase();
 }
-function ct(t) {
+function ut(t) {
   const e = t.length;
   if (e === 0) return new Int32Array(0);
   const s = new Int32Array(e), n = new Int32Array(e);
@@ -1204,8 +1210,8 @@ function ct(t) {
     }
     let u = 0, a = i - 1;
     for (; u < a; ) {
-      const d = u + a >>> 1;
-      t[n[d]] < c ? u = d + 1 : a = d;
+      const _ = u + a >>> 1;
+      t[n[_]] < c ? u = _ + 1 : a = _;
     }
     c < t[n[u]] && (u > 0 && (s[r] = n[u - 1]), n[u] = r);
   }
@@ -1214,7 +1220,7 @@ function ct(t) {
     o[r] = c, c = s[c];
   return o;
 }
-function ut() {
+function ht() {
   if (typeof window < "u") {
     const t = window.__ATOM_DEBUG__;
     if (typeof t == "boolean")
@@ -1227,8 +1233,8 @@ function ut() {
   }
   return !1;
 }
-let Q = ut();
-const E = {
+let Q = ht();
+const g = {
   get enabled() {
     return Q;
   },
@@ -1246,8 +1252,8 @@ const E = {
    */
   domUpdated(t, e, s) {
     if (!Q) return;
-    const n = fe(t);
-    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), ht(t);
+    const n = _e(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), at(t);
   },
   cleanup(t) {
     Q && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
@@ -1256,7 +1262,7 @@ const E = {
     Q && console.warn("[atom-effect-jquery]", ...t);
   }
 };
-function ht(t) {
+function at(t) {
   const e = t[0];
   if (!e || !document.contains(e)) return;
   const s = "atom_debug_timer", n = "atom_debug_cleanup_timer", i = "atom_debug_org_style";
@@ -1285,35 +1291,35 @@ function ht(t) {
   }, 100);
   t.data(s, o);
 }
-const at = /* @__PURE__ */ new WeakMap();
-function Ve(t, e = {}) {
-  const s = st(t, e);
-  return e.name && at.set(s, { name: e.name }), s;
+const lt = /* @__PURE__ */ new WeakMap();
+function je(t, e = {}) {
+  const s = nt(t, e);
+  return e.name && lt.set(s, { name: e.name }), s;
 }
-Object.defineProperty(Ve, "debug", {
+Object.defineProperty(je, "debug", {
   get() {
-    return E.enabled;
+    return g.enabled;
   },
   set(t) {
-    E.enabled = t;
+    g.enabled = t;
   }
 });
-function lt() {
+function ft() {
   return new Promise((t) => setTimeout(t, 0));
 }
 h.extend({
-  atom: Ve,
-  computed: it,
+  atom: je,
+  computed: ot,
   effect: W,
-  batch: Se,
-  untracked: Pe,
-  isAtom: ge,
-  isComputed: Ae,
-  isReactive: (t) => ge(t) || Ae(t),
-  nextTick: lt
+  batch: ye,
+  untracked: ke,
+  isAtom: be,
+  isComputed: ve,
+  isReactive: (t) => be(t) || ve(t),
+  nextTick: ft
 });
-const ee = "_aes-bound";
-class ft {
+const te = "_aes-bound";
+class _t {
   effects = /* @__PURE__ */ new WeakMap();
   cleanups = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
@@ -1334,18 +1340,18 @@ class ft {
   }
   trackEffect(e, s) {
     let n = this.effects.get(e);
-    n || (n = [], this.effects.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ee))), n.push(s);
+    n || (n = [], this.effects.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(te))), n.push(s);
   }
   trackCleanup(e, s) {
     let n = this.cleanups.get(e);
-    n || (n = [], this.cleanups.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ee))), n.push(s);
+    n || (n = [], this.cleanups.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(te))), n.push(s);
   }
   hasBind(e) {
     return this.boundElements.has(e);
   }
   cleanup(e) {
     if (!this.boundElements.delete(e)) return;
-    this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.classList.remove(ee), E.cleanup(fe(e));
+    this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.classList.remove(te), g.cleanup(_e(e));
     const s = this.effects.get(e);
     if (s) {
       this.effects.delete(e);
@@ -1355,7 +1361,7 @@ class ft {
           try {
             r.dispose();
           } catch (c) {
-            E.warn("Effect dispose error:", c);
+            g.warn("Effect dispose error:", c);
           }
       }
     }
@@ -1368,116 +1374,121 @@ class ft {
           try {
             r();
           } catch (c) {
-            E.warn("Cleanup error:", c);
+            g.warn("Cleanup error:", c);
           }
       }
     }
   }
   cleanupDescendants(e) {
-    const s = e.querySelectorAll(`.${ee}`);
+    const s = e.querySelectorAll(`.${te}`);
     for (let n = 0, i = s.length; n < i; n++) {
       const o = s[n];
-      o && (this.boundElements.has(o) ? this.cleanup(o) : o.classList.remove(ee));
+      o && (this.boundElements.has(o) ? this.cleanup(o) : o.classList.remove(te));
     }
   }
   cleanupTree(e) {
     this.cleanupDescendants(e), this.cleanup(e);
   }
 }
-const _ = new ft();
-let ne = null;
+const d = new _t();
+let ie = null;
 function dt(t = document.body) {
-  ne || (ne = new MutationObserver((e) => {
+  ie || (ie = new MutationObserver((e) => {
     for (let s = 0, n = e.length; s < n; s++) {
       const i = e[s];
       if (!i) continue;
       const o = i.removedNodes;
       for (let r = 0, c = o.length; r < c; r++) {
         const u = o[r];
-        u && (_.isKept(u) || _.isIgnored(u) || u.isConnected || u.nodeType === 1 && _.cleanupTree(u));
+        u && (d.isKept(u) || d.isIgnored(u) || u.isConnected || u.nodeType === 1 && d.cleanupTree(u));
       }
     }
-  }), ne.observe(t, { childList: !0, subtree: !0 }));
+  }), ie.observe(t, { childList: !0, subtree: !0 }));
 }
-function xt() {
-  ne?.disconnect(), ne = null;
+function Rt() {
+  ie?.disconnect(), ie = null;
 }
-function g(t, e, s, n) {
+function b(t, e, s, n) {
   const i = h(t);
-  if (rt(e)) {
+  if (ct(e)) {
     const o = W(() => {
       const r = e.value;
-      s(r), E.domUpdated(i, n, r);
+      s(r), g.domUpdated(i, n, r);
     });
-    _.trackEffect(t, o);
+    d.trackEffect(t, o);
   } else
-    s(e), E.domUpdated(i, n, e);
+    s(e), g.domUpdated(i, n, e);
 }
+var p = /* @__PURE__ */ ((t) => (t[t.None = 0] = "None", t[t.Focused = 1] = "Focused", t[t.Composing = 2] = "Composing", t[t.SyncingToAtom = 4] = "SyncingToAtom", t[t.SyncingToDom = 8] = "SyncingToDom", t[t.Busy = 14] = "Busy", t))(p || {});
 function Ie() {
-  return { timeoutId: null, phase: "idle", hasFocus: !1 };
+  return {
+    timeoutId: null,
+    flags: 0
+    /* None */
+  };
 }
-function je(t, e, s = {}) {
+function He(t, e, s = {}) {
   const {
     debounce: n,
     event: i = "input",
-    parse: o = (b) => b,
-    format: r = (b) => String(b ?? ""),
+    parse: o = (m) => m,
+    format: r = (m) => String(m ?? ""),
     equal: c = Object.is
   } = s, u = Ie(), a = () => {
-    u.phase = "composing";
-  }, d = () => {
-    u.phase = "idle", S();
+    u.flags |= p.Composing;
+  }, _ = () => {
+    u.flags &= ~p.Composing, y();
   };
-  t.on("compositionstart", a), t.on("compositionend", d);
-  const P = () => {
-    u.hasFocus = !0;
-  }, S = () => {
-    if (u.phase === "idle") {
-      u.phase = "syncing-to-atom";
+  t.on("compositionstart", a), t.on("compositionend", _);
+  const k = () => {
+    u.flags |= p.Focused;
+  }, y = () => {
+    if (!(u.flags & p.Busy)) {
+      u.flags |= p.SyncingToAtom;
       try {
         e.value = o(t.val());
       } finally {
-        u.phase = "idle";
+        u.flags &= ~p.SyncingToAtom;
       }
     }
-  }, z = () => {
-    u.timeoutId && (clearTimeout(u.timeoutId), u.timeoutId = null, S()), u.hasFocus = !1;
-    const b = r(e.value);
-    t.val() !== b && t.val(b);
+  }, X = () => {
+    u.timeoutId && (clearTimeout(u.timeoutId), u.timeoutId = null, y()), u.flags &= ~p.Focused;
+    const m = r(e.value);
+    t.val() !== m && t.val(m);
   };
-  t.on("focus", P), t.on("blur", z);
-  const R = () => {
-    u.phase === "idle" && (n ? (u.timeoutId && clearTimeout(u.timeoutId), u.timeoutId = window.setTimeout(S, n)) : S());
+  t.on("focus", k), t.on("blur", X);
+  const A = () => {
+    u.flags & p.Busy || (n ? (u.timeoutId && clearTimeout(u.timeoutId), u.timeoutId = window.setTimeout(y, n)) : y());
   };
-  return t.on(i, R), t.on("change", R), { effect: () => {
-    const b = r(e.value), T = t.val();
-    if (T !== b) {
-      if (u.hasFocus && c(o(T), e.value))
+  return t.on(i, A), t.on("change", A), { effect: () => {
+    const m = r(e.value), x = t.val();
+    if (x !== m) {
+      if (u.flags & p.Focused && c(o(x), e.value))
         return;
-      u.phase = "syncing-to-dom";
+      u.flags |= p.SyncingToDom;
       try {
-        if (u.hasFocus) {
-          const k = t[0], Z = k.selectionStart, oe = k.selectionEnd;
-          t.val(b);
-          const q = b.length;
-          k.setSelectionRange(
-            Math.min(Z ?? q, q),
-            Math.min(oe ?? q, q)
+        if (u.flags & p.Focused) {
+          const M = t[0], Z = M.selectionStart, re = M.selectionEnd;
+          t.val(m);
+          const G = m.length;
+          M.setSelectionRange(
+            Math.min(Z ?? G, G),
+            Math.min(re ?? G, G)
           );
         } else
-          t.val(b);
-        E.domUpdated(t, "val", b);
+          t.val(m);
+        g.domUpdated(t, "val", m);
       } finally {
-        u.phase = "idle";
+        u.flags &= ~p.SyncingToDom;
       }
     }
   }, cleanup: () => {
-    t.off(i, R), t.off("change", R), t.off("compositionstart", a), t.off("compositionend", d), t.off("focus", P), t.off("blur", z), u.timeoutId && clearTimeout(u.timeoutId);
+    t.off(i, A), t.off("change", A), t.off("compositionstart", a), t.off("compositionend", _), t.off("focus", k), t.off("blur", X), u.timeoutId && clearTimeout(u.timeoutId);
   } };
 }
 h.fn.atomText = function(t, e) {
   return this.each(function() {
-    g(
+    b(
       this,
       t,
       (s) => {
@@ -1490,12 +1501,12 @@ h.fn.atomText = function(t, e) {
 };
 h.fn.atomHtml = function(t) {
   return this.each(function() {
-    g(this, t, (e) => h(this).html(String(e ?? "")), "html");
+    b(this, t, (e) => h(this).html(String(e ?? "")), "html");
   });
 };
 h.fn.atomClass = function(t, e) {
   return this.each(function() {
-    g(
+    b(
       this,
       e,
       (s) => h(this).toggleClass(t, !!s),
@@ -1505,7 +1516,7 @@ h.fn.atomClass = function(t, e) {
 };
 h.fn.atomCss = function(t, e, s) {
   return this.each(function() {
-    g(
+    b(
       this,
       e,
       (n) => {
@@ -1518,7 +1529,7 @@ h.fn.atomCss = function(t, e, s) {
 };
 h.fn.atomAttr = function(t, e) {
   return this.each(function() {
-    g(
+    b(
       this,
       e,
       (s) => {
@@ -1531,52 +1542,52 @@ h.fn.atomAttr = function(t, e) {
 };
 h.fn.atomProp = function(t, e) {
   return this.each(function() {
-    g(this, e, (s) => h(this).prop(t, s), `prop.${t}`);
+    b(this, e, (s) => h(this).prop(t, s), `prop.${t}`);
   });
 };
 h.fn.atomShow = function(t) {
   return this.each(function() {
-    g(this, t, (e) => h(this).toggle(!!e), "show");
+    b(this, t, (e) => h(this).toggle(!!e), "show");
   });
 };
 h.fn.atomHide = function(t) {
   return this.each(function() {
-    g(this, t, (e) => h(this).toggle(!e), "hide");
+    b(this, t, (e) => h(this).toggle(!e), "hide");
   });
 };
 h.fn.atomVal = function(t, e = {}) {
   return this.each(function() {
-    const s = h(this), { effect: n, cleanup: i } = je(s, t, e), o = W(n);
-    _.trackEffect(this, o), _.trackCleanup(this, i);
+    const s = h(this), { effect: n, cleanup: i } = He(s, t, e), o = W(n);
+    d.trackEffect(this, o), d.trackCleanup(this, i);
   });
 };
 h.fn.atomChecked = function(t) {
   return this.each(function() {
     const e = h(this), s = Ie(), n = () => {
-      s.phase === "idle" && (t.value = !!e.prop("checked"));
+      s.flags & p.Busy || (t.value = !!e.prop("checked"));
     };
-    e.on("change", n), _.trackCleanup(this, () => e.off("change", n));
+    e.on("change", n), d.trackCleanup(this, () => e.off("change", n));
     const i = W(() => {
-      s.phase = "syncing-to-dom";
+      s.flags |= p.SyncingToDom;
       const o = !!t.value;
-      e.prop("checked", o), E.domUpdated(e, "checked", o), s.phase = "idle";
+      e.prop("checked", o), g.domUpdated(e, "checked", o), s.flags &= ~p.SyncingToDom;
     });
-    _.trackEffect(this, i);
+    d.trackEffect(this, i);
   });
 };
 h.fn.atomOn = function(t, e) {
   return this.each(function() {
     const s = h(this);
-    s.on(t, e), _.trackCleanup(this, () => s.off(t, e));
+    s.on(t, e), d.trackCleanup(this, () => s.off(t, e));
   });
 };
 h.fn.atomUnbind = function() {
   return this.each(function() {
-    _.cleanupTree(this);
+    d.cleanupTree(this);
   });
 };
-function _t(t, e) {
-  g(
+function pt(t, e) {
+  b(
     t.el,
     e,
     (s) => {
@@ -1585,8 +1596,8 @@ function _t(t, e) {
     "text"
   );
 }
-function pt(t, e) {
-  g(
+function Et(t, e) {
+  b(
     t.el,
     e,
     (s) => {
@@ -1595,9 +1606,9 @@ function pt(t, e) {
     "html"
   );
 }
-function Et(t, e) {
+function gt(t, e) {
   for (const s in e)
-    g(
+    b(
       t.el,
       e[s],
       (n) => {
@@ -1606,7 +1617,7 @@ function Et(t, e) {
       `class.${s}`
     );
 }
-function gt(t, e) {
+function bt(t, e) {
   const s = t.el.style;
   for (const n in e) {
     const i = e[n];
@@ -1614,7 +1625,7 @@ function gt(t, e) {
     const o = n.includes("-") ? n.replace(/-./g, (r) => r.charAt(1).toUpperCase()) : n;
     if (Array.isArray(i)) {
       const [r, c] = i;
-      g(
+      b(
         t.el,
         r,
         (u) => {
@@ -1623,7 +1634,7 @@ function gt(t, e) {
         `css.${n}`
       );
     } else
-      g(
+      b(
         t.el,
         i,
         (r) => {
@@ -1633,11 +1644,11 @@ function gt(t, e) {
       );
   }
 }
-function bt(t, e) {
+function mt(t, e) {
   const s = t.el;
   for (const n in e) {
     const i = e[n];
-    g(
+    b(
       s,
       i,
       (o) => {
@@ -1651,10 +1662,10 @@ function bt(t, e) {
     );
   }
 }
-function mt(t, e) {
+function St(t, e) {
   const s = t.el;
   for (const n in e)
-    g(
+    b(
       s,
       e[n],
       (i) => {
@@ -1663,8 +1674,8 @@ function mt(t, e) {
       `prop.${n}`
     );
 }
-function St(t, e) {
-  g(
+function yt(t, e) {
+  b(
     t.el,
     e,
     (s) => {
@@ -1674,7 +1685,7 @@ function St(t, e) {
   );
 }
 function It(t, e) {
-  g(
+  b(
     t.el,
     e,
     (s) => {
@@ -1683,30 +1694,30 @@ function It(t, e) {
     "hide"
   );
 }
-function yt(t, e) {
-  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: o } = je(t.$el, s, n), r = W(i);
-  _.trackEffect(t.el, r), t.trackCleanup(o);
-}
 function Dt(t, e) {
+  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: o } = He(t.$el, s, n), r = W(i);
+  d.trackEffect(t.el, r), t.trackCleanup(o);
+}
+function Ct(t, e) {
   const s = Ie(), n = () => {
-    s.phase === "idle" && (e.value = t.$el.prop("checked"));
+    s.flags & p.Busy || (e.value = t.$el.prop("checked"));
   };
   t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n));
   const i = W(() => {
-    s.phase = "syncing-to-dom";
+    s.flags |= p.SyncingToDom;
     const o = !!e.value;
-    t.$el.prop("checked", o), E.domUpdated(t.$el, "checked", o), s.phase = "idle";
+    t.$el.prop("checked", o), g.domUpdated(t.$el, "checked", o), s.flags &= ~p.SyncingToDom;
   });
-  _.trackEffect(t.el, i);
+  d.trackEffect(t.el, i);
 }
-function Ct(t, e) {
+function Nt(t, e) {
   const s = t.el;
   for (const n in e) {
     const i = e[n];
     if (typeof i != "function") continue;
     const o = i, r = (c) => {
       const u = h.Event(c.type, { originalEvent: c });
-      Se(() => o.call(s, u));
+      ye(() => o.call(s, u));
     };
     s.addEventListener(n, r), t.trackCleanup(() => s.removeEventListener(n, r));
   }
@@ -1716,83 +1727,83 @@ h.fn.atomBind = function(t) {
     const s = {
       $el: h(this),
       el: this,
-      trackCleanup: (n) => _.trackCleanup(this, n)
+      trackCleanup: (n) => d.trackCleanup(this, n)
     };
-    t.text !== void 0 && _t(s, t.text), t.html !== void 0 && pt(s, t.html), t.class && Et(s, t.class), t.css && gt(s, t.css), t.attr && bt(s, t.attr), t.prop && mt(s, t.prop), t.show !== void 0 && St(s, t.show), t.hide !== void 0 && It(s, t.hide), t.val !== void 0 && yt(s, t.val), t.checked !== void 0 && Dt(s, t.checked), t.on && Ct(s, t.on);
+    t.text !== void 0 && pt(s, t.text), t.html !== void 0 && Et(s, t.html), t.class && gt(s, t.class), t.css && bt(s, t.css), t.attr && mt(s, t.attr), t.prop && St(s, t.prop), t.show !== void 0 && yt(s, t.show), t.hide !== void 0 && It(s, t.hide), t.val !== void 0 && Dt(s, t.val), t.checked !== void 0 && Ct(s, t.checked), t.on && Nt(s, t.on);
   });
 };
 h.fn.atomList = function(t, e) {
-  const { key: s, render: n, bind: i, update: o, onAdd: r, onRemove: c, empty: u } = e, a = typeof s == "function" ? s : (d) => d[s];
+  const { key: s, render: n, bind: i, update: o, onAdd: r, onRemove: c, empty: u } = e, a = typeof s == "function" ? s : (_) => _[s];
   return this.each(function() {
-    const d = h(this), P = fe(this), S = /* @__PURE__ */ new Map(), z = /* @__PURE__ */ new Set();
-    let R = [], X = null;
-    const ye = W(() => {
-      const b = t.value, T = b.length;
-      if (T === 0 ? u && !X && (X = h(u).appendTo(d)) : X && (X.remove(), X = null), T === 0 && S.size === 0) {
-        R = [];
+    const _ = h(this), k = _e(this), y = /* @__PURE__ */ new Map(), X = /* @__PURE__ */ new Set();
+    let A = [], q = null;
+    const De = W(() => {
+      const m = t.value, x = m.length;
+      if (x === 0 ? u && !q && (q = h(u).appendTo(_)) : q && (q.remove(), q = null), x === 0 && y.size === 0) {
+        A = [];
         return;
       }
-      E.log("list", `${P} updating with ${T} items`);
-      const k = new Array(T), Z = /* @__PURE__ */ new Set();
-      for (let f = 0; f < T; f++) {
-        const m = b[f], I = a(m, f);
-        E.enabled && Z.has(I) && console.warn(
+      g.log("list", `${k} updating with ${x} items`);
+      const M = new Array(x), Z = /* @__PURE__ */ new Set();
+      for (let f = 0; f < x; f++) {
+        const S = m[f], I = a(S, f);
+        g.enabled && Z.has(I) && console.warn(
           `[atomList] Duplicate key "${I}" at index ${f}. Items with duplicate keys may cause unexpected behavior.`
-        ), k[f] = I, Z.add(I);
+        ), M[f] = I, Z.add(I);
       }
-      for (const [f, m] of S) {
-        if (Z.has(f) || z.has(f)) continue;
+      for (const [f, S] of y) {
+        if (Z.has(f) || X.has(f)) continue;
         const I = () => {
-          m.$el.remove();
-          const y = m.$el[0];
-          y && _.cleanup(y), z.delete(f), E.log("list", `${P} removed item:`, f);
+          S.$el.remove();
+          const D = S.$el[0];
+          D && d.cleanup(D), X.delete(f), g.log("list", `${k} removed item:`, f);
         };
-        if (S.delete(f), z.add(f), c) {
-          const y = c(m.$el);
-          y instanceof Promise ? y.then(I) : I();
+        if (y.delete(f), X.add(f), c) {
+          const D = c(S.$el);
+          D instanceof Promise ? D.then(I) : I();
         } else
           I();
       }
-      if (T === 0) {
-        R = [];
+      if (x === 0) {
+        A = [];
         return;
       }
-      const oe = /* @__PURE__ */ new Map();
-      for (let f = 0; f < R.length; f++) {
-        const m = R[f];
-        m !== void 0 && oe.set(m, f);
+      const re = /* @__PURE__ */ new Map();
+      for (let f = 0; f < A.length; f++) {
+        const S = A[f];
+        S !== void 0 && re.set(S, f);
       }
-      const q = new Int32Array(T);
-      for (let f = 0; f < T; f++) {
-        const m = k[f];
-        q[f] = m !== void 0 ? oe.get(m) ?? -1 : -1;
+      const G = new Int32Array(x);
+      for (let f = 0; f < x; f++) {
+        const S = M[f];
+        G[f] = S !== void 0 ? re.get(S) ?? -1 : -1;
       }
-      const De = ct(q);
-      let de = De.length - 1, w = null;
-      for (let f = T - 1; f >= 0; f--) {
-        const m = k[f], I = b[f], y = S.get(m);
-        if (y) {
-          y.item = I;
-          const G = y.$el[0];
-          if (!G) continue;
-          o && o(y.$el, I, f), de >= 0 && De[de] === f ? (de--, G.nextSibling !== w && (w ? y.$el.insertBefore(w) : y.$el.appendTo(d))) : w ? y.$el.insertBefore(w) : y.$el.appendTo(d), w = G;
+      const Ce = ut(G);
+      let de = Ce.length - 1, L = null;
+      for (let f = x - 1; f >= 0; f--) {
+        const S = M[f], I = m[f], D = y.get(S);
+        if (D) {
+          D.item = I;
+          const ee = D.$el[0];
+          if (!ee) continue;
+          o && o(D.$el, I, f), de >= 0 && Ce[de] === f ? (de--, ee.nextSibling !== L && (L ? D.$el.insertBefore(L) : D.$el.appendTo(_))) : L ? D.$el.insertBefore(L) : D.$el.appendTo(_), L = ee;
         } else {
-          const G = n(I, f), Y = G instanceof Element ? h(G) : h(G);
-          S.set(m, { $el: Y, item: I }), w ? Y.insertBefore(w) : Y.appendTo(d), i && i(Y, I, f), r && r(Y), E.log("list", `${P} added item:`, m), w = Y[0] || null;
+          const ee = n(I, f), Y = h(ee);
+          y.set(S, { $el: Y, item: I }), L ? Y.insertBefore(L) : Y.appendTo(_), i && i(Y, I, f), r && r(Y), g.log("list", `${k} added item:`, S), L = Y[0] || null;
         }
       }
-      R = k;
+      A = M;
     });
-    _.trackEffect(this, ye), _.trackCleanup(this, () => {
-      S.clear(), z.clear(), R = [], X?.remove();
+    d.trackEffect(this, De), d.trackCleanup(this, () => {
+      y.clear(), X.clear(), A = [], q?.remove();
     });
   });
 };
-const ue = /* @__PURE__ */ new WeakMap();
+const he = /* @__PURE__ */ new WeakMap();
 h.fn.atomMount = function(t, e = {}) {
   return this.each(function() {
-    const s = h(this), n = fe(this), i = ue.get(this);
-    i && (E.log("mount", `${n} unmounting existing component`), i()), E.log("mount", `${n} mounting component`);
+    const s = h(this), n = _e(this), i = he.get(this);
+    i && (g.log("mount", `${n} unmounting existing component`), i()), g.log("mount", `${n} mounting component`);
     let o;
     try {
       o = t(s, e);
@@ -1803,40 +1814,40 @@ h.fn.atomMount = function(t, e = {}) {
     let r = !1;
     const c = () => {
       if (!r) {
-        if (r = !0, E.log("mount", `${n} full cleanup`), typeof o == "function")
+        if (r = !0, g.log("mount", `${n} full cleanup`), typeof o == "function")
           try {
             o();
           } catch (u) {
             console.error("[atom-effect-jquery] Cleanup error:", u);
           }
-        _.cleanupTree(this), ue.delete(this);
+        d.cleanupTree(this), he.delete(this);
       }
     };
-    ue.set(this, c), _.trackCleanup(this, c);
+    he.set(this, c), d.trackCleanup(this, c);
   });
 };
 h.fn.atomUnmount = function() {
   return this.each(function() {
-    ue.get(this)?.();
+    he.get(this)?.();
   });
 };
-const te = /* @__PURE__ */ new WeakMap();
-let ve = !1;
-function He() {
-  if (ve) return;
-  ve = !0;
+const se = /* @__PURE__ */ new WeakMap();
+let Ue = !1;
+function $e() {
+  if (Ue) return;
+  Ue = !0;
   const t = h.fn.on, e = h.fn.off, s = h.fn.remove, n = h.fn.empty, i = h.fn.detach;
   h.fn.remove = function(o) {
     return (o ? this.filter(o) : this).each(function() {
-      _.cleanupTree(this), _.markIgnored(this);
+      d.cleanupTree(this), d.markIgnored(this);
     }), s.call(this, o);
   }, h.fn.empty = function() {
     return this.each(function() {
-      _.cleanupDescendants(this);
+      d.cleanupDescendants(this);
     }), n.call(this);
   }, h.fn.detach = function(o) {
     return (o ? this.filter(o) : this).each(function() {
-      _.keep(this);
+      d.keep(this);
     }), i.call(this, o);
   }, h.fn.on = function(...o) {
     let r = -1;
@@ -1848,9 +1859,9 @@ function He() {
     if (r !== -1) {
       const c = o[r];
       let u;
-      te.has(c) ? u = te.get(c) : (u = function(a, ...d) {
-        return Se(() => c.call(this, a, ...d));
-      }, te.set(c, u)), o[r] = u;
+      se.has(c) ? u = se.get(c) : (u = function(a, ..._) {
+        return ye(() => c.call(this, a, ..._));
+      }, se.set(c, u)), o[r] = u;
     }
     return t.apply(this, o);
   }, h.fn.off = function(...o) {
@@ -1862,27 +1873,27 @@ function He() {
       }
     if (r !== -1) {
       const c = o[r];
-      te.has(c) && (o[r] = te.get(c));
+      se.has(c) && (o[r] = se.get(c));
     }
     return e.apply(this, o);
   };
 }
-const Rt = He;
-He();
+const At = $e;
+$e();
 h(() => {
   dt(document.body);
 });
 export {
-  st as atom,
-  Se as batch,
-  it as computed,
-  vt as default,
-  xt as disableAutoCleanup,
+  nt as atom,
+  ye as batch,
+  ot as computed,
+  Ut as default,
+  Rt as disableAutoCleanup,
   W as effect,
   dt as enableAutoCleanup,
-  Rt as enablejQueryBatching,
-  He as enablejQueryOverrides,
-  _ as registry,
-  Pe as untracked
+  At as enablejQueryBatching,
+  $e as enablejQueryOverrides,
+  d as registry,
+  ke as untracked
 };
 //# sourceMappingURL=index.mjs.map