@but212/atom-effect-jquery 0.22.2 → 0.23.0

package/dist/index.mjs

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