@but212/atom-effect-jquery 0.22.2 → 0.24.0

package/dist/index.mjs

@@ -1,2053 +1,2352 @@
-import l from "jquery";
-import { default as Ys } from "jquery";
-const ut = {
-  IDLE: "idle",
-  PENDING: "pending",
-  RESOLVED: "resolved",
-  REJECTED: "rejected"
-}, k = {
-  DISPOSED: 1,
-  EXECUTING: 8
-}, ue = {
-  DISPOSED: 1,
-  /** Marker bit: identifies this node as a computed. */
-  IS_COMPUTED: 2,
-  DIRTY: 8,
-  IDLE: 16,
-  PENDING: 32,
-  RESOLVED: 64,
-  REJECTED: 128,
-  RECOMPUTING: 256,
-  HAS_ERROR: 512
-}, M = {
-  DISPOSED: 1,
-  SYNC: 8,
-  NOTIFICATION_SCHEDULED: 16
-}, q = {
-  // Infinite loop protection
-  MAX_EXECUTIONS_PER_SECOND: 1e3,
-  MAX_EXECUTIONS_PER_EFFECT: 100,
-  // Batch processing limits to prevent blocking the main thread for too long
-  MAX_EXECUTIONS_PER_FLUSH: 1e4,
-  MAX_FLUSH_ITERATIONS: 1e3,
-  MIN_FLUSH_ITERATIONS: 10,
-  // Memory management
-  BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, ke = {
-  WARN_INFINITE_LOOP: !0
-}, Zt = {
-  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";
-  }
-}
-class j extends et {
-  constructor(t, e = null) {
-    super(t, e, !0), this.name = "ComputedError";
-  }
-}
-class Z extends et {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "EffectError";
-  }
-}
-class Lt extends et {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "SchedulerError";
-  }
-}
-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]
+import e from "jquery";
+//#region ../core/dist/index.mjs
+var t = {
+	IDLE: "idle",
+	PENDING: "pending",
+	RESOLVED: "resolved",
+	REJECTED: "rejected"
+}, n = {
+	DISPOSED: 1,
+	EXECUTING: 8
+}, r = {
+	DISPOSED: 1,
+	IS_COMPUTED: 2,
+	DIRTY: 8,
+	IDLE: 16,
+	PENDING: 32,
+	RESOLVED: 64,
+	REJECTED: 128,
+	RECOMPUTING: 256,
+	HAS_ERROR: 512,
+	FORCE_COMPUTE: 1024
+}, i = {
+	DISPOSED: 1,
+	SYNC: 8,
+	NOTIFICATION_SCHEDULED: 16
+}, a = {
+	MAX_EXECUTIONS_PER_SECOND: 1e3,
+	MAX_EXECUTIONS_PER_EFFECT: 100,
+	MAX_EXECUTIONS_PER_FLUSH: 1e4,
+	MAX_FLUSH_ITERATIONS: 1e3,
+	MIN_FLUSH_ITERATIONS: 10,
+	BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
+}, o = {
+	WARN_INFINITE_LOOP: !0,
+	EFFECT_FREQUENCY_WINDOW: 1e3
+}, s = {
+	MAX_ASYNC_RETRIES: 3,
+	MAX_PROMISE_ID: 2 ** 53 - 1 - 1
+}, c = {
+	UNINITIALIZED: -1,
+	MIN: 1
+}, l = 1073741823, u = { VERSION_BITS: 16 };
+typeof process < "u" && process.env;
+var d = Object.freeze([]), f = class {
+	constructor(e, t, n = void 0) {
+		this.node = e, this.version = t, this.unsub = n;
+	}
+}, p = class {
+	constructor(e, t) {
+		this.fn = e, this.sub = t;
+	}
+	notify(e, t) {
+		this.fn ? this.fn(e, t) : this.sub && this.sub.execute();
+	}
+}, m = class extends Error {
+	constructor(e, t = null, n = !0) {
+		super(e), this.cause = t, this.recoverable = n, this.name = "AtomError";
+	}
+}, h = class extends m {
+	constructor(e, t = null) {
+		super(e, t, !0), this.name = "ComputedError";
+	}
+}, g = class extends m {
+	constructor(e, t = null) {
+		super(e, t, !1), this.name = "EffectError";
+	}
+}, _ = class extends m {
+	constructor(e, t = null) {
+		super(e, t, !1), this.name = "SchedulerError";
+	}
+}, v = {
+	COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
+	COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
+	COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
+	COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
+	COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
+	COMPUTED_DISPOSED: "Attempted to access disposed computed",
+	ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
+	ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
+	EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
+	EFFECT_EXECUTION_FAILED: "Effect execution failed",
+	EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
+	EFFECT_DISPOSED: "Attempted to run disposed effect",
+	SCHEDULER_FLUSH_OVERFLOW: (e, t) => `Maximum flush iterations (${e}) exceeded. ${t} jobs dropped. Possible infinite loop.`,
+	CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
+	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.",
+	BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
+}, y = class {
+	constructor() {
+		this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._epoch = c.UNINITIALIZED, this._overflow = null;
+	}
+	get size() {
+		return this._count;
+	}
+	getAt(e) {
+		if (e === 0) return this._s0;
+		if (e === 1) return this._s1;
+		if (e === 2) return this._s2;
+		if (e === 3) return this._s3;
+		let t = this._overflow;
+		if (t !== null && e >= 4) {
+			let n = e - 4;
+			if (n < t.length) return t[n] || null;
+		}
+		return null;
+	}
+	setAt(e, t) {
+		if (e === 0) this._s0 = t;
+		else if (e === 1) this._s1 = t;
+		else if (e === 2) this._s2 = t;
+		else if (e === 3) this._s3 = t;
+		else {
+			this._overflow ??= [];
+			let n = this._overflow;
+			n[e - 4] = t;
+		}
+		e >= this._count && (this._count = e + 1);
+	}
+	truncateFrom(e) {
+		let t = this._count;
+		if (e >= t) return;
+		if (e <= 0) {
+			let e = this._s0;
+			e != null && (this._onItemRemoved(e), this._s0 = null);
+		}
+		if (e <= 1) {
+			let e = this._s1;
+			e != null && (this._onItemRemoved(e), this._s1 = null);
+		}
+		if (e <= 2) {
+			let e = this._s2;
+			e != null && (this._onItemRemoved(e), this._s2 = null);
+		}
+		if (e <= 3) {
+			let e = this._s3;
+			e != null && (this._onItemRemoved(e), this._s3 = null);
+		}
+		let n = this._overflow;
+		if (n !== null && t > 4) {
+			let t = e > 4 ? e - 4 : 0, r = n.length;
+			for (let e = t; e < r; e++) {
+				let t = n[e];
+				t != null && (this._onItemRemoved(t), n[e] = null);
+			}
+			e <= 4 ? (n.length = 0, this._overflow = null) : n.length = e - 4;
+		}
+		this._count = e;
+	}
+	_onItemRemoved(e) {}
+	add(e) {
+		if (this._s0 === null) {
+			this._s0 = e, this._count++;
+			return;
+		}
+		if (this._s1 === null) {
+			this._s1 = e, this._count++;
+			return;
+		}
+		if (this._s2 === null) {
+			this._s2 = e, this._count++;
+			return;
+		}
+		if (this._s3 === null) {
+			this._s3 = e, this._count++;
+			return;
+		}
+		if (this._overflow === null) this._overflow = [e];
+		else {
+			let t = this._overflow;
+			for (let n = 0, r = t.length; n < r; n++) if (t[n] === null) {
+				t[n] = e, this._count++;
+				return;
+			}
+			t.push(e);
+		}
+		this._count++;
+	}
+	remove(e) {
+		if (this._s0 === e) return this._s0 = null, this._count--, !0;
+		if (this._s1 === e) return this._s1 = null, this._count--, !0;
+		if (this._s2 === e) return this._s2 = null, this._count--, !0;
+		if (this._s3 === e) return this._s3 = null, this._count--, !0;
+		let t = this._overflow;
+		if (t == null) return !1;
+		for (let n = 0, r = t.length; n < r; n++) if (t[n] === e) return t[n] = null, this._count--, !0;
+		return !1;
+	}
+	has(e) {
+		let t = this._count;
+		if (t === 0) return !1;
+		if (this._s0 === e || this._s1 === e || this._s2 === e || this._s3 === e) return !0;
+		if (t <= 4) return !1;
+		let n = this._overflow;
+		if (n != null) {
+			let r = 0;
+			this._s0 != null && r++, this._s1 != null && r++, this._s2 != null && r++, this._s3 != null && r++;
+			for (let i = 0, a = n.length; i < a; i++) {
+				let a = n[i];
+				if (a != null) {
+					if (a === e) return !0;
+					if (++r === t) break;
+				}
+			}
+		}
+		return !1;
+	}
+	forEach(e) {
+		let t = this._count;
+		if (t === 0) return;
+		let n = this._s0;
+		n != null && e(n);
+		let r = this._s1;
+		r != null && e(r);
+		let i = this._s2;
+		i != null && e(i);
+		let a = this._s3;
+		if (a != null && e(a), t <= 4) return;
+		let o = this._overflow;
+		if (o != null) {
+			let s = 0;
+			n != null && s++, r != null && s++, i != null && s++, a != null && s++;
+			for (let n = 0, r = o.length; n < r; n++) {
+				let r = o[n];
+				if (r != null && (e(r), ++s === t)) return;
+			}
+		}
+	}
+	forEachIndexed(e) {
+		let t = this._count;
+		if (t === 0) return 0;
+		let n = 0, r = this._s0;
+		r != null && (e(r), n++);
+		let i = this._s1;
+		i != null && (e(i), n++);
+		let a = this._s2;
+		a != null && (e(a), n++);
+		let o = this._s3;
+		if (o != null && (e(o), n++), t <= 4 || n === t) return n;
+		let s = this._overflow;
+		if (s != null) for (let r = 0, i = s.length; r < i; r++) {
+			let i = s[r];
+			if (i != null && (e(i), ++n === t)) break;
+		}
+		return n;
+	}
+	compact() {
+		let e = this._overflow;
+		if (e === null || e.length === 0) return;
+		let t = 0;
+		for (; t < e.length;) if (e[t] === null) {
+			let n = e.pop();
+			t < e.length && n != null && (e[t] = n);
+		} else t++;
+		e.length === 0 && (this._overflow = null);
+	}
+	clear() {
+		this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._overflow !== null && (this._overflow.length = 0, this._overflow = null);
+	}
+	dispose() {
+		this.clear();
+	}
+}, b = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), x = /* @__PURE__ */ Symbol("AtomEffect.Type"), S = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), C = {
+	enabled: !1,
+	warnInfiniteLoop: o.WARN_INFINITE_LOOP,
+	warn(e, t) {},
+	attachDebugInfo(e, t, n) {},
+	getDebugName: (e) => e?.[b],
+	getDebugType: (e) => e?.[x]
+}, w = 1, ee = () => w++;
+function T(e, t, n) {
+	if (e instanceof m) return e;
+	let r = e instanceof Error, i = r ? e.message : String(e), a = r ? e : void 0;
+	return new t(`${r ? e.constructor.name : "Unexpected error"} (${n}): ${i}`, a);
+}
+var te = class {
+	constructor() {
+		this.flags = 0, this.version = 0, this._lastSeenEpoch = c.UNINITIALIZED, this.id = ee() & l, this._slots = null, this._notifying = 0, this._deps = null, this._hotIndex = -1;
+	}
+	subscribe(e) {
+		let t = typeof e == "function";
+		if (!t && (!e || typeof e.execute != "function")) throw T(/* @__PURE__ */ TypeError("Invalid subscriber"), m, v.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+		let n = this._slots;
+		n || (n = new y(), this._slots = n);
+		let r = !1;
+		if (n.forEach((n) => {
+			(t ? n.fn === e : n.sub === e) && (r = !0);
+		}), r) return () => {};
+		let i = new p(t ? e : void 0, t ? void 0 : e);
+		return n.add(i), () => this._unsubscribe(i);
+	}
+	_unsubscribe(e) {
+		if (this._slots) {
+			if (this._notifying > 0) {
+				this._slots.remove(e);
+				return;
+			}
+			this._slots.remove(e), this._slots.compact();
+		}
+	}
+	subscriberCount() {
+		return this._slots ? this._slots.size : 0;
+	}
+	_notifySubscribers(e, t) {
+		let n = this._slots;
+		if (!(!n || n.size === 0)) {
+			this._notifying++;
+			try {
+				n.forEach((n) => {
+					try {
+						n.notify(e, t);
+					} catch (e) {
+						console.error(T(e, m, v.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+					}
+				});
+			} finally {
+				this._notifying--, this._notifying === 0 && n.compact();
+			}
+		}
+	}
+	_isDirty() {
+		let e = this._deps;
+		if (!e || e.size === 0) return !1;
+		if (this._hotIndex !== -1) {
+			let t = e.getAt(this._hotIndex);
+			if (t != null && t.node.version !== t.version) return !0;
+		}
+		return !e.hasComputeds && !e.isDirtyFast() ? !1 : this._deepDirtyCheck();
+	}
+}, ne = 0, re = () => (ne = ne + 1 & 1073741823 || 1, ne), ie = (e) => e + 1 & l, ae = 0, oe = !1, se = 0, ce = () => se;
+function le() {
+	return oe ? !1 : (oe = !0, se = re(), ae = 0, !0);
+}
+var ue = () => {
+	oe = !1;
+}, de = () => oe ? ++ae : 0, fe = /* @__PURE__ */ (function(e) {
+	return e[e.IDLE = 0] = "IDLE", e[e.BATCHING = 1] = "BATCHING", e[e.FLUSHING = 2] = "FLUSHING", e;
+})({}), E = new class {
+	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 = a.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
+	}
+	get phase() {
+		return this._isProcessing || this._isFlushingSync ? fe.FLUSHING : this._isBatching ? fe.BATCHING : fe.IDLE;
+	}
+	get queueSize() {
+		return this._size;
+	}
+	get isBatching() {
+		return this._isBatching;
+	}
+	schedule(e) {
+		if (e._nextEpoch !== this._epoch) {
+			if (e._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
+				this._batchQueue[this._batchQueueSize++] = e;
+				return;
+			}
+			this._queueBuffer[this._bufferIndex][this._size++] = e, this._isProcessing || this._flush();
+		}
+	}
+	_flush() {
+		this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
+	}
+	_runLoop() {
+		try {
+			if (this._size === 0) return;
+			let e = le();
+			this._drainQueue(), e && ue();
+		} finally {
+			this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
+		}
+	}
+	_flushSync() {
+		this._isFlushingSync = !0;
+		let e = le();
+		try {
+			this._mergeBatchQueue(), this._drainQueue();
+		} finally {
+			this._isFlushingSync = !1, e && ue();
+		}
+	}
+	_mergeBatchQueue() {
+		if (this._batchQueueSize === 0) return;
+		let e = ++this._epoch, t = this._batchQueue, n = this._queueBuffer[this._bufferIndex], r = this._size;
+		t.slice(0, this._batchQueueSize).forEach((t) => {
+			t._nextEpoch !== e && (t._nextEpoch = e, n[r++] = t);
+		}), this._size = r, this._batchQueueSize = 0, t.length > a.BATCH_QUEUE_SHRINK_THRESHOLD && (t.length = 0);
+	}
+	_drainQueue() {
+		let e = 0;
+		for (; this._size > 0;) {
+			if (++e > this._maxFlushIterations) {
+				this._handleFlushOverflow();
+				return;
+			}
+			this._processQueue(), this._mergeBatchQueue();
+		}
+	}
+	_processQueue() {
+		let e = this._bufferIndex, t = this._queueBuffer[e], n = this._size;
+		this._bufferIndex = e ^ 1, this._size = 0, this._epoch++;
+		for (let e = 0; e < n; e++) try {
+			let n = t[e];
+			typeof n == "function" ? n() : n.execute();
+		} catch (e) {
+			console.error(new _("Error occurred during scheduler execution", e));
+		}
+		t.length = 0;
+	}
+	_handleFlushOverflow() {
+		let e = this._size + this._batchQueueSize;
+		if (console.error(new _(v.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, e))), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow) try {
+			this.onOverflow(e);
+		} catch {}
+	}
+	startBatch() {
+		this._batchDepth++, this._isBatching = !0;
+	}
+	endBatch() {
+		this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
+	}
+	setMaxFlushIterations(e) {
+		if (e < a.MIN_FLUSH_ITERATIONS) throw new _(`Max flush iterations must be at least ${a.MIN_FLUSH_ITERATIONS}`);
+		this._maxFlushIterations = e;
+	}
+}(), pe = /* @__PURE__ */ Symbol.for("atom-effect/atom"), me = /* @__PURE__ */ Symbol.for("atom-effect/computed"), he = /* @__PURE__ */ Symbol.for("atom-effect/effect"), ge = /* @__PURE__ */ Symbol.for("atom-effect/writable"), D = {
+	current: null,
+	run(e, t) {
+		let n = this.current;
+		this.current = e;
+		try {
+			return t();
+		} finally {
+			this.current = n;
+		}
+	}
 };
-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;
-  }
-  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 $t {
-  constructor(t, e, n = void 0) {
-    this.node = t, this.version = e, this.unsub = n;
-  }
-}
-class Mt {
-  constructor(t, e) {
-    this.fn = t, this.sub = e;
-  }
-}
-const b = {
-  // Computed Errors
-  COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
-  COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
-  COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
-  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
-  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
-  COMPUTED_DISPOSED: "Attempted to access disposed computed",
-  // Atom Errors
-  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
-  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
-  // Effect Errors
-  EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
-  EFFECT_EXECUTION_FAILED: "Effect execution failed",
-  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.`,
-  // 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."
+function O(e) {
+	let t = D.current;
+	if (t === null) return e();
+	D.current = null;
+	try {
+		return e();
+	} finally {
+		D.current = t;
+	}
+}
+var _e = class extends te {
+	constructor(e, t) {
+		super(), this._pendingOldValue = void 0, this[pe] = !0, this[ge] = !0, this._value = e, t && (this.flags |= i.SYNC), C.attachDebugInfo(this, "atom", this.id);
+	}
+	get value() {
+		return D.current?.addDependency(this), this._value;
+	}
+	set value(e) {
+		let t = this._value;
+		if (Object.is(t, e)) return;
+		this._value = e, this.version = ie(this.version);
+		let n = this._slots, r = this.flags;
+		if (n == null || n.size === 0 || r & i.NOTIFICATION_SCHEDULED) return;
+		this._pendingOldValue = t;
+		let a = r | i.NOTIFICATION_SCHEDULED;
+		if (this.flags = a, (a & i.SYNC) !== 0 && !E.isBatching) {
+			this._flushNotifications();
+			return;
+		}
+		E.schedule(this);
+	}
+	execute() {
+		this._flushNotifications();
+	}
+	_flushNotifications() {
+		let e = this.flags;
+		if (!(e & i.NOTIFICATION_SCHEDULED) || e & i.DISPOSED) return;
+		let t = this._pendingOldValue;
+		this._pendingOldValue = void 0, this.flags &= ~i.NOTIFICATION_SCHEDULED, this._notifySubscribers(this._value, t);
+	}
+	peek() {
+		return this._value;
+	}
+	dispose() {
+		this.flags & i.DISPOSED || (this._slots?.clear(), this.flags |= i.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+	}
+	_deepDirtyCheck() {
+		return !1;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
 };
-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}`;
-  return new t(r, o);
-}
-class de {
-  constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = Be() & yt;
-  }
-}
-class _e extends de {
-  /**
-   * Adds subscriber.
-   */
-  subscribe(t) {
-    const e = typeof t == "function";
-    if (!e && (!t || typeof t.execute != "function"))
-      throw tt(
-        new TypeError("Invalid subscriber"),
-        et,
-        b.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
-      );
-    if (this._subscribers.some((i) => i ? e ? i.fn === t : i.sub === t : !1))
-      return () => {
-      };
-    const n = new Mt(
-      e ? t : void 0,
-      e ? void 0 : t
-    );
-    return this._subscribers.push(n), () => this._unsubscribe(n);
-  }
-  _unsubscribe(t) {
-    const e = this._subscribers, n = e.indexOf(t);
-    if (n === -1) return;
-    const i = e.pop();
-    n < e.length && i && (e[n] = i);
-  }
-  subscriberCount() {
-    return this._subscribers.length;
-  }
-  _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);
-        }
-    });
-  }
-  _handleNotifyError(t) {
-    console.error(tt(t, et, 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);
-}
-const se = () => {
-  gt = !1;
-}, He = () => gt ? ++jt : 0;
-class Ge {
-  constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = q.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
-  }
-  get phase() {
-    return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
-  }
-  get queueSize() {
-    return this._size;
-  }
-  get isBatching() {
-    return this._isBatching;
-  }
-  /**
-   * Schedules job.
-   */
-  schedule(t) {
-    if (t._nextEpoch !== this._epoch) {
-      if (t._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
-        this._batchQueue[this._batchQueueSize++] = t;
-        return;
-      }
-      this._queueBuffer[this._bufferIndex][this._size++] = t, this._isProcessing || this._flush();
-    }
-  }
-  /**
-   * Triggers flush.
-   */
-  _flush() {
-    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
-  }
-  /**
-   * Scheduler loop.
-   */
-  _runLoop() {
-    try {
-      if (this._size === 0) return;
-      const t = ee();
-      this._drainQueue(), t && se();
-    } finally {
-      this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
-    }
-  }
-  _flushSync() {
-    this._isFlushingSync = !0;
-    const t = ee();
-    try {
-      this._mergeBatchQueue(), this._drainQueue();
-    } finally {
-      this._isFlushingSync = !1, t && se();
-    }
-  }
-  _mergeBatchQueue() {
-    if (this._batchQueueSize === 0) return;
-    const t = ++this._epoch, e = this._batchQueue, n = 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);
-  }
-  _drainQueue() {
-    let t = 0;
-    for (; this._size > 0; ) {
-      if (++t > this._maxFlushIterations) {
-        this._handleFlushOverflow();
-        return;
-      }
-      this._processQueue(), this._mergeBatchQueue();
-    }
-  }
-  _processQueue() {
-    const t = this._bufferIndex, e = this._queueBuffer[t], n = this._size;
-    this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
-    for (let i = 0; i < n; i++)
-      try {
-        e[i]();
-      } catch (o) {
-        console.error(new Lt("Error occurred during scheduler execution", o));
-      }
-    e.length = 0;
-  }
-  _handleFlushOverflow() {
-    const t = this._size + this._batchQueueSize;
-    if (console.error(
-      new Lt(
-        b.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
-      )
-    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
-      try {
-        this.onOverflow(t);
-      } catch {
-      }
-  }
-  startBatch() {
-    this._batchDepth++, this._isBatching = !0;
-  }
-  endBatch() {
-    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}`
-      );
-    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 = {
-  /** Active listener. */
-  current: null,
-  /**
-   * Executes in context.
-   *
-   * @param listener - The subscriber.
-   * @param fn - The logic to execute.
-   * @returns The result of `fn`.
-   */
-  run(s, t) {
-    const e = this.current;
-    this.current = s;
-    try {
-      return t();
-    } finally {
-      this.current = e;
-    }
-  }
+function ve(e, t = {}) {
+	return new _e(e, t.sync ?? !1);
+}
+var ye = class extends y {
+	constructor() {
+		super(), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1, this._depsHash = 0, this._map = null, this.hasComputeds = !1, this._depsHash = 0;
+	}
+	prepareTracking() {
+		this.hasComputeds = !1;
+	}
+	_onItemRemoved(e) {
+		let t = e.unsub;
+		t && t();
+	}
+	claimExisting(e, t) {
+		let n = this._count;
+		if (t >= n) return !1;
+		let r = n - t;
+		if (this._map !== null || r > this._SCAN_THRESHOLD) return this._claimViaMap(e, t);
+		if (t < 4) {
+			if (t <= 0) {
+				let t = this._s0;
+				if (t && t.node === e && t.unsub) return t.version = e.version, !0;
+			}
+			if (t <= 1 && n > 1) {
+				let n = this._s1;
+				if (n && n.node === e && n.unsub) return n.version = e.version, t !== 1 && (this._s1 = this._s0, this._s0 = n), !0;
+			}
+			if (t <= 2 && n > 2) {
+				let n = this._s2;
+				if (n && n.node === e && n.unsub) return n.version = e.version, t !== 2 && this._swapInline(2, t, n), !0;
+			}
+			if (t <= 3 && n > 3) {
+				let n = this._s3;
+				if (n && n.node === e && n.unsub) return n.version = e.version, t !== 3 && this._swapInline(3, t, n), !0;
+			}
+		}
+		let i = t > 4 ? t : 4, a = this._overflow;
+		if (a) for (let n = i - 4, r = a.length; n < r; n++) {
+			let r = a[n];
+			if (r && r.node === e && r.unsub) return r.version = e.version, this._swapGeneral(n + 4, t, r), !0;
+		}
+		return !1;
+	}
+	_claimViaMap(e, t) {
+		if (this._map === null) {
+			this._map = /* @__PURE__ */ new Map();
+			let e = this._count;
+			for (let n = t; n < e; n++) {
+				let e = this.getAt(n);
+				e?.unsub && this._map.set(e.node, n);
+			}
+		}
+		let n = this._map.get(e);
+		if (n === void 0 || n < t) return !1;
+		let r = this.getAt(n);
+		if (r == null || !r.unsub) return !1;
+		if (r.version = e.version, n !== t) {
+			let i = this.getAt(t);
+			this.setAt(t, r), this.setAt(n, i), i?.unsub && this._map.set(i.node, n), this._map.set(e, t);
+		}
+		return !0;
+	}
+	_swapInline(e, t, n) {
+		let r = this.getAt(t);
+		this.setAt(t, n), this.setAt(e, r);
+	}
+	_swapGeneral(e, t, n) {
+		if (e === t) return;
+		let r = this.getAt(t);
+		this.setAt(t, n), this.setAt(e, r);
+	}
+	insertNew(e, t) {
+		let n = this._count;
+		if (e < n) {
+			let t = this.getAt(e);
+			t != null && (this.add(t), this._map !== null && t.unsub && this._map.set(t.node, this._count - 1));
+		}
+		e === 0 ? this._s0 = t : e === 1 ? this._s1 = t : e === 2 ? this._s2 = t : e === 3 ? this._s3 = t : this.setAt(e, t), e >= n && (this._count = e + 1);
+	}
+	truncateFrom(e) {
+		e >= this._count || (super.truncateFrom(e), this._map !== null && (this._map.clear(), this._map = null));
+	}
+	seal() {
+		let e = this._count;
+		if (e <= 0) {
+			this._depsHash = 0;
+			return;
+		}
+		let t = 0, n = u.VERSION_BITS, r = this._s0;
+		if (r && (t = t + (r.version << n) + r.node.id | 0), e > 1) {
+			let e = this._s1;
+			e && (t = t + (e.version << n) + e.node.id | 0);
+		}
+		if (e > 2) {
+			let e = this._s2;
+			e && (t = t + (e.version << n) + e.node.id | 0);
+		}
+		if (e > 3) {
+			let e = this._s3;
+			e && (t = t + (e.version << n) + e.node.id | 0);
+			let r = this._overflow;
+			if (r) for (let e = 0, i = r.length; e < i; e++) {
+				let i = r[e];
+				i && (t = t + (i.version << n) + i.node.id | 0);
+			}
+		}
+		this._depsHash = t;
+	}
+	isDirtyFast() {
+		let e = this._count;
+		if (e <= 0) return !1;
+		let t = 0, n = u.VERSION_BITS, r = this._s0;
+		if (r) {
+			let e = r.node;
+			t = t + (e.version << n) + e.id | 0;
+		}
+		if (e > 1) {
+			let e = this._s1;
+			if (e) {
+				let r = e.node;
+				t = t + (r.version << n) + r.id | 0;
+			}
+		}
+		if (e > 2) {
+			let e = this._s2;
+			if (e) {
+				let r = e.node;
+				t = t + (r.version << n) + r.id | 0;
+			}
+		}
+		if (e > 3) {
+			let e = this._s3;
+			if (e) {
+				let r = e.node;
+				t = t + (r.version << n) + r.id | 0;
+			}
+			let r = this._overflow;
+			if (r) for (let e = 0, i = r.length; e < i; e++) {
+				let i = r[e];
+				if (i) {
+					let e = i.node;
+					t = t + (e.version << n) + e.id | 0;
+				}
+			}
+		}
+		return t !== this._depsHash;
+	}
+	captureVersionSnapshot() {
+		let e = this._count;
+		if (e <= 0) return 0;
+		let t = 0, n = this._s0;
+		if (n && (t = (t << 5) - t + n.node.version | 0), e > 1) {
+			let e = this._s1;
+			e && (t = (t << 5) - t + e.node.version | 0);
+		}
+		if (e > 2) {
+			let e = this._s2;
+			e && (t = (t << 5) - t + e.node.version | 0);
+		}
+		if (e > 3) {
+			let e = this._s3;
+			e && (t = (t << 5) - t + e.node.version | 0);
+			let n = this._overflow;
+			if (n) for (let e = 0, r = n.length; e < r; e++) {
+				let r = n[e];
+				r && (t = (t << 5) - t + r.node.version | 0);
+			}
+		}
+		return t;
+	}
+	disposeAll() {
+		this._count > 0 && this.truncateFrom(0), this.hasComputeds = !1, this._map !== null && (this._map.clear(), this._map = null);
+	}
+	remove(e) {
+		throw Error("remove() is strictly prohibited in DepSlotBuffer to preserve sequential cache paths.");
+	}
+	compact() {}
 };
-function H(s) {
-  const t = P.current;
-  if (t === null) return s();
-  P.current = null;
-  try {
-    return s();
-  } finally {
-    P.current = t;
-  }
-}
-var ne;
-class je extends _e {
-  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);
-  }
-  get value() {
-    const t = P.current;
-    return t && fe(this, t, this._subscribers), 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._flushNotifications();
-        return;
-      }
-      ot.schedule(this._notifyTask);
-    }
-  }
-  /**
-   * Triggers subscribers.
-   */
-  _flushNotifications() {
-    const t = this.flags;
-    if (!(t & M.NOTIFICATION_SCHEDULED) || t & M.DISPOSED)
-      return;
-    const e = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
-  }
-  peek() {
-    return this._value;
-  }
-  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)]() {
-    this.dispose();
-  }
-}
-function Bt(s, t = {}) {
-  return new je(s, t.sync ?? !1);
-}
-class Ve {
-  /**
-   * @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 ? {
-      acquired: 0,
-      released: 0,
-      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
-    } : null;
-  }
-  /**
-   * Acquires array.
-   */
-  acquire() {
-    return this.stats && this.stats.acquired++, this.pool.pop() ?? [];
-  }
-  /**
-   * Releases array.
-   *
-   * @param arr - Array to release.
-   * @param emptyConst - Optional empty constant.
-   */
-  release(t, e) {
-    if (!(e && t === e)) {
-      if (t.length > this.capacity) {
-        this.stats && this.stats.rejected.tooLarge++;
-        return;
-      }
-      if (this.pool.length >= this.limit) {
-        this.stats && this.stats.rejected.poolFull++;
-        return;
-      }
-      if (Object.isFrozen(t)) {
-        this.stats && this.stats.rejected.frozen++;
-        return;
-      }
-      t.length = 0, this.pool.push(t), this.stats && this.stats.released++;
-    }
-  }
-  /**
-   * Pool stats.
-   */
-  getStats() {
-    if (!this.stats) return null;
-    const { acquired: t, released: e, rejected: n } = this.stats, i = t - e - (n.frozen + n.tooLarge + n.poolFull);
-    return {
-      acquired: t,
-      released: e,
-      rejected: { ...n },
-      leaked: i,
-      poolSize: this.pool.length
-    };
-  }
-  /**
-   * Resets pool.
-   */
-  reset() {
-    this.pool.length = 0, this.stats && (this.stats = {
-      acquired: 0,
-      released: 0,
-      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
-    });
-  }
-}
-const A = Object.freeze(
-  []
-), B = new Ve();
-function qt(s) {
-  return s !== null && typeof s == "object" && Vt in s;
-}
-function qe(s) {
-  return s !== null && typeof s == "object" && ge in s;
-}
-function me(s) {
-  return s !== null && typeof s == "object" && typeof s.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;
-}
-class Ye extends _e {
-  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)
-      try {
-        this._recompute();
-      } catch {
-      }
-  }
-  _track() {
-    const t = P.current;
-    t && fe(this, t, this._subscribers);
-  }
-  get value() {
-    this._track();
-    const t = this.flags;
-    if ((t & (V | K | ft)) === V)
-      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 & (K | ft) && (this._recompute(), this.flags & V))
-      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);
-    }
-    if (this.flags & nt) {
-      if (n) return e;
-      throw this._error;
-    }
-    return this._value;
-  }
-  peek() {
-    return this._value;
-  }
-  get state() {
-    return this._track(), Qe(this.flags);
-  }
-  get hasError() {
-    return this._track(), this.flags & (nt | dt) ? !0 : this._links.some((t) => t?.node?.flags & dt);
-  }
-  get isValid() {
-    return !this.hasError;
-  }
-  get errors() {
-    if (this._track(), !this.hasError) return Pe;
-    const t = [];
-    return this._error && t.push(this._error), this._links.forEach((e) => {
-      const n = e.node;
-      n.flags & dt && n.errors.forEach((i) => {
-        i && !t.includes(i) && t.push(i);
-      });
-    }), Object.freeze(t);
-  }
-  get lastError() {
-    return this._track(), this._error;
-  }
-  get isPending() {
-    return this._track(), (this.flags & Et) !== 0;
-  }
-  get isResolved() {
-    return this._track(), (this.flags & V) !== 0;
-  }
-  invalidate() {
-    this._markDirty();
-  }
-  dispose() {
-    if (this.flags & kt) 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;
-  }
-  [(oe = Vt, ie = ge, 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++;
-    }
-  }
-  _recompute() {
-    if (this.flags & st) return;
-    this.flags |= st;
-    const t = this._links;
-    this._trackEpoch = zt(), this._trackLinks = B.acquire(), 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) {
-      if (!e)
-        try {
-          this._trackLinks.length = this._trackCount, te(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
-        } catch {
-        }
-      this._handleError(n, 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;
-    }
-  }
-  _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;
-    const e = this._promiseId;
-    t.then(
-      (n) => {
-        if (e === this._promiseId) {
-          if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
-            const i = pe();
-            return this._lastDriftEpoch !== i && (this._lastDriftEpoch = i, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new j(
-                `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
-              ),
-              b.COMPUTED_ASYNC_COMPUTATION_FAILED
-            );
-          }
-          this._finalizeResolution(n), this._notifySubscribers(n, void 0);
-        }
-      },
-      (n) => e === this._promiseId && this._handleError(n, 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;
-    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)
-      try {
-        this._onError(i);
-      } catch (o) {
-        console.error(b.CALLBACK_ERROR_IN_ERROR_HANDLER, o);
-      }
-    if (n) 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;
-  }
-  execute() {
-    this._markDirty();
-  }
-  /** @internal */
-  _markDirty() {
-    this.flags & (st | K) || (this.flags |= K, this._notifySubscribers(void 0, void 0));
-  }
-}
-function St(s, t = {}) {
-  return new Ye(s, t);
-}
-var re;
-class Ke extends de {
-  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);
-  }
-  run() {
-    if (this.flags & k.DISPOSED)
-      throw new Z(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);
-  }
-  [(re = ze, Symbol.dispose)]() {
-    this.dispose();
-  }
-  addDependency(t) {
-    if (!(this.flags & k.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;
-      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));
-    }
-  }
-  /**
-   * 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;
-    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;
-    } finally {
-      this._finalizeDependencies(n, this._prevLinks, e), this.flags &= -9;
-    }
-  }
-  _handleAsyncResult(t) {
-    const e = ++this._execId;
-    t.then(
-      (n) => {
-        if (e !== this._execId || this.flags & k.DISPOSED) {
-          if (typeof n == "function")
-            try {
-              n();
-            } catch (i) {
-              this._handleExecutionError(i, b.EFFECT_CLEANUP_FAILED);
-            }
-          return;
-        }
-        typeof n == "function" && (this._cleanup = n);
-      },
-      (n) => e === this._execId && this._handleExecutionError(n)
-    );
-  }
-  _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));
-  }
-  _unsubLinks(t) {
-    t.forEach((e) => e?.unsub?.());
-  }
-  _isDirty() {
-    const t = this._links, e = P.current;
-    P.current = null;
-    try {
-      return t.some((n) => {
-        const i = n.node;
-        if (i.flags & ue.IS_COMPUTED)
-          try {
-            i.value;
-          } catch {
-            return !0;
-          }
-        return i.version !== n.version;
-      });
-    } finally {
-      P.current = e;
-    }
-  }
-  _execCleanup() {
-    if (this._cleanup) {
-      try {
-        this._cleanup();
-      } catch (t) {
-        this._handleExecutionError(t, b.EFFECT_CLEANUP_FAILED);
-      }
-      this._cleanup = null;
-    }
-  }
-  _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++;
-  }
-  get isDisposed() {
-    return (this.flags & k.DISPOSED) !== 0;
-  }
-  get executionCount() {
-    return this._executionCount;
-  }
-  get isExecuting() {
-    return (this.flags & k.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}`
-    );
-    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)
-      try {
-        this._onError(n);
-      } catch (i) {
-        console.error(tt(i, Z, 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);
-  return e.execute(), e;
-}
-function Ie(s) {
-  if (typeof s != "function")
-    throw new TypeError("Batch callback must be a function");
-  ot.startBatch();
-  try {
-    return s();
-  } finally {
-    ot.endBatch();
-  }
-}
-const g = {
-  /** Used by the SPA router ($.route). */
-  ROUTE: "[atom-route]",
-  /** Used by all reactive binding helpers (bindText, bindCss, bindAttr, …). */
-  BINDING: "[atom-binding]",
-  /** Used by atomList reactive list rendering. */
-  LIST: "[atom-list]",
-  /** Used by mount/unmount lifecycle helpers. */
-  MOUNT: "[atom-mount]"
-}, _t = Object.freeze({
-  mode: "hash",
-  basePath: "",
-  autoBindLinks: !1,
-  activeClass: "active"
-}), We = {
-  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 k(e) {
+	return typeof e == "object" && !!e && pe in e;
+}
+function be(e) {
+	return typeof e == "object" && !!e && me in e;
+}
+function xe(e) {
+	return typeof e == "object" && !!e && typeof e.then == "function";
+}
+var { IDLE: A, DIRTY: j, PENDING: M, RESOLVED: N, REJECTED: P, HAS_ERROR: F, RECOMPUTING: I, DISPOSED: Se, IS_COMPUTED: Ce, FORCE_COMPUTE: we } = r, Te = class extends te {
+	constructor(e, t = {}) {
+		if (typeof e != "function") throw new h(v.COMPUTED_MUST_BE_FUNCTION);
+		if (super(), this[pe] = !0, this[me] = !0, this._error = null, this._promiseId = 0, this._deps = new ye(), this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = c.UNINITIALIZED, this._trackEpoch = c.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = Ce | j | A, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : S, this._onError = t.onError ?? null, this._maxAsyncRetries = (t.maxAsyncRetries ?? s.MAX_ASYNC_RETRIES) & l, C.attachDebugInfo(this, "computed", this.id), t.lazy === !1) try {
+			this._recompute();
+		} catch {}
+	}
+	_track() {
+		D.current?.addDependency(this);
+	}
+	get value() {
+		this._track();
+		let e = this.flags;
+		if ((e & (N | j | A)) === N) return this._value;
+		if (e & Se) throw new h(v.COMPUTED_DISPOSED);
+		if (e & I) {
+			if (this._defaultValue !== S) return this._defaultValue;
+			throw new h(v.COMPUTED_CIRCULAR_DEPENDENCY);
+		}
+		if (e & (j | A) && ((e & A) === 0 && (e & we) === 0 && this._deps.size > 0 && !this._isDirty() ? this.flags &= ~j : this._recompute(), this.flags & N)) return this._value;
+		let t = this._defaultValue, n = t !== S;
+		if (this.flags & M) {
+			if (n) return t;
+			throw new h(v.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+		}
+		if (this.flags & P) {
+			if (n) return t;
+			throw this._error;
+		}
+		return this._value;
+	}
+	peek() {
+		return this._value;
+	}
+	get state() {
+		this._track();
+		let e = this.flags;
+		return e & N ? t.RESOLVED : e & M ? t.PENDING : e & P ? t.REJECTED : t.IDLE;
+	}
+	get hasError() {
+		if (this._track(), this.flags & (P | F)) return !0;
+		let e = this._deps, t = e.size;
+		for (let n = 0; n < t; n++) {
+			let t = e.getAt(n);
+			if (t != null && t.node.flags & F) return !0;
+		}
+		return !1;
+	}
+	get isValid() {
+		return !this.hasError;
+	}
+	get errors() {
+		this._track();
+		let e = [];
+		this._error && e.push(this._error);
+		let t = this._deps, n = t.size;
+		for (let r = 0; r < n; r++) {
+			let n = t.getAt(r);
+			if (n == null) continue;
+			let i = n.node;
+			i.flags & F && this._collectErrorsFromDep(i, e);
+		}
+		return e.length === 0 ? d : Object.freeze(e);
+	}
+	_collectErrorsFromDep(e, t) {
+		let n = e.errors, r = n.length;
+		for (let e = 0; e < r; e++) {
+			let r = n[e];
+			r != null && !t.includes(r) && t.push(r);
+		}
+	}
+	get lastError() {
+		return this._track(), this._error;
+	}
+	get isPending() {
+		return this._track(), (this.flags & M) !== 0;
+	}
+	get isResolved() {
+		return this._track(), (this.flags & N) !== 0;
+	}
+	invalidate() {
+		this.flags |= we, this._markDirty();
+	}
+	dispose() {
+		this.flags & Se || (this._deps.disposeAll(), this._slots?.clear(), this.flags = Se | j | A, this._error = null, this._value = void 0, this._hotIndex = -1);
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	addDependency(e) {
+		if (e._lastSeenEpoch === this._trackEpoch) return;
+		e._lastSeenEpoch = this._trackEpoch;
+		let t = this._trackCount, n = this._deps.getAt(t);
+		if (n != null && n.node === e) n.version = e.version;
+		else if (!this._deps.claimExisting(e, t)) {
+			let n = new f(e, e.version, e.subscribe(this));
+			this._deps.insertNew(t, n);
+		}
+		e.flags & Ce && (this._deps.hasComputeds = !0), this._trackCount = t + 1;
+	}
+	_recompute() {
+		if (this.flags & I) return;
+		this.flags = (this.flags | I) & ~we, this._trackEpoch = re(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+		let e = !1;
+		try {
+			let t = D.run(this, this._fn);
+			this._deps.truncateFrom(this._trackCount), this._deps.seal(), e = !0, xe(t) ? this._handleAsyncComputation(t) : this._finalizeResolution(t);
+		} catch (t) {
+			if (!e) try {
+				this._deps.truncateFrom(this._trackCount);
+			} catch {}
+			this._handleError(t, v.COMPUTED_COMPUTATION_FAILED, !0);
+		} finally {
+			this._trackEpoch = c.UNINITIALIZED, this._trackCount = 0, this.flags &= ~I;
+		}
+	}
+	_handleAsyncComputation(e) {
+		this.flags = (this.flags | M) & ~(A | j | N | P), this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % s.MAX_PROMISE_ID;
+		let t = this._promiseId;
+		e.then((e) => {
+			if (t === this._promiseId) {
+				if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
+					let e = ce();
+					return this._lastDriftEpoch !== e && (this._lastDriftEpoch = e, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(new h(`Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`), v.COMPUTED_ASYNC_COMPUTATION_FAILED);
+				}
+				this._finalizeResolution(e), this._notifySubscribers(e, void 0);
+			}
+		}, (e) => t === this._promiseId && this._handleError(e, v.COMPUTED_ASYNC_COMPUTATION_FAILED));
+	}
+	_captureVersionSnapshot() {
+		return this._deps.captureVersionSnapshot();
+	}
+	_handleError(e, t, n = !1) {
+		let r = T(e, h, t);
+		if (!n && !(this.flags & P) && (this.version = ie(this.version)), this._error = r, this.flags = this.flags & ~(A | j | M | N) | P | F, this._onError) try {
+			this._onError(r);
+		} catch (e) {
+			console.error(v.CALLBACK_ERROR_IN_ERROR_HANDLER, e);
+		}
+		if (n) throw r;
+		this._notifySubscribers(void 0, void 0);
+	}
+	_finalizeResolution(e) {
+		(!(this.flags & N) || !this._equal(this._value, e)) && (this.version = ie(this.version)), this._value = e, this._error = null, this.flags = (this.flags | N) & ~(A | j | M | P | F);
+	}
+	execute() {
+		this._markDirty();
+	}
+	_markDirty() {
+		this.flags & (I | j) || (this.flags |= j, this._notifySubscribers(void 0, void 0));
+	}
+	_deepDirtyCheck() {
+		let e = this._deps, t = D.current;
+		D.current = null;
+		try {
+			let t = e.size;
+			for (let n = 0; n < t; n++) {
+				let t = e.getAt(n);
+				if (t == null) continue;
+				let r = t.node;
+				if (r.flags & Ce) try {
+					r.value;
+				} catch {}
+				if (r.version !== t.version) return this._hotIndex = n, !0;
+			}
+			return this._hotIndex = -1, !1;
+		} finally {
+			D.current = t;
+		}
+	}
 };
-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",
-  "src",
-  "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;
-}
-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;
-  for (let r = 0; r < e.length; r++) {
-    const c = e[r];
-    if (!rt.call(o, c) || i[c] !== o[c])
-      return !1;
-  }
-  return !0;
-}
-function gs(s) {
-  const t = s.length;
-  if (t === 0) return new Int32Array(0);
-  const e = new Int32Array(t).fill(-1), n = new Int32Array(t);
-  let i = 0;
-  for (let r = 0; r < t; r++) {
-    const c = s[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;
-      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;
-    }
-    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 o = new Int32Array(i);
-  if (i > 0) {
-    let r = n[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() {
-  if (typeof window < "u") {
-    const s = window.__ATOM_DEBUG__;
-    if (typeof s == "boolean") return s;
-  }
-  return ms?.VITE_ATOM_DEBUG === "true";
-}
-let W = ys();
-const f = {
-  get enabled() {
-    return W;
-  },
-  set enabled(s) {
-    W = s;
-  },
-  /**
-   * Logs a message only when debug mode is active.
-   */
-  log(s, ...t) {
-    W && console.log(`${g.MOUNT} ${s}:`, ...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
-    );
-  },
-  /**
-   * 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));
-  },
-  /**
-   * Logs a cleanup event only when debug mode is active.
-   */
-  cleanup(s) {
-    W && console.log(`${g.MOUNT} Cleanup: ${s}`);
-  },
-  /**
-   * Unconditional warning for runtime errors and unexpected states.
-   * Not gated by debugEnabled — these are always surfaced regardless of
-   * debug mode because they indicate real problems (e.g. dispose failures,
-   * missing route targets, pushState security errors).
-   *
-   * `prefix` is the subsystem tag (e.g. `LOG_PREFIXES.ROUTE`) so that the
-   * originating subsystem appears in the log rather than the generic MOUNT tag.
-   * Pass an empty string to emit a prefix-free message.
-   */
-  warn(s, t, ...e) {
-    console.warn(`${s} ${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);
-  t !== void 0 && cancelAnimationFrame(t);
-  const e = xt.get(s);
-  e !== void 0 && clearTimeout(e);
-  const n = requestAnimationFrame(() => {
-    Pt.delete(s), s.classList.add(Gt), xt.set(
-      s,
-      setTimeout(() => {
-        s.classList.remove(Gt), xt.delete(s);
-      }, Ce)
-    );
-  });
-  Pt.set(s, n);
-}
-function Se(s, t) {
-  return Bt(s, t);
-}
-Object.defineProperty(Se, "debug", {
-  enumerable: !0,
-  // configurable: true allows tests and advanced consumers to redefine or
-  // delete the accessor if needed. The default (false) would permanently lock
-  // the property on the function object.
-  configurable: !0,
-  get() {
-    return f.enabled;
-  },
-  set(s) {
-    f.enabled = s;
-  }
-});
-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 L(e, t = {}) {
+	return new Te(e, t);
+}
+var Ee = class extends te {
+	constructor(e, t = {}) {
+		super(), this[he] = !0, this._cleanup = null, this._deps = new ye(), this._currentEpoch = c.UNINITIALIZED, this._lastFlushEpoch = c.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._fn = e, this._onError = t.onError ?? null, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? a.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? a.MAX_EXECUTIONS_PER_EFFECT, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => E.schedule(this), C.attachDebugInfo(this, "effect", this.id);
+	}
+	run() {
+		if (this.flags & n.DISPOSED) throw new g(v.EFFECT_DISPOSED);
+		this.execute(!0);
+	}
+	dispose() {
+		this.flags & n.DISPOSED || (this.flags |= n.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	addDependency(e) {
+		if (!(this.flags & n.EXECUTING)) return;
+		let t = this._currentEpoch;
+		if (e._lastSeenEpoch === t) return;
+		e._lastSeenEpoch = t;
+		let i = this._trackCount, a = this._deps, o = a.getAt(i);
+		o != null && o.node === e ? o.version = e.version : a.claimExisting(e, i) || this._insertNewDependency(e, i), e.flags & r.IS_COMPUTED && (a.hasComputeds = !0), this._trackCount = i + 1;
+	}
+	_insertNewDependency(e, t) {
+		let n;
+		try {
+			let t = e.subscribe(this._notifyCallback);
+			n = new f(e, e.version, t);
+		} catch (t) {
+			let r = T(t, g, v.EFFECT_EXECUTION_FAILED);
+			if (console.error(r), this._onError) try {
+				this._onError(r);
+			} catch {}
+			n = new f(e, e.version, void 0);
+		}
+		this._deps.insertNew(t, n);
+	}
+	execute(e = !1) {
+		if (this.flags & (n.DISPOSED | n.EXECUTING)) return;
+		let t = this._deps;
+		if (!e && t.size > 0 && !this._isDirty()) return;
+		this._checkInfiniteLoops(), this.flags |= n.EXECUTING, this._execCleanup(), this._currentEpoch = re(), this._trackCount = 0, t.prepareTracking(), this._hotIndex = -1;
+		let r = !1;
+		try {
+			let e = D.run(this, this._fn);
+			t.truncateFrom(this._trackCount), t.seal(), r = !0, xe(e) ? this._handleAsyncResult(e) : this._cleanup = typeof e == "function" ? e : null;
+		} catch (e) {
+			if (!r) try {
+				t.truncateFrom(this._trackCount);
+			} catch {}
+			this._handleExecutionError(e), this._cleanup = null;
+		} finally {
+			this.flags &= ~n.EXECUTING;
+		}
+	}
+	_handleAsyncResult(e) {
+		let t = ++this._execId;
+		e.then((e) => {
+			if (t !== this._execId || this.flags & n.DISPOSED) {
+				if (typeof e == "function") try {
+					e();
+				} catch (e) {
+					this._handleExecutionError(e, v.EFFECT_CLEANUP_FAILED);
+				}
+				return;
+			}
+			typeof e == "function" && (this._cleanup = e);
+		}, (e) => t === this._execId && this._handleExecutionError(e));
+	}
+	_deepDirtyCheck() {
+		let e = D.current;
+		D.current = null;
+		let t = this._deps;
+		try {
+			let e = t.size;
+			for (let n = 0; n < e; n++) {
+				let e = t.getAt(n);
+				if (e == null) continue;
+				let i = e.node;
+				if (i.flags & r.IS_COMPUTED && this._tryPullComputed(i), i.version !== e.version) return this._hotIndex = n, !0;
+			}
+			return !1;
+		} finally {
+			D.current = e;
+		}
+	}
+	_tryPullComputed(e) {
+		try {
+			e.value;
+		} catch {}
+	}
+	_execCleanup() {
+		if (this._cleanup) {
+			try {
+				this._cleanup();
+			} catch (e) {
+				this._handleExecutionError(e, v.EFFECT_CLEANUP_FAILED);
+			}
+			this._cleanup = null;
+		}
+	}
+	_checkInfiniteLoops() {
+		let e = ce();
+		this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), de() > a.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+	}
+	_checkFrequencyLimit() {
+		if (!Number.isFinite(this._maxExecutions)) return;
+		let e = Date.now();
+		if (e - this._windowStart >= o.EFFECT_FREQUENCY_WINDOW) {
+			this._windowStart = e, this._windowCount = 1;
+			return;
+		}
+		if (++this._windowCount > this._maxExecutions) {
+			let e = new g(v.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+			throw this.dispose(), this._handleExecutionError(e), e;
+		}
+	}
+	get isDisposed() {
+		return (this.flags & n.DISPOSED) !== 0;
+	}
+	get executionCount() {
+		return this._executionCount;
+	}
+	get isExecuting() {
+		return (this.flags & n.EXECUTING) !== 0;
+	}
+	_throwInfiniteLoopError(e) {
+		let t = new g(`Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${ae}`);
+		throw this.dispose(), console.error(t), t;
+	}
+	_handleExecutionError(e, t = v.EFFECT_EXECUTION_FAILED) {
+		let n = T(e, g, t);
+		if (console.error(n), this._onError) try {
+			this._onError(n);
+		} catch (e) {
+			console.error(T(e, g, v.CALLBACK_ERROR_IN_ERROR_HANDLER));
+		}
+	}
 };
-l.extend(Rs);
-const J = "_aes-bound";
-class Ns {
-  constructor() {
-    this.records = /* @__PURE__ */ new WeakMap(), this.preservedNodes = /* @__PURE__ */ new WeakSet(), this.ignoredNodes = /* @__PURE__ */ new WeakSet();
-  }
-  // --------------------------------------------------------------------------
-  // Lifecycle flags
-  // --------------------------------------------------------------------------
-  keep(t) {
-    this.preservedNodes.add(t);
-  }
-  isKept(t) {
-    return this.preservedNodes.has(t);
-  }
-  markIgnored(t) {
-    this.ignoredNodes.add(t);
-  }
-  isIgnored(t) {
-    return this.ignoredNodes.has(t);
-  }
-  // --------------------------------------------------------------------------
-  // Tracking
-  // --------------------------------------------------------------------------
-  getOrCreateRecord(t) {
-    let e = this.records.get(t);
-    return e || (e = {}, this.records.set(t, e), t.classList.add(J)), e;
-  }
-  trackEffect(t, e) {
-    const n = this.getOrCreateRecord(t);
-    n.effects ??= [], n.effects.push(e);
-  }
-  trackCleanup(t, e) {
-    const n = this.getOrCreateRecord(t);
-    n.cleanups ??= [], n.cleanups.push(e);
-  }
-  setComponentCleanup(t, e) {
-    const n = this.getOrCreateRecord(t);
-    n.componentCleanup = e;
-  }
-  hasBind(t) {
-    return this.records.has(t);
-  }
-  // --------------------------------------------------------------------------
-  // Cleanup
-  // --------------------------------------------------------------------------
-  cleanup(t) {
-    const e = this.records.get(t);
-    if (!e) {
-      t.isConnected && t.classList.remove(J), 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)
-      try {
-        e.componentCleanup();
-      } catch (n) {
-        f.error(g.MOUNT, T.MOUNT_CLEANUP_ERROR(), n);
-      }
-    if (e.effects) {
-      const n = e.effects;
-      for (let i = 0, o = n.length; i < o; i++)
-        try {
-          n[i].dispose();
-        } catch (r) {
-          f.error(g.BINDING, T.EFFECT_DISPOSE_ERROR(), r);
-        }
-    }
-    if (e.cleanups) {
-      const n = e.cleanups;
-      for (let i = 0, o = n.length; i < o; i++)
-        try {
-          n[i]();
-        } catch (r) {
-          f.error(g.BINDING, T.BINDING_CLEANUP_ERROR(), 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:`,
-        i
-      )));
-    }
-  }
-  cleanupTree(t) {
-    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 }
-    );
-    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));
-      }
-    }
-  }), it.observe(s, { childList: !0, subtree: !0 });
-}
-function Vs() {
-  it?.disconnect(), it = null, pt = null;
-}
-function Q(s, t, e, n) {
-  if (ye(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);
-        });
-      })
-    );
-  } else {
-    try {
-      e(t);
-    } catch (i) {
-      f.error(g.BINDING, `${T.UPDATER_ERROR(n)} (static):`, i);
-      return;
-    }
-    f.enabled && f.domUpdated(s, n, t);
-  }
-}
-const F = /* @__PURE__ */ Symbol("atom-effect-internal"), mt = /* @__PURE__ */ new WeakMap();
-let x = null;
-const be = (s) => {
-  if (s[F]) return s;
-  let t = mt.get(s);
-  return t || (t = function(...e) {
-    return Ie(() => s.apply(this, e));
-  }, t[F] = !0, mt.set(s, 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() {
-  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
-  };
-  const s = x;
-  l.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));
-    }
-    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);
-    }
-    return s.empty.call(this);
-  }, l.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);
-    }
-    return s.detach.call(this, t);
-  }, l.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) {
-    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);
-  };
-}
-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);
-}
-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) {
-    this.flags = 0, this.timeoutId = void 0, this.handleCompositionStart = () => {
-      this.flags |= v.Composing;
-    }, this.handleCompositionEnd = () => {
-      this.flags &= ~v.Composing, this.handleInput();
-    }, this.handleFocus = () => {
-      this.flags |= v.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.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)
-          try {
-            if (this.equal(this.parse(E), r)) return;
-          } catch {
-          }
-        this.flags |= v.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);
-        } finally {
-          this.flags &= ~v.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.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);
-  }
-  // --- Sync Logic ---
-  syncAtomFromDom() {
-    if (!(this.flags & v.Busy)) {
-      this.flags |= v.SyncingToAtom;
-      try {
-        const t = this.parse(this.el.value);
-        this.equal(this.atom.peek(), t) || (this.atom.value = t);
-      } catch (t) {
-        f.warn(g.BINDING, `${T.PARSE_ERROR()}:`, t);
-      } finally {
-        this.flags &= ~v.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);
-  }
-}
-function ws(s, t, e) {
-  const n = new Us(s, t, e);
-  return { fx: X(n.syncDomFromAtom), cleanup: n.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 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 U(s) {
-  return {
-    $el: l(s),
-    el: s,
-    trackCleanup: (t) => y.trackCleanup(s, t)
-  };
-}
-function Te(s, t, e) {
-  const n = s.el;
-  Q(
-    n,
-    t,
-    (i) => {
-      const o = e ? e(i) : typeof i == "string" ? i : String(i ?? "");
-      n.textContent !== o && (n.textContent = o);
-    },
-    "text"
-  );
-}
-function Re(s, t) {
-  const e = s.el, n = qt(t) ? xs(t) : t;
-  Q(
-    e,
-    n,
-    (i) => {
-      e.innerHTML !== i && (y.cleanupDescendants(e), e.innerHTML = i);
-    },
-    "html"
-  );
-}
-function Ne(s, 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);
-        },
-        `class.${e}`
-      );
-    }
-}
-function Oe(s, t) {
-  const e = s.el, n = 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(
-        e,
-        c,
-        (d) => {
-          const m = E ? `${d}${E}` : String(d);
-          Es(m) || (n[r] = m);
-        },
-        `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(
-        e,
-        t[n],
-        (i) => {
-          if (i == null || i === !1) {
-            e.removeAttribute(n);
-            return;
-          }
-          const o = i === !0 ? n : String(i);
-          _s(n, o) || e.getAttribute(n) !== o && e.setAttribute(n, o);
-        },
-        `attr.${n}`
-      );
-    }
-}
-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);
-        },
-        `prop.${n}`
-      );
-    }
-}
-function It(s, t, e) {
-  const n = s.el;
-  Q(
-    n,
-    t,
-    (o) => {
-      const r = e !== !!o;
-      n.style.display = r ? "" : "none";
-    },
-    e ? "hide" : "show"
-  );
-}
-function Ae(s, t, e = {}) {
-  const n = s.el.tagName.toLowerCase();
-  if (!Je.has(n)) {
-    console.warn(`${g.BINDING} ${T.INVALID_INPUT_ELEMENT(n)}`);
-    return;
-  }
-  const { fx: i, cleanup: o } = ws(s.$el, t, e);
-  y.trackEffect(s.el, i), s.trackCleanup(o);
-}
-function Le(s, t) {
-  const e = s.el, n = s.$el, i = () => {
-    const r = e.checked;
-    t.value !== r && (t.value = r);
-  };
-  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));
-    });
-  });
-  y.trackEffect(e, o);
-}
-function Ps(s, t) {
-  const e = s.$el;
-  e.on(t), s.trackCleanup(() => e.off(t));
-}
-function $s(s, t, e) {
-  const n = s.$el;
-  n.on(t, e), s.trackCleanup(() => n.off(t, e));
-}
-function Ue(s) {
-  y.cleanupTree(s);
-}
-l.fn.atomText = function(s, t) {
-  for (let e = 0, n = this.length; e < n; e++)
-    Te(U(this[e]), s, t);
-  return this;
-};
-l.fn.atomHtml = function(s) {
-  for (let t = 0, e = this.length; t < e; t++)
-    Re(U(this[t]), s);
-  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);
-  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);
-  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);
-  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);
-  return this;
-};
-l.fn.atomShow = function(s) {
-  for (let t = 0, e = this.length; t < e; t++)
-    It(U(this[t]), s, !1);
-  return this;
-};
-l.fn.atomHide = function(s) {
-  for (let t = 0, e = this.length; t < e; t++)
-    It(U(this[t]), s, !0);
-  return this;
+function R(e, t = {}) {
+	if (typeof e != "function") throw new g(v.EFFECT_MUST_BE_FUNCTION);
+	let n = new Ee(e, t);
+	return n.execute(), n;
+}
+function De(e) {
+	if (typeof e != "function") throw TypeError(v.BATCH_CALLBACK_MUST_BE_FUNCTION);
+	E.startBatch();
+	try {
+		return e();
+	} finally {
+		E.endBatch();
+	}
+}
+//#endregion
+//#region src/utils/index.ts
+function Oe(e) {
+	return k(e);
+}
+function z(e) {
+	let t = e.tagName.toLowerCase();
+	if (e.id) return `${t}#${e.id}`;
+	let n = e.classList, r = n.length;
+	if (r === 0) return t;
+	let i = t;
+	for (let e = 0; e < r; e++) i += `.${n[e]}`;
+	return i;
+}
+var B = Object.prototype.hasOwnProperty;
+function ke(e, t) {
+	if (e === t) return !0;
+	if (e === null || t === null || typeof e != "object" || typeof t != "object") return !1;
+	let n = Object.keys(e), r = Object.keys(t);
+	if (n.length !== r.length) return !1;
+	let i = e, a = t;
+	for (let e = 0; e < n.length; e++) {
+		let t = n[e];
+		if (!B.call(a, t) || i[t] !== a[t]) return !1;
+	}
+	return !0;
+}
+//#endregion
+//#region src/constants.ts
+var V = {
+	ROUTE: "[atom-route]",
+	BINDING: "[atom-binding]",
+	LIST: "[atom-list]",
+	MOUNT: "[atom-mount]"
+}, H = Object.freeze({
+	mode: "hash",
+	basePath: "",
+	autoBindLinks: !1,
+	activeClass: "active"
+}), Ae = {
+	EVENT: "input",
+	DEBOUNCE: 0
+}, je = { HIGHLIGHT_DURATION_MS: 500 }, Me = new Set([
+	"input",
+	"select",
+	"textarea"
+]), Ne = new Set([
+	"src",
+	"href",
+	"action",
+	"formaction",
+	"data",
+	"poster",
+	"background",
+	"cite",
+	"longdesc",
+	"profile",
+	"usemap",
+	"classid",
+	"codebase",
+	"xlink:href"
+]), Pe = new Set([
+	"innerHTML",
+	"outerHTML",
+	"srcdoc",
+	"__proto__",
+	"constructor",
+	"prototype"
+]), U = {
+	ROUTE: {
+		NOT_FOUND: (e) => `Route "${e}" not found and no notFound route configured`,
+		TEMPLATE_NOT_FOUND: (e) => `Template "${e}" not found`,
+		TARGET_NOT_FOUND: (e) => `Target element "${e}" not found`,
+		MALFORMED_URI: (e) => `Malformed URI component: ${e}`
+	},
+	SECURITY: {
+		UNSAFE_CONTENT: () => "Unsafe content neutralized during sanitization.",
+		BLOCKED_CSS_VALUE: (e) => `Blocked dangerous value in CSS style property "${e}".`,
+		BLOCKED_EVENT_HANDLER: (e) => `Blocked setting dangerous event handler attribute/property "${e}".`,
+		BLOCKED_PROTOCOL: (e) => `Blocked dangerous protocol in "${e}".`,
+		BLOCKED_PROP: (e) => `Blocked setting dangerous property "${e}". Use html binding for sanitized HTML.`
+	},
+	BINDING: {
+		INVALID_INPUT_ELEMENT: (e) => `Val binding used on non-input element <${e}>.`,
+		MISSING_SOURCE: (e) => `[${e}] source is required when prop/name is a string.`,
+		MISSING_CONDITION: (e) => `[${e}] condition is required when className is a string.`,
+		UPDATER_ERROR: (e, t) => `Updater threw in binding "${e}"${t ? " (static)" : ""}`,
+		CLEANUP_ERROR: (e) => `Binding cleanup error${e ? `: ${e}` : ""}`,
+		PARSE_ERROR: (e) => `parse() threw during DOM→Atom sync${e ? `: ${e}` : ""}`
+	},
+	LIST: { DUPLICATE_KEY: (e, t, n) => `Duplicate key "${e}" at index ${t} in atomList <${n}>.` },
+	MOUNT: {
+		ERROR: (e) => `Mount error${e ? ` in component <${e}>` : ""}`,
+		CLEANUP_ERROR: (e) => `Cleanup error${e ? ` in component <${e}>` : ""}`
+	},
+	CORE: { EFFECT_DISPOSE_ERROR: (e) => `Effect dispose error${e ? `: ${e}` : ""}` }
+}, Fe = `${je.HIGHLIGHT_DURATION_MS / 1e3}s`;
+function Ie() {
+	if (typeof window < "u") {
+		let e = window.__ATOM_DEBUG__;
+		if (typeof e == "boolean") return e;
+	}
+	try {
+		if (globalThis.process?.env?.VITE_ATOM_DEBUG === "true") return !0;
+	} catch {}
+	return !1;
+}
+var Le = Ie(), W = {
+	get enabled() {
+		if (typeof window < "u") {
+			let e = window.__ATOM_DEBUG__;
+			if (typeof e == "boolean") return e;
+		}
+		return Le;
+	},
+	set enabled(e) {
+		Le = e;
+	},
+	log(e, ...t) {
+		this.enabled && console.log(`${e}`, ...t);
+	},
+	atomChanged(e, t, n, r) {
+		this.enabled && console.log(`${e} Atom "${t ?? "anonymous"}" changed:`, n, "→", r);
+	},
+	domUpdated(e, t, n, r) {
+		if (!this.enabled) return;
+		let i = t instanceof Element ? t : t[0];
+		i && (console.log(`${e} DOM updated: ${z(i)}.${n} =`, r), Ue(i));
+	},
+	cleanup(e, t) {
+		this.enabled && console.log(`${e} Cleanup: ${t}`);
+	},
+	warn(e, t, ...n) {
+		console.warn(`${e} ${t}`, ...n);
+	},
+	error(e, t, n) {
+		console.error(`${e} ${t}`, n);
+	}
+}, Re = "atom-debug-highlight", ze = "data-atom-debug", G;
+function Be() {
+	if ((G instanceof HTMLStyleElement ? G : G?.deref())?.isConnected || document.querySelector(`style[${ze}]`)) return;
+	let e = document.createElement("style");
+	e.setAttribute(ze, ""), e.textContent = `.${Re}{outline:2px solid rgba(255,68,68,0.8);outline-offset:1px;transition:outline ${Fe} ease-out}`, document.head.appendChild(e), G = typeof WeakRef < "u" ? new WeakRef(e) : e;
+}
+var Ve = /* @__PURE__ */ new WeakMap(), He = /* @__PURE__ */ new WeakMap();
+function Ue(e) {
+	if (!W.enabled || !e.isConnected) return;
+	Be();
+	let t = He.get(e);
+	t !== void 0 && cancelAnimationFrame(t);
+	let n = Ve.get(e);
+	n !== void 0 && clearTimeout(n);
+	let r = requestAnimationFrame(() => {
+		He.delete(e), e.isConnected && (e.classList.add(Re), Ve.set(e, setTimeout(() => {
+			e.isConnected && e.classList.remove(Re), Ve.delete(e);
+		}, je.HIGHLIGHT_DURATION_MS)));
+	});
+	He.set(e, r);
+}
+//#endregion
+//#region src/core/namespace.ts
+function We(e, t) {
+	return ve(e, t);
+}
+Object.defineProperty(We, "debug", {
+	enumerable: !0,
+	configurable: !0,
+	get() {
+		return W.enabled;
+	},
+	set(e) {
+		W.enabled = e;
+	}
+});
+function Ge() {
+	return new Promise((e) => setTimeout(e, 0));
+}
+var Ke = {
+	atom: We,
+	computed: L,
+	effect: R,
+	batch: De,
+	untracked: O,
+	isAtom: k,
+	isComputed: be,
+	isReactive: Oe,
+	nextTick: Ge
 };
-l.fn.atomVal = function(s, t = {}) {
-  for (let e = 0, n = this.length; e < n; e++)
-    Ae(U(this[e]), s, t);
-  return this;
+e.extend(Ke);
+//#endregion
+//#region src/utils/array-pool.ts
+var qe = class {
+	constructor(e = 50, t = 256) {
+		this.limit = e, this.capacity = t, this.pool = [];
+	}
+	acquire() {
+		return this.pool.pop() ?? [];
+	}
+	release(e) {
+		e.length > this.capacity || this.pool.length >= this.limit || Object.isFrozen(e) || (e.length = 0, this.pool.push(e));
+	}
+	reset() {
+		this.pool.length = 0;
+	}
+}, Je = class {
+	constructor(e, t, n = 64) {
+		this.factory = e, this.reset = t, this.limit = n, this.pool = [];
+	}
+	acquire() {
+		return this.pool.pop() ?? this.factory();
+	}
+	release(e) {
+		this.pool.length >= this.limit || (this.reset(e), this.pool.push(e));
+	}
+	drain() {
+		this.pool.length = 0;
+	}
+	get size() {
+		return this.pool.length;
+	}
+}, Ye = new qe(), Xe = new qe(), Ze = new Je(() => ({
+	effects: void 0,
+	cleanups: void 0,
+	componentCleanup: void 0
+}), (e) => {
+	e.effects = void 0, e.cleanups = void 0, e.componentCleanup = void 0;
+}, 128), K = "_aes-bound", q = new class {
+	constructor() {
+		this.records = /* @__PURE__ */ new WeakMap(), this.preservedNodes = /* @__PURE__ */ new WeakSet(), this.ignoredNodes = /* @__PURE__ */ new WeakSet();
+	}
+	keep(e) {
+		this.preservedNodes.add(e);
+	}
+	isKept(e) {
+		return this.preservedNodes.has(e);
+	}
+	markIgnored(e) {
+		this.ignoredNodes.add(e);
+	}
+	isIgnored(e) {
+		return this.ignoredNodes.has(e);
+	}
+	getOrCreateRecord(e) {
+		let t = this.records.get(e);
+		return t || (t = Ze.acquire(), this.records.set(e, t), e.classList.add(K)), t;
+	}
+	trackEffect(e, t) {
+		let n = this.getOrCreateRecord(e);
+		n.effects ??= Ye.acquire(), n.effects.push(t);
+	}
+	trackCleanup(e, t) {
+		let n = this.getOrCreateRecord(e);
+		n.cleanups ??= Xe.acquire(), n.cleanups.push(t);
+	}
+	setComponentCleanup(e, t) {
+		let n = this.getOrCreateRecord(e);
+		n.componentCleanup = t;
+	}
+	hasBind(e) {
+		return this.records.has(e);
+	}
+	cleanup(e) {
+		let t = this.records.get(e);
+		if (!t) {
+			e.nodeType === 1 && e.classList.remove(K), this.preservedNodes.delete(e), this.ignoredNodes.delete(e);
+			return;
+		}
+		if (this.records.delete(e), this.preservedNodes.delete(e), this.ignoredNodes.delete(e), e.nodeType === 1 && e.classList.remove(K), W.enabled) {
+			let t = e.nodeType === 1 ? z(e) : e.nodeName || "Node";
+			W.cleanup(V.BINDING, t);
+		}
+		if (t.componentCleanup) try {
+			t.componentCleanup();
+		} catch (t) {
+			let n = e.nodeType === 1 ? z(e) : "Node";
+			W.error(V.MOUNT, U.MOUNT.CLEANUP_ERROR(n), t);
+		}
+		if (t.effects) {
+			let n = t.effects;
+			for (let t = 0, r = n.length; t < r; t++) try {
+				n[t].dispose();
+			} catch (t) {
+				let n = e.nodeType === 1 ? z(e) : "Node";
+				W.error(V.BINDING, U.CORE.EFFECT_DISPOSE_ERROR(n), t);
+			}
+			Ye.release(n), t.effects = void 0;
+		}
+		if (t.cleanups) {
+			let n = t.cleanups;
+			for (let t = 0, r = n.length; t < r; t++) try {
+				n[t]();
+			} catch (t) {
+				let n = e.nodeType === 1 ? z(e) : "Node";
+				W.error(V.BINDING, U.BINDING.CLEANUP_ERROR(n), t);
+			}
+			Xe.release(n), t.cleanups = void 0;
+		}
+		Ze.release(t);
+	}
+	cleanupDescendants(e) {
+		let t = "getElementsByClassName" in e && typeof e.getElementsByClassName == "function" ? e.getElementsByClassName(K) : e.querySelectorAll(`.${K}`);
+		for (let e = t.length - 1; e >= 0; e--) {
+			let n = t[e];
+			n && (this.records.has(n) ? this.cleanup(n) : (n.classList.remove(K), W.enabled && W.warn(V.BINDING, `${K} class found on unregistered element:`, n)));
+		}
+	}
+	cleanupTree(e) {
+		(e.nodeType === 1 || e.nodeType === 11) && this.cleanupDescendants(e), this.cleanup(e);
+	}
+}(), Qe = /* @__PURE__ */ new Map();
+function $e(e) {
+	if (Qe.has(e)) return;
+	let t = new MutationObserver((e) => {
+		for (let t = 0, n = e.length; t < n; t++) {
+			let n = e[t].removedNodes;
+			for (let e = 0, t = n.length; e < t; e++) {
+				let t = n[e];
+				t.nodeType === 1 && (t.isConnected || q.isKept(t) || q.isIgnored(t) || q.cleanupTree(t));
+			}
+		}
+	});
+	t.observe(e, {
+		childList: !0,
+		subtree: !0
+	}), Qe.set(e, t);
+}
+function et() {
+	Qe.forEach((e) => e.disconnect()), Qe.clear();
+}
+//#endregion
+//#region src/core/jquery-patch.ts
+var tt = Symbol("atom-effect-internal"), nt = /* @__PURE__ */ new WeakMap(), J = null, rt = (e) => {
+	if (e[tt]) return e;
+	let t = nt.get(e);
+	return t || (t = function(...t) {
+		return De(() => e.apply(this, t));
+	}, t[tt] = !0, nt.set(e, t)), t;
 };
-l.fn.atomChecked = function(s) {
-  for (let t = 0, e = this.length; t < e; t++)
-    Le(U(this[t]), s);
-  return this;
+function it(e) {
+	let t = {}, n = Object.entries(e);
+	for (let e = 0, r = n.length; e < r; e++) {
+		let r = n[e], i = r[0], a = r[1];
+		a && (t[i] = rt(a));
+	}
+	return t;
+}
+function at(e) {
+	let t = {}, n = Object.entries(e);
+	for (let e = 0, r = n.length; e < r; e++) {
+		let r = n[e], i = r[0], a = r[1];
+		t[i] = a ? nt.get(a) ?? a : void 0;
+	}
+	return t;
+}
+function ot() {
+	if (J !== null) return;
+	J = {
+		on: e.fn.on,
+		off: e.fn.off,
+		remove: e.fn.remove,
+		empty: e.fn.empty,
+		detach: e.fn.detach
+	};
+	let t = J;
+	e.fn.remove = function(e) {
+		let n = e ? this.filter(e) : this;
+		for (let e = 0, t = n.length; e < t; e++) {
+			let t = n[e];
+			t && (q.markIgnored(t), q.cleanupTree(t));
+		}
+		let r = t.remove.call(this, e);
+		return r === void 0 ? this : r;
+	}, e.fn.empty = function() {
+		for (let e = 0, t = this.length; e < t; e++) {
+			let t = this[e];
+			t?.hasChildNodes() && q.cleanupDescendants(t);
+		}
+		let e = t.empty.call(this);
+		return e === void 0 ? this : e;
+	}, e.fn.detach = function(e) {
+		let n = e ? this.filter(e) : this;
+		for (let e = 0, t = n.length; e < t; e++) {
+			let t = n[e];
+			t && q.keep(t);
+		}
+		let r = t.detach.call(this, e);
+		return r === void 0 ? this : r;
+	}, e.fn.on = function(...e) {
+		let n = e[0];
+		if (n && typeof n == "object") e[0] = it(n);
+		else {
+			let t = e.length - 1;
+			t >= 0 && typeof e[t] == "function" && (e[t] = rt(e[t]));
+		}
+		let r = t.on.apply(this, e);
+		return r === void 0 ? this : r;
+	}, e.fn.off = function(...e) {
+		let n = e[0];
+		if (n && typeof n == "object") e[0] = at(n);
+		else {
+			let t = e.length - 1;
+			if (t >= 0 && typeof e[t] == "function") {
+				let n = e[t];
+				e[t] = nt.get(n) ?? n;
+			}
+		}
+		let r = t.off.apply(this, e);
+		return r === void 0 ? this : r;
+	};
+}
+function st() {
+	J !== null && (e.fn.on = J.on, e.fn.off = J.off, e.fn.remove = J.remove, e.fn.empty = J.empty, e.fn.detach = J.detach, J = null);
+}
+//#endregion
+//#region src/types.ts
+var Y = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Focused = 1] = "Focused", e[e.Composing = 2] = "Composing", e[e.SyncingToAtom = 4] = "SyncingToAtom", e[e.SyncingToDom = 8] = "SyncingToDom", e[e.Busy = 14] = "Busy", e;
+}({}), ct = 0;
+function X(e) {
+	e[tt] = !0;
+}
+var lt = class {
+	constructor(e, t, n) {
+		this.flags = 0, this.timeoutId = void 0, this.handleCompositionStart = () => {
+			this.flags |= Y.Composing;
+		}, this.handleCompositionEnd = () => {
+			this.flags &= ~Y.Composing, this.handleInput();
+		}, this.handleFocus = () => {
+			this.flags |= Y.Focused;
+		}, this.handleBlur = () => {
+			this.flags &= ~Y.Focused;
+			let e = !!(this.flags & Y.Composing);
+			this.flags &= ~Y.Composing, this.flushPendingDebounce(), e && this.timeoutId === void 0 && this.syncAtomFromDom(), this.normalizeDomValue();
+		}, this.syncDomFromAtom = () => {
+			let e = this.atom.value;
+			O(() => {
+				let t = this.format(e), n;
+				if (n = this.isMultipleSelect ? this.$el.val() || [] : this.el.value, this.equal(n, e)) return;
+				let r = !!(this.flags & Y.Focused);
+				if (r) try {
+					let t = this.isMultipleSelect ? n : this.parse(this.el.value);
+					if (this.equal(t, e)) return;
+				} catch {}
+				this.flags |= Y.SyncingToDom;
+				try {
+					if (this.isMultipleSelect) this.$el.val(e);
+					else if (r && (this.el instanceof HTMLInputElement || this.el instanceof HTMLTextAreaElement)) try {
+						let e = this.el.selectionStart, n = this.el.selectionEnd;
+						this.el.value = t;
+						let r = t.length;
+						e !== null && n !== null && this.el.setSelectionRange(e < r ? e : r, n < r ? n : r);
+					} catch {
+						this.el.value = t;
+					}
+					else this.el.value = t;
+					W.enabled && W.domUpdated(V.BINDING, this.$el, "val", t);
+				} finally {
+					this.flags &= ~Y.SyncingToDom;
+				}
+			});
+		}, this.cleanup = () => {
+			this.$el.off(this.ns), clearTimeout(this.timeoutId), this.timeoutId = void 0;
+		}, this.$el = e, this.el = e[0], this.atom = t, this.isMultipleSelect = this.el.tagName === "SELECT" && this.el.multiple, this.ns = `.atomBind-${++ct}`;
+		let r = n.debounce ?? 0, i = n.event ?? Ae.EVENT;
+		this.parse = n.parse ?? ((e) => e), this.format = n.format ?? ((e) => this.isMultipleSelect ? (Array.isArray(e) ? e : e ? [String(e)] : []).join(",") : String(e ?? ""));
+		let a = n.equal ?? Object.is;
+		this.equal = (e, t) => a(e, t) ? !0 : Array.isArray(e) && Array.isArray(t) ? e.length === t.length && e.every((e, n) => Object.is(e, t[n])) : !1, r > 0 ? this.handleInput = () => {
+			this.flags & Y.Composing || (clearTimeout(this.timeoutId), this.timeoutId = setTimeout(() => this.syncAtomFromDom(), r));
+		} : this.handleInput = () => {
+			this.flags & Y.Composing || this.syncAtomFromDom();
+		}, X(this.handleFocus), X(this.handleBlur), X(this.handleCompositionStart), X(this.handleCompositionEnd), X(this.handleInput), this.bindEvents(i);
+	}
+	flushPendingDebounce() {
+		this.timeoutId !== void 0 && (clearTimeout(this.timeoutId), this.timeoutId = void 0, this.syncAtomFromDom());
+	}
+	normalizeDomValue() {
+		let e = this.format(this.atom.peek());
+		if (this.isMultipleSelect) {
+			let e = this.$el.val() || [], t = Array.isArray(this.atom.peek()) ? this.atom.peek() : [];
+			this.equal(e, t) || this.$el.val(t);
+		} else this.el.value !== e && (this.el.value = e);
+	}
+	syncAtomFromDom() {
+		if (!(this.flags & Y.Busy)) {
+			this.flags |= Y.SyncingToAtom;
+			try {
+				let e;
+				e = this.isMultipleSelect ? this.$el.val() || [] : this.el.value;
+				let t = this.parse(e);
+				this.equal(this.atom.peek(), t) || (this.atom.value = t);
+			} catch (e) {
+				W.warn(V.BINDING, U.BINDING.PARSE_ERROR(e instanceof Error ? e.message : String(e)), e);
+			} finally {
+				this.flags &= ~Y.SyncingToAtom;
+			}
+		}
+	}
+	bindEvents(e) {
+		let t = this.ns, n = e.trim().split(/\s+/).map((e) => `${e}${t}`).join(" ");
+		this.$el.on(`focus${t}`, this.handleFocus).on(`blur${t}`, this.handleBlur).on(`compositionstart${t}`, this.handleCompositionStart).on(`compositionend${t}`, this.handleCompositionEnd).on(n, this.handleInput);
+	}
 };
-l.fn.atomOn = function(s, t) {
-  for (let e = 0, n = this.length; e < n; e++)
-    $s(U(this[e]), s, t);
-  return this;
+function ut(e, t, n) {
+	let r = new lt(e, t, n);
+	return {
+		fx: R(r.syncDomFromAtom),
+		cleanup: r.cleanup
+	};
+}
+//#endregion
+//#region src/core/effect-factory.ts
+function dt(e, t, n, r) {
+	if (Oe(t)) {
+		let i = t;
+		q.trackEffect(e, R(() => {
+			let t = i.value;
+			O(() => {
+				try {
+					n(t);
+				} catch (e) {
+					W.error(V.BINDING, U.BINDING.UPDATER_ERROR(r), e);
+					return;
+				}
+				W.enabled && W.domUpdated(V.BINDING, e, r, t);
+			});
+		}, { name: r }));
+	} else O(() => {
+		try {
+			n(t);
+		} catch (e) {
+			W.error(V.BINDING, U.BINDING.UPDATER_ERROR(r, !0), e);
+			return;
+		}
+		W.enabled && W.domUpdated(V.BINDING, e, r, t);
+	});
+}
+function ft(e, t, n, r) {
+	let i = Object.keys(t), a = [], o = {};
+	for (let e = 0; e < i.length; e++) {
+		let n = i[e], r = t[n];
+		Oe(r) ? a.push(n) : o[n] = r;
+	}
+	a.length > 0 ? q.trackEffect(e, R(() => {
+		let i = { ...o };
+		for (let e = 0; e < a.length; e++) {
+			let n = a[e];
+			i[n] = t[n].value;
+		}
+		O(() => {
+			try {
+				n(i);
+			} catch (e) {
+				W.error(V.BINDING, U.BINDING.UPDATER_ERROR(r), e);
+				return;
+			}
+			W.enabled && W.domUpdated(V.BINDING, e, r, i);
+		});
+	}, { name: r })) : O(() => {
+		try {
+			n(o);
+		} catch (e) {
+			W.error(V.BINDING, U.BINDING.UPDATER_ERROR(r, !0), e);
+			return;
+		}
+		W.enabled && W.domUpdated(V.BINDING, e, r, o);
+	});
+}
+//#endregion
+//#region src/utils/sanitize.ts
+var pt = new Set([
+	"href",
+	"src",
+	"action",
+	"formaction",
+	"xlink:href",
+	"data",
+	"poster",
+	"background",
+	"cite",
+	"longdesc",
+	"profile",
+	"usemap",
+	"classid",
+	"codebase"
+]), mt = /^\s*(?:javascript|vbscript)\s*:/i, ht = /(?: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, gt = /url\s*\(\s*(?:["']?\s*)?(?:javascript|vbscript)\s*:/i, _t = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, vt = /&#x([0-9a-f]+);?|&#([0-9]+);?/gi, yt = {
+	colon: ":",
+	Tab: "	",
+	NewLine: "\n"
+}, bt = /&(colon|Tab|NewLine);/g, xt = /<\?[\s\S]*?\?>/g, St = /(<(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, Ct = /(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, wt = /data\s*:\s*(?:text\/(?:html|javascript|vbscript|xml)|application\/(?:javascript|xhtml\+xml|xml|x-shockwave-flash)|image\/svg\+xml)/gi, Tt = /\bon\w+\s*=/gim, Et = new RegExp(ht.source, "gim");
+function Dt(e) {
+	let t = String(e ?? "");
+	t = t.replace(_t, ""), t = t.replace(vt, (e, t, n) => String.fromCodePoint(t ? parseInt(t, 16) : parseInt(n, 10))), t = t.replace(bt, (e, t) => yt[t] ?? ""), t = t.replace(xt, "");
+	let n;
+	do
+		n = t, t = t.replace(St, "");
+	while (t !== n);
+	return t = t.replace(Ct, "data-unsafe-protocol:"), t = t.replace(wt, "data-unsafe-protocol:"), t = t.replace(Tt, "data-unsafe-attr="), t = t.replace(Et, "data-unsafe-css:"), t;
+}
+function Ot(e, t) {
+	return pt.has(e.toLowerCase()) ? mt.test(t) : !1;
+}
+function kt(e) {
+	return e.toLowerCase().includes("url(") ? gt.test(e) : !1;
+}
+//#endregion
+//#region src/bindings/unified.ts
+var At = /* @__PURE__ */ new Map();
+function jt(e) {
+	let t = At.get(e);
+	return t === void 0 ? (t = e.includes("-") ? e.replace(/-./g, (e) => e[1].toUpperCase()) : e, At.set(e, t), t) : t;
+}
+var Mt = /* @__PURE__ */ new WeakMap();
+function Nt(e) {
+	let t = Mt.get(e);
+	return t || (t = L(() => Dt(e.value)), Mt.set(e, t)), t;
+}
+function Pt(e) {
+	return {
+		el: e,
+		trackCleanup: (t) => q.trackCleanup(e, t)
+	};
+}
+function Ft(e, t, n) {
+	let r = e.el;
+	dt(r, t, (e) => {
+		let t = n ? n(e) : typeof e == "string" ? e : String(e ?? "");
+		r.textContent !== t && (r.textContent = t);
+	}, "text");
+}
+function It(e, t) {
+	let n = e.el;
+	dt(n, k(t) ? Nt(t) : t, (e) => {
+		n.innerHTML !== e && (q.cleanupDescendants(n), n.innerHTML = e);
+	}, "html");
+}
+function Lt(e, t) {
+	let n = e.el;
+	ft(n, t, (e) => {
+		for (let t in e) {
+			let r = e[t], i = t.trim().split(/\s+/).filter(Boolean);
+			r ? n.classList.add(...i) : n.classList.remove(...i);
+		}
+	}, "class");
+}
+function Rt(e, t) {
+	let n = e.el, r = n.style;
+	q.trackEffect(n, R(() => {
+		for (let e in t) if (B.call(t, e)) {
+			let n = t[e], i = jt(e), [a, o] = Array.isArray(n) ? n : [n, ""], s = k(a) ? a.value : a;
+			O(() => {
+				let e = o ? String(s) + o : String(s);
+				kt(e) || r[i] !== e && (r[i] = e);
+			});
+		}
+	}, { name: "css" }));
+}
+function zt(e, t) {
+	let n = e.el, r = {};
+	for (let e in t) if (B.call(t, e)) {
+		if (e.toLowerCase().startsWith("on")) {
+			console.warn(`${V.BINDING} ${U.SECURITY.BLOCKED_EVENT_HANDLER(e)}`);
+			continue;
+		}
+		r[e] = t[e];
+	}
+	ft(n, r, (e) => {
+		for (let t in e) {
+			let r = e[t], i = t.toLowerCase().startsWith("aria-");
+			if (r == null || r === !1 && !i) {
+				n.removeAttribute(t);
+				continue;
+			}
+			let a = r === !0 ? i ? "true" : t : String(r);
+			if (Ot(t, a)) {
+				console.warn(`${V.BINDING} ${U.SECURITY.BLOCKED_PROTOCOL(t)}`);
+				continue;
+			}
+			n.getAttribute(t) !== a && n.setAttribute(t, a);
+		}
+	}, "attr");
+}
+function Bt(e, t) {
+	let n = e.el, r = {};
+	for (let e in t) if (B.call(t, e)) {
+		if (e.toLowerCase().startsWith("on")) {
+			console.warn(`${V.BINDING} ${U.SECURITY.BLOCKED_EVENT_HANDLER(e)}`);
+			continue;
+		}
+		if (Pe.has(e)) {
+			console.warn(`${V.BINDING} ${U.SECURITY.BLOCKED_PROP(e)}`);
+			continue;
+		}
+		r[e] = t[e];
+	}
+	ft(e.el, r, (e) => {
+		for (let t in e) {
+			let r = e[t], i = t.toLowerCase();
+			if (Ne.has(i) && typeof r == "string" && Ot(t, r)) {
+				console.warn(`${V.BINDING} ${U.SECURITY.BLOCKED_PROTOCOL(t)}`);
+				continue;
+			}
+			n[t] !== r && (n[t] = r);
+		}
+	}, "prop");
+}
+function Vt(e, t, n) {
+	let r = e.el, i = n ? "hide" : "show", a = r.style.display, o = a === "none" ? "" : a;
+	dt(r, t, (e) => {
+		let t = n === !!e ? "none" : o;
+		r.style.display !== t && (r.style.display = t);
+	}, i);
+}
+function Ht(t, n, r = {}) {
+	let i = t.el.tagName.toLowerCase();
+	if (!Me.has(i)) {
+		console.warn(`${V.BINDING} ${U.BINDING.INVALID_INPUT_ELEMENT(i)}`);
+		return;
+	}
+	let { fx: a, cleanup: o } = ut(e(t.el), n, r);
+	q.trackEffect(t.el, a), t.trackCleanup(o);
+}
+function Ut(t, n) {
+	let r = t.el, i = e(r), a = r.type === "radio", o = () => {
+		let t = r.checked;
+		if (n.peek() !== t && (n.value = t, a && t && r.name)) {
+			let t = r.name.replace(/"/g, "\\\"");
+			(r.form ? e(r.form) : e(document)).find(`input[type="radio"][name="${t}"]`).not(r).trigger("change.atomRadioSync");
+		}
+	};
+	o[tt] = !0, i.on("change change.atomRadioSync", o), t.trackCleanup(() => i.off("change change.atomRadioSync", o));
+	let s = R(() => {
+		let e = !!n.value;
+		O(() => {
+			r.checked !== e && (r.checked = e, W.enabled && W.domUpdated(V.BINDING, r, "checked", e));
+		});
+	});
+	q.trackEffect(r, s);
+}
+function Wt(t, n) {
+	let r = e(t.el);
+	r.on(n), t.trackCleanup(() => r.off(n));
+}
+function Gt(t, n, r) {
+	let i = e(t.el);
+	i.on(n, r), t.trackCleanup(() => i.off(n, r));
+}
+function Kt(e) {
+	q.cleanupTree(e);
+}
+//#endregion
+//#region src/bindings/chainable.ts
+function Z(e, t) {
+	for (let n = 0, r = e.length; n < r; n++) {
+		let r = e[n];
+		r.nodeType === 1 ? t(Pt(r), r) : W.enabled && W.log(V.BINDING, `Skipping non-Element node (nodeType=${r.nodeType})`);
+	}
+	return e;
+}
+e.fn.atomText = function(e, t) {
+	return Z(this, (n) => Ft(n, e, t));
+}, e.fn.atomHtml = function(e) {
+	return Z(this, (t) => It(t, e));
+}, e.fn.atomClass = function(e, t) {
+	if (typeof e == "string" && t === void 0) return console.warn(`${V.BINDING} ${U.BINDING.MISSING_CONDITION("atomClass")}`), this;
+	let n = typeof e == "string" ? { [e]: t } : e;
+	return Z(this, (e) => Lt(e, n));
+}, e.fn.atomCss = function(e, t, n) {
+	if (typeof e == "string" && t === void 0) return console.warn(`${V.BINDING} ${U.BINDING.MISSING_SOURCE("atomCss")}`), this;
+	let r = typeof e == "string" ? { [e]: n ? [t, n] : t } : e;
+	return Z(this, (e) => Rt(e, r));
+}, e.fn.atomAttr = function(e, t) {
+	if (typeof e == "string" && t === void 0) return console.warn(`${V.BINDING} ${U.BINDING.MISSING_SOURCE("atomAttr")}`), this;
+	let n = typeof e == "string" ? { [e]: t } : e;
+	return Z(this, (e) => zt(e, n));
+}, e.fn.atomProp = function(e, t) {
+	if (typeof e == "string" && t === void 0) return console.warn(`${V.BINDING} ${U.BINDING.MISSING_SOURCE("atomProp")}`), this;
+	let n = typeof e == "string" ? { [e]: t } : e;
+	return Z(this, (e) => Bt(e, n));
+}, e.fn.atomShow = function(e) {
+	return Z(this, (t) => Vt(t, e, !1));
+}, e.fn.atomHide = function(e) {
+	return Z(this, (t) => Vt(t, e, !0));
+}, e.fn.atomVal = function(e, t = {}) {
+	return Z(this, (n) => Ht(n, e, t));
+}, e.fn.atomChecked = function(e) {
+	return Z(this, (t) => Ut(t, e));
+}, e.fn.atomOn = function(e, t) {
+	return Z(this, (n) => Gt(n, e, t));
+}, e.fn.atomBind = function(e) {
+	let { text: t, html: n, class: r, css: i, attr: a, prop: o, show: s, hide: c, val: l, checked: u, on: d } = e, f = l === void 0 ? null : Array.isArray(l) ? {
+		atom: l[0],
+		opts: l[1]
+	} : {
+		atom: l,
+		opts: void 0
+	};
+	return Z(this, (e) => {
+		t !== void 0 && Ft(e, t), n !== void 0 && It(e, n), r !== void 0 && Lt(e, r), i !== void 0 && Rt(e, i), a !== void 0 && zt(e, a), o !== void 0 && Bt(e, o), s !== void 0 && Vt(e, s, !1), c !== void 0 && Vt(e, c, !0), f !== null && Ht(e, f.atom, f.opts), u !== void 0 && Ut(e, u), d !== void 0 && Wt(e, d);
+	});
+}, e.fn.atomUnbind = function() {
+	for (let e = 0, t = this.length; e < t; e++) {
+		let t = this[e];
+		t.nodeType === 1 && Kt(t);
+	}
+	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);
-  }
-  return this;
+//#endregion
+//#region src/bindings/list.ts
+var qt = /* @__PURE__ */ new WeakMap(), Jt = 0, Yt = new Je(() => /* @__PURE__ */ new Map(), (e) => e.clear()), Xt = new Je(() => /* @__PURE__ */ new Set(), (e) => e.clear()), Q = new qe(100, 1024);
+function Zt(e, t, n) {
+	t?.isConnected ? e.insertBefore(t) : e.appendTo(n);
+}
+function $(t) {
+	return t instanceof Element ? e(t) : t;
+}
+var Qt = class {
+	constructor(e, t, n) {
+		this.$container = e, this.containerSelector = t, this.onRemove = n, this.oldKeys = [], this.oldItems = [], this.oldNodes = [], this.removingKeys = /* @__PURE__ */ new Set(), this.$emptyEl = null, this.keyToIndex = /* @__PURE__ */ new Map(), this.statesBuffer = new Uint8Array(256), this.indicesBuffer = new Int32Array(256);
+	}
+	scheduleRemoval(e, t) {
+		let n = () => {
+			this.fx?.isDisposed || (t.remove(), this.removingKeys.delete(e), W.log(V.LIST, `${this.containerSelector} removed item:`, e));
+		};
+		if (!this.onRemove) {
+			n();
+			return;
+		}
+		let r = this.onRemove(t);
+		r instanceof Promise ? r.then(n, n) : n();
+	}
+	removeItem(e, t) {
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e];
+			n instanceof Element && n.removeAttribute("data-atom-key");
+		}
+		this.removingKeys.add(e), this.scheduleRemoval(e, t);
+	}
+	dispose() {
+		this.removingKeys.clear(), this.oldKeys.length = 0, this.oldItems.length = 0, this.oldNodes.length = 0, this.keyToIndex.clear(), this.$emptyEl?.remove(), this.$container.off(".atomList");
+		let e = new Uint8Array(), t = new Int32Array();
+		this.statesBuffer = e, this.indicesBuffer = t;
+	}
+	ensureBuffers(e) {
+		this.statesBuffer.length < e && (this.statesBuffer = new Uint8Array(Math.max(e, this.statesBuffer.length * 2))), this.indicesBuffer.length < e && (this.indicesBuffer = new Int32Array(Math.max(e, this.indicesBuffer.length * 2)));
+	}
 };
-l.fn.atomUnbind = function() {
-  for (let s = 0, t = this.length; s < t; s++)
-    Ue(this[s]);
-  return this;
+function $t(t, n, r, i) {
+	if (t.$emptyEl && n > 0 && (t.$emptyEl.remove(), t.$emptyEl = null), n !== 0) return;
+	let { oldKeys: a, oldNodes: o, onRemove: s } = t;
+	if (s) for (let e = 0, n = a.length; e < n; e++) {
+		let n = a[e], r = o[e];
+		r && t.removeItem(n, $(r));
+	}
+	else {
+		for (let e = 0, n = a.length; e < n; e++) t.removingKeys.delete(a[e]);
+		r.empty();
+	}
+	i && !t.$emptyEl && (t.$emptyEl = e(typeof i == "string" ? Dt(i) : i).appendTo(r)), Q.release(t.oldKeys), Q.release(t.oldItems), Q.release(t.oldNodes), t.oldKeys = [], t.oldItems = [], t.oldNodes = [];
+}
+function en(e, t, n, r, i, a) {
+	let { oldKeys: o, oldItems: s, oldNodes: c, removingKeys: l, keyToIndex: u } = e, d = o.length, f = 0, p = d - 1, m = n - 1;
+	for (; f <= p && f <= m;) {
+		let e = t[f], n = r(e, f);
+		if (o[f] !== n) break;
+		let i = s[f];
+		if (!(a ? a(i, e) : ke(i, e))) break;
+		u.set(n, f), f++;
+	}
+	for (; p >= f && m >= f;) {
+		let e = t[m], n = r(e, m);
+		if (o[p] !== n) break;
+		let i = s[p];
+		if (!(a ? a(i, e) : ke(i, e))) break;
+		u.set(n, m), p--, m--;
+	}
+	let h = Yt.acquire();
+	for (let e = f; e <= p; e++) h.set(o[e], e);
+	let g = Q.acquire();
+	g.length = n;
+	let _ = Xt.acquire();
+	e.ensureBuffers(n);
+	let v = Q.acquire();
+	v.length = n;
+	let y = Q.acquire();
+	y.length = n;
+	let b = e.statesBuffer, x = e.indicesBuffer, S = Q.acquire(), C = Q.acquire(), w = Q.acquire();
+	for (let e = 0; e < f; e++) g[e] = o[e], v[e] = t[e], y[e] = c[e], b[e] = 3, x[e] = e;
+	for (let e = d - 1, r = n - 1; r > m; r--, e--) g[r] = o[e], v[r] = t[r], y[r] = c[e], b[r] = 3, x[r] = e;
+	for (let n = f; n <= m; n++) {
+		let o = t[n], d = r(o, n);
+		if (g[n] = d, v[n] = o, u.set(d, n), _.has(d)) {
+			W.warn(V.LIST, U.LIST.DUPLICATE_KEY(d, n, e.containerSelector)), x[n] = -1;
+			continue;
+		}
+		_.add(d);
+		let f = h.get(d);
+		if (f === void 0) {
+			S.push(d), C.push(o), w.push(n), x[n] = -1, b[n] = 1;
+			continue;
+		}
+		let p = s[f];
+		y[n] = c[f];
+		let m = a ? a(p, o) : ke(p, o);
+		!i && p !== o && !m ? (S.push(d), C.push(o), w.push(n), b[n] = 2) : b[n] = 0, x[n] = l.has(d) ? -1 : f;
+	}
+	return Yt.release(h), {
+		newKeys: g,
+		newKeySet: _,
+		newItems: v,
+		newNodes: y,
+		newStates: b,
+		newIndices: x,
+		trKeys: S,
+		trItems: C,
+		trIdxs: w,
+		startIndex: f,
+		oldEndIndex: p,
+		newEndIndex: m
+	};
+}
+function tn(t, n, r) {
+	let { trKeys: i, trItems: a, trIdxs: o, newNodes: s, newStates: c } = t, l = i.length, u = n.render, d = Array(l), f = [], p = 0;
+	for (let e = 0; e < l; e++) {
+		let t = u(a[e], o[e]);
+		d[e] = t, typeof t == "string" && (f.push(t), p++);
+	}
+	let m = null, h = f.length;
+	if (h > 0) if (h === 1) m = [Dt(f[0])];
+	else {
+		let e = `<template data-atom-sep="${(Jt++).toString(36)}"></template>`;
+		m = Dt(f.join(e)).split(e);
+	}
+	if (r && m && p === l && !n.bind && !n.onAdd && !n.onRemove && !n.events) return m;
+	let g = 0;
+	for (let t = 0; t < l; t++) {
+		let n = d[t], r = e(typeof n == "string" ? m[g++] : n), a = o[t], l = c[a], u = i[t], f = String(u);
+		for (let e = 0, t = r.length; e < t; e++) {
+			let t = r[e];
+			t instanceof Element && t.setAttribute("data-atom-key", f);
+		}
+		if (l === 2) {
+			let e = s[a];
+			if (e) {
+				let t = $(e);
+				for (let e = 0, n = t.length; e < n; e++) {
+					let n = t[e];
+					n && q.cleanupTree(n);
+				}
+				t.replaceWith(r);
+			}
+		}
+		s[a] = r.length === 1 ? r[0] : r;
+	}
+	return null;
+}
+function nn(e, t) {
+	let { startIndex: n, oldEndIndex: r, newKeySet: i } = t, { oldKeys: a, oldNodes: o } = e;
+	for (let t = n; t <= r; t++) {
+		let n = a[t];
+		if (i.has(n)) continue;
+		let r = o[t];
+		r && e.removeItem(n, $(r));
+	}
+}
+function rn(t, n, r, i, a, o) {
+	let { bind: s, update: c, onAdd: l } = a, { newKeys: u, newItems: d, newNodes: f, newStates: p, newIndices: m } = n, h = u.length, g = t.oldKeys.length === 0;
+	if (o !== null) {
+		r.innerHTML = o.join("");
+		let n = r.firstElementChild;
+		for (let r = 0; r < h && n; r++) {
+			let i = u[r];
+			n.setAttribute("data-atom-key", String(i)), f[r] = n, p[r] = 0, t.removingKeys.delete(i), W.enabled && W.domUpdated(V.LIST, e(n), "list.add", d[r]), n = n.nextElementSibling;
+		}
+		return;
+	}
+	if (g) {
+		let e = document.createDocumentFragment();
+		for (let t = 0; t < h; t++) {
+			let n = f[t];
+			if (n instanceof Element) e.appendChild(n);
+			else for (let t = 0; t < n.length; t++) e.appendChild(n[t]);
+		}
+		r.appendChild(e);
+	} else {
+		let e = null, t = 2147483647;
+		for (let n = h - 1; n >= 0; n--) {
+			let r = m[n], a = f[n];
+			r !== -1 && r < t ? t = r : Zt($(a), e, i), e = a instanceof Element ? a : a[0] ?? null;
+		}
+	}
+	for (let e = 0; e < h; e++) {
+		let n = f[e], r = p[e];
+		if (r !== 3) {
+			let i = $(n), a = d[e];
+			if (r === 0 ? c?.(i, a, e) : s?.(i, a, e), r === 1) {
+				l?.(i);
+				let n = u[e];
+				t.removingKeys.delete(n), W.enabled && W.domUpdated(V.LIST, i, "list.add", d[e]);
+			}
+		}
+	}
+}
+e.fn.atomList = function(t, n) {
+	let { key: r, bind: i, update: a, onAdd: o, onRemove: s, empty: c, events: l, isEqual: u } = n, d = typeof r == "function" ? r : (e, t) => e[r], f = {
+		bind: i,
+		update: a,
+		onAdd: o,
+		onRemove: s,
+		events: l
+	};
+	for (let r = 0, i = this.length; r < i; r++) {
+		let i = this[r], o = e(i);
+		o.off(".atomList");
+		let p = qt.get(i);
+		p && (p.fx.dispose(), p.ctx.dispose());
+		let m = z(i), h = new Qt(o, m, s), g = R(() => {
+			let e = t.value, r = e.length;
+			O(() => {
+				if ($t(h, r, o, c), r === 0) return;
+				W.log(V.LIST, `${m} updating with ${r} items`);
+				let t = en(h, e, r, d, a, u), s = tn(t, n, h.oldKeys.length === 0);
+				if (nn(h, t), rn(h, t, i, o, f, s), l) {
+					let { startIndex: e, oldEndIndex: n, newKeySet: r } = t;
+					for (let t = e; t <= n; t++) {
+						let e = h.oldKeys[t];
+						r.has(e) || h.keyToIndex.delete(e);
+					}
+				}
+				Q.release(h.oldKeys), Q.release(h.oldItems), Q.release(h.oldNodes), h.oldKeys = t.newKeys, h.oldItems = t.newItems, h.oldNodes = t.newNodes, Xt.release(t.newKeySet), Q.release(t.trKeys), Q.release(t.trItems), Q.release(t.trIdxs);
+			});
+		});
+		if (h.fx = g, l) for (let e in l) {
+			if (!B.call(l, e)) continue;
+			let t = l[e], n = e.indexOf(" "), r = n === -1 ? e : e.slice(0, n), i = (n === -1 ? null : e.slice(n + 1).trim()) || "> *";
+			o.on(`${r}.atomList`, i, function(e) {
+				let n = e.target.closest?.("[data-atom-key]");
+				if (!n) return;
+				let r = n.getAttribute("data-atom-key");
+				if (r === null) return;
+				let i = r;
+				if (!h.keyToIndex.has(r)) {
+					let e = Number(r);
+					!Number.isNaN(e) && h.keyToIndex.has(e) && (i = e);
+				}
+				let a = h.keyToIndex.get(i);
+				a !== void 0 && t.call(n, h.oldItems[a], a, e);
+			});
+		}
+		q.trackEffect(i, g), qt.set(i, {
+			fx: g,
+			ctx: h
+		}), q.trackCleanup(i, () => {
+			h.dispose(), qt.delete(i);
+		});
+	}
+	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);
-    };
-    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 = $;
-      });
-    }), y.trackEffect(p, bt), y.trackCleanup(p, () => {
-      C.clear(), I.clear(), R.length = 0, Y?.remove();
-    });
-  }
-  return this;
+//#endregion
+//#region src/bindings/mount.ts
+var an = Object.freeze({});
+e.fn.atomMount = function(t, n) {
+	let r = n ?? an;
+	for (let n = 0, i = this.length; n < i; n++) {
+		let i = this[n];
+		if (!i) continue;
+		q.cleanupTree(i);
+		let a = e(i), o;
+		try {
+			o = O(() => t(a, r));
+		} catch (e) {
+			W.error(V.MOUNT, U.MOUNT.ERROR(t.name), e);
+			continue;
+		}
+		typeof o == "function" && q.setComponentCleanup(i, o);
+	}
+	return this;
+}, e.fn.atomUnmount = function() {
+	for (let e = 0, t = this.length; e < t; e++) {
+		let t = this[e];
+		t && Kt(t);
+	}
+	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];
-    if (!o) continue;
-    y.cleanupTree(o);
-    const r = l(o);
-    let c;
-    try {
-      c = H(() => s(r, e));
-    } catch (E) {
-      f.error(g.MOUNT, T.MOUNT_ERROR(), E);
-      continue;
-    }
-    typeof c == "function" && y.setComponentCleanup(o, c);
-  }
-  return this;
+//#endregion
+//#region src/features/route.ts
+function on(e, t) {
+	try {
+		return history.pushState(e, "", t), !0;
+	} catch (e) {
+		return W.warn(V.ROUTE, "PushState failed (likely file:// protocol or security restriction). UI will update, but URL will not.", e), !1;
+	}
+}
+var sn = class {
+	constructor(t) {
+		this.isDestroyed = !1, this.previousRoute = "", this.cleanups = [], this.templateCache = /* @__PURE__ */ new Map(), this.routeCleanups = [], this.lastRawQuery = "", this.cachedParams = {}, this.config = {
+			...t,
+			mode: t.mode ?? H.mode,
+			basePath: t.basePath ?? H.basePath,
+			autoBindLinks: t.autoBindLinks ?? H.autoBindLinks,
+			activeClass: t.activeClass ?? H.activeClass
+		}, this.isHistoryMode = this.config.mode === "history", this.$target = e(this.config.target), this.normalizedBasePath = this.config.basePath?.replace(/\/$/, "") || "", this.activeClass = this.config.activeClass ?? H.activeClass, this.previousUrl = this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash, this.currentRouteAtom = ve(this.getRouteName()), this.currentRoute = this.currentRouteAtom, this.queryParamsAtom = ve(this.getQueryParams()), this.queryParams = L(() => this.queryParamsAtom.value), this.handleUrlChange = this.handleUrlChange.bind(this), this.destroy = this.destroy.bind(this), this.init();
+	}
+	init() {
+		let e = this.isHistoryMode ? "popstate" : "hashchange";
+		window.addEventListener(e, this.handleUrlChange), this.cleanups.push(() => window.removeEventListener(e, this.handleUrlChange));
+		let t = R(() => {
+			let e = this.currentRouteAtom.value;
+			O(() => {
+				let e = this.routeCleanups;
+				for (let t = 0, n = e.length; t < n; t++) try {
+					e[t]();
+				} catch (e) {
+					W.warn(V.ROUTE, "Cleanup error during route transition:", e);
+				}
+				e.length = 0;
+			}), this.renderRoute(e);
+		});
+		this.cleanups.push(() => t.dispose()), this.setupAutoBindLinks(), this.$target[0] && q.trackCleanup(this.$target[0], this.destroy);
+	}
+	getRouteName() {
+		let e = this.config.default;
+		if (this.isHistoryMode) {
+			let t = window.location.pathname, n = 0, r = this.normalizedBasePath;
+			return r && t.startsWith(r) && (n = r.length), t.charCodeAt(n) === 47 && n++, (n === 0 ? t : t.substring(n)) || e;
+		}
+		let t = window.location.hash;
+		if (t.length <= 1) return e;
+		let n = t.indexOf("?");
+		return (n === -1 ? t.substring(1) : t.substring(1, n)) || e;
+	}
+	getQueryParams() {
+		let e = "";
+		if (this.isHistoryMode) e = window.location.search.substring(1);
+		else {
+			let t = window.location.hash, n = t.indexOf("?");
+			n !== -1 && (e = t.substring(n + 1));
+		}
+		if (e === this.lastRawQuery) return this.cachedParams;
+		let t = {};
+		e && new URLSearchParams(e).forEach((e, n) => {
+			t[n] = e;
+		});
+		let n = !1, r = this.cachedParams, i = Object.keys(r), a = Object.keys(t);
+		if (i.length !== a.length) n = !0;
+		else for (let e = 0, i = a.length; e < i; e++) {
+			let i = a[e];
+			if (r[i] !== t[i]) {
+				n = !0;
+				break;
+			}
+		}
+		return n && (this.cachedParams = t), this.lastRawQuery = e, e.includes("%"), this.cachedParams;
+	}
+	setUrl(e) {
+		if (this.isHistoryMode) {
+			let t = `${this.normalizedBasePath}/${e}`;
+			on(null, t), this.previousUrl = t;
+		} else {
+			let t = `#${e}`;
+			window.location.hash = t, this.previousUrl = t;
+		}
+	}
+	restoreUrl() {
+		this.isHistoryMode ? on(null, this.previousUrl) : window.location.hash = this.previousUrl;
+	}
+	getCurrentUrl() {
+		return this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash;
+	}
+	getRouteConfig(e) {
+		let { routes: t, notFound: n } = this.config, r = t[e];
+		return !r && n && (r = t[n]), r || (W.warn(V.ROUTE, U.ROUTE.NOT_FOUND(e)), null);
+	}
+	renderTemplate(e) {
+		let t = this.templateCache.get(e);
+		if (!t) {
+			let n = document.querySelector(e);
+			if (!n || !(n instanceof HTMLTemplateElement)) return W.warn(V.ROUTE, U.ROUTE.TEMPLATE_NOT_FOUND(e)), !1;
+			t = n, this.templateCache.set(e, t);
+		}
+		let n = t.content.cloneNode(!0);
+		return this.$target.append(n), !0;
+	}
+	renderRoute(e) {
+		if (this.isDestroyed) return;
+		let t = this.$target[0];
+		if (!t) {
+			W.warn(V.ROUTE, U.ROUTE.TARGET_NOT_FOUND(this.config.target));
+			return;
+		}
+		let n = this.getRouteConfig(e);
+		if (!n) return;
+		let r = this.getQueryParams(), i = this.previousRoute, { beforeTransition: a, afterTransition: o } = this.config;
+		a && O(() => a(i, e)), this.$target.empty();
+		let s = r, { onEnter: c } = n;
+		if (c) {
+			let e = O(() => c(r, this));
+			e !== void 0 && (s = {
+				...r,
+				...e
+			});
+		}
+		let l = (e) => {
+			this.routeCleanups.push(e);
+		};
+		n.render ? n.render(t, e, s, l, this) : n.template && this.renderTemplate(n.template) && n.onMount && n.onMount(this.$target.children(), l, this), o && O(() => o(i, e)), this.previousRoute = e;
+	}
+	handleUrlChange() {
+		if (this.isDestroyed) return;
+		let e = this.getCurrentUrl();
+		if (e === this.previousUrl) return;
+		let t = this.getRouteName(), n = this.currentRouteAtom.peek(), r = this.getQueryParams();
+		if (n !== t) {
+			let e = this.config.routes[n];
+			if (e?.onLeave && O(() => e.onLeave(this)) === !1) {
+				this.restoreUrl();
+				return;
+			}
+			this.currentRouteAtom.value = t, this.queryParamsAtom.value = r;
+		} else this.queryParamsAtom.value = r;
+		this.previousUrl = e;
+	}
+	setupAutoBindLinks() {
+		if (!this.config.autoBindLinks) return;
+		let t = (e) => {
+			e.preventDefault();
+			let t = e.currentTarget.dataset.route;
+			t != null && this.navigate(t);
+		};
+		e(document).on("click", "[data-route]", t), this.cleanups.push(() => {
+			e(document).off("click", "[data-route]", t);
+		});
+		let n = this.activeClass, r = [], i = R(() => {
+			let e = this.currentRouteAtom.value;
+			O(() => {
+				for (let e = 0, t = r.length; e < t; e++) {
+					let t = r[e];
+					t.classList.remove(n), t.removeAttribute("aria-current");
+				}
+				try {
+					let t = e.replace(/"/g, "\\\""), i = document.querySelectorAll(`[data-route="${t}"]`), a = i.length, o = Array(a);
+					for (let e = 0; e < a; e++) {
+						let t = i[e];
+						t.classList.add(n), t.setAttribute("aria-current", "page"), o[e] = t;
+					}
+					r = o;
+				} catch {
+					r = [];
+				}
+			});
+		});
+		this.cleanups.push(() => i.dispose());
+	}
+	navigate(e) {
+		if (this.isDestroyed) return;
+		let t = this.currentRouteAtom.peek(), n = this.config.routes[t];
+		if (n?.onLeave && n.onLeave(this) === !1) return;
+		let r = e || this.config.default;
+		if (!r) {
+			W.warn(V.ROUTE, "navigate() called with empty routeName and no default configured.");
+			return;
+		}
+		this.setUrl(r), this.queryParamsAtom.value = {}, this.currentRouteAtom.value = r;
+	}
+	destroy() {
+		if (this.isDestroyed) return;
+		this.isDestroyed = !0;
+		let e = this.cleanups;
+		this.cleanups = [];
+		for (let t = 0, n = e.length; t < n; t++) try {
+			e[t]();
+		} catch (e) {
+			W.warn(V.ROUTE, "Cleanup error during destroy:", e);
+		}
+		this.templateCache.clear();
+	}
 };
