@but212/atom-effect-jquery 0.14.0 → 0.15.0

package/dist/index.mjs

@@ -1,22 +1,22 @@
 import h from "jquery";
-import { default as wt } from "jquery";
+import { default as vt } from "jquery";
 const He = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, ue = {
+}, ce = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, v = {
+}, A = {
   DISPOSED: 1,
   HAS_FN_SUBS: 2,
   HAS_OBJ_SUBS: 4
-}, N = {
-  ...v,
+}, R = {
+  ...A,
   EXECUTING: 8
 }, l = {
-  ...v,
+  ...A,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -24,8 +24,8 @@ const He = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, F = {
-  ...v,
+}, v = {
+  ...A,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
 }, V = {
@@ -47,54 +47,54 @@ const He = {
   MIN_FLUSH_ITERATIONS: 10,
   /** Threshold for shrinking the batch queue to assist GC */
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, De = {
+}, Ce = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, A = 1073741823, Xe = 20, de = 1 << Xe - 1, x = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", qe = Object.freeze([]);
-class k extends Error {
+}, H = 1073741823, D = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ze = Object.freeze([]);
+class L extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
    * @param cause - Original error that caused this error
    * @param recoverable - Whether the operation can be retried
    */
-  constructor(e, t = null, n = !0) {
-    super(e), this.name = "AtomError", this.cause = t, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
+  constructor(e, s = null, n = !0) {
+    super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class G extends k {
+class M extends L {
   /**
    * Creates a new ComputedError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, t = null) {
-    super(e, t, !0), this.name = "ComputedError";
+  constructor(e, s = null) {
+    super(e, s, !0), this.name = "ComputedError";
   }
 }
-class Q extends k {
+class Y extends L {
   /**
    * Creates a new EffectError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, t = null) {
-    super(e, t, !1), this.name = "EffectError";
+  constructor(e, s = null) {
+    super(e, s, !1), this.name = "EffectError";
   }
 }
-class ne extends k {
+class se extends L {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, t = null) {
-    super(e, t, !1), this.name = "SchedulerError";
+  constructor(e, s = null) {
+    super(e, s, !1), this.name = "SchedulerError";
   }
 }
-const m = {
+const p = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -102,6 +102,10 @@ 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.
    */
@@ -114,6 +118,14 @@ const m = {
    * Error thrown when an asynchronous computed computation fails.
    */
   COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
+  /**
+   * Error thrown when a circular dependency is detected during computation.
+   */
+  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected during computation",
+  /**
+   * Error thrown when subscribing to a dependency fails.
+   */
+  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
   // ─────────────────────────────────────────────────────────────────
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
@@ -121,6 +133,10 @@ 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.
@@ -141,75 +157,99 @@ const m = {
    * Error thrown when an effect's cleanup function fails.
    */
   EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
+  /**
+   * Error thrown when attempting to run a disposed effect.
+   */
+  EFFECT_DISPOSED: "Cannot run a disposed effect",
+  // ─────────────────────────────────────────────────────────────────
+  // 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.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, fe = /* @__PURE__ */ Symbol("debugName"), Qe = /* @__PURE__ */ Symbol("id"), _e = /* @__PURE__ */ Symbol("type"), Ce = /* @__PURE__ */ Symbol("noDefaultValue");
-function Ge(s) {
-  return "dependencies" in s && Array.isArray(s.dependencies);
+}, fe = /* @__PURE__ */ Symbol("debugName"), Xe = /* @__PURE__ */ Symbol("id"), de = /* @__PURE__ */ Symbol("type"), Ne = /* @__PURE__ */ Symbol("noDefaultValue");
+function qe(t) {
+  return "dependencies" in t && Array.isArray(t.dependencies);
 }
-let Ne = 0;
-function Re(s, e, t) {
-  if (s._visitedEpoch !== t) {
-    if (s._visitedEpoch = t, s === e)
-      throw new G("Indirect circular dependency detected");
-    if (Ge(s)) {
-      const n = s.dependencies;
+let Te = 0;
+function Ue(t, e, s) {
+  if (t._visitedEpoch !== s) {
+    if (t._visitedEpoch = s, t === e)
+      throw new M("Indirect circular dependency detected");
+    if (qe(t)) {
+      const n = t.dependencies;
       for (let i = 0; i < n.length; i++) {
         const o = n[i];
-        o && Re(o, e, t);
+        o && Ue(o, e, s);
       }
     }
   }
 }
-const O = {
+const U = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: De.MAX_DEPENDENCIES,
-  warnInfiniteLoop: De.WARN_INFINITE_LOOP,
-  warn(s, e) {
-    this.enabled && s && console.warn(`[Atom Effect] ${e}`);
+  maxDependencies: Ce.MAX_DEPENDENCIES,
+  warnInfiniteLoop: Ce.WARN_INFINITE_LOOP,
+  warn(t, e) {
+    this.enabled && t && console.warn(`[Atom Effect] ${e}`);
   },
   /**
    * Checks for circular dependencies.
    * Direct check runs always; indirect check only in dev mode.
    * @throws {ComputedError} When circular dependency detected
    */
-  checkCircular(s, e) {
-    if (s === e)
-      throw new G("Direct circular dependency detected");
-    this.enabled && (Ne++, Re(s, e, Ne));
+  checkCircular(t, e) {
+    if (t === e)
+      throw new M("Direct circular dependency detected");
+    this.enabled && (Te++, Ue(t, e, Te));
   },
-  attachDebugInfo(s, e, t) {
+  attachDebugInfo(t, e, s) {
     if (!this.enabled)
       return;
-    const n = s;
-    n[fe] = `${e}_${t}`, n[Qe] = t, n[_e] = e;
+    const n = t;
+    n[fe] = `${e}_${s}`, n[Xe] = s, n[de] = e;
   },
-  getDebugName(s) {
-    if (s != null && fe in s)
-      return s[fe];
+  getDebugName(t) {
+    if (t != null && fe in t)
+      return t[fe];
   },
-  getDebugType(s) {
-    if (s != null && _e in s)
-      return s[_e];
+  getDebugType(t) {
+    if (t != null && de in t)
+      return t[de];
   }
 };
-let Ye = 1;
-const Je = () => Ye++;
-class Ue {
+let Ge = 1;
+const Ye = () => Ge++;
+class we {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = Je() & A, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = Ye() & H, this._tempUnsub = void 0;
   }
   /**
    * Calculates the logical distance (shift) between current and cached version.
    */
   getShift(e) {
-    return this.version - e & A;
+    return this.version - e & H;
   }
 }
-class we extends Ue {
+class Fe extends we {
   /**
    * Subscribes a listener function or Subscriber object to value changes.
    */
@@ -218,11 +258,11 @@ class we extends Ue {
       return this._addSubscriber(
         this._fnSubs,
         e,
-        v.HAS_FN_SUBS
+        A.HAS_FN_SUBS
       );
     if (e !== null && typeof e == "object" && "execute" in e)
-      return this._addSubscriber(this._objSubs, e, v.HAS_OBJ_SUBS);
-    throw new k(m.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      return this._addSubscriber(this._objSubs, e, A.HAS_OBJ_SUBS);
+    throw new L(p.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
   }
   /**
    * Gets the total number of active subscribers.
@@ -234,15 +274,18 @@ class we extends Ue {
    * Adds a subscriber to the specified subscription list and returns an unsubscribe function.
    * Uses swap-and-pop for efficient removals.
    */
-  _addSubscriber(e, t, n) {
-    if (e.indexOf(t) !== -1) return () => {
-    };
-    e.push(t), this.flags |= n;
+  _addSubscriber(e, s, n) {
+    if (e.indexOf(s) !== -1)
+      return D && console.warn(
+        "Attempted to subscribe the same listener twice. Ignoring duplicate subscription."
+      ), () => {
+      };
+    e.push(s), this.flags |= n;
     let i = !1;
     return () => {
       if (i) return;
       i = !0;
-      const o = e.indexOf(t);
+      const o = e.indexOf(s);
       if (o !== -1) {
         const r = e.pop();
         o < e.length && (e[o] = r), this.flags &= ~(e.length === 0 ? n : 0);
@@ -252,24 +295,24 @@ class we extends Ue {
   /**
    * Notifies all subscribers of a change.
    */
-  _notifySubscribers(e, t) {
-    const n = this.flags, i = v.HAS_FN_SUBS | v.HAS_OBJ_SUBS;
+  _notifySubscribers(e, s) {
+    const n = this.flags, i = A.HAS_FN_SUBS | A.HAS_OBJ_SUBS;
     if (n & i) {
-      if (n & v.HAS_FN_SUBS) {
+      if (n & A.HAS_FN_SUBS) {
         const o = this._fnSubs;
         for (let r = 0, c = o.length; r < c; r++) {
           const u = o[r];
           if (u)
             try {
-              u(e, t);
+              u(e, s);
             } catch (a) {
               console.error(
-                new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+                new L(p.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
               );
             }
         }
       }
-      if (n & v.HAS_OBJ_SUBS) {
+      if (n & A.HAS_OBJ_SUBS) {
         const o = this._objSubs;
         for (let r = 0, c = o.length; r < c; r++) {
           const u = o[r];
@@ -278,7 +321,7 @@ class we extends Ue {
               u.execute();
             } catch (a) {
               console.error(
-                new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+                new L(p.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
               );
             }
         }
@@ -286,59 +329,59 @@ class we extends Ue {
     }
   }
 }
-class Ke {
+class Qe {
   constructor() {
-    this.acquired = 0, this.released = 0, this.rejected = new We();
+    this.acquired = 0, this.released = 0, this.rejected = new Je();
   }
 }
-class We {
+class Je {
   constructor() {
     this.frozen = 0, this.tooLarge = 0, this.poolFull = 0;
   }
 }
-class ge {
+class Ee {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = x ? new Ke() : null;
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = D ? new Qe() : null;
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
     const e = this.stats;
-    return x && e && e.acquired++, this.pool.pop() ?? [];
+    return D && e && e.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
    * Clears the array before storing it.
    */
-  release(e, t) {
-    if (t && e === t || Object.isFrozen(e)) {
+  release(e, s) {
+    if (s && e === s || Object.isFrozen(e)) {
       const c = this.stats;
-      x && c && e !== t && c.rejected.frozen++;
+      D && 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;
-      x && c && (n > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
+      D && c && (n > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
       return;
     }
     e.length = 0, i.push(e);
     const r = this.stats;
-    x && r && r.released++;
+    D && r && r.released++;
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
     const e = this.stats;
-    if (!x || !e) return null;
-    const { acquired: t, released: n, rejected: i } = e, o = i.frozen + i.tooLarge + i.poolFull;
+    if (!D || !e) return null;
+    const { acquired: s, released: n, rejected: i } = e, o = i.frozen + i.tooLarge + i.poolFull;
     return {
-      acquired: t,
+      acquired: s,
       released: n,
       rejected: {
         frozen: i.frozen,
         tooLarge: i.tooLarge,
         poolFull: i.poolFull
       },
-      leaked: t - n - o,
+      leaked: s - n - o,
       poolSize: this.pool.length
     };
   }
@@ -346,76 +389,71 @@ class ge {
   reset() {
     this.pool.length = 0;
     const e = this.stats;
-    x && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
+    D && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
   }
 }
-const I = Object.freeze([]), B = Object.freeze([]), T = Object.freeze([]), j = new ge(), Y = new ge(), L = new ge();
-function M(s, e, t, n) {
+const C = Object.freeze([]), j = Object.freeze([]), x = Object.freeze([]), $ = new Ee(), Q = new Ee(), F = new Ee();
+function B(t, e, s, n) {
   if (e != null) {
     if ((typeof e == "object" || typeof e == "function") && typeof e.addDependency == "function") {
-      e.addDependency(s);
+      e.addDependency(t);
       return;
     }
     if (typeof e == "function") {
       const i = e;
-      t.indexOf(i) === -1 && (t.push(i), s.flags |= v.HAS_FN_SUBS);
+      s.indexOf(i) === -1 && (s.push(i), t.flags |= A.HAS_FN_SUBS);
       return;
     }
-    typeof e == "object" && typeof e.execute == "function" && n.indexOf(e) === -1 && (n.push(e), s.flags |= v.HAS_OBJ_SUBS);
+    typeof e == "object" && typeof e.execute == "function" && n.indexOf(e) === -1 && (n.push(e), t.flags |= A.HAS_OBJ_SUBS);
   }
 }
-function Te(s, e, t, n) {
-  const i = s.length, o = e.length, r = e !== I && o > 0;
+function xe(t, e, s, n) {
+  const i = t.length, o = e.length, r = e !== C && o > 0;
   if (r)
     for (let u = 0; u < o; u++) {
       const a = e[u];
-      a && (a._tempUnsub = t[u]);
+      a && (a._tempUnsub = s[u]);
     }
-  const c = Y.acquire();
+  const c = Q.acquire();
   c.length = i;
   for (let u = 0; u < i; u++) {
-    const a = s[u];
+    const a = t[u];
     if (!a) continue;
-    const _ = a._tempUnsub;
-    _ ? (c[u] = _, a._tempUnsub = void 0) : (O.checkCircular(a, n), c[u] = a.subscribe(n));
+    const d = a._tempUnsub;
+    d ? (c[u] = d, a._tempUnsub = void 0) : (U.checkCircular(a, n), c[u] = a.subscribe(n));
   }
   if (r)
     for (let u = 0; u < o; u++) {
       const a = e[u];
       if (a) {
-        const _ = a._tempUnsub;
-        _ && (_(), a._tempUnsub = void 0);
+        const d = a._tempUnsub;
+        d && (d(), a._tempUnsub = void 0);
       }
     }
-  return t !== B && Y.release(t), c;
+  return s !== j && Q.release(s), c;
 }
-let oe = 0;
-function Fe() {
-  return oe = oe + 1 & A || 1, oe;
+let ie = 0;
+function Le() {
+  return ie = ie + 1 & H || 1, ie;
 }
-function Ze() {
-  return oe;
+function Ke() {
+  return ie;
 }
-let pe = 0, be = 0, ce = !1;
-function ve() {
-  return ce ? (x && console.warn(
+let _e = 0, ge = 0, re = !1;
+function Oe() {
+  return re ? (D && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (ce = !0, pe = pe + 1 & A, be = 0, !0);
+  ), !1) : (re = !0, _e = _e + 1 & H || 1, ge = 0, !0);
 }
-function xe() {
-  ce = !1;
+function Re() {
+  re = !1;
 }
-function et() {
-  return ce ? ++be : 0;
+function We() {
+  return re ? ++ge : 0;
 }
-class tt {
+class Ze {
   constructor() {
-    this._queueBuffers = [
-      [[], []],
-      // Normal [0][0], [0][1]
-      [[], []]
-      // Urgent [1][0], [1][1]
-    ], this._bufferIndices = new Uint8Array(2), this._sizes = new Uint32Array(2), this._activeQueues = [this._queueBuffers[0][0], this._queueBuffers[1][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 = V.MAX_FLUSH_ITERATIONS;
   }
   /**
    * Returns the current operational phase of the scheduler.
@@ -423,57 +461,37 @@ class tt {
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
-  /** Current number of pending normal jobs. */
+  /** Current number of pending jobs. */
   get queueSize() {
-    return this._sizes[0];
-  }
-  /** Current number of pending urgent jobs. */
-  get urgentQueueSize() {
-    return this._sizes[1];
+    return this._size;
   }
   /**
-   * Schedules a task for execution with optional priority based on phase shift.
+   * Schedules a task for execution.
    */
-  schedule(e, t) {
-    if (typeof e != "function")
-      throw new ne("Scheduler callback must be a function");
-    const n = this._epoch;
-    if (e._nextEpoch === n) return;
-    if (e._nextEpoch = n, this.isBatching || this.isFlushingSync) {
-      this.batchQueue[this.batchQueueSize++] = e;
-      return;
+  schedule(e) {
+    if (D && typeof e != "function")
+      throw new se("Scheduler callback must be a function");
+    const s = this._epoch;
+    if (e._nextEpoch !== s) {
+      if (e._nextEpoch = s, this.isBatching || this.isFlushingSync) {
+        this.batchQueue[this.batchQueueSize++] = e;
+        return;
+      }
+      this._queueBuffer[this._bufferIndex][this._size++] = e, this.isProcessing || this.flush();
     }
-    const i = this._calculateUrgency(e, t);
-    this._activeQueues[i][this._sizes[i]++] = e, this.isProcessing || this.flush();
-  }
-  /**
-   * Calculates urgency flag using branchless bit manipulation.
-   *
-   * Logic:
-   * 1. Calculate the 'shift' (rotation distance) from the cached version.
-   * 2. Compare against PHASE_THRESHOLD (180° rotation equivalent).
-   * 3. Use (N >>> 31) to extract the sign bit in O(1) time.
-   *
-   * @returns 1 if urgent (shift >= PHASE_THRESHOLD), 0 otherwise.
-   */
-  _calculateUrgency(e, t) {
-    if (!t || e._cachedVersion === void 0)
-      return 0;
-    const n = t.getShift(e._cachedVersion);
-    return de - 1 - n >>> 31 & 1;
   }
   /**
-   * Schedules a microtask-based flush of the queues.
+   * Schedules a microtask-based flush of the queue.
    * Coalesces multiple schedule calls into a single microtask execution.
    */
   flush() {
-    this.isProcessing || this._sizes[0] === 0 && this._sizes[1] === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+    this.isProcessing || this._size === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
-        if (this._sizes[0] === 0 && this._sizes[1] === 0) return;
-        const e = ve();
-        this._drainQueue(), e && xe();
+        if (this._size === 0) return;
+        const e = Oe();
+        this._drainQueue(), e && Re();
       } finally {
-        this.isProcessing = !1, (this._sizes[0] > 0 || this._sizes[1] > 0) && !this.isBatching && this.flush();
+        this.isProcessing = !1, this._size > 0 && !this.isBatching && this.flush();
       }
     }));
   }
@@ -483,57 +501,57 @@ class tt {
    */
   flushSync() {
     this.isFlushingSync = !0;
-    const e = ve();
+    const e = Oe();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && xe();
+      this.isFlushingSync = !1, e && Re();
     }
   }
   /**
-   * Merges jobs from the batching queue into the primary normal queue.
-   * Increments the epoch/uses provided epoch to ensure deduplication.
+   * Merges jobs from the batching queue into the primary queue.
+   * Increments the epoch to ensure deduplication.
    */
   _mergeBatchQueue() {
     const e = this.batchQueueSize;
     if (e === 0) return;
-    const t = ++this._epoch, n = this.batchQueue, i = this._activeQueues[0];
-    let o = this._sizes[0];
+    const s = ++this._epoch, n = this.batchQueue, i = this._queueBuffer[this._bufferIndex];
+    let o = this._size;
     for (let r = 0; r < e; r++) {
       const c = n[r];
-      c._nextEpoch !== t && (c._nextEpoch = t, i[o++] = c);
+      c._nextEpoch !== s && (c._nextEpoch = s, i[o++] = c);
     }
-    this._sizes[0] = o, this.batchQueueSize = 0, n.length > V.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
+    this._size = o, this.batchQueueSize = 0, n.length > V.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
   }
   _drainQueue() {
     let e = 0;
-    const t = this.maxFlushIterations;
-    for (; this._sizes[1] > 0 || this._sizes[0] > 0; ) {
-      if (++e > t) {
+    const s = this.maxFlushIterations;
+    for (; this._size > 0; ) {
+      if (++e > s) {
         this._handleFlushOverflow();
         return;
       }
-      this._sizes[1] > 0 && this._processQueue(1), this._sizes[0] > 0 && this._processQueue(0), this._mergeBatchQueue();
+      this._processQueue(), this._mergeBatchQueue();
     }
   }
-  _processQueue(e) {
-    const t = this._queueBuffers[e], n = this._bufferIndices[e], i = t[n], o = this._sizes[e], r = n ^ 1;
-    this._bufferIndices[e] = r, this._activeQueues[e] = t[r], this._sizes[e] = 0, this._epoch++, this._processJobs(i, o);
+  _processQueue() {
+    const e = this._bufferIndex, s = this._queueBuffer[e], n = this._size, i = e ^ 1;
+    this._bufferIndex = i, this._size = 0, this._epoch++, this._processJobs(s, n);
   }
   _handleFlushOverflow() {
     console.error(
-      new ne(
+      new se(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
-    ), this._sizes[0] = 0, this._activeQueues[0].length = 0, this._sizes[1] = 0, this._activeQueues[1].length = 0, this.batchQueueSize = 0;
+    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this.batchQueueSize = 0;
   }
-  _processJobs(e, t) {
-    for (let n = 0; n < t; n++)
+  _processJobs(e, s) {
+    for (let n = 0; n < s; n++)
       try {
         e[n]();
       } catch (i) {
         console.error(
-          new ne("Error occurred during scheduler execution", i)
+          new se("Error occurred during scheduler execution", i)
         );
       }
     e.length = 0;
@@ -542,18 +560,22 @@ class tt {
     this.batchDepth++, this.isBatching = !0;
   }
   endBatch() {
-    this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
+    if (this.batchDepth === 0) {
+      D && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      return;
+    }
+    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
   }
   setMaxFlushIterations(e) {
     if (e < V.MIN_FLUSH_ITERATIONS)
-      throw new ne(
+      throw new se(
         `Max flush iterations must be at least ${V.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const te = new tt();
-class st {
+const ee = new Ze();
+class et {
   constructor() {
     this.current = null;
   }
@@ -564,11 +586,11 @@ class st {
    * @param listener - The tracking listener to associate with the current execution.
    * @param fn - The function to execute.
    */
-  run(e, t) {
+  run(e, s) {
     const n = this.current;
     this.current = e;
     try {
-      return t();
+      return s();
     } finally {
       this.current = n;
     }
@@ -580,59 +602,60 @@ class st {
     return this.current;
   }
 }
-const y = new st();
-function Le(s) {
-  if (typeof s != "function")
-    throw new k("Untracked callback must be a function");
+const y = new et();
+function Pe(t) {
+  if (typeof t != "function")
+    throw new L("Untracked callback must be a function");
   const e = y.current;
   y.current = null;
   try {
-    return s();
+    return t();
   } finally {
     y.current = e;
   }
 }
-class nt extends we {
-  constructor(e, t) {
-    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], t && (this.flags |= F.SYNC), O.attachDebugInfo(this, "atom", this.id);
+class tt 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);
   }
   /**
    * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
     const e = y.current;
-    return e && M(this, e, this._fnSubs, this._objSubs), this._value;
+    return e && B(this, e, this._fnSubs, this._objSubs), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
    */
   set value(e) {
-    const t = this._value;
-    if (Object.is(t, e)) return;
-    this._value = e, this.version = this.version + 1 & A;
-    const n = this.flags, i = F.HAS_FN_SUBS | F.HAS_OBJ_SUBS;
-    n & i && this._scheduleNotification(t);
+    const s = this._value;
+    if (Object.is(s, e)) return;
+    this._value = e, this.version = this.version + 1 & H;
+    const n = this.flags, i = v.HAS_FN_SUBS | v.HAS_OBJ_SUBS;
+    n & i && this._scheduleNotification(s);
   }
   /**
    * Schedules or flushes notifications based on sync mode and batching state.
    */
   _scheduleNotification(e) {
-    let t = this.flags;
-    if (t & F.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = t |= F.NOTIFICATION_SCHEDULED), t & F.SYNC && !te.isBatching) {
+    let s = this.flags;
+    if (s & v.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = s |= v.NOTIFICATION_SCHEDULED), s & v.SYNC && !ee.isBatching) {
       this._flushNotifications();
       return;
     }
     let n = this._notifyTask;
-    n || (n = this._notifyTask = () => this._flushNotifications()), te.schedule(n);
+    n || (n = this._notifyTask = () => this._flushNotifications()), ee.schedule(n);
   }
   /**
    * Flushes scheduled notifications and resets state for the next cycle.
    */
   _flushNotifications() {
-    if (!(this.flags & F.NOTIFICATION_SCHEDULED))
+    const e = this.flags;
+    if (!(e & v.NOTIFICATION_SCHEDULED) || e & v.DISPOSED)
       return;
-    const e = this._pendingOldValue, t = this._value;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(t, e);
+    const s = this._pendingOldValue, n = this._value;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(n, s);
   }
   /**
    * Returns the current value without registering it as a dependency.
@@ -644,43 +667,43 @@ class nt extends we {
    * Disposes of the atom and releases all subscribers and tasks.
    */
   dispose() {
-    this.flags & F.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= F.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & v.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= v.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function it(s, e = {}) {
-  return new nt(s, e.sync ?? !1);
+function st(t, e = {}) {
+  return new tt(t, e.sync ?? !1);
 }
-function Z(s, e, t) {
-  if (s instanceof TypeError)
-    return new e(`Type error (${t}): ${s.message}`, s);
-  if (s instanceof ReferenceError)
-    return new e(`Reference error (${t}): ${s.message}`, s);
-  if (s instanceof k)
-    return s;
-  const n = s instanceof Error ? s.message : String(s), i = s instanceof Error ? s : null;
-  return new e(`Unexpected error (${t}): ${n}`, i);
+function W(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)
+    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 Ee(s) {
-  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
+function pe(t) {
+  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
 }
-function Ae(s) {
-  if (O.enabled && (s == null || typeof s == "object")) {
-    const e = O.getDebugType(s);
+function Ae(t) {
+  if (U.enabled && t != null && typeof t == "object") {
+    const e = U.getDebugType(t);
     if (e)
       return e === "computed";
   }
-  return Ee(s) && "invalidate" in s && typeof s.invalidate == "function";
+  return pe(t) && "invalidate" in t && typeof t.invalidate == "function";
 }
-function ke(s) {
-  return s != null && typeof s.then == "function";
+function ke(t) {
+  return t != null && typeof t.then == "function";
 }
-const Pe = l.RESOLVED | l.PENDING | l.REJECTED, he = Array(Pe + 1).fill(ue.IDLE);
-he[l.RESOLVED] = ue.RESOLVED;
-he[l.PENDING] = ue.PENDING;
-he[l.REJECTED] = ue.REJECTED;
-class ot {
+const Be = l.RESOLVED | l.PENDING | l.REJECTED, ue = Array(Be + 1).fill(ce.IDLE);
+ue[l.RESOLVED] = ce.RESOLVED;
+ue[l.PENDING] = ce.PENDING;
+ue[l.REJECTED] = ce.REJECTED;
+class nt {
   constructor(e) {
-    this._owner = e, this._epoch = -1, this._nextDeps = I, this._nextVersions = T, this._depCount = 0;
+    this._owner = e, this._epoch = -1, this._nextDeps = C, this._nextVersions = x, this._depCount = 0;
   }
   execute() {
     this._owner._markDirty();
@@ -689,22 +712,22 @@ class ot {
     if (e._lastSeenEpoch === this._epoch)
       return;
     e._lastSeenEpoch = this._epoch;
-    const t = this._depCount, n = this._nextDeps, i = this._nextVersions;
-    t < n.length ? (n[t] = e, i[t] = e.version) : (n.push(e), i.push(e.version)), this._depCount = t + 1;
+    const s = this._depCount, n = this._nextDeps, i = this._nextVersions;
+    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 = I, this._nextVersions = T, this._depCount = 0;
+    this._epoch = -1, this._nextDeps = C, this._nextVersions = x, this._depCount = 0;
   }
 }
-class Me extends we {
-  constructor(e, t = {}) {
+class Me extends Fe {
+  constructor(e, s = {}) {
     if (typeof e != "function")
-      throw new G(m.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 = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Ce, this._hasDefaultValue = this._defaultValue !== Ce, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = I, this._dependencyVersions = T, this._unsubscribes = B, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new ot(this), O.attachDebugInfo(this, "computed", this.id), O.enabled) {
+      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 = C, 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) {
       const n = this;
       n.subscriberCount = this.subscriberCount.bind(this), n.isDirty = () => (this.flags & l.DIRTY) !== 0, n.dependencies = this._dependencies, n.stateFlags = "";
     }
-    if (t.lazy === !1)
+    if (s.lazy === !1)
       try {
         this._recompute();
       } catch {
@@ -712,10 +735,13 @@ class Me extends we {
   }
   get value() {
     const e = y.current;
-    e && M(this, e, this._fnSubs, this._objSubs);
-    const t = this.flags;
-    if (t & l.RECOMPUTING) return this._value;
-    t & (l.DIRTY | l.IDLE) && this._recompute();
+    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);
+    }
+    s & (l.DIRTY | l.IDLE) && this._recompute();
     const n = this.flags;
     return n & l.PENDING ? this._handlePending() : n & l.REJECTED ? this._handleRejected() : this._value;
   }
@@ -724,14 +750,14 @@ class Me extends we {
   }
   get state() {
     const e = y.current;
-    return e && M(this, e, this._fnSubs, this._objSubs), he[this.flags & Pe];
+    return e && B(this, e, this._fnSubs, this._objSubs), ue[this.flags & Be];
   }
   get hasError() {
     const e = y.current;
-    if (e && M(this, e, this._fnSubs, this._objSubs), this.flags & (l.REJECTED | l.HAS_ERROR)) return !0;
-    const t = this._dependencies;
-    for (let n = 0, i = t.length; n < i; n++) {
-      const o = t[n];
+    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++) {
+      const o = s[n];
       if (o && o.flags & l.HAS_ERROR) return !0;
     }
     return !1;
@@ -741,9 +767,9 @@ class Me extends we {
   }
   get errors() {
     const e = y.current;
-    if (e && M(this, e, this._fnSubs, this._objSubs), !this.hasError) return qe;
-    const t = Ze();
-    if (this._errorCacheEpoch === t && this._cachedErrors !== null)
+    if (e && B(this, e, this._fnSubs, this._objSubs), !this.hasError) return ze;
+    const s = Ke();
+    if (this._errorCacheEpoch === s && this._cachedErrors !== null)
       return this._cachedErrors;
     const n = /* @__PURE__ */ new Set();
     this._error && n.add(this._error);
@@ -752,45 +778,45 @@ class Me extends we {
       const u = i[r];
       if (u && "errors" in u) {
         const a = u.errors;
-        for (let _ = 0, P = a.length; _ < P; _++) {
-          const S = a[_];
-          S && n.add(S);
+        for (let d = 0, P = a.length; d < P; d++) {
+          const N = a[d];
+          N && n.add(N);
         }
       }
     }
     const o = Object.freeze([...n]);
-    return this._cachedErrors = o, this._errorCacheEpoch = t, o;
+    return this._cachedErrors = o, this._errorCacheEpoch = s, o;
   }
   get lastError() {
     const e = y.current;
-    return e && M(this, e, this._fnSubs, this._objSubs), this._error;
+    return e && B(this, e, this._fnSubs, this._objSubs), this._error;
   }
   get isPending() {
     const e = y.current;
-    return e && M(this, e, this._fnSubs, this._objSubs), (this.flags & l.PENDING) !== 0;
+    return e && B(this, e, this._fnSubs, this._objSubs), (this.flags & l.PENDING) !== 0;
   }
   get isResolved() {
     const e = y.current;
-    return e && M(this, e, this._fnSubs, this._objSubs), (this.flags & l.RESOLVED) !== 0;
+    return e && B(this, e, this._fnSubs, this._objSubs), (this.flags & l.RESOLVED) !== 0;
   }
   invalidate() {
     this._markDirty();
     const e = this._dependencyVersions;
-    e !== T && (L.release(e), this._dependencyVersions = T), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    e !== x && (F.release(e), this._dependencyVersions = x), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
     const e = this._unsubscribes;
-    if (e !== B) {
+    if (e !== j) {
       for (let i = 0, o = e.length; i < o; i++) {
         const r = e[i];
         r && r();
       }
-      Y.release(e), this._unsubscribes = B;
+      Q.release(e), this._unsubscribes = j;
     }
-    const t = this._dependencies;
-    t !== I && (j.release(t), this._dependencies = I);
+    const s = this._dependencies;
+    s !== C && ($.release(s), this._dependencies = C);
     const n = this._dependencyVersions;
-    n !== T && (L.release(n), this._dependencyVersions = T), 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 !== 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;
   }
   _clearDirty() {
     this.flags &= -9;
@@ -811,107 +837,98 @@ class Me extends we {
     this.flags = this.flags & -113 | (l.REJECTED | l.HAS_ERROR);
   }
   _setRecomputing(e) {
-    const t = l.RECOMPUTING;
-    this.flags = this.flags & ~t | (e ? -1 : 0) & t;
+    const s = l.RECOMPUTING;
+    this.flags = this.flags & ~s | (e ? -1 : 0) & s;
   }
   _recompute() {
     if (this.flags & l.RECOMPUTING)
       return;
     this._setRecomputing(!0);
-    const e = this._trackable, t = this._dependencies, n = this._dependencyVersions;
-    e._epoch = Fe(), e._nextDeps = j.acquire(), e._nextVersions = L.acquire(), e._depCount = 0;
+    const e = this._trackable, s = this._dependencies, n = this._dependencyVersions;
+    e._epoch = Le(), e._nextDeps = $.acquire(), e._nextVersions = F.acquire(), e._depCount = 0;
     let i = !1;
     try {
       const o = y.run(e, this._fn), r = e._nextDeps, c = e._nextVersions, u = e._depCount;
-      r.length = u, c.length = u, this._unsubscribes = Te(r, t, this._unsubscribes, this), this._dependencies = r, this._dependencyVersions = c, i = !0, ke(o) ? this._handleAsyncComputation(o) : this._finalizeResolution(o);
+      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);
     } 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 = Te(c, t, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = u, i = !0;
+          c.length = a, u.length = a, this._unsubscribes = xe(c, s, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = u, i = !0;
         } catch (c) {
           r = c;
         }
       this._handleComputationError(r);
     } finally {
-      i ? (t !== I && j.release(t), n !== T && L.release(n)) : (j.release(e._nextDeps), L.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
+      i ? (s !== C && $.release(s), n !== x && F.release(n)) : ($.release(e._nextDeps), F.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
     }
   }
-  _getAggregateShift() {
-    let e = 0;
-    const t = this._dependencies, n = this._dependencyVersions;
-    for (let i = 0, o = t.length; i < o; i++) {
-      const r = t[i], c = n[i];
-      r && c !== void 0 && (e = e + r.getShift(c) & A);
-    }
-    return e;
-  }
-  isUrgent() {
-    return this._getAggregateShift() >= de;
-  }
   _handleAsyncComputation(e) {
     this._setPending(), this._clearDirty(), this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
-    const t = this._promiseId;
+    const s = this._promiseId;
     e.then((n) => {
-      if (t !== this._promiseId) return;
-      const i = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & A;
-      if (de - 1 - i >>> 31 & 1) {
-        if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {
-          this._asyncRetryCount++, this._markDirty();
+      if (s === this._promiseId) {
+        if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
+          if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {
+            this._asyncRetryCount++, this._markDirty();
+            return;
+          }
+          const i = new M(
+            `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
+          );
+          this._handleAsyncRejection(i);
           return;
         }
-        const o = new G(
-          `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
-        );
-        this._handleAsyncRejection(o);
-        return;
+        this._finalizeResolution(n), this._notifySubscribers(n, void 0);
       }
-      this._finalizeResolution(n), this._notifySubscribers(n, void 0);
     }).catch((n) => {
-      t === this._promiseId && this._handleAsyncRejection(n);
+      s === this._promiseId && this._handleAsyncRejection(n);
     });
   }
   _captureVersionSnapshot() {
     let e = 0;
-    const t = this._dependencies;
-    for (let n = 0, i = t.length; n < i; n++) {
-      const o = t[n];
-      o && (e = e + o.version & A);
+    const s = this._dependencies;
+    for (let n = 0, i = s.length; n < i; n++) {
+      const o = s[n];
+      if (o) {
+        const r = o.version;
+        e = ((e << 5) - e | 0) + r & H;
+      }
     }
     return e;
   }
   _handleAsyncRejection(e) {
-    const t = Z(e, G, m.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    this.flags & l.REJECTED || (this.version = this.version + 1 & A), this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
+    const s = W(e, M, p.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    this.flags & l.REJECTED || (this.version = this.version + 1 & H), this._error = s, this._setRejected(), this._clearDirty();
     const n = this._onError;
     if (n)
       try {
-        n(t);
+        n(s);
       } catch (i) {
-        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        console.error(p.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 & A), 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 & H), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleComputationError(e) {
-    const t = Z(e, G, m.COMPUTED_COMPUTATION_FAILED);
-    this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
+    const s = W(e, M, p.COMPUTED_COMPUTATION_FAILED);
+    this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
     const n = this._onError;
     if (n)
       try {
-        n(t);
+        n(s);
       } catch (i) {
-        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        console.error(p.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
-    throw t;
+    throw s;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new G(m.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new M(p.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     const e = this._error;
@@ -929,42 +946,42 @@ class Me extends we {
   }
 }
 Object.freeze(Me.prototype);
-function rt(s, e = {}) {
-  return new Me(s, e);
+function it(t, e = {}) {
+  return new Me(t, e);
 }
-class ct extends Ue {
-  constructor(e, t = {}) {
-    super(), this._cleanup = null, this._dependencies = I, this._dependencyVersions = T, this._unsubscribes = B, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? V.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? V.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
+class ot extends we {
+  constructor(e, s = {}) {
+    super(), this._cleanup = null, this._dependencies = C, 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 = x && n && i > 0 ? new Array(i).fill(0) : null, O.attachDebugInfo(this, "effect", this.id);
+    this._historyCapacity = i, this._history = D && n && i > 0 ? new Array(i).fill(0) : null, this._execId = 0, U.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & N.DISPOSED)
-      throw new Q(m.EFFECT_MUST_BE_FUNCTION);
+    if (this.flags & R.DISPOSED)
+      throw new Y(p.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
     const e = this.flags;
-    if (e & N.DISPOSED) return;
-    this.flags = e | N.DISPOSED, this._safeCleanup();
-    const t = this._unsubscribes;
-    if (t !== B) {
-      for (let o = 0, r = t.length; o < r; o++) {
-        const c = t[o];
+    if (e & R.DISPOSED) return;
+    this.flags = e | R.DISPOSED, this._safeCleanup();
+    const s = this._unsubscribes;
+    if (s !== j) {
+      for (let o = 0, r = s.length; o < r; o++) {
+        const c = s[o];
         c && c();
       }
-      Y.release(t), this._unsubscribes = B;
+      Q.release(s), this._unsubscribes = j;
     }
     const n = this._dependencies;
-    n !== I && (j.release(n), this._dependencies = I);
+    n !== C && ($.release(n), this._dependencies = C);
     const i = this._dependencyVersions;
-    i !== T && (L.release(i), this._dependencyVersions = T), this._executeTask = void 0;
+    i !== x && (F.release(i), this._dependencyVersions = x), this._executeTask = void 0;
   }
   addDependency(e) {
-    if (!(this.flags & N.EXECUTING)) return;
-    const t = this._currentEpoch;
-    if (e._lastSeenEpoch === t) return;
-    e._lastSeenEpoch = t;
+    if (!(this.flags & R.EXECUTING)) return;
+    const s = this._currentEpoch;
+    if (e._lastSeenEpoch === s) return;
+    e._lastSeenEpoch = s;
     const n = this._nextDeps, i = this._nextVersions, o = this._nextUnsubs;
     if (!n || !i || !o) return;
     n.push(e), i.push(e.version);
@@ -972,48 +989,62 @@ class ct extends Ue {
     r ? (o.push(r), e._tempUnsub = void 0) : this._subscribeTo(e);
   }
   execute(e = !1) {
-    if (this.flags & (N.DISPOSED | N.EXECUTING) || !e && !this._shouldExecute()) return;
+    if (this.flags & (R.DISPOSED | R.EXECUTING) || !e && !this._shouldExecute()) return;
     this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-    const t = this._prepareEffectExecutionContext();
+    const s = this._prepareEffectExecutionContext();
     let n = !1;
     try {
-      const i = y.run(this, this._fn), o = t.nextDeps.length;
-      t.nextDeps.length = o, t.nextVersions.length = o, this._dependencies = t.nextDeps, this._dependencyVersions = t.nextVersions, this._unsubscribes = t.nextUnsubs, n = !0, this._checkLoopWarnings(), ke(i) ? i.then((r) => {
-        !(this.flags & N.DISPOSED) && typeof r == "function" && (this._cleanup = r);
-      }).catch((r) => this._handleExecutionError(r)) : this._cleanup = typeof i == "function" ? i : null;
+      const i = y.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) => {
+        const u = r !== this._execId, a = this.flags & R.DISPOSED;
+        if (u || a) {
+          if (typeof c == "function")
+            try {
+              c();
+            } catch (d) {
+              this._handleExecutionError(d, p.EFFECT_CLEANUP_FAILED);
+            }
+          return;
+        }
+        typeof c == "function" && (this._cleanup = c);
+      }).catch((c) => {
+        r === this._execId && this._handleExecutionError(c);
+      }) : this._cleanup = typeof i == "function" ? i : null;
     } catch (i) {
       n = !0, this._handleExecutionError(i), this._cleanup = null;
     } finally {
-      this._cleanupEffect(t, n), this._setExecuting(!1);
+      this._cleanupEffect(s, n), this._setExecuting(!1);
     }
   }
   _prepareEffectExecutionContext() {
-    const e = this._dependencies, t = this._dependencyVersions, n = this._unsubscribes, i = j.acquire(), o = L.acquire(), r = Y.acquire(), c = Fe();
-    if (e !== I)
+    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = $.acquire(), o = F.acquire(), r = Q.acquire(), c = Le();
+    if (e !== C)
       for (let u = 0, a = e.length; u < a; u++) {
-        const _ = e[u];
-        _ && (_._tempUnsub = n[u]);
+        const d = e[u];
+        d && (d._tempUnsub = n[u]);
       }
-    return this._nextDeps = i, this._nextVersions = o, this._nextUnsubs = r, this._currentEpoch = c, { prevDeps: e, prevVersions: t, prevUnsubs: n, nextDeps: i, nextVersions: o, nextUnsubs: r };
+    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 };
   }
-  _cleanupEffect(e, t) {
+  _cleanupEffect(e, s) {
     this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null;
     const n = e.prevDeps;
-    if (t) {
-      if (n !== I) {
+    if (s) {
+      if (n !== C) {
         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));
         }
-        j.release(n);
+        $.release(n);
       }
-      e.prevUnsubs !== B && Y.release(e.prevUnsubs), e.prevVersions !== T && L.release(e.prevVersions);
+      e.prevUnsubs !== j && Q.release(e.prevUnsubs), e.prevVersions !== x && F.release(e.prevVersions);
     } else {
-      j.release(e.nextDeps), L.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 (Y.release(i), n !== I)
+      if (Q.release(i), n !== C)
         for (let o = 0, r = n.length; o < r; o++) {
           const c = n[o];
           c && (c._tempUnsub = void 0);
@@ -1022,84 +1053,82 @@ class ct extends Ue {
   }
   _subscribeTo(e) {
     try {
-      const t = e.subscribe(() => {
-        if (this._trackModifications && this.flags & N.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) {
+      const s = e.subscribe(() => {
+        if (this._trackModifications && this.flags & R.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) {
           this.execute();
           return;
         }
         let i = this._executeTask;
-        i || (i = this._executeTask = () => this.execute()), te.schedule(i);
+        i || (i = this._executeTask = () => this.execute()), ee.schedule(i);
       }), n = this._nextUnsubs;
-      n && n.push(t);
-    } catch (t) {
-      console.error(Z(t, Q, m.EFFECT_EXECUTION_FAILED));
+      n && n.push(s);
+    } catch (s) {
+      console.error(W(s, Y, p.EFFECT_EXECUTION_FAILED));
       const n = this._nextUnsubs;
       n && n.push(() => {
       });
     }
   }
   get isDisposed() {
-    return (this.flags & N.DISPOSED) !== 0;
+    return (this.flags & R.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & N.EXECUTING) !== 0;
-  }
-  _setDisposed() {
-    this.flags |= N.DISPOSED;
+    return (this.flags & R.EXECUTING) !== 0;
   }
   _setExecuting(e) {
-    const t = N.EXECUTING;
-    this.flags = this.flags & ~t | (e ? -1 : 0) & t;
+    const s = R.EXECUTING;
+    this.flags = this.flags & ~s | (e ? -1 : 0) & s;
   }
   _safeCleanup() {
     const e = this._cleanup;
     if (e) {
       try {
         e();
-      } catch (t) {
-        console.error(Z(t, Q, m.EFFECT_CLEANUP_FAILED));
+      } catch (s) {
+        this._handleExecutionError(s, p.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoop() {
-    const e = pe;
-    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), et() > V.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
-    const t = this._history;
-    if (t) {
+    const e = _e;
+    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 s = this._history;
+    if (s) {
       const n = Date.now(), i = this._historyPtr, o = this._historyCapacity;
-      t[i] = n;
+      s[i] = n;
       const r = (i + 1) % o;
       this._historyPtr = r;
-      const c = t[r] ?? 0;
+      const c = s[r] ?? 0;
       if (c > 0 && n - c < He.ONE_SECOND_MS) {
-        const u = new Q(
+        const u = new Y(
           `Effect executed ${o} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(u), this._onError && this._onError(u), x) throw u;
+        if (this.dispose(), console.error(u), this._onError && this._onError(u), D) throw u;
+        return;
       }
     }
   }
   _throwInfiniteLoopError(e) {
-    const t = new Q(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${be}`
+    const s = new Y(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${ge}`
     );
-    throw this.dispose(), console.error(t), t;
+    throw this.dispose(), console.error(s), s;
   }
   _shouldExecute() {
     const e = this._dependencies;
     if (e.length === 0) return !0;
-    const t = this._dependencyVersions;
+    const s = this._dependencyVersions;
     for (let n = 0, i = e.length; n < i; n++) {
       const o = e[n];
       if (o) {
-        if (o.version !== t[n]) return !0;
+        if (o.version !== s[n]) return !0;
         if ("value" in o)
           try {
-            Le(() => o.value);
+            Pe(() => o.value);
           } catch {
             return !0;
           }
@@ -1107,84 +1136,89 @@ class ct extends Ue {
     }
     return !1;
   }
-  _handleExecutionError(e) {
-    const t = Z(e, Q, m.EFFECT_EXECUTION_FAILED);
-    console.error(t);
-    const n = this._onError;
-    n && n(t);
+  _handleExecutionError(e, s = p.EFFECT_EXECUTION_FAILED) {
+    const n = W(e, Y, s);
+    console.error(n);
+    const i = this._onError;
+    if (i)
+      try {
+        i(n);
+      } catch (o) {
+        console.error(W(o, Y, p.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      }
   }
   _checkLoopWarnings() {
-    if (this._trackModifications && O.enabled) {
-      const e = this._dependencies, t = this._currentEpoch;
+    if (this._trackModifications && U.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 === t && O.warn(
+        o && o._modifiedAtEpoch === s && U.warn(
           !0,
-          `Effect is reading a dependency (${O.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${U.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function J(s, e = {}) {
-  if (typeof s != "function")
-    throw new Q(m.EFFECT_MUST_BE_FUNCTION);
-  const t = new ct(s, e);
-  return t.execute(), t;
+function J(t, e = {}) {
+  if (typeof t != "function")
+    throw new Y(p.EFFECT_MUST_BE_FUNCTION);
+  const s = new ot(t, e);
+  return s.execute(), s;
 }
-function Ve(s) {
-  if (typeof s != "function")
-    throw new k("Batch callback must be a function");
-  te.startBatch();
+function be(t) {
+  if (typeof t != "function")
+    throw new L("Batch callback must be a function");
+  ee.startBatch();
   try {
-    return s();
+    return t();
   } finally {
-    te.endBatch();
+    ee.endBatch();
   }
 }
-function ut(s) {
-  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s;
+function rt(t) {
+  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
 }
-function ae(s) {
-  if (!s) return "unknown";
-  const e = "jquery" in s ? s[0] : s;
+function he(t) {
+  if (!t) return "unknown";
+  const e = "jquery" in t ? t[0] : t;
   if (!e) return "unknown";
   if (e.id) return `#${e.id}`;
   if (e.className) {
-    const t = String(e.className).split(/\s+/).filter(Boolean).join(".");
-    return t ? `${e.tagName.toLowerCase()}.${t}` : e.tagName.toLowerCase();
+    const s = String(e.className).split(/\s+/).filter(Boolean).join(".");
+    return s ? `${e.tagName.toLowerCase()}.${s}` : e.tagName.toLowerCase();
   }
   return e.tagName.toLowerCase();
 }
-function ht(s) {
-  const e = s.length;
+function ct(t) {
+  const e = t.length;
   if (e === 0) return new Int32Array(0);
-  const t = new Int32Array(e), n = new Int32Array(e);
+  const s = new Int32Array(e), n = new Int32Array(e);
   let i = 0;
   for (let r = 0; r < e; r++) {
-    const c = s[r];
+    const c = t[r];
     if (c === -1) continue;
-    if (i === 0 || s[n[i - 1]] < c) {
-      t[r] = i > 0 ? n[i - 1] : -1, n[i++] = r;
+    if (i === 0 || t[n[i - 1]] < c) {
+      s[r] = i > 0 ? n[i - 1] : -1, n[i++] = r;
       continue;
     }
     let u = 0, a = i - 1;
     for (; u < a; ) {
-      const _ = u + a >>> 1;
-      s[n[_]] < c ? u = _ + 1 : a = _;
+      const d = u + a >>> 1;
+      t[n[d]] < c ? u = d + 1 : a = d;
     }
-    c < s[n[u]] && (u > 0 && (t[r] = n[u - 1]), n[u] = r);
+    c < t[n[u]] && (u > 0 && (s[r] = n[u - 1]), n[u] = r);
   }
   const o = new Int32Array(i);
   for (let r = i - 1, c = n[i - 1]; r >= 0; r--)
-    o[r] = c, c = t[c];
+    o[r] = c, c = s[c];
   return o;
 }
-function at() {
+function ut() {
   if (typeof window < "u") {
-    const s = window.__ATOM_DEBUG__;
-    if (typeof s == "boolean")
-      return s;
+    const t = window.__ATOM_DEBUG__;
+    if (typeof t == "boolean")
+      return t;
   }
   try {
     if (typeof process < "u" && process.env && process.env.NODE_ENV === "development")
@@ -1193,93 +1227,93 @@ function at() {
   }
   return !1;
 }
-let q = at();
-const g = {
+let G = ut();
+const E = {
   get enabled() {
-    return q;
+    return G;
   },
-  set enabled(s) {
-    q = s;
+  set enabled(t) {
+    G = t;
   },
-  log(s, ...e) {
-    q && console.log(`[atom-effect-jquery] ${s}:`, ...e);
+  log(t, ...e) {
+    G && console.log(`[atom-effect-jquery] ${t}:`, ...e);
   },
-  atomChanged(s, e, t) {
-    q && console.log(`[atom-effect-jquery] Atom "${s || "anonymous"}" changed:`, e, "→", t);
+  atomChanged(t, e, s) {
+    G && console.log(`[atom-effect-jquery] Atom "${t || "anonymous"}" changed:`, e, "→", s);
   },
   /**
    * Logs DOM updates and triggers visual highlight.
    */
-  domUpdated(s, e, t) {
-    if (!q) return;
-    const n = ae(s);
-    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, t), lt(s);
+  domUpdated(t, e, s) {
+    if (!G) return;
+    const n = he(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), ht(t);
   },
-  cleanup(s) {
-    q && console.log(`[atom-effect-jquery] Cleanup: ${s}`);
+  cleanup(t) {
+    G && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
   },
-  warn(...s) {
-    q && console.warn("[atom-effect-jquery]", ...s);
+  warn(...t) {
+    G && console.warn("[atom-effect-jquery]", ...t);
   }
 };
-function lt(s) {
-  const e = s[0];
+function ht(t) {
+  const e = t[0];
   if (!e || !document.contains(e)) return;
-  const t = "atom_debug_timer", n = "atom_debug_cleanup_timer", i = "atom_debug_org_style";
-  clearTimeout(s.data(t)), clearTimeout(s.data(n)), s.data(i) || s.data(i, {
-    outline: s.css("outline"),
-    outlineOffset: s.css("outline-offset"),
-    transition: s.css("transition")
-  }), s.css({
+  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, {
+    outline: t.css("outline"),
+    outlineOffset: t.css("outline-offset"),
+    transition: t.css("transition")
+  }), t.css({
     outline: "2px solid rgba(255, 68, 68, 0.8)",
     "outline-offset": "1px",
     transition: "none"
     // Remove transition for instant feedback on update
   });
   const o = setTimeout(() => {
-    const r = s.data(i);
-    s.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
-      s.css({
+    const r = t.data(i);
+    t.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
+      t.css({
         outline: r?.outline || "",
         "outline-offset": r?.outlineOffset || ""
       });
       const c = setTimeout(() => {
-        s.css("transition", r?.transition || ""), s.removeData(t), s.removeData(n), s.removeData(i);
+        t.css("transition", r?.transition || ""), t.removeData(s), t.removeData(n), t.removeData(i);
       }, 500);
-      s.data(n, c);
+      t.data(n, c);
     });
   }, 100);
-  s.data(t, o);
+  t.data(s, o);
 }
-const ft = /* @__PURE__ */ new WeakMap();
-function Be(s, e = {}) {
-  const t = it(s, e);
-  return e.name && ft.set(t, { name: e.name }), t;
+const at = /* @__PURE__ */ new WeakMap();
+function Ve(t, e = {}) {
+  const s = st(t, e);
+  return e.name && at.set(s, { name: e.name }), s;
 }
-Object.defineProperty(Be, "debug", {
+Object.defineProperty(Ve, "debug", {
   get() {
-    return g.enabled;
+    return E.enabled;
   },
-  set(s) {
-    g.enabled = s;
+  set(t) {
+    E.enabled = t;
   }
 });
-function _t() {
-  return new Promise((s) => setTimeout(s, 0));
+function lt() {
+  return new Promise((t) => setTimeout(t, 0));
 }
 h.extend({
-  atom: Be,
-  computed: rt,
+  atom: Ve,
+  computed: it,
   effect: J,
-  batch: Ve,
-  untracked: Le,
-  isAtom: Ee,
+  batch: be,
+  untracked: Pe,
+  isAtom: pe,
   isComputed: Ae,
-  isReactive: (s) => Ee(s) || Ae(s),
-  nextTick: _t
+  isReactive: (t) => pe(t) || Ae(t),
+  nextTick: lt
 });
-const ie = "_aes-bound";
-class dt {
+const ne = "_aes-bound";
+class ft {
   effects = /* @__PURE__ */ new WeakMap();
   cleanups = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
@@ -1298,30 +1332,30 @@ class dt {
   isIgnored(e) {
     return this.ignoredNodes.has(e);
   }
-  trackEffect(e, t) {
+  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(ie))), n.push(t);
+    n || (n = [], this.effects.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ne))), n.push(s);
   }
-  trackCleanup(e, t) {
+  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(ie))), n.push(t);
+    n || (n = [], this.cleanups.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ne))), n.push(s);
   }
   hasBind(e) {
     return this.boundElements.has(e);
   }
   cleanup(e) {
     if (!this.boundElements.delete(e)) return;
-    e.classList.remove(ie), g.cleanup(ae(e));
-    const t = this.effects.get(e);
-    if (t) {
+    this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.classList.remove(ne), E.cleanup(he(e));
+    const s = this.effects.get(e);
+    if (s) {
       this.effects.delete(e);
-      for (let i = 0, o = t.length; i < o; i++) {
-        const r = t[i];
+      for (let i = 0, o = s.length; i < o; i++) {
+        const r = s[i];
         if (r)
           try {
             r.dispose();
           } catch (c) {
-            g.warn("Effect dispose error:", c);
+            E.warn("Effect dispose error:", c);
           }
       }
     }
@@ -1334,15 +1368,15 @@ class dt {
           try {
             r();
           } catch (c) {
-            g.warn("Cleanup error:", c);
+            E.warn("Cleanup error:", c);
           }
       }
     }
   }
   cleanupDescendants(e) {
-    const t = e.querySelectorAll(`.${ie}`);
-    for (let n = 0, i = t.length; n < i; n++) {
-      const o = t[n];
+    const s = e.querySelectorAll(`.${ne}`);
+    for (let n = 0, i = s.length; n < i; n++) {
+      const o = s[n];
       o && this.boundElements.has(o) && this.cleanup(o);
     }
   }
@@ -1350,393 +1384,396 @@ class dt {
     this.cleanupDescendants(e), this.cleanup(e);
   }
 }
-const d = new dt();
-let ee = null;
-function pt(s = document.body) {
-  ee || (ee = new MutationObserver((e) => {
-    for (let t = 0, n = e.length; t < n; t++) {
-      const i = e[t];
+const _ = new ft();
+let Z = null;
+function dt(t = document.body) {
+  Z || (Z = 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 && (d.isKept(u) || d.isIgnored(u) || u.isConnected || u.nodeType === 1 && d.cleanupTree(u));
+        u && (_.isKept(u) || _.isIgnored(u) || u.isConnected || u.nodeType === 1 && _.cleanupTree(u));
       }
     }
-  }), ee.observe(s, { childList: !0, subtree: !0 }));
+  }), Z.observe(t, { childList: !0, subtree: !0 }));
 }
-function At() {
-  ee?.disconnect(), ee = null;
+function xt() {
+  Z?.disconnect(), Z = null;
 }
-function p(s, e, t, n) {
-  const i = h(s), o = s;
-  if (ut(e)) {
-    const r = J(() => {
-      const c = e.value;
-      t(c), g.domUpdated(i, n, c);
+function g(t, e, s, n) {
+  const i = h(t);
+  if (rt(e)) {
+    const o = J(() => {
+      const r = e.value;
+      s(r), E.domUpdated(i, n, r);
     });
-    d.trackEffect(o, r);
+    _.trackEffect(t, o);
   } else
-    t(e);
+    s(e), E.domUpdated(i, n, e);
 }
-function je() {
+function me() {
   return { timeoutId: null, phase: "idle", hasFocus: !1 };
 }
-function ze(s, e, t = {}) {
+function je(t, e, s = {}) {
   const {
     debounce: n,
     event: i = "input",
-    parse: o = (D) => D,
-    format: r = (D) => String(D ?? "")
-  } = t, c = je(), u = () => {
-    c.phase = "composing";
-  }, a = () => {
-    c.phase = "idle", S();
+    parse: o = (m) => m,
+    format: r = (m) => String(m ?? ""),
+    equal: c = Object.is
+  } = s, u = me(), a = () => {
+    u.phase = "composing";
+  }, d = () => {
+    u.phase = "idle", k();
   };
-  s.on("compositionstart", u), s.on("compositionend", a);
-  const _ = () => {
-    c.hasFocus = !0;
-  }, P = () => {
-    c.hasFocus = !1;
-    const D = r(e.value);
-    s.val() !== D && s.val(D);
+  t.on("compositionstart", a), t.on("compositionend", d);
+  const P = () => {
+    u.hasFocus = !0;
+  }, N = () => {
+    u.hasFocus = !1;
+    const m = r(e.value);
+    t.val() !== m && t.val(m);
   };
-  s.on("focus", _), s.on("blur", P);
-  const S = () => {
-    c.phase === "idle" && (c.phase = "syncing-to-atom", e.value = o(s.val()), c.phase = "idle");
-  }, R = () => {
-    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(S, n)) : S());
+  t.on("focus", P), t.on("blur", N);
+  const k = () => {
+    u.phase === "idle" && (u.phase = "syncing-to-atom", e.value = o(t.val()), u.phase = "idle");
+  }, O = () => {
+    u.phase === "idle" && (n ? (u.timeoutId && clearTimeout(u.timeoutId), u.timeoutId = window.setTimeout(k, n)) : k());
   };
-  return s.on(i, R), s.on("change", R), { effect: () => {
-    const D = r(e.value), K = s.val();
-    if (K !== D) {
-      if (c.hasFocus && o(K) === e.value)
+  return t.on(i, O), t.on("change", O), { effect: () => {
+    const m = r(e.value), T = t.val();
+    if (T !== m) {
+      if (u.hasFocus && c(o(T), e.value))
         return;
-      c.phase = "syncing-to-dom", s.val(D), g.domUpdated(s, "val", D), c.phase = "idle";
+      u.phase = "syncing-to-dom", t.val(m), E.domUpdated(t, "val", m), u.phase = "idle";
     }
   }, cleanup: () => {
-    s.off(i, R), s.off("change", R), s.off("compositionstart", u), s.off("compositionend", a), s.off("focus", _), s.off("blur", P), c.timeoutId && clearTimeout(c.timeoutId);
+    t.off(i, O), t.off("change", O), t.off("compositionstart", a), t.off("compositionend", d), t.off("focus", P), t.off("blur", N), u.timeoutId && clearTimeout(u.timeoutId);
   } };
 }
-h.fn.atomText = function(s, e) {
+h.fn.atomText = function(t, e) {
   return this.each(function() {
-    p(
+    g(
       this,
-      s,
-      (t) => {
-        const n = e ? e(t) : String(t ?? "");
+      t,
+      (s) => {
+        const n = e ? e(s) : String(s ?? "");
         h(this).text(n);
       },
       "text"
     );
   });
 };
-h.fn.atomHtml = function(s) {
+h.fn.atomHtml = function(t) {
   return this.each(function() {
-    p(this, s, (e) => h(this).html(String(e ?? "")), "html");
+    g(this, t, (e) => h(this).html(String(e ?? "")), "html");
   });
 };
-h.fn.atomClass = function(s, e) {
+h.fn.atomClass = function(t, e) {
   return this.each(function() {
-    p(
+    g(
       this,
       e,
-      (t) => h(this).toggleClass(s, !!t),
-      `class.${s}`
+      (s) => h(this).toggleClass(t, !!s),
+      `class.${t}`
     );
   });
 };
-h.fn.atomCss = function(s, e, t) {
+h.fn.atomCss = function(t, e, s) {
   return this.each(function() {
-    p(
+    g(
       this,
       e,
       (n) => {
-        const i = t ? `${n}${t}` : n;
-        h(this).css(s, i);
+        const i = s ? `${n}${s}` : n;
+        h(this).css(t, i);
       },
-      `css.${s}`
+      `css.${t}`
     );
   });
 };
-h.fn.atomAttr = function(s, e) {
+h.fn.atomAttr = function(t, e) {
   return this.each(function() {
-    p(
+    g(
       this,
       e,
-      (t) => {
+      (s) => {
         const n = h(this);
-        t == null || t === !1 ? n.removeAttr(s) : t === !0 ? n.attr(s, s) : n.attr(s, String(t));
+        s == null || s === !1 ? n.removeAttr(t) : s === !0 ? n.attr(t, t) : n.attr(t, String(s));
       },
-      `attr.${s}`
+      `attr.${t}`
     );
   });
 };
-h.fn.atomProp = function(s, e) {
+h.fn.atomProp = function(t, e) {
   return this.each(function() {
-    p(this, e, (t) => h(this).prop(s, t), `prop.${s}`);
+    g(this, e, (s) => h(this).prop(t, s), `prop.${t}`);
   });
 };
-h.fn.atomShow = function(s) {
+h.fn.atomShow = function(t) {
   return this.each(function() {
-    p(this, s, (e) => h(this).toggle(!!e), "show");
+    g(this, t, (e) => h(this).toggle(!!e), "show");
   });
 };
-h.fn.atomHide = function(s) {
+h.fn.atomHide = function(t) {
   return this.each(function() {
-    p(this, s, (e) => h(this).toggle(!e), "hide");
+    g(this, t, (e) => h(this).toggle(!e), "hide");
   });
 };
-h.fn.atomVal = function(s, e = {}) {
+h.fn.atomVal = function(t, e = {}) {
   return this.each(function() {
-    const t = h(this), { effect: n, cleanup: i } = ze(t, s, e), o = J(n);
-    d.trackEffect(this, o), d.trackCleanup(this, i);
+    const s = h(this), { effect: n, cleanup: i } = je(s, t, e), o = J(n);
+    _.trackEffect(this, o), _.trackCleanup(this, i);
   });
 };
-h.fn.atomChecked = function(s) {
+h.fn.atomChecked = function(t) {
   return this.each(function() {
-    const e = h(this);
-    let t = !1;
-    const n = () => {
-      t || (s.value = !!e.prop("checked"));
+    const e = h(this), s = me(), n = () => {
+      s.phase === "idle" && (t.value = !!e.prop("checked"));
     };
-    e.on("change", n), d.trackCleanup(this, () => e.off("change", n));
+    e.on("change", n), _.trackCleanup(this, () => e.off("change", n));
     const i = J(() => {
-      t = !0;
-      const o = !!s.value;
-      e.prop("checked", o), g.domUpdated(e, "checked", o), t = !1;
+      s.phase = "syncing-to-dom";
+      const o = !!t.value;
+      e.prop("checked", o), E.domUpdated(e, "checked", o), s.phase = "idle";
     });
-    d.trackEffect(this, i);
+    _.trackEffect(this, i);
   });
 };
-h.fn.atomOn = function(s, e) {
+h.fn.atomOn = function(t, e) {
   return this.each(function() {
-    const t = h(this);
-    t.on(s, e), d.trackCleanup(this, () => t.off(s, e));
+    const s = h(this);
+    s.on(t, e), _.trackCleanup(this, () => s.off(t, e));
   });
 };
 h.fn.atomUnbind = function() {
   return this.each(function() {
-    d.cleanupTree(this);
+    _.cleanupTree(this);
   });
 };
-function Et(s, e) {
-  p(
-    s.el,
+function _t(t, e) {
+  g(
+    t.el,
     e,
-    (t) => {
-      s.el.textContent = String(t ?? "");
+    (s) => {
+      t.el.textContent = String(s ?? "");
     },
     "text"
   );
 }
-function gt(s, e) {
-  p(
-    s.el,
+function pt(t, e) {
+  g(
+    t.el,
     e,
-    (t) => {
-      s.el.innerHTML = String(t ?? "");
+    (s) => {
+      t.el.innerHTML = String(s ?? "");
     },
     "html"
   );
 }
-function bt(s, e) {
-  for (const t in e)
-    p(
-      s.el,
-      e[t],
+function Et(t, e) {
+  for (const s in e)
+    g(
+      t.el,
+      e[s],
       (n) => {
-        s.el.classList.toggle(t, !!n);
+        t.el.classList.toggle(s, !!n);
       },
-      `class.${t}`
+      `class.${s}`
     );
 }
-function mt(s, e) {
-  const t = s.el.style;
+function gt(t, e) {
+  const s = t.el.style;
   for (const n in e) {
     const i = e[n];
     if (i === void 0) continue;
     const o = n.includes("-") ? n.replace(/-./g, (r) => r.charAt(1).toUpperCase()) : n;
     if (Array.isArray(i)) {
       const [r, c] = i;
-      p(
-        s.el,
+      g(
+        t.el,
         r,
         (u) => {
-          t[o] = `${u}${c}`;
+          s[o] = `${u}${c}`;
         },
         `css.${n}`
       );
     } else
-      p(
-        s.el,
+      g(
+        t.el,
         i,
         (r) => {
-          t[o] = r;
+          s[o] = r;
         },
         `css.${n}`
       );
   }
 }
-function St(s, e) {
-  const t = s.el;
+function bt(t, e) {
+  const s = t.el;
   for (const n in e) {
     const i = e[n];
-    p(
-      t,
+    g(
+      s,
       i,
       (o) => {
         if (o == null || o === !1) {
-          t.removeAttribute(n);
+          s.removeAttribute(n);
           return;
         }
-        t.setAttribute(n, o === !0 ? n : String(o));
+        s.setAttribute(n, o === !0 ? n : String(o));
       },
       `attr.${n}`
     );
   }
 }
-function yt(s, e) {
-  const t = s.el;
+function mt(t, e) {
+  const s = t.el;
   for (const n in e)
-    p(
-      t,
+    g(
+      s,
       e[n],
       (i) => {
-        t[n] = i;
+        s[n] = i;
       },
       `prop.${n}`
     );
 }
-function It(s, e) {
-  p(
-    s.el,
+function St(t, e) {
+  g(
+    t.el,
     e,
-    (t) => {
-      s.$el.toggle(!!t);
+    (s) => {
+      t.$el.toggle(!!s);
     },
     "show"
   );
 }
-function Dt(s, e) {
-  p(
-    s.el,
+function It(t, e) {
+  g(
+    t.el,
     e,
-    (t) => {
-      s.$el.toggle(!t);
+    (s) => {
+      t.$el.toggle(!s);
     },
     "hide"
   );
 }
-function Ct(s, e) {
-  const t = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: o } = ze(s.$el, t, n), r = J(i);
-  d.trackEffect(s.el, r), s.trackCleanup(o);
+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 = J(i);
+  _.trackEffect(t.el, r), t.trackCleanup(o);
 }
-function Nt(s, e) {
-  const t = je(), n = () => {
-    t.phase === "idle" && (e.value = s.$el.prop("checked"));
+function Dt(t, e) {
+  const s = me(), n = () => {
+    s.phase === "idle" && (e.value = t.$el.prop("checked"));
   };
-  s.$el.on("change", n), s.trackCleanup(() => s.$el.off("change", n));
+  t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n));
   const i = J(() => {
-    t.phase = "syncing-to-dom";
+    s.phase = "syncing-to-dom";
     const o = !!e.value;
-    s.$el.prop("checked", o), g.domUpdated(s.$el, "checked", o), t.phase = "idle";
+    t.$el.prop("checked", o), E.domUpdated(t.$el, "checked", o), s.phase = "idle";
   });
-  d.trackEffect(s.el, i);
+  _.trackEffect(t.el, i);
 }
-function Tt(s, e) {
-  const t = s.el;
+function Ct(t, e) {
+  const s = t.el;
   for (const n in e) {
     const i = e[n];
     if (typeof i != "function") continue;
-    const o = (r) => i.call(t, h.Event(r));
-    t.addEventListener(n, o), s.trackCleanup(() => t.removeEventListener(n, o));
+    const o = i, r = (c) => {
+      const u = h.Event(c.type, { originalEvent: c });
+      be(() => o.call(s, u));
+    };
+    s.addEventListener(n, r), t.trackCleanup(() => s.removeEventListener(n, r));
   }
 }
-h.fn.atomBind = function(s) {
+h.fn.atomBind = function(t) {
   return this.each(function() {
-    const t = {
+    const s = {
       $el: h(this),
       el: this,
-      effects: [],
-      trackCleanup: (n) => d.trackCleanup(this, n)
+      trackCleanup: (n) => _.trackCleanup(this, n)
     };
-    s.text !== void 0 && Et(t, s.text), s.html !== void 0 && gt(t, s.html), s.class && bt(t, s.class), s.css && mt(t, s.css), s.attr && St(t, s.attr), s.prop && yt(t, s.prop), s.show !== void 0 && It(t, s.show), s.hide !== void 0 && Dt(t, s.hide), s.val !== void 0 && Ct(t, s.val), s.checked !== void 0 && Nt(t, s.checked), s.on && Tt(t, s.on);
+    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);
   });
 };
-h.fn.atomList = function(s, e) {
-  const { key: t, render: n, bind: i, update: o, onAdd: r, onRemove: c, empty: u } = e, a = typeof t == "function" ? t : (_) => _[t];
+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];
   return this.each(function() {
-    const _ = h(this), P = ae(this), S = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Set();
-    let z = [], $ = null;
-    const D = J(() => {
-      const K = s.value, U = K.length;
-      if (U === 0 ? u && !$ && ($ = h(u).appendTo(_)) : $ && ($.remove(), $ = null), U === 0 && S.size === 0) {
-        z = [];
+    const d = h(this), P = he(this), N = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set();
+    let O = [], z = null;
+    const Se = J(() => {
+      const m = t.value, T = m.length;
+      if (T === 0 ? u && !z && (z = h(u).appendTo(d)) : z && (z.remove(), z = null), T === 0 && N.size === 0) {
+        O = [];
         return;
       }
-      g.log("list", `${P} updating with ${U} items`);
-      const se = new Array(U), me = /* @__PURE__ */ new Set();
-      for (let f = 0; f < U; f++) {
-        const E = K[f], C = a(E, f);
-        se[f] = C, me.add(C);
+      E.log("list", `${P} updating with ${T} items`);
+      const te = new Array(T), ae = /* @__PURE__ */ new Set();
+      for (let f = 0; f < T; f++) {
+        const b = m[f], S = a(b, f);
+        E.enabled && ae.has(S) && console.warn(
+          `[atomList] Duplicate key "${S}" at index ${f}. Items with duplicate keys may cause unexpected behavior.`
+        ), te[f] = S, ae.add(S);
       }
-      for (const [f, E] of S) {
-        if (me.has(f) || R.has(f)) continue;
-        const C = () => {
-          E.$el.remove();
-          const b = E.$el[0];
-          b && d.cleanup(b), R.delete(f), g.log("list", `${P} removed item:`, f);
+      for (const [f, b] of N) {
+        if (ae.has(f) || k.has(f)) continue;
+        const S = () => {
+          b.$el.remove();
+          const I = b.$el[0];
+          I && _.cleanup(I), k.delete(f), E.log("list", `${P} removed item:`, f);
         };
-        if (S.delete(f), R.add(f), c) {
-          const b = c(E.$el);
-          b instanceof Promise ? b.then(C) : C();
+        if (N.delete(f), k.add(f), c) {
+          const I = c(b.$el);
+          I instanceof Promise ? I.then(S) : S();
         } else
-          C();
+          S();
       }
-      if (U === 0) {
-        z = [];
+      if (T === 0) {
+        O = [];
         return;
       }
-      const Se = /* @__PURE__ */ new Map();
-      for (let f = 0; f < z.length; f++) {
-        const E = z[f];
-        E !== void 0 && Se.set(E, f);
+      const Ie = /* @__PURE__ */ new Map();
+      for (let f = 0; f < O.length; f++) {
+        const b = O[f];
+        b !== void 0 && Ie.set(b, f);
       }
-      const ye = new Int32Array(U);
-      for (let f = 0; f < U; f++) {
-        const E = se[f];
-        ye[f] = E !== void 0 ? Se.get(E) ?? -1 : -1;
+      const ye = new Int32Array(T);
+      for (let f = 0; f < T; f++) {
+        const b = te[f];
+        ye[f] = b !== void 0 ? Ie.get(b) ?? -1 : -1;
       }
-      const Ie = ht(ye);
-      let le = Ie.length - 1, w = null;
-      for (let f = U - 1; f >= 0; f--) {
-        const E = se[f], C = K[f], b = S.get(E);
-        if (b) {
-          b.item = C;
-          const H = b.$el[0];
-          if (!H) continue;
-          o && o(b.$el, C, f), le >= 0 && Ie[le] === f ? (le--, H.nextSibling !== w && (w ? b.$el.insertBefore(w) : b.$el.appendTo(_))) : w ? b.$el.insertBefore(w) : b.$el.appendTo(_), w = H;
+      const De = ct(ye);
+      let le = De.length - 1, w = null;
+      for (let f = T - 1; f >= 0; f--) {
+        const b = te[f], S = m[f], I = N.get(b);
+        if (I) {
+          I.item = S;
+          const X = I.$el[0];
+          if (!X) continue;
+          o && o(I.$el, S, f), le >= 0 && De[le] === f ? (le--, X.nextSibling !== w && (w ? I.$el.insertBefore(w) : I.$el.appendTo(d))) : w ? I.$el.insertBefore(w) : I.$el.appendTo(d), w = X;
         } else {
-          const H = n(C, f), X = H instanceof Element ? h(H) : h(H);
-          S.set(E, { $el: X, item: C }), w ? X.insertBefore(w) : X.appendTo(_), i && i(X, C, f), r && r(X), g.log("list", `${P} added item:`, E), w = X[0] || null;
+          const X = n(S, f), q = X instanceof Element ? h(X) : h(X);
+          N.set(b, { $el: q, item: S }), w ? q.insertBefore(w) : q.appendTo(d), i && i(q, S, f), r && r(q), E.log("list", `${P} added item:`, b), w = q[0] || null;
         }
       }
-      z = se;
+      O = te;
     });
-    d.trackEffect(this, D), d.trackCleanup(this, () => {
-      S.clear(), R.clear(), z = [], $?.remove();
+    _.trackEffect(this, Se), _.trackCleanup(this, () => {
+      N.clear(), k.clear(), O = [], z?.remove();
     });
   });
 };
-const re = /* @__PURE__ */ new WeakMap();
-h.fn.atomMount = function(s, e = {}) {
+const oe = /* @__PURE__ */ new WeakMap();
+h.fn.atomMount = function(t, e = {}) {
   return this.each(function() {
-    const t = h(this), n = ae(this), i = re.get(this);
-    i && (g.log("mount", `${n} unmounting existing component`), i()), g.log("mount", `${n} mounting component`);
+    const s = h(this), n = he(this), i = oe.get(this);
+    i && (E.log("mount", `${n} unmounting existing component`), i()), E.log("mount", `${n} mounting component`);
     let o;
     try {
-      o = s(t, e);
+      o = t(s, e);
     } catch (u) {
       console.error("[atom-effect-jquery] Mount error:", u);
       return;
@@ -1744,39 +1781,40 @@ h.fn.atomMount = function(s, e = {}) {
     let r = !1;
     const c = () => {
       if (!r) {
-        if (r = !0, g.log("mount", `${n} full cleanup`), typeof o == "function")
+        if (r = !0, E.log("mount", `${n} full cleanup`), typeof o == "function")
           try {
             o();
-          } catch {
+          } catch (u) {
+            console.error("[atom-effect-jquery] Cleanup error:", u);
           }
-        d.cleanupTree(this), re.delete(this);
+        _.cleanupTree(this), oe.delete(this);
       }
     };
-    re.set(this, c), d.trackCleanup(this, c);
+    oe.set(this, c), _.trackCleanup(this, c);
   });
 };
 h.fn.atomUnmount = function() {
   return this.each(function() {
-    re.get(this)?.();
+    oe.get(this)?.();
   });
 };
-const W = /* @__PURE__ */ new WeakMap();
-let Oe = !1;
+const K = /* @__PURE__ */ new WeakMap();
+let ve = !1;
 function $e() {
-  if (Oe) return;
-  Oe = !0;
-  const s = h.fn.on, e = h.fn.off, t = h.fn.remove, n = h.fn.empty, i = h.fn.detach;
+  if (ve) return;
+  ve = !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() {
-      d.cleanupTree(this), d.markIgnored(this);
-    }), t.call(this, o);
+      _.cleanupTree(this), _.markIgnored(this);
+    }), s.call(this, o);
   }, h.fn.empty = function() {
     return this.each(function() {
-      d.cleanupDescendants(this);
+      _.cleanupDescendants(this);
     }), n.call(this);
   }, h.fn.detach = function(o) {
     return (o ? this.filter(o) : this).each(function() {
-      d.keep(this);
+      _.keep(this);
     }), i.call(this, o);
   }, h.fn.on = function(...o) {
     let r = -1;
@@ -1788,11 +1826,11 @@ function $e() {
     if (r !== -1) {
       const c = o[r];
       let u;
-      W.has(c) ? u = W.get(c) : (u = function(...a) {
-        return Ve(() => c.apply(this, a));
-      }, W.set(c, u)), o[r] = u;
+      K.has(c) ? u = K.get(c) : (u = function(a, ...d) {
+        return be(() => c.call(this, a, ...d));
+      }, K.set(c, u)), o[r] = u;
     }
-    return s.apply(this, o);
+    return t.apply(this, o);
   }, h.fn.off = function(...o) {
     let r = -1;
     for (let c = o.length - 1; c >= 0; c--)
@@ -1802,7 +1840,7 @@ function $e() {
       }
     if (r !== -1) {
       const c = o[r];
-      W.has(c) && (o[r] = W.get(c));
+      K.has(c) && (o[r] = K.get(c));
     }
     return e.apply(this, o);
   };
@@ -1810,19 +1848,19 @@ function $e() {
 const Ot = $e;
 $e();
 h(() => {
-  pt(document.body);
+  dt(document.body);
 });
 export {
-  it as atom,
-  Ve as batch,
-  rt as computed,
-  wt as default,
-  At as disableAutoCleanup,
+  st as atom,
+  be as batch,
+  it as computed,
+  vt as default,
+  xt as disableAutoCleanup,
   J as effect,
-  pt as enableAutoCleanup,
+  dt as enableAutoCleanup,
   Ot as enablejQueryBatching,
   $e as enablejQueryOverrides,
-  d as registry,
-  Le as untracked
+  _ as registry,
+  Pe as untracked
 };
 //# sourceMappingURL=index.mjs.map