@but212/atom-effect-jquery 0.23.0 → 0.24.1

package/dist/index.mjs

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