@but212/atom-effect-jquery 0.13.1 → 0.14.0

package/dist/index.mjs

@@ -1,37 +1,34 @@
-import u from "jquery";
+import h from "jquery";
 import { default as wt } from "jquery";
-const Be = {
+const He = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, ce = {
+}, ue = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, ee = {
+}, v = {
   DISPOSED: 1,
-  // 0001 - Effect has been disposed
-  EXECUTING: 2
-  // 0010 - Effect is currently executing
+  HAS_FN_SUBS: 2,
+  HAS_OBJ_SUBS: 4
+}, N = {
+  ...v,
+  EXECUTING: 8
 }, l = {
-  DIRTY: 1,
-  // 0001 - Needs recomputation
-  IDLE: 2,
-  // 0010 - Initial state, not computed yet
-  PENDING: 4,
-  // 0100 - Async computation in progress
-  RESOLVED: 8,
-  // 1000 - Successfully computed
-  REJECTED: 16,
-  // 10000 - Computation failed
-  RECOMPUTING: 32,
-  // 100000 - Currently recomputing
-  HAS_ERROR: 64
-  // 1000000 - Has error state
-}, G = {
-  SYNC: 1,
-  NOTIFICATION_SCHEDULED: 2
-}, q = {
+  ...v,
+  DIRTY: 8,
+  IDLE: 16,
+  PENDING: 32,
+  RESOLVED: 64,
+  REJECTED: 128,
+  RECOMPUTING: 256,
+  HAS_ERROR: 512
+}, F = {
+  ...v,
+  SYNC: 8,
+  NOTIFICATION_SCHEDULED: 16
+}, V = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /**
@@ -47,55 +44,57 @@ const Be = {
   /** Maximum iterations for synchronous flush loop to prevent infinite loops */
   MAX_FLUSH_ITERATIONS: 1e3,
   /** Minimum allowed value for max flush iterations */
-  MIN_FLUSH_ITERATIONS: 10
-}, Se = {
+  MIN_FLUSH_ITERATIONS: 10,
+  /** Threshold for shrinking the batch queue to assist GC */
+  BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
+}, De = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, F = 1073741823, qe = 20, de = 1 << qe - 1, C = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ze = Object.freeze([]);
-class U extends Error {
+}, 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 {
   /**
    * 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, s = null, n = !0) {
-    super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
+  constructor(e, t = null, n = !0) {
+    super(e), this.name = "AtomError", this.cause = t, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class B extends U {
+class G extends k {
   /**
    * Creates a new ComputedError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, s = null) {
-    super(e, s, !0), this.name = "ComputedError";
+  constructor(e, t = null) {
+    super(e, t, !0), this.name = "ComputedError";
   }
 }
-class j extends U {
+class Q extends k {
   /**
    * Creates a new EffectError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, s = null) {
-    super(e, s, !1), this.name = "EffectError";
+  constructor(e, t = null) {
+    super(e, t, !1), this.name = "EffectError";
   }
 }
-class te extends U {
+class ne extends k {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
    * @param cause - Original error
    */
-  constructor(e, s = null) {
-    super(e, s, !1), this.name = "SchedulerError";
+  constructor(e, t = null) {
+    super(e, t, !1), this.name = "SchedulerError";
   }
 }
-const b = {
+const m = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -147,454 +146,413 @@ const b = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, le = /* @__PURE__ */ Symbol("debugName"), Qe = /* @__PURE__ */ Symbol("id"), fe = /* @__PURE__ */ Symbol("type"), De = /* @__PURE__ */ Symbol("noDefaultValue");
-function $e(t) {
-  return "dependencies" in t && Array.isArray(t.dependencies);
+}, 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);
 }
-let Ie = 0;
-function ve(t, e, s) {
-  if (t._visitedEpoch !== s) {
-    if (t._visitedEpoch = s, t === e)
-      throw new B("Indirect circular dependency detected");
-    if ($e(t)) {
-      const n = 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;
       for (let i = 0; i < n.length; i++) {
-        const r = n[i];
-        r && ve(r, e, s);
+        const o = n[i];
+        o && Re(o, e, t);
       }
     }
   }
 }
