@but212/atom-effect-jquery 0.17.0 → 0.19.0

package/dist/index.mjs

@@ -1,21 +1,19 @@
 import u from "jquery";
-import { default as Me } from "jquery";
-const Wt = {
+import { default as Vt } from "jquery";
+const Je = {
   ONE_SECOND_MS: 1e3
-}, ht = {
+}, Ee = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, F = {
-  DISPOSED: 1,
-  HAS_FN_SUBS: 2,
-  HAS_OBJ_SUBS: 4
-}, k = {
-  ...F,
+}, ve = {
+  DISPOSED: 1
+}, P = {
+  ...ve,
   EXECUTING: 8
-}, h = {
-  ...F,
+}, d = {
+  ...ve,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -23,11 +21,11 @@ const Wt = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, R = {
-  ...F,
+}, H = {
+  ...ve,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, $ = {
+}, q = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
@@ -36,118 +34,116 @@ const Wt = {
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, kt = {
-  MAX_DEPENDENCIES: 1e3,
+}, Ze = {
   WARN_INFINITE_LOOP: !0
-}, 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";
+}, ie = 1073741823, A = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, et = 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 B extends Z {
-  constructor(t, e = null) {
-    super(t, e, !0), this.name = "ComputedError";
+class z extends ee {
+  constructor(e, t = null) {
+    super(e, t, !0), this.name = "ComputedError";
   }
 }
-class q extends Z {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "EffectError";
+class G extends ee {
+  constructor(e, t = null) {
+    super(e, t, !1), this.name = "EffectError";
   }
 }
-class it extends Z {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "SchedulerError";
+class ae extends ee {
+  constructor(e, t = null) {
+    super(e, t, !1), this.name = "SchedulerError";
   }
 }
-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(
+const Ne = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), tt = /* @__PURE__ */ Symbol("AtomEffect.Id"), Re = /* @__PURE__ */ Symbol("AtomEffect.Type"), ye = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), nt = (n) => "dependencies" in n && Array.isArray(n.dependencies);
+function Me(n, e, t) {
+  if (n === e)
+    throw new z(
       "Circular dependency detected: The computation refers to itself explicitly or implicitly."
     );
-  if (!e.has(n.id) && (e.add(n.id), te(n))) {
+  if (!t.has(n.id) && (t.add(n.id), nt(n))) {
     const s = n.dependencies;
     for (let i = 0; i < s.length; i++) {
       const o = s[i];
-      o && Bt(o, t, e);
+      o && Me(o, e, t);
     }
   }
 }
-const X = {
+const Y = {
   // 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}`);
+  enabled: A,
+  warnInfiniteLoop: Ze.WARN_INFINITE_LOOP,
+  warn(n, e) {
+    A && this.enabled && n && console.warn(`[Atom Effect] ${e}`);
   },
-  checkCircular(n, t) {
-    if (n === t)
-      throw new B("Direct circular dependency detected");
-    m && this.enabled && Bt(n, t, /* @__PURE__ */ new Set());
+  checkCircular(n, e) {
+    if (n === e)
+      throw new z("Direct circular dependency detected");
+    A && this.enabled && Me(n, e, /* @__PURE__ */ new Set());
   },
-  attachDebugInfo(n, t, e) {
-    if (!m || !this.enabled) return;
+  attachDebugInfo(n, e, t) {
+    if (!A || !this.enabled) return;
     const s = n;
-    s[At] = `${t}_${e}`, s[Zt] = e, s[vt] = t;
+    s[Ne] = `${e}_${t}`, s[tt] = t, s[Re] = e;
   },
-  getDebugName: (n) => n?.[At],
-  getDebugType: (n) => n?.[vt]
+  getDebugName: (n) => n?.[Ne],
+  getDebugType: (n) => n?.[Re]
 };
-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];
+let st = 1;
+const it = () => st++;
+function Be(n, e, t) {
+  if (typeof e == "function") {
+    const i = e;
+    for (let o = 0, r = t.length; o < r; o++) {
+      const c = t[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++;
+    t.push(new Ce(i, void 0));
     return;
   }
-  if ("addDependency" in t) {
-    t.addDependency(n);
+  if ("addDependency" in e) {
+    e.addDependency(n);
     return;
   }
-  const s = t;
-  for (let i = 0, o = e.length; i < o; i++) {
-    const r = e[i];
+  const s = e;
+  for (let i = 0, o = t.length; i < o; i++) {
+    const r = t[i];
     if (r && r.sub === s) return;
   }
-  e.push(new St(void 0, s)), n.flags |= F.HAS_OBJ_SUBS, "_objSubCount" in n && n._objSubCount++;
+  t.push(new Ce(void 0, s));
 }
-function se(n, t, e) {
-  for (let s = 0, i = t.length; s < i; s++) {
-    const o = t[s];
+function ot(n, e, t) {
+  for (let s = 0, i = e.length; s < i; s++) {
+    const o = e[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));
+    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 = t.length; s < i; s++) {
-    const o = t[s];
+  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;
     }
   }
 }
-class mt {
-  constructor(t, e, s = void 0) {
-    this.node = t, this.version = e, this.unsub = s;
+class he {
+  constructor(e, t, s = void 0) {
+    this.node = e, this.version = t, this.unsub = s;
   }
 }
-class St {
-  constructor(t, e) {
-    this.fn = t, this.sub = e;
+class Ce {
+  constructor(e, t) {
+    this.fn = e, this.sub = t;
   }
 }
-const S = {
+const D = {
   // Computed Errors
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
@@ -163,85 +159,87 @@ const S = {
   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 K(n, t, e) {
-  if (n instanceof Z)
+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} (${e}): ${i}`;
-  return new t(c, o);
+  const c = `${r} (${t}): ${i}`;
+  return new e(c, o);
 }
-class jt {
+class je {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = ne() & G, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = it() & ie, this._tempUnsub = void 0;
   }
 }
-class Ht extends jt {
-  constructor() {
-    super(...arguments), this._fnSubCount = 0, this._objSubCount = 0;
-  }
+class Ve extends je {
   /**
    * Adds subscriber.
    */
-  subscribe(t) {
-    const e = typeof t == "function";
-    if (!e && (!t || typeof t.execute != "function"))
-      throw K(
+  subscribe(e) {
+    const t = typeof e == "function";
+    if (!t && (!e || typeof e.execute != "function"))
+      throw Z(
         new TypeError("Invalid subscriber"),
-        Z,
-        S.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        ee,
+        D.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."), () => {
+      if (c && (t ? c.fn === e : c.sub === e))
+        return A && console.warn("Duplicate subscription ignored."), () => {
         };
     }
-    const i = new St(
-      e ? t : void 0,
-      e ? void 0 : t
+    const i = new Ce(
+      t ? e : void 0,
+      t ? void 0 : e
     );
-    return s.push(i), e ? (this._fnSubCount++, this.flags |= F.HAS_FN_SUBS) : (this._objSubCount++, this.flags |= F.HAS_OBJ_SUBS), () => this._unsubscribe(i);
+    return s.push(i), () => this._unsubscribe(i);
   }
-  _unsubscribe(t) {
-    const e = this._subscribers, s = e.indexOf(t);
+  _unsubscribe(e) {
+    const t = this._subscribers, s = t.indexOf(e);
     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 i = t.pop();
+    s < t.length && i && (t[s] = i);
   }
   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;
+  _notifySubscribers(e, t) {
+    if (this._subscribers.length === 0) return;
+    const s = this._subscribers.slice(0), 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();
+          r.fn ? r.fn(e, t) : r.sub && r.sub.execute();
         } catch (c) {
           this._handleNotifyError(c);
         }
     }
   }
-  _handleNotifyError(t) {
-    console.error(K(t, Z, S.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+  _handleNotifyError(e) {
+    console.error(Z(e, ee, D.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-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);
+let fe = 0;
+const He = () => (fe = fe + 1 & ie || 1, fe), rt = () => fe, Ie = (n) => n + 1 & ie;
+let Se = 0, Te = 0, _e = !1;
+function xe() {
+  return _e ? (A && console.warn("startFlush() called during flush - ignored"), !1) : (_e = !0, Se = Se + 1 & ie || 1, Te = 0, !0);
 }
-const Rt = () => {
-  ut = !1;
-}, oe = () => ut ? ++Ct : 0, A = {
+const Ae = () => {
+  _e = !1;
+}, ct = () => _e ? ++Te : 0, $ = {
   /** Queue buffer */
   _queueBuffer: [[], []],
   _bufferIndex: 0,
@@ -257,7 +255,7 @@ const Rt = () => {
   _batchQueue: [],
   _batchQueueSize: 0,
   /** Config */
-  _maxFlushIterations: $.MAX_FLUSH_ITERATIONS,
+  _maxFlushIterations: q.MAX_FLUSH_ITERATIONS,
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
   },
@@ -271,8 +269,8 @@ const Rt = () => {
    * Schedules job.
    */
   schedule(n) {
-    if (m && typeof n != "function")
-      throw new it("Scheduler callback must be a function");
+    if (A && typeof n != "function")
+      throw new ae("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;
@@ -292,31 +290,31 @@ const Rt = () => {
    */
   _runLoop: () => {
     try {
-      if (A._size === 0) return;
-      const n = Ut();
-      A._drainQueue(), n && Rt();
+      if ($._size === 0) return;
+      const n = xe();
+      $._drainQueue(), n && Ae();
     } finally {
-      A._isProcessing = !1, A._size > 0 && !A._isBatching && A._flush();
+      $._isProcessing = !1, $._size > 0 && !$._isBatching && $._flush();
     }
   },
   _flushSync() {
     this._isFlushingSync = !0;
-    const n = Ut();
+    const n = xe();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, n && Rt();
+      this._isFlushingSync = !1, n && Ae();
     }
   },
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const n = ++this._epoch, t = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
+    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 = t[i];
-      o._nextEpoch !== n && (o._nextEpoch = n, e[s++] = o);
+      const o = e[i];
+      o._nextEpoch !== n && (o._nextEpoch = n, t[s++] = o);
     }
-    this._size = s, this._batchQueueSize = 0, t.length > $.BATCH_QUEUE_SHRINK_THRESHOLD && (t.length = 0);
+    this._size = s, this._batchQueueSize = 0, e.length > q.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
   },
   _drainQueue() {
     let n = 0;
@@ -329,41 +327,48 @@ const Rt = () => {
     }
   },
   _processQueue() {
-    const n = this._bufferIndex, t = this._queueBuffer[n], e = this._size;
+    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 < e; s++)
+    for (let s = 0; s < t; s++)
       try {
-        t[s]();
+        e[s]();
       } catch (i) {
-        console.error(new it("Error occurred during scheduler execution", i));
+        console.error(new ae("Error occurred during scheduler execution", i));
       }
-    t.length = 0;
+    e.length = 0;
   },
+  /** Overflow callback */
+  onOverflow: null,
   _handleFlushOverflow() {
-    console.error(
-      new it(
-        `Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`
+    const n = this._size + this._batchQueueSize;
+    if (console.error(
+      new ae(
+        D.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, n)
       )
-    ), 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(n);
+      } catch {
+      }
   },
   startBatch() {
     this._batchDepth++, this._isBatching = !0;
   },
   endBatch() {
     if (this._batchDepth === 0) {
-      m && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      A && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
     --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}`
+    if (n < q.MIN_FLUSH_ITERATIONS)
+      throw new ae(
+        `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
       );
     this._maxFlushIterations = n;
   }
-}, Q = {
+}, B = {
   /** Active listener. */
   current: null,
   /**
@@ -373,75 +378,75 @@ const Rt = () => {
    * @param fn - The logic to execute.
    * @returns The result of `fn`.
    */
-  run(n, t) {
-    const e = this.current;
+  run(n, e) {
+    const t = this.current;
     this.current = n;
     try {
-      return t();
+      return e();
     } finally {
-      this.current = e;
+      this.current = t;
     }
   }
 };
-function zt(n) {
-  const t = Q.current;
-  if (t === null) return n();
-  Q.current = null;
+function at(n) {
+  const e = B.current;
+  if (e === null) return n();
+  B.current = null;
   try {
     return n();
   } finally {
-    Q.current = t;
+    B.current = e;
   }
 }
-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);
+class ut extends Ve {
+  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);
   }
   get value() {
-    const t = Q.current;
-    return t && $t(this, t, this._subscribers), this._value;
+    const e = B.current;
+    return e && Be(this, e, 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;
+  set value(e) {
+    const t = this._value;
+    if (Object.is(t, e)) return;
+    this._value = e, this.version = Ie(this.version);
     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) {
+    if (!(this._subscribers.length === 0 || s & H.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = t, this.flags = s | H.NOTIFICATION_SCHEDULED, s & H.SYNC && !$.isBatching) {
         this._flushNotifications();
         return;
       }
-      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), A.schedule(this._notifyTask);
+      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), $.schedule(this._notifyTask);
     }
   }
   /**
    * Triggers subscribers.
    */
   _flushNotifications() {
-    const t = this.flags;
-    if (!(t & R.NOTIFICATION_SCHEDULED) || t & R.DISPOSED)
+    const e = this.flags;
+    if (!(e & H.NOTIFICATION_SCHEDULED) || e & H.DISPOSED)
       return;
-    const e = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
+    const t = this._pendingOldValue;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, t);
   }
   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);
+    this.flags & H.DISPOSED || (this._subscribers.length = 0, this.flags |= H.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function ue(n, t = {}) {
-  return new ce(n, t.sync ?? !1);
+function ze(n, e = {}) {
+  return new ut(n, e.sync ?? !1);
 }
-class le {
+class lt {
   /**
    * @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(t = 50, e = 256) {
-    this.limit = t, this.capacity = e, this.pool = [], this.stats = m ? {
+  constructor(e = 50, t = 256, s = !1) {
+    this.limit = e, this.capacity = t, this.pool = [], this.stats = null, this.stats = A || s ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -451,7 +456,7 @@ class le {
    * Acquires array.
    */
   acquire() {
-    return m && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases array.
@@ -459,32 +464,32 @@ class le {
    * @param arr - Array to release.
    * @param emptyConst - Optional empty constant.
    */
-  release(t, e) {
-    if (!(e && t === e)) {
-      if (t.length > this.capacity) {
-        m && this.stats && this.stats.rejected.tooLarge++;
+  release(e, t) {
+    if (!(t && e === t)) {
+      if (e.length > this.capacity) {
+        this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.limit) {
-        m && this.stats && this.stats.rejected.poolFull++;
+        this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      if (Object.isFrozen(t)) {
-        m && this.stats && this.stats.rejected.frozen++;
+      if (Object.isFrozen(e)) {
+        this.stats && this.stats.rejected.frozen++;
         return;
       }
-      t.length = 0, this.pool.push(t), m && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), this.stats && this.stats.released++;
     }
   }
   /**
    * Pool stats.
    */
   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);
+    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: t,
-      released: e,
+      acquired: e,
+      released: t,
       rejected: { ...s },
       leaked: i,
       poolSize: this.pool.length
@@ -494,68 +499,68 @@ class le {
    * Resets pool.
    */
   reset() {
-    this.pool.length = 0, m && this.stats && (this.stats = {
+    this.pool.length = 0, this.stats && (this.stats = {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
     });
   }
 }
-const tt = (n) => Object.freeze(n);
-tt([]);
-tt([]);
-tt([]);
-tt([]);
-const T = tt([]);
-tt([]);
-const j = new le();
-function yt(n) {
+const oe = (n) => Object.freeze(n);
+oe([]);
+oe([]);
+oe([]);
+oe([]);
+const U = oe([]), X = new lt();
+function De(n) {
   return n !== null && typeof n == "object" && "value" in n && typeof n.subscribe == "function";
 }
-function wt(n) {
-  return yt(n) && typeof n.invalidate == "function";
+function Le(n) {
+  return De(n) && typeof n.invalidate == "function";
 }
-function qt(n) {
+function qe(n) {
   return n !== null && typeof n == "object" && typeof n.then == "function";
 }
-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)
+const Xe = d.RESOLVED | d.PENDING | d.REJECTED, ge = Array(Xe + 1).fill(Ee.IDLE);
+ge[d.RESOLVED] = Ee.RESOLVED;
+ge[d.PENDING] = Ee.PENDING;
+ge[d.REJECTED] = Ee.REJECTED;
+const ht = 3, Ue = Number.MAX_SAFE_INTEGER - 1, ft = d.REJECTED | d.HAS_ERROR;
+class Qe extends Ve {
+  constructor(e, t = {}) {
+    if (typeof e != "function") throw new z(D.COMPUTED_MUST_BE_FUNCTION);
+    super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = U, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._errorDepCount = 0, this._trackEpoch = -1, this._trackLinks = U, 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 : ye, this._onError = t.onError ?? null;
+    const s = t.maxAsyncRetries;
+    if (this._maxAsyncRetries = s != null && s >= 0 ? s : ht, Y.attachDebugInfo(this, "computed", this.id), t.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = Q.current;
-    t && $t(this, t, this._subscribers);
+    const e = B.current;
+    e && Be(this, e, this._subscribers);
   }
   get value() {
     this._track();
-    const t = this.flags;
-    if ((t & (h.RESOLVED | h.DIRTY | h.IDLE)) === h.RESOLVED)
+    const e = this.flags;
+    if ((e & (d.RESOLVED | d.DIRTY | d.IDLE)) === d.RESOLVED)
       return this._value;
-    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 (e & d.DISPOSED)
+      throw new z(D.COMPUTED_DISPOSED);
+    if (e & d.RECOMPUTING) {
+      if (this._defaultValue !== ye) return this._defaultValue;
+      throw new z(D.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (h.DIRTY | h.IDLE) && (this._recompute(), this.flags & h.RESOLVED))
+    if (e & (d.DIRTY | d.IDLE) && (this._recompute(), this.flags & d.RESOLVED))
       return this._value;
-    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);
+    const t = this._defaultValue, s = t !== ye;
+    if (this.flags & d.PENDING) {
+      if (s) return t;
+      throw new z(D.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & h.REJECTED) {
-      if (this._error?.recoverable && s) return e;
+    if (this.flags & d.REJECTED) {
+      if (this._error?.recoverable && s) return t;
       throw this._error;
     }
     return this._value;
@@ -564,14 +569,14 @@ class Gt extends Ht {
     return this._value;
   }
   get state() {
-    return this._track(), at[this.flags & Xt];
+    return this._track(), ge[this.flags & Xe];
   }
   get hasError() {
-    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;
+    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;
+      if (i && i.flags & d.HAS_ERROR) return !0;
     }
     return !1;
   }
@@ -580,330 +585,349 @@ class Gt extends Ht {
     return !this.hasError;
   }
   get errors() {
-    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);
+    if (this._track(), !this.hasError) return et;
+    const e = rt();
+    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;
-      if (c.flags & h.HAS_ERROR) {
+      if (c.flags & d.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 _ = l.errors;
+          for (let g = 0; g < _.length; g++) {
+            const v = _[g];
+            v && t.indexOf(v) === -1 && t.push(v);
           }
         }
       }
     }
-    const i = Object.freeze(Array.from(e));
-    return this._errorCacheEpoch = t, this._cachedErrors = i, i;
+    const i = Object.freeze(t);
+    return this._errorCacheEpoch = e, this._cachedErrors = i, i;
   }
   get lastError() {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & h.PENDING) !== 0;
+    return this._track(), (this.flags & d.PENDING) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & h.RESOLVED) !== 0;
+    return this._track(), (this.flags & d.RESOLVED) !== 0;
   }
   invalidate() {
     this._markDirty(), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    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;
+    if (this.flags & d.DISPOSED) return;
+    const e = this._links;
+    if (e !== U) {
+      for (let t = 0, s = e.length; t < s; t++)
+        e[t].unsub?.();
+      X.release(e), this._links = U;
     }
-    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;
+    this._subscribers.length = 0, this.flags = d.DISPOSED | d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Ue, 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;
+  addDependency(e) {
+    if (e._lastSeenEpoch !== this._trackEpoch) {
+      if (e._lastSeenEpoch = this._trackEpoch, this._trackCount < this._trackLinks.length) {
+        const t = this._trackLinks[this._trackCount];
+        t.node = e, t.version = e.version;
       } else
-        this._trackLinks.push(new mt(t, t.version));
+        this._trackLinks.push(new he(e, e.version));
       this._trackCount++;
     }
   }
-  _commitDeps(t) {
-    this._trackLinks.length = this._trackCount, se(this._trackLinks, t, this), this._links = this._trackLinks;
+  _commitDeps(e) {
+    this._trackLinks.length = this._trackCount, ot(this._trackLinks, e, this), this._links = this._trackLinks;
   }
-  _recompute() {
-    if (this.flags & h.RECOMPUTING) return;
-    this.flags |= h.RECOMPUTING;
+  _updateErrorDepCount() {
+    let e = 0;
     const t = this._links;
-    this._trackEpoch = Vt(), this._trackLinks = j.acquire(), this._trackCount = 0;
-    let e = !1;
+    for (let s = 0, i = t.length; s < i; s++) {
+      const o = t[s]?.node;
+      o && o.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 = He(), this._trackLinks = X.acquire(), this._trackCount = 0;
+    let t = !1;
     try {
-      const s = Q.run(this, this._fn);
-      this._commitDeps(t), e = !0, qt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+      const s = B.run(this, this._fn);
+      this._commitDeps(e), t = !0, this._updateErrorDepCount(), qe(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
     } catch (s) {
-      if (!e)
+      if (!t)
         try {
-          this._commitDeps(t), e = !0;
-        } catch {
+          this._commitDeps(e), t = !0, this._updateErrorDepCount();
+        } catch (i) {
+          A && console.warn("[atom-effect] _commitDeps failed during error recovery:", i);
         }
-      this._handleError(s, S.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, D.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      e && t !== T ? j.release(t) : e || j.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = T, this._trackCount = 0, this.flags &= -257;
+      t && e !== U ? X.release(e) : t || X.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = U, this._trackCount = 0, this.flags &= -257;
     }
   }
-  _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(
+  _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) % Ue;
+    const t = this._promiseId;
+    e.then(
       (s) => {
-        if (e === this._promiseId) {
+        if (t === 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
+            return this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
+              new z(
+                `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
+              ),
+              D.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
           this._finalizeResolution(s), this._notifySubscribers(s, void 0);
         }
       },
-      (s) => e === this._promiseId && this._handleError(s, S.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (s) => t === this._promiseId && this._handleError(s, D.COMPUTED_ASYNC_COMPUTATION_FAILED)
     );
   }
   _captureVersionSnapshot() {
-    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;
+    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 & ie;
+    return e;
   }
-  _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)
+  _handleError(e, t, s = !1) {
+    const i = Z(e, z, t);
+    if (!s && !(this.flags & d.REJECTED) && (this.version = Ie(this.version)), this._error = i, this.flags = this.flags & -121 | ft, this._onError)
       try {
         this._onError(i);
       } catch (o) {
-        console.error(S.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
+        console.error(D.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
       }
     if (s) throw i;
     this._notifySubscribers(void 0, void 0);
   }
-  _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;
+  _finalizeResolution(e) {
+    (!(this.flags & d.RESOLVED) || !this._equal(this._value, e)) && (this.version = Ie(this.version)), this._value = e, this._error = null, this.flags = (this.flags | d.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    this.flags & (h.RECOMPUTING | h.DIRTY) || (this.flags |= h.DIRTY, this._notifySubscribers(void 0, void 0));
+    this.flags & (d.RECOMPUTING | d.DIRTY) || (this.flags |= d.DIRTY, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Gt.prototype);
-function he(n, t = {}) {
-  return new Gt(n, t);
+Object.freeze(Qe.prototype);
+function dt(n, e = {}) {
+  return new Qe(n, e);
 }
-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);
+class _t extends je {
+  constructor(e, t = {}) {
+    super(), this._cleanup = null, this._links = U, 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;
+    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 = A && s && i > 0 ? new Array(i).fill(0) : null, Y.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & k.DISPOSED)
-      throw new q(S.EFFECT_DISPOSED);
+    if (this.flags & P.DISPOSED)
+      throw new G(D.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    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;
+    this.flags & P.DISPOSED || (this.flags |= P.DISPOSED, this._execCleanup(), this._releaseLinks(this._links), this._links = U, 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 he(e, e.version, e._tempUnsub)), e._tempUnsub = void 0;
       return;
     }
     try {
-      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);
+      const s = e.subscribe(() => {
+        if (this._trackModifications && this.flags & P.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
+        this._executeTask || (this._executeTask = () => this.execute()), $.schedule(this._executeTask);
       });
-      e.push(new mt(t, t.version, s));
+      t.push(new he(e, e.version, s));
     } catch (s) {
-      console.error(K(s, q, S.EFFECT_EXECUTION_FAILED));
+      const i = Z(s, G, D.EFFECT_EXECUTION_FAILED);
+      if (console.error(i), this._onError)
+        try {
+          this._onError(i);
+        } catch {
+        }
+      t.push(new he(e, e.version, void 0));
     }
   }
   /**
    * 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];
+  execute(e = !1) {
+    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 !== U)
+      for (let o = 0, r = t.length; o < r; o++) {
+        const c = t[o];
         c && (c.node._tempUnsub = c.unsub);
       }
-    const s = j.acquire();
-    this._nextLinks = s, this._currentEpoch = Vt();
+    const s = X.acquire();
+    this._nextLinks = s, this._currentEpoch = He();
     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;
+      const o = B.run(this, this._fn);
+      this._links = s, i = !0, this._checkLoopWarnings(), qe(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;
+      this._finalizeDependencies(i, t, s), this.flags &= -9;
     }
   }
-  _handleAsyncResult(t) {
-    const e = ++this._execId;
-    t.then(
+  _handleAsyncResult(e) {
+    const t = ++this._execId;
+    e.then(
       (s) => {
-        if (e !== this._execId || this.flags & k.DISPOSED) {
+        if (t !== this._execId || this.flags & P.DISPOSED) {
           if (typeof s == "function")
             try {
               s();
             } catch (i) {
-              this._handleExecutionError(i, S.EFFECT_CLEANUP_FAILED);
+              this._handleExecutionError(i, D.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
         typeof s == "function" && (this._cleanup = s);
       },
-      (s) => e === this._execId && this._handleExecutionError(s)
+      (s) => t === 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;
+  _finalizeDependencies(e, t, s) {
+    if (this._nextLinks = null, e) {
+      if (t !== U) {
+        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));
         }
-        j.release(e);
+        X.release(t);
       }
-    } 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);
+    } else if (this._releaseLinks(s), X.release(s), t !== U)
+      for (let i = 0, o = t.length; i < o; i++)
+        t[i] && (t[i].node._tempUnsub = void 0);
+  }
+  _releaseLinks(e) {
+    if (e !== U) {
+      for (let t = 0, s = e.length; t < s; t++)
+        e[t]?.unsub?.();
+      X.release(e);
     }
   }
   _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;
+    const e = this._links, t = B.current;
+    B.current = null;
+    try {
+      for (let s = 0, i = e.length; s < i; s++) {
+        const o = e[s], r = o.node;
+        if ("value" in r)
+          try {
+            r.value;
+          } catch {
+            return A && console.warn(`[atom-effect] Dependency #${r.id} threw during dirty check`), !0;
+          }
+        if (r.version !== o.version) return !0;
       }
+      return !1;
+    } finally {
+      B.current = t;
     }
-    return !1;
   }
   _execCleanup() {
     if (this._cleanup) {
       try {
         this._cleanup();
-      } catch (t) {
-        this._handleExecutionError(t, S.EFFECT_CLEANUP_FAILED);
+      } catch (e) {
+        this._handleExecutionError(e, D.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _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 e = Se;
+    if (this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ct() > 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 && 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;
+      if (s > 0 && t - s < Je.ONE_SECOND_MS) {
+        const i = new G(D.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+        if (this.dispose(), this._handleExecutionError(i), A) throw i;
       }
     }
   }
   get isDisposed() {
-    return (this.flags & k.DISPOSED) !== 0;
+    return (this.flags & P.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & k.EXECUTING) !== 0;
+    return (this.flags & P.EXECUTING) !== 0;
   }
-  _throwInfiniteLoopError(t) {
-    const e = new q(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Ct}`
+  _throwInfiniteLoopError(e) {
+    const t = new G(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Te}`
     );
-    throw this.dispose(), console.error(e), e;
+    throw this.dispose(), console.error(t), t;
   }
-  _handleExecutionError(t, e = S.EFFECT_EXECUTION_FAILED) {
-    const s = K(t, q, e);
+  _handleExecutionError(e, t = D.EFFECT_EXECUTION_FAILED) {
+    const s = Z(e, G, t);
     if (console.error(s), this._onError)
       try {
         this._onError(s);
       } catch (i) {
-        console.error(K(i, q, S.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(Z(i, G, D.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
   _checkLoopWarnings() {
-    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].node;
-        o._modifiedAtEpoch === t && X.warn(
+    if (this._trackModifications && Y.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(
           !0,
-          `Effect is reading a dependency (${X.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${Y.getDebugName(o) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function Y(n, t = {}) {
+function V(n, e = {}) {
   if (typeof n != "function")
-    throw new q(S.EFFECT_MUST_BE_FUNCTION);
-  const e = new ae(n, t);
-  return e.execute(), e;
+    throw new G(D.EFFECT_MUST_BE_FUNCTION);
+  const t = new _t(n, e);
+  return t.execute(), t;
 }
-function It(n) {
+function Oe(n) {
   if (typeof n != "function")
     throw new TypeError("Batch callback must be a function");
-  A.startBatch();
+  $.startBatch();
   try {
     return n();
   } finally {
-    A.endBatch();
+    $.endBatch();
   }
 }
-function fe(n) {
+function pt(n) {
   return n !== null && typeof n == "object" && "value" in n && "subscribe" in n;
 }
-function ft(n) {
+function me(n) {
   if (!n) return "unknown";
-  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;
+  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;
   if (i && i.length > 0) {
     let o = s;
     for (let r = 0, c = i.length; r < c; r++) {
@@ -914,36 +938,60 @@ function ft(n) {
   }
   return s;
 }
-function _e(n) {
-  const t = n.length;
-  if (t === 0) return new Int32Array(0);
-  const e = new Int32Array(t), s = new Int32Array(t);
+function Ge(n) {
+  let e = String(n ?? "");
+  if (e = e.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ""), e = e.replace(/<\?[\s\S]*?\?>/g, "").replace(
+    /<(script|iframe|object|embed|base|meta|form|applet|link|style|template|noscript|title)\b[^>]*>([\s\S]*?)<\/\1>/gim,
+    ""
+  ).replace(
+    /<(script|iframe|object|embed|base|meta|form|applet|link|style|template|noscript|title)\b[^>]*\/?>/gim,
+    ""
+  ), ((o) => o.replace(/&#x([0-9a-f]+);?/gi, (r, c) => String.fromCharCode(parseInt(c, 16))).replace(/&#([0-9]+);?/gi, (r, c) => String.fromCharCode(parseInt(c, 10))))(e).match(/(?:java|vb)script:|data:/i)) {
+    const o = (r) => new RegExp(
+      `${r.split("").map((c) => {
+        const l = c.charCodeAt(0);
+        return `(?:${c}|&#0*${l};?|&#x0*${l.toString(16)};?)`;
+      }).join("\\s*")}\\s*(?::|&colon;|&#x?0*((58)|(3a));?|%3a)`,
+      "gi"
+    );
+    e = e.replace(o("javascript"), "data-unsafe-protocol:").replace(o("vbscript"), "data-unsafe-protocol:");
+  } else {
+    const o = /((?: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*(?::|&colon;|&#x?0*((58)|(3a));?|%3a))/gim;
+    e = e.replace(o, "data-unsafe-protocol:");
+  }
+  const i = /data\s*:\s*(?:text\/html|application\/javascript|text\/javascript|text\/vbscript)/gim;
+  return e = e.replace(i, "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;
+}
+function Et(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 < t; r++) {
+  for (let r = 0; r < e; r++) {
     const c = n[r];
     if (c === void 0 || c === -1) continue;
     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;
+      t[r] = l ?? -1, s[i++] = r;
       continue;
     }
-    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;
+    let _ = 0, g = i - 1;
+    for (; _ < g; ) {
+      const C = _ + g >>> 1, k = s[C];
+      k !== void 0 && (n[k] ?? -1) < c ? _ = C + 1 : g = C;
     }
-    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 v = s[_];
+    v !== void 0 && c < (n[v] ?? Number.MAX_SAFE_INTEGER) && (_ > 0 && (t[r] = s[_ - 1] ?? -1), s[_] = 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 = e[r];
+      o[c] = r, r = t[r];
   }
   return o;
 }
-function de() {
+function gt() {
   if (typeof window < "u") {
     const n = window.__ATOM_DEBUG__;
     if (typeof n == "boolean") return n;
@@ -954,401 +1002,416 @@ function de() {
   }
   return !1;
 }
-let z = de();
-const _ = {
+let Q = gt();
+const b = {
   get enabled() {
-    return z;
+    return Q;
   },
   set enabled(n) {
-    z = n;
+    Q = n;
   },
-  log(n, ...t) {
-    z && console.log(`[atom-effect-jquery] ${n}:`, ...t);
+  log(n, ...e) {
+    Q && console.log(`[atom-effect-jquery] ${n}:`, ...e);
   },
-  atomChanged(n, t, e) {
-    z && console.log(
+  atomChanged(n, e, t) {
+    Q && console.log(
       `[atom-effect-jquery] Atom "${n ?? "anonymous"}" changed:`,
-      t,
+      e,
       "→",
-      e
+      t
     );
   },
   /**
    * Logs DOM updates and triggers visual highlight.
    */
-  domUpdated(n, t, e) {
-    z && (console.log(`[atom-effect-jquery] DOM updated: ${ft(n)}.${t} =`, e), Ee(n));
+  domUpdated(n, e, t) {
+    Q && (console.log(`[atom-effect-jquery] DOM updated: ${me(n)}.${e} =`, t), mt(n));
   },
   cleanup(n) {
-    z && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
+    Q && console.log(`[atom-effect-jquery] Cleanup: ${n}`);
   },
   warn(...n) {
-    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 = {
+    Q && console.warn("[atom-effect-jquery]", ...n);
+  }
+}, be = /* @__PURE__ */ new WeakMap();
+function mt(n) {
+  const e = "jquery" in n ? n[0] : n;
+  if (!e || !e.isConnected) return;
+  let t = be.get(e);
+  if (t || (t = {}, be.set(e, t)), t.timer && clearTimeout(t.timer), t.cleanupTimer && clearTimeout(t.cleanupTimer), !t.orgStyle) {
+    const i = e.style;
+    t.orgStyle = {
       outline: i.outline,
       outlineOffset: i.outlineOffset,
       transition: i.transition
     };
   }
-  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);
+  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), be.delete(e);
       }, 500);
     }));
   }, 100);
 }
-const pe = /* @__PURE__ */ new WeakMap();
-function Qt(n, t = {}) {
-  const e = ue(n, t);
-  return t.name && pe.set(e, { name: t.name }), e;
+const yt = /* @__PURE__ */ new WeakMap();
+function Ye(n, e = {}) {
+  const t = ze(n, e);
+  return e.name && yt.set(t, { name: e.name }), t;
 }
-Object.defineProperty(Qt, "debug", {
+Object.defineProperty(Ye, "debug", {
   get() {
-    return _.enabled;
+    return b.enabled;
   },
   set(n) {
-    _.enabled = n;
+    b.enabled = n;
   }
 });
-function ge() {
+function bt() {
   return new Promise((n) => setTimeout(n, 0));
 }
 u.extend({
-  atom: Qt,
-  computed: he,
-  effect: Y,
-  batch: It,
-  untracked: zt,
-  isAtom: yt,
-  isComputed: wt,
-  isReactive: (n) => yt(n) || wt(n),
-  nextTick: ge
+  atom: Ye,
+  computed: dt,
+  effect: V,
+  batch: Oe,
+  untracked: at,
+  isAtom: De,
+  isComputed: Le,
+  isReactive: (n) => De(n) || Le(n),
+  nextTick: bt
 });
-const ot = "_aes-bound";
-class me {
+const ue = "_aes-bound";
+class Ct {
   records = /* @__PURE__ */ new WeakMap();
   boundElements = /* @__PURE__ */ new WeakSet();
   preservedNodes = /* @__PURE__ */ new WeakSet();
   ignoredNodes = /* @__PURE__ */ new WeakSet();
   // Prevent redundant cleanup
-  keep(t) {
-    this.preservedNodes.add(t);
+  keep(e) {
+    this.preservedNodes.add(e);
   }
-  isKept(t) {
-    return this.preservedNodes.has(t);
+  isKept(e) {
+    return this.preservedNodes.has(e);
   }
-  markIgnored(t) {
-    this.ignoredNodes.add(t);
+  markIgnored(e) {
+    this.ignoredNodes.add(e);
   }
-  isIgnored(t) {
-    return this.ignoredNodes.has(t);
+  isIgnored(e) {
+    return this.ignoredNodes.has(e);
   }
-  _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;
+  _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(ue))), t;
   }
-  trackEffect(t, e) {
-    const s = this._getOrCreateRecord(t);
-    s.effects || (s.effects = []), s.effects.push(e);
+  trackEffect(e, t) {
+    const s = this._getOrCreateRecord(e);
+    s.effects || (s.effects = []), s.effects.push(t);
   }
-  trackCleanup(t, e) {
-    const s = this._getOrCreateRecord(t);
-    s.cleanups || (s.cleanups = []), s.cleanups.push(e);
+  trackCleanup(e, t) {
+    const s = this._getOrCreateRecord(e);
+    s.cleanups || (s.cleanups = []), s.cleanups.push(t);
   }
-  hasBind(t) {
-    return this.boundElements.has(t);
+  hasBind(e) {
+    return this.boundElements.has(e);
   }
-  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;
+  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(ue), b.enabled && b.cleanup(me(e));
+    const s = t.effects;
     if (s)
       for (let o = 0, r = s.length; o < r; o++)
         try {
           s[o]?.dispose();
         } catch (c) {
-          _.warn("Effect dispose error:", c);
+          b.warn("Effect dispose error:", c);
         }
-    const i = e.cleanups;
+    const i = t.cleanups;
     if (i)
       for (let o = 0, r = i.length; o < r; o++)
         try {
           i[o]?.();
         } catch (c) {
-          _.warn("Cleanup error:", c);
+          b.warn("Cleanup error:", c);
         }
   }
-  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);
+  cleanupDescendants(e) {
+    const t = e.querySelectorAll(`.${ue}`);
+    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(ue);
     }
   }
-  cleanupTree(t) {
-    this.cleanupDescendants(t), this.cleanup(t);
+  cleanupTree(e) {
+    this.cleanupDescendants(e), this.cleanup(e);
   }
 }
-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;
+const y = new Ct();
+let se = null;
+function It(n = document.body) {
+  se || (se = 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];
-          c.nodeType === 1 && (c.isConnected || p.isKept(c) || p.isIgnored(c) || p.cleanupTree(c));
+          c.nodeType === 1 && (c.isConnected || y.isKept(c) || y.isIgnored(c) || y.cleanupTree(c));
         }
     }
-  }), et.observe(n, { childList: !0, subtree: !0 }));
+  }), se.observe(n, { childList: !0, subtree: !0 }));
 }
-function xe() {
-  et?.disconnect(), et = null;
+function $t() {
+  se?.disconnect(), se = null;
 }
-function b(n, t, e, s) {
-  fe(t) ? p.trackEffect(
+function O(n, e, t, s) {
+  pt(e) ? y.trackEffect(
     n,
-    Y(() => {
-      const i = t.value;
-      e(i), _.domUpdated(u(n), s, i);
+    V(() => {
+      const i = e.value;
+      t(i), b.domUpdated(u(n), s, i);
     })
-  ) : (e(t), _.domUpdated(u(n), s, t));
+  ) : (t(e), b.domUpdated(u(n), s, e));
 }
-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() {
+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() {
   return {
     timeoutId: null,
     flags: 0
     /* None */
   };
 }
-function Yt(n, t, e = {}) {
+function We(n, e, t = {}) {
   const {
     debounce: s,
     event: i = "input",
-    parse: o = (I) => I,
-    format: r = (I) => String(I ?? ""),
+    parse: o = (w) => w,
+    format: r = (w) => String(w ?? ""),
     equal: c = Object.is
-  } = e, l = Dt(), a = n[0], d = () => {
-    if (!(l.flags & g.Busy)) {
-      l.flags |= g.SyncingToAtom;
+  } = t, l = ke(), _ = n[0], g = () => {
+    if (!(l.flags & S.Busy)) {
+      l.flags |= S.SyncingToAtom;
       try {
-        const I = a.value, D = o(I);
-        c(t.value, D) || (t.value = D);
+        const w = _.value, N = o(w);
+        c(e.value, N) || (e.value = N);
       } finally {
-        l.flags &= ~g.SyncingToAtom;
+        l.flags &= ~S.SyncingToAtom;
       }
     }
-  }, 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);
+  }, v = () => {
+    l.timeoutId && (clearTimeout(l.timeoutId), l.timeoutId = null, g()), l.flags &= ~S.Focused;
+    const w = r(e.value);
+    _.value !== w && (_.value = w);
   }, C = () => {
-    l.flags & g.Busy || (s ? (l.timeoutId && clearTimeout(l.timeoutId), l.timeoutId = setTimeout(d, s)) : d());
-  }, v = {
+    l.flags & S.Busy || (s ? (l.timeoutId && clearTimeout(l.timeoutId), l.timeoutId = setTimeout(g, s)) : g());
+  }, k = {
     compositionstart: () => {
-      l.flags |= g.Composing;
+      l.flags |= S.Composing;
     },
     compositionend: () => {
-      l.flags &= ~g.Composing, d();
+      l.flags &= ~S.Composing, g();
     },
     focus: () => {
-      l.flags |= g.Focused;
+      l.flags |= S.Focused;
     },
-    blur: N,
+    blur: v,
     [i]: C,
     change: C
   };
-  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;
+  return n.on(k), { effect: () => {
+    const w = e.value, N = r(w), x = _.value;
+    if (x !== N && !(l.flags & S.Focused && c(o(x), w))) {
+      l.flags |= S.SyncingToDom;
       try {
-        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));
+        if (l.flags & S.Focused) {
+          const { selectionStart: L, selectionEnd: W } = _;
+          _.value = N;
+          const F = N.length;
+          _.setSelectionRange(Math.min(L ?? F, F), Math.min(W ?? F, F));
         } else
-          a.value = D;
-        _.domUpdated(n, "val", D);
+          _.value = N;
+        b.domUpdated(n, "val", N);
       } finally {
-        l.flags &= ~g.SyncingToDom;
+        l.flags &= ~S.SyncingToDom;
       }
     }
   }, cleanup: () => {
-    n.off(v), l.timeoutId && clearTimeout(l.timeoutId);
+    n.off(k), l.timeoutId && clearTimeout(l.timeoutId);
   } };
 }
-u.fn.atomText = function(n, t) {
+u.fn.atomText = function(n, e) {
   return this.each(function() {
-    const e = u(this);
-    b(this, n, t ? (i) => e.text(t(i)) : (i) => e.text(String(i ?? "")), "text");
+    const t = u(this);
+    O(this, n, e ? (i) => t.text(e(i)) : (i) => t.text(String(i ?? "")), "text");
   });
 };
 u.fn.atomHtml = function(n) {
   return this.each(function() {
-    const t = u(this);
-    b(this, n, (e) => t.html(String(e ?? "")), "html");
+    const e = u(this);
+    O(
+      this,
+      n,
+      (t) => {
+        const s = String(t ?? ""), i = Ge(s);
+        i !== s && console.warn("[atomHtml] Unsafe content neutralized during sanitization."), e.html(i);
+      },
+      "html"
+    );
   });
 };
-u.fn.atomClass = function(n, t) {
+u.fn.atomClass = function(n, e) {
   return this.each(function() {
-    const e = u(this);
-    b(
+    const t = u(this);
+    O(
       this,
-      t,
-      (s) => e.toggleClass(n, !!s),
+      e,
+      (s) => t.toggleClass(n, !!s),
       `class.${n}`
     );
   });
 };
-u.fn.atomCss = function(n, t, e) {
+u.fn.atomCss = function(n, e, t) {
   return this.each(function() {
     const s = u(this);
-    b(this, t, e ? (o) => s.css(n, `${o}${e}`) : (o) => s.css(n, o), `css.${n}`);
+    O(this, e, t ? (o) => s.css(n, `${o}${t}`) : (o) => s.css(n, o), `css.${n}`);
   });
 };
-u.fn.atomAttr = function(n, t) {
+u.fn.atomAttr = function(n, e) {
   return this.each(function() {
-    const e = u(this);
-    b(
+    const t = u(this);
+    O(
       this,
-      t,
+      e,
       (s) => {
         if (s == null || s === !1) {
-          e.removeAttr(n);
+          t.removeAttr(n);
           return;
         }
-        e.attr(n, s === !0 ? n : String(s));
+        t.attr(n, s === !0 ? n : String(s));
       },
       `attr.${n}`
     );
   });
 };
-u.fn.atomProp = function(n, t) {
+u.fn.atomProp = function(n, e) {
   return this.each(function() {
-    const e = u(this);
-    b(this, t, (s) => e.prop(n, s), `prop.${n}`);
+    const t = u(this);
+    O(this, e, (s) => t.prop(n, s), `prop.${n}`);
   });
 };
 u.fn.atomShow = function(n) {
   return this.each(function() {
-    const t = u(this);
-    b(this, n, (e) => t.toggle(!!e), "show");
+    const e = u(this);
+    O(this, n, (t) => e.toggle(!!t), "show");
   });
 };
 u.fn.atomHide = function(n) {
   return this.each(function() {
-    const t = u(this);
-    b(this, n, (e) => t.toggle(!e), "hide");
+    const e = u(this);
+    O(this, n, (t) => e.toggle(!t), "hide");
   });
 };
-u.fn.atomVal = function(n, t = {}) {
+u.fn.atomVal = function(n, e = {}) {
   return this.each(function() {
-    const { effect: e, cleanup: s } = Yt(u(this), n, t);
-    p.trackEffect(this, Y(e)), p.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 } = We(u(this), n, e);
+    y.trackEffect(this, V(s)), y.trackCleanup(this, i);
   });
 };
 u.fn.atomChecked = function(n) {
   return this.each(function() {
-    const t = u(this), e = this, s = Dt(), i = () => {
-      if (s.flags & g.Busy) return;
-      const r = e.checked;
+    const e = u(this), t = this, s = ke(), i = () => {
+      if (s.flags & S.Busy) return;
+      const r = t.checked;
       n.value !== r && (n.value = r);
     };
-    t.on("change", i), p.trackCleanup(this, () => t.off("change", i));
-    const o = Y(() => {
-      s.flags |= g.SyncingToDom;
+    e.on("change", i), y.trackCleanup(this, () => e.off("change", i));
+    const o = V(() => {
+      s.flags |= S.SyncingToDom;
       const r = !!n.value;
-      e.checked !== r && (e.checked = r, _.domUpdated(t, "checked", r)), s.flags &= ~g.SyncingToDom;
+      t.checked !== r && (t.checked = r, b.domUpdated(e, "checked", r)), s.flags &= ~S.SyncingToDom;
     });
-    p.trackEffect(this, o);
+    y.trackEffect(this, o);
   });
 };
-u.fn.atomOn = function(n, t) {
+u.fn.atomOn = function(n, e) {
   return this.each(function() {
-    const e = u(this);
-    e.on(n, t), p.trackCleanup(this, () => e.off(n, t));
+    const t = u(this);
+    t.on(n, e), y.trackCleanup(this, () => t.off(n, e));
   });
 };
 u.fn.atomUnbind = function() {
   return this.each(function() {
-    p.cleanupTree(this);
+    y.cleanupTree(this);
   });
 };
-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);
+const Fe = /* @__PURE__ */ Object.create(null);
+function St(n) {
+  let e = Fe[n];
+  return e || (e = n.includes("-") ? n.replace(/-./g, (t) => t[1].toUpperCase()) : n, Fe[n] = e, e);
 }
-function ye(n, t) {
-  const e = n.el;
-  b(
-    e,
+function Dt(n, e) {
+  const t = n.el;
+  O(
     t,
+    e,
     (s) => {
       const i = typeof s == "string" ? s : String(s ?? "");
-      e.textContent !== i && (e.textContent = i);
+      t.textContent !== i && (t.textContent = i);
     },
     "text"
   );
 }
-function Ce(n, t) {
-  const e = n.el;
-  b(
-    e,
+function vt(n, e) {
+  const t = n.el;
+  O(
     t,
+    e,
     (s) => {
-      const i = String(s ?? "");
-      e.innerHTML !== i && (e.innerHTML = i);
+      const i = String(s ?? ""), o = Ge(i);
+      o !== i && console.warn("[atomBind] Unsafe content neutralized during sanitization.");
+      const r = o;
+      t.innerHTML !== r && (t.innerHTML = r);
     },
     "html"
   );
 }
-function Ie(n, t) {
-  for (const e in t)
-    b(
+function Tt(n, e) {
+  for (const t in e)
+    O(
       n.el,
-      t[e],
+      e[t],
       (s) => {
-        n.el.classList.toggle(e, !!s);
+        n.el.classList.toggle(t, !!s);
       },
-      `class.${e}`
+      `class.${t}`
     );
 }
-function De(n, t) {
-  const e = n.el, s = e.style;
-  for (const i in t) {
-    const o = t[i];
+function Ot(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 = be(i);
-    Array.isArray(o) ? b(
-      e,
+    const r = St(i);
+    Array.isArray(o) ? O(
+      t,
       o[0],
       (c) => {
         s[r] = `${c}${o[1]}`;
       },
       `css.${i}`
-    ) : b(
-      e,
+    ) : O(
+      t,
       o,
       (c) => {
         s[r] = c;
@@ -1357,279 +1420,421 @@ function De(n, t) {
     );
   }
 }
-function Te(n, t) {
-  const e = n.el;
-  for (const s in t)
-    b(
-      e,
-      t[s],
+function kt(n, e) {
+  const t = n.el;
+  for (const s in e)
+    O(
+      t,
+      e[s],
       (i) => {
         if (i == null || i === !1) {
-          e.removeAttribute(s);
+          t.removeAttribute(s);
           return;
         }
         const o = i === !0 ? s : String(i);
-        e.getAttribute(s) !== o && e.setAttribute(s, o);
+        t.getAttribute(s) !== o && t.setAttribute(s, o);
       },
       `attr.${s}`
     );
 }
-function Ne(n, t) {
-  const e = n.el;
-  for (const s in t)
-    b(
+function wt(n, e) {
+  const t = n.el;
+  for (const s in e)
+    O(
       n.el,
-      t[s],
+      e[s],
       (i) => {
-        e[s] !== i && (e[s] = i);
+        t[s] !== i && (t[s] = i);
       },
       `prop.${s}`
     );
 }
-function Oe(n, t) {
-  const e = n.el;
-  b(
-    e,
+function Nt(n, e) {
+  const t = n.el;
+  O(
     t,
+    e,
     (s) => {
-      e.style.display = s ? "" : "none", _.enabled && _.domUpdated(e, "show", s);
+      t.style.display = s ? "" : "none", b.enabled && b.domUpdated(t, "show", s);
     },
     "show"
   );
 }
-function ke(n, t) {
-  const e = n.el;
-  b(
-    e,
+function Rt(n, e) {
+  const t = n.el;
+  O(
     t,
+    e,
     (s) => {
-      e.style.display = s ? "none" : "", _.enabled && _.domUpdated(e, "hide", s);
+      t.style.display = s ? "none" : "", b.enabled && b.domUpdated(t, "hide", s);
     },
     "hide"
   );
 }
-function Ae(n, t) {
-  const e = Array.isArray(t), { effect: s, cleanup: i } = Yt(
+function xt(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: o } = We(
     n.$el,
-    e ? t[0] : t,
-    e ? t[1] : {}
+    s ? e[0] : e,
+    s ? e[1] : {}
   );
-  p.trackEffect(n.el, Y(s)), n.trackCleanup(i);
+  y.trackEffect(n.el, V(i)), n.trackCleanup(o);
 }
-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);
+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);
   };
-  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;
+  t.addEventListener("change", i), n.trackCleanup(() => t.removeEventListener("change", i));
+  const o = V(() => {
+    s.flags |= S.SyncingToDom;
+    const r = !!e.value;
+    t.checked !== r && (t.checked = r, b.enabled && b.domUpdated(t, "checked", r)), s.flags &= ~S.SyncingToDom;
   });
-  p.trackEffect(e, o);
+  y.trackEffect(t, o);
 }
-function Ue(n, t) {
-  for (const e in t) {
-    const s = t[e];
+function Lt(n, e) {
+  for (const t in e) {
+    const s = e[t];
     if (typeof s != "function") continue;
     const i = (o) => {
-      It(
+      Oe(
         () => s.call(
           n.el,
           u.Event(o.type, { originalEvent: o })
         )
       );
     };
-    n.el.addEventListener(e, i), n.trackCleanup(() => n.el.removeEventListener(e, i));
+    n.el.addEventListener(t, i), n.trackCleanup(() => n.el.removeEventListener(t, i));
   }
 }
 u.fn.atomBind = function(n) {
   return this.each(function() {
-    const t = this;
-    let e = null;
+    const e = this;
+    let t = null;
     const s = {
       get $el() {
-        return e || (e = u(t)), e;
+        return t || (t = u(e)), t;
       },
-      el: t,
-      trackCleanup: (i) => p.trackCleanup(t, i)
+      el: e,
+      trackCleanup: (i) => y.trackCleanup(e, i)
     };
-    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);
+    n.text !== void 0 && Dt(s, n.text), n.html !== void 0 && vt(s, n.html), n.class && Tt(s, n.class), n.css && Ot(s, n.css), n.attr && kt(s, n.attr), n.prop && wt(s, n.prop), n.show !== void 0 && Nt(s, n.show), n.hide !== void 0 && Rt(s, n.hide), n.val !== void 0 && xt(s, n.val), n.checked !== void 0 && At(s, n.checked), n.on && Lt(s, n.on);
   });
 };
-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];
+u.fn.atomList = function(n, e) {
+  const { key: t, render: s, bind: i, update: o, onAdd: r, onRemove: c, empty: l } = e, _ = typeof t == "function" ? t : (g, v) => g[t];
   return this.each(function() {
-    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 = [];
+    const g = u(this), v = me(this), C = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set();
+    let R = [], M = null;
+    const w = V(() => {
+      const N = n.value, x = N.length;
+      if (x === 0 ? l && !M && (M = u(l).appendTo(g)) : M && (M.remove(), M = null), x === 0 && C.size === 0) {
+        R = [];
         return;
       }
-      _.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;
+      b.log("list", `${v} updating with ${x} items`);
+      const L = /* @__PURE__ */ new Map(), W = R.length;
+      for (let a = 0; a < W; a++)
+        L.set(R[a], a);
+      const F = new Array(x), K = /* @__PURE__ */ new Set(), re = new Int32Array(x);
+      for (let a = 0; a < x; a++) {
+        const E = N[a], f = _(E, a);
+        K.has(f) && console.warn(`[atomList] Duplicate key "${f}" at index ${a}.`), F[a] = f, K.add(f), re[a] = L.get(f) ?? -1;
       }
       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);
+        for (const [a, E] of C) {
+          if (K.has(a) || k.has(a)) continue;
+          const f = () => {
+            E.$el.remove(), E.$el[0] && y.cleanup(E.$el[0]), k.delete(a), b.log("list", `${v} removed item:`, a);
           };
-          if (C.delete(f), v.add(f), c) {
-            const y = c(x.$el);
-            y instanceof Promise ? y.then(E) : E();
+          if (C.delete(a), k.add(a), c) {
+            const p = c(E.$el);
+            p instanceof Promise ? p.then(f) : f();
           } else
-            E();
+            f();
         }
-      if (O === 0) {
-        H = [];
+      if (x === 0) {
+        R = [];
         return;
       }
-      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;
+      const te = Et(re);
+      let ne = te.length - 1, h = null;
+      for (let a = x - 1; a >= 0; a--) {
+        const E = F[a], f = N[a], p = C.get(E);
+        if (p) {
+          const T = p.item;
+          p.item = f;
+          const m = p.$el[0];
+          if (!m) continue;
           if (o)
-            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;
+            o(p.$el, f, a), b.domUpdated(p.$el, "list.update", f);
+          else if (T !== f) {
+            let I = !0;
+            if (typeof T == "object" && T !== null && typeof f == "object" && f !== null) {
+              I = !1;
+              let j = 0;
+              const ce = T, we = f;
+              for (const J in ce) {
+                if (ce[J] !== we[J]) {
+                  I = !0;
                   break;
                 }
-                L++;
+                j++;
               }
-              if (!M) {
-                let W = 0;
-                for (const Re in Ot)
-                  if (W++, W > L) {
-                    M = !0;
+              if (!I) {
+                let J = 0;
+                for (const Ft in we)
+                  if (J++, J > j) {
+                    I = !0;
                     break;
                   }
-                L !== W && (M = !0);
+                j !== J && (I = !0);
               }
             }
-            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 (I) {
+              const j = u(s(f, a)), ce = h === m;
+              p.$el.replaceWith(j), p.$el = j, i && i(j, f, a), b.domUpdated(j, "list.render", f), ce && (h = j[0] || null);
             }
           }
-          if (Et >= 0 && Nt[Et] === f)
-            Et--;
+          if (ne >= 0 && te[ne] === a)
+            ne--;
           else {
-            const M = y.$el[0];
-            w?.isConnected ? w !== M && y.$el.insertBefore(w) : y.$el.appendTo(d);
+            const I = p.$el[0];
+            h?.isConnected ? h !== I && p.$el.insertBefore(h) : p.$el.appendTo(g);
           }
-          w = y.$el[0] || null;
+          h = p.$el[0] || null;
         } else {
-          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;
+          const T = s(f, a), m = u(T);
+          C.set(E, { $el: m, item: f }), h?.isConnected ? m.insertBefore(h) : m.appendTo(g), i && i(m, f, a), r && r(m), b.domUpdated(m, "list.add", f), h = m[0] || null;
         }
       }
-      H = P;
+      R = F;
     });
-    p.trackEffect(this, I), p.trackCleanup(this, () => {
-      C.clear(), v.clear(), H = [], V?.remove();
+    y.trackEffect(this, w), y.trackCleanup(this, () => {
+      C.clear(), k.clear(), R = [], M?.remove();
     });
   });
 };
-const ct = /* @__PURE__ */ new WeakMap();
-u.fn.atomMount = function(n, t = {}) {
+const de = /* @__PURE__ */ new WeakMap();
+u.fn.atomMount = function(n, e = {}) {
   return this.each(function() {
-    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`);
+    const t = b.enabled, s = t ? me(this) : "", i = de.get(this);
+    i && (t && b.log("mount", `${s} unmounting existing component`), i()), t && b.log("mount", `${s} mounting component`);
     let o;
     try {
-      o = n(u(this), t);
+      o = n(u(this), e);
     } catch (c) {
       console.error("[atom-effect-jquery] Mount error:", c);
       return;
     }
     const r = () => {
-      if (ct.delete(this)) {
-        if (e && _.log("mount", `${s} full cleanup`), typeof o == "function")
+      if (de.delete(this)) {
+        if (t && b.log("mount", `${s} full cleanup`), typeof o == "function")
           try {
             o();
           } catch (c) {
             console.error("[atom-effect-jquery] Cleanup error:", c);
           }
-        p.cleanupTree(this);
+        y.cleanupTree(this);
       }
     };
-    ct.set(this, r), p.trackCleanup(this, r);
+    de.set(this, r), y.trackCleanup(this, r);
   });
 };
 u.fn.atomUnmount = function() {
   return this.each(function() {
-    const n = ct.get(this);
+    const n = de.get(this);
     n && n();
   });
 };
-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;
+const le = "[$.route]";
+function Ut(n) {
+  const {
+    target: e,
+    default: t,
+    routes: s,
+    notFound: i,
+    autoBindLinks: o = !1,
+    activeClass: r = "active",
+    beforeTransition: c,
+    afterTransition: l
+  } = n;
+  let _ = !1, g = null, v = window.location.hash;
+  const C = [], k = /* @__PURE__ */ new Set(), R = u(e), M = () => {
+    const h = window.location.hash, a = h.indexOf("?");
+    return (a === -1 ? h.substring(1) : h.substring(1, a)) || t;
+  }, w = (h) => {
+    const a = h.indexOf("?");
+    if (a === -1) return {};
+    const E = {}, f = h.length;
+    let p = a + 1;
+    const T = (m) => {
+      try {
+        return decodeURIComponent(m);
+      } catch {
+        return console.warn(`${le} Malformed URI component: ${m}`), m;
+      }
+    };
+    for (; p < f; ) {
+      let m = h.indexOf("&", p);
+      if (m === -1 && (m = f), m > p) {
+        const I = h.indexOf("=", p);
+        I !== -1 && I < m ? E[T(h.substring(p, I))] = T(
+          h.substring(I + 1, m)
+        ) : E[T(h.substring(p, m))] = "";
+      }
+      p = m + 1;
+    }
+    return E;
+  }, N = (h) => {
+    let a = s[h];
+    return !a && i && (a = s[i]), a || (console.warn(`${le} Route "${h}" not found and no notFound route configured`), null);
+  }, x = (h) => {
+    const a = document.querySelector(h);
+    if (!a?.content)
+      return console.warn(`${le} Template "${h}" not found`), !1;
+    const E = a.content.cloneNode(!0);
+    return R.append(E), !0;
+  }, L = ze(M()), W = (h) => {
+    if (_) return;
+    const a = R[0];
+    if (!a) {
+      console.warn(`${le} Target element "${e}" not found`);
+      return;
+    }
+    const E = N(h);
+    if (!E) return;
+    const f = w(window.location.hash);
+    c && c(g || h, h), R.empty();
+    let p = f;
+    if (E.onEnter) {
+      const T = E.onEnter(f);
+      T !== void 0 && (p = { ...f, ...T });
+    }
+    E.render ? E.render(a, h, p) : E.template && x(E.template), l && l(g || h, h), g = h;
+  }, F = (h) => {
+    if (_) return;
+    const a = L.value, E = s[a];
+    E?.onLeave && E.onLeave() === !1 || (v = `#${h}`, window.location.hash = v, L.value = h);
+  }, K = () => {
+    if (_) return;
+    const h = window.location.hash;
+    if (h === v) return;
+    const a = M(), E = L.value;
+    if (E !== a) {
+      const f = s[E];
+      if (f?.onLeave && f.onLeave() === !1) {
+        window.location.hash = v;
+        return;
+      }
+      L.value = a;
+    } else
+      W(a);
+    v = h;
+  }, re = () => {
+    if (!o) return;
+    const h = (f) => {
+      f.preventDefault();
+      const p = u(f.currentTarget).data("route");
+      F(p);
+    };
+    u(document).on("click", "[data-route]", h), C.push(() => {
+      u(document).off("click", "[data-route]", h);
+    });
+    const a = (f) => {
+      if (k.has(f)) return;
+      const p = u(f), T = p.data("route");
+      k.add(f);
+      const m = V(() => {
+        const I = L.value === T;
+        p.toggleClass(r, I), I ? p.attr("aria-current", "page") : p.removeAttr("aria-current");
+      });
+      y.trackEffect(f, m), y.trackCleanup(f, () => {
+        k.delete(f);
+      });
+    };
+    u("[data-route]").each(function() {
+      a(this);
+    });
+    const E = new MutationObserver((f) => {
+      for (const p of f)
+        p.type === "childList" && p.addedNodes.forEach((T) => {
+          if (T.nodeType === 1) {
+            const m = T;
+            m.matches?.("[data-route]") && a(m), m.querySelectorAll && m.querySelectorAll("[data-route]").forEach(
+              (I) => a(I)
+            );
+          }
+        });
+    });
+    E.observe(document.body, { childList: !0, subtree: !0 }), C.push(() => E.disconnect());
+  }, te = () => {
+    _ || (_ = !0, C.forEach((h) => h()), C.length = 0, k.forEach((h) => y.cleanup(h)), k.clear());
+  };
+  window.addEventListener("hashchange", K), C.push(() => window.removeEventListener("hashchange", K));
+  const ne = V(() => {
+    W(L.value);
+  });
+  return C.push(() => ne.dispose()), re(), R[0] && y.trackCleanup(R[0], te), {
+    currentRoute: L,
+    navigate: F,
+    destroy: te
+  };
+}
+u.extend({
+  route: Ut
+});
+const pe = /* @__PURE__ */ new WeakMap();
+let Pe = !1;
+const $e = (n) => {
+  let e = pe.get(n);
+  return e || (e = function(...t) {
+    return Oe(() => n.apply(this, t));
+  }, pe.set(n, e)), e;
 };
-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;
+function Ke() {
+  if (Pe) return;
+  Pe = !0;
+  const n = u.fn.on, e = u.fn.off, t = 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, l = r.length; c < l; c++) {
-      const a = r[c];
-      a && (p.cleanupTree(a), p.markIgnored(a));
+      const _ = r[c];
+      _ && (y.cleanupTree(_), y.markIgnored(_));
     }
-    return e.call(this, o);
+    return t.call(this, o);
   }, u.fn.empty = function() {
     for (let o = 0, r = this.length; o < r; o++) {
       const c = this[o];
-      c && p.cleanupDescendants(c);
+      c && y.cleanupDescendants(c);
     }
     return s.call(this);
   }, u.fn.detach = function(o) {
     const r = o ? this.filter(o) : this;
     for (let c = 0, l = r.length; c < l; c++) {
-      const a = r[c];
-      a && p.keep(a);
+      const _ = r[c];
+      _ && y.keep(_);
     }
     return i.call(this, o);
   }, u.fn.on = function(...o) {
     const r = o[0];
     if (r && typeof r == "object") {
       const c = r, l = {};
-      for (const a in c) {
-        const d = c[a];
-        d && (l[a] = Mt(d));
+      for (const _ in c) {
+        const g = c[_];
+        g && (l[_] = $e(g));
       }
       o[0] = l;
     } else
       for (let c = o.length - 1; c >= 0; c--)
         if (typeof o[c] == "function") {
-          o[c] = Mt(o[c]);
+          o[c] = $e(o[c]);
           break;
         }
     return n.apply(this, o);
@@ -1637,36 +1842,36 @@ function Jt() {
     const r = o[0];
     if (r && typeof r == "object") {
       const c = r, l = {};
-      for (const a in c) {
-        const d = c[a];
-        d && (l[a] = lt.get(d) || d);
+      for (const _ in c) {
+        const g = c[_];
+        g && (l[_] = pe.get(g) || g);
       }
       o[0] = l;
     } else
       for (let c = o.length - 1; c >= 0; c--)
         if (typeof o[c] == "function") {
-          o[c] = lt.get(o[c]) || o[c];
+          o[c] = pe.get(o[c]) || o[c];
           break;
         }
-    return t.apply(this, o);
+    return e.apply(this, o);
   };
 }
-const Le = Jt;
-Jt();
+const Mt = Ke;
+Ke();
 u(() => {
-  Se(document.body);
+  It(document.body);
 });
 export {
-  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
+  ze as atom,
+  Oe as batch,
+  dt as computed,
+  Vt as default,
+  $t as disableAutoCleanup,
+  V as effect,
+  It as enableAutoCleanup,
+  Mt as enablejQueryBatching,
+  Ke as enablejQueryOverrides,
+  y as registry,
+  at as untracked
 };
 //# sourceMappingURL=index.mjs.map