@but212/atom-effect-jquery 0.8.3 → 0.9.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import u from "jquery";
-import { default as Tt } from "jquery";
-const Ve = {
+import { default as xt } from "jquery";
+const Le = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
 }, oe = {
@@ -28,7 +28,7 @@ const Ve = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, V = {
+}, L = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /**
@@ -50,7 +50,7 @@ const Ve = {
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, B = 1073741823, R = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", je = Object.freeze([]);
+}, B = 1073741823, T = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", je = Object.freeze([]);
 class k extends Error {
   /**
    * Creates a new AtomError
@@ -58,8 +58,8 @@ class k extends Error {
    * @param cause - Original error that caused this error
    * @param recoverable - Whether the operation can be retried
    */
-  constructor(e, s = null, n = !0) {
-    super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
+  constructor(e, s = null, i = !0) {
+    super(e), this.name = "AtomError", this.cause = s, this.recoverable = i, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
 class X extends k {
@@ -72,7 +72,7 @@ class X extends k {
     super(e, s, !0), this.name = "ComputedError";
   }
 }
-class M extends k {
+class V extends k {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -92,7 +92,7 @@ class ee extends k {
     super(e, s, !1), this.name = "SchedulerError";
   }
 }
-const m = {
+const y = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -100,10 +100,6 @@ const m = {
    * Error thrown when computed() receives a non-function argument.
    */
   COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function",
-  /**
-   * Error thrown when subscribe() receives an invalid listener.
-   */
-  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function or Subscriber object",
   /**
    * Error thrown when accessing a pending async computed without a default value.
    */
@@ -116,10 +112,6 @@ const m = {
    * Error thrown when an asynchronous computed computation fails.
    */
   COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
-  /**
-   * Error thrown when subscribing to a dependency fails.
-   */
-  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
   // ─────────────────────────────────────────────────────────────────
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
@@ -127,10 +119,6 @@ const m = {
    * Error thrown when atom.subscribe() receives an invalid listener.
    */
   ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function or Subscriber object",
-  /**
-   * Error thrown when the atom subscriber notification process fails.
-   */
-  ATOM_SUBSCRIBER_EXECUTION_FAILED: "Error occurred while executing atom subscribers",
   /**
    * Error logged when an individual subscriber throws during notification.
    * @remarks This error is caught and logged to prevent cascading failures.
@@ -151,26 +139,6 @@ const m = {
    * Error thrown when an effect's cleanup function fails.
    */
   EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
-  // ─────────────────────────────────────────────────────────────────
-  // Debug warnings
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Warning message for large dependency graphs.
-   *
-   * @param count - The number of dependencies detected
-   * @returns Formatted warning message with dependency count
-   *
-   * @example
-   * ```ts
-   * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));
-   * // Output: "Large dependency graph detected: 150 dependencies"
-   * ```
-   */
-  LARGE_DEPENDENCY_GRAPH: (t) => `Large dependency graph detected: ${t} dependencies`,
-  /**
-   * Warning logged when attempting to unsubscribe a non-existent listener.
-   */
-  UNSUBSCRIBE_NON_EXISTENT: "Attempted to unsubscribe a non-existent listener",
   /**
    * Error logged when the onError callback itself throws an error.
    * @remarks This prevents cascading failures from masking the original error.
@@ -186,9 +154,9 @@ function Ce(t, e, s) {
     if (t._visitedEpoch = s, t === e)
       throw new X("Indirect circular dependency detected");
     if (qe(t)) {
-      const n = t.dependencies;
-      for (let i = 0; i < n.length; i++) {
-        const r = n[i];
+      const i = t.dependencies;
+      for (let n = 0; n < i.length; n++) {
+        const r = i[n];
         r && Ce(r, e, s);
       }
     }
@@ -214,8 +182,8 @@ const w = {
   attachDebugInfo(t, e, s) {
     if (!this.enabled)
       return;
-    const n = t;
-    n[he] = `${e}_${s}`, n[Be] = s, n[ae] = e;
+    const i = t;
+    i[he] = `${e}_${s}`, i[Be] = s, i[ae] = e;
   },
   getDebugName(t) {
     if (t != null && he in t)
@@ -248,7 +216,7 @@ class Ne extends ve {
     if (typeof e == "object" && e !== null && "execute" in e)
       return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new k(m.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new k(y.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -265,36 +233,36 @@ class Ne extends ve {
    */
   _notifySubscribers(e, s) {
     this._functionSubscribers.forEachSafe(
-      (n) => n(e, s),
-      (n) => console.error(new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (i) => i(e, s),
+      (i) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     ), this._objectSubscribers.forEachSafe(
-      (n) => n.execute(),
-      (n) => console.error(new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (i) => i.execute(),
+      (i) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     );
   }
 }
 let te = 0;
-function Te() {
-  return te = (te + 1 | 0) & B, te;
+function xe() {
+  return te = te + 1 & B || 1, te;
 }
 function Ge() {
   return te;
 }
-let ne = 0, fe = 0, ie = !1;
-function Se() {
-  return ie ? (R && console.warn(
+let ie = 0, fe = 0, ne = !1;
+function ye() {
+  return ne ? (T && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (ie = !0, ne = ne + 1 & B, fe = 0, !0);
+  ), !1) : (ne = !0, ie = ie + 1 & B, fe = 0, !0);
 }
-function ye() {
-  ie = !1;
+function Se() {
+  ne = !1;
 }
 function Qe() {
-  return ie ? ++fe : 0;
+  return ne ? ++fe : 0;
 }
 class He {
   constructor() {
-    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 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.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = L.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
@@ -315,17 +283,17 @@ class He {
     this.isProcessing = !0;
     const e = this.queue, s = this.queueSize;
     this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, queueMicrotask(() => {
-      const n = Se();
-      this._processJobs(e, s), this.isProcessing = !1, n && ye(), this.queueSize > 0 && !this.isBatching && this.flush();
+      const i = ye();
+      this._processJobs(e, s), this.isProcessing = !1, i && Se(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = Se();
+    const e = ye();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && ye();
+      this.isFlushingSync = !1, e && Se();
     }
   }
   _mergeBatchQueue() {
@@ -359,12 +327,12 @@ class He {
     ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
   }
   _processJobs(e, s) {
-    for (let n = 0; n < s; n++)
+    for (let i = 0; i < s; i++)
       try {
-        e[n]?.();
-      } catch (i) {
+        e[i]?.();
+      } catch (n) {
         console.error(
-          new ee("Error occurred during scheduler execution", i)
+          new ee("Error occurred during scheduler execution", n)
         );
       }
     e.length = 0;
@@ -385,9 +353,9 @@ class He {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < V.MIN_FLUSH_ITERATIONS)
+    if (e < L.MIN_FLUSH_ITERATIONS)
       throw new ee(
-        `Max flush iterations must be at least ${V.MIN_FLUSH_ITERATIONS}`
+        `Max flush iterations must be at least ${L.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
@@ -418,7 +386,7 @@ const q = {
     return this.current;
   }
 };
-function Re(t) {
+function Te(t) {
   if (typeof t != "function")
     throw new k("Untracked callback must be a function");
   const e = q.current;
@@ -451,8 +419,8 @@ class re {
     const s = this.subscribers.indexOf(e);
     if (s === -1)
       return !1;
-    const n = this.subscribers.length - 1;
-    return s !== n && (this.subscribers[s] = this.subscribers[n]), this.subscribers.pop(), !0;
+    const i = this.subscribers.length - 1;
+    return s !== i && (this.subscribers[s] = this.subscribers[i]), this.subscribers.pop(), !0;
   }
   has(e) {
     return this.subscribers ? this.subscribers.indexOf(e) !== -1 : !1;
@@ -465,11 +433,11 @@ class re {
   /** Iterates with error handling to prevent one failure from breaking the chain */
   forEachSafe(e, s) {
     if (this.subscribers)
-      for (let n = 0; n < this.subscribers.length; n++)
+      for (let i = 0; i < this.subscribers.length; i++)
         try {
-          e(this.subscribers[n], n);
-        } catch (i) {
-          s ? s(i) : console.error("[SubscriberManager] Error in subscriber callback:", i);
+          e(this.subscribers[i], i);
+        } catch (n) {
+          s ? s(n) : console.error("[SubscriberManager] Error in subscriber callback:", n);
         }
   }
   get size() {
@@ -487,7 +455,7 @@ class re {
 }
 class de {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = R ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = T ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -495,7 +463,7 @@ class de {
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return R && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return T && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -506,38 +474,38 @@ class de {
   release(e, s) {
     if (!(s && e === s)) {
       if (Object.isFrozen(e)) {
-        R && this.stats && this.stats.rejected.frozen++;
+        T && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        R && this.stats && this.stats.rejected.tooLarge++;
+        T && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        R && this.stats && this.stats.rejected.poolFull++;
+        T && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), R && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), T && this.stats && this.stats.released++;
     }
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!R || !this.stats) return null;
-    const { acquired: e, released: s, rejected: n } = this.stats, i = n.frozen + n.tooLarge + n.poolFull;
+    if (!T || !this.stats) return null;
+    const { acquired: e, released: s, rejected: i } = this.stats, n = i.frozen + i.tooLarge + i.poolFull;
     return {
       acquired: e,
       released: s,
-      rejected: n,
-      leaked: e - s - i,
+      rejected: i,
+      leaked: e - s - n,
       poolSize: this.pool.length
     };
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, R && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, T && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const y = Object.freeze([]), O = Object.freeze([]), D = Object.freeze([]), $ = new de(), j = new de(), A = new de();
+const S = Object.freeze([]), O = Object.freeze([]), D = Object.freeze([]), M = new de(), j = new de(), A = new de();
 function le(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
 }
@@ -549,7 +517,7 @@ function De(t) {
   }
   return le(t) && "invalidate" in t && typeof t.invalidate == "function";
 }
-function Ue(t) {
+function Re(t) {
   return t != null && typeof t.then == "function";
 }
 function Je(t) {
@@ -564,7 +532,7 @@ function Ke(t) {
 function We(t) {
   return Je(t) && typeof t.execute == "function";
 }
-function xe(t, e, s, n) {
+function Ue(t, e, s, i) {
   if (e) {
     if (Ye(e)) {
       e.addDependency(t);
@@ -574,27 +542,27 @@ function xe(t, e, s, n) {
       s.add(e);
       return;
     }
-    We(e) && n.add(e);
+    We(e) && i.add(e);
   }
 }
-function Ze(t, e, s, n) {
-  if (e !== y && s !== O)
+function Ze(t, e, s, i) {
+  if (e !== S && s !== O)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o && (o._tempUnsub = s[r]);
     }
-  const i = j.acquire();
-  i.length = t.length;
+  const n = j.acquire();
+  n.length = t.length;
   for (let r = 0; r < t.length; r++) {
     const o = t[r];
-    o && (o._tempUnsub ? (i[r] = o._tempUnsub, o._tempUnsub = void 0) : (w.checkCircular(o, n), i[r] = o.subscribe(n)));
+    o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (w.checkCircular(o, i), n[r] = o.subscribe(i)));
   }
-  if (e !== y)
+  if (e !== S)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
     }
-  return s !== O && j.release(s), i;
+  return s !== O && j.release(s), n;
 }
 class et extends Ne {
   constructor(e, s) {
@@ -625,7 +593,7 @@ class et extends Ne {
     this.version = this.version + 1 & B, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(s);
   }
   _track(e) {
-    xe(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
+    Ue(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
   }
   _scheduleNotification(e) {
     this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !Y.isBatching ? this._flushNotifications() : Y.schedule(this._notifyTask);
@@ -651,15 +619,15 @@ class et extends Ne {
 function tt(t, e = {}) {
   return new et(t, e.sync ?? !1);
 }
-function G(t, e, s) {
+function H(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 k)
     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);
+  const i = t instanceof Error ? t.message : String(t), n = t instanceof Error ? t : null;
+  return new e(`Unexpected error (${s}): ${i}`, n);
 }
 const Oe = d.RESOLVED | d.PENDING | d.REJECTED, ce = Array(Oe + 1).fill(oe.IDLE);
 ce[d.RESOLVED] = oe.RESOLVED;
@@ -668,21 +636,21 @@ ce[d.REJECTED] = oe.REJECTED;
 class Ae extends Ne {
   constructor(e, s = {}) {
     if (typeof e != "function")
-      throw new X(m.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : ge, this._hasDefaultValue = this._defaultValue !== ge, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new re(), this._objectSubscribersStore = new re(), this._dependencies = y, this._dependencyVersions = D, this._unsubscribes = O, this._notifyJob = () => {
+      throw new X(y.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : ge, this._hasDefaultValue = this._defaultValue !== ge, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new re(), this._objectSubscribersStore = new re(), this._dependencies = S, this._dependencyVersions = D, this._unsubscribes = O, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
-        (n) => n(),
-        (n) => console.error(n)
+        (i) => i(),
+        (i) => console.error(i)
       ), this._objectSubscribersStore.forEachSafe(
-        (n) => n.execute(),
-        (n) => console.error(n)
+        (i) => i.execute(),
+        (i) => console.error(i)
       );
     }, this._trackable = Object.assign(() => this._markDirty(), {
-      addDependency: (n) => {
+      addDependency: (i) => {
       }
     }), w.attachDebugInfo(this, "computed", this.id), w.enabled) {
-      const n = this;
-      n.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, n.isDirty = () => this._isDirty(), n.dependencies = this._dependencies, n.stateFlags = this._getFlagsAsString();
+      const i = this;
+      i.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, i.isDirty = () => this._isDirty(), i.dependencies = this._dependencies, i.stateFlags = this._getFlagsAsString();
     }
     if (s.lazy === !1)
       try {
@@ -726,10 +694,10 @@ class Ae extends Ne {
       return this._cachedErrors;
     const s = /* @__PURE__ */ new Set();
     this._error && s.add(this._error);
-    for (let n = 0; n < this._dependencies.length; n++) {
-      const i = this._dependencies[n];
-      if (i && "errors" in i) {
-        const r = i.errors;
+    for (let i = 0; i < this._dependencies.length; i++) {
+      const n = this._dependencies[i];
+      if (n && "errors" in n) {
+        const r = n.errors;
         for (let o = 0; o < r.length; o++) {
           const c = r[o];
           c && s.add(c);
@@ -758,7 +726,7 @@ class Ae extends Ne {
       }
       j.release(this._unsubscribes), this._unsubscribes = O;
     }
-    this._dependencies !== y && ($.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._dependencies !== S && (M.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   // State flag operations
   _isDirty() {
@@ -817,32 +785,32 @@ class Ae extends Ne {
     const e = this._prepareComputationContext();
     let s = !1;
     try {
-      const n = q.run(this._trackable, this._fn);
-      this._commitDependencies(e), s = !0, Ue(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
-    } catch (n) {
+      const i = q.run(this._trackable, this._fn);
+      this._commitDependencies(e), s = !0, Re(i) ? this._handleAsyncComputation(i) : this._handleSyncResult(i);
+    } catch (i) {
       if (!s)
         try {
           this._commitDependencies(e), s = !0;
-        } catch (i) {
-          this._handleComputationError(i);
+        } catch (n) {
+          this._handleComputationError(n);
         }
-      this._handleComputationError(n);
+      this._handleComputationError(i);
     } finally {
       this._cleanupContext(e, s), this._setRecomputing(!1);
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = $.acquire(), i = A.acquire(), r = Te(), o = { depCount: 0 }, c = (_) => {
-      _._lastSeenEpoch !== r && (_._lastSeenEpoch = r, o.depCount < n.length ? (n[o.depCount] = _, i[o.depCount] = _.version) : (n.push(_), i.push(_.version)), o.depCount++);
+    const e = this._dependencies, s = this._dependencyVersions, i = M.acquire(), n = A.acquire(), r = xe(), o = { depCount: 0 }, c = (_) => {
+      _._lastSeenEpoch !== r && (_._lastSeenEpoch = r, o.depCount < i.length ? (i[o.depCount] = _, n[o.depCount] = _.version) : (i.push(_), n.push(_.version)), o.depCount++);
     }, f = this._trackable.addDependency;
-    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: f, state: o };
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: i, nextVersions: n, originalAdd: f, state: o };
   }
   _commitDependencies(e) {
-    const { nextDeps: s, nextVersions: n, state: i, prevDeps: r } = e;
-    s.length = i.depCount, n.length = i.depCount, this._unsubscribes = Ze(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
+    const { nextDeps: s, nextVersions: i, state: n, prevDeps: r } = e;
+    s.length = n.depCount, i.length = n.depCount, this._unsubscribes = Ze(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = i;
   }
   _cleanupContext(e, s) {
-    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== y && $.release(e.prevDeps), e.prevVersions !== D && A.release(e.prevVersions)) : ($.release(e.nextDeps), A.release(e.nextVersions));
+    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== S && M.release(e.prevDeps), e.prevVersions !== D && A.release(e.prevVersions)) : (M.release(e.nextDeps), A.release(e.nextVersions));
   }
   _handleSyncResult(e) {
     const s = !this._isResolved() || !this._equal(this._value, e);
@@ -851,10 +819,10 @@ class Ae extends Ne {
   _handleAsyncComputation(e) {
     this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
     const s = this._promiseId;
-    e.then((n) => {
-      s === this._promiseId && this._handleAsyncResolution(n);
-    }).catch((n) => {
-      s === this._promiseId && this._handleAsyncRejection(n);
+    e.then((i) => {
+      s === this._promiseId && this._handleAsyncResolution(i);
+    }).catch((i) => {
+      s === this._promiseId && this._handleAsyncRejection(i);
     });
   }
   _handleAsyncResolution(e) {
@@ -862,29 +830,29 @@ class Ae extends Ne {
     this.version = this.version + Number(s) & B, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
   }
   _handleAsyncRejection(e) {
-    const s = G(e, X, m.COMPUTED_ASYNC_COMPUTATION_FAILED), n = !this._isRejected();
-    if (this.version = this.version + Number(n) & B, this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const s = H(e, X, y.COMPUTED_ASYNC_COMPUTATION_FAILED), i = !this._isRejected();
+    if (this.version = this.version + Number(i) & B, this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
-      } catch (i) {
-        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+      } catch (n) {
+        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     this._notifyJob();
   }
   _handleComputationError(e) {
-    const s = G(e, X, m.COMPUTED_COMPUTATION_FAILED);
+    const s = H(e, X, y.COMPUTED_COMPUTATION_FAILED);
     if (this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
-      } catch (n) {
-        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+      } catch (i) {
+        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw s;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new X(m.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new X(y.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -899,7 +867,7 @@ class Ae extends Ne {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    xe(
+    Ue(
       this,
       q.getCurrent(),
       this._functionSubscribersStore,
@@ -911,7 +879,7 @@ Object.freeze(Ae.prototype);
 function st(t, e = {}) {
   return new Ae(t, e);
 }
-class nt extends ve {
+class it extends ve {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -920,56 +888,58 @@ class nt extends ve {
   constructor(e, s = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new M(m.EFFECT_MUST_BE_FUNCTION);
+        throw new V(y.EFFECT_MUST_BE_FUNCTION);
       this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
         if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== O) {
           for (let n = 0; n < this._unsubscribes.length; n++) {
-            const i = this._unsubscribes[n];
-            i && i();
+            const r = this._unsubscribes[n];
+            r && r();
           }
           j.release(this._unsubscribes), this._unsubscribes = O;
         }
-        this._dependencies !== y && ($.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D);
+        this._dependencies !== S && (M.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D);
       }
     }, this.addDependency = (n) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        const i = this._currentEpoch;
-        if (n._lastSeenEpoch === i) return;
-        n._lastSeenEpoch = i, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
+        const r = this._currentEpoch;
+        if (n._lastSeenEpoch === r) return;
+        n._lastSeenEpoch = r, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
       const n = this._prepareEffectContext();
-      let i = !1;
+      let r = !1;
       try {
-        const r = q.run(this, this._fn);
-        this._commitEffect(n), i = !0, this._checkLoopWarnings(), Ue(r) ? r.then((o) => {
-          !this.isDisposed && typeof o == "function" && (this._cleanup = o);
-        }).catch((o) => {
-          console.error(G(o, M, m.EFFECT_EXECUTION_FAILED));
-        }) : this._cleanup = typeof r == "function" ? r : null;
-      } catch (r) {
-        i = !0, console.error(G(r, M, m.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        const o = q.run(this, this._fn);
+        this._commitEffect(n), r = !0, this._checkLoopWarnings(), Re(o) ? o.then((c) => {
+          !this.isDisposed && typeof c == "function" && (this._cleanup = c);
+        }).catch((c) => {
+          this._handleExecutionError(c);
+        }) : this._cleanup = typeof o == "function" ? o : null;
+      } catch (o) {
+        r = !0, this._handleExecutionError(o), this._cleanup = null;
       } finally {
-        this._cleanupEffect(n, i), this._setExecuting(!1);
+        this._cleanupEffect(n, r), this._setExecuting(!1);
       }
-    }, 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._cleanup = null, this._dependencies = y, this._dependencyVersions = D, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = R ? [] : null, this._executionCount = 0, w.attachDebugInfo(this, "effect", this.id);
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? L.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? L.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._cleanup = null, this._dependencies = S, this._dependencyVersions = D, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = s.onError ?? null, this._historyPtr = 0;
+    const i = Number.isFinite(this._maxExecutions);
+    this._historyCapacity = i ? Math.min(this._maxExecutions + 1, L.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = T && i && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, w.attachDebugInfo(this, "effect", this.id);
   }
   /**
    * Prepares the execution context by acquiring pools and setting up epoch.
    * @returns The prepared EffectContext.
    */
   _prepareEffectContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = $.acquire(), r = A.acquire(), o = j.acquire(), c = Te();
-    if (e !== y && n !== O)
+    const e = this._dependencies, s = this._dependencyVersions, i = this._unsubscribes, n = M.acquire(), r = A.acquire(), o = j.acquire(), c = xe();
+    if (e !== S && i !== O)
       for (let f = 0; f < e.length; f++) {
         const _ = e[f];
-        _ && (_._tempUnsub = n[f]);
+        _ && (_._tempUnsub = i[f]);
       }
-    return this._nextDeps = i, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: s, prevUnsubs: n, nextDeps: i, nextVersions: r, nextUnsubs: o };
+    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: s, prevUnsubs: i, nextDeps: n, nextVersions: r, nextUnsubs: o };
   }
   /**
    * Commits the tracked dependencies as the current active dependencies.
@@ -986,22 +956,22 @@ class nt extends ve {
    */
   _cleanupEffect(e, s) {
     if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, s) {
-      if (e.prevDeps !== y) {
-        for (let n = 0; n < e.prevDeps.length; n++) {
-          const i = e.prevDeps[n];
-          i?._tempUnsub && (i._tempUnsub(), i._tempUnsub = void 0);
+      if (e.prevDeps !== S) {
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
+          n?._tempUnsub && (n._tempUnsub(), n._tempUnsub = void 0);
         }
-        $.release(e.prevDeps);
+        M.release(e.prevDeps);
       }
       e.prevUnsubs !== O && j.release(e.prevUnsubs), e.prevVersions !== D && A.release(e.prevVersions);
     } else {
-      $.release(e.nextDeps), A.release(e.nextVersions);
-      for (let n = 0; n < e.nextUnsubs.length; n++)
-        e.nextUnsubs[n]?.();
-      if (j.release(e.nextUnsubs), e.prevDeps !== y)
-        for (let n = 0; n < e.prevDeps.length; n++) {
-          const i = e.prevDeps[n];
-          i && (i._tempUnsub = void 0);
+      M.release(e.nextDeps), A.release(e.nextVersions);
+      for (let i = 0; i < e.nextUnsubs.length; i++)
+        e.nextUnsubs[i]?.();
+      if (j.release(e.nextUnsubs), e.prevDeps !== S)
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
+          n && (n._tempUnsub = void 0);
         }
     }
   }
@@ -1016,7 +986,7 @@ class nt extends ve {
       });
       this._nextUnsubs && this._nextUnsubs.push(s);
     } catch (s) {
-      console.error(G(s, M, m.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(H(s, V, y.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1053,7 +1023,7 @@ class nt extends ve {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(G(e, M, m.EFFECT_CLEANUP_FAILED));
+        console.error(H(e, V, y.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1063,28 +1033,21 @@ class nt extends ve {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== ne && (this._lastFlushEpoch = ne, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Qe() > V.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
-      const e = Date.now();
-      this._history.push(e), this._history.length > V.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
-    }
-  }
-  _checkTimestampLoop(e) {
-    const s = this._history;
-    if (!s || this._maxExecutions <= 0) return;
-    const n = e - Ve.ONE_SECOND_MS;
-    let i = 0;
-    for (let r = s.length - 1; r >= 0 && !(s[r] < n); r--)
-      i++;
-    if (i > this._maxExecutions) {
-      const r = new M(
-        `Effect executed ${i} times within 1 second. Infinite loop suspected`
-      );
-      if (this.dispose(), console.error(r), R)
-        throw r;
+    if (this._lastFlushEpoch !== ie && (this._lastFlushEpoch = ie, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Qe() > L.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+      const e = Date.now(), s = this._historyPtr, i = this._historyCapacity;
+      this._history[s] = e;
+      const n = (s + 1) % i, r = this._history[n] ?? 0;
+      if (this._historyPtr = n, r > 0 && e - r < Le.ONE_SECOND_MS) {
+        const o = new V(
+          `Effect executed ${i} times within 1 second. Infinite loop suspected`
+        );
+        if (this.dispose(), console.error(o), this._onError && this._onError(o), T)
+          throw o;
+      }
     }
   }
   _throwInfiniteLoopError(e) {
-    const s = new M(
+    const s = new V(
       `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${fe}`
     );
     throw this.dispose(), console.error(s), s;
@@ -1094,14 +1057,14 @@ class nt extends ve {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === y || this._dependencyVersions === D)
+    if (this._dependencies === S || this._dependencyVersions === D)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const s = this._dependencies[e];
       if (s) {
         if ("value" in s)
           try {
-            Re(() => s.value);
+            Te(() => s.value);
           } catch {
             return !0;
           }
@@ -1111,6 +1074,14 @@ class nt extends ve {
     }
     return !1;
   }
+  /**
+   * Handles errors occurring during effect execution.
+   * Wraps the error, logs it to console, and calls onError callback if provided.
+   */
+  _handleExecutionError(e) {
+    const s = H(e, V, y.EFFECT_EXECUTION_FAILED);
+    console.error(s), this._onError && this._onError(s);
+  }
   /**
    * Checks for potential infinite loops where an effect modifies its own dependencies.
    * Only active if trackModifications is enabled and debug is on.
@@ -1119,10 +1090,10 @@ class nt extends ve {
     if (this._trackModifications && w.enabled) {
       const e = this._dependencies;
       for (let s = 0; s < e.length; s++) {
-        const n = e[s];
-        n && n._modifiedAtEpoch === this._currentEpoch && w.warn(
+        const i = e[s];
+        i && i._modifiedAtEpoch === this._currentEpoch && w.warn(
           !0,
-          `Effect is reading a dependency (${w.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${w.getDebugName(i) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
@@ -1130,8 +1101,8 @@ class nt extends ve {
 }
 function I(t, e = {}) {
   if (typeof t != "function")
-    throw new M(m.EFFECT_MUST_BE_FUNCTION);
-  const s = new nt(t, e);
+    throw new V(y.EFFECT_MUST_BE_FUNCTION);
+  const s = new it(t, e);
   return s.execute(), s;
 }
 function b(t) {
@@ -1150,7 +1121,7 @@ function ue(t) {
   }
   return e.tagName.toLowerCase();
 }
-function it() {
+function nt() {
   if (typeof window < "u") {
     const t = window.__ATOM_DEBUG__;
     if (typeof t == "boolean")
@@ -1163,7 +1134,7 @@ function it() {
   }
   return !1;
 }
-let P = it();
+let P = nt();
 const h = {
   get enabled() {
     return P;
@@ -1182,8 +1153,8 @@ const h = {
    */
   domUpdated(t, e, s) {
     if (!P) return;
-    const n = ue(t);
-    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), rt(t);
+    const i = ue(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${i}.${e} =`, s), rt(t);
   },
   cleanup(t) {
     P && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
@@ -1195,8 +1166,8 @@ const h = {
 function rt(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";
-  clearTimeout(t.data(s)), clearTimeout(t.data(n)), t.data(i) || t.data(i, {
+  const s = "atom_debug_timer", i = "atom_debug_cleanup_timer", n = "atom_debug_org_style";
+  clearTimeout(t.data(s)), clearTimeout(t.data(i)), t.data(n) || t.data(n, {
     outline: t.css("outline"),
     outlineOffset: t.css("outline-offset"),
     transition: t.css("transition")
@@ -1207,16 +1178,16 @@ function rt(t) {
     // Remove transition for instant feedback on update
   });
   const r = setTimeout(() => {
-    const o = t.data(i);
+    const o = t.data(n);
     t.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
       t.css({
         outline: o?.outline || "",
         "outline-offset": o?.outlineOffset || ""
       });
       const c = setTimeout(() => {
-        t.css("transition", o?.transition || ""), t.removeData(s), t.removeData(n), t.removeData(i);
+        t.css("transition", o?.transition || ""), t.removeData(s), t.removeData(i), t.removeData(n);
       }, 500);
-      t.data(n, c);
+      t.data(i, c);
     });
   }, 100);
   t.data(s, r);
@@ -1242,7 +1213,7 @@ u.extend({
   computed: st,
   effect: I,
   batch: z,
-  untracked: Re,
+  untracked: Te,
   isAtom: le,
   isComputed: De,
   isReactive: (t) => le(t) || De(t),
@@ -1253,8 +1224,8 @@ function ke() {
 }
 function Fe(t, e, s = {}) {
   const {
-    debounce: n,
-    event: i = "input",
+    debounce: i,
+    event: n = "input",
     parse: r = (p) => p,
     format: o = (p) => String(p ?? "")
   } = s, c = ke(), f = () => {
@@ -1265,28 +1236,28 @@ function Fe(t, e, s = {}) {
   t.on("compositionstart", f), t.on("compositionend", _);
   const C = () => {
     c.hasFocus = !0;
-  }, S = () => {
+  }, m = () => {
     c.hasFocus = !1;
     const p = o(e.value);
     t.val() !== p && t.val(p);
   };
-  t.on("focus", C), t.on("blur", S);
+  t.on("focus", C), t.on("blur", m);
   const F = () => {
     c.phase === "idle" && (c.phase = "syncing-to-atom", z(() => {
       e.value = r(t.val());
     }), c.phase = "idle");
   }, v = () => {
-    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(F, n)) : F());
+    c.phase === "idle" && (i ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(F, i)) : F());
   };
-  return t.on(i, v), t.on("change", v), { effect: () => {
-    const p = o(e.value), L = t.val();
-    if (L !== p) {
-      if (c.hasFocus && r(L) === e.value)
+  return t.on(n, v), t.on("change", v), { effect: () => {
+    const p = o(e.value), $ = t.val();
+    if ($ !== p) {
+      if (c.hasFocus && r($) === e.value)
         return;
       c.phase = "syncing-to-dom", t.val(p), h.domUpdated(t, "val", p), c.phase = "idle";
     }
   }, cleanup: () => {
-    t.off(i, v), t.off("change", v), t.off("compositionstart", f), t.off("compositionend", _), t.off("focus", C), t.off("blur", S), c.timeoutId && clearTimeout(c.timeoutId);
+    t.off(n, v), t.off("change", v), t.off("compositionstart", f), t.off("compositionend", _), t.off("focus", C), t.off("blur", m), c.timeoutId && clearTimeout(c.timeoutId);
   } };
 }
 class ut {
@@ -1311,15 +1282,15 @@ class ut {
    * Registers an Effect to be disposed later.
    */
   trackEffect(e, s) {
-    const n = this.effects.get(e) || [];
-    n.push(s), this.effects.set(e, n), this.boundElements.add(e);
+    const i = this.effects.get(e) || [];
+    i.push(s), this.effects.set(e, i), this.boundElements.add(e);
   }
   /**
    * Registers a custom cleanup function (e.g., event listener removal).
    */
   trackCleanup(e, s) {
-    const n = this.cleanups.get(e) || [];
-    n.push(s), this.cleanups.set(e, n), this.boundElements.add(e);
+    const i = this.cleanups.get(e) || [];
+    i.push(s), this.cleanups.set(e, i), this.boundElements.add(e);
   }
   /**
    * Checks if an element has bindings (Fast check).
@@ -1336,17 +1307,17 @@ class ut {
     if (!this.boundElements.has(e)) return;
     h.cleanup(ue(e));
     const s = this.effects.get(e);
-    s && (this.effects.delete(e), s.forEach((i) => {
+    s && (this.effects.delete(e), s.forEach((n) => {
       try {
-        i.dispose();
+        n.dispose();
       } catch (r) {
         h.warn("Effect dispose error:", r);
       }
     }));
-    const n = this.cleanups.get(e);
-    n && (this.cleanups.delete(e), n.forEach((i) => {
+    const i = this.cleanups.get(e);
+    i && (this.cleanups.delete(e), i.forEach((n) => {
       try {
-        i();
+        n();
       } catch (r) {
         h.warn("Cleanup error:", r);
       }
@@ -1357,8 +1328,8 @@ class ut {
    * - Essential for deep removal (empty(), remove(), etc.).
    */
   cleanupTree(e) {
-    e.querySelectorAll("*").forEach((n) => {
-      this.boundElements.has(n) && this.cleanup(n);
+    e.querySelectorAll("*").forEach((i) => {
+      this.boundElements.has(i) && this.cleanup(i);
     }), this.cleanup(e);
   }
 }
@@ -1367,8 +1338,8 @@ let J = null;
 function ht(t = document.body) {
   J || (J = new MutationObserver((e) => {
     for (const s of e)
-      s.removedNodes.forEach((n) => {
-        l.isKept(n) || n.isConnected || n.nodeType === 1 && l.cleanupTree(n);
+      s.removedNodes.forEach((i) => {
+        l.isKept(i) || i.isConnected || i.nodeType === 1 && l.cleanupTree(i);
       });
   }), J.observe(t, { childList: !0, subtree: !0 }));
 }
@@ -1379,14 +1350,14 @@ u.fn.atomText = function(t, e) {
   return this.each(function() {
     const s = u(this);
     if (b(t)) {
-      const n = I(() => {
-        const i = E(t), r = e ? e(i) : String(i ?? "");
+      const i = I(() => {
+        const n = E(t), r = e ? e(n) : String(n ?? "");
         s.text(r), h.domUpdated(s, "text", r);
       });
-      l.trackEffect(this, n);
+      l.trackEffect(this, i);
     } else {
-      const n = e ? e(t) : String(t ?? "");
-      s.text(n);
+      const i = e ? e(t) : String(t ?? "");
+      s.text(i);
     }
   });
 };
@@ -1395,8 +1366,8 @@ u.fn.atomHtml = function(t) {
     const e = u(this);
     if (b(t)) {
       const s = I(() => {
-        const n = String(E(t) ?? "");
-        e.html(n), h.domUpdated(e, "html", n);
+        const i = String(E(t) ?? "");
+        e.html(i), h.domUpdated(e, "html", i);
       });
       l.trackEffect(this, s);
     } else
@@ -1407,49 +1378,49 @@ u.fn.atomClass = function(t, e) {
   return this.each(function() {
     const s = u(this);
     if (b(e)) {
-      const n = I(() => {
-        const i = !!E(e);
-        s.toggleClass(t, i), h.domUpdated(s, `class.${t}`, i);
+      const i = I(() => {
+        const n = !!E(e);
+        s.toggleClass(t, n), h.domUpdated(s, `class.${t}`, n);
       });
-      l.trackEffect(this, n);
+      l.trackEffect(this, i);
     } else
       s.toggleClass(t, !!e);
   });
 };
 u.fn.atomCss = function(t, e, s) {
   return this.each(function() {
-    const n = u(this);
+    const i = u(this);
     if (b(e)) {
-      const i = I(() => {
+      const n = I(() => {
         const r = E(e), o = s ? `${r}${s}` : r;
-        n.css(t, o), h.domUpdated(n, `css.${t}`, o);
+        i.css(t, o), h.domUpdated(i, `css.${t}`, o);
       });
-      l.trackEffect(this, i);
+      l.trackEffect(this, n);
     } else
-      n.css(t, s ? `${e}${s}` : e);
+      i.css(t, s ? `${e}${s}` : e);
   });
 };
 u.fn.atomAttr = function(t, e) {
   return this.each(function() {
-    const s = u(this), n = (i) => {
-      i == null || i === !1 ? s.removeAttr(t) : i === !0 ? s.attr(t, t) : s.attr(t, String(i)), h.domUpdated(s, `attr.${t}`, i);
+    const s = u(this), i = (n) => {
+      n == null || n === !1 ? s.removeAttr(t) : n === !0 ? s.attr(t, t) : s.attr(t, String(n)), h.domUpdated(s, `attr.${t}`, n);
     };
     if (b(e)) {
-      const i = I(() => n(E(e)));
-      l.trackEffect(this, i);
+      const n = I(() => i(E(e)));
+      l.trackEffect(this, n);
     } else
-      n(e);
+      i(e);
   });
 };
 u.fn.atomProp = function(t, e) {
   return this.each(function() {
     const s = u(this);
     if (b(e)) {
-      const n = I(() => {
-        const i = E(e);
-        s.prop(t, i), h.domUpdated(s, `prop.${t}`, i);
+      const i = I(() => {
+        const n = E(e);
+        s.prop(t, n), h.domUpdated(s, `prop.${t}`, n);
       });
-      l.trackEffect(this, n);
+      l.trackEffect(this, i);
     } else
       s.prop(t, e);
   });
@@ -1459,8 +1430,8 @@ u.fn.atomShow = function(t) {
     const e = u(this);
     if (b(t)) {
       const s = I(() => {
-        const n = !!E(t);
-        e.toggle(n), h.domUpdated(e, "show", n);
+        const i = !!E(t);
+        e.toggle(i), h.domUpdated(e, "show", i);
       });
       l.trackEffect(this, s);
     } else
@@ -1472,8 +1443,8 @@ u.fn.atomHide = function(t) {
     const e = u(this);
     if (b(t)) {
       const s = I(() => {
-        const n = !E(t);
-        e.toggle(n), h.domUpdated(e, "hide", !n);
+        const i = !E(t);
+        e.toggle(i), h.domUpdated(e, "hide", !i);
       });
       l.trackEffect(this, s);
     } else
@@ -1482,32 +1453,32 @@ u.fn.atomHide = function(t) {
 };
 u.fn.atomVal = function(t, e = {}) {
   return this.each(function() {
-    const { effect: s, cleanup: n } = Fe(u(this), t, e), i = I(s);
-    l.trackEffect(this, i), l.trackCleanup(this, n);
+    const { effect: s, cleanup: i } = Fe(u(this), t, e), n = I(s);
+    l.trackEffect(this, n), l.trackCleanup(this, i);
   });
 };
 u.fn.atomChecked = function(t) {
   return this.each(function() {
     const e = u(this);
     let s = !1;
-    const n = () => {
+    const i = () => {
       s || z(() => {
         t.value = e.prop("checked");
       });
     };
-    e.on("change", n), l.trackCleanup(this, () => e.off("change", n));
-    const i = I(() => {
+    e.on("change", i), l.trackCleanup(this, () => e.off("change", i));
+    const n = I(() => {
       s = !0, e.prop("checked", t.value), h.domUpdated(e, "checked", t.value), s = !1;
     });
-    l.trackEffect(this, i);
+    l.trackEffect(this, n);
   });
 };
 u.fn.atomOn = function(t, e) {
   return this.each(function() {
-    const s = u(this), n = function(i) {
-      z(() => e.call(this, i));
+    const s = u(this), i = function(n) {
+      z(() => e.call(this, n));
     };
-    s.on(t, n), l.trackCleanup(this, () => s.off(t, n));
+    s.on(t, i), l.trackCleanup(this, () => s.off(t, i));
   });
 };
 u.fn.atomUnbind = function() {
@@ -1528,39 +1499,39 @@ function lt(t, e) {
   }) : t.$el.html(String(e ?? ""));
 }
 function ft(t, e) {
-  for (const [s, n] of Object.entries(e))
-    b(n) ? t.effects.push(() => {
-      const i = !!E(n);
-      t.$el.toggleClass(s, i), h.domUpdated(t.$el, `class.${s}`, i);
-    }) : t.$el.toggleClass(s, !!n);
+  for (const [s, i] of Object.entries(e))
+    b(i) ? t.effects.push(() => {
+      const n = !!E(i);
+      t.$el.toggleClass(s, n), h.domUpdated(t.$el, `class.${s}`, n);
+    }) : t.$el.toggleClass(s, !!i);
 }
 function dt(t, e) {
-  for (const [s, n] of Object.entries(e))
-    if (Array.isArray(n)) {
-      const [i, r] = n;
-      b(i) ? t.effects.push(() => {
-        const o = `${E(i)}${r}`;
+  for (const [s, i] of Object.entries(e))
+    if (Array.isArray(i)) {
+      const [n, r] = i;
+      b(n) ? t.effects.push(() => {
+        const o = `${E(n)}${r}`;
         t.$el.css(s, o), h.domUpdated(t.$el, `css.${s}`, o);
-      }) : t.$el.css(s, `${i}${r}`);
-    } else b(n) ? t.effects.push(() => {
-      const i = E(n);
-      t.$el.css(s, i), h.domUpdated(t.$el, `css.${s}`, i);
-    }) : t.$el.css(s, n);
+      }) : t.$el.css(s, `${n}${r}`);
+    } else b(i) ? t.effects.push(() => {
+      const n = E(i);
+      t.$el.css(s, n), h.domUpdated(t.$el, `css.${s}`, n);
+    }) : t.$el.css(s, i);
 }
 function _t(t, e) {
-  for (const [s, n] of Object.entries(e)) {
-    const i = (r) => {
+  for (const [s, i] of Object.entries(e)) {
+    const n = (r) => {
       r == null || r === !1 ? t.$el.removeAttr(s) : r === !0 ? t.$el.attr(s, s) : t.$el.attr(s, String(r)), h.domUpdated(t.$el, `attr.${s}`, r);
     };
-    b(n) ? t.effects.push(() => i(E(n))) : i(n);
+    b(i) ? t.effects.push(() => n(E(i))) : n(i);
   }
 }
 function pt(t, e) {
-  for (const [s, n] of Object.entries(e))
-    b(n) ? t.effects.push(() => {
-      const i = E(n);
-      t.$el.prop(s, i), h.domUpdated(t.$el, `prop.${s}`, i);
-    }) : t.$el.prop(s, n);
+  for (const [s, i] of Object.entries(e))
+    b(i) ? t.effects.push(() => {
+      const n = E(i);
+      t.$el.prop(s, n), h.domUpdated(t.$el, `prop.${s}`, n);
+    }) : t.$el.prop(s, i);
 }
 function bt(t, e) {
   b(e) ? t.effects.push(() => {
@@ -1575,57 +1546,57 @@ function Et(t, e) {
   }) : t.$el.toggle(!e);
 }
 function gt(t, e) {
-  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = Fe(t.$el, s, n);
-  t.effects.push(i), t.trackCleanup(r);
+  const s = Array.isArray(e) ? e[0] : e, i = Array.isArray(e) ? e[1] : {}, { effect: n, cleanup: r } = Fe(t.$el, s, i);
+  t.effects.push(n), t.trackCleanup(r);
 }
 function mt(t, e) {
-  const s = ke(), n = () => {
+  const s = ke(), i = () => {
     s.phase === "idle" && z(() => {
       e.value = t.$el.prop("checked");
     });
   };
-  t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n)), t.effects.push(() => {
+  t.$el.on("change", i), t.trackCleanup(() => t.$el.off("change", i)), t.effects.push(() => {
     s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), h.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
   });
 }
-function St(t, e) {
-  for (const [s, n] of Object.entries(e)) {
-    const i = function(r) {
-      z(() => n.call(this, r));
+function yt(t, e) {
+  for (const [s, i] of Object.entries(e)) {
+    const n = function(r) {
+      z(() => i.call(this, r));
     };
-    t.$el.on(s, i), t.trackCleanup(() => t.$el.off(s, i));
+    t.$el.on(s, n), t.trackCleanup(() => t.$el.off(s, n));
   }
 }
 u.fn.atomBind = function(t) {
   return this.each(function() {
-    const e = u(this), s = [], n = {
+    const e = u(this), s = [], i = {
       $el: e,
       el: this,
       effects: s,
-      trackCleanup: (i) => l.trackCleanup(this, i)
+      trackCleanup: (n) => l.trackCleanup(this, n)
     };
-    t.text !== void 0 && at(n, t.text), t.html !== void 0 && lt(n, t.html), t.class && ft(n, t.class), t.css && dt(n, t.css), t.attr && _t(n, t.attr), t.prop && pt(n, t.prop), t.show !== void 0 && bt(n, t.show), t.hide !== void 0 && Et(n, t.hide), t.val !== void 0 && gt(n, t.val), t.checked !== void 0 && mt(n, t.checked), t.on && St(n, t.on), s.forEach((i) => {
-      const r = I(i);
+    t.text !== void 0 && at(i, t.text), t.html !== void 0 && lt(i, t.html), t.class && ft(i, t.class), t.css && dt(i, t.css), t.attr && _t(i, t.attr), t.prop && pt(i, t.prop), t.show !== void 0 && bt(i, t.show), t.hide !== void 0 && Et(i, t.hide), t.val !== void 0 && gt(i, t.val), t.checked !== void 0 && mt(i, t.checked), t.on && yt(i, t.on), s.forEach((n) => {
+      const r = I(n);
       l.trackEffect(this, r);
     });
   });
 };
-function yt(t) {
+function St(t) {
   if (t.length === 0) return [];
   const e = t.slice(), s = [0];
-  let n, i, r, o;
+  let i, n, r, o;
   const c = t.length;
-  for (n = 0; n < c; n++) {
-    const C = t[n];
+  for (i = 0; i < c; i++) {
+    const C = t[i];
     if (C !== -1) {
-      const S = s[s.length - 1];
-      if (t[S] < C) {
-        e[n] = S, s.push(n);
+      const m = s[s.length - 1];
+      if (t[m] < C) {
+        e[i] = m, s.push(i);
         continue;
       }
-      for (i = 0, r = s.length - 1; i < r; )
-        o = (i + r) / 2 | 0, t[s[o]] < C ? i = o + 1 : r = o;
-      C < t[s[i]] && (i > 0 && (e[n] = s[i - 1]), s[i] = n);
+      for (n = 0, r = s.length - 1; n < r; )
+        o = (n + r) / 2 | 0, t[s[o]] < C ? n = o + 1 : r = o;
+      C < t[s[n]] && (n > 0 && (e[i] = s[n - 1]), s[n] = i);
     }
   }
   let f = s.length, _ = s[f - 1];
@@ -1635,72 +1606,72 @@ function yt(t) {
 }
 u.fn.atomList = function(t, e) {
   return this.each(function() {
-    const s = u(this), n = ue(this), { key: i, render: r, bind: o, onAdd: c, onRemove: f, empty: _ } = e, C = typeof i == "function" ? i : (p) => p[i], S = /* @__PURE__ */ new Map();
+    const s = u(this), i = ue(this), { key: n, render: r, bind: o, onAdd: c, onRemove: f, empty: _ } = e, C = typeof n == "function" ? n : (p) => p[n], m = /* @__PURE__ */ new Map();
     let F = [], v = null;
     const K = /* @__PURE__ */ new Set(), _e = I(() => {
-      const p = t.value, L = [], pe = /* @__PURE__ */ new Set();
+      const p = t.value, $ = [], pe = /* @__PURE__ */ new Set();
       for (let a = 0; a < p.length; a++) {
-        const g = p[a], T = C(g, a);
-        L.push(T), pe.add(T);
+        const g = p[a], x = C(g, a);
+        $.push(x), pe.add(x);
       }
-      if (h.log("list", `${n} updating with ${p.length} items`), p.length === 0 && _) {
+      if (h.log("list", `${i} updating with ${p.length} items`), p.length === 0 && _) {
         v || (v = u(_), s.append(v));
-        for (const [, a] of S) {
+        for (const [, a] of m) {
           a.$el.remove();
           const g = a.$el[0];
           g && l.cleanup(g);
         }
-        S.clear(), F = [];
+        m.clear(), F = [];
         return;
       } else v && (v.remove(), v = null);
-      for (const [a, g] of S)
+      for (const [a, g] of m)
         if (!pe.has(a)) {
           if (K.has(a)) continue;
-          const T = () => {
+          const x = () => {
             g.$el.remove();
             const W = g.$el[0];
-            W && l.cleanup(W), K.delete(a), h.log("list", `${n} removed item:`, a);
+            W && l.cleanup(W), K.delete(a), h.log("list", `${i} removed item:`, a);
           };
-          S.delete(a), K.add(a), f ? Promise.resolve(f(g.$el)).then(T) : T();
+          m.delete(a), K.add(a), f ? Promise.resolve(f(g.$el)).then(x) : x();
         }
       const be = /* @__PURE__ */ new Map();
       F.forEach((a, g) => be.set(a, g));
-      const $e = L.map((a) => be.get(a) ?? -1), Le = yt($e), Pe = new Set(Le);
-      let U = null;
+      const $e = $.map((a) => be.get(a) ?? -1), Pe = St($e), Ve = new Set(Pe);
+      let R = null;
       for (let a = p.length - 1; a >= 0; a--) {
-        const g = L[a], T = p[a], W = Pe.has(a);
-        if (S.has(g)) {
-          const N = S.get(g);
+        const g = $[a], x = p[a], W = Ve.has(a);
+        if (m.has(g)) {
+          const N = m.get(g);
           if (!N) continue;
-          N.item = T;
-          const x = N.$el[0];
-          if (!x) continue;
-          if (e.update && e.update(N.$el, T, a), !W)
-            U ? N.$el.insertBefore(U) : N.$el.appendTo(s);
+          N.item = x;
+          const U = N.$el[0];
+          if (!U) continue;
+          if (e.update && e.update(N.$el, x, a), !W)
+            R ? N.$el.insertBefore(R) : N.$el.appendTo(s);
           else {
-            const Q = x.nextSibling;
-            U && Q !== U ? N.$el.insertBefore(U) : !U && Q && N.$el.appendTo(s);
+            const G = U.nextSibling;
+            R && G !== R ? N.$el.insertBefore(R) : !R && G && N.$el.appendTo(s);
           }
-          U = x;
+          R = U;
         } else {
-          const N = r(T, a), x = N instanceof Element ? u(N) : u(N);
-          S.set(g, { $el: x, item: T }), U ? x.insertBefore(U) : x.appendTo(s), o && o(x, T, a), c && c(x), h.log("list", `${n} added item:`, g);
-          const Q = x[0];
-          Q && (U = Q);
+          const N = r(x, a), U = N instanceof Element ? u(N) : u(N);
+          m.set(g, { $el: U, item: x }), R ? U.insertBefore(R) : U.appendTo(s), o && o(U, x, a), c && c(U), h.log("list", `${i} added item:`, g);
+          const G = U[0];
+          G && (R = G);
         }
       }
-      F = L;
+      F = $;
     });
     l.trackEffect(this, _e), l.trackCleanup(this, () => {
-      S.clear(), F = [], v?.remove();
+      m.clear(), F = [], v?.remove();
     });
   });
 };
 const se = /* @__PURE__ */ new WeakMap();
 u.fn.atomMount = function(t, e = {}) {
   return this.each(function() {
-    const s = u(this), n = ue(this), i = se.get(this);
-    i && (h.log("mount", `${n} unmounting existing component`), i()), h.log("mount", `${n} mounting component`);
+    const s = u(this), i = ue(this), n = se.get(this);
+    n && (h.log("mount", `${i} unmounting existing component`), n()), h.log("mount", `${i} mounting component`);
     let r;
     try {
       r = t(s, e);
@@ -1711,7 +1682,7 @@ u.fn.atomMount = function(t, e = {}) {
     let o = !1;
     const c = () => {
       if (!o) {
-        if (o = !0, h.log("mount", `${n} full cleanup`), typeof r == "function")
+        if (o = !0, h.log("mount", `${i} full cleanup`), typeof r == "function")
           try {
             r();
           } catch {
@@ -1727,12 +1698,12 @@ u.fn.atomUnmount = function() {
     se.get(this)?.();
   });
 };
-const H = /* @__PURE__ */ new WeakMap();
+const Q = /* @__PURE__ */ new WeakMap();
 let Ie = !1;
 function Me() {
   if (Ie) return;
   Ie = !0;
-  const t = u.fn.on, e = u.fn.off, s = u.fn.remove, n = u.fn.empty, i = u.fn.detach;
+  const t = u.fn.on, e = u.fn.off, s = u.fn.remove, i = u.fn.empty, n = u.fn.detach;
   u.fn.remove = function(r) {
     return (r ? this.filter(r) : this).each(function() {
       l.cleanupTree(this);
@@ -1740,11 +1711,11 @@ function Me() {
   }, u.fn.empty = function() {
     return this.each(function() {
       this.querySelectorAll("*").forEach((o) => l.cleanup(o));
-    }), n.call(this);
+    }), i.call(this);
   }, u.fn.detach = function(r) {
     return (r ? this.filter(r) : this).each(function() {
       l.keep(this);
-    }), i.call(this, r);
+    }), n.call(this, r);
   }, u.fn.on = function(...r) {
     let o = -1;
     for (let c = r.length - 1; c >= 0; c--)
@@ -1755,12 +1726,12 @@ function Me() {
     if (o !== -1) {
       const c = r[o];
       let f;
-      H.has(c) ? f = H.get(c) : (f = function(..._) {
+      Q.has(c) ? f = Q.get(c) : (f = function(..._) {
         let C;
         return z(() => {
           C = c.apply(this, _);
         }), C;
-      }, H.set(c, f)), r[o] = f;
+      }, Q.set(c, f)), r[o] = f;
     }
     return t.apply(this, r);
   }, u.fn.off = function(...r) {
@@ -1772,7 +1743,7 @@ function Me() {
       }
     if (o !== -1) {
       const c = r[o];
-      H.has(c) && (r[o] = H.get(c));
+      Q.has(c) && (r[o] = Q.get(c));
     }
     return e.apply(this, r);
   };
@@ -1786,13 +1757,13 @@ export {
   tt as atom,
   z as batch,
   st as computed,
-  Tt as default,
+  xt as default,
   It as disableAutoCleanup,
   I as effect,
   ht as enableAutoCleanup,
   Ct as enablejQueryBatching,
   Me as enablejQueryOverrides,
   l as registry,
-  Re as untracked
+  Te as untracked
 };
 //# sourceMappingURL=index.mjs.map