@but212/atom-effect-jquery 0.16.0 → 0.17.0

package/dist/index.mjs

@@ -1,22 +1,21 @@
-import l from "jquery";
-import { default as Vt } from "jquery";
-const Ze = {
-  /** One second in milliseconds */
+import u from "jquery";
+import { default as Me } from "jquery";
+const Wt = {
   ONE_SECOND_MS: 1e3
-}, _e = {
+}, ht = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, w = {
+}, F = {
   DISPOSED: 1,
   HAS_FN_SUBS: 2,
   HAS_OBJ_SUBS: 4
-}, U = {
-  ...w,
+}, k = {
+  ...F,
   EXECUTING: 8
-}, f = {
-  ...w,
+}, h = {
+  ...F,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -24,695 +23,540 @@ const Ze = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, L = {
-  ...w,
+}, R = {
+  ...F,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, q = {
-  /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
+}, $ = {
+  // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
-  /**
-   * Maximum executions per effect within a single flush cycle
-   * Increased from 50 to 100
-   */
   MAX_EXECUTIONS_PER_EFFECT: 100,
-  /**
-   * Maximum total executions across all effects in a single flush cycle
-   * Increased from 5000 to 10000
-   */
+  // Batch processing limits to prevent blocking the main thread for too long
   MAX_EXECUTIONS_PER_FLUSH: 1e4,
-  /** 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,
-  /** Threshold for shrinking the batch queue to assist GC */
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, we = {
-  /** Maximum dependencies before warning about large dependency graphs */
+}, kt = {
   MAX_DEPENDENCIES: 1e3,
-  /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, K = 1073741823, Z = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", et = Object.freeze([]);
-class Q extends Error {
-  /**
-   * Creates a new AtomError
-   * @param message - Error message describing what went wrong
-   * @param cause - Original error that caused this error
-   * @param recoverable - Whether the operation can be retried
-   */
-  constructor(e, t = null, s = !0) {
-    super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
+}, G = 1073741823, m = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, Kt = Object.freeze([]);
+class Z extends Error {
+  constructor(t, e = null, s = !0) {
+    super(t), this.cause = e, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date(), this.name = "AtomError";
   }
 }
-class $ extends Q {
-  /**
-   * Creates a new ComputedError
-   * @param message - Error message
-   * @param cause - Original error
-   */
-  constructor(e, t = null) {
-    super(e, t, !0), this.name = "ComputedError";
+class B extends Z {
+  constructor(t, e = null) {
+    super(t, e, !0), this.name = "ComputedError";
   }
 }
-class Y extends Q {
-  /**
-   * Creates a new EffectError
-   * @param message - Error message
-   * @param cause - Original error
-   */
-  constructor(e, t = null) {
-    super(e, t, !1), this.name = "EffectError";
+class q extends Z {
+  constructor(t, e = null) {
+    super(t, e, !1), this.name = "EffectError";
   }
 }
-class ue extends Q {
-  /**
-   * Creates a new SchedulerError
-   * @param message - Error message
-   * @param cause - Original error
-   */
-  constructor(e, t = null) {
-    super(e, t, !1), this.name = "SchedulerError";
+class it extends Z {
+  constructor(t, e = null) {
+    super(t, e, !1), this.name = "SchedulerError";
   }
 }
-const C = {
-  // ─────────────────────────────────────────────────────────────────
-  // Computed errors
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Error thrown when computed() receives a non-function argument.
-   */
-  COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function",
-  /**
-   * Error thrown when accessing a pending async computed without a default value.
-   */
-  COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation is pending. No default value provided",
-  /**
-   * Error thrown when a synchronous computed computation fails.
-   */
-  COMPUTED_COMPUTATION_FAILED: "Computed computation failed",
-  /**
-   * Error thrown when an asynchronous computed computation fails.
-   */
-  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
-  /**
-   * Error thrown when a circular dependency is detected during computation.
-   */
-  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected during computation",
-  /**
-   * Error thrown when accessing a disposed computed value.
-   */
-  COMPUTED_DISPOSED: "Cannot access a disposed computed",
-  // ─────────────────────────────────────────────────────────────────
-  // Atom errors
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Error thrown when atom.subscribe() receives an invalid listener.
-   */
-  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function or Subscriber object",
-  /**
-   * Error logged when an individual subscriber throws during notification.
-   * @remarks This error is caught and logged to prevent cascading failures.
-   */
-  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Error during individual atom subscriber execution",
-  // ─────────────────────────────────────────────────────────────────
-  // Effect errors
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Error thrown when effect() receives a non-function argument.
-   */
-  EFFECT_MUST_BE_FUNCTION: "Effect function must be a function",
-  /**
-   * Error thrown when an effect's execution fails.
-   */
-  EFFECT_EXECUTION_FAILED: "Effect execution failed",
-  /**
-   * Error thrown when an effect's cleanup function fails.
-   */
-  EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
-  /**
-   * Error thrown when attempting to run a disposed effect.
-   */
-  EFFECT_DISPOSED: "Cannot run a disposed effect",
-  // ─────────────────────────────────────────────────────────────────
-  // Debug warnings
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Warning message for large dependency graphs.
-   *
-   * @param count - The number of dependencies detected
-   * @returns Formatted warning message with dependency count
-   *
-   * @example
-   * ```ts
-   * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));
-   * // Output: "Large dependency graph detected: 150 dependencies"
-   * ```
-   */
-  LARGE_DEPENDENCY_GRAPH: (n) => `Large dependency graph detected: ${n} dependencies`,
-  /**
-   * Error logged when the onError callback itself throws an error.
-   * @remarks This prevents cascading failures from masking the original error.
-   */
-  CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, Se = /* @__PURE__ */ Symbol("debugName"), tt = /* @__PURE__ */ Symbol("id"), ye = /* @__PURE__ */ Symbol("type"), Ie = /* @__PURE__ */ Symbol("noDefaultValue");
-function nt(n) {
-  return "dependencies" in n && Array.isArray(n.dependencies);
-}
-function Ve(n, e, t) {
-  if (!t.has(n.id)) {
-    if (t.add(n.id), n === e)
-      throw new $("Indirect circular dependency detected");
-    if (nt(n)) {
-      const s = n.dependencies;
-      for (let i = 0; i < s.length; i++) {
-        const o = s[i];
-        o && Ve(o, e, t);
-      }
+const At = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Zt = /* @__PURE__ */ Symbol("AtomEffect.Id"), vt = /* @__PURE__ */ Symbol("AtomEffect.Type"), pt = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), te = (n) => "dependencies" in n && Array.isArray(n.dependencies);
+function Bt(n, t, e) {
+  if (n === t)
+    throw new B(
+      "Circular dependency detected: The computation refers to itself explicitly or implicitly."
+    );
+  if (!e.has(n.id) && (e.add(n.id), te(n))) {
+    const s = n.dependencies;
+    for (let i = 0; i < s.length; i++) {
+      const o = s[i];
+      o && Bt(o, t, e);
     }
   }
 }
-const F = {
-  enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: we.MAX_DEPENDENCIES,
-  warnInfiniteLoop: we.WARN_INFINITE_LOOP,
-  warn(n, e) {
-    this.enabled && n && console.warn(`[Atom Effect] ${e}`);
+const X = {
+  // Dev mode flag
+  enabled: m,
+  maxDependencies: kt.MAX_DEPENDENCIES,
+  warnInfiniteLoop: kt.WARN_INFINITE_LOOP,
+  warn(n, t) {
+    m && this.enabled && n && console.warn(`[Atom Effect] ${t}`);
   },
-  /**
-   * Checks for circular dependencies.
-   * Direct check runs always; indirect check only in dev mode.
-   * @throws {ComputedError} When circular dependency detected
-   */
-  checkCircular(n, e) {
-    if (n === e)
-      throw new $("Direct circular dependency detected");
-    this.enabled && Ve(n, e, /* @__PURE__ */ new Set());
+  checkCircular(n, t) {
+    if (n === t)
+      throw new B("Direct circular dependency detected");
+    m && this.enabled && Bt(n, t, /* @__PURE__ */ new Set());
   },
-  attachDebugInfo(n, e, t) {
-    if (!this.enabled)
-      return;
+  attachDebugInfo(n, t, e) {
+    if (!m || !this.enabled) return;
     const s = n;
-    s[Se] = `${e}_${t}`, s[tt] = t, s[ye] = e;
-  },
-  getDebugName(n) {
-    if (n != null && Se in n)
-      return n[Se];
+    s[At] = `${t}_${e}`, s[Zt] = e, s[vt] = t;
   },
-  getDebugType(n) {
-    if (n != null && ye in n)
-      return n[ye];
-  }
+  getDebugName: (n) => n?.[At],
+  getDebugType: (n) => n?.[vt]
 };
-let st = 1;
-const it = () => st++;
-class He {
-  constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = it() & K, this._tempUnsub = void 0;
-  }
-}
-class ze extends He {
-  /**
-   * Subscribes a listener function or Subscriber object to value changes.
-   */
-  subscribe(e) {
-    if (typeof e == "function")
-      return this._addSubscriber(this._fnSubs, e, w.HAS_FN_SUBS);
-    if (e !== null && typeof e == "object" && "execute" in e)
-      return this._addSubscriber(this._objSubs, e, w.HAS_OBJ_SUBS);
-    throw new Q(C.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+let ee = 1;
+const ne = () => ee++;
+function $t(n, t, e) {
+  if (typeof t == "function") {
+    const i = t;
+    for (let o = 0, r = e.length; o < r; o++) {
+      const c = e[o];
+      if (c && c.fn === i) return;
+    }
+    e.push(new St(i, void 0)), n.flags |= F.HAS_FN_SUBS, "_fnSubCount" in n && n._fnSubCount++;
+    return;
   }
-  /**
-   * Internal helper for subscription logic to reduce code duplication and branching.
-   */
-  _addSubscriber(e, t, s) {
-    return e.indexOf(t) !== -1 ? (Z && console.warn(
-      "Attempted to subscribe the same listener twice. Ignoring duplicate subscription."
-    ), () => {
-    }) : (e.push(t), this.flags |= s, () => {
-      const i = e.indexOf(t);
-      if (i === -1) return;
-      const o = e.pop();
-      i < e.length && (e[i] = o), e.length === 0 && (this.flags &= ~s);
-    });
+  if ("addDependency" in t) {
+    t.addDependency(n);
+    return;
   }
-  /**
-   * Gets the total number of active subscribers.
-   */
-  subscriberCount() {
-    return this._fnSubs.length + this._objSubs.length;
+  const s = t;
+  for (let i = 0, o = e.length; i < o; i++) {
+    const r = e[i];
+    if (r && r.sub === s) return;
   }
-  /**
-   * Notifies all subscribers of a change.
-   */
-  _notifySubscribers(e, t) {
-    const s = this.flags;
-    if (s & (w.HAS_FN_SUBS | w.HAS_OBJ_SUBS)) {
-      if (s & w.HAS_FN_SUBS) {
-        const i = this._fnSubs;
-        for (let o = 0; o < i.length; o++)
-          try {
-            i[o](e, t);
-          } catch (r) {
-            this._handleNotifyError(r);
-          }
-      }
-      if (s & w.HAS_OBJ_SUBS) {
-        const i = this._objSubs;
-        for (let o = 0; o < i.length; o++)
-          try {
-            i[o].execute();
-          } catch (r) {
-            this._handleNotifyError(r);
-          }
-      }
+  e.push(new St(void 0, s)), n.flags |= F.HAS_OBJ_SUBS, "_objSubCount" in n && n._objSubCount++;
+}
+function se(n, t, e) {
+  for (let s = 0, i = t.length; s < i; s++) {
+    const o = t[s];
+    o && (o.node._tempUnsub = o.unsub);
+  }
+  for (let s = 0, i = n.length; s < i; s++) {
+    const o = n[s];
+    if (!o) continue;
+    const r = o.node;
+    r._tempUnsub !== void 0 ? (o.unsub = r._tempUnsub, r._tempUnsub = void 0) : (X.checkCircular(r, e), o.unsub = r.subscribe(e));
+  }
+  for (let s = 0, i = t.length; s < i; s++) {
+    const o = t[s];
+    if (o) {
+      const r = o.node;
+      r._tempUnsub !== void 0 && (r._tempUnsub(), r._tempUnsub = void 0), o.unsub = void 0;
     }
   }
-  /**
-   * Hoisted error reporter to keep notification loops lean and aid JIT inlining.
-   */
-  _handleNotifyError(e) {
-    console.error(new Q(C.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, e));
+}
+class mt {
+  constructor(t, e, s = void 0) {
+    this.node = t, this.version = e, this.unsub = s;
   }
 }
-class ot {
-  constructor() {
-    this.frozen = 0, this.tooLarge = 0, this.poolFull = 0;
+class St {
+  constructor(t, e) {
+    this.fn = t, this.sub = e;
   }
 }
-class rt {
+const S = {
+  // Computed Errors
+  COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
+  COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
+  COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
+  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
+  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
+  COMPUTED_DISPOSED: "Attempted to access disposed computed",
+  // Atom Errors
+  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
+  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
+  // Effect Errors
+  EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
+  EFFECT_EXECUTION_FAILED: "Effect execution failed",
+  EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
+  EFFECT_DISPOSED: "Attempted to run disposed effect",
+  CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler"
+};
+function K(n, t, e) {
+  if (n instanceof Z)
+    return n;
+  const s = n instanceof Error, i = s ? n.message : String(n), o = s ? n : void 0;
+  let r = "Unexpected error";
+  n instanceof TypeError ? r = "Type error" : n instanceof ReferenceError && (r = "Reference error");
+  const c = `${r} (${e}): ${i}`;
+  return new t(c, o);
+}
+class jt {
   constructor() {
-    this.acquired = 0, this.released = 0, this.rejected = new ot();
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = ne() & G, this._tempUnsub = void 0;
   }
 }
-class Ne {
+class Ht extends jt {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = Z ? new rt() : null;
-  }
-  /** Acquires an array from the pool or creates a new one if the pool is empty. */
-  acquire() {
-    const e = this.stats;
-    return e && e.acquired++, this.pool.pop() ?? [];
+    super(...arguments), this._fnSubCount = 0, this._objSubCount = 0;
   }
   /**
-   * Releases an array back to the pool.
-   * Clears the array before storing it.
+   * Adds subscriber.
    */
-  release(e, t) {
-    const s = this.stats;
-    if (t && e === t) return;
-    if (Object.isFrozen(e)) {
-      s && s.rejected.frozen++;
-      return;
-    }
-    if (e.length > this.maxReusableCapacity) {
-      s && s.rejected.tooLarge++;
-      return;
-    }
-    const i = this.pool;
-    if (i.length >= this.maxPoolSize) {
-      s && s.rejected.poolFull++;
-      return;
+  subscribe(t) {
+    const e = typeof t == "function";
+    if (!e && (!t || typeof t.execute != "function"))
+      throw K(
+        new TypeError("Invalid subscriber"),
+        Z,
+        S.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+      );
+    const s = this._subscribers;
+    for (let o = 0, r = s.length; o < r; o++) {
+      const c = s[o];
+      if (c && (e ? c.fn === t : c.sub === t))
+        return m && console.warn("Duplicate subscription ignored."), () => {
+        };
     }
-    e.length = 0, i.push(e), s && s.released++;
-  }
-  /** Returns current stats for the pool (dev mode only). */
-  getStats() {
-    const e = this.stats;
-    if (!e) return null;
-    const { acquired: t, released: s, rejected: i } = e, { frozen: o, tooLarge: r, poolFull: c } = i;
-    return {
-      acquired: t,
-      released: s,
-      rejected: {
-        frozen: o,
-        tooLarge: r,
-        poolFull: c
-      },
-      leaked: t - s - (o + r + c),
-      poolSize: this.pool.length
-    };
+    const i = new St(
+      e ? t : void 0,
+      e ? void 0 : t
+    );
+    return s.push(i), e ? (this._fnSubCount++, this.flags |= F.HAS_FN_SUBS) : (this._objSubCount++, this.flags |= F.HAS_OBJ_SUBS), () => this._unsubscribe(i);
   }
-  /** Resets the pool and its stats. */
-  reset() {
-    this.pool.length = 0;
-    const e = this.stats;
-    e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
+  _unsubscribe(t) {
+    const e = this._subscribers, s = e.indexOf(t);
+    if (s === -1) return;
+    const i = e.pop();
+    s < e.length && i && (e[s] = i), t.fn ? this._fnSubCount-- : this._objSubCount--, e.length === 0 ? (this.flags &= -7, this._fnSubCount = 0, this._objSubCount = 0) : t.fn && this._fnSubCount <= 0 ? (this.flags &= -3, this._fnSubCount = 0) : !t.fn && this._objSubCount <= 0 && (this.flags &= -5, this._objSubCount = 0);
   }
-}
-const v = Object.freeze([]), X = Object.freeze([]), R = Object.freeze([]), G = new Ne(), W = new Ne(), j = new Ne();
-function z(n, e, t, s) {
-  if (e != null) {
-    if (typeof e.addDependency == "function") {
-      e.addDependency(n);
-      return;
-    }
-    if (typeof e == "function") {
-      const i = e;
-      t.indexOf(i) === -1 && (t.push(i), n.flags |= w.HAS_FN_SUBS);
-      return;
-    }
-    if (typeof e.execute == "function") {
-      const i = e;
-      s.indexOf(i) === -1 && (s.push(i), n.flags |= w.HAS_OBJ_SUBS);
+  subscriberCount() {
+    return this._subscribers.length;
+  }
+  _notifySubscribers(t, e) {
+    if (!(this.flags & (F.HAS_FN_SUBS | F.HAS_OBJ_SUBS))) return;
+    const s = this._subscribers, i = s.length;
+    for (let o = 0; o < i; o++) {
+      const r = s[o];
+      if (r)
+        try {
+          r.fn ? r.fn(t, e) : r.sub && r.sub.execute();
+        } catch (c) {
+          this._handleNotifyError(c);
+        }
     }
   }
+  _handleNotifyError(t) {
+    console.error(K(t, Z, S.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+  }
 }
-function ct(n, e, t, s) {
-  const i = e.length;
-  if (i > 0)
-    for (let c = 0; c < i; c++) {
-      const u = e[c];
-      u && (u._tempUnsub = t[c]);
-    }
-  const o = n.length, r = W.acquire();
-  r.length = o;
-  for (let c = 0; c < o; c++) {
-    const u = n[c];
-    if (!u) continue;
-    const h = u._tempUnsub;
-    h ? (r[c] = h, u._tempUnsub = void 0) : (F.checkCircular(u, s), r[c] = u.subscribe(s));
-  }
-  if (i > 0)
-    for (let c = 0; c < i; c++) {
-      const u = e[c];
-      if (u) {
-        const h = u._tempUnsub;
-        h && (h(), u._tempUnsub = void 0);
-      }
-    }
-  return t !== X && W.release(t), r;
-}
-let le = 0;
-function qe() {
-  return le = le + 1 & K || 1, le;
-}
-function ut() {
-  return le;
-}
-let De = 0, Oe = 0, fe = !1;
-function ke() {
-  return fe ? (Z && console.warn(
-    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (fe = !0, De = De + 1 & K || 1, Oe = 0, !0);
-}
-function Le() {
-  fe = !1;
-}
-function ht() {
-  return fe ? ++Oe : 0;
+let rt = 0;
+const Vt = () => (rt = rt + 1 & G || 1, rt), ie = () => rt;
+let bt = 0, Ct = 0, ut = !1;
+function Ut() {
+  return ut ? (m && console.warn("startFlush() called during flush - ignored"), !1) : (ut = !0, bt = bt + 1 & G || 1, Ct = 0, !0);
 }
-class lt {
-  constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._isFlushingSync = !1, this._maxFlushIterations = q.MAX_FLUSH_ITERATIONS;
-  }
-  /**
-   * Returns the current operational phase of the scheduler.
-   */
+const Rt = () => {
+  ut = !1;
+}, oe = () => ut ? ++Ct : 0, A = {
+  /** Queue buffer */
+  _queueBuffer: [[], []],
+  _bufferIndex: 0,
+  _size: 0,
+  /** Epoch counter */
+  _epoch: 0,
+  /** State flags */
+  _isProcessing: !1,
+  _isBatching: !1,
+  _isFlushingSync: !1,
+  /** Batching state */
+  _batchDepth: 0,
+  _batchQueue: [],
+  _batchQueueSize: 0,
+  /** Config */
+  _maxFlushIterations: $.MAX_FLUSH_ITERATIONS,
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
-  }
-  /** Current number of pending jobs. */
+  },
   get queueSize() {
     return this._size;
-  }
-  /**
-   * Returns whether the scheduler is currently batching updates.
-   */
+  },
   get isBatching() {
     return this._isBatching;
-  }
+  },
   /**
-   * Schedules a task for execution.
+   * Schedules job.
    */
-  schedule(e) {
-    if (Z && typeof e != "function")
-      throw new ue("Scheduler callback must be a function");
-    const t = this._epoch;
-    if (e._nextEpoch === t) return;
-    if (e._nextEpoch = t, this._isBatching || this._isFlushingSync) {
-      this._batchQueue[this._batchQueueSize++] = e;
-      return;
+  schedule(n) {
+    if (m && typeof n != "function")
+      throw new it("Scheduler callback must be a function");
+    if (n._nextEpoch !== this._epoch) {
+      if (n._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
+        this._batchQueue[this._batchQueueSize++] = n;
+        return;
+      }
+      this._queueBuffer[this._bufferIndex][this._size++] = n, this._isProcessing || this._flush();
     }
-    const s = this._bufferIndex, i = this._size;
-    this._queueBuffer[s][i] = e, this._size = i + 1, this._isProcessing || this.flush();
-  }
+  },
   /**
-   * Schedules a microtask-based flush of the queue.
-   * Coalesces multiple schedule calls into a single microtask execution.
+   * Triggers flush.
    */
-  flush() {
-    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(() => {
-      try {
-        if (this._size === 0) return;
-        const e = ke();
-        this._drainQueue(), e && Le();
-      } finally {
-        this._isProcessing = !1, this._size > 0 && !this._isBatching && this.flush();
-      }
-    }));
-  }
+  _flush() {
+    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._runLoop));
+  },
   /**
-   * Immediately flushes all queues synchronously.
-   * Used at the end of a batch block or when immediate reflection is required.
+   * Scheduler loop.
    */
-  flushSync() {
+  _runLoop: () => {
+    try {
+      if (A._size === 0) return;
+      const n = Ut();
+      A._drainQueue(), n && Rt();
+    } finally {
+      A._isProcessing = !1, A._size > 0 && !A._isBatching && A._flush();
+    }
+  },
+  _flushSync() {
     this._isFlushingSync = !0;
-    const e = ke();
+    const n = Ut();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, e && Le();
+      this._isFlushingSync = !1, n && Rt();
     }
-  }
-  /**
-   * Merges jobs from the batching queue into the primary queue.
-   * Increments the epoch to ensure deduplication.
-   */
+  },
   _mergeBatchQueue() {
-    const e = this._batchQueueSize;
-    if (e === 0) return;
-    const t = ++this._epoch, s = this._batchQueue, i = this._queueBuffer[this._bufferIndex];
-    let o = this._size;
-    for (let r = 0; r < e; r++) {
-      const c = s[r];
-      c._nextEpoch !== t && (c._nextEpoch = t, i[o++] = c);
+    if (this._batchQueueSize === 0) return;
+    const n = ++this._epoch, t = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
+    let s = this._size;
+    for (let i = 0; i < this._batchQueueSize; i++) {
+      const o = t[i];
+      o._nextEpoch !== n && (o._nextEpoch = n, e[s++] = o);
     }
-    this._size = o, this._batchQueueSize = 0, s.length > q.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
-  }
+    this._size = s, this._batchQueueSize = 0, t.length > $.BATCH_QUEUE_SHRINK_THRESHOLD && (t.length = 0);
+  },
   _drainQueue() {
-    let e = 0;
-    const t = this._maxFlushIterations;
+    let n = 0;
     for (; this._size > 0; ) {
-      if (++e > t) {
+      if (++n > this._maxFlushIterations) {
         this._handleFlushOverflow();
         return;
       }
       this._processQueue(), this._mergeBatchQueue();
     }
-  }
+  },
   _processQueue() {
-    const e = this._bufferIndex, t = this._queueBuffer[e], s = this._size;
-    this._bufferIndex = e ^ 1, this._size = 0, this._epoch++, this._processJobs(t, s);
-  }
+    const n = this._bufferIndex, t = this._queueBuffer[n], e = this._size;
+    this._bufferIndex = n ^ 1, this._size = 0, this._epoch++;
+    for (let s = 0; s < e; s++)
+      try {
+        t[s]();
+      } catch (i) {
+        console.error(new it("Error occurred during scheduler execution", i));
+      }
+    t.length = 0;
+  },
   _handleFlushOverflow() {
     console.error(
-      new ue(
+      new it(
         `Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0;
-  }
-  _processJobs(e, t) {
-    for (let s = 0; s < t; s++)
-      try {
-        const i = e[s];
-        i && i();
-      } catch (i) {
-        console.error(
-          new ue("Error occurred during scheduler execution", i)
-        );
-      }
-    e.length = 0;
-  }
+  },
   startBatch() {
     this._batchDepth++, this._isBatching = !0;
-  }
+  },
   endBatch() {
-    const e = this._batchDepth;
-    if (e === 0) {
-      Z && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+    if (this._batchDepth === 0) {
+      m && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
-    const t = e - 1;
-    this._batchDepth = t, t === 0 && (this.flushSync(), this._isBatching = !1);
-  }
-  setMaxFlushIterations(e) {
-    if (e < q.MIN_FLUSH_ITERATIONS)
-      throw new ue(
-        `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
+    --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
+  },
+  setMaxFlushIterations(n) {
+    if (n < $.MIN_FLUSH_ITERATIONS)
+      throw new it(
+        `Max flush iterations must be at least ${$.MIN_FLUSH_ITERATIONS}`
       );
-    this._maxFlushIterations = e;
-  }
-}
-const oe = new lt();
-class at {
-  constructor() {
-    this.current = null;
+    this._maxFlushIterations = n;
   }
+}, Q = {
+  /** Active listener. */
+  current: null,
   /**
-   * Runs the provided function within the context of the given listener.
-   * Restores the previous context after the function completes or throws.
+   * Executes in context.
    *
-   * @param listener - The tracking listener to associate with the current execution.
-   * @param fn - The function to execute.
+   * @param listener - The subscriber.
+   * @param fn - The logic to execute.
+   * @returns The result of `fn`.
    */
-  run(e, t) {
-    const s = this.current;
-    this.current = e;
+  run(n, t) {
+    const e = this.current;
+    this.current = n;
     try {
       return t();
     } finally {
-      this.current = s;
+      this.current = e;
     }
   }
-  /**
-   * Retrieves the listener currently associated with the tracking context.
-   */
-  getCurrent() {
-    return this.current;
-  }
-}
-const O = new at();
-function Xe(n) {
-  if (typeof n != "function")
-    throw new Q("Untracked callback must be a function");
-  const e = O.current;
-  O.current = null;
+};
+function zt(n) {
+  const t = Q.current;
+  if (t === null) return n();
+  Q.current = null;
   try {
     return n();
   } finally {
-    O.current = e;
+    Q.current = t;
   }
 }
-class ft extends ze {
-  constructor(e, t) {
-    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], t && (this.flags |= L.SYNC), F.attachDebugInfo(this, "atom", this.id);
+const re = R.HAS_FN_SUBS | R.HAS_OBJ_SUBS;
+class ce extends Ht {
+  constructor(t, e) {
+    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this._value = t, e && (this.flags |= R.SYNC), X.attachDebugInfo(this, "atom", this.id);
+  }
+  get value() {
+    const t = Q.current;
+    return t && $t(this, t, this._subscribers), this._value;
+  }
+  set value(t) {
+    const e = this._value;
+    if (Object.is(e, t)) return;
+    this._value = t, this.version = this.version + 1 & G;
+    const s = this.flags;
+    if (!((s & re) === 0 || s & R.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = e, this.flags = s | R.NOTIFICATION_SCHEDULED, s & R.SYNC && !A.isBatching) {
+        this._flushNotifications();
+        return;
+      }
+      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), A.schedule(this._notifyTask);
+    }
   }
   /**
-   * Returns the current value and registers the atom as a dependency if in a tracking context.
+   * Triggers subscribers.
    */
-  get value() {
-    const e = O.current;
-    return e && z(this, e, this._fnSubs, this._objSubs), this._value;
+  _flushNotifications() {
+    const t = this.flags;
+    if (!(t & R.NOTIFICATION_SCHEDULED) || t & R.DISPOSED)
+      return;
+    const e = this._pendingOldValue;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
+  }
+  peek() {
+    return this._value;
+  }
+  dispose() {
+    this.flags & R.DISPOSED || (this._subscribers.length = 0, this.flags |= R.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
+}
+function ue(n, t = {}) {
+  return new ce(n, t.sync ?? !1);
+}
+class le {
   /**
-   * Sets a new value and schedules notifications if the value has changed.
+   * @param limit - Max unique arrays to hold (default: 50). Prevents the pool itself from consuming too much memory.
+   * @param capacity - Max length of an array to accept (default: 256).
    */
-  set value(e) {
-    const t = this._value;
-    t === e || Object.is(t, e) || (this._value = e, this.version = this.version + 1 & K, this.flags & (L.HAS_FN_SUBS | L.HAS_OBJ_SUBS) && this._scheduleNotification(t));
+  constructor(t = 50, e = 256) {
+    this.limit = t, this.capacity = e, this.pool = [], this.stats = m ? {
+      acquired: 0,
+      released: 0,
+      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
+    } : null;
   }
   /**
-   * Schedules or flushes notifications based on sync mode and batching state.
+   * Acquires array.
    */
-  _scheduleNotification(e) {
-    let t = this.flags;
-    if (t & L.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, t |= L.NOTIFICATION_SCHEDULED, this.flags = t), t & L.SYNC && !oe.isBatching) {
-      this._flushNotifications();
-      return;
-    }
-    this._notifyTask || (this._notifyTask = () => this._flushNotifications());
-    const s = this._notifyTask;
-    oe.schedule(s);
+  acquire() {
+    return m && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
-   * Flushes scheduled notifications and resets state for the next cycle.
+   * Releases array.
+   *
+   * @param arr - Array to release.
+   * @param emptyConst - Optional empty constant.
    */
-  _flushNotifications() {
-    const e = this.flags;
-    if (!(e & L.NOTIFICATION_SCHEDULED) || e & L.DISPOSED)
-      return;
-    const t = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags = e & -17, this._notifySubscribers(this._value, t);
+  release(t, e) {
+    if (!(e && t === e)) {
+      if (t.length > this.capacity) {
+        m && this.stats && this.stats.rejected.tooLarge++;
+        return;
+      }
+      if (this.pool.length >= this.limit) {
+        m && this.stats && this.stats.rejected.poolFull++;
+        return;
+      }
+      if (Object.isFrozen(t)) {
+        m && this.stats && this.stats.rejected.frozen++;
+        return;
+      }
+      t.length = 0, this.pool.push(t), m && this.stats && this.stats.released++;
+    }
   }
   /**
-   * Returns the current value without registering it as a dependency.
+   * Pool stats.
    */
-  peek() {
-    return this._value;
+  getStats() {
+    if (!m || !this.stats) return null;
+    const { acquired: t, released: e, rejected: s } = this.stats, i = t - e - (s.frozen + s.tooLarge + s.poolFull);
+    return {
+      acquired: t,
+      released: e,
+      rejected: { ...s },
+      leaked: i,
+      poolSize: this.pool.length
+    };
   }
   /**
-   * Disposes of the atom and releases all subscribers and tasks.
+   * Resets pool.
    */
-  dispose() {
-    const e = this.flags;
-    e & L.DISPOSED || (this._fnSubs.length = 0, this._objSubs.length = 0, this.flags = e | L.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+  reset() {
+    this.pool.length = 0, m && this.stats && (this.stats = {
+      acquired: 0,
+      released: 0,
+      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
+    });
   }
 }
-function dt(n, e = {}) {
-  return new ft(n, e.sync ?? !1);
-}
-function se(n, e, t) {
-  if (n instanceof TypeError)
-    return new e(`Type error (${t}): ${n.message}`, n);
-  if (n instanceof ReferenceError)
-    return new e(`Reference error (${t}): ${n.message}`, n);
-  if (n instanceof Q)
-    return n;
-  const s = n instanceof Error ? n.message : String(n), i = n instanceof Error ? n : null;
-  return new e(`Unexpected error (${t}): ${s}`, i);
-}
-function Te(n) {
+const tt = (n) => Object.freeze(n);
+tt([]);
+tt([]);
+tt([]);
+tt([]);
+const T = tt([]);
+tt([]);
+const j = new le();
+function yt(n) {
   return n !== null && typeof n == "object" && "value" in n && typeof n.subscribe == "function";
 }
-function Fe(n) {
-  return F.enabled && n != null && typeof n == "object" && F.getDebugType(n) === "computed" ? !0 : Te(n) && typeof n.invalidate == "function";
+function wt(n) {
+  return yt(n) && typeof n.invalidate == "function";
 }
-function Ge(n) {
-  return n != null && typeof n.then == "function";
+function qt(n) {
+  return n !== null && typeof n == "object" && typeof n.then == "function";
 }
-const Qe = f.RESOLVED | f.PENDING | f.REJECTED, pe = Array(Qe + 1).fill(_e.IDLE);
-pe[f.RESOLVED] = _e.RESOLVED;
-pe[f.PENDING] = _e.PENDING;
-pe[f.REJECTED] = _e.REJECTED;
-const Pe = 3, Me = Number.MAX_SAFE_INTEGER - 1;
-class Je extends ze {
-  constructor(e, t = {}) {
-    if (typeof e != "function")
-      throw new $(C.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._value = void 0, this.flags = f.DIRTY | f.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Ie, this._onError = t.onError ?? null, this._fnSubs = [], this._objSubs = [], this._dependencies = v, this._dependencyVersions = R, this._unsubscribes = X, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackDeps = v, this._trackVersions = R, this._trackCount = 0, F.attachDebugInfo(this, "computed", this.id), F.enabled) {
-      const s = this;
-      s.subscriberCount = this.subscriberCount.bind(this), s.isDirty = () => (this.flags & f.DIRTY) !== 0, s.dependencies = this._dependencies;
-    }
-    if (t.lazy === !1)
+const Xt = h.RESOLVED | h.PENDING | h.REJECTED, at = Array(Xt + 1).fill(ht.IDLE);
+at[h.RESOLVED] = ht.RESOLVED;
+at[h.PENDING] = ht.PENDING;
+at[h.REJECTED] = ht.REJECTED;
+const xt = 3, Lt = Number.MAX_SAFE_INTEGER - 1;
+class Gt extends Ht {
+  constructor(t, e = {}) {
+    if (typeof t != "function") throw new B(S.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = T, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = T, this._trackCount = 0, this._value = void 0, this.flags = h.DIRTY | h.IDLE, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : pt, this._onError = e.onError ?? null, X.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
+  _track() {
+    const t = Q.current;
+    t && $t(this, t, this._subscribers);
+  }
   get value() {
-    const e = O.current;
-    e && z(this, e, this._fnSubs, this._objSubs);
-    let t = this.flags;
-    if ((t & (f.RESOLVED | f.DIRTY | f.IDLE)) === f.RESOLVED)
+    this._track();
+    const t = this.flags;
+    if ((t & (h.RESOLVED | h.DIRTY | h.IDLE)) === h.RESOLVED)
       return this._value;
-    if (t & f.DISPOSED)
-      throw new $(C.COMPUTED_DISPOSED);
-    if (t & f.RECOMPUTING) {
-      const o = this._defaultValue;
-      if (o !== Ie) return o;
-      throw new $(C.COMPUTED_CIRCULAR_DEPENDENCY);
+    if (t & h.DISPOSED)
+      throw new B(S.COMPUTED_DISPOSED);
+    if (t & h.RECOMPUTING) {
+      if (this._defaultValue !== pt) return this._defaultValue;
+      throw new B(S.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (f.DIRTY | f.IDLE) && (this._recompute(), t = this.flags), t & f.RESOLVED)
+    if (t & (h.DIRTY | h.IDLE) && (this._recompute(), this.flags & h.RESOLVED))
       return this._value;
-    const s = this._defaultValue, i = s !== Ie;
-    if (t & f.PENDING) {
-      if (i) return s;
-      throw new $(C.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    const e = this._defaultValue, s = e !== pt;
+    if (this.flags & h.PENDING) {
+      if (s) return e;
+      throw new B(S.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (t & f.REJECTED) {
-      const o = this._error;
-      if (o?.recoverable && i) return s;
-      throw o;
+    if (this.flags & h.REJECTED) {
+      if (this._error?.recoverable && s) return e;
+      throw this._error;
     }
     return this._value;
   }
@@ -720,454 +564,386 @@ class Je extends ze {
     return this._value;
   }
   get state() {
-    const e = O.current;
-    return e && z(this, e, this._fnSubs, this._objSubs), pe[this.flags & Qe];
+    return this._track(), at[this.flags & Xt];
   }
   get hasError() {
-    const e = O.current;
-    if (e && z(this, e, this._fnSubs, this._objSubs), this.flags & (f.REJECTED | f.HAS_ERROR)) return !0;
-    const t = this._dependencies;
-    for (let s = 0, i = t.length; s < i; s++)
-      if (t[s].flags & f.HAS_ERROR) return !0;
+    if (this._track(), this.flags & (h.REJECTED | h.HAS_ERROR)) return !0;
+    const t = this._links;
+    for (let e = 0, s = t.length; e < s; e++) {
+      const i = t[e]?.node;
+      if (i && i.flags & h.HAS_ERROR) return !0;
+    }
     return !1;
   }
+  // ... (isValid, errors, lastError getters remain structurally similar, omitted for brevity if mostly unchanged) ...
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    const e = O.current;
-    if (e && z(this, e, this._fnSubs, this._objSubs), !this.hasError) return et;
-    const t = ut();
-    if (this._errorCacheEpoch === t && this._cachedErrors !== null)
-      return this._cachedErrors;
-    const s = /* @__PURE__ */ new Set(), i = this._error;
-    i && s.add(i);
-    const o = this._dependencies;
-    for (let c = 0, u = o.length; c < u; c++) {
-      const h = o[c];
-      if (h.flags & f.HAS_ERROR) {
-        const p = h.errors;
-        if (p)
-          for (let a = 0, _ = p.length; a < _; a++) {
-            const d = p[a];
-            d && s.add(d);
+    if (this._track(), !this.hasError) return Kt;
+    const t = ie();
+    if (this._errorCacheEpoch === t && this._cachedErrors) return this._cachedErrors;
+    const e = /* @__PURE__ */ new Set();
+    this._error && e.add(this._error);
+    const s = this._links;
+    for (let o = 0, r = s.length; o < r; o++) {
+      const c = s[o].node;
+      if (c.flags & h.HAS_ERROR) {
+        const l = c;
+        if (l.errors) {
+          const a = l.errors;
+          for (let d = 0; d < a.length; d++) {
+            const N = a[d];
+            N && e.add(N);
           }
+        }
       }
     }
-    const r = Object.freeze(Array.from(s));
-    return this._errorCacheEpoch = t, this._cachedErrors = r, r;
+    const i = Object.freeze(Array.from(e));
+    return this._errorCacheEpoch = t, this._cachedErrors = i, i;
   }
   get lastError() {
-    const e = O.current;
-    return e && z(this, e, this._fnSubs, this._objSubs), this._error;
+    return this._track(), this._error;
   }
   get isPending() {
-    const e = O.current;
-    return e && z(this, e, this._fnSubs, this._objSubs), (this.flags & f.PENDING) !== 0;
+    return this._track(), (this.flags & h.PENDING) !== 0;
   }
   get isResolved() {
-    const e = O.current;
-    return e && z(this, e, this._fnSubs, this._objSubs), (this.flags & f.RESOLVED) !== 0;
+    return this._track(), (this.flags & h.RESOLVED) !== 0;
   }
   invalidate() {
-    this._markDirty();
-    const e = this._dependencyVersions;
-    e !== R && (j.release(e), this._dependencyVersions = R), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty(), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this.flags & f.DISPOSED) return;
-    const e = this._unsubscribes;
-    if (e !== X) {
-      for (let i = 0, o = e.length; i < o; i++) {
-        const r = e[i];
-        r && r();
-      }
-      W.release(e), this._unsubscribes = X;
+    if (this.flags & h.DISPOSED) return;
+    const t = this._links;
+    if (t !== T) {
+      for (let e = 0, s = t.length; e < s; e++)
+        t[e].unsub?.();
+      j.release(t), this._links = T;
+    }
+    this._subscribers.length = 0, this.flags = h.DISPOSED | h.DIRTY | h.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Lt, this._cachedErrors = null, this._errorCacheEpoch = -1;
+  }
+  addDependency(t) {
+    if (t._lastSeenEpoch !== this._trackEpoch) {
+      if (t._lastSeenEpoch = this._trackEpoch, this._trackCount < this._trackLinks.length) {
+        const e = this._trackLinks[this._trackCount];
+        e.node = t, e.version = t.version;
+      } else
+        this._trackLinks.push(new mt(t, t.version));
+      this._trackCount++;
     }
-    const t = this._dependencies;
-    t !== v && (G.release(t), this._dependencies = v);
-    const s = this._dependencyVersions;
-    s !== R && (j.release(s), this._dependencyVersions = R), this._fnSubs.length = 0, this._objSubs.length = 0, this.flags = f.DISPOSED | f.DIRTY | f.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Me, this._cachedErrors = null, this._errorCacheEpoch = -1;
-  }
-  addDependency(e) {
-    if (e._lastSeenEpoch === this._trackEpoch) return;
-    e._lastSeenEpoch = this._trackEpoch;
-    const t = this._trackCount, s = this._trackDeps, i = this._trackVersions;
-    t < s.length ? (s[t] = e, i[t] = e.version) : (s.push(e), i.push(e.version)), this._trackCount = t + 1;
   }
-  _commitDeps(e) {
-    const t = this._trackDeps, s = this._trackVersions, i = this._trackCount;
-    t.length = i, s.length = i, this._unsubscribes = ct(t, e, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
+  _commitDeps(t) {
+    this._trackLinks.length = this._trackCount, se(this._trackLinks, t, this), this._links = this._trackLinks;
   }
   _recompute() {
-    if (this.flags & f.RECOMPUTING) return;
-    this.flags |= f.RECOMPUTING;
-    const e = this._dependencies, t = this._dependencyVersions;
-    this._trackEpoch = qe(), this._trackDeps = G.acquire(), this._trackVersions = j.acquire(), this._trackCount = 0;
-    let s = !1;
+    if (this.flags & h.RECOMPUTING) return;
+    this.flags |= h.RECOMPUTING;
+    const t = this._links;
+    this._trackEpoch = Vt(), this._trackLinks = j.acquire(), this._trackCount = 0;
+    let e = !1;
     try {
-      const i = O.run(this, this._fn);
-      this._commitDeps(e), s = !0, Ge(i) ? this._handleAsyncComputation(i) : this._finalizeResolution(i);
-    } catch (i) {
-      let o = i;
-      if (!s)
+      const s = Q.run(this, this._fn);
+      this._commitDeps(t), e = !0, qt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+    } catch (s) {
+      if (!e)
         try {
-          this._commitDeps(e), s = !0;
-        } catch (r) {
-          o = r;
+          this._commitDeps(t), e = !0;
+        } catch {
         }
-      this._handleComputationError(o);
+      this._handleError(s, S.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      s ? (e !== v && G.release(e), t !== R && j.release(t)) : (G.release(this._trackDeps), j.release(this._trackVersions)), this._trackEpoch = -1, this._trackDeps = v, this._trackVersions = R, this._trackCount = 0, this.flags &= -257;
+      e && t !== T ? j.release(t) : e || j.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = T, this._trackCount = 0, this.flags &= -257;
     }
   }
-  _handleAsyncComputation(e) {
-    this.flags = (this.flags | f.PENDING) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Me;
-    const t = this._promiseId;
-    e.then((s) => {
-      if (t === this._promiseId) {
-        if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
-          if (this._asyncRetryCount < Pe) {
-            this._asyncRetryCount++, this._markDirty();
-            return;
-          }
-          this._handleAsyncRejection(
-            new $(`Async drift threshold exceeded after ${Pe} retries.`)
-          );
-          return;
+  _handleAsyncComputation(t) {
+    this.flags = (this.flags | h.PENDING) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Lt;
+    const e = this._promiseId;
+    t.then(
+      (s) => {
+        if (e === this._promiseId) {
+          if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion)
+            return this._asyncRetryCount++ < xt ? this._markDirty() : this._handleError(
+              new B(`Async drift threshold exceeded after ${xt} retries.`),
+              S.COMPUTED_ASYNC_COMPUTATION_FAILED
+            );
+          this._finalizeResolution(s), this._notifySubscribers(s, void 0);
         }
-        this._finalizeResolution(s), this._notifySubscribers(s, void 0);
-      }
-    }).catch((s) => {
-      t === this._promiseId && this._handleAsyncRejection(s);
-    });
+      },
+      (s) => e === this._promiseId && this._handleError(s, S.COMPUTED_ASYNC_COMPUTATION_FAILED)
+    );
   }
   _captureVersionSnapshot() {
-    let e = 0;
-    const t = this._dependencies;
-    for (let s = 0, i = t.length; s < i; s++) {
-      const o = t[s];
-      if (o) {
-        const r = o.version;
-        e = ((e << 5) - e | 0) + r & K;
-      }
-    }
-    return e;
-  }
-  _handleAsyncRejection(e) {
-    const t = se(e, $, C.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    this.flags & f.REJECTED || (this.version = this.version + 1 & K), this._error = t, this.flags = this.flags & -121 | (f.REJECTED | f.HAS_ERROR);
-    const s = this._onError;
-    if (s)
+    let t = 0;
+    const e = this._links;
+    for (let s = 0, i = e.length; s < i; s++)
+      t = ((t << 5) - t | 0) + e[s].node.version & G;
+    return t;
+  }
+  _handleError(t, e, s = !1) {
+    const i = K(t, B, e);
+    if (!s && !(this.flags & h.REJECTED) && (this.version = this.version + 1 & G), this._error = i, this.flags = this.flags & -121 | (h.REJECTED | h.HAS_ERROR), this._onError)
       try {
-        s(t);
-      } catch (i) {
-        console.error(C.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+        this._onError(i);
+      } catch (o) {
+        console.error(S.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
       }
+    if (s) throw i;
     this._notifySubscribers(void 0, void 0);
   }
-  _finalizeResolution(e) {
-    (!(this.flags & f.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & K), this._value = e, this._error = null, this.flags = (this.flags | f.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
-  }
-  _handleComputationError(e) {
-    const t = se(e, $, C.COMPUTED_COMPUTATION_FAILED);
-    this._error = t, this.flags = this.flags & -121 | (f.REJECTED | f.HAS_ERROR);
-    const s = this._onError;
-    if (s)
-      try {
-        s(t);
-      } catch (i) {
-        console.error(C.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
-      }
-    throw t;
+  _finalizeResolution(t) {
+    (!(this.flags & h.RESOLVED) || !this._equal(this._value, t)) && (this.version = this.version + 1 & G), this._value = t, this._error = null, this.flags = (this.flags | h.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    const e = this.flags;
-    e & (f.RECOMPUTING | f.DIRTY) || (this.flags = e | f.DIRTY, this._notifySubscribers(void 0, void 0));
+    this.flags & (h.RECOMPUTING | h.DIRTY) || (this.flags |= h.DIRTY, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Je.prototype);
-function _t(n, e = {}) {
-  return new Je(n, e);
+Object.freeze(Gt.prototype);
+function he(n, t = {}) {
+  return new Gt(n, t);
 }
-class pt extends He {
-  constructor(e, t = {}) {
-    super(), this._cleanup = null, this._dependencies = v, this._dependencyVersions = R, this._unsubscribes = X, 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 ?? q.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? q.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
-    const s = Number.isFinite(this._maxExecutions), i = s ? Math.min(this._maxExecutions + 1, q.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
-    this._historyCapacity = i, this._history = Z && s && i > 0 ? new Array(i).fill(0) : null, this._execId = 0, F.attachDebugInfo(this, "effect", this.id);
+class ae extends jt {
+  constructor(t, e = {}) {
+    super(), this._cleanup = null, this._links = T, this._nextLinks = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._historyPtr = 0, this._execId = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? $.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? $.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = e.trackModifications ?? !1;
+    const s = Number.isFinite(this._maxExecutions), i = s ? Math.min(this._maxExecutions + 1, $.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
+    this._historyCapacity = i, this._history = m && s && i > 0 ? new Array(i).fill(0) : null, X.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & U.DISPOSED)
-      throw new Y(C.EFFECT_DISPOSED);
+    if (this.flags & k.DISPOSED)
+      throw new q(S.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    const e = this.flags;
-    if (e & U.DISPOSED) return;
-    if (this.flags = e | U.DISPOSED, this._cleanup) {
-      try {
-        this._cleanup();
-      } catch (o) {
-        this._handleExecutionError(o, C.EFFECT_CLEANUP_FAILED);
-      }
-      this._cleanup = null;
-    }
-    const t = this._unsubscribes;
-    if (t !== X) {
-      for (let o = 0, r = t.length; o < r; o++) {
-        const c = t[o];
-        c && c();
-      }
-      W.release(t), this._unsubscribes = X;
-    }
-    const s = this._dependencies;
-    s !== v && (G.release(s), this._dependencies = v);
-    const i = this._dependencyVersions;
-    i !== R && (j.release(i), this._dependencyVersions = R), this._executeTask = void 0;
-  }
-  addDependency(e) {
-    if (!(this.flags & U.EXECUTING)) return;
-    const t = this._currentEpoch;
-    if (e._lastSeenEpoch === t) return;
-    e._lastSeenEpoch = t;
-    const s = this._nextDeps, i = this._nextVersions, o = this._nextUnsubs;
-    s.push(e), i.push(e.version);
-    const r = e._tempUnsub;
-    if (r) {
-      o.push(r), e._tempUnsub = void 0;
+    this.flags & k.DISPOSED || (this.flags |= k.DISPOSED, this._execCleanup(), this._releaseLinks(this._links), this._links = T, this._executeTask = void 0);
+  }
+  addDependency(t) {
+    if (!(this.flags & k.EXECUTING) || t._lastSeenEpoch === this._currentEpoch) return;
+    t._lastSeenEpoch = this._currentEpoch;
+    const e = this._nextLinks;
+    if (t._tempUnsub) {
+      e.push(new mt(t, t.version, t._tempUnsub)), t._tempUnsub = void 0;
       return;
     }
     try {
-      const c = this._sync, u = this._trackModifications, h = e.subscribe(() => {
-        if (u && this.flags & U.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), c) {
-          this.execute();
-          return;
-        }
-        this._executeTask || (this._executeTask = () => this.execute());
-        const p = this._executeTask;
-        oe.schedule(p);
-      });
-      o.push(h);
-    } catch (c) {
-      console.error(se(c, Y, C.EFFECT_EXECUTION_FAILED)), o.push(() => {
+      const s = t.subscribe(() => {
+        if (this._trackModifications && this.flags & k.EXECUTING && (t._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
+        this._executeTask || (this._executeTask = () => this.execute()), A.schedule(this._executeTask);
       });
+      e.push(new mt(t, t.version, s));
+    } catch (s) {
+      console.error(K(s, q, S.EFFECT_EXECUTION_FAILED));
     }
   }
-  execute(e = !1) {
-    if (this.flags & (U.DISPOSED | U.EXECUTING)) return;
-    if (!e) {
-      const a = this._dependencies, _ = a.length;
-      if (_ > 0) {
-        const d = this._dependencyVersions;
-        let S = !1;
-        for (let T = 0; T < _; T++) {
-          const I = a[T];
-          if (I.version !== d[T]) {
-            S = !0;
-            break;
-          }
-          if ("value" in I)
+  /**
+   * Executes effect with tracking.
+   */
+  execute(t = !1) {
+    if (this.flags & (k.DISPOSED | k.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags |= k.EXECUTING, this._execCleanup();
+    const e = this._links;
+    if (e !== T)
+      for (let o = 0, r = e.length; o < r; o++) {
+        const c = e[o];
+        c && (c.node._tempUnsub = c.unsub);
+      }
+    const s = j.acquire();
+    this._nextLinks = s, this._currentEpoch = Vt();
+    let i = !1;
+    try {
+      const o = Q.run(this, this._fn);
+      this._links = s, i = !0, this._checkLoopWarnings(), qt(o) ? this._handleAsyncResult(o) : this._cleanup = typeof o == "function" ? o : null;
+    } catch (o) {
+      i = !0, this._handleExecutionError(o), this._cleanup = null;
+    } finally {
+      this._finalizeDependencies(i, e, s), this.flags &= -9;
+    }
+  }
+  _handleAsyncResult(t) {
+    const e = ++this._execId;
+    t.then(
+      (s) => {
+        if (e !== this._execId || this.flags & k.DISPOSED) {
+          if (typeof s == "function")
             try {
-              if (Xe(() => I.value), I.version !== d[T]) {
-                S = !0;
-                break;
-              }
-            } catch {
-              S = !0;
-              break;
+              s();
+            } catch (i) {
+              this._handleExecutionError(i, S.EFFECT_CLEANUP_FAILED);
             }
+          return;
+        }
+        typeof s == "function" && (this._cleanup = s);
+      },
+      (s) => e === this._execId && this._handleExecutionError(s)
+    );
+  }
+  _finalizeDependencies(t, e, s) {
+    if (this._nextLinks = null, t) {
+      if (e !== T) {
+        for (let i = 0, o = e.length; i < o; i++) {
+          const r = e[i], c = r?.node._tempUnsub;
+          c && (c(), r && (r.node._tempUnsub = void 0));
         }
-        if (!S) return;
+        j.release(e);
       }
+    } else if (this._releaseLinks(s), j.release(s), e !== T)
+      for (let i = 0, o = e.length; i < o; i++)
+        e[i] && (e[i].node._tempUnsub = void 0);
+  }
+  _releaseLinks(t) {
+    if (t !== T) {
+      for (let e = 0, s = t.length; e < s; e++)
+        t[e]?.unsub?.();
+      j.release(t);
     }
-    const t = De;
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ht() > q.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
-    const s = this._history;
-    if (s) {
-      const a = Date.now(), _ = this._historyPtr;
-      s[_] = a;
-      const d = (_ + 1) % this._historyCapacity;
-      this._historyPtr = d;
-      const S = s[d] || 0;
-      if (S > 0 && a - S < Ze.ONE_SECOND_MS) {
-        const T = new Y(
-          "Effect executed too frequently within 1 second. Suspected infinite loop."
-        );
-        if (this.dispose(), this._handleExecutionError(T), Z) throw T;
-        return;
+  }
+  _isDirty() {
+    const t = this._links;
+    for (let e = 0, s = t.length; e < s; e++) {
+      const i = t[e], o = i.node;
+      if (o.version !== i.version) return !0;
+      if ("value" in o) {
+        try {
+          zt(() => o.value);
+        } catch {
+          return !0;
+        }
+        if (o.version !== i.version) return !0;
       }
     }
-    if (this.flags |= U.EXECUTING, this._cleanup) {
+    return !1;
+  }
+  _execCleanup() {
+    if (this._cleanup) {
       try {
         this._cleanup();
-      } catch (a) {
-        this._handleExecutionError(a, C.EFFECT_CLEANUP_FAILED);
+      } catch (t) {
+        this._handleExecutionError(t, S.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
-    const i = this._dependencies, o = this._dependencyVersions, r = this._unsubscribes;
-    if (i !== v)
-      for (let a = 0, _ = i.length; a < _; a++) {
-        const d = i[a];
-        d && (d._tempUnsub = r[a]);
-      }
-    const c = G.acquire(), u = j.acquire(), h = W.acquire();
-    this._nextDeps = c, this._nextVersions = u, this._nextUnsubs = h, this._currentEpoch = qe();
-    let p = !1;
-    try {
-      const a = O.run(this, this._fn);
-      this._dependencies = c, this._dependencyVersions = u, this._unsubscribes = h, p = !0, this._checkLoopWarnings();
-      const _ = ++this._execId;
-      Ge(a) ? a.then((d) => {
-        if (_ !== this._execId || this.flags & U.DISPOSED) {
-          if (typeof d == "function")
-            try {
-              d();
-            } catch (S) {
-              this._handleExecutionError(S, C.EFFECT_CLEANUP_FAILED);
-            }
-          return;
-        }
-        typeof d == "function" && (this._cleanup = d);
-      }).catch((d) => {
-        _ === this._execId && this._handleExecutionError(d);
-      }) : this._cleanup = typeof a == "function" ? a : null;
-    } catch (a) {
-      p = !0, this._handleExecutionError(a), this._cleanup = null;
-    } finally {
-      if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, p) {
-        if (i !== v) {
-          for (let a = 0, _ = i.length; a < _; a++) {
-            const d = i[a], S = d ? d._tempUnsub : void 0;
-            S && (S(), d && (d._tempUnsub = void 0));
-          }
-          G.release(i);
-        }
-        o !== R && j.release(o), r !== X && W.release(r);
-      } else {
-        G.release(c), j.release(u);
-        for (let a = 0, _ = h.length; a < _; a++) {
-          const d = h[a];
-          d && d();
-        }
-        if (W.release(h), i !== v)
-          for (let a = 0, _ = i.length; a < _; a++) {
-            const d = i[a];
-            d && (d._tempUnsub = void 0);
-          }
+  }
+  _checkInfiniteLoops() {
+    const t = bt;
+    if (this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > $.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+      const e = Date.now();
+      this._history[this._historyPtr] = e, this._historyPtr = (this._historyPtr + 1) % this._historyCapacity;
+      const s = this._history[this._historyPtr] || 0;
+      if (s > 0 && e - s < Wt.ONE_SECOND_MS) {
+        const i = new q(
+          "Effect executed too frequently within 1 second. Suspected infinite loop."
+        );
+        if (this.dispose(), this._handleExecutionError(i), m) throw i;
       }
-      this.flags &= -9;
     }
   }
   get isDisposed() {
-    return (this.flags & U.DISPOSED) !== 0;
+    return (this.flags & k.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & U.EXECUTING) !== 0;
+    return (this.flags & k.EXECUTING) !== 0;
   }
-  _throwInfiniteLoopError(e) {
-    const t = new Y(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Oe}`
+  _throwInfiniteLoopError(t) {
+    const e = new q(
+      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Ct}`
     );
-    throw this.dispose(), console.error(t), t;
+    throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(e, t = C.EFFECT_EXECUTION_FAILED) {
-    const s = se(e, Y, t);
-    console.error(s);
-    const i = this._onError;
-    if (i)
+  _handleExecutionError(t, e = S.EFFECT_EXECUTION_FAILED) {
+    const s = K(t, q, e);
+    if (console.error(s), this._onError)
       try {
-        i(s);
-      } catch (o) {
-        console.error(se(o, Y, C.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        this._onError(s);
+      } catch (i) {
+        console.error(K(i, q, S.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
   _checkLoopWarnings() {
-    if (this._trackModifications && F.enabled) {
-      const e = this._dependencies, t = this._currentEpoch;
+    if (this._trackModifications && X.enabled) {
+      const t = this._currentEpoch, e = this._links;
       for (let s = 0, i = e.length; s < i; s++) {
-        const o = e[s];
-        o && o._modifiedAtEpoch === t && F.warn(
+        const o = e[s].node;
+        o._modifiedAtEpoch === t && X.warn(
           !0,
-          `Effect is reading a dependency (${F.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${X.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function ee(n, e = {}) {
+function Y(n, t = {}) {
   if (typeof n != "function")
-    throw new Y(C.EFFECT_MUST_BE_FUNCTION);
-  const t = new pt(n, e);
-  return t.execute(), t;
+    throw new q(S.EFFECT_MUST_BE_FUNCTION);
+  const e = new ae(n, t);
+  return e.execute(), e;
 }
-function Ae(n) {
+function It(n) {
   if (typeof n != "function")
-    throw new Q("Batch callback must be a function");
-  oe.startBatch();
+    throw new TypeError("Batch callback must be a function");
+  A.startBatch();
   try {
     return n();
   } finally {
-    oe.endBatch();
+    A.endBatch();
   }
 }
-function Et(n) {
+function fe(n) {
   return n !== null && typeof n == "object" && "value" in n && "subscribe" in n;
 }
-function Ee(n) {
+function ft(n) {
   if (!n) return "unknown";
-  const e = "jquery" in n ? n[0] : n;
-  if (!e) return "unknown";
-  const t = e.id;
-  if (t && typeof t == "string") return `#${t}`;
-  const s = e.tagName.toLowerCase(), i = e.classList;
+  const t = "jquery" in n ? n[0] : n;
+  if (!t) return "unknown";
+  const e = t.id;
+  if (e && typeof e == "string") return `#${e}`;
+  const s = t.tagName.toLowerCase(), i = t.classList;
   if (i && i.length > 0) {
     let o = s;
     for (let r = 0, c = i.length; r < c; r++) {
-      const u = i[r];
-      u && (o += `.${u}`);
+      const l = i[r];
+      l && (o += `.${l}`);
     }
     return o;
   }
   return s;
 }
-function gt(n) {
-  const e = n.length;
-  if (e === 0) return new Int32Array(0);
-  const t = new Int32Array(e), s = new Int32Array(e);
+function _e(n) {
+  const t = n.length;
+  if (t === 0) return new Int32Array(0);
+  const e = new Int32Array(t), s = new Int32Array(t);
   let i = 0;
-  for (let r = 0; r < e; r++) {
+  for (let r = 0; r < t; r++) {
     const c = n[r];
     if (c === void 0 || c === -1) continue;
-    const u = i > 0 ? s[i - 1] : void 0;
-    if (i === 0 || u !== void 0 && (n[u] ?? -1) < c) {
-      t[r] = u ?? -1, s[i++] = r;
+    const l = i > 0 ? s[i - 1] : void 0;
+    if (i === 0 || l !== void 0 && (n[l] ?? -1) < c) {
+      e[r] = l ?? -1, s[i++] = r;
       continue;
     }
-    let h = 0, p = i - 1;
-    for (; h < p; ) {
-      const _ = h + p >>> 1, d = s[_];
-      d !== void 0 && (n[d] ?? -1) < c ? h = _ + 1 : p = _;
+    let a = 0, d = i - 1;
+    for (; a < d; ) {
+      const C = a + d >>> 1, v = s[C];
+      v !== void 0 && (n[v] ?? -1) < c ? a = C + 1 : d = C;
     }
-    const a = s[h];
-    a !== void 0 && c < (n[a] ?? Number.MAX_SAFE_INTEGER) && (h > 0 && (t[r] = s[h - 1] ?? -1), s[h] = r);
+    const N = s[a];
+    N !== void 0 && c < (n[N] ?? Number.MAX_SAFE_INTEGER) && (a > 0 && (e[r] = s[a - 1] ?? -1), s[a] = r);
   }
   const o = new Int32Array(i);
   if (i > 0) {
     let r = s[i - 1];
     for (let c = i - 1; c >= 0 && r !== void 0 && r !== -1; c--)
-      o[c] = r, r = t[r];
+      o[c] = r, r = e[r];
   }
   return o;
 }
-function mt() {
+function de() {
   if (typeof window < "u") {
     const n = window.__ATOM_DEBUG__;
     if (typeof n == "boolean") return n;
@@ -1178,401 +954,401 @@ function mt() {
   }
   return !1;
 }
-let J = mt();
-const g = {
+let z = de();
+const _ = {
   get enabled() {
-    return J;
+    return z;
   },
   set enabled(n) {
-    J = n;
+    z = n;
   },
-  log(n, ...e) {
-    J && console.log(`[atom-effect-jquery] ${n}:`, ...e);
+  log(n, ...t) {
+    z && console.log(`[atom-effect-jquery] ${n}:`, ...t);
   },
-  atomChanged(n, e, t) {
-    J && console.log(
+  atomChanged(n, t, e) {
+    z && console.log(
       `[atom-effect-jquery] Atom "${n ?? "anonymous"}" changed:`,
-      e,
+      t,
       "→",
-      t
+      e
     );
   },
   /**
    * Logs DOM updates and triggers visual highlight.
    */
-  domUpdated(n, e, t) {
-    J && (console.log(`[atom-effect-jquery] DOM updated: ${Ee(n)}.${e} =`, t), bt(n));
+  domUpdated(n, t, e) {
+    z && (console.log(`[atom-effect-jquery] DOM updated: ${ft(n)}.${t} =`, e), Ee(n));
   },
   cleanup(n) {
-    J && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
+    z && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
   },
   warn(...n) {
-    J && console.warn("[atom-effect-jquery]", ...n);
-  }
-}, Ce = /* @__PURE__ */ new WeakMap();
-function bt(n) {
-  const e = "jquery" in n ? n[0] : n;
-  if (!e || !e.isConnected) return;
-  let t = Ce.get(e);
-  if (t || (t = {}, Ce.set(e, t)), t.timer && clearTimeout(t.timer), t.cleanupTimer && clearTimeout(t.cleanupTimer), !t.orgStyle) {
-    const i = e.style;
-    t.orgStyle = {
+    z && console.warn("[atom-effect-jquery]", ...n);
+  }
+}, gt = /* @__PURE__ */ new WeakMap();
+function Ee(n) {
+  const t = "jquery" in n ? n[0] : n;
+  if (!t || !t.isConnected) return;
+  let e = gt.get(t);
+  if (e || (e = {}, gt.set(t, e)), e.timer && clearTimeout(e.timer), e.cleanupTimer && clearTimeout(e.cleanupTimer), !e.orgStyle) {
+    const i = t.style;
+    e.orgStyle = {
       outline: i.outline,
       outlineOffset: i.outlineOffset,
       transition: i.transition
     };
   }
-  const s = e.style;
-  s.outline = "2px solid rgba(255, 68, 68, 0.8)", s.outlineOffset = "1px", s.transition = "none", t.timer = setTimeout(() => {
-    e.isConnected && (s.transition = "outline 0.5s ease-out", requestAnimationFrame(() => {
-      if (!e.isConnected) return;
-      const i = t?.orgStyle;
-      i && (s.outline = i.outline, s.outlineOffset = i.outlineOffset), t.cleanupTimer = setTimeout(() => {
-        e.isConnected && t?.orgStyle && (s.transition = t.orgStyle.transition), Ce.delete(e);
+  const s = t.style;
+  s.outline = "2px solid rgba(255, 68, 68, 0.8)", s.outlineOffset = "1px", s.transition = "none", e.timer = setTimeout(() => {
+    t.isConnected && (s.transition = "outline 0.5s ease-out", requestAnimationFrame(() => {
+      if (!t.isConnected) return;
+      const i = e?.orgStyle;
+      i && (s.outline = i.outline, s.outlineOffset = i.outlineOffset), e.cleanupTimer = setTimeout(() => {
+        t.isConnected && e?.orgStyle && (s.transition = e.orgStyle.transition), gt.delete(t);
       }, 500);
     }));
   }, 100);
 }
-const St = /* @__PURE__ */ new WeakMap();
-function Ye(n, e = {}) {
-  const t = dt(n, e);
-  return e.name && St.set(t, { name: e.name }), t;
+const pe = /* @__PURE__ */ new WeakMap();
+function Qt(n, t = {}) {
+  const e = ue(n, t);
+  return t.name && pe.set(e, { name: t.name }), e;
 }
-Object.defineProperty(Ye, "debug", {
+Object.defineProperty(Qt, "debug", {
   get() {
-    return g.enabled;
+    return _.enabled;
   },
   set(n) {
-    g.enabled = n;
+    _.enabled = n;
   }
 });
-function yt() {
+function ge() {
   return new Promise((n) => setTimeout(n, 0));
 }
-l.extend({
-  atom: Ye,
-  computed: _t,
-  effect: ee,
-  batch: Ae,
-  untracked: Xe,
-  isAtom: Te,
-  isComputed: Fe,
-  isReactive: (n) => Te(n) || Fe(n),
-  nextTick: yt
+u.extend({
+  atom: Qt,
+  computed: he,
+  effect: Y,
+  batch: It,
+  untracked: zt,
+  isAtom: yt,
+  isComputed: wt,
+  isReactive: (n) => yt(n) || wt(n),
+  nextTick: ge
 });
-const he = "_aes-bound";
-class It {
+const ot = "_aes-bound";
+class me {
   records = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
   preservedNodes = /* @__PURE__ */ new WeakSet();
   ignoredNodes = /* @__PURE__ */ new WeakSet();
   // Prevent redundant cleanup
-  keep(e) {
-    this.preservedNodes.add(e);
+  keep(t) {
+    this.preservedNodes.add(t);
   }
-  isKept(e) {
-    return this.preservedNodes.has(e);
+  isKept(t) {
+    return this.preservedNodes.has(t);
   }
-  markIgnored(e) {
-    this.ignoredNodes.add(e);
+  markIgnored(t) {
+    this.ignoredNodes.add(t);
   }
-  isIgnored(e) {
-    return this.ignoredNodes.has(e);
+  isIgnored(t) {
+    return this.ignoredNodes.has(t);
   }
-  _getOrCreateRecord(e) {
-    let t = this.records.get(e);
-    return t || (t = {}, this.records.set(e, t), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(he))), t;
+  _getOrCreateRecord(t) {
+    let e = this.records.get(t);
+    return e || (e = {}, this.records.set(t, e), this.boundElements.has(t) || (this.boundElements.add(t), t.classList.add(ot))), e;
   }
-  trackEffect(e, t) {
-    const s = this._getOrCreateRecord(e);
-    s.effects || (s.effects = []), s.effects.push(t);
+  trackEffect(t, e) {
+    const s = this._getOrCreateRecord(t);
+    s.effects || (s.effects = []), s.effects.push(e);
   }
-  trackCleanup(e, t) {
-    const s = this._getOrCreateRecord(e);
-    s.cleanups || (s.cleanups = []), s.cleanups.push(t);
+  trackCleanup(t, e) {
+    const s = this._getOrCreateRecord(t);
+    s.cleanups || (s.cleanups = []), s.cleanups.push(e);
   }
-  hasBind(e) {
-    return this.boundElements.has(e);
+  hasBind(t) {
+    return this.boundElements.has(t);
   }
-  cleanup(e) {
-    if (!this.boundElements.delete(e)) return;
-    const t = this.records.get(e);
-    if (!t) return;
-    this.records.delete(e), this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.classList.remove(he), g.enabled && g.cleanup(Ee(e));
-    const s = t.effects;
+  cleanup(t) {
+    if (!this.boundElements.delete(t)) return;
+    const e = this.records.get(t);
+    if (!e) return;
+    this.records.delete(t), this.preservedNodes.delete(t), this.ignoredNodes.delete(t), t.classList.remove(ot), _.enabled && _.cleanup(ft(t));
+    const s = e.effects;
     if (s)
       for (let o = 0, r = s.length; o < r; o++)
         try {
           s[o]?.dispose();
         } catch (c) {
-          g.warn("Effect dispose error:", c);
+          _.warn("Effect dispose error:", c);
         }
-    const i = t.cleanups;
+    const i = e.cleanups;
     if (i)
       for (let o = 0, r = i.length; o < r; o++)
         try {
           i[o]?.();
         } catch (c) {
-          g.warn("Cleanup error:", c);
+          _.warn("Cleanup error:", c);
         }
   }
-  cleanupDescendants(e) {
-    const t = e.querySelectorAll(`.${he}`);
-    for (let s = 0, i = t.length; s < i; s++) {
-      const o = t[s];
-      o && this.boundElements.has(o) ? this.cleanup(o) : o && o.classList.remove(he);
+  cleanupDescendants(t) {
+    const e = t.querySelectorAll(`.${ot}`);
+    for (let s = 0, i = e.length; s < i; s++) {
+      const o = e[s];
+      o && this.boundElements.has(o) ? this.cleanup(o) : o && o.classList.remove(ot);
     }
   }
-  cleanupTree(e) {
-    this.cleanupDescendants(e), this.cleanup(e);
+  cleanupTree(t) {
+    this.cleanupDescendants(t), this.cleanup(t);
   }
 }
-const b = new It();
-let ie = null;
-function Ct(n = document.body) {
-  ie || (ie = new MutationObserver((e) => {
-    for (let t = 0, s = e.length; t < s; t++) {
-      const i = e[t]?.removedNodes;
+const p = new me();
+let et = null;
+function Se(n = document.body) {
+  et || (et = new MutationObserver((t) => {
+    for (let e = 0, s = t.length; e < s; e++) {
+      const i = t[e]?.removedNodes;
       if (!i) continue;
       const o = i.length;
       if (o !== 0)
         for (let r = 0; r < o; r++) {
           const c = i[r];
-          c.nodeType === 1 && (c.isConnected || b.isKept(c) || b.isIgnored(c) || b.cleanupTree(c));
+          c.nodeType === 1 && (c.isConnected || p.isKept(c) || p.isIgnored(c) || p.cleanupTree(c));
         }
     }
-  }), ie.observe(n, { childList: !0, subtree: !0 }));
+  }), et.observe(n, { childList: !0, subtree: !0 }));
 }
-function Mt() {
-  ie?.disconnect(), ie = null;
+function xe() {
+  et?.disconnect(), et = null;
 }
-function D(n, e, t, s) {
-  Et(e) ? b.trackEffect(
+function b(n, t, e, s) {
+  fe(t) ? p.trackEffect(
     n,
-    ee(() => {
-      const i = e.value;
-      t(i), g.domUpdated(l(n), s, i);
+    Y(() => {
+      const i = t.value;
+      e(i), _.domUpdated(u(n), s, i);
     })
-  ) : (t(e), g.domUpdated(l(n), s, e));
+  ) : (e(t), _.domUpdated(u(n), s, t));
 }
-var y = /* @__PURE__ */ ((n) => (n[n.None = 0] = "None", n[n.Focused = 1] = "Focused", n[n.Composing = 2] = "Composing", n[n.SyncingToAtom = 4] = "SyncingToAtom", n[n.SyncingToDom = 8] = "SyncingToDom", n[n.Busy = 14] = "Busy", n))(y || {});
-function Re() {
+var g = /* @__PURE__ */ ((n) => (n[n.None = 0] = "None", n[n.Focused = 1] = "Focused", n[n.Composing = 2] = "Composing", n[n.SyncingToAtom = 4] = "SyncingToAtom", n[n.SyncingToDom = 8] = "SyncingToDom", n[n.Busy = 14] = "Busy", n))(g || {});
+function Dt() {
   return {
     timeoutId: null,
     flags: 0
     /* None */
   };
 }
-function We(n, e, t = {}) {
+function Yt(n, t, e = {}) {
   const {
     debounce: s,
     event: i = "input",
     parse: o = (I) => I,
     format: r = (I) => String(I ?? ""),
     equal: c = Object.is
-  } = t, u = Re(), h = n[0], p = () => {
-    if (!(u.flags & y.Busy)) {
-      u.flags |= y.SyncingToAtom;
+  } = e, l = Dt(), a = n[0], d = () => {
+    if (!(l.flags & g.Busy)) {
+      l.flags |= g.SyncingToAtom;
       try {
-        const I = h.value, A = o(I);
-        c(e.value, A) || (e.value = A);
+        const I = a.value, D = o(I);
+        c(t.value, D) || (t.value = D);
       } finally {
-        u.flags &= ~y.SyncingToAtom;
+        l.flags &= ~g.SyncingToAtom;
       }
     }
-  }, a = () => {
-    u.timeoutId && (clearTimeout(u.timeoutId), u.timeoutId = null, p()), u.flags &= ~y.Focused;
-    const I = r(e.value);
-    h.value !== I && (h.value = I);
-  }, _ = () => {
-    u.flags & y.Busy || (s ? (u.timeoutId && clearTimeout(u.timeoutId), u.timeoutId = setTimeout(p, s)) : p());
-  }, d = {
+  }, N = () => {
+    l.timeoutId && (clearTimeout(l.timeoutId), l.timeoutId = null, d()), l.flags &= ~g.Focused;
+    const I = r(t.value);
+    a.value !== I && (a.value = I);
+  }, C = () => {
+    l.flags & g.Busy || (s ? (l.timeoutId && clearTimeout(l.timeoutId), l.timeoutId = setTimeout(d, s)) : d());
+  }, v = {
     compositionstart: () => {
-      u.flags |= y.Composing;
+      l.flags |= g.Composing;
     },
     compositionend: () => {
-      u.flags &= ~y.Composing, p();
+      l.flags &= ~g.Composing, d();
     },
     focus: () => {
-      u.flags |= y.Focused;
+      l.flags |= g.Focused;
     },
-    blur: a,
-    [i]: _,
-    change: _
+    blur: N,
+    [i]: C,
+    change: C
   };
-  return n.on(d), { effect: () => {
-    const I = e.value, A = r(I), x = h.value;
-    if (x !== A && !(u.flags & y.Focused && c(o(x), I))) {
-      u.flags |= y.SyncingToDom;
+  return n.on(v), { effect: () => {
+    const I = t.value, D = r(I), O = a.value;
+    if (O !== D && !(l.flags & g.Focused && c(o(O), I))) {
+      l.flags |= g.SyncingToDom;
       try {
-        if (u.flags & y.Focused) {
-          const { selectionStart: re, selectionEnd: ge } = h;
-          h.value = A;
-          const V = A.length;
-          h.setSelectionRange(Math.min(re ?? V, V), Math.min(ge ?? V, V));
+        if (l.flags & g.Focused) {
+          const { selectionStart: nt, selectionEnd: _t } = a;
+          a.value = D;
+          const P = D.length;
+          a.setSelectionRange(Math.min(nt ?? P, P), Math.min(_t ?? P, P));
         } else
-          h.value = A;
-        g.domUpdated(n, "val", A);
+          a.value = D;
+        _.domUpdated(n, "val", D);
       } finally {
-        u.flags &= ~y.SyncingToDom;
+        l.flags &= ~g.SyncingToDom;
       }
     }
   }, cleanup: () => {
-    n.off(d), u.timeoutId && clearTimeout(u.timeoutId);
+    n.off(v), l.timeoutId && clearTimeout(l.timeoutId);
   } };
 }
-l.fn.atomText = function(n, e) {
+u.fn.atomText = function(n, t) {
   return this.each(function() {
-    const t = l(this);
-    D(this, n, e ? (i) => t.text(e(i)) : (i) => t.text(String(i ?? "")), "text");
+    const e = u(this);
+    b(this, n, t ? (i) => e.text(t(i)) : (i) => e.text(String(i ?? "")), "text");
   });
 };
-l.fn.atomHtml = function(n) {
+u.fn.atomHtml = function(n) {
   return this.each(function() {
-    const e = l(this);
-    D(this, n, (t) => e.html(String(t ?? "")), "html");
+    const t = u(this);
+    b(this, n, (e) => t.html(String(e ?? "")), "html");
   });
 };
-l.fn.atomClass = function(n, e) {
+u.fn.atomClass = function(n, t) {
   return this.each(function() {
-    const t = l(this);
-    D(
+    const e = u(this);
+    b(
       this,
-      e,
-      (s) => t.toggleClass(n, !!s),
+      t,
+      (s) => e.toggleClass(n, !!s),
       `class.${n}`
     );
   });
 };
-l.fn.atomCss = function(n, e, t) {
+u.fn.atomCss = function(n, t, e) {
   return this.each(function() {
-    const s = l(this);
-    D(this, e, t ? (o) => s.css(n, `${o}${t}`) : (o) => s.css(n, o), `css.${n}`);
+    const s = u(this);
+    b(this, t, e ? (o) => s.css(n, `${o}${e}`) : (o) => s.css(n, o), `css.${n}`);
   });
 };
-l.fn.atomAttr = function(n, e) {
+u.fn.atomAttr = function(n, t) {
   return this.each(function() {
-    const t = l(this);
-    D(
+    const e = u(this);
+    b(
       this,
-      e,
+      t,
       (s) => {
         if (s == null || s === !1) {
-          t.removeAttr(n);
+          e.removeAttr(n);
           return;
         }
-        t.attr(n, s === !0 ? n : String(s));
+        e.attr(n, s === !0 ? n : String(s));
       },
       `attr.${n}`
     );
   });
 };
-l.fn.atomProp = function(n, e) {
+u.fn.atomProp = function(n, t) {
   return this.each(function() {
-    const t = l(this);
-    D(this, e, (s) => t.prop(n, s), `prop.${n}`);
+    const e = u(this);
+    b(this, t, (s) => e.prop(n, s), `prop.${n}`);
   });
 };
-l.fn.atomShow = function(n) {
+u.fn.atomShow = function(n) {
   return this.each(function() {
-    const e = l(this);
-    D(this, n, (t) => e.toggle(!!t), "show");
+    const t = u(this);
+    b(this, n, (e) => t.toggle(!!e), "show");
   });
 };
-l.fn.atomHide = function(n) {
+u.fn.atomHide = function(n) {
   return this.each(function() {
-    const e = l(this);
-    D(this, n, (t) => e.toggle(!t), "hide");
+    const t = u(this);
+    b(this, n, (e) => t.toggle(!e), "hide");
   });
 };
-l.fn.atomVal = function(n, e = {}) {
+u.fn.atomVal = function(n, t = {}) {
   return this.each(function() {
-    const { effect: t, cleanup: s } = We(l(this), n, e);
-    b.trackEffect(this, ee(t)), b.trackCleanup(this, s);
+    const { effect: e, cleanup: s } = Yt(u(this), n, t);
+    p.trackEffect(this, Y(e)), p.trackCleanup(this, s);
   });
 };
-l.fn.atomChecked = function(n) {
+u.fn.atomChecked = function(n) {
   return this.each(function() {
-    const e = l(this), t = this, s = Re(), i = () => {
-      if (s.flags & y.Busy) return;
-      const r = t.checked;
+    const t = u(this), e = this, s = Dt(), i = () => {
+      if (s.flags & g.Busy) return;
+      const r = e.checked;
       n.value !== r && (n.value = r);
     };
-    e.on("change", i), b.trackCleanup(this, () => e.off("change", i));
-    const o = ee(() => {
-      s.flags |= y.SyncingToDom;
+    t.on("change", i), p.trackCleanup(this, () => t.off("change", i));
+    const o = Y(() => {
+      s.flags |= g.SyncingToDom;
       const r = !!n.value;
-      t.checked !== r && (t.checked = r, g.domUpdated(e, "checked", r)), s.flags &= ~y.SyncingToDom;
+      e.checked !== r && (e.checked = r, _.domUpdated(t, "checked", r)), s.flags &= ~g.SyncingToDom;
     });
-    b.trackEffect(this, o);
+    p.trackEffect(this, o);
   });
 };
-l.fn.atomOn = function(n, e) {
+u.fn.atomOn = function(n, t) {
   return this.each(function() {
-    const t = l(this);
-    t.on(n, e), b.trackCleanup(this, () => t.off(n, e));
+    const e = u(this);
+    e.on(n, t), p.trackCleanup(this, () => e.off(n, t));
   });
 };
-l.fn.atomUnbind = function() {
+u.fn.atomUnbind = function() {
   return this.each(function() {
-    b.cleanupTree(this);
+    p.cleanupTree(this);
   });
 };
-const Be = /* @__PURE__ */ Object.create(null);
-function Dt(n) {
-  let e = Be[n];
-  return e || (e = n.includes("-") ? n.replace(/-./g, (t) => t[1].toUpperCase()) : n, Be[n] = e, e);
+const Ft = /* @__PURE__ */ Object.create(null);
+function be(n) {
+  let t = Ft[n];
+  return t || (t = n.includes("-") ? n.replace(/-./g, (e) => e[1].toUpperCase()) : n, Ft[n] = t, t);
 }
-function Tt(n, e) {
-  const t = n.el;
-  D(
-    t,
+function ye(n, t) {
+  const e = n.el;
+  b(
     e,
+    t,
     (s) => {
       const i = typeof s == "string" ? s : String(s ?? "");
-      t.textContent !== i && (t.textContent = i);
+      e.textContent !== i && (e.textContent = i);
     },
     "text"
   );
 }
-function Nt(n, e) {
-  const t = n.el;
-  D(
-    t,
+function Ce(n, t) {
+  const e = n.el;
+  b(
     e,
+    t,
     (s) => {
       const i = String(s ?? "");
-      t.innerHTML !== i && (t.innerHTML = i);
+      e.innerHTML !== i && (e.innerHTML = i);
     },
     "html"
   );
 }
-function Ot(n, e) {
-  for (const t in e)
-    D(
+function Ie(n, t) {
+  for (const e in t)
+    b(
       n.el,
-      e[t],
+      t[e],
       (s) => {
-        n.el.classList.toggle(t, !!s);
+        n.el.classList.toggle(e, !!s);
       },
-      `class.${t}`
+      `class.${e}`
     );
 }
-function At(n, e) {
-  const t = n.el, s = t.style;
-  for (const i in e) {
-    const o = e[i];
+function De(n, t) {
+  const e = n.el, s = e.style;
+  for (const i in t) {
+    const o = t[i];
     if (o === void 0) continue;
-    const r = Dt(i);
-    Array.isArray(o) ? D(
-      t,
+    const r = be(i);
+    Array.isArray(o) ? b(
+      e,
       o[0],
       (c) => {
         s[r] = `${c}${o[1]}`;
       },
       `css.${i}`
-    ) : D(
-      t,
+    ) : b(
+      e,
       o,
       (c) => {
         s[r] = c;
@@ -1581,316 +1357,316 @@ function At(n, e) {
     );
   }
 }
-function Rt(n, e) {
-  const t = n.el;
-  for (const s in e)
-    D(
-      t,
-      e[s],
+function Te(n, t) {
+  const e = n.el;
+  for (const s in t)
+    b(
+      e,
+      t[s],
       (i) => {
         if (i == null || i === !1) {
-          t.removeAttribute(s);
+          e.removeAttribute(s);
           return;
         }
         const o = i === !0 ? s : String(i);
-        t.getAttribute(s) !== o && t.setAttribute(s, o);
+        e.getAttribute(s) !== o && e.setAttribute(s, o);
       },
       `attr.${s}`
     );
 }
-function vt(n, e) {
-  const t = n.el;
-  for (const s in e)
-    D(
+function Ne(n, t) {
+  const e = n.el;
+  for (const s in t)
+    b(
       n.el,
-      e[s],
+      t[s],
       (i) => {
-        t[s] !== i && (t[s] = i);
+        e[s] !== i && (e[s] = i);
       },
       `prop.${s}`
     );
 }
-function xt(n, e) {
-  const t = n.el;
-  D(
-    t,
+function Oe(n, t) {
+  const e = n.el;
+  b(
     e,
+    t,
     (s) => {
-      t.style.display = s ? "" : "none", g.enabled && g.domUpdated(t, "show", s);
+      e.style.display = s ? "" : "none", _.enabled && _.domUpdated(e, "show", s);
     },
     "show"
   );
 }
-function Ut(n, e) {
-  const t = n.el;
-  D(
-    t,
+function ke(n, t) {
+  const e = n.el;
+  b(
     e,
+    t,
     (s) => {
-      t.style.display = s ? "none" : "", g.enabled && g.domUpdated(t, "hide", s);
+      e.style.display = s ? "none" : "", _.enabled && _.domUpdated(e, "hide", s);
     },
     "hide"
   );
 }
-function wt(n, e) {
-  const t = Array.isArray(e), { effect: s, cleanup: i } = We(
+function Ae(n, t) {
+  const e = Array.isArray(t), { effect: s, cleanup: i } = Yt(
     n.$el,
-    t ? e[0] : e,
-    t ? e[1] : {}
+    e ? t[0] : t,
+    e ? t[1] : {}
   );
-  b.trackEffect(n.el, ee(s)), n.trackCleanup(i);
+  p.trackEffect(n.el, Y(s)), n.trackCleanup(i);
 }
-function kt(n, e) {
-  const t = n.el, s = Re(), i = () => {
-    if (s.flags & y.Busy) return;
-    const r = t.checked;
-    e.value !== r && (e.value = r);
+function ve(n, t) {
+  const e = n.el, s = Dt(), i = () => {
+    if (s.flags & g.Busy) return;
+    const r = e.checked;
+    t.value !== r && (t.value = r);
   };
-  t.addEventListener("change", i), n.trackCleanup(() => t.removeEventListener("change", i));
-  const o = ee(() => {
-    s.flags |= y.SyncingToDom;
-    const r = !!e.value;
-    t.checked !== r && (t.checked = r, g.enabled && g.domUpdated(t, "checked", r)), s.flags &= ~y.SyncingToDom;
+  e.addEventListener("change", i), n.trackCleanup(() => e.removeEventListener("change", i));
+  const o = Y(() => {
+    s.flags |= g.SyncingToDom;
+    const r = !!t.value;
+    e.checked !== r && (e.checked = r, _.enabled && _.domUpdated(e, "checked", r)), s.flags &= ~g.SyncingToDom;
   });
-  b.trackEffect(t, o);
+  p.trackEffect(e, o);
 }
-function Lt(n, e) {
-  for (const t in e) {
-    const s = e[t];
+function Ue(n, t) {
+  for (const e in t) {
+    const s = t[e];
     if (typeof s != "function") continue;
     const i = (o) => {
-      Ae(
+      It(
         () => s.call(
           n.el,
-          l.Event(o.type, { originalEvent: o })
+          u.Event(o.type, { originalEvent: o })
         )
       );
     };
-    n.el.addEventListener(t, i), n.trackCleanup(() => n.el.removeEventListener(t, i));
+    n.el.addEventListener(e, i), n.trackCleanup(() => n.el.removeEventListener(e, i));
   }
 }
-l.fn.atomBind = function(n) {
+u.fn.atomBind = function(n) {
   return this.each(function() {
-    const e = this;
-    let t = null;
+    const t = this;
+    let e = null;
     const s = {
       get $el() {
-        return t || (t = l(e)), t;
+        return e || (e = u(t)), e;
       },
-      el: e,
-      trackCleanup: (i) => b.trackCleanup(e, i)
+      el: t,
+      trackCleanup: (i) => p.trackCleanup(t, i)
     };
-    n.text !== void 0 && Tt(s, n.text), n.html !== void 0 && Nt(s, n.html), n.class && Ot(s, n.class), n.css && At(s, n.css), n.attr && Rt(s, n.attr), n.prop && vt(s, n.prop), n.show !== void 0 && xt(s, n.show), n.hide !== void 0 && Ut(s, n.hide), n.val !== void 0 && wt(s, n.val), n.checked !== void 0 && kt(s, n.checked), n.on && Lt(s, n.on);
+    n.text !== void 0 && ye(s, n.text), n.html !== void 0 && Ce(s, n.html), n.class && Ie(s, n.class), n.css && De(s, n.css), n.attr && Te(s, n.attr), n.prop && Ne(s, n.prop), n.show !== void 0 && Oe(s, n.show), n.hide !== void 0 && ke(s, n.hide), n.val !== void 0 && Ae(s, n.val), n.checked !== void 0 && ve(s, n.checked), n.on && Ue(s, n.on);
   });
 };
-l.fn.atomList = function(n, e) {
-  const { key: t, render: s, bind: i, update: o, onAdd: r, onRemove: c, empty: u } = e, h = typeof t == "function" ? t : (p, a) => p[t];
+u.fn.atomList = function(n, t) {
+  const { key: e, render: s, bind: i, update: o, onAdd: r, onRemove: c, empty: l } = t, a = typeof e == "function" ? e : (d, N) => d[e];
   return this.each(function() {
-    const p = l(this), a = Ee(this), _ = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Set();
-    let S = [], T = null;
-    const I = ee(() => {
-      const A = n.value, x = A.length;
-      if (x === 0 ? u && !T && (T = l(u).appendTo(p)) : T && (T.remove(), T = null), x === 0 && _.size === 0) {
-        S = [];
+    const d = u(this), N = ft(this), C = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Set();
+    let H = [], V = null;
+    const I = Y(() => {
+      const D = n.value, O = D.length;
+      if (O === 0 ? l && !V && (V = u(l).appendTo(d)) : V && (V.remove(), V = null), O === 0 && C.size === 0) {
+        H = [];
         return;
       }
-      g.log("list", `${a} updating with ${x} items`);
-      const re = /* @__PURE__ */ new Map(), ge = S.length;
-      for (let E = 0; E < ge; E++)
-        re.set(S[E], E);
-      const V = new Array(x), me = /* @__PURE__ */ new Set(), ve = new Int32Array(x);
-      for (let E = 0; E < x; E++) {
-        const M = A[E], m = h(M, E);
-        g.enabled && me.has(m) && console.warn(`[atomList] Duplicate key "${m}" at index ${E}.`), V[E] = m, me.add(m), ve[E] = re.get(m) ?? -1;
+      _.log("list", `${N} updating with ${O} items`);
+      const nt = /* @__PURE__ */ new Map(), _t = H.length;
+      for (let f = 0; f < _t; f++)
+        nt.set(H[f], f);
+      const P = new Array(O), dt = /* @__PURE__ */ new Set(), Tt = new Int32Array(O);
+      for (let f = 0; f < O; f++) {
+        const x = D[f], E = a(x, f);
+        _.enabled && dt.has(E) && console.warn(`[atomList] Duplicate key "${E}" at index ${f}.`), P[f] = E, dt.add(E), Tt[f] = nt.get(E) ?? -1;
       }
-      if (_.size > 0)
-        for (const [E, M] of _) {
-          if (me.has(E) || d.has(E)) continue;
-          const m = () => {
-            M.$el.remove(), M.$el[0] && b.cleanup(M.$el[0]), d.delete(E), g.log("list", `${a} removed item:`, E);
+      if (C.size > 0)
+        for (const [f, x] of C) {
+          if (dt.has(f) || v.has(f)) continue;
+          const E = () => {
+            x.$el.remove(), x.$el[0] && p.cleanup(x.$el[0]), v.delete(f), _.log("list", `${N} removed item:`, f);
           };
-          if (_.delete(E), d.add(E), c) {
-            const N = c(M.$el);
-            N instanceof Promise ? N.then(m) : m();
+          if (C.delete(f), v.add(f), c) {
+            const y = c(x.$el);
+            y instanceof Promise ? y.then(E) : E();
           } else
-            m();
+            E();
         }
-      if (x === 0) {
-        S = [];
+      if (O === 0) {
+        H = [];
         return;
       }
-      const xe = gt(ve);
-      let be = xe.length - 1, P = null;
-      for (let E = x - 1; E >= 0; E--) {
-        const M = V[E], m = A[E], N = _.get(M);
-        if (N) {
-          const te = N.item;
-          N.item = m;
-          const k = N.$el[0];
-          if (!k) continue;
+      const Nt = _e(Tt);
+      let Et = Nt.length - 1, w = null;
+      for (let f = O - 1; f >= 0; f--) {
+        const x = P[f], E = D[f], y = C.get(x);
+        if (y) {
+          const J = y.item;
+          y.item = E;
+          const U = y.$el[0];
+          if (!U) continue;
           if (o)
-            o(N.$el, m, E), g.domUpdated(N.$el, "list.update", m);
-          else if (te !== m) {
-            let H = !0;
-            if (typeof te == "object" && te !== null && typeof m == "object" && m !== null) {
-              H = !1;
-              let B = 0;
-              const ce = te, Ue = m;
-              for (const ne in ce) {
-                if (ce[ne] !== Ue[ne]) {
-                  H = !0;
+            o(y.$el, E, f), _.domUpdated(y.$el, "list.update", E);
+          else if (J !== E) {
+            let M = !0;
+            if (typeof J == "object" && J !== null && typeof E == "object" && E !== null) {
+              M = !1;
+              let L = 0;
+              const st = J, Ot = E;
+              for (const W in st) {
+                if (st[W] !== Ot[W]) {
+                  M = !0;
                   break;
                 }
-                B++;
+                L++;
               }
-              if (!H) {
-                let ne = 0;
-                for (const Ft in Ue)
-                  if (ne++, ne > B) {
-                    H = !0;
+              if (!M) {
+                let W = 0;
+                for (const Re in Ot)
+                  if (W++, W > L) {
+                    M = !0;
                     break;
                   }
-                B !== ne && (H = !0);
+                L !== W && (M = !0);
               }
             }
-            if (H) {
-              const B = l(s(m, E)), ce = P === k;
-              N.$el.replaceWith(B), N.$el = B, i && i(B, m, E), g.domUpdated(B, "list.render", m), ce && (P = B[0] || null);
+            if (M) {
+              const L = u(s(E, f)), st = w === U;
+              y.$el.replaceWith(L), y.$el = L, i && i(L, E, f), _.domUpdated(L, "list.render", E), st && (w = L[0] || null);
             }
           }
-          if (be >= 0 && xe[be] === E)
-            be--;
+          if (Et >= 0 && Nt[Et] === f)
+            Et--;
           else {
-            const H = N.$el[0];
-            P?.isConnected ? P !== H && N.$el.insertBefore(P) : N.$el.appendTo(p);
+            const M = y.$el[0];
+            w?.isConnected ? w !== M && y.$el.insertBefore(w) : y.$el.appendTo(d);
           }
-          P = N.$el[0] || null;
+          w = y.$el[0] || null;
         } else {
-          const te = s(m, E), k = l(te);
-          _.set(M, { $el: k, item: m }), P?.isConnected ? k.insertBefore(P) : k.appendTo(p), i && i(k, m, E), r && r(k), g.domUpdated(k, "list.add", m), P = k[0] || null;
+          const J = s(E, f), U = u(J);
+          C.set(x, { $el: U, item: E }), w?.isConnected ? U.insertBefore(w) : U.appendTo(d), i && i(U, E, f), r && r(U), _.domUpdated(U, "list.add", E), w = U[0] || null;
         }
       }
-      S = V;
+      H = P;
     });
-    b.trackEffect(this, I), b.trackCleanup(this, () => {
-      _.clear(), d.clear(), S = [], T?.remove();
+    p.trackEffect(this, I), p.trackCleanup(this, () => {
+      C.clear(), v.clear(), H = [], V?.remove();
     });
   });
 };
-const ae = /* @__PURE__ */ new WeakMap();
-l.fn.atomMount = function(n, e = {}) {
+const ct = /* @__PURE__ */ new WeakMap();
+u.fn.atomMount = function(n, t = {}) {
   return this.each(function() {
-    const t = g.enabled, s = t ? Ee(this) : "", i = ae.get(this);
-    i && (t && g.log("mount", `${s} unmounting existing component`), i()), t && g.log("mount", `${s} mounting component`);
+    const e = _.enabled, s = e ? ft(this) : "", i = ct.get(this);
+    i && (e && _.log("mount", `${s} unmounting existing component`), i()), e && _.log("mount", `${s} mounting component`);
     let o;
     try {
-      o = n(l(this), e);
+      o = n(u(this), t);
     } catch (c) {
       console.error("[atom-effect-jquery] Mount error:", c);
       return;
     }
     const r = () => {
-      if (ae.delete(this)) {
-        if (t && g.log("mount", `${s} full cleanup`), typeof o == "function")
+      if (ct.delete(this)) {
+        if (e && _.log("mount", `${s} full cleanup`), typeof o == "function")
           try {
             o();
           } catch (c) {
             console.error("[atom-effect-jquery] Cleanup error:", c);
           }
-        b.cleanupTree(this);
+        p.cleanupTree(this);
       }
     };
-    ae.set(this, r), b.trackCleanup(this, r);
+    ct.set(this, r), p.trackCleanup(this, r);
   });
 };
-l.fn.atomUnmount = function() {
+u.fn.atomUnmount = function() {
   return this.each(function() {
-    const n = ae.get(this);
+    const n = ct.get(this);
     n && n();
   });
 };
-const de = /* @__PURE__ */ new WeakMap();
-let $e = !1;
-const je = (n) => {
-  let e = de.get(n);
-  return e || (e = function(...t) {
-    return Ae(() => n.apply(this, t));
-  }, de.set(n, e)), e;
+const lt = /* @__PURE__ */ new WeakMap();
+let Pt = !1;
+const Mt = (n) => {
+  let t = lt.get(n);
+  return t || (t = function(...e) {
+    return It(() => n.apply(this, e));
+  }, lt.set(n, t)), t;
 };
-function Ke() {
-  if ($e) return;
-  $e = !0;
-  const n = l.fn.on, e = l.fn.off, t = l.fn.remove, s = l.fn.empty, i = l.fn.detach;
-  l.fn.remove = function(o) {
+function Jt() {
+  if (Pt) return;
+  Pt = !0;
+  const n = u.fn.on, t = u.fn.off, e = u.fn.remove, s = u.fn.empty, i = u.fn.detach;
+  u.fn.remove = function(o) {
     const r = o ? this.filter(o) : this;
-    for (let c = 0, u = r.length; c < u; c++) {
-      const h = r[c];
-      h && (b.cleanupTree(h), b.markIgnored(h));
+    for (let c = 0, l = r.length; c < l; c++) {
+      const a = r[c];
+      a && (p.cleanupTree(a), p.markIgnored(a));
     }
-    return t.call(this, o);
-  }, l.fn.empty = function() {
+    return e.call(this, o);
+  }, u.fn.empty = function() {
     for (let o = 0, r = this.length; o < r; o++) {
       const c = this[o];
-      c && b.cleanupDescendants(c);
+      c && p.cleanupDescendants(c);
     }
     return s.call(this);
-  }, l.fn.detach = function(o) {
+  }, u.fn.detach = function(o) {
     const r = o ? this.filter(o) : this;
-    for (let c = 0, u = r.length; c < u; c++) {
-      const h = r[c];
-      h && b.keep(h);
+    for (let c = 0, l = r.length; c < l; c++) {
+      const a = r[c];
+      a && p.keep(a);
     }
     return i.call(this, o);
-  }, l.fn.on = function(...o) {
+  }, u.fn.on = function(...o) {
     const r = o[0];
     if (r && typeof r == "object") {
-      const c = r, u = {};
-      for (const h in c) {
-        const p = c[h];
-        p && (u[h] = je(p));
+      const c = r, l = {};
+      for (const a in c) {
+        const d = c[a];
+        d && (l[a] = Mt(d));
       }
-      o[0] = u;
+      o[0] = l;
     } else
       for (let c = o.length - 1; c >= 0; c--)
         if (typeof o[c] == "function") {
-          o[c] = je(o[c]);
+          o[c] = Mt(o[c]);
           break;
         }
     return n.apply(this, o);
-  }, l.fn.off = function(...o) {
+  }, u.fn.off = function(...o) {
     const r = o[0];
     if (r && typeof r == "object") {
-      const c = r, u = {};
-      for (const h in c) {
-        const p = c[h];
-        p && (u[h] = de.get(p) || p);
+      const c = r, l = {};
+      for (const a in c) {
+        const d = c[a];
+        d && (l[a] = lt.get(d) || d);
       }
-      o[0] = u;
+      o[0] = l;
     } else
       for (let c = o.length - 1; c >= 0; c--)
         if (typeof o[c] == "function") {
-          o[c] = de.get(o[c]) || o[c];
+          o[c] = lt.get(o[c]) || o[c];
           break;
         }
-    return e.apply(this, o);
+    return t.apply(this, o);
   };
 }
-const Bt = Ke;
-Ke();
-l(() => {
-  Ct(document.body);
+const Le = Jt;
+Jt();
+u(() => {
+  Se(document.body);
 });
 export {
-  dt as atom,
-  Ae as batch,
-  _t as computed,
-  Vt as default,
-  Mt as disableAutoCleanup,
-  ee as effect,
-  Ct as enableAutoCleanup,
-  Bt as enablejQueryBatching,
-  Ke as enablejQueryOverrides,
-  b as registry,
-  Xe as untracked
+  ue as atom,
+  It as batch,
+  he as computed,
+  Me as default,
+  xe as disableAutoCleanup,
+  Y as effect,
+  Se as enableAutoCleanup,
+  Le as enablejQueryBatching,
+  Jt as enablejQueryOverrides,
+  p as registry,
+  zt as untracked
 };
 //# sourceMappingURL=index.mjs.map