@but212/atom-effect-jquery 0.22.1 → 0.23.0

package/dist/index.mjs

@@ -1,14 +1,14 @@
-import c from "jquery";
-import { default as qs } from "jquery";
-const ut = {
+import h from "jquery";
+import { default as zs } from "jquery";
+const rt = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, L = {
+}, w = {
   DISPOSED: 1,
   EXECUTING: 8
-}, fe = {
+}, Qt = {
   DISPOSED: 1,
   /** Marker bit: identifies this node as a computed. */
   IS_COMPUTED: 2,
@@ -19,11 +19,11 @@ const ut = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, $ = {
+}, M = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, q = {
+}, j = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
@@ -33,84 +33,64 @@ const ut = {
   MIN_FLUSH_ITERATIONS: 10,
   // Memory management
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, we = {
+}, Ce = {
   WARN_INFINITE_LOOP: !0
-}, te = {
+}, $t = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
-}, It = 1073741823, ke = typeof process < "u" && process.env && !1 || !1, xe = Object.freeze([]);
-class tt extends Error {
-  constructor(t, s = null, n = !0) {
-    super(t), this.cause = s, this.recoverable = n, this.name = "AtomError";
+}, Y = {
+  /** Uninitialized epoch marker. Used as initial value before any flush has occurred. */
+  UNINITIALIZED: -1
+}, mt = 1073741823, Te = typeof process < "u" && process.env && !1 || !1, Se = Object.freeze([]);
+function Pt(n, t, e) {
+  const s = /* @__PURE__ */ new Map();
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i];
+    o?.unsub && s.set(o.node, o.unsub);
   }
-}
-class z extends tt {
-  constructor(t, s = null) {
-    super(t, s, !0), this.name = "ComputedError";
+  for (let i = 0; i < n.length; i++) {
+    const o = n[i];
+    if (!o) continue;
+    const r = o.node, c = s.get(r);
+    c !== void 0 ? (o.unsub = c, s.delete(r)) : o.unsub || (o.unsub = r.subscribe(e));
   }
+  for (const i of s.values())
+    i();
 }
-class J extends tt {
-  constructor(t, s = null) {
-    super(t, s, !1), this.name = "EffectError";
+class ht {
+  constructor(t, e, s = void 0) {
+    this.node = t, this.version = e, this.unsub = s;
   }
 }
-class At extends tt {
-  constructor(t, s = null) {
-    super(t, s, !1), this.name = "SchedulerError";
+class Ne {
+  constructor(t, e) {
+    this.fn = t, this.sub = e;
   }
-}
-const Pe = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Me = /* @__PURE__ */ Symbol("AtomEffect.Type"), Ut = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), yt = {
-  // Dev mode flag
-  enabled: ke,
-  warnInfiniteLoop: we.WARN_INFINITE_LOOP,
-  warn(e, t) {
-  },
-  checkCircular(e, t) {
-    if (e === t)
-      throw new z("Direct circular dependency detected");
-  },
-  attachDebugInfo(e, t, s) {
-  },
-  getDebugName: (e) => e?.[Pe],
-  getDebugType: (e) => e?.[Me]
-};
-let $e = 1;
-const Fe = () => $e++;
-function de(e, t, s) {
-  if (typeof t == "function") {
-    const i = t;
-    if (s.some((r) => r && r.fn === i)) return;
-    s.push(new Mt(i, void 0));
-    return;
+  notify(t, e) {
+    this.fn ? this.fn(t, e) : this.sub && this.sub.execute();
   }
-  if ("addDependency" in t) {
-    t.addDependency(e);
-    return;
+}
+class W extends Error {
+  constructor(t, e = null, s = !0) {
+    super(t), this.cause = e, this.recoverable = s, this.name = "AtomError";
   }
-  const n = t;
-  s.some((i) => i && i.sub === n) || s.push(new Mt(void 0, n));
 }
-function ee(e, t, s) {
-  const n = /* @__PURE__ */ new Map();
-  t.forEach((i) => {
-    i?.unsub && n.set(i.node, i.unsub);
-  }), e.forEach((i) => {
-    if (!i) return;
-    const r = i.node, o = n.get(r);
-    o !== void 0 ? (i.unsub = o, n.delete(r)) : (yt.checkCircular(r, s), i.unsub = r.subscribe(s));
-  }), n.forEach((i) => i());
+class z extends W {
+  constructor(t, e = null) {
+    super(t, e, !0), this.name = "ComputedError";
+  }
 }
-class Pt {
-  constructor(t, s, n = void 0) {
-    this.node = t, this.version = s, this.unsub = n;
+class q extends W {
+  constructor(t, e = null) {
+    super(t, e, !1), this.name = "EffectError";
   }
 }
-class Mt {
-  constructor(t, s) {
-    this.fn = t, this.sub = s;
+class yt extends W {
+  constructor(t, e = null) {
+    super(t, e, !1), this.name = "SchedulerError";
   }
 }
-const y = {
+const b = {
   // Computed Errors
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
@@ -127,82 +107,140 @@ const y = {
   EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
   EFFECT_DISPOSED: "Attempted to run disposed effect",
   // Scheduler Errors
-  SCHEDULER_FLUSH_OVERFLOW: (e, t) => `Maximum flush iterations (${e}) exceeded. ${t} jobs dropped. Possible infinite loop.`,
+  SCHEDULER_FLUSH_OVERFLOW: (n, t) => `Maximum flush iterations (${n}) exceeded. ${t} 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.",
   SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
-  SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring."
+  SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring.",
+  BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
+}, be = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Re = /* @__PURE__ */ Symbol("AtomEffect.Type"), Ct = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Lt = {
+  // Dev mode flag
+  enabled: Te,
+  warnInfiniteLoop: Ce.WARN_INFINITE_LOOP,
+  warn(n, t) {
+  },
+  attachDebugInfo(n, t, e) {
+  },
+  getDebugName: (n) => n?.[be],
+  getDebugType: (n) => n?.[Re]
 };
-function Z(e, t, s) {
-  if (e instanceof tt)
-    return e;
-  const n = e instanceof Error, i = n ? e.message : String(e), r = n ? e : void 0, o = `${n ? e.constructor.name : "Unexpected error"} (${s}): ${i}`;
-  return new t(o, r);
+let ve = 1;
+const De = () => ve++;
+function Q(n, t, e) {
+  if (n instanceof W)
+    return n;
+  const s = n instanceof Error, i = s ? n.message : String(n), o = s ? n : void 0, r = `${s ? n.constructor.name : "Unexpected error"} (${e}): ${i}`;
+  return new t(r, o);
 }
-class _e {
+class Wt {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = Fe() & It;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = Y.UNINITIALIZED, this.id = De() & mt;
   }
 }
-class Ee extends _e {
+class Zt extends Wt {
+  constructor() {
+    super(...arguments), this._notifying = 0;
+  }
   /**
    * Adds subscriber.
    */
   subscribe(t) {
-    const s = typeof t == "function";
-    if (!s && (!t || typeof t.execute != "function"))
-      throw Z(
+    const e = typeof t == "function";
+    if (!e && (!t || typeof t.execute != "function"))
+      throw Q(
         new TypeError("Invalid subscriber"),
-        tt,
-        y.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        W,
+        b.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
-    if (this._subscribers.some((i) => i ? s ? i.fn === t : i.sub === t : !1))
+    const s = this._subscribers, i = s.length;
+    let o = !1;
+    for (let c = 0; c < i; c++) {
+      const a = s[c];
+      if (a != null && (e ? a.fn === t : a.sub === t)) {
+        o = !0;
+        break;
+      }
+    }
+    if (o)
       return () => {
       };
-    const n = new Mt(
-      s ? t : void 0,
-      s ? void 0 : t
+    const r = new Ne(
+      e ? t : void 0,
+      e ? void 0 : t
     );
-    return this._subscribers.push(n), () => this._unsubscribe(n);
+    return s.push(r), () => this._unsubscribe(r);
   }
   _unsubscribe(t) {
-    const s = this._subscribers, n = s.indexOf(t);
-    if (n === -1) return;
-    const i = s.pop();
-    n < s.length && i && (s[n] = i);
+    const e = this._subscribers;
+    let s = -1;
+    for (let o = 0; o < e.length; o++)
+      if (e[o] === t) {
+        s = o;
+        break;
+      }
+    if (s === -1) return;
+    if (this._notifying > 0) {
+      e[s] = null;
+      return;
+    }
+    const i = e.pop();
+    s < e.length && i !== void 0 && (e[s] = i);
   }
   subscriberCount() {
-    return this._subscribers.length;
+    let t = 0;
+    const e = this._subscribers;
+    for (let s = 0; s < e.length; s++)
+      e[s] != null && t++;
+    return t;
   }
-  _notifySubscribers(t, s) {
-    this._subscribers.length !== 0 && this._subscribers.slice(0).forEach((n) => {
-      if (n)
-        try {
-          n.fn ? n.fn(t, s) : n.sub && n.sub.execute();
-        } catch (i) {
-          this._handleNotifyError(i);
+  _notifySubscribers(t, e) {
+    const s = this._subscribers, i = s.length;
+    if (i !== 0) {
+      this._notifying++;
+      try {
+        for (let o = 0; o < i; o++) {
+          const r = s[o];
+          if (r != null)
+            try {
+              r.notify(t, e);
+            } catch (c) {
+              this._handleNotifyError(c);
+            }
         }
-    });
+      } finally {
+        this._notifying--, this._notifying === 0 && this._cleanupTombstones();
+      }
+    }
+  }
+  _cleanupTombstones() {
+    const t = this._subscribers;
+    let e = 0;
+    for (; e < t.length; )
+      if (t[e] === null) {
+        const s = t.pop();
+        e < t.length && s !== void 0 && (t[e] = s);
+      } else
+        e++;
   }
   _handleNotifyError(t) {
-    console.error(Z(t, tt, y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(Q(t, W, b.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let Lt = 0;
-const jt = () => (Lt = Lt + 1 & It || 1, Lt), $t = (e) => e + 1 & It;
-let zt = 0, pt = !1, pe = 0;
-const me = () => pe;
-function se() {
-  return pt ? !1 : (pt = !0, pe = jt(), zt = 0, !0);
+let Tt = 0;
+const kt = () => (Tt = Tt + 1 & mt || 1, Tt), vt = (n) => n + 1 & mt;
+let At = 0, ut = !1, Jt = 0;
+const te = () => Jt;
+function Mt() {
+  return ut ? !1 : (ut = !0, Jt = kt(), At = 0, !0);
 }
-const ne = () => {
-  pt = !1;
-}, Be = () => pt ? ++zt : 0;
-class He {
+const Ft = () => {
+  ut = !1;
+}, Oe = () => ut ? ++At : 0;
+class Le {
   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);
+    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 = j.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
@@ -237,28 +275,28 @@ class He {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = se();
-      this._drainQueue(), t && ne();
+      const t = Mt();
+      this._drainQueue(), t && Ft();
     } finally {
       this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = se();
+    const t = Mt();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && ne();
+      this._isFlushingSync = !1, t && Ft();
     }
   }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const t = ++this._epoch, s = this._batchQueue, n = this._queueBuffer[this._bufferIndex];
+    const t = ++this._epoch, e = this._batchQueue, s = this._queueBuffer[this._bufferIndex];
     let i = this._size;
-    s.slice(0, this._batchQueueSize).forEach((r) => {
-      r._nextEpoch !== t && (r._nextEpoch = t, n[i++] = r);
-    }), this._size = i, this._batchQueueSize = 0, s.length > q.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
+    e.slice(0, this._batchQueueSize).forEach((o) => {
+      o._nextEpoch !== t && (o._nextEpoch = t, s[i++] = o);
+    }), this._size = i, this._batchQueueSize = 0, e.length > j.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
   }
   _drainQueue() {
     let t = 0;
@@ -271,21 +309,22 @@ class He {
     }
   }
   _processQueue() {
-    const t = this._bufferIndex, s = this._queueBuffer[t], n = this._size;
+    const t = this._bufferIndex, e = this._queueBuffer[t], s = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
-    for (let i = 0; i < n; i++)
+    for (let i = 0; i < s; i++)
       try {
-        s[i]();
-      } catch (r) {
-        console.error(new At("Error occurred during scheduler execution", r));
+        const o = e[i];
+        typeof o == "function" ? o() : o.execute();
+      } catch (o) {
+        console.error(new yt("Error occurred during scheduler execution", o));
       }
-    s.length = 0;
+    e.length = 0;
   }
   _handleFlushOverflow() {
     const t = this._size + this._batchQueueSize;
     if (console.error(
-      new At(
-        y.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
+      new yt(
+        b.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
       try {
@@ -300,14 +339,14 @@ class He {
     this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(t) {
-    if (t < q.MIN_FLUSH_ITERATIONS)
-      throw new At(
-        `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
+    if (t < j.MIN_FLUSH_ITERATIONS)
+      throw new yt(
+        `Max flush iterations must be at least ${j.MIN_FLUSH_ITERATIONS}`
       );
     this._maxFlushIterations = t;
   }
 }
-const rt = new He(), Vt = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ge = /* @__PURE__ */ Symbol.for("atom-effect/computed"), Ge = /* @__PURE__ */ Symbol.for("atom-effect/effect"), k = {
+const ot = new Le(), Ut = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ee = /* @__PURE__ */ Symbol.for("atom-effect/computed"), ke = /* @__PURE__ */ Symbol.for("atom-effect/effect"), Ae = /* @__PURE__ */ Symbol.for("atom-effect/writable"), $ = {
   /** Active listener. */
   current: null,
   /**
@@ -317,79 +356,85 @@ const rt = new He(), Vt = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ge = /
    * @param fn - The logic to execute.
    * @returns The result of `fn`.
    */
-  run(e, t) {
-    const s = this.current;
-    this.current = e;
+  run(n, t) {
+    const e = this.current;
+    this.current = n;
     try {
       return t();
     } finally {
-      this.current = s;
+      this.current = e;
     }
   }
 };
-function H(e) {
-  const t = k.current;
-  if (t === null) return e();
-  k.current = null;
+function P(n) {
+  const t = $.current;
+  if (t === null) return n();
+  $.current = null;
   try {
-    return e();
+    return n();
   } finally {
-    k.current = t;
+    $.current = t;
   }
 }
-var ie;
-class je extends Ee {
-  constructor(t, s) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = () => this._flushNotifications(), this._subscribers = [], this[ie] = !0, this._value = t, s && (this.flags |= $.SYNC), yt.attachDebugInfo(this, "atom", this.id);
+var Bt, Gt;
+class Ue extends Zt {
+  constructor(t, e) {
+    super(), this._pendingOldValue = void 0, this._subscribers = [], this[Gt] = !0, this[Bt] = !0, this._value = t, e && (this.flags |= M.SYNC), Lt.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
-    const t = k.current;
-    return t && de(this, t, this._subscribers), this._value;
+    return $.current?.addDependency(this), this._value;
   }
   set value(t) {
-    const s = this._value;
-    if (Object.is(s, t)) return;
-    this._value = t, this.version = $t(this.version);
-    const n = this.flags;
-    if (!(this._subscribers.length === 0 || n & $.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = s, this.flags = n | $.NOTIFICATION_SCHEDULED, n & $.SYNC && !rt.isBatching) {
+    const e = this._value;
+    if (Object.is(e, t)) return;
+    this._value = t, this.version = vt(this.version);
+    const s = this.flags;
+    if (!(this._subscribers.length === 0 || s & M.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = e, this.flags = s | M.NOTIFICATION_SCHEDULED, s & M.SYNC && !ot.isBatching) {
         this._flushNotifications();
         return;
       }
-      rt.schedule(this._notifyTask);
+      ot.schedule(this);
     }
   }
+  /**
+   * Executes scheduled notification.
+   * @internal
+   */
+  execute() {
+    this._flushNotifications();
+  }
   /**
    * Triggers subscribers.
    */
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & $.NOTIFICATION_SCHEDULED) || t & $.DISPOSED)
+    if (!(t & M.NOTIFICATION_SCHEDULED) || t & M.DISPOSED)
       return;
-    const s = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, s);
+    const e = this._pendingOldValue;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
   }
   peek() {
     return this._value;
   }
   dispose() {
-    this.flags & $.DISPOSED || (this._subscribers.length = 0, this.flags |= $.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+    this.flags & M.DISPOSED || (this._subscribers.length = 0, this.flags |= M.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
   }
-  [(ie = Vt, Symbol.dispose)]() {
+  [(Gt = Ut, Bt = Ae, Symbol.dispose)]() {
     this.dispose();
   }
 }
-function Ft(e, t = {}) {
-  return new je(e, t.sync ?? !1);
+function Dt(n, t = {}) {
+  return new Ue(n, t.sync ?? !1);
 }
-class ze {
+class we {
   /**
    * @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, s = 256, n = !1) {
-    this.limit = t, this.capacity = s, this.pool = [], this.stats = null, this.stats = n ? {
+  constructor(t = 50, e = 256, s = !1) {
+    this.limit = t, this.capacity = e, this.pool = [], this.stats = null, this.stats = s ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -407,8 +452,8 @@ class ze {
    * @param arr - Array to release.
    * @param emptyConst - Optional empty constant.
    */
-  release(t, s) {
-    if (!(s && t === s)) {
+  release(t, e) {
+    if (!(e && t === e)) {
       if (t.length > this.capacity) {
         this.stats && this.stats.rejected.tooLarge++;
         return;
@@ -429,11 +474,11 @@ class ze {
    */
   getStats() {
     if (!this.stats) return null;
-    const { acquired: t, released: s, rejected: n } = this.stats, i = t - s - (n.frozen + n.tooLarge + n.poolFull);
+    const { acquired: t, released: e, rejected: s } = this.stats, i = t - e - (s.frozen + s.tooLarge + s.poolFull);
     return {
       acquired: t,
-      released: s,
-      rejected: { ...n },
+      released: e,
+      rejected: { ...s },
       leaked: i,
       poolSize: this.pool.length
     };
@@ -449,58 +494,57 @@ class ze {
     });
   }
 }
-const O = Object.freeze(
+const L = Object.freeze(
   []
-), B = new ze();
-function qt(e) {
-  return e !== null && typeof e == "object" && Vt in e;
-}
-function Ve(e) {
-  return e !== null && typeof e == "object" && ge in e;
-}
-function Ie(e) {
-  return e !== null && typeof e == "object" && typeof e.then == "function";
-}
-var re, oe;
-const { IDLE: lt, DIRTY: K, PENDING: _t, RESOLVED: V, REJECTED: nt, HAS_ERROR: ft, RECOMPUTING: st, DISPOSED: wt, IS_COMPUTED: qe } = fe;
-function Xe(e) {
-  return e & V ? ut.RESOLVED : e & _t ? ut.PENDING : e & nt ? ut.REJECTED : ut.IDLE;
-}
-class Qe extends Ee {
-  constructor(t, s = {}) {
-    if (typeof t != "function") throw new z(y.COMPUTED_MUST_BE_FUNCTION);
-    super(), this[oe] = !0, this[re] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = O, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = -1, this._trackEpoch = -1, this._trackLinks = O, this._trackCount = 0, this._value = void 0, this.flags = qe | K | lt, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : Ut, this._onError = s.onError ?? null;
-    const n = s.maxAsyncRetries;
-    if (this._maxAsyncRetries = (n ?? te.MAX_ASYNC_RETRIES) & It, yt.attachDebugInfo(this, "computed", this.id), s.lazy === !1)
+), F = new we();
+function wt(n) {
+  return n !== null && typeof n == "object" && Ut in n;
+}
+function xe(n) {
+  return n !== null && typeof n == "object" && ee in n;
+}
+function se(n) {
+  return n !== null && typeof n == "object" && typeof n.then == "function";
+}
+var Ht, jt;
+const { IDLE: ct, DIRTY: K, PENDING: lt, RESOLVED: H, REJECTED: it, HAS_ERROR: at, RECOMPUTING: tt, DISPOSED: St, IS_COMPUTED: $e } = Qt;
+function Pe(n) {
+  return n & H ? rt.RESOLVED : n & lt ? rt.PENDING : n & it ? rt.REJECTED : rt.IDLE;
+}
+class Me extends Zt {
+  constructor(t, e = {}) {
+    if (typeof t != "function") throw new z(b.COMPUTED_MUST_BE_FUNCTION);
+    super(), this[jt] = !0, this[Ht] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = L, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = Y.UNINITIALIZED, this._trackEpoch = Y.UNINITIALIZED, this._trackLinks = L, this._trackCount = 0, this._value = void 0, this.flags = $e | K | ct, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : Ct, this._onError = e.onError ?? null;
+    const s = e.maxAsyncRetries;
+    if (this._maxAsyncRetries = (s ?? $t.MAX_ASYNC_RETRIES) & mt, Lt.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = k.current;
-    t && de(this, t, this._subscribers);
+    $.current?.addDependency(this);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (V | K | lt)) === V)
+    if ((t & (H | K | ct)) === H)
       return this._value;
-    if (t & wt)
-      throw new z(y.COMPUTED_DISPOSED);
-    if (t & st) {
-      if (this._defaultValue !== Ut) return this._defaultValue;
-      throw new z(y.COMPUTED_CIRCULAR_DEPENDENCY);
+    if (t & St)
+      throw new z(b.COMPUTED_DISPOSED);
+    if (t & tt) {
+      if (this._defaultValue !== Ct) return this._defaultValue;
+      throw new z(b.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (K | lt) && (this._recompute(), this.flags & V))
+    if (t & (K | ct) && (this._recompute(), this.flags & H))
       return this._value;
-    const s = this._defaultValue, n = s !== Ut;
-    if (this.flags & _t) {
-      if (n) return s;
-      throw new z(y.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    const e = this._defaultValue, s = e !== Ct;
+    if (this.flags & lt) {
+      if (s) return e;
+      throw new z(b.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & nt) {
-      if (n) return s;
+    if (this.flags & it) {
+      if (s) return e;
       throw this._error;
     }
     return this._value;
@@ -509,20 +553,20 @@ class Qe extends Ee {
     return this._value;
   }
   get state() {
-    return this._track(), Xe(this.flags);
+    return this._track(), Pe(this.flags);
   }
   get hasError() {
-    return this._track(), this.flags & (nt | ft) ? !0 : this._links.some((t) => t?.node?.flags & ft);
+    return this._track(), this.flags & (it | at) ? !0 : this._links.some((t) => t?.node?.flags & at);
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    if (this._track(), !this.hasError) return xe;
+    if (this._track(), !this.hasError) return Se;
     const t = [];
-    return this._error && t.push(this._error), this._links.forEach((s) => {
-      const n = s.node;
-      n.flags & ft && n.errors.forEach((i) => {
+    return this._error && t.push(this._error), this._links.forEach((e) => {
+      const s = e.node;
+      s.flags & at && s.errors.forEach((i) => {
         i && !t.includes(i) && t.push(i);
       });
     }), Object.freeze(t);
@@ -531,203 +575,257 @@ class Qe extends Ee {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & _t) !== 0;
+    return this._track(), (this.flags & lt) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & V) !== 0;
+    return this._track(), (this.flags & H) !== 0;
   }
   invalidate() {
     this._markDirty();
   }
   dispose() {
-    if (this.flags & wt) return;
+    if (this.flags & St) return;
     const t = this._links;
-    t !== O && (t.forEach((s) => s.unsub?.()), B.release(t), this._links = O), this._subscribers.length = 0, this.flags = wt | K | lt, this._error = null, this._value = void 0;
+    t !== L && (t.forEach((e) => e.unsub?.()), F.release(t), this._links = L), this._subscribers.length = 0, this.flags = St | K | ct, this._error = null, this._value = void 0;
   }
-  [(oe = Vt, re = ge, Symbol.dispose)]() {
+  [(jt = Ut, Ht = ee, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
     if (t._lastSeenEpoch !== this._trackEpoch) {
-      if (t._lastSeenEpoch = this._trackEpoch, this._trackCount < this._trackLinks.length) {
-        const s = this._trackLinks[this._trackCount];
-        s.node = t, s.version = t.version;
-      } else
-        this._trackLinks.push(new Pt(t, t.version));
-      this._trackCount++;
+      if (t._lastSeenEpoch = this._trackEpoch, this._trackLinks === this._links && this._trackCount < this._links.length && this._links[this._trackCount].node === t) {
+        this._links[this._trackCount].version = t.version, this._trackCount++;
+        return;
+      }
+      if (this._trackLinks === this._links) {
+        const e = F.acquire();
+        for (let s = 0; s < this._trackCount; s++)
+          e[s] = this._links[s];
+        this._trackLinks = e;
+      }
+      this._trackCount < this._trackLinks.length ? this._trackLinks[this._trackCount] = new ht(t, t.version) : this._trackLinks.push(new ht(t, t.version)), this._trackCount++;
     }
   }
   _recompute() {
-    if (this.flags & st) return;
-    this.flags |= st;
+    if (this.flags & tt) return;
+    this.flags |= tt;
     const t = this._links;
-    this._trackEpoch = jt(), this._trackLinks = B.acquire(), this._trackCount = 0;
-    let s = !1;
+    this._trackEpoch = kt(), this._trackLinks = t, this._trackCount = 0;
+    let e = !1;
     try {
-      const n = k.run(this, this._fn);
-      this._trackLinks.length = this._trackCount, ee(this._trackLinks, t, this), this._links = this._trackLinks, s = !0, Ie(n) ? this._handleAsyncComputation(n) : this._finalizeResolution(n);
-    } catch (n) {
-      if (!s)
+      const s = $.run(this, this._fn);
+      if (this._trackLinks === t)
+        if (this._trackCount === t.length)
+          e = !0;
+        else {
+          for (let i = this._trackCount; i < t.length; i++)
+            t[i].unsub?.();
+          t.length = this._trackCount, e = !0;
+        }
+      else
+        this._trackLinks.length = this._trackCount, Pt(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
+      se(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+    } catch (s) {
+      if (!e)
         try {
-          this._trackLinks.length = this._trackCount, ee(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
+          if (this._trackLinks === t) {
+            for (let i = this._trackCount; i < t.length; i++)
+              t[i].unsub?.();
+            t.length = this._trackCount, e = !0;
+          } else
+            this._trackLinks.length = this._trackCount, Pt(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
         } catch {
         }
-      this._handleError(n, y.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, b.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      s && t !== O ? B.release(t) : s || B.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = O, this._trackCount = 0, this.flags &= ~st;
+      e ? this._links !== t && t !== L && F.release(t) : this._trackLinks !== t && this._trackLinks !== L && F.release(this._trackLinks), this._trackEpoch = Y.UNINITIALIZED, this._trackLinks = L, this._trackCount = 0, this.flags &= ~tt;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | _t) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % te.MAX_PROMISE_ID;
-    const s = this._promiseId;
+    this.flags = (this.flags | lt) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % $t.MAX_PROMISE_ID;
+    const e = this._promiseId;
     t.then(
-      (n) => {
-        if (s === this._promiseId) {
+      (s) => {
+        if (e === this._promiseId) {
           if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
-            const i = me();
+            const i = te();
             return this._lastDriftEpoch !== i && (this._lastDriftEpoch = i, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
               new z(
                 `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
               ),
-              y.COMPUTED_ASYNC_COMPUTATION_FAILED
+              b.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
           }
-          this._finalizeResolution(n), this._notifySubscribers(n, void 0);
+          this._finalizeResolution(s), this._notifySubscribers(s, void 0);
         }
       },
-      (n) => s === this._promiseId && this._handleError(n, y.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (s) => e === this._promiseId && this._handleError(s, b.COMPUTED_ASYNC_COMPUTATION_FAILED)
     );
   }
   _captureVersionSnapshot() {
     let t = 0;
-    const s = this._links;
-    for (let n = 0, i = s.length; n < i; n++)
-      t = (t << 5) - t + s[n].node.version | 0;
+    const e = this._links;
+    for (let s = 0, i = e.length; s < i; s++)
+      t = (t << 5) - t + e[s].node.version | 0;
     return t;
   }
-  _handleError(t, s, n = !1) {
-    const i = Z(t, z, s);
-    if (!n && !(this.flags & nt) && (this.version = $t(this.version)), this._error = i, this.flags = this.flags & -121 | nt | ft, this._onError)
+  _handleError(t, e, s = !1) {
+    const i = Q(t, z, e);
+    if (!s && !(this.flags & it) && (this.version = vt(this.version)), this._error = i, this.flags = this.flags & -121 | it | at, this._onError)
       try {
         this._onError(i);
-      } catch (r) {
-        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+      } catch (o) {
+        console.error(b.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
       }
-    if (n) throw i;
+    if (s) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & V) || !this._equal(this._value, t)) && (this.version = $t(this.version)), this._value = t, this._error = null, this.flags = (this.flags | V) & -697;
+    (!(this.flags & H) || !this._equal(this._value, t)) && (this.version = vt(this.version)), this._value = t, this._error = null, this.flags = (this.flags | H) & -697;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    this.flags & (st | K) || (this.flags |= K, this._notifySubscribers(void 0, void 0));
+    this.flags & (tt | K) || (this.flags |= K, this._notifySubscribers(void 0, void 0));
   }
 }
-function Ct(e, t = {}) {
-  return new Qe(e, t);
+function gt(n, t = {}) {
+  return new Me(n, t);
 }
-var ce;
-class Ke extends _e {
-  constructor(t, s = {}) {
-    super(), this[ce] = !0, this._cleanup = null, this._links = O, this._nextLinks = null, this._prevLinks = O, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? q.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? q.MAX_EXECUTIONS_PER_EFFECT, this._sync ? (this._executeTask = void 0, this._notifyCallback = () => this.execute()) : (this._executeTask = () => this.execute(), this._notifyCallback = () => rt.schedule(this._executeTask)), yt.attachDebugInfo(this, "effect", this.id);
+var Vt;
+class Fe extends Wt {
+  constructor(t, e = {}) {
+    super(), this[Vt] = !0, this._cleanup = null, this._links = L, this._nextLinks = null, this._prevLinks = L, this._currentEpoch = Y.UNINITIALIZED, this._lastFlushEpoch = Y.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? j.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? j.MAX_EXECUTIONS_PER_EFFECT, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => ot.schedule(this), Lt.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & L.DISPOSED)
-      throw new J(y.EFFECT_DISPOSED);
+    if (this.flags & w.DISPOSED)
+      throw new q(b.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & L.DISPOSED || (this.flags |= L.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== O && B.release(this._links), this._links = O, this._prevLinks = O);
+    this.flags & w.DISPOSED || (this.flags |= w.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== L && F.release(this._links), this._links = L, this._prevLinks = L);
   }
-  [(ce = Ge, Symbol.dispose)]() {
+  [(Vt = ke, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & L.EXECUTING)) return;
-    const s = this._currentEpoch;
-    if (t._lastSeenEpoch === s) return;
-    t._lastSeenEpoch = s;
-    const n = this._nextLinks, i = this._prevLinks, r = i.findIndex((o) => o && o.node === t && o.unsub);
-    if (r !== -1) {
-      const o = i[r];
-      o.version = t.version, n.push(o), i[r] = null;
+    if (!(this.flags & w.EXECUTING)) return;
+    const e = this._currentEpoch;
+    if (t._lastSeenEpoch === e) return;
+    t._lastSeenEpoch = e;
+    const s = this._prevLinks;
+    if (this._nextLinks === s && this._trackCount < s.length && s[this._trackCount].node === t) {
+      s[this._trackCount].version = t.version, this._trackCount++;
       return;
     }
-    try {
-      const o = t.subscribe(this._notifyCallback);
-      n.push(new Pt(t, t.version, o));
-    } catch (o) {
-      const l = Z(o, J, y.EFFECT_EXECUTION_FAILED);
-      if (console.error(l), this._onError)
-        try {
-          this._onError(l);
-        } catch {
-        }
-      n.push(new Pt(t, t.version, void 0));
+    if (this._nextLinks === s) {
+      const r = F.acquire();
+      for (let c = 0; c < this._trackCount; c++)
+        r[c] = s[c];
+      this._nextLinks = r;
     }
+    const i = this._nextLinks;
+    let o = -1;
+    for (let r = this._trackCount; r < s.length; r++) {
+      const c = s[r];
+      if (c && c.node === t && c.unsub) {
+        o = r;
+        break;
+      }
+    }
+    if (o !== -1) {
+      const r = s[o];
+      r.version = t.version, i[this._trackCount] = r, s[o] = null;
+    } else
+      try {
+        const r = t.subscribe(this._notifyCallback);
+        i[this._trackCount] = new ht(t, t.version, r);
+      } catch (r) {
+        const c = Q(r, q, b.EFFECT_EXECUTION_FAILED);
+        if (console.error(c), this._onError)
+          try {
+            this._onError(c);
+          } catch {
+          }
+        i[this._trackCount] = new ht(t, t.version, void 0);
+      }
+    this._trackCount++;
   }
   /**
    * Executes effect with tracking.
    */
   execute(t = !1) {
-    if (this.flags & (L.DISPOSED | L.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= L.EXECUTING, this._execCleanup(), this._prevLinks = this._links;
-    const s = B.acquire();
-    this._nextLinks = s, this._currentEpoch = jt();
-    let n = !1;
+    if (this.flags & (w.DISPOSED | w.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags |= w.EXECUTING, this._execCleanup(), this._prevLinks = this._links, this._nextLinks = this._links, this._currentEpoch = kt(), this._trackCount = 0;
+    let e = !1;
     try {
-      const i = k.run(this, this._fn);
-      this._links = s, n = !0, Ie(i) ? this._handleAsyncResult(i) : this._cleanup = typeof i == "function" ? i : null;
-    } catch (i) {
-      this._links = s, n = !0, this._handleExecutionError(i), this._cleanup = null;
+      const s = $.run(this, this._fn);
+      if (this._nextLinks === this._prevLinks)
+        if (this._trackCount === this._prevLinks.length)
+          e = !0;
+        else {
+          for (let i = this._trackCount; i < this._prevLinks.length; i++)
+            this._prevLinks[i]?.unsub?.();
+          this._prevLinks.length = this._trackCount, e = !0;
+        }
+      else
+        this._nextLinks.length = this._trackCount, e = !0;
+      this._links = this._nextLinks, se(s) ? this._handleAsyncResult(s) : this._cleanup = typeof s == "function" ? s : null;
+    } catch (s) {
+      if (!e)
+        if (this._nextLinks === this._prevLinks) {
+          for (let i = this._trackCount; i < this._prevLinks.length; i++)
+            this._prevLinks[i]?.unsub?.();
+          this._prevLinks.length = this._trackCount, e = !0;
+        } else
+          this._nextLinks.length = this._trackCount, e = !0;
+      this._links = this._nextLinks, this._handleExecutionError(s), this._cleanup = null;
     } finally {
-      this._finalizeDependencies(n, this._prevLinks, s), this.flags &= -9;
+      this._finalizeDependencies(e, this._prevLinks, this._nextLinks), this.flags &= -9;
     }
   }
   _handleAsyncResult(t) {
-    const s = ++this._execId;
+    const e = ++this._execId;
     t.then(
-      (n) => {
-        if (s !== this._execId || this.flags & L.DISPOSED) {
-          if (typeof n == "function")
+      (s) => {
+        if (e !== this._execId || this.flags & w.DISPOSED) {
+          if (typeof s == "function")
             try {
-              n();
+              s();
             } catch (i) {
-              this._handleExecutionError(i, y.EFFECT_CLEANUP_FAILED);
+              this._handleExecutionError(i, b.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
-        typeof n == "function" && (this._cleanup = n);
+        typeof s == "function" && (this._cleanup = s);
       },
-      (n) => s === this._execId && this._handleExecutionError(n)
+      (s) => e === this._execId && this._handleExecutionError(s)
     );
   }
-  _finalizeDependencies(t, s, n) {
-    this._nextLinks = null, this._prevLinks = O, t ? (s.forEach((i) => i?.unsub?.()), s !== O && B.release(s)) : (this._unsubLinks(n), B.release(n));
+  _finalizeDependencies(t, e, s) {
+    this._nextLinks = null, this._prevLinks = L, t ? s !== e && e !== L && (e.forEach((i) => i?.unsub?.()), F.release(e)) : s !== e && s !== L && s && (this._unsubLinks(s), F.release(s));
   }
   _unsubLinks(t) {
-    t.forEach((s) => s?.unsub?.());
+    t.forEach((e) => e?.unsub?.());
   }
   _isDirty() {
-    const t = this._links, s = k.current;
-    k.current = null;
+    const t = this._links, e = $.current;
+    $.current = null;
     try {
-      return t.some((n) => {
-        const i = n.node;
-        if (i.flags & fe.IS_COMPUTED)
+      return t.some((s) => {
+        const i = s.node;
+        if (i.flags & Qt.IS_COMPUTED)
           try {
             i.value;
           } catch {
             return !0;
           }
-        return i.version !== n.version;
+        return i.version !== s.version;
       });
     } finally {
-      k.current = s;
+      $.current = e;
     }
   }
   _execCleanup() {
@@ -735,57 +833,57 @@ class Ke extends _e {
       try {
         this._cleanup();
       } catch (t) {
-        this._handleExecutionError(t, y.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(t, b.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const t = me();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Be() > q.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    const t = te();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Oe() > j.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
   }
   get isDisposed() {
-    return (this.flags & L.DISPOSED) !== 0;
+    return (this.flags & w.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & L.EXECUTING) !== 0;
+    return (this.flags & w.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const s = new J(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${zt}`
+    const e = new q(
+      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${At}`
     );
-    throw this.dispose(), console.error(s), s;
+    throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(t, s = y.EFFECT_EXECUTION_FAILED) {
-    const n = Z(t, J, s);
-    if (console.error(n), this._onError)
+  _handleExecutionError(t, e = b.EFFECT_EXECUTION_FAILED) {
+    const s = Q(t, q, e);
+    if (console.error(s), this._onError)
       try {
-        this._onError(n);
+        this._onError(s);
       } catch (i) {
-        console.error(Z(i, J, y.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(Q(i, q, b.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
 }
-function X(e, t = {}) {
-  if (typeof e != "function")
-    throw new J(y.EFFECT_MUST_BE_FUNCTION);
-  const s = new Ke(e, t);
-  return s.execute(), s;
+function V(n, t = {}) {
+  if (typeof n != "function")
+    throw new q(b.EFFECT_MUST_BE_FUNCTION);
+  const e = new Fe(n, t);
+  return e.execute(), e;
 }
-function ye(e) {
-  if (typeof e != "function")
-    throw new TypeError("Batch callback must be a function");
-  rt.startBatch();
+function ne(n) {
+  if (typeof n != "function")
+    throw new TypeError(b.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  ot.startBatch();
   try {
-    return e();
+    return n();
   } finally {
-    rt.endBatch();
+    ot.endBatch();
   }
 }
-const d = {
+const E = {
   /** Used by the SPA router ($.route). */
   ROUTE: "[atom-route]",
   /** Used by all reactive binding helpers (bindText, bindCss, bindAttr, …). */
@@ -794,268 +892,258 @@ const d = {
   LIST: "[atom-list]",
   /** Used by mount/unmount lifecycle helpers. */
   MOUNT: "[atom-mount]"
-}, dt = Object.freeze({
+}, et = Object.freeze({
   mode: "hash",
   basePath: "",
   autoBindLinks: !1,
   activeClass: "active"
-}), Ye = {
+}), Be = {
+  /** Default DOM event to trigger synchronization. */
   EVENT: "input"
-}, We = /* @__PURE__ */ new Set(["input", "select", "textarea"]), Je = /* @__PURE__ */ new Set([
-  "innerHTML",
-  "outerHTML",
-  "srcdoc",
-  "__proto__",
-  "constructor",
-  "prototype"
-]), S = {
-  ROUTE_NOT_FOUND: (e) => `Route "${e}" not found and no notFound route configured`,
-  TEMPLATE_NOT_FOUND: (e) => `Template "${e}" not found`,
-  TARGET_NOT_FOUND: (e) => `Target element "${e}" not found`,
-  MALFORMED_URI: (e) => `Malformed URI component: ${e}`,
-  /** Emitted when sanitizeHtml modifies the input. Prefixed at call site with LOG_PREFIXES.BINDING or LIST to identify the originating subsystem. */
-  UNSAFE_CONTENT: () => "Unsafe content neutralized during sanitization.",
-  /** Emitted by bindCss when a CSS style property value contains a dangerous protocol. */
-  BLOCKED_DANGEROUS_CSS_VALUE: (e) => `Blocked dangerous value in CSS style property "${e}".`,
-  BLOCKED_EVENT_HANDLER: (e) => `Blocked setting dangerous event handler attribute "${e}".`,
-  BLOCKED_PROTOCOL: (e) => `Blocked dangerous protocol in "${e}" attribute.`,
-  BLOCKED_DANGEROUS_PROP: (e) => `Blocked setting dangerous property "${e}". Use html binding for sanitized HTML.`,
-  INVALID_INPUT_ELEMENT: (e) => `Val binding used on non-input element <${e}>.`,
-  MISSING_SOURCE: (e) => `[${e}] source is required when prop/name is a string.`,
-  MISSING_CONDITION: (e) => `[${e}] condition is required when className is a string.`,
-  DUPLICATE_KEY: (e, t) => `Duplicate key "${e}" at index ${t}.`,
-  UPDATER_ERROR: (e) => `Updater threw in binding "${e}"`,
-  EFFECT_DISPOSE_ERROR: () => "Effect dispose error",
-  BINDING_CLEANUP_ERROR: () => "Binding cleanup error",
-  PARSE_ERROR: () => "parse() threw during DOM→Atom sync",
-  MOUNT_ERROR: () => "Mount error",
-  MOUNT_CLEANUP_ERROR: () => "Cleanup error"
-};
-function Ce(e) {
-  return qt(e);
-}
-function Xt(e) {
-  const t = e.tagName.toLowerCase();
-  if (e.id) return `${t}#${e.id}`;
-  const s = e.classList, n = s.length;
-  if (n === 0) return t;
-  let i = t;
-  for (let r = 0; r < n; r++)
-    i += `.${s[r]}`;
-  return i;
-}
-const Ze = /* @__PURE__ */ new Set([
-  "href",
+}, ie = {
+  /** Default duration in ms for visual highlighting during DOM updates. */
+  HIGHLIGHT_DURATION_MS: 500
+}, Ge = /* @__PURE__ */ new Set(["input", "select", "textarea"]), He = /* @__PURE__ */ new Set([
   "src",
+  "href",
   "action",
   "formaction",
-  "xlink:href",
   "data",
   "poster",
-  "srcset",
   "background",
   "cite",
   "longdesc",
   "profile",
   "usemap",
   "classid",
-  "codebase"
-]), ts = Object.prototype.hasOwnProperty, es = /^\s*(?:javascript|vbscript)\s*:/i, ss = (
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: Intentionally matching control characters for XSS sanitization
-  /(?:expression\s*\(|behavior\s*:|(?:\\[0-9a-f]{1,6}\s*|[\s\x00-\x20/'"])*(?: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|d\s*a\s*t\s*a)\s*:(?!image\/))/i
-), ns = /url\s*\(\s*(?:["']?\s*)?(?:javascript|vbscript)\s*:/i, is = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, rs = /<\?[\s\S]*?\?>/g, os = /(<(script|iframe|object|embed|base|meta|applet|noscript|form|style|link)\b[^>]*>([\s\S]*?)<\/\2>|<(script|iframe|object|embed|base|meta|applet|noscript|form|style|link)\b[^>]*\/?>)/gi, cs = /(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, as = /data\s*:\s*(?:text\/(?:html|javascript|vbscript|xml)|application\/(?:javascript|xhtml\+xml|xml|x-shockwave-flash)|image\/svg\+xml)/gi, hs = /\bon\w+\s*=/gim, us = new RegExp(ss.source, "gim");
-function Bt(e) {
-  let t = String(e ?? "");
-  t = t.replace(is, ""), t = t.replace(rs, "");
-  let s;
-  do
-    s = t, t = t.replace(os, "");
-  while (t !== s);
-  return t = t.replace(cs, "data-unsafe-protocol:"), t = t.replace(as, "data-unsafe-protocol:"), t = t.replace(hs, "data-unsafe-attr="), t = t.replace(us, "data-unsafe-css:"), t;
-}
-function ls(e, t) {
-  return Ze.has(e.toLowerCase()) ? es.test(t) : !1;
-}
-function fs(e) {
-  return e.toLowerCase().includes("url(") ? ns.test(e) : !1;
-}
-function ds(e, t) {
-  if (e === t) return !0;
-  if (e === null || t === null || typeof e != "object" || typeof t != "object") return !1;
-  const s = Object.keys(e), n = Object.keys(t);
-  if (s.length !== n.length) return !1;
-  const i = e, r = t;
-  for (let o = 0; o < s.length; o++) {
-    const l = s[o];
-    if (!ts.call(r, l) || i[l] !== r[l])
+  "codebase",
+  "xlink:href"
+]), je = /* @__PURE__ */ new Set([
+  "innerHTML",
+  "outerHTML",
+  "srcdoc",
+  "__proto__",
+  "constructor",
+  "prototype"
+]), S = {
+  ROUTE: {
+    NOT_FOUND: (n) => `Route "${n}" not found and no notFound route configured`,
+    TEMPLATE_NOT_FOUND: (n) => `Template "${n}" not found`,
+    TARGET_NOT_FOUND: (n) => `Target element "${n}" not found`,
+    MALFORMED_URI: (n) => `Malformed URI component: ${n}`
+  },
+  SECURITY: {
+    /** Emitted when sanitizeHtml modifies the input. */
+    UNSAFE_CONTENT: () => "Unsafe content neutralized during sanitization.",
+    /** Emitted when a CSS style property value contains a dangerous protocol. */
+    BLOCKED_CSS_VALUE: (n) => `Blocked dangerous value in CSS style property "${n}".`,
+    BLOCKED_EVENT_HANDLER: (n) => `Blocked setting dangerous event handler attribute/property "${n}".`,
+    BLOCKED_PROTOCOL: (n) => `Blocked dangerous protocol in "${n}".`,
+    BLOCKED_PROP: (n) => `Blocked setting dangerous property "${n}". Use html binding for sanitized HTML.`
+  },
+  BINDING: {
+    INVALID_INPUT_ELEMENT: (n) => `Val binding used on non-input element <${n}>.`,
+    MISSING_SOURCE: (n) => `[${n}] source is required when prop/name is a string.`,
+    MISSING_CONDITION: (n) => `[${n}] condition is required when className is a string.`,
+    UPDATER_ERROR: (n, t) => `Updater threw in binding "${n}"${t ? " (static)" : ""}`,
+    CLEANUP_ERROR: (n) => `Binding cleanup error${n ? `: ${n}` : ""}`,
+    PARSE_ERROR: (n) => `parse() threw during DOM→Atom sync${n ? `: ${n}` : ""}`
+  },
+  LIST: {
+    DUPLICATE_KEY: (n, t, e) => `Duplicate key "${n}" at index ${t} in atomList <${e}>.`
+  },
+  MOUNT: {
+    ERROR: (n) => `Mount error${n ? ` in component <${n}>` : ""}`,
+    CLEANUP_ERROR: (n) => `Cleanup error${n ? ` in component <${n}>` : ""}`
+  },
+  CORE: {
+    EFFECT_DISPOSE_ERROR: (n) => `Effect dispose error${n ? `: ${n}` : ""}`
+  }
+};
+function oe(n) {
+  return wt(n);
+}
+function X(n) {
+  const t = n.tagName.toLowerCase();
+  if (n.id) return `${t}#${n.id}`;
+  const e = n.classList, s = e.length;
+  if (s === 0) return t;
+  let i = t;
+  for (let o = 0; o < s; o++)
+    i += `.${e[o]}`;
+  return i;
+}
+const Z = Object.prototype.hasOwnProperty;
+function Ve(n, t) {
+  if (n === t) return !0;
+  if (n === null || t === null || typeof n != "object" || typeof t != "object") return !1;
+  const e = Object.keys(n), s = Object.keys(t);
+  if (e.length !== s.length) return !1;
+  const i = n, o = t;
+  for (let r = 0; r < e.length; r++) {
+    const c = e[r];
+    if (!Z.call(o, c) || i[c] !== o[c])
       return !1;
   }
   return !0;
 }
-function _s(e) {
-  const t = e.length;
+function ze(n) {
+  const t = n.length;
   if (t === 0) return new Int32Array(0);
-  const s = new Int32Array(t).fill(-1), n = new Int32Array(t);
+  const e = new Int32Array(t).fill(-1), s = new Int32Array(t);
   let i = 0;
-  for (let o = 0; o < t; o++) {
-    const l = e[o];
-    if (l === void 0 || l === -1) continue;
-    const p = i > 0 ? n[i - 1] : void 0;
-    if (i === 0 || p !== void 0 && (e[p] ?? -1) < l) {
-      s[o] = p ?? -1, n[i++] = o;
+  for (let r = 0; r < t; r++) {
+    const c = n[r];
+    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) {
+      e[r] = a ?? -1, s[i++] = r;
       continue;
     }
-    let C = 0, b = i - 1;
-    for (; C < b; ) {
-      const E = C + b >>> 1, m = n[E];
-      m !== void 0 && (e[m] ?? -1) < l ? C = E + 1 : b = E;
+    let l = 0, u = i - 1;
+    for (; l < u; ) {
+      const y = l + u >>> 1, p = s[y];
+      p !== void 0 && (n[p] ?? -1) < c ? l = y + 1 : u = y;
     }
-    const N = n[C];
-    N !== void 0 && l < (e[N] ?? Number.MAX_SAFE_INTEGER) && (C > 0 && (s[o] = n[C - 1] ?? -1), n[C] = o);
+    const _ = s[l];
+    _ !== void 0 && c < (n[_] ?? Number.MAX_SAFE_INTEGER) && (l > 0 && (e[r] = s[l - 1] ?? -1), s[l] = r);
   }
-  const r = new Int32Array(i);
+  const o = new Int32Array(i);
   if (i > 0) {
-    let o = n[i - 1];
-    for (let l = i - 1; l >= 0 && o !== void 0 && o !== -1; l--)
-      r[l] = o, o = s[o];
+    let r = s[i - 1];
+    for (let c = i - 1; c >= 0 && r !== void 0 && r !== -1; c--)
+      o[c] = r, r = e[r];
   }
-  return r;
+  return o;
 }
-const Es = {}, be = 600, ps = `${be / 1e3}s`;
-function ms() {
+const Ke = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 }, qe = `${ie.HIGHLIGHT_DURATION_MS / 1e3}s`;
+function Xe() {
   if (typeof window < "u") {
-    const e = window.__ATOM_DEBUG__;
-    if (typeof e == "boolean") return e;
+    const n = window.__ATOM_DEBUG__;
+    if (typeof n == "boolean") return n;
+  }
+  try {
+    if (Ke?.VITE_ATOM_DEBUG === "true") return !0;
+  } catch {
+  }
+  try {
+    if (globalThis.process?.env?.VITE_ATOM_DEBUG === "true")
+      return !0;
+  } catch {
   }
-  return Es?.VITE_ATOM_DEBUG === "true";
+  return !1;
 }
-let Y = ms();
-const f = {
+let zt = Xe();
+const d = {
   get enabled() {
-    return Y;
+    if (typeof window < "u") {
+      const n = window.__ATOM_DEBUG__;
+      if (typeof n == "boolean") return n;
+    }
+    return zt;
   },
-  set enabled(e) {
-    Y = e;
+  set enabled(n) {
+    zt = n;
   },
   /**
    * Logs a message only when debug mode is active.
    */
-  log(e, ...t) {
-    Y && console.log(`${d.MOUNT} ${e}:`, ...t);
+  log(n, ...t) {
+    this.enabled && console.log(`${n}`, ...t);
   },
   /**
    * Logs an atom value change only when debug mode is active.
    */
-  atomChanged(e, t, s) {
-    Y && console.log(
-      `${d.MOUNT} Atom "${e ?? "anonymous"}" changed:`,
-      t,
-      "→",
-      s
-    );
+  atomChanged(n, t, e, s) {
+    this.enabled && console.log(`${n} Atom "${t ?? "anonymous"}" changed:`, e, "→", s);
   },
   /**
    * Logs a DOM update and triggers a visual highlight flash.
-   * Only active when debug mode is enabled.
-   *
-   * @param target - The element or jQuery wrapper that was updated.
-   * @param type - The binding type (e.g. 'text', 'checked', 'attr.href').
-   * @param value - The new value that was applied.
    */
-  domUpdated(e, t, s) {
-    if (!Y) return;
-    const n = e instanceof Element ? e : e[0];
-    n instanceof HTMLElement && (console.log(`${d.MOUNT} DOM updated: ${Xt(n)}.${t} =`, s), ys(n));
+  domUpdated(n, t, e, s) {
+    if (!this.enabled) return;
+    const i = t instanceof Element ? t : t[0];
+    i && (console.log(`${n} DOM updated: ${X(i)}.${e} =`, s), Qe(i));
   },
   /**
    * Logs a cleanup event only when debug mode is active.
    */
-  cleanup(e) {
-    Y && console.log(`${d.MOUNT} Cleanup: ${e}`);
+  cleanup(n, t) {
+    this.enabled && console.log(`${n} Cleanup: ${t}`);
   },
   /**
-   * Unconditional warning for runtime errors and unexpected states.
-   * Not gated by debugEnabled — these are always surfaced regardless of
-   * debug mode because they indicate real problems (e.g. dispose failures,
-   * missing route targets, pushState security errors).
-   *
-   * `prefix` is the subsystem tag (e.g. `LOG_PREFIXES.ROUTE`) so that the
-   * originating subsystem appears in the log rather than the generic MOUNT tag.
-   * Pass an empty string to emit a prefix-free message.
+   * Unconditional warning for runtime errors.
    */
-  warn(e, t, ...s) {
-    console.warn(`${e} ${t}`, ...s);
+  warn(n, t, ...e) {
+    console.warn(`${n} ${t}`, ...e);
   },
   /**
    * Unconditional error for binding failures.
-   * Not gated by debugEnabled — binding errors are always surfaced because
-   * they indicate a broken updater that silently stopped applying values.
    */
-  error(e, t, s) {
-    console.error(`${e} ${t}`, s);
-  }
-}, Ht = "atom-debug-highlight", gs = "data-atom-debug";
-let ae;
-function Is() {
-  if (ae?.deref()?.isConnected) return;
-  const e = document.createElement("style");
-  e.setAttribute(gs, ""), e.textContent = `.${Ht}{outline:2px solid rgba(255,68,68,0.8);outline-offset:1px;transition:outline ${ps} ease-out}`, document.head.appendChild(e), ae = new WeakRef(e);
-}
-const kt = /* @__PURE__ */ new WeakMap(), xt = /* @__PURE__ */ new WeakMap();
-function ys(e) {
-  if (!e.isConnected) return;
-  Is();
-  const t = xt.get(e);
+  error(n, t, e) {
+    console.error(`${n} ${t}`, e);
+  }
+}, Ot = "atom-debug-highlight", Kt = "data-atom-debug";
+let st;
+function Ye() {
+  if ((st instanceof HTMLStyleElement ? st : st?.deref())?.isConnected || document.querySelector(`style[${Kt}]`)) return;
+  const t = document.createElement("style");
+  t.setAttribute(Kt, ""), t.textContent = `.${Ot}{outline:2px solid rgba(255,68,68,0.8);outline-offset:1px;transition:outline ${qe} ease-out}`, document.head.appendChild(t), typeof WeakRef < "u" ? st = new WeakRef(t) : st = t;
+}
+const Nt = /* @__PURE__ */ new WeakMap(), bt = /* @__PURE__ */ new WeakMap();
+function Qe(n) {
+  if (!d.enabled || !n.isConnected) return;
+  Ye();
+  const t = bt.get(n);
   t !== void 0 && cancelAnimationFrame(t);
-  const s = kt.get(e);
-  s !== void 0 && clearTimeout(s);
-  const n = requestAnimationFrame(() => {
-    xt.delete(e), e.classList.add(Ht), kt.set(
-      e,
+  const e = Nt.get(n);
+  e !== void 0 && clearTimeout(e);
+  const s = requestAnimationFrame(() => {
+    bt.delete(n), n.isConnected && (n.classList.add(Ot), Nt.set(
+      n,
       setTimeout(() => {
-        e.classList.remove(Ht), kt.delete(e);
-      }, be)
-    );
+        n.isConnected && n.classList.remove(Ot), Nt.delete(n);
+      }, ie.HIGHLIGHT_DURATION_MS)
+    ));
   });
-  xt.set(e, n);
+  bt.set(n, s);
 }
-function Se(e, t) {
-  return Ft(e, t);
+function re(n, t) {
+  return Dt(n, t);
 }
-Object.defineProperty(Se, "debug", {
+Object.defineProperty(re, "debug", {
   enumerable: !0,
   // configurable: true allows tests and advanced consumers to redefine or
   // delete the accessor if needed. The default (false) would permanently lock
   // the property on the function object.
   configurable: !0,
   get() {
-    return f.enabled;
+    return d.enabled;
   },
-  set(e) {
-    f.enabled = e;
+  set(n) {
+    d.enabled = n;
   }
 });
-function Cs() {
-  return new Promise((e) => setTimeout(e, 0));
-}
-const bs = {
-  // `atom` carries a runtime `debug` accessor added via Object.defineProperty.
-  // TypeScript cannot see it through the declared function type, so the double
-  // cast is unavoidable. The NamespaceExtensions annotation still verifies all
-  // other fields; only `atom`'s shape escapes static checking here.
-  atom: Se,
-  computed: Ct,
-  effect: X,
-  batch: ye,
-  untracked: H,
-  isAtom: qt,
-  isComputed: Ve,
-  isReactive: Ce,
-  nextTick: Cs
+function We() {
+  return new Promise((n) => setTimeout(n, 0));
+}
+const Ze = {
+  // Double cast required for the `atom` function due to its runtime `debug`
+  // accessor (see JSDoc for `function atom` above). All other fields are
+  // fully verified by `NamespaceExtensions`.
+  atom: re,
+  computed: gt,
+  effect: V,
+  batch: ne,
+  untracked: P,
+  isAtom: wt,
+  isComputed: xe,
+  isReactive: oe,
+  nextTick: We
 };
-c.extend(bs);
-const W = "_aes-bound";
-class Ss {
+h.extend(Ze);
+const G = "_aes-bound";
+class Je {
   constructor() {
     this.records = /* @__PURE__ */ new WeakMap(), this.preservedNodes = /* @__PURE__ */ new WeakSet(), this.ignoredNodes = /* @__PURE__ */ new WeakSet();
   }
@@ -1078,20 +1166,20 @@ class Ss {
   // Tracking
   // --------------------------------------------------------------------------
   getOrCreateRecord(t) {
-    let s = this.records.get(t);
-    return s || (s = {}, this.records.set(t, s), t.classList.add(W)), s;
+    let e = this.records.get(t);
+    return e || (e = { effects: void 0, cleanups: void 0, componentCleanup: void 0 }, this.records.set(t, e), t.classList.add(G)), e;
   }
-  trackEffect(t, s) {
-    const n = this.getOrCreateRecord(t);
-    n.effects ??= [], n.effects.push(s);
+  trackEffect(t, e) {
+    const s = this.getOrCreateRecord(t);
+    s.effects ??= [], s.effects.push(e);
   }
-  trackCleanup(t, s) {
-    const n = this.getOrCreateRecord(t);
-    n.cleanups ??= [], n.cleanups.push(s);
+  trackCleanup(t, e) {
+    const s = this.getOrCreateRecord(t);
+    s.cleanups ??= [], s.cleanups.push(e);
   }
-  setComponentCleanup(t, s) {
-    const n = this.getOrCreateRecord(t);
-    n.componentCleanup = s;
+  setComponentCleanup(t, e) {
+    const s = this.getOrCreateRecord(t);
+    s.componentCleanup = e;
   }
   hasBind(t) {
     return this.records.has(t);
@@ -1100,644 +1188,923 @@ class Ss {
   // Cleanup
   // --------------------------------------------------------------------------
   cleanup(t) {
-    const s = this.records.get(t);
-    if (!s) {
-      t.isConnected && t.classList.remove(W), this.preservedNodes.delete(t), this.ignoredNodes.delete(t);
+    const e = this.records.get(t);
+    if (!e) {
+      t.nodeType === 1 && t.classList.remove(G), this.preservedNodes.delete(t), this.ignoredNodes.delete(t);
       return;
     }
-    if (this.records.delete(t), this.preservedNodes.delete(t), this.ignoredNodes.delete(t), t.isConnected && t.classList.remove(W), f.enabled && f.cleanup(Xt(t)), s.componentCleanup)
-      try {
-        s.componentCleanup();
-      } catch (n) {
-        f.error(d.MOUNT, S.MOUNT_CLEANUP_ERROR(), n);
-      }
-    s.effects?.forEach((n) => {
-      try {
-        n.dispose();
-      } catch (i) {
-        f.error(d.BINDING, S.EFFECT_DISPOSE_ERROR(), i);
-      }
-    }), s.cleanups?.forEach((n) => {
+    if (this.records.delete(t), this.preservedNodes.delete(t), this.ignoredNodes.delete(t), t.nodeType === 1 && t.classList.remove(G), d.enabled) {
+      const s = t.nodeType === 1 ? X(t) : t.nodeName || "Node";
+      d.cleanup(E.BINDING, s);
+    }
+    if (e.componentCleanup)
       try {
-        n();
-      } catch (i) {
-        f.error(d.BINDING, S.BINDING_CLEANUP_ERROR(), i);
+        e.componentCleanup();
+      } catch (s) {
+        const i = t.nodeType === 1 ? X(t) : "Node";
+        d.error(E.MOUNT, S.MOUNT.CLEANUP_ERROR(i), s);
       }
-    });
+    if (e.effects) {
+      const s = e.effects;
+      for (let i = 0, o = s.length; i < o; i++)
+        try {
+          s[i].dispose();
+        } catch (r) {
+          const c = t.nodeType === 1 ? X(t) : "Node";
+          d.error(E.BINDING, S.CORE.EFFECT_DISPOSE_ERROR(c), r);
+        }
+    }
+    if (e.cleanups) {
+      const s = e.cleanups;
+      for (let i = 0, o = s.length; i < o; i++)
+        try {
+          s[i]();
+        } catch (r) {
+          const c = t.nodeType === 1 ? X(t) : "Node";
+          d.error(E.BINDING, S.BINDING.CLEANUP_ERROR(c), r);
+        }
+    }
   }
   cleanupDescendants(t) {
-    const s = t.querySelectorAll(`.${W}`);
-    for (const n of s)
-      this.records.has(n) ? this.cleanup(n) : (n.classList.remove(W), f.warn(
-        d.BINDING,
-        `${W} class found on unregistered element:`,
-        n
-      ));
+    const e = "getElementsByClassName" in t && typeof t.getElementsByClassName == "function" ? t.getElementsByClassName(G) : t.querySelectorAll(`.${G}`);
+    for (let s = e.length - 1; s >= 0; s--) {
+      const i = e[s];
+      i && (this.records.has(i) ? this.cleanup(i) : (i.classList.remove(G), d.enabled && d.warn(
+        E.BINDING,
+        `${G} class found on unregistered element:`,
+        i
+      )));
+    }
   }
   cleanupTree(t) {
-    this.cleanupDescendants(t), this.cleanup(t);
+    (t.nodeType === 1 || t.nodeType === 11) && this.cleanupDescendants(t), this.cleanup(t);
   }
 }
-const g = new Ss();
-let it = null, Et = null;
-function Rs(e) {
-  if (it !== null) {
-    Et !== e && f.warn(
-      d.BINDING,
-      "enableAutoCleanup() called with a different root while already active. Observation was NOT switched — call disableAutoCleanup() first.",
-      { current: Et, requested: e }
-    );
+const R = new Je(), ft = /* @__PURE__ */ new Map();
+function ts(n) {
+  if (ft.has(n))
     return;
-  }
-  Et = e, it = new MutationObserver((t) => {
-    for (const s of t)
-      for (const n of s.removedNodes)
-        n.nodeType === 1 && (n.isConnected || g.isKept(n) || g.isIgnored(n) || g.cleanupTree(n));
-  }), it.observe(e, { childList: !0, subtree: !0 });
+  const t = new MutationObserver((e) => {
+    for (let s = 0, i = e.length; s < i; s++) {
+      const o = e[s].removedNodes;
+      for (let r = 0, c = o.length; r < c; r++) {
+        const a = o[r];
+        a.nodeType === 1 && (a.isConnected || R.isKept(a) || R.isIgnored(a) || R.cleanupTree(a));
+      }
+    }
+  });
+  t.observe(n, { childList: !0, subtree: !0 }), ft.set(n, t);
 }
 function Gs() {
-  it?.disconnect(), it = null, Et = null;
+  ft.forEach((n) => n.disconnect()), ft.clear();
 }
-function Q(e, t, s, n) {
-  if (Ce(t)) {
+function B(n, t, e, s) {
+  if (oe(t)) {
     const i = t;
-    g.trackEffect(
-      e,
-      X(() => {
-        const r = i.value;
-        H(() => {
-          try {
-            s(r);
-          } catch (o) {
-            f.error(d.BINDING, `${S.UPDATER_ERROR(n)}:`, o);
-            return;
-          }
-          f.enabled && f.domUpdated(e, n, r);
-        });
-      })
+    R.trackEffect(
+      n,
+      V(
+        () => {
+          const o = i.value;
+          P(() => {
+            try {
+              e(o);
+            } catch (r) {
+              d.error(E.BINDING, S.BINDING.UPDATER_ERROR(s), r);
+              return;
+            }
+            d.enabled && d.domUpdated(E.BINDING, n, s, o);
+          });
+        },
+        { name: s }
+      )
     );
-  } else {
-    try {
-      s(t);
-    } catch (i) {
-      f.error(d.BINDING, `${S.UPDATER_ERROR(n)} (static):`, i);
-      return;
-    }
-    f.enabled && f.domUpdated(e, n, t);
-  }
+  } else
+    P(() => {
+      try {
+        e(t);
+      } catch (i) {
+        d.error(E.BINDING, S.BINDING.UPDATER_ERROR(s, !0), i);
+        return;
+      }
+      d.enabled && d.domUpdated(E.BINDING, n, s, t);
+    });
 }
-const F = /* @__PURE__ */ Symbol("atom-effect-internal"), mt = /* @__PURE__ */ new WeakMap();
-let w = null;
-const Re = (e) => {
-  if (e[F]) return e;
-  let t = mt.get(e);
-  return t || (t = function(...s) {
-    return ye(() => e.apply(this, s));
-  }, t[F] = !0, mt.set(e, t)), t;
+const dt = /* @__PURE__ */ Symbol("atom-effect-internal"), _t = /* @__PURE__ */ new WeakMap();
+let x = null;
+const ce = (n) => {
+  if (n[dt]) return n;
+  let t = _t.get(n);
+  return t || (t = function(...e) {
+    return ne(() => n.apply(this, e));
+  }, t[dt] = !0, _t.set(n, t)), t;
 };
-function Ts(e) {
-  const t = {};
-  return Object.keys(e).forEach((s) => {
-    const n = e[s];
-    n && (t[s] = Re(n));
-  }), t;
-}
-function Os(e) {
-  const t = {};
-  return Object.keys(e).forEach((s) => {
-    const n = e[s];
-    t[s] = n ? mt.get(n) ?? n : void 0;
-  }), t;
-}
-function Ns() {
-  if (w !== null) return;
-  w = {
-    on: c.fn.on,
-    off: c.fn.off,
-    remove: c.fn.remove,
-    empty: c.fn.empty,
-    detach: c.fn.detach
+function es(n) {
+  const t = {}, e = Object.entries(n);
+  for (let s = 0, i = e.length; s < i; s++) {
+    const o = e[s], r = o[0], c = o[1];
+    c && (t[r] = ce(c));
+  }
+  return t;
+}
+function ss(n) {
+  const t = {}, e = Object.entries(n);
+  for (let s = 0, i = e.length; s < i; s++) {
+    const o = e[s], r = o[0], c = o[1];
+    t[r] = c ? _t.get(c) ?? c : void 0;
+  }
+  return t;
+}
+function ns() {
+  if (x !== null) return;
+  x = {
+    on: h.fn.on,
+    off: h.fn.off,
+    remove: h.fn.remove,
+    empty: h.fn.empty,
+    detach: h.fn.detach
   };
-  const e = w;
-  c.fn.remove = function(t) {
-    const s = t ? this.filter(t) : this;
-    for (let n = 0, i = s.length; n < i; n++) {
-      const r = s[n];
-      r && (g.markIgnored(r), g.cleanupTree(r));
+  const n = x;
+  h.fn.remove = function(t) {
+    const e = t ? this.filter(t) : this;
+    for (let i = 0, o = e.length; i < o; i++) {
+      const r = e[i];
+      r && (R.markIgnored(r), R.cleanupTree(r));
     }
-    return e.remove.call(this, t);
-  }, c.fn.empty = function() {
-    for (let t = 0, s = this.length; t < s; t++) {
-      const n = this[t];
-      n && g.cleanupDescendants(n);
+    const s = n.remove.call(this, t);
+    return s !== void 0 ? s : this;
+  }, h.fn.empty = function() {
+    for (let e = 0, s = this.length; e < s; e++) {
+      const i = this[e];
+      i?.hasChildNodes() && R.cleanupDescendants(i);
     }
-    return e.empty.call(this);
-  }, c.fn.detach = function(t) {
-    const s = t ? this.filter(t) : this;
-    for (let n = 0, i = s.length; n < i; n++) {
-      const r = s[n];
-      r && g.keep(r);
+    const t = n.empty.call(this);
+    return t !== void 0 ? t : this;
+  }, h.fn.detach = function(t) {
+    const e = t ? this.filter(t) : this;
+    for (let i = 0, o = e.length; i < o; i++) {
+      const r = e[i];
+      r && R.keep(r);
     }
-    return e.detach.call(this, t);
-  }, c.fn.on = function(...t) {
-    const s = t[0];
-    if (s && typeof s == "object")
-      t[0] = Ts(s);
-    else
-      for (let n = t.length - 1; n >= 0; n--)
-        if (typeof t[n] == "function") {
-          t[n] = Re(t[n]);
-          break;
-        }
-    return e.on.apply(this, t);
-  }, c.fn.off = function(...t) {
-    const s = t[0];
-    if (s && typeof s == "object")
-      t[0] = Os(s);
-    else
-      for (let n = t.length - 1; n >= 0; n--)
-        if (typeof t[n] == "function") {
-          const i = t[n];
-          t[n] = mt.get(i) ?? i;
-          break;
-        }
-    return e.off.apply(this, t);
+    const s = n.detach.call(this, t);
+    return s !== void 0 ? s : this;
+  }, h.fn.on = function(...t) {
+    const e = t[0];
+    if (e && typeof e == "object")
+      t[0] = es(e);
+    else {
+      const i = t.length - 1;
+      i >= 0 && typeof t[i] == "function" && (t[i] = ce(t[i]));
+    }
+    const s = n.on.apply(this, t);
+    return s !== void 0 ? s : this;
+  }, h.fn.off = function(...t) {
+    const e = t[0];
+    if (e && typeof e == "object")
+      t[0] = ss(e);
+    else {
+      const i = t.length - 1;
+      if (i >= 0 && typeof t[i] == "function") {
+        const o = t[i];
+        t[i] = _t.get(o) ?? o;
+      }
+    }
+    const s = n.off.apply(this, t);
+    return s !== void 0 ? s : this;
   };
 }
-function js() {
-  w !== null && (c.fn.on = w.on, c.fn.off = w.off, c.fn.remove = w.remove, c.fn.empty = w.empty, c.fn.detach = w.detach, w = null);
+function Hs() {
+  x !== null && (h.fn.on = x.on, h.fn.off = x.off, h.fn.remove = x.remove, h.fn.empty = x.empty, h.fn.detach = x.detach, x = null);
+}
+var O = /* @__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))(O || {});
+let is = 0;
+function nt(n) {
+  n[dt] = !0;
 }
-var T = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Focused = 1] = "Focused", e[e.Composing = 2] = "Composing", e[e.SyncingToAtom = 4] = "SyncingToAtom", e[e.SyncingToDom = 8] = "SyncingToDom", e[e.Busy = 14] = "Busy", e))(T || {});
-let vs = 0;
-class Ds {
-  constructor(t, s, n) {
-    this.flags = 0, this.timeoutId = void 0, this.ns = `.atomBind-${++vs}`, this.handleCompositionStart = () => {
-      this.flags |= T.Composing;
+class os {
+  constructor(t, e, s) {
+    this.flags = 0, this.timeoutId = void 0, this.handleCompositionStart = () => {
+      this.flags |= O.Composing;
     }, this.handleCompositionEnd = () => {
-      this.flags &= ~T.Composing, this.handleInput();
+      this.flags &= ~O.Composing, this.handleInput();
     }, this.handleFocus = () => {
-      this.flags |= T.Focused;
+      this.flags |= O.Focused;
     }, this.handleBlur = () => {
-      this.flags &= ~T.Focused, this.timeoutId !== void 0 && (clearTimeout(this.timeoutId), this.timeoutId = void 0, this.syncAtomFromDom());
-      const r = this.options.format(this.atom.peek());
-      this.el.value !== r && (this.el.value = r);
+      this.flags &= ~O.Focused;
+      const c = !!(this.flags & O.Composing);
+      this.flags &= ~O.Composing, this.flushPendingDebounce(), c && this.timeoutId === void 0 && this.syncAtomFromDom(), this.normalizeDomValue();
     }, this.syncDomFromAtom = () => {
-      const r = this.atom.value;
-      H(() => {
-        const o = this.options.format(r), l = this.el.value;
-        if (l === o) return;
-        const p = !!(this.flags & T.Focused);
-        if (p)
+      const c = this.atom.value;
+      P(() => {
+        const a = this.format(c);
+        let l;
+        if (this.isMultipleSelect ? l = this.$el.val() || [] : l = this.el.value, this.equal(l, c)) return;
+        const u = !!(this.flags & O.Focused);
+        if (u)
           try {
-            if (this.options.equal(this.options.parse(l), r)) return;
+            const _ = this.isMultipleSelect ? l : this.parse(this.el.value);
+            if (this.equal(_, c)) return;
           } catch {
           }
-        this.flags |= T.SyncingToDom;
+        this.flags |= O.SyncingToDom;
         try {
-          if (p && (this.el instanceof HTMLInputElement || this.el instanceof HTMLTextAreaElement)) {
-            const C = this.el.selectionStart, b = this.el.selectionEnd;
-            this.el.value = o;
-            const N = o.length;
-            C !== null && b !== null && this.el.setSelectionRange(Math.min(C, N), Math.min(b, N));
-          } else
-            this.el.value = o;
-          f.domUpdated(this.$el, "val", o);
+          if (this.isMultipleSelect)
+            this.$el.val(c);
+          else if (u && (this.el instanceof HTMLInputElement || this.el instanceof HTMLTextAreaElement))
+            try {
+              const _ = this.el.selectionStart, y = this.el.selectionEnd;
+              this.el.value = a;
+              const p = a.length;
+              _ !== null && y !== null && this.el.setSelectionRange(_ < p ? _ : p, y < p ? y : p);
+            } catch {
+              this.el.value = a;
+            }
+          else
+            this.el.value = a;
+          d.enabled && d.domUpdated(E.BINDING, this.$el, "val", a);
         } finally {
-          this.flags &= ~T.SyncingToDom;
+          this.flags &= ~O.SyncingToDom;
         }
       });
     }, this.cleanup = () => {
       this.$el.off(this.ns), clearTimeout(this.timeoutId), this.timeoutId = void 0;
-    }, this.$el = t, this.el = t[0], this.atom = s;
-    const i = n.debounce ?? 0;
-    this.options = {
-      debounce: i,
-      event: n.event ?? Ye.EVENT,
-      parse: n.parse ?? ((r) => r),
-      format: n.format ?? ((r) => String(r ?? "")),
-      equal: n.equal ?? Object.is
-    }, i > 0 ? this.handleInput = () => {
-      this.flags & T.Composing || (clearTimeout(this.timeoutId), this.timeoutId = setTimeout(() => this.syncAtomFromDom(), i));
+    }, this.$el = t, this.el = t[0], this.atom = e, this.isMultipleSelect = this.el.tagName === "SELECT" && this.el.multiple, this.ns = `.atomBind-${++is}`;
+    const i = s.debounce ?? 0, o = s.event ?? Be.EVENT;
+    this.parse = s.parse ?? ((c) => c), this.format = s.format ?? ((c) => this.isMultipleSelect ? (Array.isArray(c) ? c : c ? [String(c)] : []).join(",") : String(c ?? ""));
+    const r = s.equal ?? Object.is;
+    this.equal = (c, a) => r(c, a) ? !0 : Array.isArray(c) && Array.isArray(a) ? c.length === a.length && c.every((l, u) => Object.is(l, a[u])) : !1, i > 0 ? this.handleInput = () => {
+      this.flags & O.Composing || (clearTimeout(this.timeoutId), this.timeoutId = setTimeout(() => this.syncAtomFromDom(), i));
     } : this.handleInput = () => {
-      this.flags & T.Composing || this.syncAtomFromDom();
-    }, this.handleFocus[F] = !0, this.handleBlur[F] = !0, this.handleCompositionStart[F] = !0, this.handleCompositionEnd[F] = !0, this.handleInput[F] = !0, this.bindEvents();
+      this.flags & O.Composing || this.syncAtomFromDom();
+    }, nt(this.handleFocus), nt(this.handleBlur), nt(this.handleCompositionStart), nt(this.handleCompositionEnd), nt(this.handleInput), this.bindEvents(o);
+  }
+  // --- Blur helpers ---
+  /**
+   * Flushes any pending debounce timer immediately.
+   * Called on blur so that a value the user finished typing is not lost
+   * when focus moves away before the debounce delay expires.
+   */
+  flushPendingDebounce() {
+    this.timeoutId !== void 0 && (clearTimeout(this.timeoutId), this.timeoutId = void 0, this.syncAtomFromDom());
+  }
+  /**
+   * Re-formats the current atom value into the input element on blur.
+   * Ensures the displayed text matches the canonical format (e.g. trims trailing
+   * spaces, applies number formatting) after the user finishes editing.
+   */
+  normalizeDomValue() {
+    const t = this.format(this.atom.peek());
+    if (this.isMultipleSelect) {
+      const e = this.$el.val() || [], s = Array.isArray(this.atom.peek()) ? this.atom.peek() : [];
+      this.equal(e, s) || this.$el.val(s);
+    } else this.el.value !== t && (this.el.value = t);
   }
   // --- Sync Logic ---
   syncAtomFromDom() {
-    if (!(this.flags & T.Busy)) {
-      this.flags |= T.SyncingToAtom;
+    if (!(this.flags & O.Busy)) {
+      this.flags |= O.SyncingToAtom;
       try {
-        const t = this.options.parse(this.el.value);
-        this.options.equal(this.atom.peek(), t) || (this.atom.value = t);
+        let t;
+        this.isMultipleSelect ? t = this.$el.val() || [] : t = this.el.value;
+        const e = this.parse(t);
+        this.equal(this.atom.peek(), e) || (this.atom.value = e);
       } catch (t) {
-        f.warn(d.BINDING, `${S.PARSE_ERROR()}:`, t);
+        d.warn(
+          E.BINDING,
+          S.BINDING.PARSE_ERROR(t instanceof Error ? t.message : String(t)),
+          t
+        );
       } finally {
-        this.flags &= ~T.SyncingToAtom;
+        this.flags &= ~O.SyncingToAtom;
       }
     }
   }
-  bindEvents() {
-    this.$el.on(`focus${this.ns}`, this.handleFocus).on(`blur${this.ns}`, this.handleBlur).on(`compositionstart${this.ns}`, this.handleCompositionStart).on(`compositionend${this.ns}`, this.handleCompositionEnd).on(`${this.options.event}${this.ns}`, this.handleInput);
+  bindEvents(t) {
+    const e = this.ns, s = t.trim().split(/\s+/).map((i) => `${i}${e}`).join(" ");
+    this.$el.on(`focus${e}`, this.handleFocus).on(`blur${e}`, this.handleBlur).on(`compositionstart${e}`, this.handleCompositionStart).on(`compositionend${e}`, this.handleCompositionEnd).on(s, this.handleInput);
   }
 }
-function As(e, t, s) {
-  const n = new Ds(e, t, s);
-  return { fx: X(n.syncDomFromAtom), cleanup: n.cleanup };
+function rs(n, t, e) {
+  const s = new os(n, t, e);
+  return { fx: V(s.syncDomFromAtom), cleanup: s.cleanup };
 }
-const he = /* @__PURE__ */ new Map();
-function Us(e) {
-  let t = he.get(e);
-  return t !== void 0 || (t = e.includes("-") ? e.replace(/-./g, (s) => s[1].toUpperCase()) : e, he.set(e, t)), t;
+const cs = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "action",
+  "formaction",
+  "xlink:href",
+  "data",
+  "poster",
+  "background",
+  "cite",
+  "longdesc",
+  "profile",
+  "usemap",
+  "classid",
+  "codebase"
+]), as = /^\s*(?:javascript|vbscript)\s*:/i, ls = (
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: Intentionally matching control characters for XSS sanitization
+  /(?:expression\s*\(|behavior\s*:|-moz-binding\s*:|(?:\\[0-9a-f]{1,6}\s*|[\s\x00-\x20/'"])*(?: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|d\s*a\s*t\s*a)\s*:(?!image\/))/i
+), hs = /url\s*\(\s*(?:["']?\s*)?(?:javascript|vbscript)\s*:/i, us = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, fs = /&#x([0-9a-f]+);?|&#([0-9]+);?/gi, ds = {
+  colon: ":",
+  Tab: "	",
+  NewLine: `
+`
+}, _s = /&(colon|Tab|NewLine);/g, ps = /<\?[\s\S]*?\?>/g, Es = /(<(script|iframe|object|embed|base|meta|applet|noscript|form|style|link)\b[^>]*>([\s\S]*?)<\/\2>|<(script|iframe|object|embed|base|meta|applet|noscript|form|style|link)\b[^>]*\/?>)/gi, ms = /(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, gs = /data\s*:\s*(?:text\/(?:html|javascript|vbscript|xml)|application\/(?:javascript|xhtml\+xml|xml|x-shockwave-flash)|image\/svg\+xml)/gi, Is = /\bon\w+\s*=/gim, ys = new RegExp(ls.source, "gim");
+function pt(n) {
+  let t = String(n ?? "");
+  t = t.replace(us, ""), t = t.replace(
+    fs,
+    (s, i, o) => String.fromCodePoint(i ? parseInt(i, 16) : parseInt(o, 10))
+  ), t = t.replace(_s, (s, i) => ds[i] ?? ""), t = t.replace(ps, "");
+  let e;
+  do
+    e = t, t = t.replace(Es, "");
+  while (t !== e);
+  return t = t.replace(ms, "data-unsafe-protocol:"), t = t.replace(gs, "data-unsafe-protocol:"), t = t.replace(Is, "data-unsafe-attr="), t = t.replace(ys, "data-unsafe-css:"), t;
+}
+function ae(n, t) {
+  return cs.has(n.toLowerCase()) ? as.test(t) : !1;
+}
+function Cs(n) {
+  return n.toLowerCase().includes("url(") ? hs.test(n) : !1;
 }
-const ue = /* @__PURE__ */ new WeakMap();
-function Ls(e) {
-  let t = ue.get(e);
-  return t || (t = Ct(() => Bt(e.value)), ue.set(e, t)), t;
+const qt = /* @__PURE__ */ new Map();
+function Ts(n) {
+  let t = qt.get(n);
+  return t !== void 0 || (t = n.includes("-") ? n.replace(/-./g, (e) => e[1].toUpperCase()) : n, qt.set(n, t)), t;
 }
-function D(e) {
+const Xt = /* @__PURE__ */ new WeakMap();
+function Ss(n) {
+  let t = Xt.get(n);
+  return t || (t = gt(() => pt(n.value)), Xt.set(n, t)), t;
+}
+function A(n) {
   return {
-    $el: c(e),
-    el: e,
-    trackCleanup: (t) => g.trackCleanup(e, t)
+    $el: h(n),
+    el: n,
+    trackCleanup: (t) => R.trackCleanup(n, t)
   };
 }
-function Te(e, t, s) {
-  const n = e.el;
-  Q(
-    n,
+function le(n, t, e) {
+  const s = n.el;
+  B(
+    s,
     t,
     (i) => {
-      const r = s ? s(i) : typeof i == "string" ? i : String(i ?? "");
-      n.textContent !== r && (n.textContent = r);
+      const o = e ? e(i) : typeof i == "string" ? i : String(i ?? "");
+      s.textContent !== o && (s.textContent = o);
     },
     "text"
   );
 }
-function Oe(e, t) {
-  const s = e.el, n = qt(t) ? Ls(t) : t;
-  Q(
+function he(n, t) {
+  const e = n.el, s = wt(t) ? Ss(t) : t;
+  B(
+    e,
     s,
-    n,
     (i) => {
-      s.innerHTML !== i && (g.cleanupDescendants(s), s.innerHTML = i);
+      e.innerHTML !== i && (R.cleanupDescendants(e), e.innerHTML = i);
     },
     "html"
   );
 }
-function Ne(e, t) {
-  Object.entries(t).forEach(([s, n]) => {
-    Q(
-      e.el,
-      n,
-      (i) => {
-        e.el.classList.toggle(s, !!i);
-      },
-      `class.${s}`
-    );
-  });
+function ue(n, t) {
+  for (const e in t)
+    if (Z.call(t, e)) {
+      const s = t[e], i = e.trim().split(/\s+/).filter(Boolean);
+      i.length > 1 ? B(
+        n.el,
+        s,
+        (o) => {
+          o ? n.el.classList.add(...i) : n.el.classList.remove(...i);
+        },
+        `class.${e}`
+      ) : i.length === 1 && B(
+        n.el,
+        s,
+        (o) => {
+          n.el.classList.toggle(i[0], !!o);
+        },
+        `class.${e}`
+      );
+    }
 }
-function ve(e, t) {
-  const s = e.el, n = s.style;
-  Object.entries(t).forEach(([i, r]) => {
-    const o = Us(i), [l, p] = Array.isArray(r) ? r : [r, ""];
-    Q(
-      s,
-      l,
-      (C) => {
-        const b = p ? `${C}${p}` : String(C);
-        fs(b) || (n[o] = b);
-      },
-      `css.${i}`
-    );
-  });
+function fe(n, t) {
+  const e = n.el, s = e.style;
+  for (const i in t)
+    if (Z.call(t, i)) {
+      const o = t[i], r = Ts(i), [c, a] = Array.isArray(o) ? o : [o, ""];
+      B(
+        e,
+        c,
+        (l) => {
+          const u = a ? String(l) + a : String(l);
+          Cs(u) || (s[r] = u);
+        },
+        `css.${i}`
+      );
+    }
 }
-function De(e, t) {
-  const s = e.el;
-  Object.keys(t).forEach((n) => {
-    n.toLowerCase().startsWith("on") || Q(
-      s,
-      t[n],
-      (i) => {
-        if (i == null || i === !1) {
-          s.removeAttribute(n);
-          return;
-        }
-        const r = i === !0 ? n : String(i);
-        ls(n, r) || s.getAttribute(n) !== r && s.setAttribute(n, r);
-      },
-      `attr.${n}`
-    );
-  });
+function de(n, t) {
+  const e = n.el;
+  for (const s in t)
+    if (Z.call(t, s)) {
+      const i = s.toLowerCase();
+      if (i.startsWith("on")) {
+        console.warn(
+          `${E.BINDING} ${S.SECURITY.BLOCKED_EVENT_HANDLER(s)}`
+        );
+        continue;
+      }
+      const o = i.startsWith("aria-");
+      B(
+        e,
+        t[s],
+        (r) => {
+          if (r == null) {
+            e.removeAttribute(s);
+            return;
+          }
+          if (r === !1 && !o) {
+            e.removeAttribute(s);
+            return;
+          }
+          const c = r === !0 ? o ? "true" : s : String(r);
+          if (ae(s, c)) {
+            console.warn(
+              `${E.BINDING} ${S.SECURITY.BLOCKED_PROTOCOL(s)}`
+            );
+            return;
+          }
+          e.getAttribute(s) !== c && e.setAttribute(s, c);
+        },
+        `attr.${s}`
+      );
+    }
 }
-function Ae(e, t) {
-  const s = e.el;
-  Object.keys(t).forEach((n) => {
-    Je.has(n) || Q(
-      e.el,
-      t[n],
-      (i) => {
-        s[n] !== i && (s[n] = i);
-      },
-      `prop.${n}`
-    );
-  });
+function _e(n, t) {
+  const e = n.el;
+  for (const s in t)
+    if (Z.call(t, s)) {
+      const i = s.toLowerCase();
+      if (i.startsWith("on")) {
+        console.warn(
+          `${E.BINDING} ${S.SECURITY.BLOCKED_EVENT_HANDLER(s)}`
+        );
+        continue;
+      }
+      if (je.has(s)) {
+        console.warn(`${E.BINDING} ${S.SECURITY.BLOCKED_PROP(s)}`);
+        continue;
+      }
+      const o = He.has(i);
+      B(
+        n.el,
+        t[s],
+        (r) => {
+          if (o && typeof r == "string" && ae(s, r)) {
+            console.warn(
+              `${E.BINDING} ${S.SECURITY.BLOCKED_PROTOCOL(s)}`
+            );
+            return;
+          }
+          e[s] !== r && (e[s] = r);
+        },
+        `prop.${s}`
+      );
+    }
 }
-function gt(e, t, s) {
-  const n = e.el;
-  Q(
-    n,
+function Et(n, t, e) {
+  const s = n.el, i = e ? "hide" : "show", o = s.style.display, r = o === "none" ? "" : o;
+  B(
+    s,
     t,
-    (r) => {
-      const o = s !== !!r;
-      n.style.display = o ? "" : "none";
+    (c) => {
+      s.style.display = e !== !!c ? r : "none";
     },
-    s ? "hide" : "show"
+    i
   );
 }
-function Gt(e, t, s = {}) {
-  const n = e.el.tagName.toLowerCase();
-  if (!We.has(n)) {
-    console.warn(`${d.BINDING} ${S.INVALID_INPUT_ELEMENT(n)}`);
+function pe(n, t, e = {}) {
+  const s = n.el.tagName.toLowerCase();
+  if (!Ge.has(s)) {
+    console.warn(
+      `${E.BINDING} ${S.BINDING.INVALID_INPUT_ELEMENT(s)}`
+    );
     return;
   }
-  const { fx: i, cleanup: r } = As(e.$el, t, s);
-  g.trackEffect(e.el, i), e.trackCleanup(r);
+  const { fx: i, cleanup: o } = rs(n.$el, t, e);
+  R.trackEffect(n.el, i), n.trackCleanup(o);
 }
-function Ue(e, t) {
-  const s = e.el, n = e.$el, i = () => {
-    const o = s.checked;
-    t.value !== o && (t.value = o);
+function Ee(n, t) {
+  const e = n.el, s = n.$el, i = e.type === "radio", o = () => {
+    const c = e.checked;
+    if (t.value !== c && (t.value = c, i && c && e.name)) {
+      const a = e.name.replace(/"/g, '\\"');
+      (e.form ? h(e.form) : h(document)).find(`input[type="radio"][name="${a}"]`).not(e).trigger("change.atomRadioSync");
+    }
   };
-  i[F] = !0, n.on("change", i), e.trackCleanup(() => n.off("change", i));
-  const r = X(() => {
-    const o = !!t.value;
-    H(() => {
-      s.checked !== o && (s.checked = o, f.domUpdated(n, "checked", o));
+  o[dt] = !0, s.on("change change.atomRadioSync", o), n.trackCleanup(() => s.off("change change.atomRadioSync", o));
+  const r = V(() => {
+    const c = !!t.value;
+    P(() => {
+      e.checked !== c && (e.checked = c, d.enabled && d.domUpdated(E.BINDING, s, "checked", c));
     });
   });
-  g.trackEffect(s, r);
+  R.trackEffect(e, r);
 }
-function ws(e, t) {
-  const s = e.$el;
-  s.on(t), e.trackCleanup(() => s.off(t));
+function Ns(n, t) {
+  const e = n.$el;
+  e.on(t), n.trackCleanup(() => e.off(t));
 }
-function ks(e, t, s) {
-  const n = e.$el;
-  n.on(t, s), e.trackCleanup(() => n.off(t, s));
+function bs(n, t, e) {
+  const s = n.$el;
+  s.on(t, e), n.trackCleanup(() => s.off(t, e));
 }
-function Le(e) {
-  g.cleanupTree(e);
+function me(n) {
+  R.cleanupTree(n);
 }
-c.fn.atomText = function(e, t) {
-  return this.each(function() {
-    Te(D(this), e, t);
-  });
+function k(n) {
+  d.enabled && d.log(E.BINDING, `Skipping non-Element node (nodeType=${n})`);
+}
+h.fn.atomText = function(n, t) {
+  for (let e = 0, s = this.length; e < s; e++) {
+    const i = this[e];
+    i.nodeType === 1 ? le(A(i), n, t) : k(i.nodeType);
+  }
+  return this;
 };
-c.fn.atomHtml = function(e) {
-  return this.each(function() {
-    Oe(D(this), e);
-  });
+h.fn.atomHtml = function(n) {
+  for (let t = 0, e = this.length; t < e; t++) {
+    const s = this[t];
+    s.nodeType === 1 ? he(A(s), n) : k(s.nodeType);
+  }
+  return this;
 };
-c.fn.atomClass = function(e, t) {
-  if (typeof e == "string" && t === void 0)
-    return console.warn(`${d.BINDING} ${S.MISSING_CONDITION("atomClass")}`), this;
-  const s = typeof e == "string" ? { [e]: t } : e;
-  return this.each(function() {
-    Ne(D(this), s);
-  });
+h.fn.atomClass = function(n, t) {
+  if (typeof n == "string" && t === void 0)
+    return console.warn(
+      `${E.BINDING} ${S.BINDING.MISSING_CONDITION("atomClass")}`
+    ), this;
+  const e = typeof n == "string" ? { [n]: t } : n;
+  for (let s = 0, i = this.length; s < i; s++) {
+    const o = this[s];
+    o.nodeType === 1 ? ue(A(o), e) : k(o.nodeType);
+  }
+  return this;
 };
-c.fn.atomCss = function(e, t, s) {
-  if (typeof e == "string" && t === void 0)
-    return console.warn(`${d.BINDING} ${S.MISSING_SOURCE("atomCss")}`), this;
-  const n = typeof e == "string" ? { [e]: s ? [t, s] : t } : e;
-  return this.each(function() {
-    ve(D(this), n);
-  });
+h.fn.atomCss = function(n, t, e) {
+  if (typeof n == "string" && t === void 0)
+    return console.warn(`${E.BINDING} ${S.BINDING.MISSING_SOURCE("atomCss")}`), this;
+  const s = typeof n == "string" ? { [n]: e ? [t, e] : t } : n;
+  for (let i = 0, o = this.length; i < o; i++) {
+    const r = this[i];
+    r.nodeType === 1 ? fe(A(r), s) : k(r.nodeType);
+  }
+  return this;
 };
-c.fn.atomAttr = function(e, t) {
-  if (typeof e == "string" && t === void 0)
-    return console.warn(`${d.BINDING} ${S.MISSING_SOURCE("atomAttr")}`), this;
-  const s = typeof e == "string" ? { [e]: t } : e;
-  return this.each(function() {
-    De(D(this), s);
-  });
+h.fn.atomAttr = function(n, t) {
+  if (typeof n == "string" && t === void 0)
+    return console.warn(`${E.BINDING} ${S.BINDING.MISSING_SOURCE("atomAttr")}`), this;
+  const e = typeof n == "string" ? { [n]: t } : n;
+  for (let s = 0, i = this.length; s < i; s++) {
+    const o = this[s];
+    o.nodeType === 1 ? de(A(o), e) : k(o.nodeType);
+  }
+  return this;
 };
-c.fn.atomProp = function(e, t) {
-  if (typeof e == "string" && t === void 0)
-    return console.warn(`${d.BINDING} ${S.MISSING_SOURCE("atomProp")}`), this;
-  const s = typeof e == "string" ? { [e]: t } : e;
-  return this.each(function() {
-    Ae(D(this), s);
-  });
+h.fn.atomProp = function(n, t) {
+  if (typeof n == "string" && t === void 0)
+    return console.warn(`${E.BINDING} ${S.BINDING.MISSING_SOURCE("atomProp")}`), this;
+  const e = typeof n == "string" ? { [n]: t } : n;
+  for (let s = 0, i = this.length; s < i; s++) {
+    const o = this[s];
+    o.nodeType === 1 ? _e(A(o), e) : k(o.nodeType);
+  }
+  return this;
 };
-c.fn.atomShow = function(e) {
-  return this.each(function() {
-    gt(D(this), e, !1);
-  });
+h.fn.atomShow = function(n) {
+  for (let t = 0, e = this.length; t < e; t++) {
+    const s = this[t];
+    s.nodeType === 1 ? Et(A(s), n, !1) : k(s.nodeType);
+  }
+  return this;
 };
-c.fn.atomHide = function(e) {
-  return this.each(function() {
-    gt(D(this), e, !0);
-  });
+h.fn.atomHide = function(n) {
+  for (let t = 0, e = this.length; t < e; t++) {
+    const s = this[t];
+    s.nodeType === 1 ? Et(A(s), n, !0) : k(s.nodeType);
+  }
+  return this;
 };
-c.fn.atomVal = function(e, t = {}) {
-  return this.each(function() {
-    Gt(D(this), e, t);
-  });
+h.fn.atomVal = function(n, t = {}) {
+  for (let e = 0, s = this.length; e < s; e++) {
+    const i = this[e];
+    i.nodeType === 1 ? pe(
+      A(i),
+      n,
+      t
+    ) : k(i.nodeType);
+  }
+  return this;
 };
-c.fn.atomChecked = function(e) {
-  return this.each(function() {
-    Ue(D(this), e);
-  });
+h.fn.atomChecked = function(n) {
+  for (let t = 0, e = this.length; t < e; t++) {
+    const s = this[t];
+    s.nodeType === 1 ? Ee(A(s), n) : k(s.nodeType);
+  }
+  return this;
 };
-c.fn.atomOn = function(e, t) {
-  return this.each(function() {
-    ks(D(this), e, t);
-  });
+h.fn.atomOn = function(n, t) {
+  for (let e = 0, s = this.length; e < s; e++) {
+    const i = this[e];
+    i.nodeType === 1 ? bs(A(i), n, t) : k(i.nodeType);
+  }
+  return this;
 };
-c.fn.atomBind = function(e) {
-  return this.each(function() {
-    const t = D(this);
-    if (e.text !== void 0 && Te(t, e.text), e.html !== void 0 && Oe(t, e.html), e.class !== void 0 && Ne(t, e.class), e.css !== void 0 && ve(t, e.css), e.attr !== void 0 && De(t, e.attr), e.prop !== void 0 && Ae(t, e.prop), e.show !== void 0 && gt(t, e.show, !1), e.hide !== void 0 && gt(t, e.hide, !0), e.val !== void 0)
-      if (Array.isArray(e.val)) {
-        const [s, n] = e.val;
-        Gt(t, s, n);
-      } else
-        Gt(t, e.val);
-    e.checked !== void 0 && Ue(t, e.checked), e.on !== void 0 && ws(t, e.on);
-  });
+h.fn.atomBind = function(n) {
+  const { text: t, html: e, class: s, css: i, attr: o, prop: r, show: c, hide: a, val: l, checked: u, on: _ } = n, y = l === void 0 ? null : Array.isArray(l) ? {
+    atom: l[0],
+    opts: l[1]
+  } : { atom: l, opts: void 0 };
+  for (let p = 0, v = this.length; p < v; p++) {
+    const C = this[p];
+    if (C.nodeType !== 1) {
+      k(C.nodeType);
+      continue;
+    }
+    const T = A(C);
+    t !== void 0 && le(T, t), e !== void 0 && he(T, e), s !== void 0 && ue(T, s), i !== void 0 && fe(T, i), o !== void 0 && de(T, o), r !== void 0 && _e(T, r), c !== void 0 && Et(T, c, !1), a !== void 0 && Et(T, a, !0), y !== null && pe(T, y.atom, y.opts), u !== void 0 && Ee(T, u), _ !== void 0 && Ns(T, _);
+  }
+  return this;
 };
-c.fn.atomUnbind = function() {
-  return this.each(function() {
-    Le(this);
-  });
+h.fn.atomUnbind = function() {
+  for (let n = 0, t = this.length; n < t; n++) {
+    const e = this[n];
+    e.nodeType === 1 ? me(e) : k(e.nodeType);
+  }
+  return this;
 };
-function xs(e, t, s) {
-  t?.isConnected ? e.insertBefore(t) : e.appendTo(s);
-}
-c.fn.atomList = function(e, t) {
-  const { key: s, render: n, bind: i, update: r, onAdd: o, onRemove: l, empty: p } = t, C = typeof s == "function" ? s : (b, N) => b[s];
-  return this.each(function() {
-    const b = c(this), N = Xt(this), E = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Set();
-    let P = [], U = null;
-    const G = (v, R) => {
-      const j = () => {
-        bt?.isDisposed || (R.$el.remove(), m.delete(v), f.log("list", `${N} removed item:`, v));
-      };
-      if (l) {
-        const M = l(R.$el);
-        M instanceof Promise ? M.then(j, j) : j();
-      } else
-        j();
-    }, Qt = (v, R) => {
-      E.delete(v), m.add(v), G(v, R);
+const Rt = /* @__PURE__ */ new WeakMap();
+let Rs = 0;
+function vs(n, t, e) {
+  t?.isConnected ? n.insertBefore(t) : n.appendTo(e);
+}
+function Ds(n, t, e, s, i, o) {
+  t.$el[0] && (n === void 0 ? o && o(t.$el, e, s) : i && i(t.$el, e, s));
+}
+class Os {
+  constructor(t, e, s) {
+    this.$container = t, this.containerSelector = e, this.onRemove = s, this.itemMap = /* @__PURE__ */ new Map(), this.removingKeys = /* @__PURE__ */ new Set(), this.oldKeys = [], this.$emptyEl = null, this.elToKey = /* @__PURE__ */ new WeakMap(), this.keyToIndex = /* @__PURE__ */ new Map();
+  }
+  scheduleRemoval(t, e) {
+    const s = () => {
+      this.fx?.isDisposed || (e.$el.remove(), this.removingKeys.delete(t), d.log(E.LIST, `${this.containerSelector} removed item:`, t));
     };
-    let bt;
-    bt = X(() => {
-      const v = e.value, R = v.length;
-      H(() => {
-        if (U && R > 0 && (U.remove(), U = null), R === 0) {
-          if (p && !U) {
-            const a = typeof p == "string" ? Bt(p) : p;
-            U = c(a).appendTo(b);
-          }
-          E.forEach((a, h) => {
-            m.has(h) || Qt(h, a);
-          }), P = [];
-          return;
-        }
-        f.log("list", `${N} updating with ${R} items`);
-        const j = /* @__PURE__ */ new Map();
-        for (let a = 0; a < P.length; a++)
-          j.set(P[a], a);
-        const M = new Array(R), St = /* @__PURE__ */ new Set(), ot = new Int32Array(R), ct = [], Rt = [], Tt = [];
-        for (let a = 0; a < R; a++) {
-          const h = v[a], _ = C(h, a);
-          if (M[a] = _, St.has(_)) {
-            f.warn(d.LIST, S.DUPLICATE_KEY(_, a)), ot[a] = -1;
-            continue;
-          }
-          St.add(_);
-          const I = E.get(_);
-          if (I) {
-            const u = I.item;
-            !r && u !== h && !ds(u, h) && (ct.push(_), Rt.push(h), Tt.push(a)), ot[a] = m.has(_) ? -1 : j.get(_) ?? -1;
-          } else
-            ct.push(_), Rt.push(h), Tt.push(a), ot[a] = -1;
-        }
-        const Kt = "<!--sep-->", at = ct.length, Yt = new Array(
-          at
-        ), Ot = [];
-        for (let a = 0; a < at; a++) {
-          const h = n(Rt[a], Tt[a]);
-          Yt[a] = h, typeof h == "string" && Ot.push(h);
-        }
-        let ht = null;
-        if (Ot.length > 0) {
-          const a = Ot.join(Kt);
-          ht = Bt(a).split(Kt);
-        }
-        let Wt = 0;
-        for (let a = 0; a < at; a++) {
-          const h = Yt[a], _ = typeof h == "string" ? c(ht[Wt++]) : c(h), I = ct[a], u = E.get(I);
-          if (u) {
-            const A = u.$el[0];
-            A && g.cleanupTree(A), u.$el.replaceWith(_), u.$el = _, u.state = "replaced";
-          } else
-            E.set(I, { $el: _, item: null, state: "new" });
-        }
-        for (const [a, h] of E)
-          !St.has(a) && !m.has(a) && Qt(a, h);
-        const Jt = _s(ot);
-        let Nt = Jt.length - 1, Zt = null;
-        const vt = P.length === 0;
-        if (vt && ht !== null && Wt === at && !i && !o && !l && m.size === 0) {
-          this.innerHTML = ht.join("");
-          let a = 0;
-          for (let h = 0; h < R; h++) {
-            const _ = M[h], I = v[h], u = E.get(_);
-            if (!u) continue;
-            const A = this.children[a++];
-            A && (u.$el = c(A), u.item = I, u.state = void 0, m.delete(_), f.domUpdated(u.$el, "list.add", I));
-          }
-        } else {
-          const a = vt ? document.createDocumentFragment() : null;
-          if (vt && a) {
-            for (let h = R - 1; h >= 0; h--) {
-              const _ = M[h], I = v[h], u = E.get(_);
-              if (!u) continue;
-              const A = u.state, x = A === "new", et = A === "replaced";
-              u.item = I, u.state = void 0, u.$el[0] && (!x && !et && r ? r(u.$el, I, h) : (x || et) && i && i(u.$el, I, h));
-              for (let Dt = u.$el.length - 1; Dt >= 0; Dt--)
-                a.insertBefore(u.$el[Dt], a.firstChild);
-              o && x && o(u.$el), x && (m.delete(_), f.domUpdated(u.$el, "list.add", I));
-            }
-            this.appendChild(a);
-          } else
-            for (let h = R - 1; h >= 0; h--) {
-              const _ = M[h], I = v[h], u = E.get(_);
-              if (!u) continue;
-              const A = u.state, x = A === "new", et = A === "replaced";
-              u.item = I, u.state = void 0, u.$el[0] && (!x && !et && r ? r(u.$el, I, h) : (x || et) && i && i(u.$el, I, h)), Nt >= 0 && Jt[Nt] === h ? Nt-- : xs(u.$el, Zt, b), o && x && o(u.$el), Zt = u.$el[0] ?? null, x && (m.delete(_), f.domUpdated(u.$el, "list.add", I));
-            }
-        }
-        P = M;
+    if (!this.onRemove) {
+      s();
+      return;
+    }
+    const i = this.onRemove(e.$el);
+    i instanceof Promise ? i.then(s, s) : s();
+  }
+  removeItem(t, e) {
+    for (let s = 0; s < e.$el.length; s++) {
+      const i = e.$el[s];
+      i && this.elToKey.delete(i);
+    }
+    this.itemMap.delete(t), this.removingKeys.add(t), this.scheduleRemoval(t, e);
+  }
+  dispose() {
+    this.itemMap.clear(), this.removingKeys.clear(), this.oldKeys.length = 0, this.keyToIndex.clear(), this.$emptyEl?.remove(), this.$container.off(".atomList");
+  }
+}
+function Ls(n, t, e, s) {
+  if (n.$emptyEl && t > 0 && (n.$emptyEl.remove(), n.$emptyEl = null), t !== 0) return;
+  if (s && !n.$emptyEl) {
+    const r = typeof s == "string" ? pt(s) : s;
+    n.$emptyEl = h(r).appendTo(e);
+  }
+  const { oldKeys: i, itemMap: o } = n;
+  for (let r = 0, c = i.length; r < c; r++) {
+    const a = i[r], l = o.get(a);
+    l && n.removeItem(a, l);
+  }
+  i.length = 0;
+}
+function ks(n, t, e, s, i) {
+  const { oldKeys: o, itemMap: r, removingKeys: c } = n, a = /* @__PURE__ */ new Map();
+  for (let C = 0, T = o.length; C < T; C++)
+    a.set(o[C], C);
+  const l = new Array(e), u = /* @__PURE__ */ new Set(), _ = new Int32Array(e), y = [], p = [], v = [];
+  for (let C = 0; C < e; C++) {
+    const T = t[C], f = s(T, C);
+    if (l[C] = f, u.has(f)) {
+      d.warn(E.LIST, S.LIST.DUPLICATE_KEY(f, C, n.containerSelector)), _[C] = -1;
+      continue;
+    }
+    u.add(f);
+    const I = r.get(f);
+    if (!I) {
+      y.push(f), p.push(T), v.push(C), _[C] = -1;
+      continue;
+    }
+    const m = I.item;
+    !i && m !== T && !Ve(m, T) && (y.push(f), p.push(T), v.push(C)), _[C] = c.has(f) ? -1 : a.get(f) ?? -1;
+  }
+  return { newKeys: l, newKeySet: u, newIndices: _, trKeys: y, trItems: p, trIdxs: v };
+}
+function As(n, t, e, s) {
+  const { trKeys: i, trItems: o, trIdxs: r } = t, c = i.length, a = n.itemMap, l = e.render, u = new Array(c), _ = [];
+  let y = 0;
+  for (let f = 0; f < c; f++) {
+    const I = l(o[f], r[f]);
+    u[f] = I, typeof I == "string" && (_.push(I), y++);
+  }
+  let p = null;
+  const v = _.length;
+  if (v === 1)
+    p = [pt(_[0])];
+  else if (v > 1) {
+    const I = `<template data-atom-sep="${(Rs++).toString(36)}"></template>`;
+    p = pt(_.join(I)).split(I);
+  }
+  if (s && p !== null && y === c && !e.bind && !e.onAdd && !e.onRemove && !e.events)
+    return p;
+  let T = 0;
+  for (let f = 0; f < c; f++) {
+    const I = u[f], m = typeof I == "string" ? h(p[T++]) : h(I), N = i[f], g = a.get(N);
+    if (!g) {
+      a.set(N, { $el: m, item: null, state: "new" });
+      continue;
+    }
+    const D = g.$el[0];
+    D && R.cleanupTree(D), g.$el.replaceWith(m), g.$el = m, g.state = "replaced";
+  }
+  return null;
+}
+function Us(n, t) {
+  const { oldKeys: e, itemMap: s } = n;
+  for (let i = 0, o = e.length; i < o; i++) {
+    const r = e[i];
+    if (t.has(r)) continue;
+    const c = s.get(r);
+    c && n.removeItem(r, c);
+  }
+}
+function ws(n, t, e, s, i, o, r) {
+  const { bind: c, update: a, onAdd: l } = o, { newKeys: u, newIndices: _ } = e, y = t.length, p = n.oldKeys.length === 0, v = ze(_);
+  let C = v.length - 1;
+  const { itemMap: T, removingKeys: f } = n;
+  if (r !== null) {
+    s.innerHTML = r.join("");
+    let I = 0;
+    for (let m = 0; m < y; m++) {
+      const N = u[m], g = t[m], D = s.children[I++];
+      if (D) {
+        const U = h(D);
+        T.set(N, { $el: U, item: g, state: void 0 }), f.delete(N), d.enabled && d.domUpdated(E.LIST, U, "list.add", g);
+      }
+    }
+    return;
+  }
+  if (p) {
+    const I = document.createDocumentFragment();
+    for (let m = y - 1; m >= 0; m--) {
+      const N = u[m], g = T.get(N);
+      if (!g) continue;
+      const D = g.$el;
+      for (let U = D.length - 1; U >= 0; U--)
+        I.insertBefore(D[U], I.firstChild);
+    }
+    s.appendChild(I);
+  } else {
+    let I = null;
+    for (let m = y - 1; m >= 0; m--) {
+      const N = u[m], g = T.get(N);
+      g && (C >= 0 && v[C] === m ? C-- : vs(g.$el, I, i), I = g.$el[0] ?? null);
+    }
+  }
+  for (let I = 0; I < y; I++) {
+    const m = u[I], N = t[I], g = T.get(m);
+    if (!g) continue;
+    const D = g.state;
+    g.item = N, g.state = void 0, Ds(D, g, N, I, c, a), D === "new" && (l && l(g.$el), f.delete(m), d.enabled && d.domUpdated(E.LIST, g.$el, "list.add", N));
+  }
+}
+function xs(n, t) {
+  const { newKeys: e, newKeySet: s } = t, i = e.length, { oldKeys: o, itemMap: r, elToKey: c, keyToIndex: a } = n;
+  for (let l = 0, u = o.length; l < u; l++) {
+    const _ = o[l];
+    s.has(_) || a.delete(_);
+  }
+  for (let l = 0; l < i; l++) {
+    const u = e[l], _ = r.get(u);
+    if (_) {
+      for (let y = 0; y < _.$el.length; y++) {
+        const p = _.$el[y];
+        p && c.set(p, u);
+      }
+      a.set(u, l);
+    }
+  }
+}
+h.fn.atomList = function(n, t) {
+  const { key: e, bind: s, update: i, onAdd: o, onRemove: r, empty: c, events: a } = t, l = typeof e == "function" ? e : (_, y) => _[e], u = { bind: s, update: i, onAdd: o, onRemove: r, events: a };
+  for (let _ = 0, y = this.length; _ < y; _++) {
+    const p = this[_], v = h(p);
+    v.off(".atomList");
+    const C = Rt.get(p);
+    C && (C.fx.dispose(), C.ctx.dispose());
+    const T = X(p), f = new Os(v, T, r), I = V(() => {
+      const m = n.value, N = m.length;
+      P(() => {
+        if (Ls(f, N, v, c), N === 0) return;
+        d.log(E.LIST, `${T} updating with ${N} items`);
+        const g = ks(f, m, N, l, i), D = f.oldKeys.length === 0, U = As(f, g, t, D);
+        Us(f, g.newKeySet), ws(f, m, g, p, v, u, U), a && xs(f, g), f.oldKeys = g.newKeys;
       });
-    }), g.trackEffect(this, bt), g.trackCleanup(this, () => {
-      E.clear(), m.clear(), P = [], U?.remove();
     });
-  });
+    if (f.fx = I, a)
+      for (const m in a) {
+        if (!Z.call(a, m)) continue;
+        const N = a[m], g = m.indexOf(" "), D = g === -1 ? m : m.slice(0, g), U = g === -1 ? null : m.slice(g + 1).trim(), ge = U || "> *", Ie = function(ye) {
+          let J = this;
+          for (; J && J !== p; ) {
+            const It = f.elToKey.get(J);
+            if (It !== void 0) {
+              const xt = f.itemMap.get(It);
+              xt && N.call(this, xt.item, f.keyToIndex.get(It) ?? -1, ye);
+              return;
+            }
+            J = J.parentElement;
+          }
+        };
+        v.on(`${D}.atomList`, ge, Ie);
+      }
+    R.trackEffect(p, I), Rt.set(p, { fx: I, ctx: f }), R.trackCleanup(p, () => {
+      f.dispose(), Rt.delete(p);
+    });
+  }
+  return this;
 };
-const Ps = Object.freeze({});
-c.fn.atomMount = function(e, t) {
-  const s = t ?? Ps;
-  return this.each(function() {
-    g.cleanupTree(this);
-    const n = c(this);
-    let i;
+const $s = Object.freeze({});
+h.fn.atomMount = function(n, t) {
+  const e = t ?? $s;
+  for (let s = 0, i = this.length; s < i; s++) {
+    const o = this[s];
+    if (!o) continue;
+    R.cleanupTree(o);
+    const r = h(o);
+    let c;
     try {
-      i = H(() => e(n, s));
-    } catch (r) {
-      f.error(d.MOUNT, S.MOUNT_ERROR(), r);
-      return;
+      c = P(() => n(r, e));
+    } catch (a) {
+      d.error(E.MOUNT, S.MOUNT.ERROR(n.name), a);
+      continue;
     }
-    typeof i == "function" && g.setComponentCleanup(this, i);
-  });
+    typeof c == "function" && R.setComponentCleanup(o, c);
+  }
+  return this;
 };
-c.fn.atomUnmount = function() {
-  return this.each(function() {
-    Le(this);
-  });
+h.fn.atomUnmount = function() {
+  for (let n = 0, t = this.length; n < t; n++) {
+    const e = this[n];
+    e && me(e);
+  }
+  return this;
 };
-function le(e, t) {
+function Yt(n, t) {
   try {
-    return history.pushState(e, "", t), !0;
-  } catch (s) {
-    return f.warn(
-      d.ROUTE,
+    return history.pushState(n, "", t), !0;
+  } catch (e) {
+    return d.warn(
+      E.ROUTE,
       "PushState failed (likely file:// protocol or security restriction). UI will update, but URL will not.",
-      s
+      e
     ), !1;
   }
 }
-class Ms {
+class Ps {
   constructor(t) {
     this.isDestroyed = !1, this.previousRoute = "", this.cleanups = [], this.templateCache = /* @__PURE__ */ new Map(), this.config = {
       ...t,
-      mode: t.mode ?? dt.mode,
-      basePath: t.basePath ?? dt.basePath,
-      autoBindLinks: t.autoBindLinks ?? dt.autoBindLinks,
-      activeClass: t.activeClass ?? dt.activeClass
-    }, this.isHistoryMode = this.config.mode === "history", this.$target = c(this.config.target), this.normalizedBasePath = this.config.basePath?.replace(/\/$/, "") || "", this.previousUrl = this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash, this.currentRouteAtom = Ft(this.getRouteName()), this.currentRoute = this.currentRouteAtom, this.queryParamsAtom = Ft(this.getQueryParams()), this.queryParams = Ct(() => this.queryParamsAtom.value), this.handleUrlChange = this.handleUrlChange.bind(this), this.destroy = this.destroy.bind(this), this.init();
+      mode: t.mode ?? et.mode,
+      basePath: t.basePath ?? et.basePath,
+      autoBindLinks: t.autoBindLinks ?? et.autoBindLinks,
+      activeClass: t.activeClass ?? et.activeClass
+    }, this.isHistoryMode = this.config.mode === "history", this.$target = h(this.config.target), this.normalizedBasePath = this.config.basePath?.replace(/\/$/, "") || "", this.activeClass = this.config.activeClass ?? et.activeClass, this.previousUrl = this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash, this.currentRouteAtom = Dt(this.getRouteName()), this.currentRoute = this.currentRouteAtom, this.queryParamsAtom = Dt(this.getQueryParams()), this.queryParams = gt(() => this.queryParamsAtom.value), this.handleUrlChange = this.handleUrlChange.bind(this), this.destroy = this.destroy.bind(this), this.init();
   }
   init() {
     const t = this.isHistoryMode ? "popstate" : "hashchange";
     window.addEventListener(t, this.handleUrlChange), this.cleanups.push(() => window.removeEventListener(t, this.handleUrlChange));
-    const s = X(() => {
-      const n = this.currentRouteAtom.value;
-      H(() => this.renderRoute(n));
+    const e = V(() => {
+      const s = this.currentRouteAtom.value;
+      P(() => this.renderRoute(s));
     });
-    this.cleanups.push(() => s.dispose()), this.setupAutoBindLinks(), this.$target[0] && g.trackCleanup(this.$target[0], this.destroy);
+    this.cleanups.push(() => e.dispose()), this.setupAutoBindLinks(), this.$target[0] && R.trackCleanup(this.$target[0], this.destroy);
   }
   // --- Mode-abstracted internal methods ---
   /**
@@ -1747,11 +2114,11 @@ class Ms {
   getRouteName() {
     const { default: t } = this.config;
     if (this.isHistoryMode) {
-      let r = window.location.pathname;
-      return this.normalizedBasePath && r.startsWith(this.normalizedBasePath) && (r = r.substring(this.normalizedBasePath.length)), r.charCodeAt(0) === 47 && (r = r.slice(1)), r || t;
+      let o = window.location.pathname;
+      return this.normalizedBasePath && o.startsWith(this.normalizedBasePath) && (o = o.substring(this.normalizedBasePath.length)), o.charCodeAt(0) === 47 && (o = o.slice(1)), o || t;
     }
-    const s = window.location.hash, n = s.indexOf("?");
-    return (n === -1 ? s.substring(1) : s.substring(1, n)) || t;
+    const e = window.location.hash, s = e.indexOf("?");
+    return (s === -1 ? e.substring(1) : e.substring(1, s)) || t;
   }
   /**
    * Parses query parameters from the current URL.
@@ -1760,24 +2127,30 @@ class Ms {
    * only (`{ a: '2' }`). This matches `URLSearchParams` → `Object.fromEntries`
    * behaviour. If multi-value keys are needed, access `queryParams` via
    * `new URLSearchParams(window.location.search).getAll('key')` directly.
+   *
+   * Malformed percent-encoding (e.g. `%FF%FE`) is handled silently by
+   * `URLSearchParams` — it replaces undecodable sequences with the replacement
+   * character (U+FFFD) and continues parsing. If malformed encoding is detected,
+   * a warning is emitted via `debug.warn`, but the best-effort parsed result
+   * is still returned.
    */
   getQueryParams() {
     let t;
     if (this.isHistoryMode) {
       if (t = window.location.search.substring(1), !t) return {};
     } else {
-      const i = window.location.hash, r = i.indexOf("?");
-      if (r === -1) return {};
-      t = i.substring(r + 1);
+      const i = window.location.hash, o = i.indexOf("?");
+      if (o === -1) return {};
+      t = i.substring(o + 1);
     }
-    const s = new URLSearchParams(t), n = Object.fromEntries(s);
+    const e = new URLSearchParams(t), s = Object.fromEntries(e);
     if (t.includes("%"))
       try {
         decodeURIComponent(t);
       } catch {
-        f.warn(d.ROUTE, S.MALFORMED_URI(t));
+        d.warn(E.ROUTE, S.ROUTE.MALFORMED_URI(t));
       }
-    return n;
+    return s;
   }
   /**
    * Updates the browser URL to reflect a new route and keeps `previousUrl`
@@ -1785,11 +2158,11 @@ class Ms {
    */
   setUrl(t) {
     if (this.isHistoryMode) {
-      const s = `${this.normalizedBasePath}/${t}`;
-      le(null, s), this.previousUrl = s;
+      const e = `${this.normalizedBasePath}/${t}`;
+      Yt(null, e), this.previousUrl = e;
     } else {
-      const s = `#${t}`;
-      window.location.hash = s, this.previousUrl = s;
+      const e = `#${t}`;
+      window.location.hash = e, this.previousUrl = e;
     }
   }
   /**
@@ -1798,7 +2171,7 @@ class Ms {
    * that occur with replaceState during popstate events.
    */
   restoreUrl() {
-    this.isHistoryMode ? le(null, this.previousUrl) : window.location.hash = this.previousUrl;
+    this.isHistoryMode ? Yt(null, this.previousUrl) : window.location.hash = this.previousUrl;
   }
   /**
    * Returns the current full URL string for comparison purposes.
@@ -1811,9 +2184,9 @@ class Ms {
    * Resolves route configuration, falling back to notFound route if needed.
    */
   getRouteConfig(t) {
-    const { routes: s, notFound: n } = this.config;
-    let i = s[t];
-    return !i && n && (i = s[n]), i || (f.warn(d.ROUTE, S.ROUTE_NOT_FOUND(t)), null);
+    const { routes: e, notFound: s } = this.config;
+    let i = e[t];
+    return !i && s && (i = e[s]), i || (d.warn(E.ROUTE, S.ROUTE.NOT_FOUND(t)), null);
   }
   /**
    * Appends cloned template content into the target container.
@@ -1821,15 +2194,15 @@ class Ms {
    * before invoking this method if a clean slate is needed.
    */
   renderTemplate(t) {
-    let s = this.templateCache.get(t);
-    if (!s) {
+    let e = this.templateCache.get(t);
+    if (!e) {
       const i = document.querySelector(t);
       if (!i || !(i instanceof HTMLTemplateElement))
-        return f.warn(d.ROUTE, S.TEMPLATE_NOT_FOUND(t)), !1;
-      s = i, this.templateCache.set(t, s);
+        return d.warn(E.ROUTE, S.ROUTE.TEMPLATE_NOT_FOUND(t)), !1;
+      e = i, this.templateCache.set(t, e);
     }
-    const n = s.content.cloneNode(!0);
-    return this.$target.append(n), !0;
+    const s = e.content.cloneNode(!0);
+    return this.$target.append(s), !0;
   }
   /**
    * Renders the specified route, including lifecycle hooks and content.
@@ -1840,27 +2213,33 @@ class Ms {
    * outgoing content are disposed before the nodes are removed — preventing
    * the MutationObserver auto-cleanup path from firing a redundant cleanup.
    *
-   * If `beforeTransition` throws, the render is aborted and the outgoing
-   * content remains in the DOM. This is intentional — a throwing hook signals
-   * that the transition should not proceed.
+   * EXCEPTION BEHAVIOUR:
+   * - `beforeTransition` throws → render aborted, outgoing DOM intact,
+   *   `previousRoute` unchanged. Intentional: a throwing hook signals that
+   *   the transition should not proceed.
+   * - `onEnter` throws → container is already empty (`$target.empty()` ran),
+   *   rendering is skipped, and `previousRoute` is NOT updated. The router
+   *   is left in an empty-container / stale-previousRoute state. This behavior
+   *   is by design to prevent unintended state changes if the `onEnter` hook fails.
+   *   If recovery is needed, the hook should catch its own errors internally.
    */
   renderRoute(t) {
     if (this.isDestroyed) return;
-    const s = this.$target[0];
-    if (!s) {
-      f.warn(d.ROUTE, S.TARGET_NOT_FOUND(this.config.target));
+    const e = this.$target[0];
+    if (!e) {
+      d.warn(E.ROUTE, S.ROUTE.TARGET_NOT_FOUND(this.config.target));
       return;
     }
-    const n = this.getRouteConfig(t);
-    if (!n) return;
-    const i = this.getQueryParams(), r = this.previousRoute;
-    this.config.beforeTransition && this.config.beforeTransition(r, t), this.$target.empty();
-    let o = i;
-    if (n.onEnter) {
-      const l = n.onEnter(i);
-      l !== void 0 && (o = { ...i, ...l });
+    const s = this.getRouteConfig(t);
+    if (!s) return;
+    const i = this.getQueryParams(), o = this.previousRoute;
+    this.config.beforeTransition && this.config.beforeTransition(o, t), this.$target.empty();
+    let r = i;
+    if (s.onEnter) {
+      const c = s.onEnter(i);
+      c !== void 0 && (r = { ...i, ...c });
     }
-    n.render ? n.render(s, t, o) : n.template && this.renderTemplate(n.template) && n.onMount && n.onMount(this.$target.children()), this.config.afterTransition && this.config.afterTransition(r, t), this.previousRoute = t;
+    s.render ? s.render(e, t, r) : s.template && this.renderTemplate(s.template) && s.onMount && s.onMount(this.$target.children()), this.config.afterTransition && this.config.afterTransition(o, t), this.previousRoute = t;
   }
   /**
    * Handles browser URL change events (hashchange or popstate).
@@ -1869,18 +2248,18 @@ class Ms {
     if (this.isDestroyed) return;
     const t = this.getCurrentUrl();
     if (t === this.previousUrl) return;
-    const s = this.getRouteName(), n = this.currentRouteAtom.peek(), i = this.getQueryParams();
-    if (n !== s) {
-      const r = this.config.routes[n];
-      if (r?.onLeave && r.onLeave() === !1) {
+    const e = this.getRouteName(), s = this.currentRouteAtom.peek(), i = this.getQueryParams();
+    if (s !== e) {
+      const o = this.config.routes[s];
+      if (o?.onLeave && o.onLeave() === !1) {
         this.restoreUrl();
         return;
       }
-      this.currentRouteAtom.value = s, this.queryParamsAtom.value = i;
+      this.currentRouteAtom.value = e, this.queryParamsAtom.value = i;
     } else {
       this.queryParamsAtom.value = i;
-      const r = this.config.routes[n];
-      r?.onParamsChange ? r.onParamsChange(i) : this.renderRoute(s);
+      const o = this.config.routes[s];
+      o?.onParamsChange ? o.onParamsChange(i) : this.renderRoute(e);
     }
     this.previousUrl = t;
   }
@@ -1899,23 +2278,23 @@ class Ms {
     if (!this.config.autoBindLinks) return;
     const t = (i) => {
       i.preventDefault();
-      const r = i.currentTarget.dataset.route;
-      r != null && this.navigate(r);
+      const o = i.currentTarget.dataset.route;
+      o != null && this.navigate(o);
     };
-    c(document).on("click", "[data-route]", t), this.cleanups.push(() => {
-      c(document).off("click", "[data-route]", t);
+    h(document).on("click", "[data-route]", t), this.cleanups.push(() => {
+      h(document).off("click", "[data-route]", t);
     });
-    const { activeClass: s } = this.config, n = X(() => {
+    const e = this.activeClass, s = V(() => {
       const i = this.currentRouteAtom.value;
-      H(() => {
-        const r = document.querySelectorAll("[data-route]");
-        for (const o of r) {
-          const l = o.dataset.route, p = i === l;
-          o.classList.toggle(s, p), p ? o.setAttribute("aria-current", "page") : o.removeAttribute("aria-current");
+      P(() => {
+        const o = document.querySelectorAll("[data-route]");
+        for (let r = 0, c = o.length; r < c; r++) {
+          const a = o[r], l = a.dataset.route, u = i === l;
+          a.classList.toggle(e, u), u ? a.setAttribute("aria-current", "page") : a.removeAttribute("aria-current");
         }
       });
     });
-    this.cleanups.push(() => n.dispose());
+    this.cleanups.push(() => s.dispose());
   }
   /**
    * Navigates to the specified route programmatically.
@@ -1927,13 +2306,13 @@ class Ms {
    */
   navigate(t) {
     if (this.isDestroyed) return;
-    const s = this.currentRouteAtom.peek(), n = this.config.routes[s];
-    if (n?.onLeave && n.onLeave() === !1)
+    const e = this.currentRouteAtom.peek(), s = this.config.routes[e];
+    if (s?.onLeave && s.onLeave() === !1)
       return;
     const i = t || this.config.default;
     if (!i) {
-      f.warn(
-        d.ROUTE,
+      d.warn(
+        E.ROUTE,
         "navigate() called with empty routeName and no default configured."
       );
       return;
@@ -1946,73 +2325,107 @@ class Ms {
    * cleanup does not prevent the remaining ones from running.
    */
   destroy() {
-    this.isDestroyed || (this.isDestroyed = !0, this.cleanups.forEach((t) => {
+    if (this.isDestroyed) return;
+    this.isDestroyed = !0;
+    const t = this.cleanups;
+    this.cleanups = [];
+    for (let e = 0, s = t.length; e < s; e++)
       try {
-        t();
-      } catch (s) {
-        f.warn(d.ROUTE, "Cleanup error during destroy:", s);
+        t[e]();
+      } catch (i) {
+        d.warn(E.ROUTE, "Cleanup error during destroy:", i);
       }
-    }), this.cleanups.length = 0, this.templateCache.clear());
+    this.templateCache.clear();
   }
 }
-function $s(e) {
-  return new Ms(e);
+function Ms(n) {
+  return new Ps(n);
 }
-c.extend({
-  route: $s
-});
-const Fs = new Promise(() => {
+h.extend({
+  route: Ms
 });
-c.extend({
-  atomFetch(e, t) {
-    const { defaultValue: s, transform: n, method: i, headers: r, ajaxOptions: o, onError: l, eager: p } = t, C = typeof e == "function" ? e : null, b = typeof e == "string" ? e : void 0, N = {
-      ...o,
-      ...i !== void 0 && { method: i },
-      ...r !== void 0 && { headers: r }
-    };
-    let E = null;
-    return Ct(
-      async () => {
-        E?.abort(), E = new AbortController();
-        const m = E.signal, P = b ? { ...N, url: b } : { ...N, url: C() }, U = c.ajax(P);
-        m.onabort = () => U.abort(), m.aborted && U.abort();
+class Fs {
+  constructor(t, e) {
+    this.abortController = null, this.isStaticUrl = typeof t == "string", this.isStaticUrl ? this.staticUrl = t : this.getUrl = t, typeof e.ajaxOptions == "function" ? (this.ajaxOptionsFn = e.ajaxOptions, this.staticOptions = {}) : this.staticOptions = { ...e.ajaxOptions }, e.method !== void 0 && (this.staticOptions.method = e.method), e.headers !== void 0 && (this.staticOptions.headers = { ...this.staticOptions.headers, ...e.headers }), this.transformFn = e.transform, this.onErrorFn = e.onError, this.execute = this.execute.bind(this);
+  }
+  abort() {
+    this.abortController?.abort();
+  }
+  async execute() {
+    this.abortController?.abort(), this.abortController = new AbortController();
+    const t = this.abortController.signal, e = this.ajaxOptionsFn ? this.ajaxOptionsFn() : {}, s = h.extend(!0, {}, this.staticOptions, e);
+    s.success = void 0, s.error = void 0, s.complete = void 0, s.url = this.isStaticUrl ? this.staticUrl : this.getUrl();
+    const i = h.ajax(s);
+    t.onabort = () => i.abort(), t.aborted && i.abort();
+    let o;
+    try {
+      o = await i;
+    } catch (c) {
+      if (t.aborted) {
+        const u = new Error("AbortError");
+        throw u.name = "AbortError", u;
+      }
+      let a;
+      if (c && typeof c.readyState < "u") {
+        const u = c;
+        a = new Error(`Network Error: ${u.statusText || "Unknown"} (${u.status})`), a.jqXHR = u;
+      } else
+        a = c instanceof Error ? c : new Error(String(c ?? "Unknown network error"));
+      const l = this.onErrorFn;
+      if (l)
         try {
-          const G = await U;
-          return n ? n(G) : G;
-        } catch (G) {
-          if (m.aborted)
-            return Fs;
+          l(a);
+        } catch {
+        }
+      throw a;
+    } finally {
+      t.onabort = null, this.abortController?.signal === t && (this.abortController = null);
+    }
+    const r = this.transformFn;
+    if (r)
+      try {
+        return r(o);
+      } catch (c) {
+        const a = this.onErrorFn;
+        if (a)
           try {
-            l?.(G);
+            a(c);
           } catch {
           }
-          throw G;
-        } finally {
-          m.onabort = null, E.signal === m && (E = null);
-        }
-      },
-      { defaultValue: s, lazy: !(p ?? !0) }
-    );
+        throw c;
+      }
+    return o;
+  }
+}
+h.extend({
+  atomFetch(n, t) {
+    const e = new Fs(n, t), s = !(t.eager ?? !0), i = gt(e.execute, {
+      defaultValue: t.defaultValue,
+      lazy: s
+    });
+    return Object.assign(i, {
+      abort: () => e.abort()
+    });
   }
 });
-c(() => {
-  Ns(), Rs(document.body);
+h(() => {
+  ns(), ts(document.body);
 });
 export {
-  Ft as atom,
-  ye as batch,
-  Ct as computed,
-  qs as default,
+  Dt as atom,
+  ne as batch,
+  gt as computed,
+  zs as default,
   Gs as disableAutoCleanup,
-  js as disablejQueryOverrides,
-  X as effect,
-  Rs as enableAutoCleanup,
-  Ns as enablejQueryOverrides,
-  qt as isAtom,
-  Ve as isComputed,
-  Ce as isReactive,
-  Cs as nextTick,
-  g as registry,
-  H as untracked
+  Hs as disablejQueryOverrides,
+  V as effect,
+  ts as enableAutoCleanup,
+  ns as enablejQueryOverrides,
+  wt as isAtom,
+  xe as isComputed,
+  oe as isReactive,
+  We as nextTick,
+  R as registry,
+  P as untracked
 };
 //# sourceMappingURL=index.mjs.map