-l.fn.atomUnmount = function() {
-  for (let s = 0, t = this.length; s < t; s++) {
-    const e = this[s];
-    e && Ue(e);
-  }
-  return this;
+function cn(e) {
+	return new sn(e);
+}
+e.extend({ route: cn });
+//#endregion
+//#region src/features/fetch.ts
+var ln = class {
+	constructor(e, t) {
+		this.abortController = null, this.isStaticUrl = typeof e == "string", this.isStaticUrl ? this.staticUrl = e : this.getUrl = e, typeof t.ajaxOptions == "function" ? (this.ajaxOptionsFn = t.ajaxOptions, this.staticOptions = {}) : this.staticOptions = { ...t.ajaxOptions }, t.method !== void 0 && (this.staticOptions.method = t.method), t.headers !== void 0 && (this.staticOptions.headers = {
+			...this.staticOptions.headers,
+			...t.headers
+		}), this.transformFn = t.transform, this.onErrorFn = t.onError, this.execute = this.execute.bind(this);
+	}
+	abort() {
+		this.abortController?.abort();
+	}
+	async execute() {
+		this.abortController?.abort(), this.abortController = new AbortController();
+		let t = this.abortController.signal, n = this.ajaxOptionsFn ? this.ajaxOptionsFn() : {}, r = e.extend(!0, {}, this.staticOptions, n);
+		r.success = void 0, r.error = void 0, r.complete = void 0, r.url = this.isStaticUrl ? this.staticUrl : this.getUrl();
+		let i = e.ajax(r);
+		t.onabort = () => i.abort(), t.aborted && i.abort();
+		let a;
+		try {
+			a = await i;
+		} catch (e) {
+			if (t.aborted) {
+				let e = /* @__PURE__ */ Error("AbortError");
+				throw e.name = "AbortError", e;
+			}
+			let n;
+			if (e && e.readyState !== void 0) {
+				let t = e;
+				n = /* @__PURE__ */ Error(`Network Error: ${t.statusText || "Unknown"} (${t.status})`), n.jqXHR = t;
+			} else n = e instanceof Error ? e : Error(String(e ?? "Unknown network error"));
+			let r = this.onErrorFn;
+			if (r) try {
+				r(n);
+			} catch {}
+			throw n;
+		} finally {
+			t.onabort = null, this.abortController?.signal === t && (this.abortController = null);
+		}
+		let o = this.transformFn;
+		if (o) try {
+			return o(a);
+		} catch (e) {
+			let t = this.onErrorFn;
+			if (t) try {
+				t(e);
+			} catch {}
+			throw e;
+		}
+		return a;
+	}
 };
-function he(s, t) {
-  try {
-    return history.pushState(s, "", t), !0;
-  } catch (e) {
-    return f.warn(
-      g.ROUTE,
-      "PushState failed (likely file:// protocol or security restriction). UI will update, but URL will not.",
-      e
-    ), !1;
-  }
-}
-class Bs {
-  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();
-  }
-  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));
-    });
-    this.cleanups.push(() => e.dispose()), this.setupAutoBindLinks(), this.$target[0] && y.trackCleanup(this.$target[0], this.destroy);
-  }
-  // --- Mode-abstracted internal methods ---
-  /**
-   * Extracts route name from current URL.
-   * Uses `normalizedBasePath` for consistent stripping in history mode.
-   */
-  getRouteName() {
-    const { default: t } = this.config;
-    if (this.isHistoryMode) {
-      let 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;
-  }
-  /**
-   * Parses query parameters from the current URL.
-   *
-   * Note: duplicate keys (e.g. `?a=1&a=2`) are collapsed to the last value
-   * only (`{ a: '2' }`). This matches `URLSearchParams` → `Object.fromEntries`
-   * behaviour. If multi-value keys are needed, access `queryParams` via
-   * `new URLSearchParams(window.location.search).getAll('key')` directly.
-   */
-  getQueryParams() {
-    let t;
-    if (this.isHistoryMode) {
-      if (t = window.location.search.substring(1), !t) return {};
-    } else {
-      const i = window.location.hash, o = i.indexOf("?");
-      if (o === -1) return {};
-      t = i.substring(o + 1);
-    }
-    const e = new URLSearchParams(t), n = Object.fromEntries(e);
-    if (t.includes("%"))
-      try {
-        decodeURIComponent(t);
-      } catch {
-        f.warn(g.ROUTE, T.MALFORMED_URI(t));
-      }
-    return n;
-  }
-  /**
-   * Updates the browser URL to reflect a new route and keeps `previousUrl`
-   * in sync so `handleUrlChange` does not re-process our own navigation.
-   */
-  setUrl(t) {
-    if (this.isHistoryMode) {
-      const e = `${this.normalizedBasePath}/${t}`;
-      he(null, e), this.previousUrl = e;
-    } else {
-      const e = `#${t}`;
-      window.location.hash = e, this.previousUrl = e;
-    }
-  }
-  /**
-   * Restores the URL when a navigation guard blocks the transition.
-   * Uses pushState to safely add a new history entry, avoiding "back button traps"
-   * that occur with replaceState during popstate events.
-   */
-  restoreUrl() {
-    this.isHistoryMode ? he(null, this.previousUrl) : window.location.hash = this.previousUrl;
-  }
-  /**
-   * Returns the current full URL string for comparison purposes.
-   */
-  getCurrentUrl() {
-    return this.isHistoryMode ? window.location.pathname + window.location.search : window.location.hash;
-  }
-  // --- End mode-abstracted methods ---
-  /**
-   * Resolves route configuration, falling back to notFound route if needed.
-   */
-  getRouteConfig(t) {
-    const { routes: e, notFound: n } = this.config;
-    let i = e[t];
-    return !i && n && (i = e[n]), i || (f.warn(g.ROUTE, T.ROUTE_NOT_FOUND(t)), null);
-  }
-  /**
-   * Appends cloned template content into the target container.
-   * Always appends — callers are responsible for calling `$target.empty()`
-   * before invoking this method if a clean slate is needed.
-   */
-  renderTemplate(t) {
-    let e = this.templateCache.get(t);
-    if (!e) {
-      const i = document.querySelector(t);
-      if (!i || !(i instanceof HTMLTemplateElement))
-        return f.warn(g.ROUTE, T.TEMPLATE_NOT_FOUND(t)), !1;
-      e = i, this.templateCache.set(t, e);
-    }
-    const n = e.content.cloneNode(!0);
-    return this.$target.append(n), !0;
-  }
-  /**
-   * Renders the specified route, including lifecycle hooks and content.
-   *
-   * Called from within a reactive effect, so DOM mutations here run
-   * synchronously inside the effect body. `registry.cleanupDescendants` is
-   * called before `$target.empty()` to ensure any reactive bindings on
-   * outgoing content are disposed before the nodes are removed — preventing
-   * the MutationObserver auto-cleanup path from firing a redundant cleanup.
-   *
-   * If `beforeTransition` throws, the render is aborted and the outgoing
-   * content remains in the DOM. This is intentional — a throwing hook signals
-   * that the transition should not proceed.
-   */
-  renderRoute(t) {
-    if (this.isDestroyed) return;
-    const e = this.$target[0];
-    if (!e) {
-      f.warn(g.ROUTE, T.TARGET_NOT_FOUND(this.config.target));
-      return;
-    }
-    const n = this.getRouteConfig(t);
-    if (!n) 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);
-      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;
-  }
-  /**
-   * Handles browser URL change events (hashchange or popstate).
-   */
-  handleUrlChange() {
-    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];
-      if (o?.onLeave && o.onLeave() === !1) {
-        this.restoreUrl();
-        return;
-      }
-      this.currentRouteAtom.value = e, this.queryParamsAtom.value = i;
-    } else {
-      this.queryParamsAtom.value = i;
-      const o = this.config.routes[n];
-      o?.onParamsChange ? o.onParamsChange(i) : this.renderRoute(e);
-    }
-    this.previousUrl = t;
-  }
-  /**
-   * Sets up automatic binding for navigation links with data-route attribute.
-   *
-   * Event delegation is attached to `document` (not `$target`) so that
-   * `[data-route]` links anywhere in the page — including outside the router's
-   * target container — can trigger navigation. This is intentional: nav links
-   * typically live in headers or sidebars, not inside the routed content area.
-   *
-   * Active-link management uses a reactive effect that re-runs only when
-   * `currentRoute` changes — more efficient than a persistent MutationObserver.
-   */
-  setupAutoBindLinks() {
-    if (!this.config.autoBindLinks) return;
-    const t = (i) => {
-      i.preventDefault();
-      const 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);
-    });
-    const { activeClass: e } = this.config, n = X(() => {
-      const i = this.currentRouteAtom.value;
-      H(() => {
-        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");
-        }
-      });
-    });
-    this.cleanups.push(() => n.dispose());
-  }
-  /**
-   * Navigates to the specified route programmatically.
-   *
-   * If `routeName` resolves to an empty string after falling back to
-   * `config.default`, `setUrl` will be called with an empty string, producing
-   * a URL of `${basePath}/` in history mode. Callers should ensure
-   * `config.default` is always a non-empty route name.
-   */
-  navigate(t) {
-    if (this.isDestroyed) return;
-    const e = this.currentRouteAtom.peek(), n = this.config.routes[e];
-    if (n?.onLeave && n.onLeave() === !1)
-      return;
-    const i = t || this.config.default;
-    if (!i) {
-      f.warn(
-        g.ROUTE,
-        "navigate() called with empty routeName and no default configured."
-      );
-      return;
-    }
-    this.setUrl(i), this.queryParamsAtom.value = {}, this.currentRouteAtom.value = i;
-  }
-  /**
-   * Cleans up all event listeners and effects, and releases the template cache.
-   * Each cleanup function is called in a try/catch so that a single failing
-   * cleanup does not prevent the remaining ones from running.
-   */
-  destroy() {
-    if (this.isDestroyed) return;
-    this.isDestroyed = !0;
-    const t = this.cleanups;
-    for (let e = 0, n = t.length; e < n; e++)
-      try {
-        t[e]();
-      } catch (i) {
-        f.warn(g.ROUTE, "Cleanup error during destroy:", i);
-      }
-    this.cleanups.length = 0, this.templateCache.clear();
-  }
-}
-function Hs(s) {
-  return new Bs(s);
-}
-l.extend({
-  route: Hs
-});
-const Gs = new Promise(() => {
-});
-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();
-        try {
-          const R = await I;
-          return n ? n(R) : R;
-        } catch (R) {
-          if (C.aborted)
-            return Gs;
-          try {
-            c?.(R);
-          } catch {
-          }
-          throw R;
-        } finally {
-          C.onabort = null, O.signal === C && (O = null);
-        }
-      },
-      { defaultValue: e, lazy: !(E ?? !0) }
-    );
-  }
+//#endregion
+//#region src/index.ts
+e.extend({ atomFetch(e, t) {
+	let n = new ln(e, t), r = !(t.eager ?? !0), i = L(n.execute, {
+		defaultValue: t.defaultValue,
+		lazy: r
+	});
+	return Object.assign(i, { abort: () => n.abort() });
+} }), e(() => {
+	ot(), $e(document.body);
 });
-l(() => {
-  As(), Os(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
-};
-//# sourceMappingURL=index.mjs.map
+var un = e;
+//#endregion
+export { ve as atom, De as batch, L as computed, un as default, et as disableAutoCleanup, st as disablejQueryOverrides, R as effect, $e as enableAutoCleanup, ot as enablejQueryOverrides, k as isAtom, be as isComputed, Oe as isReactive, Ge as nextTick, q as registry, O as untracked };
+
+//# sourceMappingURL=index.mjs.map