-const v = {
+const O = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: Se.MAX_DEPENDENCIES,
-  warnInfiniteLoop: Se.WARN_INFINITE_LOOP,
-  warn(t, e) {
-    this.enabled && t && console.warn(`[Atom Effect] ${e}`);
+  maxDependencies: De.MAX_DEPENDENCIES,
+  warnInfiniteLoop: De.WARN_INFINITE_LOOP,
+  warn(s, e) {
+    this.enabled && s && 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(t, e) {
-    if (t === e)
-      throw new B("Direct circular dependency detected");
-    this.enabled && (Ie++, ve(t, e, Ie));
+  checkCircular(s, e) {
+    if (s === e)
+      throw new G("Direct circular dependency detected");
+    this.enabled && (Ne++, Re(s, e, Ne));
   },
-  attachDebugInfo(t, e, s) {
+  attachDebugInfo(s, e, t) {
     if (!this.enabled)
       return;
-    const n = t;
-    n[le] = `${e}_${s}`, n[Qe] = s, n[fe] = e;
+    const n = s;
+    n[fe] = `${e}_${t}`, n[Qe] = t, n[_e] = e;
   },
-  getDebugName(t) {
-    if (t != null && le in t)
-      return t[le];
+  getDebugName(s) {
+    if (s != null && fe in s)
+      return s[fe];
   },
-  getDebugType(t) {
-    if (t != null && fe in t)
-      return t[fe];
+  getDebugType(s) {
+    if (s != null && _e in s)
+      return s[_e];
   }
 };
-let Xe = 1;
-const He = () => Xe++;
-class Ae {
+let Ye = 1;
+const Je = () => Ye++;
+class Ue {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = He() & F;
-  }
-  /**
-   * Rotates the phase by 1, automatically incrementing cycle on overflow.
-   *
-   * Performance Benefits:
-   * - Branchless: No conditional statements
-   * - O(1): Single bitwise AND operation
-   * - Smi-safe: Result always within 30-bit range (0x3fffffff)
-   *
-   * When Phase reaches 0xfffff (1,048,575), the next increment:
-   * - Overflows into Cycle bits
-   * - Phase resets to 0
-   * - Cycle increments by 1
-   *
-   * @returns The new version after phase rotation
-   */
-  rotatePhase() {
-    return this.version = this.version + 1 & F, this.version;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = Je() & A, this._tempUnsub = void 0;
   }
   /**
    * Calculates the logical distance (shift) between current and cached version.
-   *
-   * Uses modular arithmetic to handle cycle wraparound correctly.
-   * The result represents how many phase rotations have occurred since
-   * the cached version was recorded.
-   *
-   * Performance Benefits:
-   * - Branchless: Single subtraction with mask
-   * - Handles wraparound: Works correctly even when version overflows
-   *
-   * Use Cases:
-   * - Scheduler priority: Large shifts indicate stale updates
-   * - Dependency staleness: Detect how outdated a cached value is
-   *
-   * @param cachedVersion - The previously cached version to compare against
-   * @returns Non-negative shift distance (0 to 0x3fffffff)
    */
   getShift(e) {
-    return this.version - e & F;
+    return this.version - e & A;
   }
 }
-class Re extends Ae {
+class we extends Ue {
   /**
    * Subscribes a listener function or Subscriber object to value changes.
-   *
-   * @param listener - Function or Subscriber object to call when the value changes
-   * @returns An unsubscribe function
-   * @throws {AtomError} If listener is not a function or Subscriber
    */
   subscribe(e) {
-    if (typeof e == "object" && e !== null && "execute" in e)
-      return this._addSubscriber(this._getObjSubs(), e);
-    if (typeof e != "function")
-      throw new U(b.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
-    return this._addSubscriber(this._getFnSubs(), e);
+    if (typeof e == "function")
+      return this._addSubscriber(
+        this._fnSubs,
+        e,
+        v.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);
   }
   /**
    * Gets the total number of active subscribers.
    */
   subscriberCount() {
-    return (this._fnSubs?.length ?? 0) + (this._objSubs?.length ?? 0);
+    return this._fnSubs.length + this._objSubs.length;
   }
-  _addSubscriber(e, s) {
-    if (e.indexOf(s) !== -1) return () => {
+  /**
+   * 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(s);
-    let n = !1;
+    e.push(t), this.flags |= n;
+    let i = !1;
     return () => {
-      if (n) return;
-      n = !0;
-      const i = e.indexOf(s);
-      if (i !== -1) {
-        const r = e.length - 1;
-        i !== r && (e[i] = e[r]), e.pop();
+      if (i) return;
+      i = !0;
+      const o = e.indexOf(t);
+      if (o !== -1) {
+        const r = e.pop();
+        o < e.length && (e[o] = r), this.flags &= ~(e.length === 0 ? n : 0);
       }
     };
   }
   /**
    * Notifies all subscribers of a change.
-   *
-   * @param newValue - The new value
-   * @param oldValue - The old value
    */
-  _notifySubscribers(e, s) {
-    const n = this._fnSubs;
-    if (n)
-      for (let r = n.length - 1; r >= 0; r--)
-        try {
-          const o = n[r];
-          o && o(e, s);
-        } catch (o) {
-          console.error(
-            new U(b.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, o)
-          );
+  _notifySubscribers(e, t) {
+    const n = this.flags, i = v.HAS_FN_SUBS | v.HAS_OBJ_SUBS;
+    if (n & i) {
+      if (n & v.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);
+            } catch (a) {
+              console.error(
+                new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+              );
+            }
         }
-    const i = this._objSubs;
-    if (i)
-      for (let r = i.length - 1; r >= 0; r--)
-        try {
-          const o = i[r];
-          o && o.execute();
-        } catch (o) {
-          console.error(
-            new U(b.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, o)
-          );
+      }
+      if (n & v.HAS_OBJ_SUBS) {
+        const o = this._objSubs;
+        for (let r = 0, c = o.length; r < c; r++) {
+          const u = o[r];
+          if (u)
+            try {
+              u.execute();
+            } catch (a) {
+              console.error(
+                new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, a)
+              );
+            }
         }
+      }
+    }
+  }
+}
+class Ke {
+  constructor() {
+    this.acquired = 0, this.released = 0, this.rejected = new We();
   }
 }
-class pe {
+class We {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = C ? {
-      acquired: 0,
-      released: 0,
-      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
-    } : null;
+    this.frozen = 0, this.tooLarge = 0, this.poolFull = 0;
+  }
+}
+class ge {
+  constructor() {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = x ? new Ke() : null;
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return C && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    const e = this.stats;
+    return x && e && e.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
    * Clears the array before storing it.
-   * @param arr - The array to release.
-   * @param emptyConst - Optional reference to a constant empty array to skip.
    */
-  release(e, s) {
-    if (!(s && e === s)) {
-      if (Object.isFrozen(e)) {
-        C && this.stats && this.stats.rejected.frozen++;
-        return;
-      }
-      if (e.length > this.maxReusableCapacity) {
-        C && this.stats && this.stats.rejected.tooLarge++;
-        return;
-      }
-      if (this.pool.length >= this.maxPoolSize) {
-        C && this.stats && this.stats.rejected.poolFull++;
-        return;
-      }
-      e.length = 0, this.pool.push(e), C && this.stats && this.stats.released++;
+  release(e, t) {
+    if (t && e === t || Object.isFrozen(e)) {
+      const c = this.stats;
+      x && c && e !== t && 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++);
+      return;
+    }
+    e.length = 0, i.push(e);
+    const r = this.stats;
+    x && r && r.released++;
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!C || !this.stats) return null;
-    const { acquired: e, released: s, rejected: n } = this.stats, i = n.frozen + n.tooLarge + n.poolFull;
+    const e = this.stats;
+    if (!x || !e) return null;
+    const { acquired: t, released: n, rejected: i } = e, o = i.frozen + i.tooLarge + i.poolFull;
     return {
-      acquired: e,
-      released: s,
-      rejected: n,
-      leaked: e - s - i,
+      acquired: t,
+      released: n,
+      rejected: {
+        frozen: i.frozen,
+        tooLarge: i.tooLarge,
+        poolFull: i.poolFull
+      },
+      leaked: t - n - o,
       poolSize: this.pool.length
     };
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, C && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    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);
   }
 }
-const y = Object.freeze([]), N = Object.freeze([]), S = Object.freeze([]), w = new pe(), z = new pe(), T = new pe();
-function _e(t) {
-  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
-}
-function Ce(t) {
-  if (v.enabled && (t == null || typeof t == "object")) {
-    const e = v.getDebugType(t);
-    if (e)
-      return e === "computed";
-  }
-  return _e(t) && "invalidate" in t && typeof t.invalidate == "function";
-}
-function Oe(t) {
-  return t != null && typeof t.then == "function";
-}
-function Ge(t) {
-  return typeof t == "object" && t !== null;
-}
-function Ye(t) {
-  return (typeof t == "object" || typeof t == "function") && t !== null && typeof t.addDependency == "function";
-}
-function Je(t) {
-  return typeof t == "function" && typeof t.addDependency != "function";
-}
-function Ke(t) {
-  return Ge(t) && typeof t.execute == "function";
-}
-function Ue(t, e, s, n) {
-  if (e) {
-    if (Ye(e)) {
-      e.addDependency(t);
+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) {
+  if (e != null) {
+    if ((typeof e == "object" || typeof e == "function") && typeof e.addDependency == "function") {
+      e.addDependency(s);
       return;
     }
-    if (Je(e)) {
+    if (typeof e == "function") {
       const i = e;
-      s.indexOf(i) === -1 && s.push(i);
+      t.indexOf(i) === -1 && (t.push(i), s.flags |= v.HAS_FN_SUBS);
       return;
     }
-    Ke(e) && n.indexOf(e) === -1 && n.push(e);
+    typeof e == "object" && typeof e.execute == "function" && n.indexOf(e) === -1 && (n.push(e), s.flags |= v.HAS_OBJ_SUBS);
   }
 }
-function We(t, e, s, n) {
-  if (e !== y && s !== N)
-    for (let r = 0; r < e.length; r++) {
-      const o = e[r];
-      o && (o._tempUnsub = s[r]);
+function Te(s, e, t, n) {
+  const i = s.length, o = e.length, r = e !== I && o > 0;
+  if (r)
+    for (let u = 0; u < o; u++) {
+      const a = e[u];
+      a && (a._tempUnsub = t[u]);
     }
-  const i = z.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) : (v.checkCircular(o, n), i[r] = o.subscribe(n)));
-  }
-  if (e !== y)
-    for (let r = 0; r < e.length; r++) {
-      const o = e[r];
-      o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
+  const c = Y.acquire();
+  c.length = i;
+  for (let u = 0; u < i; u++) {
+    const a = s[u];
+    if (!a) continue;
+    const _ = a._tempUnsub;
+    _ ? (c[u] = _, a._tempUnsub = void 0) : (O.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);
+      }
     }
-  return s !== N && z.release(s), i;
+  return t !== B && Y.release(t), c;
 }
-let ne = 0;
-function we() {
-  return ne = ne + 1 & F || 1, ne;
+let oe = 0;
+function Fe() {
+  return oe = oe + 1 & A || 1, oe;
 }
 function Ze() {
-  return ne;
+  return oe;
 }
-let re = 0, ge = 0, oe = !1;
-function xe() {
-  return oe ? (C && console.warn(
+let pe = 0, be = 0, ce = !1;
+function ve() {
+  return ce ? (x && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (oe = !0, re = re + 1 & F, ge = 0, !0);
+  ), !1) : (ce = !0, pe = pe + 1 & A, be = 0, !0);
 }
-function Ne() {
-  oe = !1;
+function xe() {
+  ce = !1;
 }
 function et() {
-  return oe ? ++ge : 0;
+  return ce ? ++be : 0;
 }
 class tt {
   constructor() {
-    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this.urgentQueueA = [], this.urgentQueueB = [], this.urgentQueue = this.urgentQueueA, this.urgentQueueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = q.MAX_FLUSH_ITERATIONS;
+    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;
   }
+  /**
+   * Returns the current operational phase of the scheduler.
+   */
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
+  /** Current number of pending normal jobs. */
+  get queueSize() {
+    return this._sizes[0];
+  }
+  /** Current number of pending urgent jobs. */
+  get urgentQueueSize() {
+    return this._sizes[1];
+  }
   /**
    * Schedules a task for execution with optional priority based on phase shift.
-   *
-   * Priority Calculation (Branchless):
-   * - If sourceNode and cachedVersion are provided, calculates shift
-   * - Jobs with shift >= PHASE_THRESHOLD go to urgentQueue
-   * - Uses branchless bit manipulation: ((shift - THRESHOLD) >>> 31) ^ 1
-   *
-   * @param callback - The function to execute
-   * @param sourceNode - Optional reactive node for shift calculation
-   * @throws {SchedulerError} If the callback is not a function
    */
-  schedule(e, s) {
+  schedule(e, t) {
     if (typeof e != "function")
-      throw new te("Scheduler callback must be a function");
-    if (e._nextEpoch !== this._epoch)
-      if (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync)
-        this.batchQueue[this.batchQueueSize++] = e;
-      else {
-        const n = this._calculateUrgency(e, s);
-        this.urgentQueue[this.urgentQueueSize] = e, this.queue[this.queueSize] = e, this.urgentQueueSize += n, this.queueSize += n ^ 1, this.isProcessing || this.flush();
-      }
+      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;
+    }
+    const i = this._calculateUrgency(e, t);
+    this._activeQueues[i][this._sizes[i]++] = e, this.isProcessing || this.flush();
   }
   /**
    * Calculates urgency flag using branchless bit manipulation.
    *
-   * Formula: ((shift - PHASE_THRESHOLD) >>> 31) ^ 1
-   * - If shift >= THRESHOLD: (negative >>> 31) = 0, XOR 1 = 1 (urgent)
-   * - If shift < THRESHOLD: (positive >>> 31) = 0... wait, that's wrong
-   *
-   * Correct formula: (shift >= THRESHOLD) ? 1 : 0
-   * Branchless: ((PHASE_THRESHOLD - 1 - shift) >>> 31)
+   * 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, 0 if normal
+   * @returns 1 if urgent (shift >= PHASE_THRESHOLD), 0 otherwise.
    */
-  _calculateUrgency(e, s) {
-    if (!s || e._cachedVersion === void 0)
+  _calculateUrgency(e, t) {
+    if (!t || e._cachedVersion === void 0)
       return 0;
-    const n = s.getShift(e._cachedVersion);
+    const n = t.getShift(e._cachedVersion);
     return de - 1 - n >>> 31 & 1;
   }
+  /**
+   * Schedules a microtask-based flush of the queues.
+   * Coalesces multiple schedule calls into a single microtask execution.
+   */
   flush() {
-    this.isProcessing || this.queueSize === 0 && this.urgentQueueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+    this.isProcessing || this._sizes[0] === 0 && this._sizes[1] === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
-        if (this.queueSize === 0 && this.urgentQueueSize === 0) return;
-        const e = xe();
-        this._drainQueue(), e && Ne();
+        if (this._sizes[0] === 0 && this._sizes[1] === 0) return;
+        const e = ve();
+        this._drainQueue(), e && xe();
       } finally {
-        this.isProcessing = !1, (this.queueSize > 0 || this.urgentQueueSize > 0) && !this.isBatching && this.flush();
+        this.isProcessing = !1, (this._sizes[0] > 0 || this._sizes[1] > 0) && !this.isBatching && this.flush();
       }
     }));
   }
+  /**
+   * Immediately flushes all queues synchronously.
+   * Used at the end of a batch block or when immediate reflection is required.
+   */
   flushSync() {
     this.isFlushingSync = !0;
-    const e = xe();
+    const e = ve();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && Ne();
+      this.isFlushingSync = !1, e && xe();
     }
   }
+  /**
+   * Merges jobs from the batching queue into the primary normal queue.
+   * Increments the epoch/uses provided epoch to ensure deduplication.
+   */
   _mergeBatchQueue() {
-    if (this._epoch++, this.batchQueueSize > 0) {
-      for (let e = 0; e < this.batchQueueSize; e++) {
-        const s = this.batchQueue[e];
-        s && s._nextEpoch !== this._epoch && (s._nextEpoch = this._epoch, this.queue[this.queueSize++] = s);
-      }
-      this.batchQueueSize = 0;
+    const e = this.batchQueueSize;
+    if (e === 0) return;
+    const t = ++this._epoch, n = this.batchQueue, i = this._activeQueues[0];
+    let o = this._sizes[0];
+    for (let r = 0; r < e; r++) {
+      const c = n[r];
+      c._nextEpoch !== t && (c._nextEpoch = t, i[o++] = c);
     }
+    this._sizes[0] = o, this.batchQueueSize = 0, n.length > V.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
   }
-  /**
-   * Drains all queues, processing urgent queue completely first.
-   *
-   * Processing Order:
-   * 1. Process all urgent jobs (high phase shift = stale updates)
-   * 2. Process normal jobs
-   * 3. Repeat until both queues are empty
-   *
-   * This ordering reduces glitches by ensuring that the most
-   * impactful state changes are propagated first.
-   */
   _drainQueue() {
     let e = 0;
-    for (; this.urgentQueueSize > 0 || this.queueSize > 0; ) {
-      if (++e > this.maxFlushIterations) {
+    const t = this.maxFlushIterations;
+    for (; this._sizes[1] > 0 || this._sizes[0] > 0; ) {
+      if (++e > t) {
         this._handleFlushOverflow();
         return;
       }
-      this.urgentQueueSize > 0 && this._processUrgentQueue(), this.queueSize > 0 && this._processCurrentQueue(), this._mergeBatchQueue();
+      this._sizes[1] > 0 && this._processQueue(1), this._sizes[0] > 0 && this._processQueue(0), this._mergeBatchQueue();
     }
   }
-  /**
-   * Processes the urgent queue using double-buffering.
-   */
-  _processUrgentQueue() {
-    const e = this.urgentQueue, s = this.urgentQueueSize;
-    this.urgentQueue = this.urgentQueue === this.urgentQueueA ? this.urgentQueueB : this.urgentQueueA, this.urgentQueueSize = 0, this._epoch++, this._processJobs(e, s);
-  }
-  _processCurrentQueue() {
-    const e = this.queue, s = this.queueSize;
-    this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, this._processJobs(e, s);
+  _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);
   }
   _handleFlushOverflow() {
     console.error(
-      new te(
+      new ne(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
-    ), this.queueSize = 0, this.queue.length = 0, this.urgentQueueSize = 0, this.urgentQueue.length = 0, this.batchQueueSize = 0;
+    ), this._sizes[0] = 0, this._activeQueues[0].length = 0, this._sizes[1] = 0, this._activeQueues[1].length = 0, this.batchQueueSize = 0;
   }
-  _processJobs(e, s) {
-    for (let n = 0; n < s; n++) {
-      const i = e[n];
-      if (i)
-        try {
-          i();
-        } catch (r) {
-          console.error(
-            new te("Error occurred during scheduler execution", r)
-          );
-        }
-    }
+  _processJobs(e, t) {
+    for (let n = 0; n < t; n++)
+      try {
+        e[n]();
+      } catch (i) {
+        console.error(
+          new ne("Error occurred during scheduler execution", i)
+        );
+      }
     e.length = 0;
   }
-  /** Starts a new batch of updates. Updates will be deferred until endBatch is called. */
   startBatch() {
     this.batchDepth++, this.isBatching = !0;
   }
-  /**
-   * Ends the current batch. If the batch depth reaches zero, all pending updates are flushed synchronously.
-   */
   endBatch() {
     this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
   }
-  /**
-   * Configures the maximum number of iterations allowed during a synchronous flush.
-   * Used to prevent infinite loops.
-   * @param max - Maximum iterations count.
-   */
   setMaxFlushIterations(e) {
-    if (e < q.MIN_FLUSH_ITERATIONS)
-      throw new te(
-        `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
+    if (e < V.MIN_FLUSH_ITERATIONS)
+      throw new ne(
+        `Max flush iterations must be at least ${V.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const W = new tt();
+const te = new tt();
 class st {
   constructor() {
     this.current = null;
@@ -606,11 +564,11 @@ class st {
    * @param listener - The tracking listener to associate with the current execution.
    * @param fn - The function to execute.
    */
-  run(e, s) {
+  run(e, t) {
     const n = this.current;
     this.current = e;
     try {
-      return s();
+      return t();
     } finally {
       this.current = n;
     }
@@ -622,140 +580,159 @@ class st {
     return this.current;
   }
 }
-const Q = new st();
-function Fe(t) {
-  if (typeof t != "function")
-    throw new U("Untracked callback must be a function");
-  const e = Q.current;
-  Q.current = null;
+const y = new st();
+function Le(s) {
+  if (typeof s != "function")
+    throw new k("Untracked callback must be a function");
+  const e = y.current;
+  y.current = null;
   try {
-    return t();
+    return s();
   } finally {
-    Q.current = e;
+    y.current = e;
   }
 }
-class nt extends Re {
-  constructor(e, s) {
-    super(), this._fnSubs = null, this._objSubs = null, this._value = e, s && (this.flags |= G.SYNC), v.attachDebugInfo(this, "atom", this.id);
-  }
-  _getFnSubs() {
-    return this._fnSubs ??= [], this._fnSubs;
-  }
-  _getObjSubs() {
-    return this._objSubs ??= [], this._objSubs;
+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);
   }
   /**
    * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = Q.current;
-    return e && Ue(this, e, this._getFnSubs(), this._getObjSubs()), this._value;
+    const e = y.current;
+    return e && M(this, e, this._fnSubs, this._objSubs), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
    */
   set value(e) {
-    if (Object.is(this._value, e)) return;
-    const s = this._value;
-    this._value = e, this.rotatePhase(), ((this._fnSubs?.length ?? 0) > 0 || (this._objSubs?.length ?? 0) > 0) && this._scheduleNotification(s);
+    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);
   }
   /**
    * Schedules or flushes notifications based on sync mode and batching state.
    */
   _scheduleNotification(e) {
-    if (this.flags & G.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= G.NOTIFICATION_SCHEDULED), this.flags & G.SYNC && !W.isBatching) {
+    let t = this.flags;
+    if (t & F.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = t |= F.NOTIFICATION_SCHEDULED), t & F.SYNC && !te.isBatching) {
       this._flushNotifications();
       return;
     }
-    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), W.schedule(this._notifyTask);
+    let n = this._notifyTask;
+    n || (n = this._notifyTask = () => this._flushNotifications()), te.schedule(n);
   }
+  /**
+   * Flushes scheduled notifications and resets state for the next cycle.
+   */
   _flushNotifications() {
-    if (!(this.flags & G.NOTIFICATION_SCHEDULED)) return;
-    const e = this._pendingOldValue, s = this._value;
-    this._pendingOldValue = void 0, this.flags &= -3, this._notifySubscribers(s, e);
+    if (!(this.flags & F.NOTIFICATION_SCHEDULED))
+      return;
+    const e = this._pendingOldValue, t = this._value;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(t, e);
   }
+  /**
+   * Returns the current value without registering it as a dependency.
+   */
   peek() {
     return this._value;
   }
+  /**
+   * Disposes of the atom and releases all subscribers and tasks.
+   */
   dispose() {
-    this._fnSubs = null, this._objSubs = null, this._value = void 0, this._notifyTask = void 0;
+    this.flags & F.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= F.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function it(t, e = {}) {
-  return new nt(t, e.sync ?? !1);
+function it(s, e = {}) {
+  return new nt(s, 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 Ee(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
+}
+function Ae(s) {
+  if (O.enabled && (s == null || typeof s == "object")) {
+    const e = O.getDebugType(s);
+    if (e)
+      return e === "computed";
+  }
+  return Ee(s) && "invalidate" in s && typeof s.invalidate == "function";
 }
-function J(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 U)
-    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 ke(s) {
+  return s != null && typeof s.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 {
+  constructor(e) {
+    this._owner = e, this._epoch = -1, this._nextDeps = I, this._nextVersions = T, this._depCount = 0;
+  }
+  execute() {
+    this._owner._markDirty();
+  }
+  addDependency(e) {
+    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;
+  }
+  reset() {
+    this._epoch = -1, this._nextDeps = I, this._nextVersions = T, this._depCount = 0;
+  }
 }
-const ke = l.RESOLVED | l.PENDING | l.REJECTED, ue = Array(ke + 1).fill(ce.IDLE);
-ue[l.RESOLVED] = ce.RESOLVED;
-ue[l.PENDING] = ce.PENDING;
-ue[l.REJECTED] = ce.REJECTED;
-class Le extends Re {
-  constructor(e, s = {}) {
+class Me extends we {
+  constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new B(b.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._fnSubs = null, this._objSubs = null, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, 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 : De, this._hasDefaultValue = this._defaultValue !== De, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._dependencies = y, this._dependencyVersions = S, this._unsubscribes = N, this._notifyJob = () => {
-      const n = this._fnSubs;
-      if (n)
-        for (let r = n.length - 1; r >= 0; r--)
-          try {
-            const o = n[r];
-            o && o(void 0, void 0);
-          } catch (o) {
-            console.error(o);
-          }
-      const i = this._objSubs;
-      if (i)
-        for (let r = i.length - 1; r >= 0; r--)
-          try {
-            const o = i[r];
-            o && o.execute();
-          } catch (o) {
-            console.error(o);
-          }
-    }, this._trackable = Object.assign(() => this._markDirty(), {
-      addDependency: (n) => {
-      }
-    }), v.attachDebugInfo(this, "computed", this.id), v.enabled) {
+      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) {
       const n = this;
-      n.subscriberCount = this.subscriberCount.bind(this), n.isDirty = () => this._isDirty(), n.dependencies = this._dependencies, n.stateFlags = this._getFlagsAsString();
+      n.subscriberCount = this.subscriberCount.bind(this), n.isDirty = () => (this.flags & l.DIRTY) !== 0, n.dependencies = this._dependencies, n.stateFlags = "";
     }
-    if (s.lazy === !1)
+    if (t.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
-  _getFnSubs() {
-    return this._fnSubs ??= [], this._fnSubs;
-  }
-  _getObjSubs() {
-    return this._objSubs ??= [], this._objSubs;
-  }
   get value() {
-    return this._registerTracking(), this._computeValue();
+    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();
+    const n = this.flags;
+    return n & l.PENDING ? this._handlePending() : n & l.REJECTED ? this._handleRejected() : this._value;
   }
   peek() {
     return this._value;
   }
   get state() {
-    return this._registerTracking(), this._getAsyncState();
+    const e = y.current;
+    return e && M(this, e, this._fnSubs, this._objSubs), he[this.flags & Pe];
   }
   get hasError() {
-    if (this._registerTracking(), this._isRejected())
-      return !0;
-    for (let e = 0; e < this._dependencies.length; e++) {
-      const s = this._dependencies[e];
-      if (s && "hasError" in s && s.hasError)
-        return !0;
+    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 (o && o.flags & l.HAS_ERROR) return !0;
     }
     return !1;
   }
@@ -763,532 +740,451 @@ class Le extends Re {
     return !this.hasError;
   }
   get errors() {
-    if (this._registerTracking(), !this.hasError)
-      return ze;
-    const e = Ze();
-    if (this._errorCacheEpoch === e && this._cachedErrors !== null)
+    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)
       return this._cachedErrors;
-    const s = /* @__PURE__ */ new Set();
-    this._error && s.add(this._error);
-    for (let n = 0; n < this._dependencies.length; n++) {
-      const i = this._dependencies[n];
-      if (i && "errors" in i) {
-        const r = i.errors;
-        for (let o = 0; o < r.length; o++) {
-          const c = r[o];
-          c && s.add(c);
+    const n = /* @__PURE__ */ new Set();
+    this._error && n.add(this._error);
+    const i = this._dependencies;
+    for (let r = 0, c = i.length; r < c; r++) {
+      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);
         }
       }
     }
-    return this._cachedErrors = Object.freeze([...s]), this._errorCacheEpoch = e, this._cachedErrors;
+    const o = Object.freeze([...n]);
+    return this._cachedErrors = o, this._errorCacheEpoch = t, o;
   }
   get lastError() {
-    return this._registerTracking(), this._error;
+    const e = y.current;
+    return e && M(this, e, this._fnSubs, this._objSubs), this._error;
   }
   get isPending() {
-    return this._registerTracking(), this._isPending();
+    const e = y.current;
+    return e && M(this, e, this._fnSubs, this._objSubs), (this.flags & l.PENDING) !== 0;
   }
   get isResolved() {
-    return this._registerTracking(), this._isResolved();
+    const e = y.current;
+    return e && M(this, e, this._fnSubs, this._objSubs), (this.flags & l.RESOLVED) !== 0;
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== S && (T.release(this._dependencyVersions), this._dependencyVersions = S), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty();
+    const e = this._dependencyVersions;
+    e !== T && (L.release(e), this._dependencyVersions = T), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this._unsubscribes !== N) {
-      for (let e = 0; e < this._unsubscribes.length; e++) {
-        const s = this._unsubscribes[e];
-        s && s();
+    const e = this._unsubscribes;
+    if (e !== B) {
+      for (let i = 0, o = e.length; i < o; i++) {
+        const r = e[i];
+        r && r();
       }
-      z.release(this._unsubscribes), this._unsubscribes = N;
+      Y.release(e), this._unsubscribes = B;
     }
-    this._dependencies !== y && (w.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== S && (T.release(this._dependencyVersions), this._dependencyVersions = S), this._fnSubs = null, this._objSubs = null, this.flags = 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;
-  }
-  // State flag operations
-  _isDirty() {
-    return (this.flags & l.DIRTY) !== 0;
-  }
-  _setDirty() {
-    this.flags |= l.DIRTY;
+    const t = this._dependencies;
+    t !== I && (j.release(t), this._dependencies = I);
+    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;
   }
   _clearDirty() {
-    this.flags &= -2;
-  }
-  _isIdle() {
-    return (this.flags & l.IDLE) !== 0;
-  }
-  _setIdle() {
-    this.flags |= l.IDLE, this.flags &= -29;
-  }
-  _isPending() {
-    return (this.flags & l.PENDING) !== 0;
+    this.flags &= -9;
   }
   _setPending() {
-    this.flags |= l.PENDING, this.flags &= -27;
+    this.flags = (this.flags | l.PENDING) & -209;
   }
   _isResolved() {
     return (this.flags & l.RESOLVED) !== 0;
   }
   _setResolved() {
-    this.flags |= l.RESOLVED, this.flags &= -87;
+    this.flags = (this.flags | l.RESOLVED) & -689;
   }
   _isRejected() {
     return (this.flags & l.REJECTED) !== 0;
   }
   _setRejected() {
-    this.flags |= l.REJECTED | l.HAS_ERROR, this.flags &= -15;
-  }
-  _isRecomputing() {
-    return (this.flags & l.RECOMPUTING) !== 0;
+    this.flags = this.flags & -113 | (l.REJECTED | l.HAS_ERROR);
   }
   _setRecomputing(e) {
-    const s = l.RECOMPUTING;
-    this.flags = this.flags & ~s | -Number(e) & s;
-  }
-  _getAsyncState() {
-    return ue[this.flags & ke];
-  }
-  _getFlagsAsString() {
-    const e = [];
-    return this._isDirty() && e.push("DIRTY"), this._isIdle() && e.push("IDLE"), this._isPending() && e.push("PENDING"), this._isResolved() && e.push("RESOLVED"), this._isRejected() && e.push("REJECTED"), this._isRecomputing() && e.push("RECOMPUTING"), e.join(" | ");
-  }
-  _computeValue() {
-    return this._isRecomputing() ? this._value : ((this._isDirty() || this._isIdle()) && this._recompute(), this._isPending() ? this._handlePending() : this._isRejected() ? this._handleRejected() : this._value);
+    const t = l.RECOMPUTING;
+    this.flags = this.flags & ~t | (e ? -1 : 0) & t;
   }
   _recompute() {
-    if (this._isRecomputing()) return;
+    if (this.flags & l.RECOMPUTING)
+      return;
     this._setRecomputing(!0);
-    const e = this._prepareComputationContext();
-    let s = !1;
+    const e = this._trackable, t = this._dependencies, n = this._dependencyVersions;
+    e._epoch = Fe(), e._nextDeps = j.acquire(), e._nextVersions = L.acquire(), e._depCount = 0;
+    let i = !1;
     try {
-      const n = Q.run(this._trackable, this._fn);
-      this._commitDependencies(e), s = !0, Oe(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
-    } catch (n) {
-      if (!s)
+      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);
+    } catch (o) {
+      let r = o;
+      if (!i)
         try {
-          this._commitDependencies(e), s = !0;
-        } catch (i) {
-          this._handleComputationError(i);
+          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;
+        } catch (c) {
+          r = c;
         }
-      this._handleComputationError(n);
+      this._handleComputationError(r);
     } finally {
-      this._cleanupContext(e, s), this._setRecomputing(!1);
+      i ? (t !== I && j.release(t), n !== T && L.release(n)) : (j.release(e._nextDeps), L.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
     }
   }
-  _prepareComputationContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = w.acquire(), i = T.acquire(), r = we(), o = { depCount: 0 }, c = (d) => {
-      d._lastSeenEpoch !== r && (d._lastSeenEpoch = r, o.depCount < n.length ? (n[o.depCount] = d, i[o.depCount] = d.version) : (n.push(d), i.push(d.version)), o.depCount++);
-    }, 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 = We(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
-  }
-  _cleanupContext(e, s) {
-    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== y && w.release(e.prevDeps), e.prevVersions !== S && T.release(e.prevVersions)) : (w.release(e.nextDeps), T.release(e.nextVersions));
-  }
-  /**
-   * Calculates aggregate shift from all dependencies.
-   * Used for scheduling priority in computed chains.
-   *
-   * Performance: O(N) where N = dependency count
-   * Branchless: Each dep.getShift uses modular arithmetic
-   *
-   * @returns Sum of all dependency shifts (capped at SMI_MAX)
-   */
   _getAggregateShift() {
     let e = 0;
-    const s = this._dependencies, n = this._dependencyVersions;
-    for (let i = 0; i < s.length; i++) {
-      const r = s[i], o = n[i];
-      r && o !== void 0 && (e = e + r.getShift(o) & F);
+    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;
   }
-  /**
-   * Checks if this computed should be scheduled with urgent priority.
-   * Based on aggregate shift from all dependencies.
-   *
-   * @returns true if aggregate shift exceeds PHASE_THRESHOLD
-   */
   isUrgent() {
     return this._getAggregateShift() >= de;
   }
-  _handleSyncResult(e) {
-    this._finalizeResolution(e);
-  }
   _handleAsyncComputation(e) {
-    this._setPending(), this._clearDirty(), this._notifyJob(), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
-    const s = this._promiseId;
+    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;
     e.then((n) => {
-      if (s !== this._promiseId) return;
-      const i = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & F;
+      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();
           return;
         }
-        const r = new B(
-          `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries. Dependencies changed too rapidly for stable computation.`
+        const o = new G(
+          `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
         );
-        this._handleAsyncRejection(r);
+        this._handleAsyncRejection(o);
         return;
       }
-      this._handleAsyncResolution(n);
+      this._finalizeResolution(n), this._notifySubscribers(n, void 0);
     }).catch((n) => {
-      s === this._promiseId && this._handleAsyncRejection(n);
+      t === this._promiseId && this._handleAsyncRejection(n);
     });
   }
-  /**
-   * Captures the aggregate version of all dependencies.
-   * Used for phase drift validation in async computations.
-   *
-   * @returns Sum of all dependency versions (capped at SMI_MAX)
-   */
   _captureVersionSnapshot() {
     let e = 0;
-    const s = this._dependencies;
-    for (let n = 0; n < s.length; n++) {
-      const i = s[n];
-      i && (e = e + i.version & F);
+    const t = this._dependencies;
+    for (let n = 0, i = t.length; n < i; n++) {
+      const o = t[n];
+      o && (e = e + o.version & A);
     }
     return e;
   }
-  _handleAsyncResolution(e) {
-    this._finalizeResolution(e), this._notifyJob();
-  }
-  /**
-   * Unified success finalization for sync and async results.
-   * Handles phase rotation, state transition, and error cache clearing.
-   */
-  _finalizeResolution(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && this.rotatePhase(), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
-  }
   _handleAsyncRejection(e) {
-    const s = J(e, B, b.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    if (!this._isRejected() && this.rotatePhase(), this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    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 n = this._onError;
+    if (n)
       try {
-        this._onError(s);
-      } catch (n) {
-        console.error(b.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+        n(t);
+      } catch (i) {
+        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
-    this._notifyJob();
+    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;
   }
   _handleComputationError(e) {
-    const s = J(e, B, b.COMPUTED_COMPUTATION_FAILED);
-    if (this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const t = Z(e, G, m.COMPUTED_COMPUTATION_FAILED);
+    this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
+    const n = this._onError;
+    if (n)
       try {
-        this._onError(s);
-      } catch (n) {
-        console.error(b.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+        n(t);
+      } catch (i) {
+        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
-    throw s;
+    throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new B(b.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new G(m.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
-    if (this._error?.recoverable && this._hasDefaultValue)
+    const e = this._error;
+    if (e?.recoverable && this._hasDefaultValue)
       return this._defaultValue;
-    throw this._error;
+    throw e;
   }
-  /** Subscriber interface - marks dirty on dependency change */
   execute() {
     this._markDirty();
   }
+  /** @internal */
   _markDirty() {
-    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
-  }
-  _registerTracking() {
-    Ue(this, Q.getCurrent(), this._getFnSubs(), this._getObjSubs());
+    const e = this.flags;
+    e & (l.RECOMPUTING | l.DIRTY) || (this.flags = e | l.DIRTY, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Le.prototype);
-function rt(t, e = {}) {
-  return new Le(t, e);
+Object.freeze(Me.prototype);
+function rt(s, e = {}) {
+  return new Me(s, e);
 }
-class ot extends Ae {
-  /**
-   * Creates a new EffectImpl instance.
-   * @param fn - The effect function to run.
-   * @param options - Configuration options for the effect.
-   */
-  constructor(e, s = {}) {
-    super(), this.run = () => {
-      if (this.isDisposed)
-        throw new j(b.EFFECT_MUST_BE_FUNCTION);
-      this._dependencyVersions !== S && (T.release(this._dependencyVersions), this._dependencyVersions = S), this.execute();
-    }, this.dispose = () => {
-      if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== N) {
-          for (let i = 0; i < this._unsubscribes.length; i++) {
-            const r = this._unsubscribes[i];
-            r && r();
-          }
-          z.release(this._unsubscribes), this._unsubscribes = N;
-        }
-        this._dependencies !== y && (w.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== S && (T.release(this._dependencyVersions), this._dependencyVersions = S);
-      }
-    }, this.addDependency = (i) => {
-      if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        const r = this._currentEpoch;
-        if (i._lastSeenEpoch === r) return;
-        i._lastSeenEpoch = r, this._nextDeps.push(i), this._nextVersions.push(i.version), i._tempUnsub ? (this._nextUnsubs.push(i._tempUnsub), i._tempUnsub = void 0) : this._subscribeTo(i);
-      }
-    }, this.execute = () => {
-      if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
-      this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const i = this._prepareEffectExecutionContext();
-      let r = !1;
-      try {
-        const o = Q.run(this, this._fn);
-        this._commitEffect(i), r = !0, this._checkLoopWarnings(), Oe(o) ? o.then((c) => {
-          !this.isDisposed && typeof c == "function" && (this._cleanup = c);
-        }).catch((c) => {
-          this._handleExecutionError(c);
-        }) : this._cleanup = typeof o == "function" ? o : null;
-      } catch (o) {
-        r = !0, this._handleExecutionError(o), this._cleanup = null;
-      } finally {
-        this._cleanupEffect(i, r), this._setExecuting(!1);
+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;
+    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);
+  }
+  run() {
+    if (this.flags & N.DISPOSED)
+      throw new Q(m.EFFECT_MUST_BE_FUNCTION);
+    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];
+        c && c();
       }
-    }, this._cleanup = null, this._dependencies = y, this._dependencyVersions = S, this._unsubscribes = N, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, 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 ?? q.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? q.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._historyPtr = 0;
-    const n = Number.isFinite(this._maxExecutions);
-    this._historyCapacity = n ? Math.min(this._maxExecutions + 1, q.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = C && n && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, v.attachDebugInfo(this, "effect", this.id);
+      Y.release(t), this._unsubscribes = B;
+    }
+    const n = this._dependencies;
+    n !== I && (j.release(n), this._dependencies = I);
+    const i = this._dependencyVersions;
+    i !== T && (L.release(i), this._dependencyVersions = T), this._executeTask = void 0;
+  }
+  addDependency(e) {
+    if (!(this.flags & N.EXECUTING)) return;
+    const t = this._currentEpoch;
+    if (e._lastSeenEpoch === t) return;
+    e._lastSeenEpoch = t;
+    const n = this._nextDeps, i = this._nextVersions, o = this._nextUnsubs;
+    if (!n || !i || !o) return;
+    n.push(e), i.push(e.version);
+    const r = e._tempUnsub;
+    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;
+    this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
+    const t = 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;
+    } catch (i) {
+      n = !0, this._handleExecutionError(i), this._cleanup = null;
+    } finally {
+      this._cleanupEffect(t, n), this._setExecuting(!1);
+    }
   }
-  /**
-   * Prepares the execution context by acquiring pools and setting up epoch.
-   * @returns The prepared EffectExecutionContext.
-   */
   _prepareEffectExecutionContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = w.acquire(), r = T.acquire(), o = z.acquire(), c = we();
-    if (e !== y && n !== N)
-      for (let h = 0; h < e.length; h++) {
-        const d = e[h];
-        d && (d._tempUnsub = n[h]);
+    const e = this._dependencies, t = this._dependencyVersions, n = this._unsubscribes, i = j.acquire(), o = L.acquire(), r = Y.acquire(), c = Fe();
+    if (e !== I)
+      for (let u = 0, a = e.length; u < a; u++) {
+        const _ = e[u];
+        _ && (_._tempUnsub = n[u]);
       }
-    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 };
-  }
-  /**
-   * Commits the tracked dependencies as the current active dependencies.
-   * @param ctx - The current effect context.
-   */
-  _commitEffect(e) {
-    const s = e.nextDeps.length;
-    e.nextDeps.length = s, e.nextVersions.length = s, this._dependencies = e.nextDeps, this._dependencyVersions = e.nextVersions, this._unsubscribes = e.nextUnsubs;
-  }
-  /**
-   * Cleans up the effect execution context, releasing resources back to pools.
-   * @param ctx - The effect context to clean up.
-   * @param committed - Whether the changes were committed to the effect.
-   */
-  _cleanupEffect(e, s) {
-    if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, s) {
-      if (e.prevDeps !== y) {
-        for (let n = 0; n < e.prevDeps.length; n++) {
-          const i = e.prevDeps[n];
-          i?._tempUnsub && (i._tempUnsub(), i._tempUnsub = void 0);
+    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 };
+  }
+  _cleanupEffect(e, t) {
+    this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null;
+    const n = e.prevDeps;
+    if (t) {
+      if (n !== I) {
+        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));
         }
-        w.release(e.prevDeps);
+        j.release(n);
       }
-      e.prevUnsubs !== N && z.release(e.prevUnsubs), e.prevVersions !== S && T.release(e.prevVersions);
+      e.prevUnsubs !== B && Y.release(e.prevUnsubs), e.prevVersions !== T && L.release(e.prevVersions);
     } else {
-      w.release(e.nextDeps), T.release(e.nextVersions);
-      for (let n = 0; n < e.nextUnsubs.length; n++)
-        e.nextUnsubs[n]?.();
-      if (z.release(e.nextUnsubs), e.prevDeps !== y)
-        for (let n = 0; n < e.prevDeps.length; n++) {
-          const i = e.prevDeps[n];
-          i && (i._tempUnsub = void 0);
+      j.release(e.nextDeps), L.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)
+        for (let o = 0, r = n.length; o < r; o++) {
+          const c = n[o];
+          c && (c._tempUnsub = void 0);
         }
     }
   }
-  /**
-   * Subscribes to a dependency's changes.
-   * @param dep - The dependency to subscribe to.
-   */
   _subscribeTo(e) {
     try {
-      const s = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : W.schedule(this.execute);
-      });
-      this._nextUnsubs && this._nextUnsubs.push(s);
-    } catch (s) {
-      console.error(J(s, j, b.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      const t = e.subscribe(() => {
+        if (this._trackModifications && this.flags & N.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) {
+          this.execute();
+          return;
+        }
+        let i = this._executeTask;
+        i || (i = this._executeTask = () => this.execute()), te.schedule(i);
+      }), n = this._nextUnsubs;
+      n && n.push(t);
+    } catch (t) {
+      console.error(Z(t, Q, m.EFFECT_EXECUTION_FAILED));
+      const n = this._nextUnsubs;
+      n && n.push(() => {
       });
     }
   }
-  /**
-   * Whether the effect has been disposed.
-   */
   get isDisposed() {
-    return (this.flags & ee.DISPOSED) !== 0;
+    return (this.flags & N.DISPOSED) !== 0;
   }
-  /**
-   * Total number of times this effect has executed.
-   */
   get executionCount() {
     return this._executionCount;
   }
-  /**
-   * Whether the effect is currently executing.
-   */
   get isExecuting() {
-    return (this.flags & ee.EXECUTING) !== 0;
+    return (this.flags & N.EXECUTING) !== 0;
   }
   _setDisposed() {
-    this.flags |= ee.DISPOSED;
+    this.flags |= N.DISPOSED;
   }
   _setExecuting(e) {
-    const s = ee.EXECUTING;
-    this.flags = this.flags & ~s | -Number(e) & s;
+    const t = N.EXECUTING;
+    this.flags = this.flags & ~t | (e ? -1 : 0) & t;
   }
-  /**
-   * Executes the cleanup function if it exists.
-   */
   _safeCleanup() {
-    if (this._cleanup) {
+    const e = this._cleanup;
+    if (e) {
       try {
-        this._cleanup();
-      } catch (e) {
-        console.error(J(e, j, b.EFFECT_CLEANUP_FAILED));
+        e();
+      } catch (t) {
+        console.error(Z(t, Q, m.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
   }
-  /**
-   * Checks for infinite loops by tracking execution counts within a flush and time period.
-   * @throws {EffectError} If an infinite loop is detected.
-   */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== re && (this._lastFlushEpoch = re, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), et() > q.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 < Be.ONE_SECOND_MS) {
-        const o = new j(
-          `Effect executed ${n} times within 1 second. Infinite loop suspected`
+    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 n = Date.now(), i = this._historyPtr, o = this._historyCapacity;
+      t[i] = n;
+      const r = (i + 1) % o;
+      this._historyPtr = r;
+      const c = t[r] ?? 0;
+      if (c > 0 && n - c < He.ONE_SECOND_MS) {
+        const u = new Q(
+          `Effect executed ${o} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(o), this._onError && this._onError(o), C)
-          throw o;
+        if (this.dispose(), console.error(u), this._onError && this._onError(u), x) throw u;
       }
     }
   }
   _throwInfiniteLoopError(e) {
-    const s = new j(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${ge}`
+    const t = new Q(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${be}`
     );
-    throw this.dispose(), console.error(s), s;
+    throw this.dispose(), console.error(t), t;
   }
-  /**
-   * Determines if the effect should execute based on dependency versions.
-   * @returns true if any dependency has changed or if it's the first run.
-   */
   _shouldExecute() {
-    if (this._dependencies === y || this._dependencyVersions === S)
-      return !0;
-    for (let e = 0; e < this._dependencies.length; e++) {
-      const s = this._dependencies[e];
-      if (s) {
-        if ("value" in s)
+    const e = this._dependencies;
+    if (e.length === 0) return !0;
+    const t = 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 ("value" in o)
           try {
-            Fe(() => s.value);
+            Le(() => o.value);
           } catch {
             return !0;
           }
-        if (s.version !== this._dependencyVersions[e])
-          return !0;
       }
     }
     return !1;
   }
-  /**
-   * Handles errors occurring during effect execution.
-   * Wraps the error, logs it to console, and calls onError callback if provided.
-   */
   _handleExecutionError(e) {
-    const s = J(e, j, b.EFFECT_EXECUTION_FAILED);
-    console.error(s), this._onError && this._onError(s);
+    const t = Z(e, Q, m.EFFECT_EXECUTION_FAILED);
+    console.error(t);
+    const n = this._onError;
+    n && n(t);
   }
-  /**
-   * Checks for potential infinite loops where an effect modifies its own dependencies.
-   * Only active if trackModifications is enabled and debug is on.
-   */
   _checkLoopWarnings() {
-    if (this._trackModifications && v.enabled) {
-      const e = this._dependencies;
-      for (let s = 0; s < e.length; s++) {
-        const n = e[s];
-        n && n._modifiedAtEpoch === this._currentEpoch && v.warn(
+    if (this._trackModifications && O.enabled) {
+      const e = this._dependencies, t = this._currentEpoch;
+      for (let n = 0, i = e.length; n < i; n++) {
+        const o = e[n];
+        o && o._modifiedAtEpoch === t && O.warn(
           !0,
-          `Effect is reading a dependency (${v.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${O.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function $(t, e = {}) {
-  if (typeof t != "function")
-    throw new j(b.EFFECT_MUST_BE_FUNCTION);
-  const s = new ot(t, e);
-  return s.execute(), s;
+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 ct(t) {
-  if (typeof t != "function")
-    throw new U("Batch callback must be a function");
-  W.startBatch();
+function Ve(s) {
+  if (typeof s != "function")
+    throw new k("Batch callback must be a function");
+  te.startBatch();
   try {
-    return t();
+    return s();
   } finally {
-    W.endBatch();
+    te.endBatch();
   }
 }
-function ut(t) {
-  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
+function ut(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s;
 }
-function he(t) {
-  if (!t) return "unknown";
-  const e = "jquery" in t ? t[0] : t;
+function ae(s) {
+  if (!s) return "unknown";
+  const e = "jquery" in s ? s[0] : s;
   if (!e) return "unknown";
   if (e.id) return `#${e.id}`;
   if (e.className) {
-    const s = String(e.className).split(/\s+/).filter(Boolean).join(".");
-    return s ? `${e.tagName.toLowerCase()}.${s}` : e.tagName.toLowerCase();
+    const t = String(e.className).split(/\s+/).filter(Boolean).join(".");
+    return t ? `${e.tagName.toLowerCase()}.${t}` : e.tagName.toLowerCase();
   }
   return e.tagName.toLowerCase();
 }
-function ht(t) {
-  const e = t.length;
+function ht(s) {
+  const e = s.length;
   if (e === 0) return new Int32Array(0);
-  const s = new Int32Array(e), n = new Int32Array(e);
+  const t = new Int32Array(e), n = new Int32Array(e);
   let i = 0;
-  for (let o = 0; o < e; o++) {
-    const c = t[o];
+  for (let r = 0; r < e; r++) {
+    const c = s[r];
     if (c === -1) continue;
-    if (i === 0 || t[n[i - 1]] < c) {
-      s[o] = i > 0 ? n[i - 1] : -1, n[i++] = o;
+    if (i === 0 || s[n[i - 1]] < c) {
+      t[r] = i > 0 ? n[i - 1] : -1, n[i++] = r;
       continue;
     }
-    let h = 0, d = i - 1;
-    for (; h < d; ) {
-      const m = h + d >>> 1;
-      t[n[m]] < c ? h = m + 1 : d = m;
+    let u = 0, a = i - 1;
+    for (; u < a; ) {
+      const _ = u + a >>> 1;
+      s[n[_]] < c ? u = _ + 1 : a = _;
     }
-    c < t[n[h]] && (h > 0 && (s[o] = n[h - 1]), n[h] = o);
+    c < s[n[u]] && (u > 0 && (t[r] = n[u - 1]), n[u] = r);
   }
-  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;
+  const o = new Int32Array(i);
+  for (let r = i - 1, c = n[i - 1]; r >= 0; r--)
+    o[r] = c, c = t[c];
+  return o;
 }
 function at() {
   if (typeof window < "u") {
-    const t = window.__ATOM_DEBUG__;
-    if (typeof t == "boolean")
-      return t;
+    const s = window.__ATOM_DEBUG__;
+    if (typeof s == "boolean")
+      return s;
   }
   try {
     if (typeof process < "u" && process.env && process.env.NODE_ENV === "development")
@@ -1297,93 +1193,93 @@ function at() {
   }
   return !1;
 }
-let M = at();
+let q = at();
 const g = {
   get enabled() {
-    return M;
+    return q;
   },
-  set enabled(t) {
-    M = t;
+  set enabled(s) {
+    q = s;
   },
-  log(t, ...e) {
-    M && console.log(`[atom-effect-jquery] ${t}:`, ...e);
+  log(s, ...e) {
+    q && console.log(`[atom-effect-jquery] ${s}:`, ...e);
   },
-  atomChanged(t, e, s) {
-    M && console.log(`[atom-effect-jquery] Atom "${t || "anonymous"}" changed:`, e, "→", s);
+  atomChanged(s, e, t) {
+    q && console.log(`[atom-effect-jquery] Atom "${s || "anonymous"}" changed:`, e, "→", t);
   },
   /**
    * Logs DOM updates and triggers visual highlight.
    */
-  domUpdated(t, e, s) {
-    if (!M) return;
-    const n = he(t);
-    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), lt(t);
+  domUpdated(s, e, t) {
+    if (!q) return;
+    const n = ae(s);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, t), lt(s);
   },
-  cleanup(t) {
-    M && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
+  cleanup(s) {
+    q && console.log(`[atom-effect-jquery] Cleanup: ${s}`);
   },
-  warn(...t) {
-    M && console.warn("[atom-effect-jquery]", ...t);
+  warn(...s) {
+    q && console.warn("[atom-effect-jquery]", ...s);
   }
 };
-function lt(t) {
-  const e = t[0];
+function lt(s) {
+  const e = s[0];
   if (!e || !document.contains(e)) return;
-  const s = "atom_debug_timer", n = "atom_debug_cleanup_timer", i = "atom_debug_org_style";
-  clearTimeout(t.data(s)), clearTimeout(t.data(n)), t.data(i) || t.data(i, {
-    outline: t.css("outline"),
-    outlineOffset: t.css("outline-offset"),
-    transition: t.css("transition")
-  }), t.css({
+  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({
     outline: "2px solid rgba(255, 68, 68, 0.8)",
     "outline-offset": "1px",
     transition: "none"
     // Remove transition for instant feedback on update
   });
-  const r = setTimeout(() => {
-    const o = t.data(i);
-    t.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
-      t.css({
-        outline: o?.outline || "",
-        "outline-offset": o?.outlineOffset || ""
+  const o = setTimeout(() => {
+    const r = s.data(i);
+    s.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
+      s.css({
+        outline: r?.outline || "",
+        "outline-offset": r?.outlineOffset || ""
       });
       const c = setTimeout(() => {
-        t.css("transition", o?.transition || ""), t.removeData(s), t.removeData(n), t.removeData(i);
+        s.css("transition", r?.transition || ""), s.removeData(t), s.removeData(n), s.removeData(i);
       }, 500);
-      t.data(n, c);
+      s.data(n, c);
     });
   }, 100);
-  t.data(s, r);
+  s.data(t, o);
 }
 const ft = /* @__PURE__ */ new WeakMap();
-function Pe(t, e = {}) {
-  const s = it(t, e);
-  return e.name && ft.set(s, { name: e.name }), s;
+function Be(s, e = {}) {
+  const t = it(s, e);
+  return e.name && ft.set(t, { name: e.name }), t;
 }
-Object.defineProperty(Pe, "debug", {
+Object.defineProperty(Be, "debug", {
   get() {
     return g.enabled;
   },
-  set(t) {
-    g.enabled = t;
+  set(s) {
+    g.enabled = s;
   }
 });
-function dt() {
-  return new Promise((t) => setTimeout(t, 0));
+function _t() {
+  return new Promise((s) => setTimeout(s, 0));
 }
-u.extend({
-  atom: Pe,
+h.extend({
+  atom: Be,
   computed: rt,
-  effect: $,
-  batch: ct,
-  untracked: Fe,
-  isAtom: _e,
-  isComputed: Ce,
-  isReactive: (t) => _e(t) || Ce(t),
-  nextTick: dt
+  effect: J,
+  batch: Ve,
+  untracked: Le,
+  isAtom: Ee,
+  isComputed: Ae,
+  isReactive: (s) => Ee(s) || Ae(s),
+  nextTick: _t
 });
-const se = "_aes-bound";
-class _t {
+const ie = "_aes-bound";
+class dt {
   effects = /* @__PURE__ */ new WeakMap();
   cleanups = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
@@ -1402,28 +1298,28 @@ class _t {
   isIgnored(e) {
     return this.ignoredNodes.has(e);
   }
-  trackEffect(e, s) {
+  trackEffect(e, t) {
     let n = this.effects.get(e);
-    n || (n = [], this.effects.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(se))), n.push(s);
+    n || (n = [], this.effects.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ie))), n.push(t);
   }
-  trackCleanup(e, s) {
+  trackCleanup(e, t) {
     let n = this.cleanups.get(e);
-    n || (n = [], this.cleanups.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(se))), n.push(s);
+    n || (n = [], this.cleanups.set(e, n), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(ie))), n.push(t);
   }
   hasBind(e) {
     return this.boundElements.has(e);
   }
   cleanup(e) {
     if (!this.boundElements.delete(e)) return;
-    e.classList.remove(se), g.cleanup(he(e));
-    const s = this.effects.get(e);
-    if (s) {
+    e.classList.remove(ie), g.cleanup(ae(e));
+    const t = this.effects.get(e);
+    if (t) {
       this.effects.delete(e);
-      for (let i = 0, r = s.length; i < r; i++) {
-        const o = s[i];
-        if (o)
+      for (let i = 0, o = t.length; i < o; i++) {
+        const r = t[i];
+        if (r)
           try {
-            o.dispose();
+            r.dispose();
           } catch (c) {
             g.warn("Effect dispose error:", c);
           }
@@ -1432,11 +1328,11 @@ class _t {
     const n = this.cleanups.get(e);
     if (n) {
       this.cleanups.delete(e);
-      for (let i = 0, r = n.length; i < r; i++) {
-        const o = n[i];
-        if (o)
+      for (let i = 0, o = n.length; i < o; i++) {
+        const r = n[i];
+        if (r)
           try {
-            o();
+            r();
           } catch (c) {
             g.warn("Cleanup error:", c);
           }
@@ -1444,489 +1340,489 @@ class _t {
     }
   }
   cleanupDescendants(e) {
-    const s = e.querySelectorAll(`.${se}`);
-    for (let n = 0, i = s.length; n < i; n++) {
-      const r = s[n];
-      r && this.boundElements.has(r) && this.cleanup(r);
+    const t = e.querySelectorAll(`.${ie}`);
+    for (let n = 0, i = t.length; n < i; n++) {
+      const o = t[n];
+      o && this.boundElements.has(o) && this.cleanup(o);
     }
   }
   cleanupTree(e) {
     this.cleanupDescendants(e), this.cleanup(e);
   }
 }
-const f = new _t();
-let K = null;
-function pt(t = document.body) {
-  K || (K = new MutationObserver((e) => {
-    for (let s = 0, n = e.length; s < n; s++) {
-      const i = e[s];
+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];
       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) || f.isIgnored(h) || h.isConnected || h.nodeType === 1 && f.cleanupTree(h));
+      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));
       }
     }
-  }), K.observe(t, { childList: !0, subtree: !0 }));
+  }), ee.observe(s, { childList: !0, subtree: !0 }));
 }
 function At() {
-  K?.disconnect(), K = null;
+  ee?.disconnect(), ee = null;
 }
-function _(t, e, s, n) {
-  const i = u(t), r = t;
+function p(s, e, t, n) {
+  const i = h(s), o = s;
   if (ut(e)) {
-    const o = $(() => {
+    const r = J(() => {
       const c = e.value;
-      s(c), g.domUpdated(i, n, c);
+      t(c), g.domUpdated(i, n, c);
     });
-    f.trackEffect(r, o);
+    d.trackEffect(o, r);
   } else
-    s(e);
+    t(e);
 }
-function Ve() {
+function je() {
   return { timeoutId: null, phase: "idle", hasFocus: !1 };
 }
-function Me(t, e, s = {}) {
+function ze(s, e, t = {}) {
   const {
     debounce: n,
     event: i = "input",
-    parse: r = (D) => D,
-    format: o = (D) => String(D ?? "")
-  } = s, c = Ve(), h = () => {
+    parse: o = (D) => D,
+    format: r = (D) => String(D ?? "")
+  } = t, c = je(), u = () => {
     c.phase = "composing";
-  }, d = () => {
-    c.phase = "idle", x();
+  }, a = () => {
+    c.phase = "idle", S();
   };
-  t.on("compositionstart", h), t.on("compositionend", d);
-  const m = () => {
+  s.on("compositionstart", u), s.on("compositionend", a);
+  const _ = () => {
     c.hasFocus = !0;
-  }, X = () => {
+  }, P = () => {
     c.hasFocus = !1;
-    const D = o(e.value);
-    t.val() !== D && t.val(D);
+    const D = r(e.value);
+    s.val() !== D && s.val(D);
   };
-  t.on("focus", m), t.on("blur", X);
-  const x = () => {
-    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(x, n)) : x());
+  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());
   };
-  return t.on(i, A), t.on("change", A), { effect: () => {
-    const D = o(e.value), H = t.val();
-    if (H !== D) {
-      if (c.hasFocus && r(H) === e.value)
+  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;
-      c.phase = "syncing-to-dom", t.val(D), g.domUpdated(t, "val", D), c.phase = "idle";
+      c.phase = "syncing-to-dom", s.val(D), g.domUpdated(s, "val", D), c.phase = "idle";
     }
   }, cleanup: () => {
-    t.off(i, A), t.off("change", A), t.off("compositionstart", h), t.off("compositionend", d), t.off("focus", m), t.off("blur", X), c.timeoutId && clearTimeout(c.timeoutId);
+    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);
   } };
 }
-u.fn.atomText = function(t, e) {
+h.fn.atomText = function(s, e) {
   return this.each(function() {
-    _(
+    p(
       this,
-      t,
-      (s) => {
-        const n = e ? e(s) : String(s ?? "");
-        u(this).text(n);
+      s,
+      (t) => {
+        const n = e ? e(t) : String(t ?? "");
+        h(this).text(n);
       },
       "text"
     );
   });
 };
-u.fn.atomHtml = function(t) {
+h.fn.atomHtml = function(s) {
   return this.each(function() {
-    _(this, t, (e) => u(this).html(String(e ?? "")), "html");
+    p(this, s, (e) => h(this).html(String(e ?? "")), "html");
   });
 };
-u.fn.atomClass = function(t, e) {
+h.fn.atomClass = function(s, e) {
   return this.each(function() {
-    _(
+    p(
       this,
       e,
-      (s) => u(this).toggleClass(t, !!s),
-      `class.${t}`
+      (t) => h(this).toggleClass(s, !!t),
+      `class.${s}`
     );
   });
 };
-u.fn.atomCss = function(t, e, s) {
+h.fn.atomCss = function(s, e, t) {
   return this.each(function() {
-    _(
+    p(
       this,
       e,
       (n) => {
-        const i = s ? `${n}${s}` : n;
-        u(this).css(t, i);
+        const i = t ? `${n}${t}` : n;
+        h(this).css(s, i);
       },
-      `css.${t}`
+      `css.${s}`
     );
   });
 };
-u.fn.atomAttr = function(t, e) {
+h.fn.atomAttr = function(s, e) {
   return this.each(function() {
-    _(
+    p(
       this,
       e,
-      (s) => {
-        const n = u(this);
-        s == null || s === !1 ? n.removeAttr(t) : s === !0 ? n.attr(t, t) : n.attr(t, String(s));
+      (t) => {
+        const n = h(this);
+        t == null || t === !1 ? n.removeAttr(s) : t === !0 ? n.attr(s, s) : n.attr(s, String(t));
       },
-      `attr.${t}`
+      `attr.${s}`
     );
   });
 };
-u.fn.atomProp = function(t, e) {
+h.fn.atomProp = function(s, e) {
   return this.each(function() {
-    _(this, e, (s) => u(this).prop(t, s), `prop.${t}`);
+    p(this, e, (t) => h(this).prop(s, t), `prop.${s}`);
   });
 };
-u.fn.atomShow = function(t) {
+h.fn.atomShow = function(s) {
   return this.each(function() {
-    _(this, t, (e) => u(this).toggle(!!e), "show");
+    p(this, s, (e) => h(this).toggle(!!e), "show");
   });
 };
-u.fn.atomHide = function(t) {
+h.fn.atomHide = function(s) {
   return this.each(function() {
-    _(this, t, (e) => u(this).toggle(!e), "hide");
+    p(this, s, (e) => h(this).toggle(!e), "hide");
   });
 };
-u.fn.atomVal = function(t, e = {}) {
+h.fn.atomVal = function(s, e = {}) {
   return this.each(function() {
-    const s = u(this), { effect: n, cleanup: i } = Me(s, t, e), r = $(n);
-    f.trackEffect(this, r), f.trackCleanup(this, i);
+    const t = h(this), { effect: n, cleanup: i } = ze(t, s, e), o = J(n);
+    d.trackEffect(this, o), d.trackCleanup(this, i);
   });
 };
-u.fn.atomChecked = function(t) {
+h.fn.atomChecked = function(s) {
   return this.each(function() {
-    const e = u(this);
-    let s = !1;
+    const e = h(this);
+    let t = !1;
     const n = () => {
-      s || (t.value = !!e.prop("checked"));
+      t || (s.value = !!e.prop("checked"));
     };
-    e.on("change", n), f.trackCleanup(this, () => e.off("change", n));
-    const i = $(() => {
-      s = !0;
-      const r = !!t.value;
-      e.prop("checked", r), g.domUpdated(e, "checked", r), s = !1;
+    e.on("change", n), d.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;
     });
-    f.trackEffect(this, i);
+    d.trackEffect(this, i);
   });
 };
-u.fn.atomOn = function(t, e) {
+h.fn.atomOn = function(s, e) {
   return this.each(function() {
-    const s = u(this);
-    s.on(t, e), f.trackCleanup(this, () => s.off(t, e));
+    const t = h(this);
+    t.on(s, e), d.trackCleanup(this, () => t.off(s, e));
   });
 };
-u.fn.atomUnbind = function() {
+h.fn.atomUnbind = function() {
   return this.each(function() {
-    f.cleanupTree(this);
+    d.cleanupTree(this);
   });
 };
-function gt(t, e) {
-  _(
-    t.el,
+function Et(s, e) {
+  p(
+    s.el,
     e,
-    (s) => {
-      t.el.textContent = String(s ?? "");
+    (t) => {
+      s.el.textContent = String(t ?? "");
     },
     "text"
   );
 }
-function Et(t, e) {
-  _(
-    t.el,
+function gt(s, e) {
+  p(
+    s.el,
     e,
-    (s) => {
-      t.el.innerHTML = String(s ?? "");
+    (t) => {
+      s.el.innerHTML = String(t ?? "");
     },
     "html"
   );
 }
-function bt(t, e) {
-  for (const s in e)
-    _(
-      t.el,
-      e[s],
+function bt(s, e) {
+  for (const t in e)
+    p(
+      s.el,
+      e[t],
       (n) => {
-        t.el.classList.toggle(s, !!n);
+        s.el.classList.toggle(t, !!n);
       },
-      `class.${s}`
+      `class.${t}`
     );
 }
-function mt(t, e) {
-  const s = t.el.style;
+function mt(s, e) {
+  const t = s.el.style;
   for (const n in e) {
     const i = e[n];
     if (i === void 0) continue;
-    const r = n.includes("-") ? n.replace(/-./g, (o) => o.charAt(1).toUpperCase()) : n;
+    const o = n.includes("-") ? n.replace(/-./g, (r) => r.charAt(1).toUpperCase()) : n;
     if (Array.isArray(i)) {
-      const [o, c] = i;
-      _(
-        t.el,
-        o,
-        (h) => {
-          s[r] = `${h}${c}`;
+      const [r, c] = i;
+      p(
+        s.el,
+        r,
+        (u) => {
+          t[o] = `${u}${c}`;
         },
         `css.${n}`
       );
     } else
-      _(
-        t.el,
+      p(
+        s.el,
         i,
-        (o) => {
-          s[r] = o;
+        (r) => {
+          t[o] = r;
         },
         `css.${n}`
       );
   }
 }
-function yt(t, e) {
-  const s = t.el;
+function St(s, e) {
+  const t = s.el;
   for (const n in e) {
     const i = e[n];
-    _(
-      s,
+    p(
+      t,
       i,
-      (r) => {
-        if (r == null || r === !1) {
-          s.removeAttribute(n);
+      (o) => {
+        if (o == null || o === !1) {
+          t.removeAttribute(n);
           return;
         }
-        s.setAttribute(n, r === !0 ? n : String(r));
+        t.setAttribute(n, o === !0 ? n : String(o));
       },
       `attr.${n}`
     );
   }
 }
-function St(t, e) {
-  const s = t.el;
+function yt(s, e) {
+  const t = s.el;
   for (const n in e)
-    _(
-      s,
+    p(
+      t,
       e[n],
       (i) => {
-        s[n] = i;
+        t[n] = i;
       },
       `prop.${n}`
     );
 }
-function Dt(t, e) {
-  _(
-    t.el,
+function It(s, e) {
+  p(
+    s.el,
     e,
-    (s) => {
-      t.$el.toggle(!!s);
+    (t) => {
+      s.$el.toggle(!!t);
     },
     "show"
   );
 }
-function It(t, e) {
-  _(
-    t.el,
+function Dt(s, e) {
+  p(
+    s.el,
     e,
-    (s) => {
-      t.$el.toggle(!s);
+    (t) => {
+      s.$el.toggle(!t);
     },
     "hide"
   );
 }
-function Ct(t, e) {
-  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = Me(t.$el, s, n), o = $(i);
-  f.trackEffect(t.el, o), t.trackCleanup(r);
+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 xt(t, e) {
-  const s = Ve(), n = () => {
-    s.phase === "idle" && (e.value = t.$el.prop("checked"));
+function Nt(s, e) {
+  const t = je(), n = () => {
+    t.phase === "idle" && (e.value = s.$el.prop("checked"));
   };
-  t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n));
-  const i = $(() => {
-    s.phase = "syncing-to-dom";
-    const r = !!e.value;
-    t.$el.prop("checked", r), g.domUpdated(t.$el, "checked", r), s.phase = "idle";
+  s.$el.on("change", n), s.trackCleanup(() => s.$el.off("change", n));
+  const i = J(() => {
+    t.phase = "syncing-to-dom";
+    const o = !!e.value;
+    s.$el.prop("checked", o), g.domUpdated(s.$el, "checked", o), t.phase = "idle";
   });
-  f.trackEffect(t.el, i);
+  d.trackEffect(s.el, i);
 }
-function Nt(t, e) {
-  const s = t.el;
+function Tt(s, e) {
+  const t = s.el;
   for (const n in e) {
     const i = e[n];
     if (typeof i != "function") continue;
-    const r = (o) => i.call(s, u.Event(o));
-    s.addEventListener(n, r), t.trackCleanup(() => s.removeEventListener(n, r));
+    const o = (r) => i.call(t, h.Event(r));
+    t.addEventListener(n, o), s.trackCleanup(() => t.removeEventListener(n, o));
   }
 }
-u.fn.atomBind = function(t) {
+h.fn.atomBind = function(s) {
   return this.each(function() {
-    const s = {
-      $el: u(this),
+    const t = {
+      $el: h(this),
       el: this,
       effects: [],
-      trackCleanup: (n) => f.trackCleanup(this, n)
+      trackCleanup: (n) => d.trackCleanup(this, n)
     };
-    t.text !== void 0 && gt(s, t.text), t.html !== void 0 && Et(s, t.html), t.class && bt(s, t.class), t.css && mt(s, t.css), t.attr && yt(s, t.attr), t.prop && St(s, t.prop), t.show !== void 0 && Dt(s, t.show), t.hide !== void 0 && It(s, t.hide), t.val !== void 0 && Ct(s, t.val), t.checked !== void 0 && xt(s, t.checked), t.on && Nt(s, t.on);
+    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);
   });
 };
-u.fn.atomList = function(t, e) {
-  const { key: s, render: n, bind: i, update: r, onAdd: o, onRemove: c, empty: h } = e, d = typeof s == "function" ? s : (m) => m[s];
+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];
   return this.each(function() {
-    const m = u(this), X = he(this), x = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Set();
-    let k = [], L = null;
-    const D = $(() => {
-      const H = t.value, R = H.length;
-      if (R === 0 ? h && !L && (L = u(h).appendTo(m)) : L && (L.remove(), L = null), R === 0 && x.size === 0) {
-        k = [];
+    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 = [];
         return;
       }
-      g.log("list", `${X} updating with ${R} items`);
-      const Z = new Array(R), Ee = /* @__PURE__ */ new Set();
-      for (let a = 0; a < R; a++) {
-        const p = H[a], I = d(p, a);
-        Z[a] = I, Ee.add(I);
+      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);
       }
-      for (const [a, p] of x) {
-        if (Ee.has(a) || A.has(a)) continue;
-        const I = () => {
-          p.$el.remove();
-          const E = p.$el[0];
-          E && f.cleanup(E), A.delete(a), g.log("list", `${X} removed item:`, a);
+      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);
         };
-        if (x.delete(a), A.add(a), c) {
-          const E = c(p.$el);
-          E instanceof Promise ? E.then(I) : I();
+        if (S.delete(f), R.add(f), c) {
+          const b = c(E.$el);
+          b instanceof Promise ? b.then(C) : C();
         } else
-          I();
+          C();
       }
-      if (R === 0) {
-        k = [];
+      if (U === 0) {
+        z = [];
         return;
       }
-      const be = /* @__PURE__ */ new Map();
-      for (let a = 0; a < k.length; a++) {
-        const p = k[a];
-        p !== void 0 && be.set(p, a);
+      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 me = new Int32Array(R);
-      for (let a = 0; a < R; a++) {
-        const p = Z[a];
-        me[a] = p !== void 0 ? be.get(p) ?? -1 : -1;
+      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 = ht(me);
-      let ae = ye.length - 1, O = null;
-      for (let a = R - 1; a >= 0; a--) {
-        const p = Z[a], I = H[a], E = x.get(p);
-        if (E) {
-          E.item = I;
-          const P = E.$el[0];
-          if (!P) continue;
-          r && r(E.$el, I, a), ae >= 0 && ye[ae] === a ? (ae--, P.nextSibling !== O && (O ? E.$el.insertBefore(O) : E.$el.appendTo(m))) : O ? E.$el.insertBefore(O) : E.$el.appendTo(m), O = P;
+      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;
         } else {
-          const P = n(I, a), V = P instanceof Element ? u(P) : u(P);
-          x.set(p, { $el: V, item: I }), O ? V.insertBefore(O) : V.appendTo(m), i && i(V, I, a), o && o(V), g.log("list", `${X} added item:`, p), O = V[0] || null;
+          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;
         }
       }
-      k = Z;
+      z = se;
     });
-    f.trackEffect(this, D), f.trackCleanup(this, () => {
-      x.clear(), A.clear(), k = [], L?.remove();
+    d.trackEffect(this, D), d.trackCleanup(this, () => {
+      S.clear(), R.clear(), z = [], $?.remove();
     });
   });
 };
-const ie = /* @__PURE__ */ new WeakMap();
-u.fn.atomMount = function(t, e = {}) {
+const re = /* @__PURE__ */ new WeakMap();
+h.fn.atomMount = function(s, e = {}) {
   return this.each(function() {
-    const s = u(this), n = he(this), i = ie.get(this);
+    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`);
-    let r;
+    let o;
     try {
-      r = t(s, e);
-    } catch (h) {
-      console.error("[atom-effect-jquery] Mount error:", h);
+      o = s(t, e);
+    } catch (u) {
+      console.error("[atom-effect-jquery] Mount error:", u);
       return;
     }
-    let o = !1;
+    let r = !1;
     const c = () => {
-      if (!o) {
-        if (o = !0, g.log("mount", `${n} full cleanup`), typeof r == "function")
+      if (!r) {
+        if (r = !0, g.log("mount", `${n} full cleanup`), typeof o == "function")
           try {
-            r();
+            o();
           } catch {
           }
-        f.cleanupTree(this), ie.delete(this);
+        d.cleanupTree(this), re.delete(this);
       }
     };
-    ie.set(this, c), f.trackCleanup(this, c);
+    re.set(this, c), d.trackCleanup(this, c);
   });
 };
-u.fn.atomUnmount = function() {
+h.fn.atomUnmount = function() {
   return this.each(function() {
-    ie.get(this)?.();
+    re.get(this)?.();
   });
 };
-const Y = /* @__PURE__ */ new WeakMap();
-let Te = !1;
-function je() {
-  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() {
-      f.cleanupTree(this), f.markIgnored(this);
-    }), s.call(this, r);
-  }, u.fn.empty = function() {
+const W = /* @__PURE__ */ new WeakMap();
+let Oe = !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;
+  h.fn.remove = function(o) {
+    return (o ? this.filter(o) : this).each(function() {
+      d.cleanupTree(this), d.markIgnored(this);
+    }), t.call(this, o);
+  }, h.fn.empty = function() {
     return this.each(function() {
-      f.cleanupDescendants(this);
+      d.cleanupDescendants(this);
     }), n.call(this);
-  }, u.fn.detach = function(r) {
-    return (r ? this.filter(r) : this).each(function() {
-      f.keep(this);
-    }), i.call(this, r);
-  }, u.fn.on = function(...r) {
-    let o = -1;
-    for (let c = r.length - 1; c >= 0; c--)
-      if (typeof r[c] == "function") {
-        o = c;
+  }, h.fn.detach = function(o) {
+    return (o ? this.filter(o) : this).each(function() {
+      d.keep(this);
+    }), i.call(this, o);
+  }, h.fn.on = function(...o) {
+    let r = -1;
+    for (let c = o.length - 1; c >= 0; c--)
+      if (typeof o[c] == "function") {
+        r = c;
         break;
       }
-    if (o !== -1) {
-      const c = r[o];
-      let h;
-      Y.has(c) ? h = Y.get(c) : (h = function(...d) {
-        return c.apply(this, d);
-      }, Y.set(c, h)), r[o] = h;
+    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;
     }
-    return t.apply(this, r);
-  }, u.fn.off = function(...r) {
-    let o = -1;
-    for (let c = r.length - 1; c >= 0; c--)
-      if (typeof r[c] == "function") {
-        o = c;
+    return s.apply(this, o);
+  }, h.fn.off = function(...o) {
+    let r = -1;
+    for (let c = o.length - 1; c >= 0; c--)
+      if (typeof o[c] == "function") {
+        r = c;
         break;
       }
-    if (o !== -1) {
-      const c = r[o];
-      Y.has(c) && (r[o] = Y.get(c));
+    if (r !== -1) {
+      const c = o[r];
+      W.has(c) && (o[r] = W.get(c));
     }
-    return e.apply(this, r);
+    return e.apply(this, o);
   };
 }
-const Rt = je;
-je();
-u(() => {
+const Ot = $e;
+$e();
+h(() => {
   pt(document.body);
 });
 export {
   it as atom,
-  ct as batch,
+  Ve as batch,
   rt as computed,
   wt as default,
   At as disableAutoCleanup,
-  $ as effect,
+  J as effect,
   pt as enableAutoCleanup,
-  Rt as enablejQueryBatching,
-  je as enablejQueryOverrides,
-  f as registry,
-  Fe as untracked
+  Ot as enablejQueryBatching,
+  $e as enablejQueryOverrides,
+  d as registry,
+  Le as untracked
 };
 //# sourceMappingURL=index.mjs.map