@but212/atom-effect-jquery 0.9.2 → 0.10.1

package/dist/index.mjs

@@ -1,14 +1,14 @@
 import u from "jquery";
-import { default as xt } from "jquery";
-const Le = {
+import { default as Ot } from "jquery";
+const Ve = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, oe = {
+}, ue = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, Z = {
+}, te = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
@@ -28,7 +28,10 @@ const Le = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, L = {
+}, Y = {
+  SYNC: 1,
+  NOTIFICATION_SCHEDULED: 2
+}, B = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /**
@@ -45,13 +48,13 @@ const Le = {
   MAX_FLUSH_ITERATIONS: 1e3,
   /** Minimum allowed value for max flush iterations */
   MIN_FLUSH_ITERATIONS: 10
-}, Ee = {
+}, ye = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, B = 1073741823, T = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", je = Object.freeze([]);
-class k extends Error {
+}, z = 1073741823, v = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", Be = Object.freeze([]);
+class w extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -62,7 +65,7 @@ class k extends Error {
     super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class X extends k {
+class Q extends w {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -72,7 +75,7 @@ class X extends k {
     super(e, s, !0), this.name = "ComputedError";
   }
 }
-class V extends k {
+class V extends w {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -82,7 +85,7 @@ class V extends k {
     super(e, s, !1), this.name = "EffectError";
   }
 }
-class ee extends k {
+class se extends w {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -92,7 +95,7 @@ class ee extends k {
     super(e, s, !1), this.name = "SchedulerError";
   }
 }
-const y = {
+const g = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -144,28 +147,28 @@ const y = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, he = /* @__PURE__ */ Symbol("debugName"), Be = /* @__PURE__ */ Symbol("id"), ae = /* @__PURE__ */ Symbol("type"), ge = /* @__PURE__ */ Symbol("noDefaultValue");
-function qe(t) {
+}, fe = /* @__PURE__ */ Symbol("debugName"), qe = /* @__PURE__ */ Symbol("id"), de = /* @__PURE__ */ Symbol("type"), De = /* @__PURE__ */ Symbol("noDefaultValue");
+function ze(t) {
   return "dependencies" in t && Array.isArray(t.dependencies);
 }
-let me = 0;
-function Ce(t, e, s) {
+let Ie = 0;
+function xe(t, e, s) {
   if (t._visitedEpoch !== s) {
     if (t._visitedEpoch = s, t === e)
-      throw new X("Indirect circular dependency detected");
-    if (qe(t)) {
+      throw new Q("Indirect circular dependency detected");
+    if (ze(t)) {
       const n = t.dependencies;
       for (let i = 0; i < n.length; i++) {
         const r = n[i];
-        r && Ce(r, e, s);
+        r && xe(r, e, s);
       }
     }
   }
 }
-const w = {
+const R = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: Ee.MAX_DEPENDENCIES,
-  warnInfiniteLoop: Ee.WARN_INFINITE_LOOP,
+  maxDependencies: ye.MAX_DEPENDENCIES,
+  warnInfiniteLoop: ye.WARN_INFINITE_LOOP,
   warn(t, e) {
     this.enabled && t && console.warn(`[Atom Effect] ${e}`);
   },
@@ -176,32 +179,32 @@ const w = {
    */
   checkCircular(t, e) {
     if (t === e)
-      throw new X("Direct circular dependency detected");
-    this.enabled && (me++, Ce(t, e, me));
+      throw new Q("Direct circular dependency detected");
+    this.enabled && (Ie++, xe(t, e, Ie));
   },
   attachDebugInfo(t, e, s) {
     if (!this.enabled)
       return;
     const n = t;
-    n[he] = `${e}_${s}`, n[Be] = s, n[ae] = e;
+    n[fe] = `${e}_${s}`, n[qe] = s, n[de] = e;
   },
   getDebugName(t) {
-    if (t != null && he in t)
-      return t[he];
+    if (t != null && fe in t)
+      return t[fe];
   },
   getDebugType(t) {
-    if (t != null && ae in t)
-      return t[ae];
+    if (t != null && de in t)
+      return t[de];
   }
 };
-let ze = 1;
-const Xe = () => ze++;
-class ve {
+let Xe = 1;
+const Ge = () => Xe++;
+class Re {
   constructor() {
-    this.id = Xe() & B, this.flags = 0;
+    this.id = Ge() & z, this.flags = 0;
   }
 }
-class Ne extends ve {
+class Ae extends Re {
   constructor() {
     super(), this.version = 0, this._lastSeenEpoch = -1;
   }
@@ -216,7 +219,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(y.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new w(g.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -234,35 +237,35 @@ class Ne extends ve {
   _notifySubscribers(e, s) {
     this._functionSubscribers.forEachSafe(
       (n) => n(e, s),
-      (n) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (n) => console.error(new w(g.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
     ), this._objectSubscribers.forEachSafe(
       (n) => n.execute(),
-      (n) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (n) => console.error(new w(g.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
     );
   }
 }
-let te = 0;
-function xe() {
-  return te = te + 1 & B || 1, te;
+let ne = 0;
+function Oe() {
+  return ne = ne + 1 & z || 1, ne;
 }
-function Ge() {
-  return te;
+function He() {
+  return ne;
 }
-let ne = 0, fe = 0, ie = !1;
-function ye() {
-  return ie ? (T && console.warn(
+let re = 0, pe = 0, oe = !1;
+function Ce() {
+  return oe ? (v && 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) : (oe = !0, re = re + 1 & z, pe = 0, !0);
 }
-function Se() {
-  ie = !1;
+function ve() {
+  oe = !1;
 }
 function Qe() {
-  return ie ? ++fe : 0;
+  return oe ? ++pe : 0;
 }
-class He {
+class Ye {
   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 = L.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 = B.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
@@ -275,15 +278,15 @@ class He {
    */
   schedule(e) {
     if (typeof e != "function")
-      throw new ee("Scheduler callback must be a function");
+      throw new se("Scheduler callback must be a function");
     e._nextEpoch !== this._epoch && (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync ? this.batchQueue[this.batchQueueSize++] = e : (this.queue[this.queueSize++] = e, this.isProcessing || this.flush()));
   }
   flush() {
     this.isProcessing || this.queueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
         if (this.queueSize === 0) return;
-        const e = ye();
-        this._drainQueue(), e && Se();
+        const e = Ce();
+        this._drainQueue(), e && ve();
       } finally {
         this.isProcessing = !1, this.queueSize > 0 && !this.isBatching && this.flush();
       }
@@ -291,11 +294,11 @@ class He {
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = ye();
+    const e = Ce();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && Se();
+      this.isFlushingSync = !1, e && ve();
     }
   }
   _mergeBatchQueue() {
@@ -323,7 +326,7 @@ class He {
   }
   _handleFlushOverflow() {
     console.error(
-      new ee(
+      new se(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
     ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
@@ -334,7 +337,7 @@ class He {
         e[n]?.();
       } catch (i) {
         console.error(
-          new ee("Error occurred during scheduler execution", i)
+          new se("Error occurred during scheduler execution", i)
         );
       }
     e.length = 0;
@@ -355,51 +358,64 @@ class He {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < L.MIN_FLUSH_ITERATIONS)
-      throw new ee(
-        `Max flush iterations must be at least ${L.MIN_FLUSH_ITERATIONS}`
+    if (e < B.MIN_FLUSH_ITERATIONS)
+      throw new se(
+        `Max flush iterations must be at least ${B.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const Y = new He();
-function z(t) {
+const Z = new Ye();
+function Je(t) {
   if (typeof t != "function")
-    throw new k("Batch callback must be a function");
-  Y.startBatch();
+    throw new w("Batch callback must be a function");
+  Z.startBatch();
   try {
     return t();
   } finally {
-    Y.endBatch();
+    Z.endBatch();
   }
 }
-const q = {
-  current: null,
-  run(t, e) {
-    const s = this.current;
-    this.current = t;
+class Ke {
+  constructor() {
+    this.current = null;
+  }
+  /**
+   * Runs the provided function within the context of the given listener.
+   * Restores the previous context after the function completes or throws.
+   *
+   * @param listener - The tracking listener to associate with the current execution.
+   * @param fn - The function to execute.
+   */
+  run(e, s) {
+    const n = this.current;
+    this.current = e;
     try {
-      return e();
+      return s();
     } finally {
-      this.current = s;
+      this.current = n;
     }
-  },
+  }
+  /**
+   * Retrieves the listener currently associated with the tracking context.
+   */
   getCurrent() {
     return this.current;
   }
-};
-function Te(t) {
+}
+const X = new Ke();
+function Ue(t) {
   if (typeof t != "function")
-    throw new k("Untracked callback must be a function");
-  const e = q.current;
-  q.current = null;
+    throw new w("Untracked callback must be a function");
+  const e = X.current;
+  X.current = null;
   try {
     return t();
   } finally {
-    q.current = e;
+    X.current = e;
   }
 }
-class re {
+class ce {
   constructor() {
     this.subscribers = null;
   }
@@ -455,9 +471,9 @@ class re {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class de {
+class be {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = T ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = v ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -465,7 +481,7 @@ class de {
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return T && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return v && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -476,23 +492,23 @@ class de {
   release(e, s) {
     if (!(s && e === s)) {
       if (Object.isFrozen(e)) {
-        T && this.stats && this.stats.rejected.frozen++;
+        v && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        T && this.stats && this.stats.rejected.tooLarge++;
+        v && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        T && this.stats && this.stats.rejected.poolFull++;
+        v && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), T && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), v && this.stats && this.stats.released++;
     }
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!T || !this.stats) return null;
+    if (!v || !this.stats) return null;
     const { acquired: e, released: s, rejected: n } = this.stats, i = n.frozen + n.tooLarge + n.poolFull;
     return {
       acquired: e,
@@ -504,142 +520,145 @@ class de {
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, T && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, v && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const S = Object.freeze([]), O = Object.freeze([]), D = Object.freeze([]), M = new de(), j = new de(), A = new de();
-function le(t) {
+const S = Object.freeze([]), T = Object.freeze([]), y = Object.freeze([]), F = new be(), q = new be(), x = new be();
+function _e(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
 }
-function De(t) {
-  if (w.enabled && (t == null || typeof t == "object")) {
-    const e = w.getDebugType(t);
+function Ne(t) {
+  if (R.enabled && (t == null || typeof t == "object")) {
+    const e = R.getDebugType(t);
     if (e)
       return e === "computed";
   }
-  return le(t) && "invalidate" in t && typeof t.invalidate == "function";
+  return _e(t) && "invalidate" in t && typeof t.invalidate == "function";
 }
-function Re(t) {
+function we(t) {
   return t != null && typeof t.then == "function";
 }
-function Je(t) {
+function We(t) {
   return typeof t == "object" && t !== null;
 }
-function Ye(t) {
+function Ze(t) {
   return (typeof t == "object" || typeof t == "function") && t !== null && typeof t.addDependency == "function";
 }
-function Ke(t) {
+function et(t) {
   return typeof t == "function" && typeof t.addDependency != "function";
 }
-function We(t) {
-  return Je(t) && typeof t.execute == "function";
+function tt(t) {
+  return We(t) && typeof t.execute == "function";
 }
-function Ue(t, e, s, n) {
+function ke(t, e, s, n) {
   if (e) {
-    if (Ye(e)) {
+    if (Ze(e)) {
       e.addDependency(t);
       return;
     }
-    if (Ke(e)) {
+    if (et(e)) {
       s.add(e);
       return;
     }
-    We(e) && n.add(e);
+    tt(e) && n.add(e);
   }
 }
-function Ze(t, e, s, n) {
-  if (e !== S && s !== O)
+function st(t, e, s, n) {
+  if (e !== S && s !== T)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o && (o._tempUnsub = s[r]);
     }
-  const i = j.acquire();
+  const i = q.acquire();
   i.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 ? (i[r] = o._tempUnsub, o._tempUnsub = void 0) : (R.checkCircular(o, n), i[r] = o.subscribe(n)));
   }
   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 !== T && q.release(s), i;
 }
-class et extends Ne {
+class nt extends Ae {
   constructor(e, s) {
-    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new re(), this._objectSubscribersStore = new re(), this._sync = s, this._notifyTask = this._flushNotifications.bind(this), w.attachDebugInfo(this, "atom", this.id);
+    super(), this._functionSubscribersStore = null, this._objectSubscribersStore = null, this._value = e, s && (this.flags |= Y.SYNC), R.attachDebugInfo(this, "atom", this.id);
   }
-  /** Gets the manager for function-based subscribers. */
   get _functionSubscribers() {
-    return this._functionSubscribersStore;
+    return this._functionSubscribersStore || (this._functionSubscribersStore = new ce()), this._functionSubscribersStore;
   }
-  /** Gets the manager for object-based subscribers. */
   get _objectSubscribers() {
-    return this._objectSubscribersStore;
+    return this._objectSubscribersStore || (this._objectSubscribersStore = new ce()), this._objectSubscribersStore;
   }
   /**
-   * Returns the current value and registers the atom as a dependency in the current tracking context.
+   * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = q.getCurrent();
-    return e && this._track(e), this._value;
+    const e = X.current;
+    return e && ke(this, e, this._functionSubscribers, this._objectSubscribers), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
-   * Uses `Object.is` for comparison.
    */
   set value(e) {
     if (Object.is(this._value, e)) return;
     const s = this._value;
-    this.version = this.version + 1 & B, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(s);
-  }
-  _track(e) {
-    Ue(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
+    this._value = e, this.version = this.version + 1 & z;
+    const n = this._functionSubscribersStore?.hasSubscribers, i = this._objectSubscribersStore?.hasSubscribers;
+    (n || i) && this._scheduleNotification(s);
   }
+  /**
+   * Schedules or flushes notifications based on sync mode and batching state.
+   */
   _scheduleNotification(e) {
-    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !Y.isBatching ? this._flushNotifications() : Y.schedule(this._notifyTask);
+    if (this.flags & Y.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= Y.NOTIFICATION_SCHEDULED), this.flags & Y.SYNC && !Z.isBatching) {
+      this._flushNotifications();
+      return;
+    }
+    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), Z.schedule(this._notifyTask);
   }
   _flushNotifications() {
-    if (!this._isNotificationScheduled) return;
+    if (!(this.flags & Y.NOTIFICATION_SCHEDULED)) return;
     const e = this._pendingOldValue, s = this._value;
-    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(s, e);
+    this._pendingOldValue = void 0, this.flags &= -3, this._notifySubscribers(s, e);
   }
   /**
-   * Returns the current value without registering as a dependency in the tracking context.
+   * Overridden to avoid unnecessary manager creation during notification loop.
    */
+  _notifySubscribers(e, s) {
+    this._functionSubscribersStore && this._functionSubscribersStore.forEachSafe((n) => n(e, s)), this._objectSubscribersStore && this._objectSubscribersStore.forEachSafe((n) => n.execute());
+  }
   peek() {
     return this._value;
   }
-  /**
-   * Disposes of the atom, clearing all subscribers and resetting the value.
-   */
   dispose() {
-    this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
+    this._functionSubscribersStore?.clear(), this._objectSubscribersStore?.clear(), this._value = void 0, this._notifyTask = void 0;
   }
 }
-function tt(t, e = {}) {
-  return new et(t, e.sync ?? !1);
+function it(t, e = {}) {
+  return new nt(t, e.sync ?? !1);
 }
-function H(t, e, s) {
+function K(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)
+  if (t instanceof w)
     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 Oe = d.RESOLVED | d.PENDING | d.REJECTED, ce = Array(Oe + 1).fill(oe.IDLE);
-ce[d.RESOLVED] = oe.RESOLVED;
-ce[d.PENDING] = oe.PENDING;
-ce[d.REJECTED] = oe.REJECTED;
-class Ae extends Ne {
+const Fe = d.RESOLVED | d.PENDING | d.REJECTED, he = Array(Fe + 1).fill(ue.IDLE);
+he[d.RESOLVED] = ue.RESOLVED;
+he[d.PENDING] = ue.PENDING;
+he[d.REJECTED] = ue.REJECTED;
+class Me extends Ae {
   constructor(e, s = {}) {
     if (typeof e != "function")
-      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 = () => {
+      throw new Q(g.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 : De, this._hasDefaultValue = this._defaultValue !== De, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new ce(), this._objectSubscribersStore = new ce(), this._dependencies = S, this._dependencyVersions = y, this._unsubscribes = T, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
         (n) => n(),
         (n) => console.error(n)
@@ -650,7 +669,7 @@ class Ae extends Ne {
     }, this._trackable = Object.assign(() => this._markDirty(), {
       addDependency: (n) => {
       }
-    }), w.attachDebugInfo(this, "computed", this.id), w.enabled) {
+    }), R.attachDebugInfo(this, "computed", this.id), R.enabled) {
       const n = this;
       n.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, n.isDirty = () => this._isDirty(), n.dependencies = this._dependencies, n.stateFlags = this._getFlagsAsString();
     }
@@ -690,8 +709,8 @@ class Ae extends Ne {
   }
   get errors() {
     if (this._registerTracking(), !this.hasError)
-      return je;
-    const e = Ge();
+      return Be;
+    const e = He();
     if (this._errorCacheEpoch === e && this._cachedErrors !== null)
       return this._cachedErrors;
     const s = /* @__PURE__ */ new Set();
@@ -718,17 +737,17 @@ class Ae extends Ne {
     return this._registerTracking(), this._isResolved();
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty(), this._dependencyVersions !== y && (x.release(this._dependencyVersions), this._dependencyVersions = y), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this._unsubscribes !== O) {
+    if (this._unsubscribes !== T) {
       for (let e = 0; e < this._unsubscribes.length; e++) {
         const s = this._unsubscribes[e];
         s && s();
       }
-      j.release(this._unsubscribes), this._unsubscribes = O;
+      q.release(this._unsubscribes), this._unsubscribes = T;
     }
-    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;
+    this._dependencies !== S && (F.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== y && (x.release(this._dependencyVersions), this._dependencyVersions = y), 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() {
@@ -772,7 +791,7 @@ class Ae extends Ne {
     this.flags = this.flags & ~s | -Number(e) & s;
   }
   _getAsyncState() {
-    return ce[this.flags & Oe];
+    return he[this.flags & Fe];
   }
   _getFlagsAsString() {
     const e = [];
@@ -787,8 +806,8 @@ 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, Re(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
+      const n = X.run(this._trackable, this._fn);
+      this._commitDependencies(e), s = !0, we(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
     } catch (n) {
       if (!s)
         try {
@@ -802,21 +821,21 @@ class Ae extends Ne {
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = M.acquire(), i = A.acquire(), r = xe(), o = { depCount: 0 }, c = (_) => {
+    const e = this._dependencies, s = this._dependencyVersions, n = F.acquire(), i = x.acquire(), r = Oe(), 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++);
-    }, f = this._trackable.addDependency;
-    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: f, state: o };
+    }, h = this._trackable.addDependency;
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: h, 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;
+    s.length = i.depCount, n.length = i.depCount, this._unsubscribes = st(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
   }
   _cleanupContext(e, s) {
-    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));
+    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== S && F.release(e.prevDeps), e.prevVersions !== y && x.release(e.prevVersions)) : (F.release(e.nextDeps), x.release(e.nextVersions));
   }
   _handleSyncResult(e) {
     const s = !this._isResolved() || !this._equal(this._value, e);
-    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.version = this.version + Number(s) & z, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleAsyncComputation(e) {
     this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
@@ -829,32 +848,32 @@ class Ae extends Ne {
   }
   _handleAsyncResolution(e) {
     const s = !this._isResolved() || !this._equal(this._value, e);
-    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();
+    this.version = this.version + Number(s) & z, 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 = H(e, X, y.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 = K(e, Q, g.COMPUTED_ASYNC_COMPUTATION_FAILED), n = !this._isRejected();
+    if (this.version = this.version + Number(n) & z, this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
       } catch (i) {
-        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        console.error(g.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     this._notifyJob();
   }
   _handleComputationError(e) {
-    const s = H(e, X, y.COMPUTED_COMPUTATION_FAILED);
+    const s = K(e, Q, g.COMPUTED_COMPUTATION_FAILED);
     if (this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
       } catch (n) {
-        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+        console.error(g.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     throw s;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new X(y.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new Q(g.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -869,19 +888,19 @@ class Ae extends Ne {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    Ue(
+    ke(
       this,
-      q.getCurrent(),
+      X.getCurrent(),
       this._functionSubscribersStore,
       this._objectSubscribersStore
     );
   }
 }
-Object.freeze(Ae.prototype);
-function st(t, e = {}) {
-  return new Ae(t, e);
+Object.freeze(Me.prototype);
+function rt(t, e = {}) {
+  return new Me(t, e);
 }
-class nt extends ve {
+class ot extends Re {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -890,18 +909,18 @@ class nt extends ve {
   constructor(e, s = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new V(y.EFFECT_MUST_BE_FUNCTION);
-      this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this.execute();
+        throw new V(g.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== y && (x.release(this._dependencyVersions), this._dependencyVersions = y), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== O) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== T) {
           for (let i = 0; i < this._unsubscribes.length; i++) {
             const r = this._unsubscribes[i];
             r && r();
           }
-          j.release(this._unsubscribes), this._unsubscribes = O;
+          q.release(this._unsubscribes), this._unsubscribes = T;
         }
-        this._dependencies !== S && (M.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D);
+        this._dependencies !== S && (F.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== y && (x.release(this._dependencyVersions), this._dependencyVersions = y);
       }
     }, this.addDependency = (i) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
@@ -915,8 +934,8 @@ class nt extends ve {
       const i = this._prepareEffectContext();
       let r = !1;
       try {
-        const o = q.run(this, this._fn);
-        this._commitEffect(i), r = !0, this._checkLoopWarnings(), Re(o) ? o.then((c) => {
+        const o = X.run(this, this._fn);
+        this._commitEffect(i), r = !0, this._checkLoopWarnings(), we(o) ? o.then((c) => {
           !this.isDisposed && typeof c == "function" && (this._cleanup = c);
         }).catch((c) => {
           this._handleExecutionError(c);
@@ -926,20 +945,20 @@ class nt extends ve {
       } finally {
         this._cleanupEffect(i, 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 ?? 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;
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? B.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? B.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._cleanup = null, this._dependencies = S, this._dependencyVersions = y, this._unsubscribes = T, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = s.onError ?? null, this._historyPtr = 0;
     const n = Number.isFinite(this._maxExecutions);
-    this._historyCapacity = n ? Math.min(this._maxExecutions + 1, L.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = T && n && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, w.attachDebugInfo(this, "effect", this.id);
+    this._historyCapacity = n ? Math.min(this._maxExecutions + 1, B.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = v && n && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, R.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 = M.acquire(), r = A.acquire(), o = j.acquire(), c = xe();
-    if (e !== S && n !== O)
-      for (let f = 0; f < e.length; f++) {
-        const _ = e[f];
-        _ && (_._tempUnsub = n[f]);
+    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = F.acquire(), r = x.acquire(), o = q.acquire(), c = Oe();
+    if (e !== S && n !== T)
+      for (let h = 0; h < e.length; h++) {
+        const _ = e[h];
+        _ && (_._tempUnsub = n[h]);
       }
     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 };
   }
@@ -963,14 +982,14 @@ class nt extends ve {
           const i = e.prevDeps[n];
           i?._tempUnsub && (i._tempUnsub(), i._tempUnsub = void 0);
         }
-        M.release(e.prevDeps);
+        F.release(e.prevDeps);
       }
-      e.prevUnsubs !== O && j.release(e.prevUnsubs), e.prevVersions !== D && A.release(e.prevVersions);
+      e.prevUnsubs !== T && q.release(e.prevUnsubs), e.prevVersions !== y && x.release(e.prevVersions);
     } else {
-      M.release(e.nextDeps), A.release(e.nextVersions);
+      F.release(e.nextDeps), x.release(e.nextVersions);
       for (let n = 0; n < e.nextUnsubs.length; n++)
         e.nextUnsubs[n]?.();
-      if (j.release(e.nextUnsubs), e.prevDeps !== S)
+      if (q.release(e.nextUnsubs), e.prevDeps !== S)
         for (let n = 0; n < e.prevDeps.length; n++) {
           const i = e.prevDeps[n];
           i && (i._tempUnsub = void 0);
@@ -984,11 +1003,11 @@ class nt extends ve {
   _subscribeTo(e) {
     try {
       const s = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : Y.schedule(this.execute);
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : Z.schedule(this.execute);
       });
       this._nextUnsubs && this._nextUnsubs.push(s);
     } catch (s) {
-      console.error(H(s, V, y.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(K(s, V, g.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -996,7 +1015,7 @@ class nt extends ve {
    * Whether the effect has been disposed.
    */
   get isDisposed() {
-    return (this.flags & Z.DISPOSED) !== 0;
+    return (this.flags & te.DISPOSED) !== 0;
   }
   /**
    * Total number of times this effect has executed.
@@ -1008,13 +1027,13 @@ class nt extends ve {
    * Whether the effect is currently executing.
    */
   get isExecuting() {
-    return (this.flags & Z.EXECUTING) !== 0;
+    return (this.flags & te.EXECUTING) !== 0;
   }
   _setDisposed() {
-    this.flags |= Z.DISPOSED;
+    this.flags |= te.DISPOSED;
   }
   _setExecuting(e) {
-    const s = Z.EXECUTING;
+    const s = te.EXECUTING;
     this.flags = this.flags & ~s | -Number(e) & s;
   }
   /**
@@ -1025,7 +1044,7 @@ class nt extends ve {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(H(e, V, y.EFFECT_CLEANUP_FAILED));
+        console.error(K(e, V, g.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1035,22 +1054,22 @@ 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() > L.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+    if (this._lastFlushEpoch !== re && (this._lastFlushEpoch = re, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Qe() > B.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
       const e = Date.now(), s = this._historyPtr, n = this._historyCapacity;
       this._history[s] = e;
       const i = (s + 1) % n, r = this._history[i] ?? 0;
-      if (this._historyPtr = i, r > 0 && e - r < Le.ONE_SECOND_MS) {
+      if (this._historyPtr = i, r > 0 && e - r < Ve.ONE_SECOND_MS) {
         const o = new V(
           `Effect executed ${n} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(o), this._onError && this._onError(o), T)
+        if (this.dispose(), console.error(o), this._onError && this._onError(o), v)
           throw o;
       }
     }
   }
   _throwInfiniteLoopError(e) {
     const s = new V(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${fe}`
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${pe}`
     );
     throw this.dispose(), console.error(s), s;
   }
@@ -1059,14 +1078,14 @@ class nt extends ve {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === S || this._dependencyVersions === D)
+    if (this._dependencies === S || this._dependencyVersions === y)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const s = this._dependencies[e];
       if (s) {
         if ("value" in s)
           try {
-            Te(() => s.value);
+            Ue(() => s.value);
           } catch {
             return !0;
           }
@@ -1081,7 +1100,7 @@ class nt extends ve {
    * Wraps the error, logs it to console, and calls onError callback if provided.
    */
   _handleExecutionError(e) {
-    const s = H(e, V, y.EFFECT_EXECUTION_FAILED);
+    const s = K(e, V, g.EFFECT_EXECUTION_FAILED);
     console.error(s), this._onError && this._onError(s);
   }
   /**
@@ -1089,32 +1108,33 @@ class nt extends ve {
    * Only active if trackModifications is enabled and debug is on.
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && w.enabled) {
+    if (this._trackModifications && R.enabled) {
       const e = this._dependencies;
       for (let s = 0; s < e.length; s++) {
         const n = e[s];
-        n && n._modifiedAtEpoch === this._currentEpoch && w.warn(
+        n && n._modifiedAtEpoch === this._currentEpoch && R.warn(
           !0,
-          `Effect is reading a dependency (${w.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${R.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function I(t, e = {}) {
+function D(t, e = {}) {
   if (typeof t != "function")
-    throw new V(y.EFFECT_MUST_BE_FUNCTION);
-  const s = new nt(t, e);
+    throw new V(g.EFFECT_MUST_BE_FUNCTION);
+  const s = new ot(t, e);
   return s.execute(), s;
 }
-function b(t) {
+function p(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
 }
-function E(t) {
-  return b(t) ? t.value : t;
+function k(t) {
+  return p(t) ? t.value : t;
 }
-function ue(t) {
-  const e = t.jquery ? t[0] : t;
+function ae(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) {
@@ -1123,7 +1143,7 @@ function ue(t) {
   }
   return e.tagName.toLowerCase();
 }
-function it() {
+function ct() {
   if (typeof window < "u") {
     const t = window.__ATOM_DEBUG__;
     if (typeof t == "boolean")
@@ -1136,8 +1156,8 @@ function it() {
   }
   return !1;
 }
-let P = it();
-const h = {
+let P = ct();
+const l = {
   get enabled() {
     return P;
   },
@@ -1155,8 +1175,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 n = ae(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), ut(t);
   },
   cleanup(t) {
     P && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
@@ -1165,7 +1185,7 @@ const h = {
     P && console.warn("[atom-effect-jquery]", ...t);
   }
 };
-function rt(t) {
+function ut(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";
@@ -1194,85 +1214,76 @@ function rt(t) {
   }, 100);
   t.data(s, r);
 }
-const ot = /* @__PURE__ */ new WeakMap();
-function we(t, e = {}) {
-  const s = tt(t, e);
-  return e.name && ot.set(s, { name: e.name }), s;
+const ht = /* @__PURE__ */ new WeakMap();
+function $e(t, e = {}) {
+  const s = it(t, e);
+  return e.name && ht.set(s, { name: e.name }), s;
 }
-Object.defineProperty(we, "debug", {
+Object.defineProperty($e, "debug", {
   get() {
-    return h.enabled;
+    return l.enabled;
   },
   set(t) {
-    h.enabled = t;
+    l.enabled = t;
   }
 });
-function ct() {
+function at() {
   return new Promise((t) => setTimeout(t, 0));
 }
 u.extend({
-  atom: we,
-  computed: st,
-  effect: I,
-  batch: z,
-  untracked: Te,
-  isAtom: le,
-  isComputed: De,
-  isReactive: (t) => le(t) || De(t),
-  nextTick: ct
+  atom: $e,
+  computed: rt,
+  effect: D,
+  batch: Je,
+  untracked: Ue,
+  isAtom: _e,
+  isComputed: Ne,
+  isReactive: (t) => _e(t) || Ne(t),
+  nextTick: at
 });
-function ke() {
+function Le() {
   return { timeoutId: null, phase: "idle", hasFocus: !1 };
 }
-function Fe(t, e, s = {}) {
+function je(t, e, s = {}) {
   const {
     debounce: n,
     event: i = "input",
-    parse: r = (p) => p,
-    format: o = (p) => String(p ?? "")
-  } = s, c = ke(), f = () => {
+    parse: r = (I) => I,
+    format: o = (I) => String(I ?? "")
+  } = s, c = Le(), h = () => {
     c.phase = "composing";
   }, _ = () => {
-    c.phase = "idle", F();
+    c.phase = "idle", N();
   };
-  t.on("compositionstart", f), t.on("compositionend", _);
-  const C = () => {
+  t.on("compositionstart", h), t.on("compositionend", _);
+  const m = () => {
     c.hasFocus = !0;
-  }, m = () => {
+  }, G = () => {
     c.hasFocus = !1;
-    const p = o(e.value);
-    t.val() !== p && t.val(p);
+    const I = o(e.value);
+    t.val() !== I && t.val(I);
   };
-  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());
+  t.on("focus", m), t.on("blur", G);
+  const N = () => {
+    c.phase === "idle" && (c.phase = "syncing-to-atom", e.value = r(t.val()), c.phase = "idle");
+  }, A = () => {
+    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(N, n)) : N());
   };
-  return t.on(i, v), t.on("change", v), { effect: () => {
-    const p = o(e.value), $ = t.val();
-    if ($ !== p) {
-      if (c.hasFocus && r($) === e.value)
+  return t.on(i, A), t.on("change", A), { effect: () => {
+    const I = o(e.value), H = t.val();
+    if (H !== I) {
+      if (c.hasFocus && r(H) === e.value)
         return;
-      c.phase = "syncing-to-dom", t.val(p), h.domUpdated(t, "val", p), c.phase = "idle";
+      c.phase = "syncing-to-dom", t.val(I), l.domUpdated(t, "val", I), 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", m), c.timeoutId && clearTimeout(c.timeoutId);
+    t.off(i, A), t.off("change", A), t.off("compositionstart", h), t.off("compositionend", _), t.off("focus", m), t.off("blur", G), c.timeoutId && clearTimeout(c.timeoutId);
   } };
 }
-class ut {
-  // DOM Element -> Effect Array (for disposal)
+class lt {
   effects = /* @__PURE__ */ new WeakMap();
-  // DOM Element -> Custom Cleanup Function Array
   cleanups = /* @__PURE__ */ new WeakMap();
-  // Track bound elements (Performance optimization)
   boundElements = /* @__PURE__ */ new WeakSet();
-  /**
-   * Tracks elements that are temporarily detached (e.g. via .detach())
-   * so they are NOT cleaned up by the MutationObserver.
-   */
   preservedNodes = /* @__PURE__ */ new WeakSet();
   keep(e) {
     this.preservedNodes.add(e);
@@ -1280,183 +1291,156 @@ class ut {
   isKept(e) {
     return this.preservedNodes.has(e);
   }
-  /**
-   * 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);
+    let n = this.effects.get(e);
+    n || (n = [], this.effects.set(e, n), this.boundElements.add(e)), n.push(s);
   }
-  /**
-   * 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);
+    let n = this.cleanups.get(e);
+    n || (n = [], this.cleanups.set(e, n), this.boundElements.add(e)), n.push(s);
   }
-  /**
-   * Checks if an element has bindings (Fast check).
-   */
   hasBind(e) {
     return this.boundElements.has(e);
   }
-  /**
-   * Cleans up a single element.
-   * - Disposes all Effects (severs connection with Atom).
-   * - Executes all custom cleanups.
-   */
   cleanup(e) {
-    if (!this.boundElements.has(e)) return;
-    h.cleanup(ue(e));
+    if (!this.boundElements.delete(e)) return;
+    l.cleanup(ae(e));
     const s = this.effects.get(e);
-    s && (this.effects.delete(e), s.forEach((i) => {
-      try {
-        i.dispose();
-      } catch (r) {
-        h.warn("Effect dispose error:", r);
+    if (s) {
+      this.effects.delete(e);
+      for (let i = 0, r = s.length; i < r; i++) {
+        const o = s[i];
+        if (o)
+          try {
+            o.dispose();
+          } catch (c) {
+            l.warn("Effect dispose error:", c);
+          }
       }
-    }));
+    }
     const n = this.cleanups.get(e);
-    n && (this.cleanups.delete(e), n.forEach((i) => {
-      try {
-        i();
-      } catch (r) {
-        h.warn("Cleanup error:", r);
+    if (n) {
+      this.cleanups.delete(e);
+      for (let i = 0, r = n.length; i < r; i++) {
+        const o = n[i];
+        if (o)
+          try {
+            o();
+          } catch (c) {
+            l.warn("Cleanup error:", c);
+          }
       }
-    })), this.boundElements.delete(e);
+    }
   }
-  /**
-   * Cleans up the element and all its descendants (Recursive).
-   * - Essential for deep removal (empty(), remove(), etc.).
-   */
   cleanupTree(e) {
-    e.querySelectorAll("*").forEach((n) => {
-      this.boundElements.has(n) && this.cleanup(n);
-    }), this.cleanup(e);
+    const s = e.querySelectorAll("*");
+    for (let n = 0, i = s.length; n < i; n++) {
+      const r = s[n];
+      r && this.boundElements.has(r) && this.cleanup(r);
+    }
+    this.cleanup(e);
   }
 }
-const l = new ut();
-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);
-      });
-  }), J.observe(t, { childList: !0, subtree: !0 }));
+const f = new lt();
+let W = null;
+function ft(t = document.body) {
+  W || (W = new MutationObserver((e) => {
+    for (let s = 0, n = e.length; s < n; s++) {
+      const i = e[s];
+      if (!i) continue;
+      const r = i.removedNodes;
+      for (let o = 0, c = r.length; o < c; o++) {
+        const h = r[o];
+        h && (f.isKept(h) || h.isConnected || h.nodeType === 1 && f.cleanupTree(h));
+      }
+    }
+  }), W.observe(t, { childList: !0, subtree: !0 }));
 }
-function It() {
-  J?.disconnect(), J = null;
+function Tt() {
+  W?.disconnect(), W = null;
 }
 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 ?? "");
-        s.text(r), h.domUpdated(s, "text", r);
+  if (p(t))
+    return this.each(function() {
+      const n = u(this), i = D(() => {
+        const r = t.value, o = e ? e(r) : String(r ?? "");
+        n.text(o), l.domUpdated(n, "text", o);
       });
-      l.trackEffect(this, n);
-    } else {
-      const n = e ? e(t) : String(t ?? "");
-      s.text(n);
-    }
-  });
+      f.trackEffect(this, i);
+    });
+  const s = e ? e(t) : String(t ?? "");
+  return this.text(s);
 };
 u.fn.atomHtml = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = String(E(t) ?? "");
-        e.html(n), h.domUpdated(e, "html", n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.html(String(t ?? ""));
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = String(t.value ?? "");
+      e.html(n), l.domUpdated(e, "html", n);
+    });
+    f.trackEffect(this, s);
+  }) : this.html(String(t ?? ""));
 };
 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);
-      });
-      l.trackEffect(this, n);
-    } else
-      s.toggleClass(t, !!e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = !!e.value;
+      s.toggleClass(t, i), l.domUpdated(s, `class.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : this.toggleClass(t, !!e);
 };
 u.fn.atomCss = function(t, e, s) {
-  return this.each(function() {
-    const n = u(this);
-    if (b(e)) {
-      const i = I(() => {
-        const r = E(e), o = s ? `${r}${s}` : r;
-        n.css(t, o), h.domUpdated(n, `css.${t}`, o);
+  if (p(e))
+    return this.each(function() {
+      const i = u(this), r = D(() => {
+        const o = e.value, c = s ? `${o}${s}` : o;
+        i.css(t, c), l.domUpdated(i, `css.${t}`, c);
       });
-      l.trackEffect(this, i);
-    } else
-      n.css(t, s ? `${e}${s}` : e);
-  });
+      f.trackEffect(this, r);
+    });
+  const n = s ? `${e}${s}` : e;
+  return this.css(t, n);
 };
 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);
-    };
-    if (b(e)) {
-      const i = I(() => n(E(e)));
-      l.trackEffect(this, i);
-    } else
-      n(e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = e.value;
+      i == null || i === !1 ? s.removeAttr(t) : i === !0 ? s.attr(t, t) : s.attr(t, String(i)), l.domUpdated(s, `attr.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : e == null || e === !1 ? this.removeAttr(t) : e === !0 ? this.attr(t, t) : this.attr(t, String(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);
-      });
-      l.trackEffect(this, n);
-    } else
-      s.prop(t, e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = e.value;
+      s.prop(t, i), l.domUpdated(s, `prop.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : this.prop(t, e);
 };
 u.fn.atomShow = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = !!E(t);
-        e.toggle(n), h.domUpdated(e, "show", n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.toggle(!!t);
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = !!t.value;
+      e.toggle(n), l.domUpdated(e, "show", n);
+    });
+    f.trackEffect(this, s);
+  }) : this.toggle(!!t);
 };
 u.fn.atomHide = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = !E(t);
-        e.toggle(n), h.domUpdated(e, "hide", !n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.toggle(!t);
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = !t.value;
+      e.toggle(n), l.domUpdated(e, "hide", !n);
+    });
+    f.trackEffect(this, s);
+  }) : this.toggle(!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 s = u(this), { effect: n, cleanup: i } = je(s, t, e), r = D(n);
+    f.trackEffect(this, r), f.trackCleanup(this, i);
   });
 };
 u.fn.atomChecked = function(t) {
@@ -1464,107 +1448,103 @@ u.fn.atomChecked = function(t) {
     const e = u(this);
     let s = !1;
     const n = () => {
-      s || z(() => {
-        t.value = e.prop("checked");
-      });
+      s || (t.value = !!e.prop("checked"));
     };
-    e.on("change", n), l.trackCleanup(this, () => e.off("change", n));
-    const i = I(() => {
-      s = !0, e.prop("checked", t.value), h.domUpdated(e, "checked", t.value), s = !1;
+    e.on("change", n), f.trackCleanup(this, () => e.off("change", n));
+    const i = D(() => {
+      s = !0;
+      const r = !!t.value;
+      e.prop("checked", r), l.domUpdated(e, "checked", r), s = !1;
     });
-    l.trackEffect(this, i);
+    f.trackEffect(this, i);
   });
 };
 u.fn.atomOn = function(t, e) {
   return this.each(function() {
-    const s = u(this), n = function(i) {
-      z(() => e.call(this, i));
-    };
-    s.on(t, n), l.trackCleanup(this, () => s.off(t, n));
+    const s = u(this);
+    s.on(t, e), f.trackCleanup(this, () => s.off(t, e));
   });
 };
 u.fn.atomUnbind = function() {
   return this.each(function() {
-    l.cleanupTree(this);
+    f.cleanupTree(this);
   });
 };
-function at(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = String(E(e) ?? "");
-    t.$el.text(s), h.domUpdated(t.$el, "text", s);
+function dt(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = String(k(e) ?? "");
+    t.$el.text(s), l.domUpdated(t.$el, "text", s);
   }) : t.$el.text(String(e ?? ""));
 }
-function lt(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = String(E(e) ?? "");
-    t.$el.html(s), h.domUpdated(t.$el, "html", s);
+function _t(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = String(k(e) ?? "");
+    t.$el.html(s), l.domUpdated(t.$el, "html", s);
   }) : t.$el.html(String(e ?? ""));
 }
-function ft(t, e) {
+function pt(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);
+    p(n) ? t.effects.push(() => {
+      const i = !!k(n);
+      t.$el.toggleClass(s, i), l.domUpdated(t.$el, `class.${s}`, i);
     }) : t.$el.toggleClass(s, !!n);
 }
-function dt(t, e) {
+function bt(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}`;
-        t.$el.css(s, o), h.domUpdated(t.$el, `css.${s}`, o);
+      p(i) ? t.effects.push(() => {
+        const o = `${k(i)}${r}`;
+        t.$el.css(s, o), l.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);
+    } else p(n) ? t.effects.push(() => {
+      const i = k(n);
+      t.$el.css(s, i), l.domUpdated(t.$el, `css.${s}`, i);
     }) : t.$el.css(s, n);
 }
-function _t(t, e) {
+function Et(t, e) {
   for (const [s, n] of Object.entries(e)) {
     const i = (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);
+      r == null || r === !1 ? t.$el.removeAttr(s) : r === !0 ? t.$el.attr(s, s) : t.$el.attr(s, String(r)), l.domUpdated(t.$el, `attr.${s}`, r);
     };
-    b(n) ? t.effects.push(() => i(E(n))) : i(n);
+    p(n) ? t.effects.push(() => i(k(n))) : i(n);
   }
 }
-function pt(t, e) {
+function gt(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);
+    p(n) ? t.effects.push(() => {
+      const i = k(n);
+      t.$el.prop(s, i), l.domUpdated(t.$el, `prop.${s}`, i);
     }) : t.$el.prop(s, n);
 }
-function bt(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = !!E(e);
-    t.$el.toggle(s), h.domUpdated(t.$el, "show", s);
+function mt(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = !!k(e);
+    t.$el.toggle(s), l.domUpdated(t.$el, "show", s);
   }) : t.$el.toggle(!!e);
 }
-function Et(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = !E(e);
-    t.$el.toggle(s), h.domUpdated(t.$el, "hide", !s);
+function St(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = !k(e);
+    t.$el.toggle(s), l.domUpdated(t.$el, "hide", !s);
   }) : 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);
+function yt(t, e) {
+  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = je(t.$el, s, n);
   t.effects.push(i), t.trackCleanup(r);
 }
-function mt(t, e) {
-  const s = ke(), n = () => {
-    s.phase === "idle" && z(() => {
-      e.value = t.$el.prop("checked");
-    });
+function Dt(t, e) {
+  const s = Le(), n = () => {
+    s.phase === "idle" && (e.value = t.$el.prop("checked"));
   };
   t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n)), t.effects.push(() => {
-    s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), h.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
+    s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), l.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
   });
 }
-function yt(t, e) {
+function It(t, e) {
   for (const [s, n] of Object.entries(e)) {
     const i = function(r) {
-      z(() => n.call(this, r));
+      n.call(this, r);
     };
     t.$el.on(s, i), t.trackCleanup(() => t.$el.off(s, i));
   }
@@ -1575,148 +1555,151 @@ u.fn.atomBind = function(t) {
       $el: e,
       el: this,
       effects: s,
-      trackCleanup: (i) => l.trackCleanup(this, i)
+      trackCleanup: (i) => f.trackCleanup(this, i)
     };
-    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 && yt(n, t.on), s.forEach((i) => {
-      const r = I(i);
-      l.trackEffect(this, r);
+    t.text !== void 0 && dt(n, t.text), t.html !== void 0 && _t(n, t.html), t.class && pt(n, t.class), t.css && bt(n, t.css), t.attr && Et(n, t.attr), t.prop && gt(n, t.prop), t.show !== void 0 && mt(n, t.show), t.hide !== void 0 && St(n, t.hide), t.val !== void 0 && yt(n, t.val), t.checked !== void 0 && Dt(n, t.checked), t.on && It(n, t.on), s.forEach((i) => {
+      const r = D(i);
+      f.trackEffect(this, r);
     });
   });
 };
-function St(t) {
-  if (t.length === 0) return [];
-  const e = t.slice(), s = [0];
-  let n, i, r, o;
-  const c = t.length;
-  for (n = 0; n < c; n++) {
-    const C = t[n];
-    if (C !== -1) {
-      const m = s[s.length - 1];
-      if (t[m] < C) {
-        e[n] = m, s.push(n);
-        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);
+function Ct(t) {
+  const e = t.length;
+  if (e === 0) return new Int32Array(0);
+  const s = new Int32Array(e), n = new Int32Array(e);
+  let i = 0;
+  for (let o = 0; o < e; o++) {
+    const c = t[o];
+    if (c === -1) continue;
+    if (i === 0 || t[n[i - 1]] < c) {
+      s[o] = i > 0 ? n[i - 1] : -1, n[i++] = o;
+      continue;
+    }
+    let h = 0, _ = i - 1;
+    for (; h < _; ) {
+      const m = h + _ >>> 1;
+      t[n[m]] < c ? h = m + 1 : _ = m;
     }
+    c < t[n[h]] && (h > 0 && (s[o] = n[h - 1]), n[h] = o);
   }
-  let f = s.length, _ = s[f - 1];
-  for (; f-- > 0; )
-    s[f] = _, _ = e[_];
-  return s;
+  const r = new Int32Array(i);
+  for (let o = i - 1, c = n[i - 1]; o >= 0; o--)
+    r[o] = c, c = s[c];
+  return r;
 }
 u.fn.atomList = function(t, e) {
+  const { key: s, render: n, bind: i, update: r, onAdd: o, onRemove: c, empty: h } = e, _ = typeof s == "function" ? s : (m) => m[s];
   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], m = /* @__PURE__ */ new Map();
-    let F = [], v = null;
-    const K = /* @__PURE__ */ new Set(), _e = I(() => {
-      const p = t.value, $ = [], pe = /* @__PURE__ */ new Set();
-      for (let a = 0; a < p.length; a++) {
-        const g = p[a], x = C(g, a);
-        $.push(x), pe.add(x);
+    const m = u(this), G = ae(this), N = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Set();
+    let M = [], $ = null;
+    const I = D(() => {
+      const H = t.value, O = H.length;
+      if (O === 0 ? h && !$ && ($ = u(h).appendTo(m)) : $ && ($.remove(), $ = null), O === 0 && N.size === 0) {
+        M = [];
+        return;
       }
-      if (h.log("list", `${n} updating with ${p.length} items`), p.length === 0 && _) {
-        v || (v = u(_), s.append(v));
-        for (const [, a] of m) {
-          a.$el.remove();
-          const g = a.$el[0];
-          g && l.cleanup(g);
-        }
-        m.clear(), F = [];
+      l.log("list", `${G} updating with ${O} items`);
+      const ee = new Array(O), Ee = /* @__PURE__ */ new Set();
+      for (let a = 0; a < O; a++) {
+        const b = H[a], C = _(b, a);
+        ee[a] = C, Ee.add(C);
+      }
+      for (const [a, b] of N) {
+        if (Ee.has(a) || A.has(a)) continue;
+        const C = () => {
+          b.$el.remove();
+          const E = b.$el[0];
+          E && f.cleanup(E), A.delete(a), l.log("list", `${G} removed item:`, a);
+        };
+        if (N.delete(a), A.add(a), c) {
+          const E = c(b.$el);
+          E instanceof Promise ? E.then(C) : C();
+        } else
+          C();
+      }
+      if (O === 0) {
+        M = [];
         return;
-      } else v && (v.remove(), v = null);
-      for (const [a, g] of m)
-        if (!pe.has(a)) {
-          if (K.has(a)) continue;
-          const x = () => {
-            g.$el.remove();
-            const W = g.$el[0];
-            W && l.cleanup(W), K.delete(a), h.log("list", `${n} removed item:`, a);
-          };
-          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 = $.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 = $[a], x = p[a], W = Ve.has(a);
-        if (m.has(g)) {
-          const N = m.get(g);
-          if (!N) continue;
-          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 G = U.nextSibling;
-            R && G !== R ? N.$el.insertBefore(R) : !R && G && N.$el.appendTo(s);
-          }
-          R = U;
+      }
+      const ge = /* @__PURE__ */ new Map();
+      for (let a = 0; a < M.length; a++) {
+        const b = M[a];
+        b !== void 0 && ge.set(b, a);
+      }
+      const me = new Int32Array(O);
+      for (let a = 0; a < O; a++) {
+        const b = ee[a];
+        me[a] = b !== void 0 ? ge.get(b) ?? -1 : -1;
+      }
+      const Se = Ct(me);
+      let le = Se.length - 1, U = null;
+      for (let a = O - 1; a >= 0; a--) {
+        const b = ee[a], C = H[a], E = N.get(b);
+        if (E) {
+          E.item = C;
+          const L = E.$el[0];
+          if (!L) continue;
+          r && r(E.$el, C, a), le >= 0 && Se[le] === a ? (le--, L.nextSibling !== U && (U ? E.$el.insertBefore(U) : E.$el.appendTo(m))) : U ? E.$el.insertBefore(U) : E.$el.appendTo(m), U = L;
         } else {
-          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", `${n} added item:`, g);
-          const G = U[0];
-          G && (R = G);
+          const L = n(C, a), j = L instanceof Element ? u(L) : u(L);
+          N.set(b, { $el: j, item: C }), U ? j.insertBefore(U) : j.appendTo(m), i && i(j, C, a), o && o(j), l.log("list", `${G} added item:`, b), U = j[0] || null;
         }
       }
-      F = $;
+      M = ee;
     });
-    l.trackEffect(this, _e), l.trackCleanup(this, () => {
-      m.clear(), F = [], v?.remove();
+    f.trackEffect(this, I), f.trackCleanup(this, () => {
+      N.clear(), A.clear(), M = [], $?.remove();
     });
   });
 };
-const se = /* @__PURE__ */ new WeakMap();
+const ie = /* @__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), n = ae(this), i = ie.get(this);
+    i && (l.log("mount", `${n} unmounting existing component`), i()), l.log("mount", `${n} mounting component`);
     let r;
     try {
       r = t(s, e);
-    } catch (f) {
-      console.error("[atom-effect-jquery] Mount error:", f);
+    } catch (h) {
+      console.error("[atom-effect-jquery] Mount error:", h);
       return;
     }
     let o = !1;
     const c = () => {
       if (!o) {
-        if (o = !0, h.log("mount", `${n} full cleanup`), typeof r == "function")
+        if (o = !0, l.log("mount", `${n} full cleanup`), typeof r == "function")
           try {
             r();
           } catch {
           }
-        l.cleanupTree(this), se.delete(this);
+        f.cleanupTree(this), ie.delete(this);
       }
     };
-    se.set(this, c), l.trackCleanup(this, c);
+    ie.set(this, c), f.trackCleanup(this, c);
   });
 };
 u.fn.atomUnmount = function() {
   return this.each(function() {
-    se.get(this)?.();
+    ie.get(this)?.();
   });
 };
-const Q = /* @__PURE__ */ new WeakMap();
-let Ie = !1;
-function Me() {
-  if (Ie) return;
-  Ie = !0;
+const J = /* @__PURE__ */ new WeakMap();
+let Te = !1;
+function Pe() {
+  if (Te) return;
+  Te = !0;
   const t = u.fn.on, e = u.fn.off, s = u.fn.remove, n = u.fn.empty, i = u.fn.detach;
   u.fn.remove = function(r) {
     return (r ? this.filter(r) : this).each(function() {
-      l.cleanupTree(this);
+      f.cleanupTree(this);
     }), s.call(this, r);
   }, u.fn.empty = function() {
     return this.each(function() {
-      this.querySelectorAll("*").forEach((o) => l.cleanup(o));
+      this.querySelectorAll("*").forEach((o) => f.cleanup(o));
     }), n.call(this);
   }, u.fn.detach = function(r) {
     return (r ? this.filter(r) : this).each(function() {
-      l.keep(this);
+      f.keep(this);
     }), i.call(this, r);
   }, u.fn.on = function(...r) {
     let o = -1;
@@ -1727,13 +1710,10 @@ function Me() {
       }
     if (o !== -1) {
       const c = r[o];
-      let f;
-      Q.has(c) ? f = Q.get(c) : (f = function(..._) {
-        let C;
-        return z(() => {
-          C = c.apply(this, _);
-        }), C;
-      }, Q.set(c, f)), r[o] = f;
+      let h;
+      J.has(c) ? h = J.get(c) : (h = function(..._) {
+        return c.apply(this, _);
+      }, J.set(c, h)), r[o] = h;
     }
     return t.apply(this, r);
   }, u.fn.off = function(...r) {
@@ -1745,27 +1725,27 @@ function Me() {
       }
     if (o !== -1) {
       const c = r[o];
-      Q.has(c) && (r[o] = Q.get(c));
+      J.has(c) && (r[o] = J.get(c));
     }
     return e.apply(this, r);
   };
 }
-const Ct = Me;
-Me();
+const xt = Pe;
+Pe();
 u(() => {
-  ht(document.body);
+  ft(document.body);
 });
 export {
-  tt as atom,
-  z as batch,
-  st as computed,
-  xt as default,
-  It as disableAutoCleanup,
-  I as effect,
-  ht as enableAutoCleanup,
-  Ct as enablejQueryBatching,
-  Me as enablejQueryOverrides,
-  l as registry,
-  Te as untracked
+  it as atom,
+  Je as batch,
+  rt as computed,
+  Ot as default,
+  Tt as disableAutoCleanup,
+  D as effect,
+  ft as enableAutoCleanup,
+  xt as enablejQueryBatching,
+  Pe as enablejQueryOverrides,
+  f as registry,
+  Ue as untracked
 };
 //# sourceMappingURL=index.mjs.map