@but212/atom-effect-jquery 0.21.3 → 0.22.1

package/dist/index.mjs

@@ -1,14 +1,14 @@
-import l from "jquery";
-import { default as mn } from "jquery";
-const bt = {
+import c from "jquery";
+import { default as qs } from "jquery";
+const ut = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, M = {
+}, L = {
   DISPOSED: 1,
   EXECUTING: 8
-}, ce = {
+}, fe = {
   DISPOSED: 1,
   /** Marker bit: identifies this node as a computed. */
   IS_COMPUTED: 2,
@@ -19,11 +19,11 @@ const bt = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, z = {
+}, $ = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, W = {
+}, q = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
@@ -33,96 +33,84 @@ const bt = {
   MIN_FLUSH_ITERATIONS: 10,
   // Memory management
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, ve = {
+}, we = {
   WARN_INFINITE_LOOP: !0
-}, Qt = {
+}, te = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
-}, Vt = 1073741823, Le = typeof process < "u" && process.env && !1 || !1, Ae = Object.freeze([]);
-class ot extends Error {
-  constructor(t, n = null, s = !0) {
-    super(t), this.cause = n, this.recoverable = s, this.name = "AtomError";
+}, 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";
   }
 }
-class Q extends ot {
-  constructor(t, n = null) {
-    super(t, n, !0), this.name = "ComputedError";
+class z extends tt {
+  constructor(t, s = null) {
+    super(t, s, !0), this.name = "ComputedError";
   }
 }
-class st extends ot {
-  constructor(t, n = null) {
-    super(t, n, !1), this.name = "EffectError";
+class J extends tt {
+  constructor(t, s = null) {
+    super(t, s, !1), this.name = "EffectError";
   }
 }
-class wt extends ot {
-  constructor(t, n = null) {
-    super(t, n, !1), this.name = "SchedulerError";
+class At extends tt {
+  constructor(t, s = null) {
+    super(t, s, !1), this.name = "SchedulerError";
   }
 }
-const Ne = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), ke = /* @__PURE__ */ Symbol("AtomEffect.Type"), Ut = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), kt = {
+const Pe = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Me = /* @__PURE__ */ Symbol("AtomEffect.Type"), Ut = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), yt = {
   // Dev mode flag
-  enabled: Le,
-  warnInfiniteLoop: ve.WARN_INFINITE_LOOP,
+  enabled: ke,
+  warnInfiniteLoop: we.WARN_INFINITE_LOOP,
   warn(e, t) {
   },
   checkCircular(e, t) {
     if (e === t)
-      throw new Q("Direct circular dependency detected");
+      throw new z("Direct circular dependency detected");
   },
-  attachDebugInfo(e, t, n) {
+  attachDebugInfo(e, t, s) {
   },
-  getDebugName: (e) => e?.[Ne],
-  getDebugType: (e) => e?.[ke]
+  getDebugName: (e) => e?.[Pe],
+  getDebugType: (e) => e?.[Me]
 };
-let Re = 1;
-const we = () => Re++;
-function ae(e, t, n) {
+let $e = 1;
+const Fe = () => $e++;
+function de(e, t, s) {
   if (typeof t == "function") {
     const i = t;
-    for (let o = 0, r = n.length; o < r; o++) {
-      const c = n[o];
-      if (c && c.fn === i) return;
-    }
-    n.push(new $t(i, void 0));
+    if (s.some((r) => r && r.fn === i)) return;
+    s.push(new Mt(i, void 0));
     return;
   }
   if ("addDependency" in t) {
     t.addDependency(e);
     return;
   }
-  const s = t;
-  for (let i = 0, o = n.length; i < o; i++) {
-    const r = n[i];
-    if (r && r.sub === s) return;
-  }
-  n.push(new $t(void 0, s));
+  const n = t;
+  s.some((i) => i && i.sub === n) || s.push(new Mt(void 0, n));
 }
-function Yt(e, t, n) {
-  const s = /* @__PURE__ */ new Map();
-  for (let i = 0, o = t.length; i < o; i++) {
-    const r = t[i];
-    r?.unsub && s.set(r.node, r.unsub);
-  }
-  for (let i = 0, o = e.length; i < o; i++) {
-    const r = e[i];
-    if (!r) continue;
-    const c = r.node, a = s.get(c);
-    a !== void 0 ? (r.unsub = a, s.delete(c)) : (kt.checkCircular(c, n), r.unsub = c.subscribe(n));
-  }
-  for (const i of s.values())
-    i();
+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 Mt {
-  constructor(t, n, s = void 0) {
-    this.node = t, this.version = n, this.unsub = s;
+class Pt {
+  constructor(t, s, n = void 0) {
+    this.node = t, this.version = s, this.unsub = n;
   }
 }
-class $t {
-  constructor(t, n) {
-    this.fn = t, this.sub = n;
+class Mt {
+  constructor(t, s) {
+    this.fn = t, this.sub = s;
   }
 }
-const D = {
+const y = {
   // Computed Errors
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
@@ -147,81 +135,74 @@ const D = {
   SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
   SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring."
 };
-function it(e, t, n) {
-  if (e instanceof ot)
+function Z(e, t, s) {
+  if (e instanceof tt)
     return e;
-  const s = e instanceof Error, i = s ? e.message : String(e), o = s ? e : void 0, r = `${s ? e.constructor.name : "Unexpected error"} (${n}): ${i}`;
-  return new t(r, o);
+  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);
 }
-class ue {
+class _e {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = we() & Vt;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = Fe() & It;
   }
 }
-class le extends ue {
+class Ee extends _e {
   /**
    * Adds subscriber.
    */
   subscribe(t) {
-    const n = typeof t == "function";
-    if (!n && (!t || typeof t.execute != "function"))
-      throw it(
+    const s = typeof t == "function";
+    if (!s && (!t || typeof t.execute != "function"))
+      throw Z(
         new TypeError("Invalid subscriber"),
-        ot,
-        D.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        tt,
+        y.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
-    const s = this._subscribers;
-    for (let o = 0, r = s.length; o < r; o++) {
-      const c = s[o];
-      if (c && (n ? c.fn === t : c.sub === t))
-        return () => {
-        };
-    }
-    const i = new $t(
-      n ? t : void 0,
-      n ? void 0 : t
+    if (this._subscribers.some((i) => i ? s ? i.fn === t : i.sub === t : !1))
+      return () => {
+      };
+    const n = new Mt(
+      s ? t : void 0,
+      s ? void 0 : t
     );
-    return s.push(i), () => this._unsubscribe(i);
+    return this._subscribers.push(n), () => this._unsubscribe(n);
   }
   _unsubscribe(t) {
-    const n = this._subscribers, s = n.indexOf(t);
-    if (s === -1) return;
-    const i = n.pop();
-    s < n.length && i && (n[s] = i);
+    const s = this._subscribers, n = s.indexOf(t);
+    if (n === -1) return;
+    const i = s.pop();
+    n < s.length && i && (s[n] = i);
   }
   subscriberCount() {
     return this._subscribers.length;
   }
-  _notifySubscribers(t, n) {
-    if (this._subscribers.length === 0) return;
-    const s = this._subscribers.slice(0), i = s.length;
-    for (let o = 0; o < i; o++) {
-      const r = s[o];
-      if (r)
+  _notifySubscribers(t, s) {
+    this._subscribers.length !== 0 && this._subscribers.slice(0).forEach((n) => {
+      if (n)
         try {
-          r.fn ? r.fn(t, n) : r.sub && r.sub.execute();
-        } catch (c) {
-          this._handleNotifyError(c);
+          n.fn ? n.fn(t, s) : n.sub && n.sub.execute();
+        } catch (i) {
+          this._handleNotifyError(i);
         }
-    }
+    });
   }
   _handleNotifyError(t) {
-    console.error(it(t, ot, D.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(Z(t, tt, y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let xt = 0;
-const zt = () => (xt = xt + 1 & Vt || 1, xt), Bt = (e) => e + 1 & Vt;
-let qt = 0, Lt = !1, he = 0;
-const Ue = () => he;
-function Wt() {
-  return Lt ? !1 : (Lt = !0, he = zt(), qt = 0, !0);
+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);
 }
-const Jt = () => {
-  Lt = !1;
-}, xe = () => Lt ? ++qt : 0;
-class Pe {
+const ne = () => {
+  pt = !1;
+}, Be = () => pt ? ++zt : 0;
+class He {
   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 = W.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 = q.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
@@ -256,30 +237,28 @@ class Pe {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = Wt();
-      this._drainQueue(), t && Jt();
+      const t = se();
+      this._drainQueue(), t && ne();
     } finally {
       this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = Wt();
+    const t = se();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && Jt();
+      this._isFlushingSync = !1, t && ne();
     }
   }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const t = ++this._epoch, n = this._batchQueue, s = this._queueBuffer[this._bufferIndex];
+    const t = ++this._epoch, s = this._batchQueue, n = this._queueBuffer[this._bufferIndex];
     let i = this._size;
-    for (let o = 0; o < this._batchQueueSize; o++) {
-      const r = n[o];
-      r._nextEpoch !== t && (r._nextEpoch = t, s[i++] = r);
-    }
-    this._size = i, this._batchQueueSize = 0, n.length > W.BATCH_QUEUE_SHRINK_THRESHOLD && (n.length = 0);
+    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);
   }
   _drainQueue() {
     let t = 0;
@@ -292,21 +271,21 @@ class Pe {
     }
   }
   _processQueue() {
-    const t = this._bufferIndex, n = this._queueBuffer[t], s = this._size;
+    const t = this._bufferIndex, s = this._queueBuffer[t], n = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
-    for (let i = 0; i < s; i++)
+    for (let i = 0; i < n; i++)
       try {
-        n[i]();
-      } catch (o) {
-        console.error(new wt("Error occurred during scheduler execution", o));
+        s[i]();
+      } catch (r) {
+        console.error(new At("Error occurred during scheduler execution", r));
       }
-    n.length = 0;
+    s.length = 0;
   }
   _handleFlushOverflow() {
     const t = this._size + this._batchQueueSize;
     if (console.error(
-      new wt(
-        D.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
+      new At(
+        y.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
       try {
@@ -321,14 +300,14 @@ class Pe {
     this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(t) {
-    if (t < W.MIN_FLUSH_ITERATIONS)
-      throw new wt(
-        `Max flush iterations must be at least ${W.MIN_FLUSH_ITERATIONS}`
+    if (t < q.MIN_FLUSH_ITERATIONS)
+      throw new At(
+        `Max flush iterations must be at least ${q.MIN_FLUSH_ITERATIONS}`
       );
     this._maxFlushIterations = t;
   }
 }
-const _t = new Pe(), Xt = /* @__PURE__ */ Symbol.for("atom-effect/atom"), fe = /* @__PURE__ */ Symbol.for("atom-effect/computed"), Fe = /* @__PURE__ */ Symbol.for("atom-effect/effect"), $ = {
+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 = {
   /** Active listener. */
   current: null,
   /**
@@ -339,45 +318,45 @@ const _t = new Pe(), Xt = /* @__PURE__ */ Symbol.for("atom-effect/atom"), fe = /
    * @returns The result of `fn`.
    */
   run(e, t) {
-    const n = this.current;
+    const s = this.current;
     this.current = e;
     try {
       return t();
     } finally {
-      this.current = n;
+      this.current = s;
     }
   }
 };
-function Me(e) {
-  const t = $.current;
+function H(e) {
+  const t = k.current;
   if (t === null) return e();
-  $.current = null;
+  k.current = null;
   try {
     return e();
   } finally {
-    $.current = t;
+    k.current = t;
   }
 }
-var Zt;
-class $e extends le {
-  constructor(t, n) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = () => this._flushNotifications(), this._subscribers = [], this[Zt] = !0, this._value = t, n && (this.flags |= z.SYNC), kt.attachDebugInfo(this, "atom", this.id);
+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);
   }
   get value() {
-    const t = $.current;
-    return t && ae(this, t, this._subscribers), this._value;
+    const t = k.current;
+    return t && de(this, t, this._subscribers), this._value;
   }
   set value(t) {
-    const n = this._value;
-    if (Object.is(n, t)) return;
-    this._value = t, this.version = Bt(this.version);
-    const s = this.flags;
-    if (!(this._subscribers.length === 0 || s & z.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = n, this.flags = s | z.NOTIFICATION_SCHEDULED, s & z.SYNC && !_t.isBatching) {
+    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) {
         this._flushNotifications();
         return;
       }
-      _t.schedule(this._notifyTask);
+      rt.schedule(this._notifyTask);
     }
   }
   /**
@@ -385,32 +364,32 @@ class $e extends le {
    */
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & z.NOTIFICATION_SCHEDULED) || t & z.DISPOSED)
+    if (!(t & $.NOTIFICATION_SCHEDULED) || t & $.DISPOSED)
       return;
-    const n = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, n);
+    const s = this._pendingOldValue;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, s);
   }
   peek() {
     return this._value;
   }
   dispose() {
-    this.flags & z.DISPOSED || (this._subscribers.length = 0, this.flags |= z.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+    this.flags & $.DISPOSED || (this._subscribers.length = 0, this.flags |= $.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
   }
-  [(Zt = Xt, Symbol.dispose)]() {
+  [(ie = Vt, Symbol.dispose)]() {
     this.dispose();
   }
 }
-function jt(e, t = {}) {
-  return new $e(e, t.sync ?? !1);
+function Ft(e, t = {}) {
+  return new je(e, t.sync ?? !1);
 }
-class Be {
+class ze {
   /**
    * @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, n = 256, s = !1) {
-    this.limit = t, this.capacity = n, this.pool = [], this.stats = null, this.stats = s ? {
+  constructor(t = 50, s = 256, n = !1) {
+    this.limit = t, this.capacity = s, this.pool = [], this.stats = null, this.stats = n ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -428,8 +407,8 @@ class Be {
    * @param arr - Array to release.
    * @param emptyConst - Optional empty constant.
    */
-  release(t, n) {
-    if (!(n && t === n)) {
+  release(t, s) {
+    if (!(s && t === s)) {
       if (t.length > this.capacity) {
         this.stats && this.stats.rejected.tooLarge++;
         return;
@@ -450,11 +429,11 @@ class Be {
    */
   getStats() {
     if (!this.stats) return null;
-    const { acquired: t, released: n, rejected: s } = this.stats, i = t - n - (s.frozen + s.tooLarge + s.poolFull);
+    const { acquired: t, released: s, rejected: n } = this.stats, i = t - s - (n.frozen + n.tooLarge + n.poolFull);
     return {
       acquired: t,
-      released: n,
-      rejected: { ...s },
+      released: s,
+      rejected: { ...n },
       leaked: i,
       poolSize: this.pool.length
     };
@@ -470,58 +449,58 @@ class Be {
     });
   }
 }
-const x = Object.freeze(
+const O = Object.freeze(
   []
-), q = new Be();
-function de(e) {
-  return e !== null && typeof e == "object" && Xt in e;
+), B = new ze();
+function qt(e) {
+  return e !== null && typeof e == "object" && Vt in e;
 }
-function _e(e) {
-  return e !== null && typeof e == "object" && fe in e;
+function Ve(e) {
+  return e !== null && typeof e == "object" && ge in e;
 }
-function Ee(e) {
+function Ie(e) {
   return e !== null && typeof e == "object" && typeof e.then == "function";
 }
-var te, ee;
-const { IDLE: St, DIRTY: et, PENDING: Dt, RESOLVED: Y, REJECTED: ft, HAS_ERROR: It, RECOMPUTING: ht, DISPOSED: Pt, IS_COMPUTED: je } = ce;
-function He(e) {
-  return e & Y ? bt.RESOLVED : e & Dt ? bt.PENDING : e & ft ? bt.REJECTED : bt.IDLE;
-}
-class Ve extends le {
-  constructor(t, n = {}) {
-    if (typeof t != "function") throw new Q(D.COMPUTED_MUST_BE_FUNCTION);
-    super(), this[ee] = !0, this[te] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = x, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = x, this._trackCount = 0, this._value = void 0, this.flags = je | et | St, this._equal = n.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in n ? n.defaultValue : Ut, this._onError = n.onError ?? null;
-    const s = n.maxAsyncRetries;
-    if (this._maxAsyncRetries = s != null && s >= 0 ? s : Qt.MAX_ASYNC_RETRIES, kt.attachDebugInfo(this, "computed", this.id), n.lazy === !1)
+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)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = $.current;
-    t && ae(this, t, this._subscribers);
+    const t = k.current;
+    t && de(this, t, this._subscribers);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (Y | et | St)) === Y)
+    if ((t & (V | K | lt)) === V)
       return this._value;
-    if (t & Pt)
-      throw new Q(D.COMPUTED_DISPOSED);
-    if (t & ht) {
+    if (t & wt)
+      throw new z(y.COMPUTED_DISPOSED);
+    if (t & st) {
       if (this._defaultValue !== Ut) return this._defaultValue;
-      throw new Q(D.COMPUTED_CIRCULAR_DEPENDENCY);
+      throw new z(y.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (et | St) && (this._recompute(), this.flags & Y))
+    if (t & (K | lt) && (this._recompute(), this.flags & V))
       return this._value;
-    const n = this._defaultValue, s = n !== Ut;
-    if (this.flags & Dt) {
-      if (s) return n;
-      throw new Q(D.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    const s = this._defaultValue, n = s !== Ut;
+    if (this.flags & _t) {
+      if (n) return s;
+      throw new z(y.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & ft) {
-      if (s) return n;
+    if (this.flags & nt) {
+      if (n) return s;
       throw this._error;
     }
     return this._value;
@@ -530,253 +509,225 @@ class Ve extends le {
     return this._value;
   }
   get state() {
-    return this._track(), He(this.flags);
+    return this._track(), Xe(this.flags);
   }
   get hasError() {
-    if (this._track(), this.flags & (ft | It)) return !0;
-    const t = this._links;
-    for (let n = 0, s = t.length; n < s; n++) {
-      const i = t[n]?.node;
-      if (i && i.flags & It) return !0;
-    }
-    return !1;
+    return this._track(), this.flags & (nt | ft) ? !0 : this._links.some((t) => t?.node?.flags & ft);
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    if (this._track(), !this.hasError) return Ae;
+    if (this._track(), !this.hasError) return xe;
     const t = [];
-    this._error && t.push(this._error);
-    const n = this._links;
-    for (let s = 0, i = n.length; s < i; s++) {
-      const o = n[s].node;
-      if (o.flags & It) {
-        const r = o.errors;
-        if (r.length > 0)
-          for (let c = 0; c < r.length; c++) {
-            const a = r[c];
-            a && t.indexOf(a) === -1 && t.push(a);
-          }
-      }
-    }
-    return Object.freeze(t);
+    return this._error && t.push(this._error), this._links.forEach((s) => {
+      const n = s.node;
+      n.flags & ft && n.errors.forEach((i) => {
+        i && !t.includes(i) && t.push(i);
+      });
+    }), Object.freeze(t);
   }
   get lastError() {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & Dt) !== 0;
+    return this._track(), (this.flags & _t) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & Y) !== 0;
+    return this._track(), (this.flags & V) !== 0;
   }
   invalidate() {
     this._markDirty();
   }
   dispose() {
-    if (this.flags & Pt) return;
+    if (this.flags & wt) return;
     const t = this._links;
-    if (t !== x) {
-      for (let n = 0, s = t.length; n < s; n++)
-        t[n].unsub?.();
-      q.release(t), this._links = x;
-    }
-    this._subscribers.length = 0, this.flags = Pt | et | St, this._error = null, this._value = void 0;
+    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;
   }
-  [(ee = Xt, te = fe, Symbol.dispose)]() {
+  [(oe = Vt, re = ge, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
     if (t._lastSeenEpoch !== this._trackEpoch) {
       if (t._lastSeenEpoch = this._trackEpoch, this._trackCount < this._trackLinks.length) {
-        const n = this._trackLinks[this._trackCount];
-        n.node = t, n.version = t.version;
+        const s = this._trackLinks[this._trackCount];
+        s.node = t, s.version = t.version;
       } else
-        this._trackLinks.push(new Mt(t, t.version));
+        this._trackLinks.push(new Pt(t, t.version));
       this._trackCount++;
     }
   }
   _recompute() {
-    if (this.flags & ht) return;
-    this.flags |= ht;
+    if (this.flags & st) return;
+    this.flags |= st;
     const t = this._links;
-    this._trackEpoch = zt(), this._trackLinks = q.acquire(), this._trackCount = 0;
-    let n = !1;
+    this._trackEpoch = jt(), this._trackLinks = B.acquire(), this._trackCount = 0;
+    let s = !1;
     try {
-      const s = $.run(this, this._fn);
-      this._trackLinks.length = this._trackCount, Yt(this._trackLinks, t, this), this._links = this._trackLinks, n = !0, Ee(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
-    } catch (s) {
-      if (!n)
+      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)
         try {
-          this._trackLinks.length = this._trackCount, Yt(this._trackLinks, t, this), this._links = this._trackLinks, n = !0;
+          this._trackLinks.length = this._trackCount, ee(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
         } catch {
         }
-      this._handleError(s, D.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(n, y.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      n && t !== x ? q.release(t) : n || q.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = x, this._trackCount = 0, this.flags &= ~ht;
+      s && t !== O ? B.release(t) : s || B.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = O, this._trackCount = 0, this.flags &= ~st;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | Dt) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Qt.MAX_PROMISE_ID;
-    const n = this._promiseId;
+    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;
     t.then(
-      (s) => {
-        if (n === this._promiseId) {
-          if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion)
-            return this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new Q(
+      (n) => {
+        if (s === this._promiseId) {
+          if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
+            const i = me();
+            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.`
               ),
-              D.COMPUTED_ASYNC_COMPUTATION_FAILED
+              y.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
-          this._finalizeResolution(s), this._notifySubscribers(s, void 0);
+          }
+          this._finalizeResolution(n), this._notifySubscribers(n, void 0);
         }
       },
-      (s) => n === this._promiseId && this._handleError(s, D.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (n) => s === this._promiseId && this._handleError(n, y.COMPUTED_ASYNC_COMPUTATION_FAILED)
     );
   }
   _captureVersionSnapshot() {
     let t = 0;
-    const n = this._links;
-    for (let s = 0, i = n.length; s < i; s++)
-      t = (t << 5) - t + n[s].node.version | 0;
+    const s = this._links;
+    for (let n = 0, i = s.length; n < i; n++)
+      t = (t << 5) - t + s[n].node.version | 0;
     return t;
   }
-  _handleError(t, n, s = !1) {
-    const i = it(t, Q, n);
-    if (!s && !(this.flags & ft) && (this.version = Bt(this.version)), this._error = i, this.flags = this.flags & -121 | ft | It, this._onError)
+  _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)
       try {
         this._onError(i);
-      } catch (o) {
-        console.error(D.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
+      } catch (r) {
+        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
       }
-    if (s) throw i;
+    if (n) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & Y) || !this._equal(this._value, t)) && (this.version = Bt(this.version)), this._value = t, this._error = null, this.flags = (this.flags | Y) & -697;
+    (!(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;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    this.flags & (ht | et) || (this.flags |= et, this._notifySubscribers(void 0, void 0));
+    this.flags & (st | K) || (this.flags |= K, this._notifySubscribers(void 0, void 0));
   }
 }
-function Gt(e, t = {}) {
-  return new Ve(e, t);
+function Ct(e, t = {}) {
+  return new Qe(e, t);
 }
-var ne;
-class ze extends ue {
-  constructor(t, n = {}) {
-    super(), this[ne] = !0, this._cleanup = null, this._links = x, this._nextLinks = null, this._prevLinks = x, 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 = n.onError ?? null, this._sync = n.sync ?? !1, this._maxExecutions = n.maxExecutionsPerSecond ?? W.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = n.maxExecutionsPerFlush ?? W.MAX_EXECUTIONS_PER_EFFECT, this._sync ? (this._executeTask = void 0, this._notifyCallback = () => this.execute()) : (this._executeTask = () => this.execute(), this._notifyCallback = () => _t.schedule(this._executeTask)), kt.attachDebugInfo(this, "effect", this.id);
+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);
   }
   run() {
-    if (this.flags & M.DISPOSED)
-      throw new st(D.EFFECT_DISPOSED);
+    if (this.flags & L.DISPOSED)
+      throw new J(y.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & M.DISPOSED || (this.flags |= M.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== x && q.release(this._links), this._links = x, this._prevLinks = x);
+    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);
   }
-  [(ne = Fe, Symbol.dispose)]() {
+  [(ce = Ge, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & M.EXECUTING)) return;
-    const n = this._currentEpoch;
-    if (t._lastSeenEpoch === n) return;
-    t._lastSeenEpoch = n;
-    const s = this._nextLinks, i = this._prevLinks;
-    for (let o = 0, r = i.length; o < r; o++) {
-      const c = i[o];
-      if (c && c.node === t && c.unsub) {
-        c.version = t.version, s.push(c), i[o] = null;
-        return;
-      }
+    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;
+      return;
     }
     try {
       const o = t.subscribe(this._notifyCallback);
-      s.push(new Mt(t, t.version, o));
+      n.push(new Pt(t, t.version, o));
     } catch (o) {
-      const r = it(o, st, D.EFFECT_EXECUTION_FAILED);
-      if (console.error(r), this._onError)
+      const l = Z(o, J, y.EFFECT_EXECUTION_FAILED);
+      if (console.error(l), this._onError)
         try {
-          this._onError(r);
+          this._onError(l);
         } catch {
         }
-      s.push(new Mt(t, t.version, void 0));
+      n.push(new Pt(t, t.version, void 0));
     }
   }
   /**
    * Executes effect with tracking.
    */
   execute(t = !1) {
-    if (this.flags & (M.DISPOSED | M.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= M.EXECUTING, this._execCleanup(), this._prevLinks = this._links;
-    const n = q.acquire();
-    this._nextLinks = n, this._currentEpoch = zt();
-    let s = !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;
     try {
-      const i = $.run(this, this._fn);
-      this._links = n, s = !0, Ee(i) ? this._handleAsyncResult(i) : this._cleanup = typeof i == "function" ? i : null;
+      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 = n, s = !0, this._handleExecutionError(i), this._cleanup = null;
+      this._links = s, n = !0, this._handleExecutionError(i), this._cleanup = null;
     } finally {
-      this._finalizeDependencies(s, this._prevLinks, n), this.flags &= -9;
+      this._finalizeDependencies(n, this._prevLinks, s), this.flags &= -9;
     }
   }
   _handleAsyncResult(t) {
-    const n = ++this._execId;
+    const s = ++this._execId;
     t.then(
-      (s) => {
-        if (n !== this._execId || this.flags & M.DISPOSED) {
-          if (typeof s == "function")
+      (n) => {
+        if (s !== this._execId || this.flags & L.DISPOSED) {
+          if (typeof n == "function")
             try {
-              s();
+              n();
             } catch (i) {
-              this._handleExecutionError(i, D.EFFECT_CLEANUP_FAILED);
+              this._handleExecutionError(i, y.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
-        typeof s == "function" && (this._cleanup = s);
+        typeof n == "function" && (this._cleanup = n);
       },
-      (s) => n === this._execId && this._handleExecutionError(s)
+      (n) => s === this._execId && this._handleExecutionError(n)
     );
   }
-  _finalizeDependencies(t, n, s) {
-    if (this._nextLinks = null, this._prevLinks = x, t) {
-      for (let i = 0, o = n.length; i < o; i++) {
-        const r = n[i];
-        r && r.unsub?.();
-      }
-      n !== x && q.release(n);
-    } else
-      this._unsubLinks(s), q.release(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));
   }
   _unsubLinks(t) {
-    for (let n = 0, s = t.length; n < s; n++)
-      t[n]?.unsub?.();
+    t.forEach((s) => s?.unsub?.());
   }
   _isDirty() {
-    const t = this._links, n = $.current;
-    $.current = null;
+    const t = this._links, s = k.current;
+    k.current = null;
     try {
-      for (let s = 0, i = t.length; s < i; s++) {
-        const o = t[s], r = o.node;
-        if (r.flags & ce.IS_COMPUTED)
+      return t.some((n) => {
+        const i = n.node;
+        if (i.flags & fe.IS_COMPUTED)
           try {
-            r.value;
+            i.value;
           } catch {
             return !0;
           }
-        if (r.version !== o.version) return !0;
-      }
-      return !1;
+        return i.version !== n.version;
+      });
     } finally {
-      $.current = n;
+      k.current = s;
     }
   }
   _execCleanup() {
@@ -784,90 +735,116 @@ class ze extends ue {
       try {
         this._cleanup();
       } catch (t) {
-        this._handleExecutionError(t, D.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(t, y.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const t = Ue();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), xe() > W.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    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++;
   }
   get isDisposed() {
-    return (this.flags & M.DISPOSED) !== 0;
+    return (this.flags & L.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & M.EXECUTING) !== 0;
+    return (this.flags & L.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const n = new st(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${qt}`
+    const s = new J(
+      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${zt}`
     );
-    throw this.dispose(), console.error(n), n;
+    throw this.dispose(), console.error(s), s;
   }
-  _handleExecutionError(t, n = D.EFFECT_EXECUTION_FAILED) {
-    const s = it(t, st, n);
-    if (console.error(s), this._onError)
+  _handleExecutionError(t, s = y.EFFECT_EXECUTION_FAILED) {
+    const n = Z(t, J, s);
+    if (console.error(n), this._onError)
       try {
-        this._onError(s);
+        this._onError(n);
       } catch (i) {
-        console.error(it(i, st, D.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(Z(i, J, y.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
 }
-function J(e, t = {}) {
+function X(e, t = {}) {
   if (typeof e != "function")
-    throw new st(D.EFFECT_MUST_BE_FUNCTION);
-  const n = new ze(e, t);
-  return n.execute(), n;
+    throw new J(y.EFFECT_MUST_BE_FUNCTION);
+  const s = new Ke(e, t);
+  return s.execute(), s;
 }
-function Kt(e) {
+function ye(e) {
   if (typeof e != "function")
     throw new TypeError("Batch callback must be a function");
-  _t.startBatch();
+  rt.startBatch();
   try {
     return e();
   } finally {
-    _t.endBatch();
-  }
-}
-function pe(e) {
-  return de(e) || _e(e);
-}
-function Rt(e) {
-  if (!e) return "unknown";
-  const t = "jquery" in e ? e[0] : e;
-  if (!t) return "unknown";
-  const n = t.id;
-  if (n && typeof n == "string") return `#${n}`;
-  const s = t.tagName.toLowerCase(), i = t.classList;
-  if (i && i.length > 0) {
-    let o = s;
-    for (let r = 0, c = i.length; r < c; r++) {
-      const a = i[r];
-      a && (o += `.${a}`);
-    }
-    return o;
+    rt.endBatch();
   }
-  return s;
 }
-function Ot(e) {
-  let t = String(e ?? "");
-  t = t.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ""), t = t.replace(/<\?[\s\S]*?\?>/g, "");
-  const n = /(<(script|iframe|object|embed|base|meta|applet|noscript)\b[^>]*>([\s\S]*?)<\/\2>|<(script|iframe|object|embed|base|meta|applet|noscript)\b[^>]*\/?>)/gim;
-  let s;
-  do
-    s = t, t = t.replace(n, "");
-  while (t !== s);
-  const i = /(j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t|v\s*b\s*s\s*c\s*r\s*i\s*p\s*t)\s*:/gi;
-  t = t.replace(i, "data-unsafe-protocol:");
-  const o = /data\s*:\s*(?:text\/html|application\/javascript|text\/javascript|text\/vbscript|text\/xml|application\/xhtml\+xml)/gim;
-  return t = t.replace(o, "data-unsafe-protocol:"), t = t.replace(/\bon\w+\s*=/gim, "data-unsafe-attr="), t = t.replace(/expression\s*\(/gim, "data-unsafe-css(").replace(/behavior\s*:/gim, "data-unsafe-css:"), t;
+const d = {
+  /** Used by the SPA router ($.route). */
+  ROUTE: "[atom-route]",
+  /** Used by all reactive binding helpers (bindText, bindCss, bindAttr, …). */
+  BINDING: "[atom-binding]",
+  /** Used by atomList reactive list rendering. */
+  LIST: "[atom-list]",
+  /** Used by mount/unmount lifecycle helpers. */
+  MOUNT: "[atom-mount]"
+}, dt = Object.freeze({
+  mode: "hash",
+  basePath: "",
+  autoBindLinks: !1,
+  activeClass: "active"
+}), Ye = {
+  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 qe = /* @__PURE__ */ new Set([
+const Ze = /* @__PURE__ */ new Set([
   "href",
   "src",
   "action",
@@ -883,167 +860,208 @@ const qe = /* @__PURE__ */ new Set([
   "usemap",
   "classid",
   "codebase"
-]), Xe = /^\s*(?:javascript|vbscript)\s*:/i;
-function Ge(e, t) {
-  return qe.has(e.toLowerCase()) ? Xe.test(t) : !1;
+]), 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 Ke(e) {
-  return e.toLowerCase().includes("url(") ? /url\s*\(\s*(?:["']?\s*)?(?:javascript|vbscript)\s*:/i.test(e) : !1;
+function fs(e) {
+  return e.toLowerCase().includes("url(") ? ns.test(e) : !1;
 }
-function Qe(e, t) {
+function ds(e, t) {
   if (e === t) return !0;
-  if (typeof e != "object" || e === null || typeof t != "object" || t === null) return !1;
-  const n = Object.keys(e), s = Object.keys(t);
-  if (n.length !== s.length) return !1;
-  const i = t;
-  for (let o = 0; o < n.length; o++) {
-    const r = n[o];
-    if (e[r] !== i[r]) return !1;
+  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])
+      return !1;
   }
   return !0;
 }
-function Ye(e) {
+function _s(e) {
   const t = e.length;
   if (t === 0) return new Int32Array(0);
-  const n = new Int32Array(t), s = new Int32Array(t);
+  const s = new Int32Array(t).fill(-1), n = new Int32Array(t);
   let i = 0;
-  for (let r = 0; r < t; r++) {
-    const c = e[r];
-    if (c === void 0 || c === -1) continue;
-    const a = i > 0 ? s[i - 1] : void 0;
-    if (i === 0 || a !== void 0 && (e[a] ?? -1) < c) {
-      n[r] = a ?? -1, s[i++] = r;
+  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;
       continue;
     }
-    let f = 0, p = i - 1;
-    for (; f < p; ) {
-      const y = f + p >>> 1, k = s[y];
-      k !== void 0 && (e[k] ?? -1) < c ? f = y + 1 : p = y;
+    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;
     }
-    const S = s[f];
-    S !== void 0 && c < (e[S] ?? Number.MAX_SAFE_INTEGER) && (f > 0 && (n[r] = s[f - 1] ?? -1), s[f] = r);
+    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 o = new Int32Array(i);
+  const r = new Int32Array(i);
   if (i > 0) {
-    let r = s[i - 1];
-    for (let c = i - 1; c >= 0 && r !== void 0 && r !== -1; c--)
-      o[c] = r, r = n[r];
+    let o = n[i - 1];
+    for (let l = i - 1; l >= 0 && o !== void 0 && o !== -1; l--)
+      r[l] = o, o = s[o];
   }
-  return o;
+  return r;
 }
-function We() {
+const Es = {}, be = 600, ps = `${be / 1e3}s`;
+function ms() {
   if (typeof window < "u") {
     const e = window.__ATOM_DEBUG__;
     if (typeof e == "boolean") return e;
   }
-  return !1;
+  return Es?.VITE_ATOM_DEBUG === "true";
 }
-let K = We();
-const E = {
+let Y = ms();
+const f = {
   get enabled() {
-    return K;
+    return Y;
   },
   set enabled(e) {
-    K = e;
+    Y = e;
   },
+  /**
+   * Logs a message only when debug mode is active.
+   */
   log(e, ...t) {
-    K && console.log(`[atom-effect-jquery] ${e}:`, ...t);
+    Y && console.log(`${d.MOUNT} ${e}:`, ...t);
   },
-  atomChanged(e, t, n) {
-    K && console.log(
-      `[atom-effect-jquery] Atom "${e ?? "anonymous"}" changed:`,
+  /**
+   * 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,
       "→",
-      n
+      s
     );
   },
   /**
-   * Logs DOM updates and triggers visual highlight.
+   * 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, n) {
-    K && (console.log(`[atom-effect-jquery] DOM updated: ${Rt(e)}.${t} =`, n), Ze(e));
+  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));
   },
+  /**
+   * Logs a cleanup event only when debug mode is active.
+   */
   cleanup(e) {
-    K && console.log(`[atom-effect-jquery] Cleanup: ${e}`);
+    Y && console.log(`${d.MOUNT} Cleanup: ${e}`);
+  },
+  /**
+   * 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.
+   */
+  warn(e, t, ...s) {
+    console.warn(`${e} ${t}`, ...s);
   },
-  warn(...e) {
-    K && console.warn("[atom-effect-jquery]", ...e);
-  }
-}, Ht = "atom-debug-highlight";
-let se = !1;
-function Je() {
-  if (se) return;
-  se = !0;
+  /**
+   * 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.textContent = `.${Ht}{outline:2px solid rgba(255,68,68,0.8);outline-offset:1px;transition:outline 0.5s ease-out}`, document.head.appendChild(e);
-}
-const Ft = /* @__PURE__ */ new WeakMap();
-function Ze(e) {
-  const t = "jquery" in e ? e[0] : e;
-  if (!t || !t.isConnected) return;
-  Je();
-  const n = Ft.get(t);
-  n && clearTimeout(n), t.classList.add(Ht), Ft.set(
-    t,
-    setTimeout(() => {
-      t.classList.remove(Ht), Ft.delete(t);
-    }, 600)
-  );
+  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);
 }
-function ge(e, t = {}) {
-  return jt(e, t);
+const kt = /* @__PURE__ */ new WeakMap(), xt = /* @__PURE__ */ new WeakMap();
+function ys(e) {
+  if (!e.isConnected) return;
+  Is();
+  const t = xt.get(e);
+  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,
+      setTimeout(() => {
+        e.classList.remove(Ht), kt.delete(e);
+      }, be)
+    );
+  });
+  xt.set(e, n);
 }
-Object.defineProperty(ge, "debug", {
+function Se(e, t) {
+  return Ft(e, t);
+}
+Object.defineProperty(Se, "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 E.enabled;
+    return f.enabled;
   },
   set(e) {
-    E.enabled = e;
+    f.enabled = e;
   }
 });
-function tn() {
+function Cs() {
   return new Promise((e) => setTimeout(e, 0));
 }
-l.extend({
-  atom: ge,
-  computed: Gt,
-  effect: J,
-  batch: Kt,
-  untracked: Me,
-  isAtom: de,
-  isComputed: _e,
-  isReactive: pe,
-  nextTick: tn
-});
-const en = "_aes-bound", Z = {
-  ROUTE: "[$.route]",
-  BIND: "[atomBind]",
-  LIST: "[atomList]"
-}, Ct = {
-  MODE: "hash",
-  ACTIVE_CLASS: "active",
-  BASE_PATH: "",
-  AUTO_BIND_LINKS: !1
-}, nn = {
-  EVENT: "input"
-}, sn = ["innerHTML", "outerHTML"], rt = {
-  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}`,
-  UNSAFE_CONTENT: "Unsafe content neutralized during sanitization.",
-  BLOCKED_DANGEROUS_VALUE: (e) => `Blocked dangerous value in "${e}" property.`,
-  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}>.`,
-  DUPLICATE_KEY: (e, t) => `Duplicate key "${e}" at index ${t}.`
-}, Tt = en;
-class on {
+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
+};
+c.extend(bs);
+const W = "_aes-bound";
+class Ss {
   constructor() {
-    this.records = /* @__PURE__ */ new WeakMap(), this.boundElements = /* @__PURE__ */ new WeakSet(), this.preservedNodes = /* @__PURE__ */ new WeakSet(), this.ignoredNodes = /* @__PURE__ */ new WeakSet();
+    this.records = /* @__PURE__ */ new WeakMap(), this.preservedNodes = /* @__PURE__ */ new WeakSet(), this.ignoredNodes = /* @__PURE__ */ new WeakSet();
   }
-  // Prevent redundant cleanup
+  // --------------------------------------------------------------------------
+  // Lifecycle flags
+  // --------------------------------------------------------------------------
   keep(t) {
     this.preservedNodes.add(t);
   }
@@ -1056,758 +1074,945 @@ class on {
   isIgnored(t) {
     return this.ignoredNodes.has(t);
   }
-  _getOrCreateRecord(t) {
-    let n = this.records.get(t);
-    return n || (n = {}, this.records.set(t, n), this.boundElements.has(t) || (this.boundElements.add(t), t.classList.add(Tt))), n;
+  // --------------------------------------------------------------------------
+  // Tracking
+  // --------------------------------------------------------------------------
+  getOrCreateRecord(t) {
+    let s = this.records.get(t);
+    return s || (s = {}, this.records.set(t, s), t.classList.add(W)), s;
+  }
+  trackEffect(t, s) {
+    const n = this.getOrCreateRecord(t);
+    n.effects ??= [], n.effects.push(s);
   }
-  trackEffect(t, n) {
-    const s = this._getOrCreateRecord(t);
-    s.effects ??= [], s.effects.push(n);
+  trackCleanup(t, s) {
+    const n = this.getOrCreateRecord(t);
+    n.cleanups ??= [], n.cleanups.push(s);
   }
-  trackCleanup(t, n) {
-    const s = this._getOrCreateRecord(t);
-    s.cleanups ??= [], s.cleanups.push(n);
+  setComponentCleanup(t, s) {
+    const n = this.getOrCreateRecord(t);
+    n.componentCleanup = s;
   }
   hasBind(t) {
-    return this.boundElements.has(t);
+    return this.records.has(t);
   }
+  // --------------------------------------------------------------------------
+  // Cleanup
+  // --------------------------------------------------------------------------
   cleanup(t) {
-    if (!this.boundElements.delete(t)) return;
-    const n = this.records.get(t);
-    if (!n) return;
-    this.records.delete(t), this.preservedNodes.delete(t), this.ignoredNodes.delete(t), t.classList.remove(Tt), E.enabled && E.cleanup(Rt(t));
-    const s = n.effects;
-    if (s)
-      for (let o = 0, r = s.length; o < r; o++)
-        try {
-          s[o]?.dispose();
-        } catch (c) {
-          E.warn("Effect dispose error:", c);
-        }
-    const i = n.cleanups;
-    if (i)
-      for (let o = 0, r = i.length; o < r; o++)
-        try {
-          i[o]?.();
-        } catch (c) {
-          E.warn("Cleanup error:", c);
-        }
+    const s = this.records.get(t);
+    if (!s) {
+      t.isConnected && t.classList.remove(W), 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) => {
+      try {
+        n();
+      } catch (i) {
+        f.error(d.BINDING, S.BINDING_CLEANUP_ERROR(), i);
+      }
+    });
   }
   cleanupDescendants(t) {
-    const n = t.querySelectorAll(`.${Tt}`);
-    for (let s = 0, i = n.length; s < i; s++) {
-      const o = n[s];
-      o && this.boundElements.has(o) ? this.cleanup(o) : o && o.classList.remove(Tt);
-    }
+    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
+      ));
   }
   cleanupTree(t) {
     this.cleanupDescendants(t), this.cleanup(t);
   }
 }
-const b = new on();
-let dt = null;
-function rn(e = document.body) {
-  dt || (dt = new MutationObserver((t) => {
-    for (let n = 0, s = t.length; n < s; n++) {
-      const i = t[n]?.removedNodes;
-      if (!i) continue;
-      const o = i.length;
-      if (o !== 0)
-        for (let r = 0; r < o; r++) {
-          const c = i[r];
-          c.nodeType === 1 && (c.isConnected || b.isKept(c) || b.isIgnored(c) || b.cleanupTree(c));
-        }
+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 }
+    );
+    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 });
+}
+function Gs() {
+  it?.disconnect(), it = null, Et = null;
+}
+function Q(e, t, s, n) {
+  if (Ce(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);
+        });
+      })
+    );
+  } else {
+    try {
+      s(t);
+    } catch (i) {
+      f.error(d.BINDING, `${S.UPDATER_ERROR(n)} (static):`, i);
+      return;
     }
-  }), dt.observe(e, { childList: !0, subtree: !0 }));
-}
-function En() {
-  dt?.disconnect(), dt = null;
-}
-function X(e, t, n, s) {
-  pe(t) ? b.trackEffect(
-    e,
-    J(() => {
-      const i = t.value;
-      n(i), E.domUpdated(l(e), s, i);
-    })
-  ) : (n(t), E.enabled && E.domUpdated(l(e), s, t));
-}
-var L = /* @__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))(L || {});
-function me() {
-  return {
-    timeoutId: null,
-    flags: 0
-    /* None */
-  };
+    f.enabled && f.domUpdated(e, n, t);
+  }
 }
-function cn(e, t, n = {}) {
-  const {
-    debounce: s,
-    event: i = nn.EVENT,
-    parse: o = (I) => I,
-    format: r = (I) => String(I ?? ""),
-    equal: c = Object.is
-  } = n, a = me(), f = e[0], p = () => {
-    if (!(a.flags & L.Busy)) {
-      a.flags |= L.SyncingToAtom;
-      try {
-        const I = f.value, C = o(I);
-        c(t.value, C) || (t.value = C);
-      } finally {
-        a.flags &= ~L.SyncingToAtom;
-      }
+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;
+};
+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
+  };
+  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));
     }
-  }, S = () => {
-    a.timeoutId && (clearTimeout(a.timeoutId), a.timeoutId = null, p()), a.flags &= ~L.Focused;
-    const I = r(t.value);
-    f.value !== I && (f.value = I);
-  }, y = () => {
-    a.flags & L.Busy || (s ? (a.timeoutId && clearTimeout(a.timeoutId), a.timeoutId = setTimeout(p, s)) : p());
-  }, k = {
-    compositionstart: () => {
-      a.flags |= L.Composing;
-    },
-    compositionend: () => {
-      a.flags &= ~L.Composing, p();
-    },
-    focus: () => {
-      a.flags |= L.Focused;
-    },
-    blur: S,
-    [i]: y,
-    change: y
+    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);
+    }
+    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);
+    }
+    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);
   };
-  return e.on(k), { effect: () => {
-    const I = t.value, C = r(I), w = f.value;
-    if (w !== C && !(a.flags & L.Focused && c(o(w), I))) {
-      a.flags |= L.SyncingToDom;
+}
+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);
+}
+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;
+    }, this.handleCompositionEnd = () => {
+      this.flags &= ~T.Composing, this.handleInput();
+    }, this.handleFocus = () => {
+      this.flags |= T.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.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)
+          try {
+            if (this.options.equal(this.options.parse(l), r)) return;
+          } catch {
+          }
+        this.flags |= T.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);
+        } finally {
+          this.flags &= ~T.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.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();
+  }
+  // --- Sync Logic ---
+  syncAtomFromDom() {
+    if (!(this.flags & T.Busy)) {
+      this.flags |= T.SyncingToAtom;
       try {
-        if (a.flags & L.Focused) {
-          const { selectionStart: H, selectionEnd: ct } = f;
-          f.value = C;
-          const V = C.length;
-          f.setSelectionRange(Math.min(H ?? 0, V), Math.min(ct ?? 0, V));
-        } else
-          f.value = C;
-        E.domUpdated(e, "val", C);
+        const t = this.options.parse(this.el.value);
+        this.options.equal(this.atom.peek(), t) || (this.atom.value = t);
+      } catch (t) {
+        f.warn(d.BINDING, `${S.PARSE_ERROR()}:`, t);
       } finally {
-        a.flags &= ~L.SyncingToDom;
+        this.flags &= ~T.SyncingToAtom;
       }
     }
-  }, cleanup: () => {
-    e.off(k), a.timeoutId && clearTimeout(a.timeoutId);
-  } };
+  }
+  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);
+  }
+}
+function As(e, t, s) {
+  const n = new Ds(e, t, s);
+  return { fx: X(n.syncDomFromAtom), cleanup: n.cleanup };
 }
-const ie = /* @__PURE__ */ Object.create(null);
-function an(e) {
-  let t = ie[e];
-  return t || (t = e.includes("-") ? e.replace(/-./g, (n) => n[1].toUpperCase()) : e, ie[e] = t, t);
+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;
 }
-function B(e) {
-  let t = null;
+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;
+}
+function D(e) {
   return {
-    get $el() {
-      return t || (t = l(e)), t;
-    },
+    $el: c(e),
     el: e,
-    trackCleanup: (n) => b.trackCleanup(e, n)
+    trackCleanup: (t) => g.trackCleanup(e, t)
   };
 }
-function un(e, t) {
+function Te(e, t, s) {
   const n = e.el;
-  X(
+  Q(
     n,
     t,
-    (s) => {
-      const i = typeof s == "string" ? s : String(s ?? "");
-      n.textContent !== i && (n.textContent = i);
+    (i) => {
+      const r = s ? s(i) : typeof i == "string" ? i : String(i ?? "");
+      n.textContent !== r && (n.textContent = r);
     },
     "text"
   );
 }
-function ye(e, t) {
-  const n = e.el;
-  X(
+function Oe(e, t) {
+  const s = e.el, n = qt(t) ? Ls(t) : t;
+  Q(
+    s,
     n,
-    t,
-    (s) => {
-      const i = String(s ?? ""), o = Ot(i);
-      o !== i && console.warn(`${Z.BIND} ${rt.UNSAFE_CONTENT}`), n.innerHTML !== o && (n.innerHTML = o);
+    (i) => {
+      s.innerHTML !== i && (g.cleanupDescendants(s), s.innerHTML = i);
     },
     "html"
   );
 }
-function be(e, t) {
-  for (const n in t)
-    X(
+function Ne(e, t) {
+  Object.entries(t).forEach(([s, n]) => {
+    Q(
       e.el,
-      t[n],
-      (s) => {
-        e.el.classList.toggle(n, !!s);
+      n,
+      (i) => {
+        e.el.classList.toggle(s, !!i);
       },
-      `class.${n}`
+      `class.${s}`
     );
+  });
 }
-function Se(e, t) {
-  const n = e.el, s = n.style;
-  for (const i in t) {
-    const o = t[i];
-    if (o === void 0) continue;
-    const r = an(i), c = Array.isArray(o), a = c ? o[0] : o, f = c ? o[1] : "";
-    X(
-      n,
-      a,
-      (p) => {
-        const S = f ? `${p}${f}` : String(p);
-        if (Ke(S)) {
-          console.warn(`${Z.BIND} ${rt.BLOCKED_DANGEROUS_VALUE(i)}`);
-          return;
-        }
-        s[r] = S;
+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 Ie(e, t) {
-  const n = e.el;
-  for (const s in t) {
-    const i = s.charCodeAt(0);
-    if ((i === 111 || i === 79) && (s.charCodeAt(1) === 110 || s.charCodeAt(1) === 78)) {
-      console.warn(`${Z.BIND} ${rt.BLOCKED_EVENT_HANDLER(s)}`);
-      continue;
-    }
-    X(
-      n,
-      t[s],
-      (o) => {
-        if (o == null || o === !1) {
-          n.removeAttribute(s);
-          return;
-        }
-        const r = o === !0 ? s : String(o);
-        if (Ge(s, r)) {
-          console.warn(`${Z.BIND} ${rt.BLOCKED_PROTOCOL(s)}`);
+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;
         }
-        n.getAttribute(s) !== r && n.setAttribute(s, r);
+        const r = i === !0 ? n : String(i);
+        ls(n, r) || s.getAttribute(n) !== r && s.setAttribute(n, r);
       },
-      `attr.${s}`
+      `attr.${n}`
     );
-  }
+  });
 }
-function Ce(e, t) {
-  const n = e.el;
-  for (const s in t) {
-    if (sn.includes(s)) {
-      console.warn(`${Z.BIND} ${rt.BLOCKED_DANGEROUS_PROP(s)}`);
-      continue;
-    }
-    X(
+function Ae(e, t) {
+  const s = e.el;
+  Object.keys(t).forEach((n) => {
+    Je.has(n) || Q(
       e.el,
-      t[s],
+      t[n],
       (i) => {
-        n[s] !== i && (n[s] = i);
+        s[n] !== i && (s[n] = i);
       },
-      `prop.${s}`
+      `prop.${n}`
     );
-  }
+  });
 }
-function At(e, t, n, s) {
-  const i = e.el;
-  X(
-    i,
+function gt(e, t, s) {
+  const n = e.el;
+  Q(
+    n,
     t,
-    (o) => {
-      const r = n ? !o : !!o;
-      i.style.display = r ? "" : "none", E.enabled && E.domUpdated(i, s, o);
+    (r) => {
+      const o = s !== !!r;
+      n.style.display = o ? "" : "none";
     },
-    s
+    s ? "hide" : "show"
   );
 }
-function Te(e, t) {
+function Gt(e, t, s = {}) {
   const n = e.el.tagName.toLowerCase();
-  if (n !== "input" && n !== "select" && n !== "textarea") {
-    console.warn(`[atomBind] Val binding used on non-input element <${n}>.`);
+  if (!We.has(n)) {
+    console.warn(`${d.BINDING} ${S.INVALID_INPUT_ELEMENT(n)}`);
     return;
   }
-  const s = Array.isArray(t), { effect: i, cleanup: o } = cn(
-    e.$el,
-    s ? t[0] : t,
-    s ? t[1] : {}
-  );
-  b.trackEffect(e.el, J(i)), e.trackCleanup(o);
+  const { fx: i, cleanup: r } = As(e.$el, t, s);
+  g.trackEffect(e.el, i), e.trackCleanup(r);
 }
-function De(e, t) {
-  const n = e.el, s = e.$el, i = me(), o = () => {
-    if (i.flags & L.Busy) return;
-    const c = n.checked;
-    t.value !== c && (t.value = c);
+function Ue(e, t) {
+  const s = e.el, n = e.$el, i = () => {
+    const o = s.checked;
+    t.value !== o && (t.value = o);
   };
-  s.on("change", o), e.trackCleanup(() => s.off("change", o));
-  const r = J(() => {
-    i.flags |= L.SyncingToDom;
-    const c = !!t.value;
-    n.checked !== c && (n.checked = c, E.enabled && E.domUpdated(s, "checked", c)), i.flags &= ~L.SyncingToDom;
+  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));
+    });
   });
-  b.trackEffect(n, r);
-}
-function ln(e, t) {
-  for (const n in t) {
-    const s = t[n];
-    if (typeof s != "function") continue;
-    const i = (o) => {
-      Kt(
-        () => s.call(
-          e.el,
-          l.Event(o.type, { originalEvent: o })
-        )
-      );
-    };
-    e.el.addEventListener(n, i), e.trackCleanup(() => e.el.removeEventListener(n, i));
-  }
+  g.trackEffect(s, r);
 }
-l.fn.atomBind = function(e) {
+function ws(e, t) {
+  const s = e.$el;
+  s.on(t), e.trackCleanup(() => s.off(t));
+}
+function ks(e, t, s) {
+  const n = e.$el;
+  n.on(t, s), e.trackCleanup(() => n.off(t, s));
+}
+function Le(e) {
+  g.cleanupTree(e);
+}
+c.fn.atomText = function(e, t) {
   return this.each(function() {
-    const t = B(this);
-    e.text !== void 0 && un(t, e.text), e.html !== void 0 && ye(t, e.html), e.class && be(t, e.class), e.css && Se(t, e.css), e.attr && Ie(t, e.attr), e.prop && Ce(t, e.prop), e.show !== void 0 && At(t, e.show, !1, "show"), e.hide !== void 0 && At(t, e.hide, !0, "hide"), e.val !== void 0 && Te(t, e.val), e.checked !== void 0 && De(t, e.checked), e.on && ln(t, e.on);
+    Te(D(this), e, t);
   });
 };
-l.fn.atomText = function(e, t) {
+c.fn.atomHtml = function(e) {
   return this.each(function() {
-    const n = l(this);
-    X(this, e, t ? (i) => n.text(t(i)) : (i) => n.text(String(i ?? "")), "text");
+    Oe(D(this), e);
   });
 };
-l.fn.atomHtml = function(e) {
+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() {
-    ye(B(this), e);
+    Ne(D(this), s);
   });
 };
-l.fn.atomClass = function(e, t) {
+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() {
-    be(B(this), { [e]: t });
+    ve(D(this), n);
   });
 };
-l.fn.atomCss = function(e, t, n) {
+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() {
-    Se(B(this), { [e]: n ? [t, n] : t });
+    De(D(this), s);
   });
 };
-l.fn.atomAttr = function(e, t) {
+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() {
-    Ie(B(this), { [e]: t });
+    Ae(D(this), s);
   });
 };
-l.fn.atomProp = function(e, t) {
+c.fn.atomShow = function(e) {
   return this.each(function() {
-    Ce(B(this), { [e]: t });
+    gt(D(this), e, !1);
   });
 };
-l.fn.atomShow = function(e) {
+c.fn.atomHide = function(e) {
   return this.each(function() {
-    At(B(this), e, !1, "show");
+    gt(D(this), e, !0);
   });
 };
-l.fn.atomHide = function(e) {
+c.fn.atomVal = function(e, t = {}) {
   return this.each(function() {
-    At(B(this), e, !0, "hide");
+    Gt(D(this), e, t);
   });
 };
-l.fn.atomVal = function(e, t = {}) {
+c.fn.atomChecked = function(e) {
   return this.each(function() {
-    Te(
-      B(this),
-      t && Object.keys(t).length > 0 ? [e, t] : e
-    );
+    Ue(D(this), e);
   });
 };
-l.fn.atomChecked = function(e) {
+c.fn.atomOn = function(e, t) {
   return this.each(function() {
-    De(B(this), e);
+    ks(D(this), e, t);
   });
 };
-l.fn.atomOn = function(e, t) {
+c.fn.atomBind = function(e) {
   return this.each(function() {
-    const n = l(this);
-    n.on(e, t), b.trackCleanup(this, () => n.off(e, t));
+    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);
   });
 };
-l.fn.atomUnbind = function() {
+c.fn.atomUnbind = function() {
   return this.each(function() {
-    b.cleanupTree(this);
+    Le(this);
   });
 };
-l.fn.atomList = function(e, t) {
-  const { key: n, render: s, bind: i, update: o, onAdd: r, onRemove: c, empty: a } = t, f = typeof n == "function" ? n : (p, S) => p[n];
+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 p = l(this), S = Rt(this), y = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set();
-    let R = [], A = null;
-    const I = J(() => {
-      const C = e.value, w = C.length;
-      if (w === 0) {
-        if (a && !A) {
-          const h = typeof a == "string" ? Ot(a) : a;
-          A = l(h).appendTo(p);
+    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);
+    };
+    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;
         }
-      } else A && (A.remove(), A = null);
-      if (w === 0 && y.size === 0) {
-        R = [];
-        return;
-      }
-      E.log("list", `${S} updating with ${w} items`);
-      const H = /* @__PURE__ */ new Map(), ct = R.length;
-      for (let h = 0; h < ct; h++)
-        H.set(R[h], h);
-      const V = new Array(w), at = /* @__PURE__ */ new Set(), Et = new Int32Array(w);
-      for (let h = 0; h < w; h++) {
-        const U = C[h], g = f(U, h);
-        at.has(g) && console.warn(`${Z.LIST} ${rt.DUPLICATE_KEY(g, h)}`), V[h] = g, at.add(g), Et[h] = H.get(g) ?? -1;
-      }
-      if (y.size > 0)
-        for (const [h, U] of y) {
-          if (at.has(h) || k.has(h)) continue;
-          const g = () => {
-            U.$el.remove(), U.$el[0] && b.cleanup(U.$el[0]), k.delete(h), E.log("list", `${S} removed item:`, h);
-          };
-          if (y.delete(h), k.add(h), c) {
-            const T = c(U.$el);
-            T instanceof Promise ? T.then(g) : g();
+        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
-            g();
+            ct.push(_), Rt.push(h), Tt.push(a), ot[a] = -1;
         }
-      if (w === 0) {
-        R = [];
-        return;
-      }
-      const pt = Ye(Et);
-      let ut = pt.length - 1, P = null;
-      for (let h = w - 1; h >= 0; h--) {
-        const U = V[h], g = C[h], T = y.get(U);
-        if (T) {
-          const j = T.item;
-          T.item = g;
-          const tt = T.$el[0];
-          if (!tt) continue;
-          if (o)
-            o(T.$el, g, h), E.domUpdated(T.$el, "list.update", g);
-          else if (j !== g && !Qe(j, g)) {
-            const O = s(g, h), gt = typeof O == "string" ? Ot(O) : O, G = l(gt), u = P === tt;
-            T.$el.replaceWith(G), T.$el = G, i && i(G, g, h), E.domUpdated(G, "list.render", g), u && (P = G[0] || null);
-          }
-          if (ut >= 0 && pt[ut] === h)
-            ut--;
-          else {
-            const O = T.$el[0];
-            P?.isConnected ? P !== O && T.$el.insertBefore(P) : T.$el.appendTo(p);
+        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));
           }
-          P = T.$el[0] || null;
         } else {
-          const j = s(g, h), tt = typeof j == "string" ? Ot(j) : j, O = l(tt);
-          y.set(U, { $el: O, item: g }), P?.isConnected ? O.insertBefore(P) : O.appendTo(p), i && i(O, g, h), r && r(O), E.domUpdated(O, "list.add", g), P = O[0] || null;
+          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));
+            }
         }
-      }
-      R = V;
-    });
-    b.trackEffect(this, I), b.trackCleanup(this, () => {
-      y.clear(), k.clear(), R = [], A?.remove();
+        P = M;
+      });
+    }), g.trackEffect(this, bt), g.trackCleanup(this, () => {
+      E.clear(), m.clear(), P = [], U?.remove();
     });
   });
 };
-const vt = /* @__PURE__ */ new WeakMap();
-l.fn.atomMount = function(e, t = {}) {
+const Ps = Object.freeze({});
+c.fn.atomMount = function(e, t) {
+  const s = t ?? Ps;
   return this.each(function() {
-    const n = Rt(this), s = vt.get(this);
-    s && (E.log("mount", `${n} unmounting existing component`), s()), E.log("mount", `${n} mounting component`);
+    g.cleanupTree(this);
+    const n = c(this);
     let i;
     try {
-      i = e(l(this), t);
+      i = H(() => e(n, s));
     } catch (r) {
-      console.error("[atom-effect-jquery] Mount error:", r);
+      f.error(d.MOUNT, S.MOUNT_ERROR(), r);
       return;
     }
-    const o = () => {
-      if (vt.delete(this)) {
-        if (E.log("mount", `${n} full cleanup`), typeof i == "function")
-          try {
-            i();
-          } catch (r) {
-            console.error("[atom-effect-jquery] Cleanup error:", r);
-          }
-        b.cleanupTree(this);
-      }
-    };
-    vt.set(this, o), b.trackCleanup(this, o);
+    typeof i == "function" && g.setComponentCleanup(this, i);
   });
 };
-l.fn.atomUnmount = function() {
+c.fn.atomUnmount = function() {
   return this.each(function() {
-    const e = vt.get(this);
-    e && e();
+    Le(this);
   });
 };
-const nt = Z.ROUTE;
-function hn(e) {
-  const {
-    target: t,
-    default: n,
-    routes: s,
-    notFound: i,
-    mode: o = Ct.MODE,
-    basePath: r = Ct.BASE_PATH,
-    autoBindLinks: c = Ct.AUTO_BIND_LINKS,
-    activeClass: a = Ct.ACTIVE_CLASS,
-    beforeTransition: f,
-    afterTransition: p
-  } = e, S = o === "history";
-  let y = !1, k = null, R = S ? window.location.pathname + window.location.search : window.location.hash;
-  const A = [], I = /* @__PURE__ */ new Set(), C = l(t), w = () => {
-    if (S) {
-      let m = window.location.pathname;
-      return r && m.startsWith(r) && (m = m.substring(r.length)), m.replace(/^\//, "") || n;
+function le(e, t) {
+  try {
+    return history.pushState(e, "", t), !0;
+  } catch (s) {
+    return f.warn(
+      d.ROUTE,
+      "PushState failed (likely file:// protocol or security restriction). UI will update, but URL will not.",
+      s
+    ), !1;
+  }
+}
+class Ms {
+  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();
+  }
+  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));
+    });
+    this.cleanups.push(() => s.dispose()), this.setupAutoBindLinks(), this.$target[0] && g.trackCleanup(this.$target[0], this.destroy);
+  }
+  // --- Mode-abstracted internal methods ---
+  /**
+   * Extracts route name from current URL.
+   * Uses `normalizedBasePath` for consistent stripping in history mode.
+   */
+  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;
     }
-    const u = window.location.hash, d = u.indexOf("?");
-    return (d === -1 ? u.substring(1) : u.substring(1, d)) || n;
-  }, H = () => {
-    let u;
-    if (S) {
-      if (u = window.location.search.substring(1), !u) return {};
+    const s = window.location.hash, n = s.indexOf("?");
+    return (n === -1 ? s.substring(1) : s.substring(1, n)) || t;
+  }
+  /**
+   * Parses query parameters from the current URL.
+   *
+   * Note: duplicate keys (e.g. `?a=1&a=2`) are collapsed to the last value
+   * 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.
+   */
+  getQueryParams() {
+    let t;
+    if (this.isHistoryMode) {
+      if (t = window.location.search.substring(1), !t) return {};
     } else {
-      const m = window.location.hash, v = m.indexOf("?");
-      if (v === -1) return {};
-      u = m.substring(v + 1);
+      const i = window.location.hash, r = i.indexOf("?");
+      if (r === -1) return {};
+      t = i.substring(r + 1);
     }
-    const d = new URLSearchParams(u), _ = Object.fromEntries(d);
-    if (u.includes("%"))
+    const s = new URLSearchParams(t), n = Object.fromEntries(s);
+    if (t.includes("%"))
       try {
-        decodeURIComponent(u);
+        decodeURIComponent(t);
       } catch {
-        E.warn(`${nt} Malformed URI component: ${u}`);
+        f.warn(d.ROUTE, S.MALFORMED_URI(t));
       }
-    return _;
-  }, ct = (u, d, _) => {
-    try {
-      return history.pushState(u, d, _), !0;
-    } catch (m) {
-      return E.warn(
-        `${nt} PushState failed (likely file:// protocol or security restriction). UI will update, but URL will not.`,
-        m
-      ), !1;
-    }
-  }, V = (u, d, _) => {
-    try {
-      return history.replaceState(u, d, _), !0;
-    } catch (m) {
-      return E.warn(`${nt} ReplaceState failed.`, m), !1;
-    }
-  }, at = (u) => {
-    if (S) {
-      const d = `${r.replace(/\/$/, "")}/${u}`;
-      ct(null, "", d), R = d;
+    return n;
+  }
+  /**
+   * Updates the browser URL to reflect a new route and keeps `previousUrl`
+   * in sync so `handleUrlChange` does not re-process our own navigation.
+   */
+  setUrl(t) {
+    if (this.isHistoryMode) {
+      const s = `${this.normalizedBasePath}/${t}`;
+      le(null, s), this.previousUrl = s;
     } else {
-      const d = `#${u}`;
-      R = d, window.location.hash = d;
+      const s = `#${t}`;
+      window.location.hash = s, this.previousUrl = s;
     }
-  }, Et = () => {
-    S ? V(null, "", R) : window.location.hash = R;
-  }, pt = () => S ? window.location.pathname + window.location.search : window.location.hash, ut = (u) => {
-    let d = s[u];
-    return !d && i && (d = s[i]), d || (E.warn(`${nt} Route "${u}" not found and no notFound route configured`), null);
-  }, P = (u) => {
-    const d = document.querySelector(u);
-    if (!d?.content)
-      return E.warn(`${nt} Template "${u}" not found`), !1;
-    const _ = d.content.cloneNode(!0);
-    return C.append(_), !0;
-  }, h = jt(w()), U = jt(H()), g = (u) => {
-    if (y) return;
-    const d = C[0];
-    if (!d) {
-      E.warn(`${nt} Target element "${t}" not found`);
+  }
+  /**
+   * Restores the URL when a navigation guard blocks the transition.
+   * Uses pushState to safely add a new history entry, avoiding "back button traps"
+   * that occur with replaceState during popstate events.
+   */
+  restoreUrl() {
+    this.isHistoryMode ? le(null, this.previousUrl) : window.location.hash = this.previousUrl;
+  }
+  /**
+   * Returns the current full URL string for comparison purposes.
+   */
+  getCurrentUrl() {
+    return this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash;
+  }
+  // --- End mode-abstracted methods ---
+  /**
+   * 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);
+  }
+  /**
+   * Appends cloned template content into the target container.
+   * Always appends — callers are responsible for calling `$target.empty()`
+   * before invoking this method if a clean slate is needed.
+   */
+  renderTemplate(t) {
+    let s = this.templateCache.get(t);
+    if (!s) {
+      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);
+    }
+    const n = s.content.cloneNode(!0);
+    return this.$target.append(n), !0;
+  }
+  /**
+   * Renders the specified route, including lifecycle hooks and content.
+   *
+   * Called from within a reactive effect, so DOM mutations here run
+   * synchronously inside the effect body. `registry.cleanupDescendants` is
+   * called before `$target.empty()` to ensure any reactive bindings on
+   * 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.
+   */
+  renderRoute(t) {
+    if (this.isDestroyed) return;
+    const s = this.$target[0];
+    if (!s) {
+      f.warn(d.ROUTE, S.TARGET_NOT_FOUND(this.config.target));
       return;
     }
-    const _ = ut(u);
-    if (!_) return;
-    const m = H();
-    f && f(k || u, u), C.empty();
-    let v = m;
-    if (_.onEnter) {
-      const N = _.onEnter(m);
-      N !== void 0 && (v = { ...m, ...N });
+    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 });
     }
-    _.render ? _.render(d, u, v) : _.template && P(_.template) && _.onMount && _.onMount(C.children()), p && p(k || u, u), k = u;
-  }, T = (u) => {
-    if (y) return;
-    const d = h.value, _ = s[d];
-    if (_?.onLeave && _.onLeave() === !1)
-      return;
-    const m = u || n;
-    at(m), h.value = m;
-  }, j = () => {
-    if (y) return;
-    const u = pt();
-    if (u === R) return;
-    const d = w(), _ = h.value, m = H();
-    if (_ !== d) {
-      const v = s[_];
-      if (v?.onLeave && v.onLeave() === !1) {
-        Et();
+    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;
+  }
+  /**
+   * Handles browser URL change events (hashchange or popstate).
+   */
+  handleUrlChange() {
+    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) {
+        this.restoreUrl();
         return;
       }
-      h.value = d, U.value = m;
+      this.currentRouteAtom.value = s, this.queryParamsAtom.value = i;
     } else {
-      U.value = m;
-      const v = s[_];
-      v?.onParamsChange ? v.onParamsChange(m) : g(d);
+      this.queryParamsAtom.value = i;
+      const r = this.config.routes[n];
+      r?.onParamsChange ? r.onParamsChange(i) : this.renderRoute(s);
     }
-    R = u;
-  }, tt = () => {
-    if (!c) return;
-    const u = (N) => {
-      N.preventDefault();
-      const F = N.currentTarget.dataset.route;
-      F != null && T(F);
-    };
-    l(document).on("click", "[data-route]", u), A.push(() => {
-      l(document).off("click", "[data-route]", u);
-    });
-    const d = (N) => {
-      I.has(N) || (I.add(N), N.classList.add("_aes-bound"));
+    this.previousUrl = t;
+  }
+  /**
+   * Sets up automatic binding for navigation links with data-route attribute.
+   *
+   * Event delegation is attached to `document` (not `$target`) so that
+   * `[data-route]` links anywhere in the page — including outside the router's
+   * target container — can trigger navigation. This is intentional: nav links
+   * typically live in headers or sidebars, not inside the routed content area.
+   *
+   * Active-link management uses a reactive effect that re-runs only when
+   * `currentRoute` changes — more efficient than a persistent MutationObserver.
+   */
+  setupAutoBindLinks() {
+    if (!this.config.autoBindLinks) return;
+    const t = (i) => {
+      i.preventDefault();
+      const r = i.currentTarget.dataset.route;
+      r != null && this.navigate(r);
     };
-    for (const N of document.querySelectorAll("[data-route]"))
-      d(N);
-    const _ = (N) => {
-      for (const F of I) {
-        const mt = F.dataset.route, lt = N === mt;
-        F.classList.toggle(a, lt), lt ? F.setAttribute("aria-current", "page") : F.removeAttribute("aria-current");
-      }
-    }, m = J(() => {
-      _(h.value);
+    c(document).on("click", "[data-route]", t), this.cleanups.push(() => {
+      c(document).off("click", "[data-route]", t);
     });
-    A.push(() => m.dispose());
-    const v = new MutationObserver((N) => {
-      let F = !1;
-      for (const mt of N)
-        mt.type === "childList" && mt.addedNodes.forEach((lt) => {
-          if (lt.nodeType === 1) {
-            const yt = lt;
-            yt.matches?.("[data-route]") && (d(yt), F = !0), yt.querySelectorAll && yt.querySelectorAll("[data-route]").forEach((Oe) => {
-              d(Oe), F = !0;
-            });
-          }
-        });
-      F && _(h.value);
+    const { activeClass: s } = this.config, n = X(() => {
+      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");
+        }
+      });
     });
-    v.observe(document.body, { childList: !0, subtree: !0 }), A.push(() => v.disconnect());
-  }, O = () => {
-    y || (y = !0, A.forEach((u) => u()), A.length = 0, I.forEach((u) => {
-      u.classList.remove("_aes-bound"), b.cleanup(u);
-    }), I.clear());
-  }, gt = S ? "popstate" : "hashchange";
-  window.addEventListener(gt, j), A.push(() => window.removeEventListener(gt, j));
-  const G = J(() => {
-    g(h.value);
-  });
-  return A.push(() => G.dispose()), tt(), C[0] && b.trackCleanup(C[0], O), {
-    currentRoute: h,
-    queryParams: Gt(() => U.value),
-    navigate: T,
-    destroy: O
-  };
-}
-l.extend({
-  route: hn
-});
-function fn(e, t) {
-  const { defaultValue: n, transform: s, method: i, headers: o, ajaxOptions: r } = t, c = typeof e == "function" ? e : () => e;
-  return Gt(
-    async () => {
-      const a = c(), f = await l.ajax({ ...r, url: a, method: i, headers: o });
-      return s ? s(f) : f;
-    },
-    { defaultValue: n, lazy: !1 }
-  );
-}
-l.extend({ atomFetch: fn });
-const Nt = /* @__PURE__ */ new WeakMap();
-let oe = !1;
-const re = (e) => {
-  let t = Nt.get(e);
-  return t || (t = function(...n) {
-    return Kt(() => e.apply(this, n));
-  }, Nt.set(e, t)), t;
-};
-function dn() {
-  if (oe) return;
-  oe = !0;
-  const e = l.fn.on, t = l.fn.off, n = l.fn.remove, s = l.fn.empty, i = l.fn.detach;
-  l.fn.remove = function(o) {
-    const r = o ? this.filter(o) : this;
-    for (let c = 0, a = r.length; c < a; c++) {
-      const f = r[c];
-      f && (b.cleanupTree(f), b.markIgnored(f));
-    }
-    return n.call(this, o);
-  }, l.fn.empty = function() {
-    for (let o = 0, r = this.length; o < r; o++) {
-      const c = this[o];
-      c && b.cleanupDescendants(c);
-    }
-    return s.call(this);
-  }, l.fn.detach = function(o) {
-    const r = o ? this.filter(o) : this;
-    for (let c = 0, a = r.length; c < a; c++) {
-      const f = r[c];
-      f && b.keep(f);
+    this.cleanups.push(() => n.dispose());
+  }
+  /**
+   * Navigates to the specified route programmatically.
+   *
+   * If `routeName` resolves to an empty string after falling back to
+   * `config.default`, `setUrl` will be called with an empty string, producing
+   * a URL of `${basePath}/` in history mode. Callers should ensure
+   * `config.default` is always a non-empty route name.
+   */
+  navigate(t) {
+    if (this.isDestroyed) return;
+    const s = this.currentRouteAtom.peek(), n = this.config.routes[s];
+    if (n?.onLeave && n.onLeave() === !1)
+      return;
+    const i = t || this.config.default;
+    if (!i) {
+      f.warn(
+        d.ROUTE,
+        "navigate() called with empty routeName and no default configured."
+      );
+      return;
     }
-    return i.call(this, o);
-  }, l.fn.on = function(...o) {
-    const r = o[0];
-    if (r && typeof r == "object") {
-      const c = r, a = {};
-      for (const f in c) {
-        const p = c[f];
-        p && (a[f] = re(p));
-      }
-      o[0] = a;
-    } else
-      for (let c = o.length - 1; c >= 0; c--)
-        if (typeof o[c] == "function") {
-          o[c] = re(o[c]);
-          break;
-        }
-    return e.apply(this, o);
-  }, l.fn.off = function(...o) {
-    const r = o[0];
-    if (r && typeof r == "object") {
-      const c = r, a = {};
-      for (const f in c) {
-        const p = c[f];
-        p && (a[f] = Nt.get(p) || p);
+    this.setUrl(i), this.queryParamsAtom.value = {}, this.currentRouteAtom.value = i;
+  }
+  /**
+   * Cleans up all event listeners and effects, and releases the template cache.
+   * Each cleanup function is called in a try/catch so that a single failing
+   * cleanup does not prevent the remaining ones from running.
+   */
+  destroy() {
+    this.isDestroyed || (this.isDestroyed = !0, this.cleanups.forEach((t) => {
+      try {
+        t();
+      } catch (s) {
+        f.warn(d.ROUTE, "Cleanup error during destroy:", s);
       }
-      o[0] = a;
-    } else
-      for (let c = o.length - 1; c >= 0; c--)
-        if (typeof o[c] == "function") {
-          o[c] = Nt.get(o[c]) || o[c];
-          break;
-        }
-    return t.apply(this, o);
-  };
+    }), this.cleanups.length = 0, this.templateCache.clear());
+  }
+}
+function $s(e) {
+  return new Ms(e);
 }
-l(() => {
-  dn(), rn(document.body);
+c.extend({
+  route: $s
+});
+const Fs = new Promise(() => {
+});
+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();
+        try {
+          const G = await U;
+          return n ? n(G) : G;
+        } catch (G) {
+          if (m.aborted)
+            return Fs;
+          try {
+            l?.(G);
+          } catch {
+          }
+          throw G;
+        } finally {
+          m.onabort = null, E.signal === m && (E = null);
+        }
+      },
+      { defaultValue: s, lazy: !(p ?? !0) }
+    );
+  }
+});
+c(() => {
+  Ns(), Rs(document.body);
 });
 export {
-  jt as atom,
-  Kt as batch,
-  Gt as computed,
-  mn as default,
-  En as disableAutoCleanup,
-  J as effect,
-  rn as enableAutoCleanup,
-  dn as enablejQueryOverrides,
-  b as registry,
-  Me as untracked
+  Ft as atom,
+  ye as batch,
+  Ct as computed,
+  qs 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
 };
 //# sourceMappingURL=index.mjs.map