@but212/atom-effect-jquery 0.18.0 → 0.19.1

package/dist/index.mjs

@@ -1,19 +1,21 @@
 import l from "jquery";
-import { default as Mt } from "jquery";
-const Je = {
+import { default as Qt } from "jquery";
+const et = {
   ONE_SECOND_MS: 1e3
-}, _e = {
+}, me = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, De = {
+}, Oe = {
   DISPOSED: 1
 }, P = {
-  ...De,
+  ...Oe,
   EXECUTING: 8
 }, d = {
-  ...De,
+  ...Oe,
+  /** Marker bit: identifies this node as a computed. */
+  IS_COMPUTED: 2,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -21,8 +23,8 @@ const Je = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, H = {
-  ...De,
+}, j = {
+  ...Oe,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
 }, q = {
@@ -34,75 +36,73 @@ const Je = {
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, Ne = {
-  MAX_DEPENDENCIES: 1e3,
+}, tt = {
   WARN_INFINITE_LOOP: !0
-}, W = 1073741823, T = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, Ze = Object.freeze([]);
-class te extends Error {
+}, oe = 1073741823, L = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, nt = Object.freeze([]);
+class ee extends Error {
   constructor(e, t = null, s = !0) {
     super(e), this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date(), this.name = "AtomError";
   }
 }
-class z extends te {
+class z extends ee {
   constructor(e, t = null) {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class Q extends te {
+class Y extends ee {
   constructor(e, t = null) {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class ue extends te {
+class le extends ee {
   constructor(e, t = null) {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-const Ae = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), et = /* @__PURE__ */ Symbol("AtomEffect.Id"), we = /* @__PURE__ */ Symbol("AtomEffect.Type"), ge = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), tt = (n) => "dependencies" in n && Array.isArray(n.dependencies);
-function Be(n, e, t) {
+const Ae = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), st = /* @__PURE__ */ Symbol("AtomEffect.Id"), Le = /* @__PURE__ */ Symbol("AtomEffect.Type"), Ce = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), it = (n) => "dependencies" in n && Array.isArray(n.dependencies);
+function Ve(n, e, t) {
   if (n === e)
     throw new z(
       "Circular dependency detected: The computation refers to itself explicitly or implicitly."
     );
-  if (!t.has(n.id) && (t.add(n.id), tt(n))) {
+  if (!t.has(n.id) && (t.add(n.id), it(n))) {
     const s = n.dependencies;
     for (let i = 0; i < s.length; i++) {
-      const o = s[i];
-      o && Be(o, e, t);
+      const r = s[i];
+      r && Ve(r, e, t);
     }
   }
 }
-const Y = {
+const W = {
   // Dev mode flag
-  enabled: T,
-  maxDependencies: Ne.MAX_DEPENDENCIES,
-  warnInfiniteLoop: Ne.WARN_INFINITE_LOOP,
+  enabled: L,
+  warnInfiniteLoop: tt.WARN_INFINITE_LOOP,
   warn(n, e) {
-    T && this.enabled && n && console.warn(`[Atom Effect] ${e}`);
+    L && this.enabled && n && console.warn(`[Atom Effect] ${e}`);
   },
   checkCircular(n, e) {
     if (n === e)
       throw new z("Direct circular dependency detected");
-    T && this.enabled && Be(n, e, /* @__PURE__ */ new Set());
+    L && this.enabled && Ve(n, e, /* @__PURE__ */ new Set());
   },
   attachDebugInfo(n, e, t) {
-    if (!T || !this.enabled) return;
+    if (!L || !this.enabled) return;
     const s = n;
-    s[Ae] = `${e}_${t}`, s[et] = t, s[we] = e;
+    s[Ae] = `${e}_${t}`, s[st] = t, s[Le] = e;
   },
   getDebugName: (n) => n?.[Ae],
-  getDebugType: (n) => n?.[we]
+  getDebugType: (n) => n?.[Le]
 };
-let nt = 1;
-const st = () => nt++;
-function je(n, e, t) {
+let rt = 1;
+const ot = () => rt++;
+function He(n, e, t) {
   if (typeof e == "function") {
     const i = e;
-    for (let o = 0, r = t.length; o < r; o++) {
-      const c = t[o];
+    for (let r = 0, o = t.length; r < o; r++) {
+      const c = t[r];
       if (c && c.fn === i) return;
     }
-    t.push(new Ie(i, void 0));
+    t.push(new Se(i, void 0));
     return;
   }
   if ("addDependency" in e) {
@@ -110,42 +110,38 @@ function je(n, e, t) {
     return;
   }
   const s = e;
-  for (let i = 0, o = t.length; i < o; i++) {
-    const r = t[i];
-    if (r && r.sub === s) return;
+  for (let i = 0, r = t.length; i < r; i++) {
+    const o = t[i];
+    if (o && o.sub === s) return;
   }
-  t.push(new Ie(void 0, s));
+  t.push(new Se(void 0, s));
 }
-function it(n, e, t) {
-  for (let s = 0, i = e.length; s < i; s++) {
-    const o = e[s];
-    o && (o.node._tempUnsub = o.unsub);
+function ct(n, e, t) {
+  const s = /* @__PURE__ */ new Map();
+  for (let i = 0, r = e.length; i < r; i++) {
+    const o = e[i];
+    o?.unsub && (s.set(o.node, o.unsub), o.unsub = void 0);
   }
-  for (let s = 0, i = n.length; s < i; s++) {
-    const o = n[s];
+  for (let i = 0, r = n.length; i < r; i++) {
+    const o = n[i];
     if (!o) continue;
-    const r = o.node;
-    r._tempUnsub !== void 0 ? (o.unsub = r._tempUnsub, r._tempUnsub = void 0) : (Y.checkCircular(r, t), o.unsub = r.subscribe(t));
-  }
-  for (let s = 0, i = e.length; s < i; s++) {
-    const o = e[s];
-    if (o) {
-      const r = o.node;
-      r._tempUnsub !== void 0 && (r._tempUnsub(), r._tempUnsub = void 0), o.unsub = void 0;
-    }
+    const c = o.node, a = s.get(c);
+    a !== void 0 ? (o.unsub = a, s.delete(c)) : (W.checkCircular(c, t), o.unsub = c.subscribe(t));
   }
+  for (const i of s.values())
+    i();
 }
-class be {
+class de {
   constructor(e, t, s = void 0) {
     this.node = e, this.version = t, this.unsub = s;
   }
 }
-class Ie {
+class Se {
   constructor(e, t) {
     this.fn = e, this.sub = t;
   }
 }
-const v = {
+const T = {
   // Computed Errors
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
@@ -161,42 +157,47 @@ const v = {
   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"
+  // Scheduler Errors
+  SCHEDULER_FLUSH_OVERFLOW: (n, e) => `Maximum flush iterations (${n}) exceeded. ${e} jobs dropped. Possible infinite loop.`,
+  // System / Debug
+  CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
+  // Effect frequency
+  EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop."
 };
-function ee(n, e, t) {
-  if (n instanceof te)
+function Z(n, e, t) {
+  if (n instanceof ee)
     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} (${t}): ${i}`;
-  return new e(c, o);
+  const s = n instanceof Error, i = s ? n.message : String(n), r = s ? n : void 0;
+  let o = "Unexpected error";
+  n instanceof TypeError ? o = "Type error" : n instanceof ReferenceError && (o = "Reference error");
+  const c = `${o} (${t}): ${i}`;
+  return new e(c, r);
 }
-class Ve {
+class je {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = st() & W, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = ot() & oe;
   }
 }
-class He extends Ve {
+class ze extends je {
   /**
    * Adds subscriber.
    */
   subscribe(e) {
     const t = typeof e == "function";
     if (!t && (!e || typeof e.execute != "function"))
-      throw ee(
+      throw Z(
         new TypeError("Invalid subscriber"),
-        te,
-        v.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        ee,
+        T.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
     const s = this._subscribers;
-    for (let o = 0, r = s.length; o < r; o++) {
-      const c = s[o];
+    for (let r = 0, o = s.length; r < o; r++) {
+      const c = s[r];
       if (c && (t ? c.fn === e : c.sub === e))
-        return T && console.warn("Duplicate subscription ignored."), () => {
+        return L && console.warn("Duplicate subscription ignored."), () => {
         };
     }
-    const i = new Ie(
+    const i = new Se(
       t ? e : void 0,
       t ? void 0 : e
     );
@@ -213,152 +214,146 @@ class He extends Ve {
   }
   _notifySubscribers(e, t) {
     if (this._subscribers.length === 0) return;
-    const s = [...this._subscribers], i = s.length;
-    for (let o = 0; o < i; o++) {
-      const r = s[o];
-      if (r)
+    const s = this._subscribers.slice(0), i = s.length;
+    for (let r = 0; r < i; r++) {
+      const o = s[r];
+      if (o)
         try {
-          r.fn ? r.fn(e, t) : r.sub && r.sub.execute();
+          o.fn ? o.fn(e, t) : o.sub && o.sub.execute();
         } catch (c) {
           this._handleNotifyError(c);
         }
     }
   }
   _handleNotifyError(e) {
-    console.error(ee(e, te, v.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(Z(e, ee, T.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let ae = 0;
-const ze = () => (ae = ae + 1 & W || 1, ae), ot = () => ae;
-let Ce = 0, Te = 0, fe = !1;
-function Re() {
-  return fe ? (T && console.warn("startFlush() called during flush - ignored"), !1) : (fe = !0, Ce = Ce + 1 & W || 1, Te = 0, !0);
+let _e = 0;
+const qe = () => (_e = _e + 1 & oe || 1, _e), at = () => _e, De = (n) => n + 1 & oe;
+let Te = 0, we = 0, Ee = !1;
+function xe() {
+  return Ee ? (L && console.warn("startFlush() called during flush - ignored"), !1) : (Ee = !0, Te = Te + 1 & oe || 1, we = 0, !0);
 }
-const xe = () => {
-  fe = !1;
-}, rt = () => fe ? ++Te : 0, F = {
-  /** 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: q.MAX_FLUSH_ITERATIONS,
+const Ue = () => {
+  Ee = !1;
+}, ut = () => Ee ? ++we : 0;
+class lt {
+  constructor() {
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = q.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
+  }
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
-  },
+  }
   get queueSize() {
     return this._size;
-  },
+  }
   get isBatching() {
     return this._isBatching;
-  },
+  }
   /**
    * Schedules job.
    */
-  schedule(n) {
-    if (T && typeof n != "function")
-      throw new ue("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;
+  schedule(e) {
+    if (L && typeof e != "function")
+      throw new le("Scheduler callback must be a function");
+    if (e._nextEpoch !== this._epoch) {
+      if (e._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
+        this._batchQueue[this._batchQueueSize++] = e;
         return;
       }
-      this._queueBuffer[this._bufferIndex][this._size++] = n, this._isProcessing || this._flush();
+      this._queueBuffer[this._bufferIndex][this._size++] = e, this._isProcessing || this._flush();
     }
-  },
+  }
   /**
    * Triggers flush.
    */
   _flush() {
-    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._runLoop));
-  },
+    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
+  }
   /**
    * Scheduler loop.
    */
-  _runLoop: () => {
+  _runLoop() {
     try {
-      if (F._size === 0) return;
-      const n = Re();
-      F._drainQueue(), n && xe();
+      if (this._size === 0) return;
+      const e = xe();
+      this._drainQueue(), e && Ue();
     } finally {
-      F._isProcessing = !1, F._size > 0 && !F._isBatching && F._flush();
+      this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
-  },
+  }
   _flushSync() {
     this._isFlushingSync = !0;
-    const n = Re();
+    const e = xe();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, n && xe();
+      this._isFlushingSync = !1, e && Ue();
     }
-  },
+  }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const n = ++this._epoch, e = this._batchQueue, t = this._queueBuffer[this._bufferIndex];
-    let s = this._size;
-    for (let i = 0; i < this._batchQueueSize; i++) {
-      const o = e[i];
-      o._nextEpoch !== n && (o._nextEpoch = n, t[s++] = o);
+    const e = ++this._epoch, t = this._batchQueue, s = this._queueBuffer[this._bufferIndex];
+    let i = this._size;
+    for (let r = 0; r < this._batchQueueSize; r++) {
+      const o = t[r];
+      o._nextEpoch !== e && (o._nextEpoch = e, s[i++] = o);
     }
-    this._size = s, this._batchQueueSize = 0, e.length > q.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
-  },
+    this._size = i, this._batchQueueSize = 0, t.length > q.BATCH_QUEUE_SHRINK_THRESHOLD && (t.length = 0);
+  }
   _drainQueue() {
-    let n = 0;
+    let e = 0;
     for (; this._size > 0; ) {
-      if (++n > this._maxFlushIterations) {
+      if (++e > this._maxFlushIterations) {
         this._handleFlushOverflow();
         return;
       }
       this._processQueue(), this._mergeBatchQueue();
     }
-  },
+  }
   _processQueue() {
-    const n = this._bufferIndex, e = this._queueBuffer[n], t = this._size;
-    this._bufferIndex = n ^ 1, this._size = 0, this._epoch++;
-    for (let s = 0; s < t; s++)
+    const e = this._bufferIndex, t = this._queueBuffer[e], s = this._size;
+    this._bufferIndex = e ^ 1, this._size = 0, this._epoch++;
+    for (let i = 0; i < s; i++)
       try {
-        e[s]();
-      } catch (i) {
-        console.error(new ue("Error occurred during scheduler execution", i));
+        t[i]();
+      } catch (r) {
+        console.error(new le("Error occurred during scheduler execution", r));
       }
-    e.length = 0;
-  },
+    t.length = 0;
+  }
   _handleFlushOverflow() {
-    console.error(
-      new ue(
-        `Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`
+    const e = this._size + this._batchQueueSize;
+    if (console.error(
+      new le(
+        T.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, e)
       )
-    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0;
-  },
+    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
+      try {
+        this.onOverflow(e);
+      } catch {
+      }
+  }
   startBatch() {
     this._batchDepth++, this._isBatching = !0;
-  },
+  }
   endBatch() {
     if (this._batchDepth === 0) {
-      T && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      L && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
     --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
-  },
-  setMaxFlushIterations(n) {
-    if (n < q.MIN_FLUSH_ITERATIONS)
-      throw new ue(
+  }
+  setMaxFlushIterations(e) {
+    if (e < q.MIN_FLUSH_ITERATIONS)
+      throw new le(
         `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
       );
-    this._maxFlushIterations = n;
+    this._maxFlushIterations = e;
   }
-}, M = {
+}
+const re = new lt(), M = {
   /** Active listener. */
   current: null,
   /**
@@ -378,7 +373,7 @@ const xe = () => {
     }
   }
 };
-function ct(n) {
+function ht(n) {
   const e = M.current;
   if (e === null) return n();
   M.current = null;
@@ -388,25 +383,25 @@ function ct(n) {
     M.current = e;
   }
 }
-class ut extends He {
+class ft extends ze {
   constructor(e, t) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this._value = e, t && (this.flags |= H.SYNC), Y.attachDebugInfo(this, "atom", this.id);
+    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this._value = e, t && (this.flags |= j.SYNC), W.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
     const e = M.current;
-    return e && je(this, e, this._subscribers), this._value;
+    return e && He(this, e, this._subscribers), this._value;
   }
   set value(e) {
     const t = this._value;
     if (Object.is(t, e)) return;
-    this._value = e, this.version = this.version + 1 & W;
+    this._value = e, this.version = De(this.version);
     const s = this.flags;
-    if (!(this._subscribers.length === 0 || s & H.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = t, this.flags = s | H.NOTIFICATION_SCHEDULED, s & H.SYNC && !F.isBatching) {
+    if (!(this._subscribers.length === 0 || s & j.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = t, this.flags = s | j.NOTIFICATION_SCHEDULED, s & j.SYNC && !re.isBatching) {
         this._flushNotifications();
         return;
       }
-      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), F.schedule(this._notifyTask);
+      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), re.schedule(this._notifyTask);
     }
   }
   /**
@@ -414,7 +409,7 @@ class ut extends He {
    */
   _flushNotifications() {
     const e = this.flags;
-    if (!(e & H.NOTIFICATION_SCHEDULED) || e & H.DISPOSED)
+    if (!(e & j.NOTIFICATION_SCHEDULED) || e & j.DISPOSED)
       return;
     const t = this._pendingOldValue;
     this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, t);
@@ -423,19 +418,20 @@ class ut extends He {
     return this._value;
   }
   dispose() {
-    this.flags & H.DISPOSED || (this._subscribers.length = 0, this.flags |= H.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & j.DISPOSED || (this._subscribers.length = 0, this.flags |= j.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function qe(n, e = {}) {
-  return new ut(n, e.sync ?? !1);
+function Xe(n, e = {}) {
+  return new ft(n, e.sync ?? !1);
 }
-class lt {
+class dt {
   /**
    * @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).
+   * @param enableStats - Force-enable stats even in production (default: false).
    */
-  constructor(e = 50, t = 256) {
-    this.limit = e, this.capacity = t, this.pool = [], this.stats = T ? {
+  constructor(e = 50, t = 256, s = !1) {
+    this.limit = e, this.capacity = t, this.pool = [], this.stats = null, this.stats = L || s ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -445,7 +441,7 @@ class lt {
    * Acquires array.
    */
   acquire() {
-    return T && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases array.
@@ -456,25 +452,25 @@ class lt {
   release(e, t) {
     if (!(t && e === t)) {
       if (e.length > this.capacity) {
-        T && this.stats && this.stats.rejected.tooLarge++;
+        this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.limit) {
-        T && this.stats && this.stats.rejected.poolFull++;
+        this.stats && this.stats.rejected.poolFull++;
         return;
       }
       if (Object.isFrozen(e)) {
-        T && this.stats && this.stats.rejected.frozen++;
+        this.stats && this.stats.rejected.frozen++;
         return;
       }
-      e.length = 0, this.pool.push(e), T && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), this.stats && this.stats.released++;
     }
   }
   /**
    * Pool stats.
    */
   getStats() {
-    if (!T || !this.stats) return null;
+    if (!this.stats) return null;
     const { acquired: e, released: t, rejected: s } = this.stats, i = e - t - (s.frozen + s.tooLarge + s.poolFull);
     return {
       acquired: e,
@@ -488,37 +484,39 @@ class lt {
    * Resets pool.
    */
   reset() {
-    this.pool.length = 0, T && this.stats && (this.stats = {
+    this.pool.length = 0, this.stats && (this.stats = {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
     });
   }
 }
-const oe = (n) => Object.freeze(n);
-oe([]);
-oe([]);
-oe([]);
-oe([]);
-const L = oe([]), X = new lt();
-function Se(n) {
+const ce = (n) => Object.freeze(n);
+ce([]);
+ce([]);
+ce([]);
+ce([]);
+const F = ce([]), X = new dt();
+function ve(n) {
   return n !== null && typeof n == "object" && "value" in n && typeof n.subscribe == "function";
 }
-function Le(n) {
-  return Se(n) && typeof n.invalidate == "function";
+function Pe(n) {
+  return ve(n) && typeof n.invalidate == "function";
 }
-function Xe(n) {
+function Ge(n) {
   return n !== null && typeof n == "object" && typeof n.then == "function";
 }
-const Ge = d.RESOLVED | d.PENDING | d.REJECTED, Ee = Array(Ge + 1).fill(_e.IDLE);
-Ee[d.RESOLVED] = _e.RESOLVED;
-Ee[d.PENDING] = _e.PENDING;
-Ee[d.REJECTED] = _e.REJECTED;
-const Ue = 3, Pe = Number.MAX_SAFE_INTEGER - 1;
-class Qe extends He {
+const Qe = d.RESOLVED | d.PENDING | d.REJECTED, ye = Array(Qe + 1).fill(me.IDLE);
+ye[d.RESOLVED] = me.RESOLVED;
+ye[d.PENDING] = me.PENDING;
+ye[d.REJECTED] = me.REJECTED;
+const _t = 3, Fe = Number.MAX_SAFE_INTEGER - 1, pt = d.REJECTED | d.HAS_ERROR;
+class Ye extends ze {
   constructor(e, t = {}) {
-    if (typeof e != "function") throw new z(v.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = L, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = L, this._trackCount = 0, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : ge, this._onError = t.onError ?? null, Y.attachDebugInfo(this, "computed", this.id), t.lazy === !1)
+    if (typeof e != "function") throw new z(T.COMPUTED_MUST_BE_FUNCTION);
+    super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = F, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._errorDepCount = 0, this._trackEpoch = -1, this._trackLinks = F, this._trackCount = 0, this._value = void 0, this.flags = d.IS_COMPUTED | d.DIRTY | d.IDLE, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Ce, this._onError = t.onError ?? null;
+    const s = t.maxAsyncRetries;
+    if (this._maxAsyncRetries = s != null && s >= 0 ? s : _t, W.attachDebugInfo(this, "computed", this.id), t.lazy === !1)
       try {
         this._recompute();
       } catch {
@@ -526,7 +524,7 @@ class Qe extends He {
   }
   _track() {
     const e = M.current;
-    e && je(this, e, this._subscribers);
+    e && He(this, e, this._subscribers);
   }
   get value() {
     this._track();
@@ -534,17 +532,17 @@ class Qe extends He {
     if ((e & (d.RESOLVED | d.DIRTY | d.IDLE)) === d.RESOLVED)
       return this._value;
     if (e & d.DISPOSED)
-      throw new z(v.COMPUTED_DISPOSED);
+      throw new z(T.COMPUTED_DISPOSED);
     if (e & d.RECOMPUTING) {
-      if (this._defaultValue !== ge) return this._defaultValue;
-      throw new z(v.COMPUTED_CIRCULAR_DEPENDENCY);
+      if (this._defaultValue !== Ce) return this._defaultValue;
+      throw new z(T.COMPUTED_CIRCULAR_DEPENDENCY);
     }
     if (e & (d.DIRTY | d.IDLE) && (this._recompute(), this.flags & d.RESOLVED))
       return this._value;
-    const t = this._defaultValue, s = t !== ge;
+    const t = this._defaultValue, s = t !== Ce;
     if (this.flags & d.PENDING) {
       if (s) return t;
-      throw new z(v.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new z(T.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
     if (this.flags & d.REJECTED) {
       if (this._error?.recoverable && s) return t;
@@ -556,10 +554,10 @@ class Qe extends He {
     return this._value;
   }
   get state() {
-    return this._track(), Ee[this.flags & Ge];
+    return this._track(), ye[this.flags & Qe];
   }
   get hasError() {
-    if (this._track(), this.flags & (d.REJECTED | d.HAS_ERROR)) return !0;
+    if (this._track(), this.flags & (d.REJECTED | d.HAS_ERROR) || this._errorDepCount > 0) return !0;
     const e = this._links;
     for (let t = 0, s = e.length; t < s; t++) {
       const i = e[t]?.node;
@@ -572,21 +570,21 @@ class Qe extends He {
     return !this.hasError;
   }
   get errors() {
-    if (this._track(), !this.hasError) return Ze;
-    const e = ot();
+    if (this._track(), !this.hasError) return nt;
+    const e = at();
     if (this._errorCacheEpoch === e && this._cachedErrors) return this._cachedErrors;
     const t = [];
     this._error && t.push(this._error);
     const s = this._links;
-    for (let o = 0, r = s.length; o < r; o++) {
-      const c = s[o].node;
+    for (let r = 0, o = s.length; r < o; r++) {
+      const c = s[r].node;
       if (c.flags & d.HAS_ERROR) {
         const a = c;
         if (a.errors) {
-          const f = a.errors;
-          for (let p = 0; p < f.length; p++) {
-            const D = f[p];
-            D && t.indexOf(D) === -1 && t.push(D);
+          const _ = a.errors;
+          for (let g = 0; g < _.length; g++) {
+            const v = _[g];
+            v && t.indexOf(v) === -1 && t.push(v);
           }
         }
       }
@@ -609,12 +607,12 @@ class Qe extends He {
   dispose() {
     if (this.flags & d.DISPOSED) return;
     const e = this._links;
-    if (e !== L) {
+    if (e !== F) {
       for (let t = 0, s = e.length; t < s; t++)
         e[t].unsub?.();
-      X.release(e), this._links = L;
+      X.release(e), this._links = F;
     }
-    this._subscribers.length = 0, this.flags = d.DISPOSED | d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Pe, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._subscribers.length = 0, this.flags = d.DISPOSED | d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Fe, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   addDependency(e) {
     if (e._lastSeenEpoch !== this._trackEpoch) {
@@ -622,70 +620,82 @@ class Qe extends He {
         const t = this._trackLinks[this._trackCount];
         t.node = e, t.version = e.version;
       } else
-        this._trackLinks.push(new be(e, e.version));
+        this._trackLinks.push(new de(e, e.version));
       this._trackCount++;
     }
   }
   _commitDeps(e) {
-    this._trackLinks.length = this._trackCount, it(this._trackLinks, e, this), this._links = this._trackLinks;
+    this._trackLinks.length = this._trackCount, ct(this._trackLinks, e, this), this._links = this._trackLinks;
+  }
+  _updateErrorDepCount() {
+    let e = 0;
+    const t = this._links;
+    for (let s = 0, i = t.length; s < i; s++) {
+      const r = t[s]?.node;
+      r && r.flags & d.HAS_ERROR && e++;
+    }
+    this._errorDepCount = e;
   }
   _recompute() {
     if (this.flags & d.RECOMPUTING) return;
     this.flags |= d.RECOMPUTING;
     const e = this._links;
-    this._trackEpoch = ze(), this._trackLinks = X.acquire(), this._trackCount = 0;
+    this._trackEpoch = qe(), this._trackLinks = X.acquire(), this._trackCount = 0;
     let t = !1;
     try {
       const s = M.run(this, this._fn);
-      this._commitDeps(e), t = !0, Xe(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+      this._commitDeps(e), t = !0, this._updateErrorDepCount(), Ge(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
     } catch (s) {
       if (!t)
         try {
-          this._commitDeps(e), t = !0;
-        } catch {
+          this._commitDeps(e), t = !0, this._updateErrorDepCount();
+        } catch (i) {
+          L && console.warn("[atom-effect] _commitDeps failed during error recovery:", i);
         }
-      this._handleError(s, v.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, T.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      t && e !== L ? X.release(e) : t || X.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = L, this._trackCount = 0, this.flags &= -257;
+      t && e !== F ? X.release(e) : t || X.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = F, this._trackCount = 0, this.flags &= -257;
     }
   }
   _handleAsyncComputation(e) {
-    this.flags = (this.flags | d.PENDING) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Pe;
+    this.flags = (this.flags | d.PENDING) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Fe;
     const t = this._promiseId;
     e.then(
       (s) => {
         if (t === this._promiseId) {
           if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion)
-            return this._asyncRetryCount++ < Ue ? this._markDirty() : this._handleError(
-              new z(`Async drift threshold exceeded after ${Ue} retries.`),
-              v.COMPUTED_ASYNC_COMPUTATION_FAILED
+            return this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
+              new z(
+                `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
+              ),
+              T.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
           this._finalizeResolution(s), this._notifySubscribers(s, void 0);
         }
       },
-      (s) => t === this._promiseId && this._handleError(s, v.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (s) => t === this._promiseId && this._handleError(s, T.COMPUTED_ASYNC_COMPUTATION_FAILED)
     );
   }
   _captureVersionSnapshot() {
     let e = 0;
     const t = this._links;
     for (let s = 0, i = t.length; s < i; s++)
-      e = ((e << 5) - e | 0) + t[s].node.version & W;
+      e = ((e << 5) - e | 0) + t[s].node.version & oe;
     return e;
   }
   _handleError(e, t, s = !1) {
-    const i = ee(e, z, t);
-    if (!s && !(this.flags & d.REJECTED) && (this.version = this.version + 1 & W), this._error = i, this.flags = this.flags & -121 | (d.REJECTED | d.HAS_ERROR), this._onError)
+    const i = Z(e, z, t);
+    if (!s && !(this.flags & d.REJECTED) && (this.version = De(this.version)), this._error = i, this.flags = this.flags & -121 | pt, this._onError)
       try {
         this._onError(i);
-      } catch (o) {
-        console.error(v.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
+      } catch (r) {
+        console.error(T.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
       }
     if (s) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(e) {
-    (!(this.flags & d.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & W), this._value = e, this._error = null, this.flags = (this.flags | d.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!(this.flags & d.RESOLVED) || !this._equal(this._value, e)) && (this.version = De(this.version)), this._value = e, this._error = null, this.flags = (this.flags | d.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   execute() {
     this._markDirty();
@@ -695,40 +705,46 @@ class Qe extends He {
     this.flags & (d.RECOMPUTING | d.DIRTY) || (this.flags |= d.DIRTY, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Qe.prototype);
-function at(n, e = {}) {
-  return new Qe(n, e);
+Object.freeze(Ye.prototype);
+function Et(n, e = {}) {
+  return new Ye(n, e);
 }
-class ht extends Ve {
+class gt extends je {
   constructor(e, t = {}) {
-    super(), this._cleanup = null, this._links = L, this._nextLinks = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._historyPtr = 0, this._execId = 0, this._fn = e, this._onError = t.onError ?? null, 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;
+    super(), this._cleanup = null, this._links = F, this._nextLinks = null, this._parkedUnsubs = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._historyPtr = 0, this._execId = 0, this._fn = e, this._onError = t.onError ?? null, 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;
     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 = T && s && i > 0 ? new Array(i).fill(0) : null, Y.attachDebugInfo(this, "effect", this.id);
+    this._historyCapacity = i, this._history = L && s && i > 0 ? new Array(i).fill(0) : null, W.attachDebugInfo(this, "effect", this.id);
   }
   run() {
     if (this.flags & P.DISPOSED)
-      throw new Q(v.EFFECT_DISPOSED);
+      throw new Y(T.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & P.DISPOSED || (this.flags |= P.DISPOSED, this._execCleanup(), this._releaseLinks(this._links), this._links = L, this._executeTask = void 0);
+    this.flags & P.DISPOSED || (this.flags |= P.DISPOSED, this._execCleanup(), this._releaseLinks(this._links), this._links = F, this._executeTask = void 0);
   }
   addDependency(e) {
     if (!(this.flags & P.EXECUTING) || e._lastSeenEpoch === this._currentEpoch) return;
     e._lastSeenEpoch = this._currentEpoch;
-    const t = this._nextLinks;
-    if (e._tempUnsub) {
-      t.push(new be(e, e.version, e._tempUnsub)), e._tempUnsub = void 0;
+    const t = this._nextLinks, s = this._parkedUnsubs?.get(e);
+    if (s) {
+      t.push(new de(e, e.version, s)), this._parkedUnsubs.delete(e);
       return;
     }
     try {
-      const s = e.subscribe(() => {
+      const i = e.subscribe(() => {
         if (this._trackModifications && this.flags & P.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
-        this._executeTask || (this._executeTask = () => this.execute()), F.schedule(this._executeTask);
+        this._executeTask || (this._executeTask = () => this.execute()), re.schedule(this._executeTask);
       });
-      t.push(new be(e, e.version, s));
-    } catch (s) {
-      console.error(ee(s, Q, v.EFFECT_EXECUTION_FAILED));
+      t.push(new de(e, e.version, i));
+    } catch (i) {
+      const r = Z(i, Y, T.EFFECT_EXECUTION_FAILED);
+      if (console.error(r), this._onError)
+        try {
+          this._onError(r);
+        } catch {
+        }
+      t.push(new de(e, e.version, void 0));
     }
   }
   /**
@@ -738,19 +754,22 @@ class ht extends Ve {
     if (this.flags & (P.DISPOSED | P.EXECUTING) || !e && this._links.length > 0 && !this._isDirty()) return;
     this._checkInfiniteLoops(), this.flags |= P.EXECUTING, this._execCleanup();
     const t = this._links;
-    if (t !== L)
-      for (let o = 0, r = t.length; o < r; o++) {
-        const c = t[o];
-        c && (c.node._tempUnsub = c.unsub);
+    if (t !== F) {
+      const r = /* @__PURE__ */ new Map();
+      for (let o = 0, c = t.length; o < c; o++) {
+        const a = t[o];
+        a?.unsub && r.set(a.node, a.unsub);
       }
+      this._parkedUnsubs = r;
+    }
     const s = X.acquire();
-    this._nextLinks = s, this._currentEpoch = ze();
+    this._nextLinks = s, this._currentEpoch = qe();
     let i = !1;
     try {
-      const o = M.run(this, this._fn);
-      this._links = s, i = !0, this._checkLoopWarnings(), Xe(o) ? this._handleAsyncResult(o) : this._cleanup = typeof o == "function" ? o : null;
-    } catch (o) {
-      i = !0, this._handleExecutionError(o), this._cleanup = null;
+      const r = M.run(this, this._fn);
+      this._links = s, i = !0, this._checkLoopWarnings(), Ge(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
+    } catch (r) {
+      i = !0, this._handleExecutionError(r), this._cleanup = null;
     } finally {
       this._finalizeDependencies(i, t, s), this.flags &= -9;
     }
@@ -764,7 +783,7 @@ class ht extends Ve {
             try {
               s();
             } catch (i) {
-              this._handleExecutionError(i, v.EFFECT_CLEANUP_FAILED);
+              this._handleExecutionError(i, T.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
@@ -775,19 +794,16 @@ class ht extends Ve {
   }
   _finalizeDependencies(e, t, s) {
     if (this._nextLinks = null, e) {
-      if (t !== L) {
-        for (let i = 0, o = t.length; i < o; i++) {
-          const r = t[i], c = r?.node._tempUnsub;
-          c && (c(), r && (r.node._tempUnsub = void 0));
-        }
-        X.release(t);
-      }
-    } else if (this._releaseLinks(s), X.release(s), t !== L)
-      for (let i = 0, o = t.length; i < o; i++)
-        t[i] && (t[i].node._tempUnsub = void 0);
+      if (this._parkedUnsubs)
+        for (const i of this._parkedUnsubs.values())
+          i();
+      t !== F && X.release(t);
+    } else
+      this._releaseLinks(s), X.release(s);
+    this._parkedUnsubs = null;
   }
   _releaseLinks(e) {
-    if (e !== L) {
+    if (e !== F) {
       for (let t = 0, s = e.length; t < s; t++)
         e[t]?.unsub?.();
       X.release(e);
@@ -798,16 +814,14 @@ class ht extends Ve {
     M.current = null;
     try {
       for (let s = 0, i = e.length; s < i; s++) {
-        const o = e[s], r = o.node;
-        if (r.version !== o.version) return !0;
-        if ("value" in r) {
+        const r = e[s], o = r.node;
+        if (o.flags & d.IS_COMPUTED)
           try {
-            r.value;
+            o.value;
           } catch {
-            return !0;
+            return L && console.warn(`[atom-effect] Dependency #${o.id} threw during dirty check`), !0;
           }
-          if (r.version !== o.version) return !0;
-        }
+        if (o.version !== r.version) return !0;
       }
       return !1;
     } finally {
@@ -819,22 +833,20 @@ class ht extends Ve {
       try {
         this._cleanup();
       } catch (e) {
-        this._handleExecutionError(e, v.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(e, T.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const e = Ce;
-    if (this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), rt() > q.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+    const e = Te;
+    if (this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ut() > q.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
       const t = Date.now();
       this._history[this._historyPtr] = t, this._historyPtr = (this._historyPtr + 1) % this._historyCapacity;
       const s = this._history[this._historyPtr] || 0;
-      if (s > 0 && t - s < Je.ONE_SECOND_MS) {
-        const i = new Q(
-          "Effect executed too frequently within 1 second. Suspected infinite loop."
-        );
-        if (this.dispose(), this._handleExecutionError(i), T) throw i;
+      if (s > 0 && t - s < et.ONE_SECOND_MS) {
+        const i = new Y(T.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+        if (this.dispose(), this._handleExecutionError(i), L) throw i;
       }
     }
   }
@@ -848,53 +860,53 @@ class ht extends Ve {
     return (this.flags & P.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(e) {
-    const t = new Q(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Te}`
+    const t = new Y(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${we}`
     );
     throw this.dispose(), console.error(t), t;
   }
-  _handleExecutionError(e, t = v.EFFECT_EXECUTION_FAILED) {
-    const s = ee(e, Q, t);
+  _handleExecutionError(e, t = T.EFFECT_EXECUTION_FAILED) {
+    const s = Z(e, Y, t);
     if (console.error(s), this._onError)
       try {
         this._onError(s);
       } catch (i) {
-        console.error(ee(i, Q, v.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(Z(i, Y, T.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
   _checkLoopWarnings() {
-    if (this._trackModifications && Y.enabled) {
+    if (this._trackModifications && W.enabled) {
       const e = this._currentEpoch, t = this._links;
       for (let s = 0, i = t.length; s < i; s++) {
-        const o = t[s].node;
-        o._modifiedAtEpoch === e && Y.warn(
+        const r = t[s].node;
+        r._modifiedAtEpoch === e && W.warn(
           !0,
-          `Effect is reading a dependency (${Y.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${W.getDebugName(r) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function j(n, e = {}) {
+function B(n, e = {}) {
   if (typeof n != "function")
-    throw new Q(v.EFFECT_MUST_BE_FUNCTION);
-  const t = new ht(n, e);
+    throw new Y(T.EFFECT_MUST_BE_FUNCTION);
+  const t = new gt(n, e);
   return t.execute(), t;
 }
-function ve(n) {
+function Re(n) {
   if (typeof n != "function")
     throw new TypeError("Batch callback must be a function");
-  F.startBatch();
+  re.startBatch();
   try {
     return n();
   } finally {
-    F.endBatch();
+    re.endBatch();
   }
 }
-function ft(n) {
+function mt(n) {
   return n !== null && typeof n == "object" && "value" in n && "subscribe" in n;
 }
-function pe(n) {
+function be(n) {
   if (!n) return "unknown";
   const e = "jquery" in n ? n[0] : n;
   if (!e) return "unknown";
@@ -902,45 +914,81 @@ function pe(n) {
   if (t && typeof t == "string") return `#${t}`;
   const s = e.tagName.toLowerCase(), i = e.classList;
   if (i && i.length > 0) {
-    let o = s;
-    for (let r = 0, c = i.length; r < c; r++) {
-      const a = i[r];
-      a && (o += `.${a}`);
+    let r = s;
+    for (let o = 0, c = i.length; o < c; o++) {
+      const a = i[o];
+      a && (r += `.${a}`);
     }
-    return o;
+    return r;
   }
   return s;
 }
-function dt(n) {
+function se(n) {
+  let e = String(n ?? "");
+  e = e.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ""), e = e.replace(/<\?[\s\S]*?\?>/g, "");
+  const t = /(<(script|iframe|object|embed|base|meta|applet|noscript)\b[^>]*>([\s\S]*?)<\/\2>|<(script|iframe|object|embed|base|meta|applet|noscript)\b[^>]*\/?>)/gim;
+  let s;
+  do
+    s = e, e = e.replace(t, "");
+  while (e !== s);
+  const i = /(j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t|v\s*b\s*s\s*c\s*r\s*i\s*p\s*t)\s*:/gi;
+  e = e.replace(i, "data-unsafe-protocol:");
+  const r = /data\s*:\s*(?:text\/html|application\/javascript|text\/javascript|text\/vbscript|text\/xml|application\/xhtml\+xml)/gim;
+  return e = e.replace(r, "data-unsafe-protocol:"), e = e.replace(/\bon\w+\s*=/gim, "data-unsafe-attr="), e = e.replace(/expression\s*\(/gim, "data-unsafe-css(").replace(/behavior\s*:/gim, "data-unsafe-css:"), e;
+}
+const yt = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "action",
+  "formaction",
+  "xlink:href",
+  "data",
+  "poster",
+  "srcset",
+  "background",
+  "cite",
+  "longdesc",
+  "profile",
+  "usemap",
+  "classid",
+  "codebase"
+]), bt = /^\s*(?:javascript|vbscript)\s*:/i;
+function We(n, e) {
+  return yt.has(n.toLowerCase()) ? bt.test(e) : !1;
+}
+function ke(n) {
+  return n.toLowerCase().includes("url(") ? /url\s*\(\s*(?:["']?\s*)?(?:javascript|vbscript)\s*:/i.test(n) : !1;
+}
+function Ct(n) {
   const e = n.length;
   if (e === 0) return new Int32Array(0);
   const t = new Int32Array(e), s = new Int32Array(e);
   let i = 0;
-  for (let r = 0; r < e; r++) {
-    const c = n[r];
+  for (let o = 0; o < e; o++) {
+    const c = n[o];
     if (c === void 0 || c === -1) continue;
     const a = i > 0 ? s[i - 1] : void 0;
     if (i === 0 || a !== void 0 && (n[a] ?? -1) < c) {
-      t[r] = a ?? -1, s[i++] = r;
+      t[o] = a ?? -1, s[i++] = o;
       continue;
     }
-    let f = 0, p = i - 1;
-    for (; f < p; ) {
-      const I = f + p >>> 1, O = s[I];
-      O !== void 0 && (n[O] ?? -1) < c ? f = I + 1 : p = I;
+    let _ = 0, g = i - 1;
+    for (; _ < g; ) {
+      const I = _ + g >>> 1, O = s[I];
+      O !== void 0 && (n[O] ?? -1) < c ? _ = I + 1 : g = I;
     }
-    const D = s[f];
-    D !== void 0 && c < (n[D] ?? Number.MAX_SAFE_INTEGER) && (f > 0 && (t[r] = s[f - 1] ?? -1), s[f] = r);
+    const v = s[_];
+    v !== void 0 && c < (n[v] ?? Number.MAX_SAFE_INTEGER) && (_ > 0 && (t[o] = s[_ - 1] ?? -1), s[_] = o);
   }
-  const o = new Int32Array(i);
+  const r = 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];
+    let o = s[i - 1];
+    for (let c = i - 1; c >= 0 && o !== void 0 && o !== -1; c--)
+      r[c] = o, o = t[o];
   }
-  return o;
+  return r;
 }
-function _t() {
+function It() {
   if (typeof window < "u") {
     const n = window.__ATOM_DEBUG__;
     if (typeof n == "boolean") return n;
@@ -951,19 +999,19 @@ function _t() {
   }
   return !1;
 }
-let G = _t();
-const m = {
+let Q = It();
+const b = {
   get enabled() {
-    return G;
+    return Q;
   },
   set enabled(n) {
-    G = n;
+    Q = n;
   },
   log(n, ...e) {
-    G && console.log(`[atom-effect-jquery] ${n}:`, ...e);
+    Q && console.log(`[atom-effect-jquery] ${n}:`, ...e);
   },
   atomChanged(n, e, t) {
-    G && console.log(
+    Q && console.log(
       `[atom-effect-jquery] Atom "${n ?? "anonymous"}" changed:`,
       e,
       "→",
@@ -974,20 +1022,20 @@ const m = {
    * Logs DOM updates and triggers visual highlight.
    */
   domUpdated(n, e, t) {
-    G && (console.log(`[atom-effect-jquery] DOM updated: ${pe(n)}.${e} =`, t), Et(n));
+    Q && (console.log(`[atom-effect-jquery] DOM updated: ${be(n)}.${e} =`, t), St(n));
   },
   cleanup(n) {
-    G && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
+    Q && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
   },
   warn(...n) {
-    G && console.warn("[atom-effect-jquery]", ...n);
+    Q && console.warn("[atom-effect-jquery]", ...n);
   }
-}, me = /* @__PURE__ */ new WeakMap();
-function Et(n) {
+}, Ie = /* @__PURE__ */ new WeakMap();
+function St(n) {
   const e = "jquery" in n ? n[0] : n;
   if (!e || !e.isConnected) return;
-  let t = me.get(e);
-  if (t || (t = {}, me.set(e, t)), t.timer && clearTimeout(t.timer), t.cleanupTimer && clearTimeout(t.cleanupTimer), !t.orgStyle) {
+  let t = Ie.get(e);
+  if (t || (t = {}, Ie.set(e, t)), t.timer && clearTimeout(t.timer), t.cleanupTimer && clearTimeout(t.cleanupTimer), !t.orgStyle) {
     const i = e.style;
     t.orgStyle = {
       outline: i.outline,
@@ -1001,40 +1049,40 @@ function Et(n) {
       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), me.delete(e);
+        e.isConnected && t?.orgStyle && (s.transition = t.orgStyle.transition), Ie.delete(e);
       }, 500);
     }));
   }, 100);
 }
-const pt = /* @__PURE__ */ new WeakMap();
-function Ye(n, e = {}) {
-  const t = qe(n, e);
-  return e.name && pt.set(t, { name: e.name }), t;
+const Dt = /* @__PURE__ */ new WeakMap();
+function Ke(n, e = {}) {
+  const t = Xe(n, e);
+  return e.name && Dt.set(t, { name: e.name }), t;
 }
-Object.defineProperty(Ye, "debug", {
+Object.defineProperty(Ke, "debug", {
   get() {
-    return m.enabled;
+    return b.enabled;
   },
   set(n) {
-    m.enabled = n;
+    b.enabled = n;
   }
 });
-function gt() {
+function Tt() {
   return new Promise((n) => setTimeout(n, 0));
 }
 l.extend({
-  atom: Ye,
-  computed: at,
-  effect: j,
-  batch: ve,
-  untracked: ct,
-  isAtom: Se,
-  isComputed: Le,
-  isReactive: (n) => Se(n) || Le(n),
-  nextTick: gt
+  atom: Ke,
+  computed: Et,
+  effect: B,
+  batch: Re,
+  untracked: ht,
+  isAtom: ve,
+  isComputed: Pe,
+  isReactive: (n) => ve(n) || Pe(n),
+  nextTick: Tt
 });
-const le = "_aes-bound";
-class mt {
+const he = "_aes-bound";
+class vt {
   records = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
   preservedNodes = /* @__PURE__ */ new WeakSet();
@@ -1054,7 +1102,7 @@ class mt {
   }
   _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(le))), t;
+    return t || (t = {}, this.records.set(e, t), this.boundElements.has(e) || (this.boundElements.add(e), e.classList.add(he))), t;
   }
   trackEffect(e, t) {
     const s = this._getOrCreateRecord(e);
@@ -1071,123 +1119,123 @@ class mt {
     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(le), m.enabled && m.cleanup(pe(e));
+    this.records.delete(e), this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.classList.remove(he), b.enabled && b.cleanup(be(e));
     const s = t.effects;
     if (s)
-      for (let o = 0, r = s.length; o < r; o++)
+      for (let r = 0, o = s.length; r < o; r++)
         try {
-          s[o]?.dispose();
+          s[r]?.dispose();
         } catch (c) {
-          m.warn("Effect dispose error:", c);
+          b.warn("Effect dispose error:", c);
         }
     const i = t.cleanups;
     if (i)
-      for (let o = 0, r = i.length; o < r; o++)
+      for (let r = 0, o = i.length; r < o; r++)
         try {
-          i[o]?.();
+          i[r]?.();
         } catch (c) {
-          m.warn("Cleanup error:", c);
+          b.warn("Cleanup error:", c);
         }
   }
   cleanupDescendants(e) {
-    const t = e.querySelectorAll(`.${le}`);
+    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(le);
+      const r = t[s];
+      r && this.boundElements.has(r) ? this.cleanup(r) : r && r.classList.remove(he);
     }
   }
   cleanupTree(e) {
     this.cleanupDescendants(e), this.cleanup(e);
   }
 }
-const y = new mt();
+const y = new vt();
 let ie = null;
-function yt(n = document.body) {
+function kt(n = document.body) {
   ie || (ie = new MutationObserver((e) => {
     for (let t = 0, s = e.length; t < s; t++) {
       const i = e[t]?.removedNodes;
       if (!i) continue;
-      const o = i.length;
-      if (o !== 0)
-        for (let r = 0; r < o; r++) {
-          const c = i[r];
+      const r = i.length;
+      if (r !== 0)
+        for (let o = 0; o < r; o++) {
+          const c = i[o];
           c.nodeType === 1 && (c.isConnected || y.isKept(c) || y.isIgnored(c) || y.cleanupTree(c));
         }
     }
   }), ie.observe(n, { childList: !0, subtree: !0 }));
 }
-function Ut() {
+function zt() {
   ie?.disconnect(), ie = null;
 }
 function k(n, e, t, s) {
-  ft(e) ? y.trackEffect(
+  mt(e) ? y.trackEffect(
     n,
-    j(() => {
+    B(() => {
       const i = e.value;
-      t(i), m.domUpdated(l(n), s, i);
+      t(i), b.domUpdated(l(n), s, i);
     })
-  ) : (t(e), m.domUpdated(l(n), s, e));
+  ) : (t(e), b.domUpdated(l(n), s, e));
 }
-var S = /* @__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))(S || {});
-function ke() {
+var D = /* @__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))(D || {});
+function Ne() {
   return {
     timeoutId: null,
     flags: 0
     /* None */
   };
 }
-function We(n, e, t = {}) {
+function Je(n, e, t = {}) {
   const {
     debounce: s,
     event: i = "input",
-    parse: o = (N) => N,
-    format: r = (N) => String(N ?? ""),
+    parse: r = (w) => w,
+    format: o = (w) => String(w ?? ""),
     equal: c = Object.is
-  } = t, a = ke(), f = n[0], p = () => {
-    if (!(a.flags & S.Busy)) {
-      a.flags |= S.SyncingToAtom;
+  } = t, a = Ne(), _ = n[0], g = () => {
+    if (!(a.flags & D.Busy)) {
+      a.flags |= D.SyncingToAtom;
       try {
-        const N = f.value, A = o(N);
-        c(e.value, A) || (e.value = A);
+        const w = _.value, R = r(w);
+        c(e.value, R) || (e.value = R);
       } finally {
-        a.flags &= ~S.SyncingToAtom;
+        a.flags &= ~D.SyncingToAtom;
       }
     }
-  }, D = () => {
-    a.timeoutId && (clearTimeout(a.timeoutId), a.timeoutId = null, p()), a.flags &= ~S.Focused;
-    const N = r(e.value);
-    f.value !== N && (f.value = N);
+  }, v = () => {
+    a.timeoutId && (clearTimeout(a.timeoutId), a.timeoutId = null, g()), a.flags &= ~D.Focused;
+    const w = o(e.value);
+    _.value !== w && (_.value = w);
   }, I = () => {
-    a.flags & S.Busy || (s ? (a.timeoutId && clearTimeout(a.timeoutId), a.timeoutId = setTimeout(p, s)) : p());
+    a.flags & D.Busy || (s ? (a.timeoutId && clearTimeout(a.timeoutId), a.timeoutId = setTimeout(g, s)) : g());
   }, O = {
     compositionstart: () => {
-      a.flags |= S.Composing;
+      a.flags |= D.Composing;
     },
     compositionend: () => {
-      a.flags &= ~S.Composing, p();
+      a.flags &= ~D.Composing, g();
     },
     focus: () => {
-      a.flags |= S.Focused;
+      a.flags |= D.Focused;
     },
-    blur: D,
+    blur: v,
     [i]: I,
     change: I
   };
   return n.on(O), { effect: () => {
-    const N = e.value, A = r(N), R = f.value;
-    if (R !== A && !(a.flags & S.Focused && c(o(R), N))) {
-      a.flags |= S.SyncingToDom;
+    const w = e.value, R = o(w), A = _.value;
+    if (A !== R && !(a.flags & D.Focused && c(r(A), w))) {
+      a.flags |= D.SyncingToDom;
       try {
-        if (a.flags & S.Focused) {
-          const { selectionStart: x, selectionEnd: K } = f;
-          f.value = A;
-          const U = A.length;
-          f.setSelectionRange(Math.min(x ?? U, U), Math.min(K ?? U, U));
+        if (a.flags & D.Focused) {
+          const { selectionStart: x, selectionEnd: K } = _;
+          _.value = R;
+          const U = R.length;
+          _.setSelectionRange(Math.min(x ?? U, U), Math.min(K ?? U, U));
         } else
-          f.value = A;
-        m.domUpdated(n, "val", A);
+          _.value = R;
+        b.domUpdated(n, "val", R);
       } finally {
-        a.flags &= ~S.SyncingToDom;
+        a.flags &= ~D.SyncingToDom;
       }
     }
   }, cleanup: () => {
@@ -1203,7 +1251,15 @@ l.fn.atomText = function(n, e) {
 l.fn.atomHtml = function(n) {
   return this.each(function() {
     const e = l(this);
-    k(this, n, (t) => e.html(String(t ?? "")), "html");
+    k(
+      this,
+      n,
+      (t) => {
+        const s = String(t ?? ""), i = se(s);
+        i !== s && console.warn("[atomHtml] Unsafe content neutralized during sanitization."), e.html(i);
+      },
+      "html"
+    );
   });
 };
 l.fn.atomClass = function(n, e) {
@@ -1220,11 +1276,18 @@ l.fn.atomClass = function(n, e) {
 l.fn.atomCss = function(n, e, t) {
   return this.each(function() {
     const s = l(this);
-    k(this, e, t ? (o) => s.css(n, `${o}${t}`) : (o) => s.css(n, o), `css.${n}`);
+    k(this, e, (r) => {
+      const o = t ? `${r}${t}` : r, c = String(o);
+      if (ke(c)) {
+        console.warn(`[atomCss] Blocked dangerous value in "${n}" property.`);
+        return;
+      }
+      s.css(n, o);
+    }, `css.${n}`);
   });
 };
 l.fn.atomAttr = function(n, e) {
-  return this.each(function() {
+  return /^on/i.test(n) ? (console.warn(`[atomAttr] Blocked setting dangerous event handler attribute "${n}".`), this) : this.each(function() {
     const t = l(this);
     k(
       this,
@@ -1234,16 +1297,23 @@ l.fn.atomAttr = function(n, e) {
           t.removeAttr(n);
           return;
         }
-        t.attr(n, s === !0 ? n : String(s));
+        const i = s === !0 ? n : String(s);
+        if (We(n, i)) {
+          console.warn(`[atomAttr] Blocked dangerous protocol in "${n}" attribute.`);
+          return;
+        }
+        t.attr(n, i);
       },
       `attr.${n}`
     );
   });
 };
 l.fn.atomProp = function(n, e) {
-  return this.each(function() {
-    const t = l(this);
-    k(this, e, (s) => t.prop(n, s), `prop.${n}`);
+  return ["innerHTML", "outerHTML"].includes(n) ? (console.warn(
+    `[atomProp] Blocked setting dangerous property "${n}". Use atomHtml for sanitized HTML binding.`
+  ), this) : this.each(function() {
+    const s = l(this);
+    k(this, e, (i) => s.prop(n, i), `prop.${n}`);
   });
 };
 l.fn.atomShow = function(n) {
@@ -1260,24 +1330,29 @@ l.fn.atomHide = function(n) {
 };
 l.fn.atomVal = function(n, e = {}) {
   return this.each(function() {
-    const { effect: t, cleanup: s } = We(l(this), n, e);
-    y.trackEffect(this, j(t)), y.trackCleanup(this, s);
+    const t = this.tagName.toLowerCase();
+    if (!["input", "select", "textarea"].includes(t)) {
+      console.warn(`[atomVal] Element <${t}> is not a valid input element.`);
+      return;
+    }
+    const { effect: s, cleanup: i } = Je(l(this), n, e);
+    y.trackEffect(this, B(s)), y.trackCleanup(this, i);
   });
 };
 l.fn.atomChecked = function(n) {
   return this.each(function() {
-    const e = l(this), t = this, s = ke(), i = () => {
-      if (s.flags & S.Busy) return;
-      const r = t.checked;
-      n.value !== r && (n.value = r);
+    const e = l(this), t = this, s = Ne(), i = () => {
+      if (s.flags & D.Busy) return;
+      const o = t.checked;
+      n.value !== o && (n.value = o);
     };
     e.on("change", i), y.trackCleanup(this, () => e.off("change", i));
-    const o = j(() => {
-      s.flags |= S.SyncingToDom;
-      const r = !!n.value;
-      t.checked !== r && (t.checked = r, m.domUpdated(e, "checked", r)), s.flags &= ~S.SyncingToDom;
+    const r = B(() => {
+      s.flags |= D.SyncingToDom;
+      const o = !!n.value;
+      t.checked !== o && (t.checked = o, b.domUpdated(e, "checked", o)), s.flags &= ~D.SyncingToDom;
     });
-    y.trackEffect(this, o);
+    y.trackEffect(this, r);
   });
 };
 l.fn.atomOn = function(n, e) {
@@ -1291,12 +1366,12 @@ l.fn.atomUnbind = function() {
     y.cleanupTree(this);
   });
 };
-const Fe = /* @__PURE__ */ Object.create(null);
-function bt(n) {
-  let e = Fe[n];
-  return e || (e = n.includes("-") ? n.replace(/-./g, (t) => t[1].toUpperCase()) : n, Fe[n] = e, e);
+const $e = /* @__PURE__ */ Object.create(null);
+function Ot(n) {
+  let e = $e[n];
+  return e || (e = n.includes("-") ? n.replace(/-./g, (t) => t[1].toUpperCase()) : n, $e[n] = e, e);
 }
-function It(n, e) {
+function wt(n, e) {
   const t = n.el;
   k(
     t,
@@ -1308,19 +1383,21 @@ function It(n, e) {
     "text"
   );
 }
-function Ct(n, e) {
+function Rt(n, e) {
   const t = n.el;
   k(
     t,
     e,
     (s) => {
-      const i = String(s ?? "");
-      t.innerHTML !== i && (t.innerHTML = i);
+      const i = String(s ?? ""), r = se(i);
+      r !== i && console.warn("[atomBind] Unsafe content neutralized during sanitization.");
+      const o = r;
+      t.innerHTML !== o && (t.innerHTML = o);
     },
     "html"
   );
 }
-function St(n, e) {
+function Nt(n, e) {
   for (const t in e)
     k(
       n.el,
@@ -1331,32 +1408,46 @@ function St(n, e) {
       `class.${t}`
     );
 }
-function Dt(n, e) {
+function At(n, e) {
   const t = n.el, s = t.style;
   for (const i in e) {
-    const o = e[i];
-    if (o === void 0) continue;
-    const r = bt(i);
-    Array.isArray(o) ? k(
+    const r = e[i];
+    if (r === void 0) continue;
+    const o = Ot(i);
+    Array.isArray(r) ? k(
       t,
-      o[0],
+      r[0],
       (c) => {
-        s[r] = `${c}${o[1]}`;
+        const a = `${c}${r[1]}`;
+        if (ke(a)) {
+          console.warn(`[atomBind] Blocked dangerous value in "${i}" property.`);
+          return;
+        }
+        s[o] = a;
       },
       `css.${i}`
     ) : k(
       t,
-      o,
+      r,
       (c) => {
-        s[r] = c;
+        const a = String(c);
+        if (ke(a)) {
+          console.warn(`[atomBind] Blocked dangerous value in "${i}" property.`);
+          return;
+        }
+        s[o] = a;
       },
       `css.${i}`
     );
   }
 }
-function Tt(n, e) {
+function Lt(n, e) {
   const t = n.el;
-  for (const s in e)
+  for (const s in e) {
+    if (/^on/i.test(s)) {
+      console.warn(`[atomBind] Blocked setting dangerous event handler attribute "${s}".`);
+      continue;
+    }
     k(
       t,
       e[s],
@@ -1365,15 +1456,27 @@ function Tt(n, e) {
           t.removeAttribute(s);
           return;
         }
-        const o = i === !0 ? s : String(i);
-        t.getAttribute(s) !== o && t.setAttribute(s, o);
+        const r = i === !0 ? s : String(i);
+        if (We(s, r)) {
+          console.warn(`[atomBind] Blocked dangerous protocol in "${s}" attribute.`);
+          return;
+        }
+        t.getAttribute(s) !== r && t.setAttribute(s, r);
       },
       `attr.${s}`
     );
+  }
 }
-function vt(n, e) {
+const xt = ["innerHTML", "outerHTML"];
+function Ut(n, e) {
   const t = n.el;
-  for (const s in e)
+  for (const s in e) {
+    if (xt.includes(s)) {
+      console.warn(
+        `[atomBind] Blocked setting dangerous property "${s}". Use html binding for sanitized HTML.`
+      );
+      continue;
+    }
     k(
       n.el,
       e[s],
@@ -1382,60 +1485,66 @@ function vt(n, e) {
       },
       `prop.${s}`
     );
+  }
 }
-function kt(n, e) {
+function Pt(n, e) {
   const t = n.el;
   k(
     t,
     e,
     (s) => {
-      t.style.display = s ? "" : "none", m.enabled && m.domUpdated(t, "show", s);
+      t.style.display = s ? "" : "none", b.enabled && b.domUpdated(t, "show", s);
     },
     "show"
   );
 }
-function Ot(n, e) {
+function Ft(n, e) {
   const t = n.el;
   k(
     t,
     e,
     (s) => {
-      t.style.display = s ? "none" : "", m.enabled && m.domUpdated(t, "hide", s);
+      t.style.display = s ? "none" : "", b.enabled && b.domUpdated(t, "hide", s);
     },
     "hide"
   );
 }
-function Nt(n, e) {
-  const t = Array.isArray(e), { effect: s, cleanup: i } = We(
+function $t(n, e) {
+  const t = n.el.tagName.toLowerCase();
+  if (!["input", "select", "textarea"].includes(t)) {
+    console.warn(`[atomBind] Val binding used on non-input element <${t}>.`);
+    return;
+  }
+  const s = Array.isArray(e), { effect: i, cleanup: r } = Je(
     n.$el,
-    t ? e[0] : e,
-    t ? e[1] : {}
+    s ? e[0] : e,
+    s ? e[1] : {}
   );
-  y.trackEffect(n.el, j(s)), n.trackCleanup(i);
+  y.trackEffect(n.el, B(i)), n.trackCleanup(r);
 }
-function At(n, e) {
-  const t = n.el, s = ke(), i = () => {
-    if (s.flags & S.Busy) return;
-    const r = t.checked;
-    e.value !== r && (e.value = r);
+function Mt(n, e) {
+  const t = n.el, s = Ne(), i = () => {
+    if (s.flags & D.Busy) return;
+    const o = t.checked;
+    e.value !== o && (e.value = o);
   };
   t.addEventListener("change", i), n.trackCleanup(() => t.removeEventListener("change", i));
-  const o = j(() => {
-    s.flags |= S.SyncingToDom;
-    const r = !!e.value;
-    t.checked !== r && (t.checked = r, m.enabled && m.domUpdated(t, "checked", r)), s.flags &= ~S.SyncingToDom;
+  const r = B(() => {
+    s.flags |= D.SyncingToDom;
+    const o = !!e.value;
+    t.checked !== o && (t.checked = o, b.enabled && b.domUpdated(t, "checked", o)), s.flags &= ~D.SyncingToDom;
   });
-  y.trackEffect(t, o);
+  y.trackEffect(t, r);
 }
-function wt(n, e) {
+function Bt(n, e) {
   for (const t in e) {
     const s = e[t];
     if (typeof s != "function") continue;
-    const i = (o) => {
-      ve(
+    const i = (r) => {
+      Re(
         () => s.call(
           n.el,
-          l.Event(o.type, { originalEvent: o })
+          l.Event(r.type, { originalEvent: r })
         )
       );
     };
@@ -1453,327 +1562,360 @@ l.fn.atomBind = function(n) {
       el: e,
       trackCleanup: (i) => y.trackCleanup(e, i)
     };
-    n.text !== void 0 && It(s, n.text), n.html !== void 0 && Ct(s, n.html), n.class && St(s, n.class), n.css && Dt(s, n.css), n.attr && Tt(s, n.attr), n.prop && vt(s, n.prop), n.show !== void 0 && kt(s, n.show), n.hide !== void 0 && Ot(s, n.hide), n.val !== void 0 && Nt(s, n.val), n.checked !== void 0 && At(s, n.checked), n.on && wt(s, n.on);
+    n.text !== void 0 && wt(s, n.text), n.html !== void 0 && Rt(s, n.html), n.class && Nt(s, n.class), n.css && At(s, n.css), n.attr && Lt(s, n.attr), n.prop && Ut(s, n.prop), n.show !== void 0 && Pt(s, n.show), n.hide !== void 0 && Ft(s, n.hide), n.val !== void 0 && $t(s, n.val), n.checked !== void 0 && Mt(s, n.checked), n.on && Bt(s, n.on);
   });
 };
 l.fn.atomList = function(n, e) {
-  const { key: t, render: s, bind: i, update: o, onAdd: r, onRemove: c, empty: a } = e, f = typeof t == "function" ? t : (p, D) => p[t];
+  const { key: t, render: s, bind: i, update: r, onAdd: o, onRemove: c, empty: a } = e, _ = typeof t == "function" ? t : (g, v) => g[t];
   return this.each(function() {
-    const p = l(this), D = pe(this), I = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Set();
-    let w = [], $ = null;
-    const N = j(() => {
-      const A = n.value, R = A.length;
-      if (R === 0 ? a && !$ && ($ = l(a).appendTo(p)) : $ && ($.remove(), $ = null), R === 0 && I.size === 0) {
-        w = [];
+    const g = l(this), v = be(this), I = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Set();
+    let N = [], $ = null;
+    const w = B(() => {
+      const R = n.value, A = R.length;
+      if (A === 0) {
+        if (a && !$) {
+          const u = typeof a == "string" ? se(a) : a;
+          $ = l(u).appendTo(g);
+        }
+      } else $ && ($.remove(), $ = null);
+      if (A === 0 && I.size === 0) {
+        N = [];
         return;
       }
-      m.log("list", `${D} updating with ${R} items`);
-      const x = /* @__PURE__ */ new Map(), K = w.length;
+      b.log("list", `${v} updating with ${A} items`);
+      const x = /* @__PURE__ */ new Map(), K = N.length;
       for (let u = 0; u < K; u++)
-        x.set(w[u], u);
-      const U = new Array(R), J = /* @__PURE__ */ new Set(), re = new Int32Array(R);
-      for (let u = 0; u < R; u++) {
-        const E = A[u], _ = f(E, u);
-        m.enabled && J.has(_) && console.warn(`[atomList] Duplicate key "${_}" at index ${u}.`), U[u] = _, J.add(_), re[u] = x.get(_) ?? -1;
+        x.set(N[u], u);
+      const U = new Array(A), J = /* @__PURE__ */ new Set(), ae = new Int32Array(A);
+      for (let u = 0; u < A; u++) {
+        const E = R[u], f = _(E, u);
+        J.has(f) && console.warn(`[atomList] Duplicate key "${f}" at index ${u}.`), U[u] = f, J.add(f), ae[u] = x.get(f) ?? -1;
       }
       if (I.size > 0)
         for (const [u, E] of I) {
           if (J.has(u) || O.has(u)) continue;
-          const _ = () => {
-            E.$el.remove(), E.$el[0] && y.cleanup(E.$el[0]), O.delete(u), m.log("list", `${D} removed item:`, u);
+          const f = () => {
+            E.$el.remove(), E.$el[0] && y.cleanup(E.$el[0]), O.delete(u), b.log("list", `${v} removed item:`, u);
           };
           if (I.delete(u), O.add(u), c) {
-            const g = c(E.$el);
-            g instanceof Promise ? g.then(_) : _();
+            const p = c(E.$el);
+            p instanceof Promise ? p.then(f) : f();
           } else
-            _();
+            f();
         }
-      if (R === 0) {
-        w = [];
+      if (A === 0) {
+        N = [];
         return;
       }
-      const ne = dt(re);
-      let se = ne.length - 1, h = null;
-      for (let u = R - 1; u >= 0; u--) {
-        const E = U[u], _ = A[u], g = I.get(E);
-        if (g) {
-          const C = g.item;
-          g.item = _;
-          const b = g.$el[0];
-          if (!b) continue;
-          if (o)
-            o(g.$el, _, u), m.domUpdated(g.$el, "list.update", _);
-          else if (C !== _) {
-            let V = !0;
-            if (typeof C == "object" && C !== null && typeof _ == "object" && _ !== null) {
-              V = !1;
-              let B = 0;
-              const ce = C, Oe = _;
-              for (const Z in ce) {
-                if (ce[Z] !== Oe[Z]) {
-                  V = !0;
+      const te = Ct(ae);
+      let ne = te.length - 1, h = null;
+      for (let u = A - 1; u >= 0; u--) {
+        const E = U[u], f = R[u], p = I.get(E);
+        if (p) {
+          const S = p.item;
+          p.item = f;
+          const C = p.$el[0];
+          if (!C) continue;
+          if (r)
+            r(p.$el, f, u), b.domUpdated(p.$el, "list.update", f);
+          else if (S !== f) {
+            let m = !0;
+            if (typeof S == "object" && S !== null && typeof f == "object" && f !== null) {
+              m = !1;
+              let G = 0;
+              const ue = S, V = f;
+              for (const H in ue) {
+                if (ue[H] !== V[H]) {
+                  m = !0;
                   break;
                 }
-                B++;
+                G++;
               }
-              if (!V) {
-                let Z = 0;
-                for (const xt in Oe)
-                  if (Z++, Z > B) {
-                    V = !0;
+              if (!m) {
+                let H = 0;
+                for (const Ht in V)
+                  if (H++, H > G) {
+                    m = !0;
                     break;
                   }
-                B !== Z && (V = !0);
+                G !== H && (m = !0);
               }
             }
-            if (V) {
-              const B = l(s(_, u)), ce = h === b;
-              g.$el.replaceWith(B), g.$el = B, i && i(B, _, u), m.domUpdated(B, "list.render", _), ce && (h = B[0] || null);
+            if (m) {
+              const G = s(f, u), ue = typeof G == "string" ? se(G) : G, V = l(ue), H = h === C;
+              p.$el.replaceWith(V), p.$el = V, i && i(V, f, u), b.domUpdated(V, "list.render", f), H && (h = V[0] || null);
             }
           }
-          if (se >= 0 && ne[se] === u)
-            se--;
+          if (ne >= 0 && te[ne] === u)
+            ne--;
           else {
-            const V = g.$el[0];
-            h?.isConnected ? h !== V && g.$el.insertBefore(h) : g.$el.appendTo(p);
+            const m = p.$el[0];
+            h?.isConnected ? h !== m && p.$el.insertBefore(h) : p.$el.appendTo(g);
           }
-          h = g.$el[0] || null;
+          h = p.$el[0] || null;
         } else {
-          const C = s(_, u), b = l(C);
-          I.set(E, { $el: b, item: _ }), h?.isConnected ? b.insertBefore(h) : b.appendTo(p), i && i(b, _, u), r && r(b), m.domUpdated(b, "list.add", _), h = b[0] || null;
+          const S = s(f, u), C = typeof S == "string" ? se(S) : S, m = l(C);
+          I.set(E, { $el: m, item: f }), h?.isConnected ? m.insertBefore(h) : m.appendTo(g), i && i(m, f, u), o && o(m), b.domUpdated(m, "list.add", f), h = m[0] || null;
         }
       }
-      w = U;
+      N = U;
     });
-    y.trackEffect(this, N), y.trackCleanup(this, () => {
-      I.clear(), O.clear(), w = [], $?.remove();
+    y.trackEffect(this, w), y.trackCleanup(this, () => {
+      I.clear(), O.clear(), N = [], $?.remove();
     });
   });
 };
-const he = /* @__PURE__ */ new WeakMap();
+const pe = /* @__PURE__ */ new WeakMap();
 l.fn.atomMount = function(n, e = {}) {
   return this.each(function() {
-    const t = m.enabled, s = t ? pe(this) : "", i = he.get(this);
-    i && (t && m.log("mount", `${s} unmounting existing component`), i()), t && m.log("mount", `${s} mounting component`);
-    let o;
+    const t = b.enabled, s = t ? be(this) : "", i = pe.get(this);
+    i && (t && b.log("mount", `${s} unmounting existing component`), i()), t && b.log("mount", `${s} mounting component`);
+    let r;
     try {
-      o = n(l(this), e);
+      r = n(l(this), e);
     } catch (c) {
       console.error("[atom-effect-jquery] Mount error:", c);
       return;
     }
-    const r = () => {
-      if (he.delete(this)) {
-        if (t && m.log("mount", `${s} full cleanup`), typeof o == "function")
+    const o = () => {
+      if (pe.delete(this)) {
+        if (t && b.log("mount", `${s} full cleanup`), typeof r == "function")
           try {
-            o();
+            r();
           } catch (c) {
             console.error("[atom-effect-jquery] Cleanup error:", c);
           }
         y.cleanupTree(this);
       }
     };
-    he.set(this, r), y.trackCleanup(this, r);
+    pe.set(this, o), y.trackCleanup(this, o);
   });
 };
 l.fn.atomUnmount = function() {
   return this.each(function() {
-    const n = he.get(this);
+    const n = pe.get(this);
     n && n();
   });
 };
-const ye = "[$.route]";
-function Rt(n) {
+const fe = "[$.route]";
+function Vt(n) {
   const {
     target: e,
     default: t,
     routes: s,
     notFound: i,
-    autoBindLinks: o = !1,
-    activeClass: r = "active",
+    autoBindLinks: r = !1,
+    activeClass: o = "active",
     beforeTransition: c,
     afterTransition: a
   } = n;
-  let f = !1, p = null, D = window.location.hash;
-  const I = [], O = /* @__PURE__ */ new Set(), w = l(e), $ = () => {
+  let _ = !1, g = null, v = window.location.hash;
+  const I = [], O = /* @__PURE__ */ new Set(), N = l(e), $ = () => {
     const h = window.location.hash, u = h.indexOf("?");
     return (u === -1 ? h.substring(1) : h.substring(1, u)) || t;
-  }, N = (h) => {
+  }, w = (h) => {
     const u = h.indexOf("?");
     if (u === -1) return {};
-    const E = {}, _ = h.length;
-    let g = u + 1;
-    for (; g < _; ) {
-      let C = h.indexOf("&", g);
-      if (C === -1 && (C = _), C > g) {
-        const b = h.indexOf("=", g);
-        b !== -1 && b < C ? E[decodeURIComponent(h.substring(g, b))] = decodeURIComponent(
-          h.substring(b + 1, C)
-        ) : E[decodeURIComponent(h.substring(g, C))] = "";
+    const E = {}, f = h.length;
+    let p = u + 1;
+    const S = (C) => {
+      try {
+        return decodeURIComponent(C);
+      } catch {
+        return console.warn(`${fe} Malformed URI component: ${C}`), C;
       }
-      g = C + 1;
+    };
+    for (; p < f; ) {
+      let C = h.indexOf("&", p);
+      if (C === -1 && (C = f), C > p) {
+        const m = h.indexOf("=", p);
+        m !== -1 && m < C ? E[S(h.substring(p, m))] = S(
+          h.substring(m + 1, C)
+        ) : E[S(h.substring(p, C))] = "";
+      }
+      p = C + 1;
     }
     return E;
-  }, A = (h) => {
-    let u = s[h];
-    return !u && i && (u = s[i]), u || (console.warn(`${ye} Route "${h}" not found and no notFound route configured`), null);
   }, R = (h) => {
+    let u = s[h];
+    return !u && i && (u = s[i]), u || (console.warn(`${fe} Route "${h}" not found and no notFound route configured`), null);
+  }, A = (h) => {
     const u = document.querySelector(h);
     if (!u?.content)
-      return console.warn(`${ye} Template "${h}" not found`), !1;
+      return console.warn(`${fe} Template "${h}" not found`), !1;
     const E = u.content.cloneNode(!0);
-    return w.append(E), !0;
-  }, x = qe($()), K = (h) => {
-    if (f) return;
-    const u = w[0];
+    return N.append(E), !0;
+  }, x = Xe($()), K = (h) => {
+    if (_) return;
+    const u = N[0];
     if (!u) {
-      console.warn(`${ye} Target element "${e}" not found`);
+      console.warn(`${fe} Target element "${e}" not found`);
       return;
     }
-    const E = A(h);
+    const E = R(h);
     if (!E) return;
-    const _ = N(window.location.hash);
-    c && c(p || h, h), w.empty();
-    let g = _;
+    const f = w(window.location.hash);
+    c && c(g || h, h), N.empty();
+    let p = f;
     if (E.onEnter) {
-      const C = E.onEnter(_);
-      C !== void 0 && (g = { ..._, ...C });
+      const S = E.onEnter(f);
+      S !== void 0 && (p = { ...f, ...S });
     }
-    E.render ? E.render(u, h, g) : E.template && R(E.template), a && a(p || h, h), p = h;
+    E.render ? E.render(u, h, p) : E.template && A(E.template), a && a(g || h, h), g = h;
   }, U = (h) => {
-    if (f) return;
+    if (_) return;
     const u = x.value, E = s[u];
-    E?.onLeave && E.onLeave() === !1 || (D = `#${h}`, window.location.hash = D, x.value = h);
+    E?.onLeave && E.onLeave() === !1 || (v = `#${h}`, window.location.hash = v, x.value = h);
   }, J = () => {
-    if (f) return;
+    if (_) return;
     const h = window.location.hash;
-    if (h === D) return;
+    if (h === v) return;
     const u = $(), E = x.value;
     if (E !== u) {
-      const _ = s[E];
-      if (_?.onLeave && _.onLeave() === !1) {
-        window.location.hash = D;
+      const f = s[E];
+      if (f?.onLeave && f.onLeave() === !1) {
+        window.location.hash = v;
         return;
       }
       x.value = u;
     } else
       K(u);
-    D = h;
-  }, re = () => {
-    if (!o) return;
-    l("[data-route]").each(function() {
-      const u = this, E = l(u), _ = E.data("route");
-      O.add(u);
-      const g = (b) => {
-        b.preventDefault(), U(_);
-      };
-      E.on("click", g), y.trackCleanup(u, () => {
-        E.off("click", g), O.delete(u);
+    v = h;
+  }, ae = () => {
+    if (!r) return;
+    const h = (f) => {
+      f.preventDefault();
+      const p = l(f.currentTarget).data("route");
+      U(p);
+    };
+    l(document).on("click", "[data-route]", h), I.push(() => {
+      l(document).off("click", "[data-route]", h);
+    });
+    const u = (f) => {
+      if (O.has(f)) return;
+      const p = l(f), S = p.data("route");
+      O.add(f);
+      const C = B(() => {
+        const m = x.value === S;
+        p.toggleClass(o, m), m ? p.attr("aria-current", "page") : p.removeAttr("aria-current");
       });
-      const C = j(() => {
-        const b = x.value === _;
-        E.toggleClass(r, b), b ? E.attr("aria-current", "page") : E.removeAttr("aria-current");
+      y.trackEffect(f, C), y.trackCleanup(f, () => {
+        O.delete(f);
       });
-      y.trackEffect(u, C);
+    };
+    l("[data-route]").each(function() {
+      u(this);
+    });
+    const E = new MutationObserver((f) => {
+      for (const p of f)
+        p.type === "childList" && p.addedNodes.forEach((S) => {
+          if (S.nodeType === 1) {
+            const C = S;
+            C.matches?.("[data-route]") && u(C), C.querySelectorAll && C.querySelectorAll("[data-route]").forEach(
+              (m) => u(m)
+            );
+          }
+        });
     });
-  }, ne = () => {
-    f || (f = !0, I.forEach((h) => h()), I.length = 0, O.forEach((h) => y.cleanup(h)), O.clear());
+    E.observe(document.body, { childList: !0, subtree: !0 }), I.push(() => E.disconnect());
+  }, te = () => {
+    _ || (_ = !0, I.forEach((h) => h()), I.length = 0, O.forEach((h) => y.cleanup(h)), O.clear());
   };
   window.addEventListener("hashchange", J), I.push(() => window.removeEventListener("hashchange", J));
-  const se = j(() => {
+  const ne = B(() => {
     K(x.value);
   });
-  return I.push(() => se.dispose()), re(), w[0] && y.trackCleanup(w[0], ne), {
+  return I.push(() => ne.dispose()), ae(), N[0] && y.trackCleanup(N[0], te), {
     currentRoute: x,
     navigate: U,
-    destroy: ne
+    destroy: te
   };
 }
 l.extend({
-  route: Rt
+  route: Vt
 });
-const de = /* @__PURE__ */ new WeakMap();
-let $e = !1;
-const Me = (n) => {
-  let e = de.get(n);
+const ge = /* @__PURE__ */ new WeakMap();
+let Me = !1;
+const Be = (n) => {
+  let e = ge.get(n);
   return e || (e = function(...t) {
-    return ve(() => n.apply(this, t));
-  }, de.set(n, e)), e;
+    return Re(() => n.apply(this, t));
+  }, ge.set(n, e)), e;
 };
-function Ke() {
-  if ($e) return;
-  $e = !0;
+function Ze() {
+  if (Me) return;
+  Me = !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) {
-    const r = o ? this.filter(o) : this;
-    for (let c = 0, a = r.length; c < a; c++) {
-      const f = r[c];
-      f && (y.cleanupTree(f), y.markIgnored(f));
+  l.fn.remove = function(r) {
+    const o = r ? this.filter(r) : this;
+    for (let c = 0, a = o.length; c < a; c++) {
+      const _ = o[c];
+      _ && (y.cleanupTree(_), y.markIgnored(_));
     }
-    return t.call(this, o);
+    return t.call(this, r);
   }, l.fn.empty = function() {
-    for (let o = 0, r = this.length; o < r; o++) {
-      const c = this[o];
+    for (let r = 0, o = this.length; r < o; r++) {
+      const c = this[r];
       c && y.cleanupDescendants(c);
     }
     return s.call(this);
-  }, l.fn.detach = function(o) {
-    const r = o ? this.filter(o) : this;
-    for (let c = 0, a = r.length; c < a; c++) {
-      const f = r[c];
-      f && y.keep(f);
+  }, l.fn.detach = function(r) {
+    const o = r ? this.filter(r) : this;
+    for (let c = 0, a = o.length; c < a; c++) {
+      const _ = o[c];
+      _ && y.keep(_);
     }
-    return i.call(this, o);
-  }, l.fn.on = function(...o) {
-    const r = o[0];
-    if (r && typeof r == "object") {
-      const c = r, a = {};
-      for (const f in c) {
-        const p = c[f];
-        p && (a[f] = Me(p));
+    return i.call(this, r);
+  }, l.fn.on = function(...r) {
+    const o = r[0];
+    if (o && typeof o == "object") {
+      const c = o, a = {};
+      for (const _ in c) {
+        const g = c[_];
+        g && (a[_] = Be(g));
       }
-      o[0] = a;
+      r[0] = a;
     } else
-      for (let c = o.length - 1; c >= 0; c--)
-        if (typeof o[c] == "function") {
-          o[c] = Me(o[c]);
+      for (let c = r.length - 1; c >= 0; c--)
+        if (typeof r[c] == "function") {
+          r[c] = Be(r[c]);
           break;
         }
-    return n.apply(this, o);
-  }, l.fn.off = function(...o) {
-    const r = o[0];
-    if (r && typeof r == "object") {
-      const c = r, a = {};
-      for (const f in c) {
-        const p = c[f];
-        p && (a[f] = de.get(p) || p);
+    return n.apply(this, r);
+  }, l.fn.off = function(...r) {
+    const o = r[0];
+    if (o && typeof o == "object") {
+      const c = o, a = {};
+      for (const _ in c) {
+        const g = c[_];
+        g && (a[_] = ge.get(g) || g);
       }
-      o[0] = a;
+      r[0] = a;
     } else
-      for (let c = o.length - 1; c >= 0; c--)
-        if (typeof o[c] == "function") {
-          o[c] = de.get(o[c]) || o[c];
+      for (let c = r.length - 1; c >= 0; c--)
+        if (typeof r[c] == "function") {
+          r[c] = ge.get(r[c]) || r[c];
           break;
         }
-    return e.apply(this, o);
+    return e.apply(this, r);
   };
 }
-const Pt = Ke;
-Ke();
+const qt = Ze;
+Ze();
 l(() => {
-  yt(document.body);
+  kt(document.body);
 });
 export {
-  qe as atom,
-  ve as batch,
-  at as computed,
-  Mt as default,
-  Ut as disableAutoCleanup,
-  j as effect,
-  yt as enableAutoCleanup,
-  Pt as enablejQueryBatching,
-  Ke as enablejQueryOverrides,
+  Xe as atom,
+  Re as batch,
+  Et as computed,
+  Qt as default,
+  zt as disableAutoCleanup,
+  B as effect,
+  kt as enableAutoCleanup,
+  qt as enablejQueryBatching,
+  Ze as enablejQueryOverrides,
   y as registry,
-  ct as untracked
+  ht as untracked
 };
 //# sourceMappingURL=index.mjs.map