likec4 1.56.0 → 1.58.0

package/__app__/src/chunks/libs/@xstate/react.mjs

@@ -0,0 +1,1982 @@
+import { i as e } from "../../rolldown-runtime.mjs";
+import { useCallback as t, useEffect as n, useLayoutEffect as r, useState as i } from "react";
+import { useSyncExternalStoreWithSelector as a } from "use-sync-external-store/shim/with-selector";
+//#region ../../node_modules/.pnpm/use-isomorphic-layout-effect@1.2.1_@types+react@19.2.16_react@19.2.7/node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js
+var o = r;
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.0/node_modules/xstate/dist/xstate-dev.esm.js
+function getGlobal() {
+	if (typeof globalThis < "u") return globalThis;
+	if (typeof self < "u") return self;
+	if (typeof window < "u") return window;
+	if (typeof global < "u") return global;
+}
+function getDevTools() {
+	let e = getGlobal();
+	if (e.__xstate__) return e.__xstate__;
+}
+var devToolsAdapter = (e) => {
+	if (typeof window > "u") return;
+	let t = getDevTools();
+	t && t.register(e);
+}, Mailbox = class {
+	constructor(e) {
+		this._process = e, this._active = !1, this._current = null, this._last = null;
+	}
+	start() {
+		this._active = !0, this.flush();
+	}
+	clear() {
+		this._current && (this._current.next = null, this._last = this._current);
+	}
+	enqueue(e) {
+		let t = {
+			value: e,
+			next: null
+		};
+		if (this._current) {
+			this._last.next = t, this._last = t;
+			return;
+		}
+		this._current = t, this._last = t, this._active && this.flush();
+	}
+	flush() {
+		for (; this._current;) {
+			let e = this._current;
+			this._process(e.value), this._current = e.next;
+		}
+		this._last = null;
+	}
+}, s = "", c = "#", l = "*", u = "xstate.init", d = "xstate.stop";
+function createAfterEvent(e, t) {
+	return { type: `xstate.after.${e}.${t}` };
+}
+function createDoneStateEvent(e, t) {
+	return {
+		type: `xstate.done.state.${e}`,
+		output: t
+	};
+}
+function createDoneActorEvent(e, t) {
+	return {
+		type: `xstate.done.actor.${e}`,
+		output: t,
+		actorId: e
+	};
+}
+function createErrorActorEvent(e, t) {
+	return {
+		type: `xstate.error.actor.${e}`,
+		error: t,
+		actorId: e
+	};
+}
+function createInitEvent(e) {
+	return {
+		type: u,
+		input: e
+	};
+}
+function reportUnhandledError(e) {
+	setTimeout(() => {
+		throw e;
+	});
+}
+var f = typeof Symbol == "function" && Symbol.observable || "@@observable";
+function matchesState(e, t) {
+	let n = toStateValue(e), r = toStateValue(t);
+	return typeof r == "string" ? typeof n == "string" ? r === n : !1 : typeof n == "string" ? n in r : Object.keys(n).every((e) => e in r ? matchesState(n[e], r[e]) : !1);
+}
+function toStatePath(e) {
+	if (isArray(e)) return e;
+	let t = [], n = "";
+	for (let r = 0; r < e.length; r++) {
+		switch (e.charCodeAt(r)) {
+			case 92:
+				n += e[r + 1], r++;
+				continue;
+			case 46:
+				t.push(n), n = "";
+				continue;
+		}
+		n += e[r];
+	}
+	return t.push(n), t;
+}
+function toStateValue(e) {
+	return isMachineSnapshot(e) ? e.value : typeof e == "string" ? pathToStateValue(toStatePath(e)) : e;
+}
+function pathToStateValue(e) {
+	if (e.length === 1) return e[0];
+	let t = {}, n = t;
+	for (let t = 0; t < e.length - 1; t++) if (t === e.length - 2) n[e[t]] = e[t + 1];
+	else {
+		let r = n;
+		n = {}, r[e[t]] = n;
+	}
+	return t;
+}
+function mapValues(e, t) {
+	let n = {}, r = Object.keys(e);
+	for (let i = 0; i < r.length; i++) {
+		let a = r[i];
+		n[a] = t(e[a], a, e, i);
+	}
+	return n;
+}
+function toArrayStrict(e) {
+	return isArray(e) ? e : [e];
+}
+function toArray(e) {
+	return e === void 0 ? [] : toArrayStrict(e);
+}
+function resolveOutput(e, t, n, r) {
+	return typeof e == "function" ? e({
+		context: t,
+		event: n,
+		self: r
+	}) : e;
+}
+function isArray(e) {
+	return Array.isArray(e);
+}
+function isErrorActorEvent(e) {
+	return e.type.startsWith("xstate.error.actor");
+}
+function toTransitionConfigArray(e) {
+	return toArrayStrict(e).map((e) => e === void 0 || typeof e == "string" ? { target: e } : e);
+}
+function normalizeTarget(e) {
+	if (!(e === void 0 || e === s)) return toArray(e);
+}
+function toObserver(e, t, n) {
+	let r = typeof e == "object", i = r ? e : void 0;
+	return {
+		next: (r ? e.next : e)?.bind(i),
+		error: (r ? e.error : t)?.bind(i),
+		complete: (r ? e.complete : n)?.bind(i)
+	};
+}
+function createInvokeId(e, t) {
+	return `${t}.${e}`;
+}
+function resolveReferencedActor(e, t) {
+	let n = t.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+	if (!n) return e.implementations.actors[t];
+	let [, r, i] = n, a = e.getStateNodeById(i).config.invoke;
+	return (Array.isArray(a) ? a[r] : a).src;
+}
+function matchesEventDescriptor(e, t) {
+	if (t === e || t === l) return !0;
+	if (!t.endsWith(".*")) return !1;
+	let n = t.split("."), r = e.split(".");
+	for (let e = 0; e < n.length; e++) {
+		let t = n[e], i = r[e];
+		if (t === "*") return e === n.length - 1;
+		if (t !== i) return !1;
+	}
+	return !0;
+}
+function createScheduledEventId(e, t) {
+	return `${e.sessionId}.${t}`;
+}
+var p = 0;
+function createSystem(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new WeakMap(), a = /* @__PURE__ */ new Set(), o = {}, { clock: s, logger: c } = t, l = {
+		schedule: (e, t, n, r, i = Math.random().toString(36).slice(2)) => {
+			let a = {
+				source: e,
+				target: t,
+				event: n,
+				delay: r,
+				id: i,
+				startedAt: Date.now()
+			}, c = createScheduledEventId(e, i);
+			u._snapshot._scheduledEvents[c] = a, o[c] = s.setTimeout(() => {
+				delete o[c], delete u._snapshot._scheduledEvents[c], u._relay(e, t, n);
+			}, r);
+		},
+		cancel: (e, t) => {
+			let n = createScheduledEventId(e, t), r = o[n];
+			delete o[n], delete u._snapshot._scheduledEvents[n], r !== void 0 && s.clearTimeout(r);
+		},
+		cancelAll: (e) => {
+			for (let t in u._snapshot._scheduledEvents) {
+				let n = u._snapshot._scheduledEvents[t];
+				n.source === e && l.cancel(e, n.id);
+			}
+		}
+	}, sendInspectionEvent = (t) => {
+		if (!a.size) return;
+		let n = {
+			...t,
+			rootId: e.sessionId
+		};
+		a.forEach((e) => e.next?.(n));
+	}, u = {
+		_snapshot: { _scheduledEvents: (t?.snapshot && t.snapshot.scheduler) ?? {} },
+		_bookId: () => `x:${p++}`,
+		_register: (e, t) => (n.set(e, t), e),
+		_unregister: (e) => {
+			n.delete(e.sessionId);
+			let t = i.get(e);
+			t !== void 0 && (r.delete(t), i.delete(e));
+		},
+		get: (e) => r.get(e),
+		getAll: () => Object.fromEntries(r.entries()),
+		_set: (e, t) => {
+			let n = r.get(e);
+			if (n && n !== t) throw Error(`Actor with system ID '${e}' already exists.`);
+			r.set(e, t), i.set(t, e);
+		},
+		inspect: (e) => {
+			let t = toObserver(e);
+			return a.add(t), { unsubscribe() {
+				a.delete(t);
+			} };
+		},
+		_sendInspectionEvent: sendInspectionEvent,
+		_relay: (e, t, n) => {
+			u._sendInspectionEvent({
+				type: "@xstate.event",
+				sourceRef: e,
+				actorRef: t,
+				event: n
+			}), t._send(n);
+		},
+		scheduler: l,
+		getSnapshot: () => ({ _scheduledEvents: { ...u._snapshot._scheduledEvents } }),
+		start: () => {
+			let e = u._snapshot._scheduledEvents;
+			u._snapshot._scheduledEvents = {};
+			for (let t in e) {
+				let { source: n, target: r, event: i, delay: a, id: o } = e[t];
+				l.schedule(n, r, i, a, o);
+			}
+		},
+		_clock: s,
+		_logger: c
+	};
+	return u;
+}
+var m = !1, h = /* @__PURE__ */ function(e) {
+	return e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped", e;
+}({}), g = {
+	clock: {
+		setTimeout: (e, t) => setTimeout(e, t),
+		clearTimeout: (e) => clearTimeout(e)
+	},
+	logger: console.log.bind(console),
+	devTools: !1
+}, Actor = class {
+	constructor(e, t) {
+		this.logic = e, this._snapshot = void 0, this.clock = void 0, this.options = void 0, this.id = void 0, this.mailbox = new Mailbox(this._process.bind(this)), this.observers = /* @__PURE__ */ new Set(), this.eventListeners = /* @__PURE__ */ new Map(), this.logger = void 0, this._processingStatus = h.NotStarted, this._parent = void 0, this._syncSnapshot = void 0, this.ref = void 0, this._actorScope = void 0, this.systemId = void 0, this.sessionId = void 0, this.system = void 0, this._doneEvent = void 0, this.src = void 0, this._deferred = [];
+		let n = {
+			...g,
+			...t
+		}, { clock: r, logger: i, parent: a, syncSnapshot: o, id: s, systemId: c, inspect: l } = n;
+		this.system = a ? a.system : createSystem(this, {
+			clock: r,
+			logger: i
+		}), l && !a && this.system.inspect(toObserver(l)), this.sessionId = this.system._bookId(), this.id = s ?? this.sessionId, this.logger = t?.logger ?? this.system._logger, this.clock = t?.clock ?? this.system._clock, this._parent = a, this._syncSnapshot = o, this.options = n, this.src = n.src ?? e, this.ref = this, this._actorScope = {
+			self: this,
+			id: this.id,
+			sessionId: this.sessionId,
+			logger: this.logger,
+			defer: (e) => {
+				this._deferred.push(e);
+			},
+			system: this.system,
+			stopChild: (e) => {
+				if (e._parent !== this) throw Error(`Cannot stop child actor ${e.id} of ${this.id} because it is not a child`);
+				e._stop();
+			},
+			emit: (e) => {
+				let t = this.eventListeners.get(e.type), n = this.eventListeners.get("*");
+				if (!t && !n) return;
+				let r = [...t ? t.values() : [], ...n ? n.values() : []];
+				for (let t of r) try {
+					t(e);
+				} catch (e) {
+					reportUnhandledError(e);
+				}
+			},
+			actionExecutor: (e) => {
+				let exec = () => {
+					if (this._actorScope.system._sendInspectionEvent({
+						type: "@xstate.action",
+						actorRef: this,
+						action: {
+							type: e.type,
+							params: e.params
+						}
+					}), !e.exec) return;
+					let t = m;
+					try {
+						m = !0, e.exec(e.info, e.params);
+					} finally {
+						m = t;
+					}
+				};
+				this._processingStatus === h.Running ? exec() : this._deferred.push(exec);
+			}
+		}, this.send = this.send.bind(this), this.system._sendInspectionEvent({
+			type: "@xstate.actor",
+			actorRef: this
+		}), c && (this.systemId = c, this.system._set(c, this)), this._initState(t?.snapshot ?? t?.state), c && this._snapshot.status !== "active" && this.system._unregister(this);
+	}
+	_initState(e) {
+		try {
+			this._snapshot = e ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(e, this._actorScope) : e : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+		} catch (e) {
+			this._snapshot = {
+				status: "error",
+				output: void 0,
+				error: e
+			};
+		}
+	}
+	update(e, t) {
+		this._snapshot = e;
+		let n;
+		for (; n = this._deferred.shift();) try {
+			n();
+		} catch (t) {
+			this._deferred.length = 0, this._snapshot = {
+				...e,
+				status: "error",
+				error: t
+			};
+		}
+		switch (this._snapshot.status) {
+			case "active":
+				for (let t of this.observers) try {
+					t.next?.(e);
+				} catch (e) {
+					reportUnhandledError(e);
+				}
+				break;
+			case "done":
+				for (let t of this.observers) try {
+					t.next?.(e);
+				} catch (e) {
+					reportUnhandledError(e);
+				}
+				this._stopProcedure(), this._complete(), this._doneEvent = createDoneActorEvent(this.id, this._snapshot.output), this._parent && this.system._relay(this, this._parent, this._doneEvent);
+				break;
+			case "error":
+				this._error(this._snapshot.error);
+				break;
+		}
+		this.system._sendInspectionEvent({
+			type: "@xstate.snapshot",
+			actorRef: this,
+			event: t,
+			snapshot: e
+		});
+	}
+	subscribe(e, t, n) {
+		let r = toObserver(e, t, n);
+		if (this._processingStatus !== h.Stopped) this.observers.add(r);
+		else switch (this._snapshot.status) {
+			case "done":
+				try {
+					r.complete?.();
+				} catch (e) {
+					reportUnhandledError(e);
+				}
+				break;
+			case "error": {
+				let e = this._snapshot.error;
+				if (!r.error) reportUnhandledError(e);
+				else try {
+					r.error(e);
+				} catch (e) {
+					reportUnhandledError(e);
+				}
+				break;
+			}
+		}
+		return { unsubscribe: () => {
+			this.observers.delete(r);
+		} };
+	}
+	on(e, t) {
+		let n = this.eventListeners.get(e);
+		n || (n = /* @__PURE__ */ new Set(), this.eventListeners.set(e, n));
+		let r = t.bind(void 0);
+		return n.add(r), { unsubscribe: () => {
+			n.delete(r);
+		} };
+	}
+	select(e, t = Object.is) {
+		return {
+			subscribe: (n) => {
+				let r = toObserver(n), i = e(this.getSnapshot());
+				return this.subscribe((n) => {
+					let a = e(n);
+					t(i, a) || (i = a, r.next?.(a));
+				});
+			},
+			get: () => e(this.getSnapshot())
+		};
+	}
+	start() {
+		if (this._processingStatus === h.Running) return this;
+		this._syncSnapshot && this.subscribe({
+			next: (e) => {
+				e.status === "active" && this.system._relay(this, this._parent, {
+					type: `xstate.snapshot.${this.id}`,
+					snapshot: e
+				});
+			},
+			error: () => {}
+		}), this.system._register(this.sessionId, this), this.systemId && this.system._set(this.systemId, this), this._processingStatus = h.Running;
+		let e = createInitEvent(this.options.input);
+		switch (this.system._sendInspectionEvent({
+			type: "@xstate.event",
+			sourceRef: this._parent,
+			actorRef: this,
+			event: e
+		}), this._snapshot.status) {
+			case "done": return this.update(this._snapshot, e), this;
+			case "error": return this._error(this._snapshot.error), this;
+		}
+		if (this._parent || this.system.start(), this.logic.start) try {
+			this.logic.start(this._snapshot, this._actorScope);
+		} catch (e) {
+			return this._snapshot = {
+				...this._snapshot,
+				status: "error",
+				error: e
+			}, this._error(e), this;
+		}
+		return this.update(this._snapshot, e), this.options.devTools && this.attachDevTools(), this.mailbox.start(), this;
+	}
+	_process(e) {
+		let t, n;
+		try {
+			t = this.logic.transition(this._snapshot, e, this._actorScope);
+		} catch (e) {
+			n = { err: e };
+		}
+		if (n) {
+			let { err: e } = n;
+			this._snapshot = {
+				...this._snapshot,
+				status: "error",
+				error: e
+			}, this._error(e);
+			return;
+		}
+		this.update(t, e), e.type === "xstate.stop" && (this._stopProcedure(), this._complete());
+	}
+	_stop() {
+		return this._processingStatus === h.Stopped ? this : (this.mailbox.clear(), this._processingStatus === h.NotStarted ? (this._processingStatus = h.Stopped, this) : (this.mailbox.enqueue({ type: d }), this));
+	}
+	stop() {
+		if (this._parent) throw Error("A non-root actor cannot be stopped directly.");
+		return this._stop();
+	}
+	_complete() {
+		for (let e of this.observers) try {
+			e.complete?.();
+		} catch (e) {
+			reportUnhandledError(e);
+		}
+		this.observers.clear(), this.eventListeners.clear();
+	}
+	_reportError(e) {
+		if (!this.observers.size) {
+			this._parent || reportUnhandledError(e), this.eventListeners.clear();
+			return;
+		}
+		let t = !1;
+		for (let n of this.observers) {
+			let r = n.error;
+			t ||= !r;
+			try {
+				r?.(e);
+			} catch (e) {
+				reportUnhandledError(e);
+			}
+		}
+		this.observers.clear(), this.eventListeners.clear(), t && reportUnhandledError(e);
+	}
+	_error(e) {
+		this._stopProcedure(), this._reportError(e), this._parent && this.system._relay(this, this._parent, createErrorActorEvent(this.id, e));
+	}
+	_stopProcedure() {
+		return this._processingStatus === h.Running ? (this.system.scheduler.cancelAll(this), this.mailbox.clear(), this.mailbox = new Mailbox(this._process.bind(this)), this._processingStatus = h.Stopped, this.system._unregister(this), this) : this;
+	}
+	_send(e) {
+		this._processingStatus !== h.Stopped && this.mailbox.enqueue(e);
+	}
+	send(e) {
+		this.system._relay(void 0, this, e);
+	}
+	attachDevTools() {
+		let { devTools: e } = this.options;
+		e && (typeof e == "function" ? e : devToolsAdapter)(this);
+	}
+	toJSON() {
+		return {
+			xstate$$type: 1,
+			id: this.id
+		};
+	}
+	getPersistedSnapshot(e) {
+		return this.logic.getPersistedSnapshot(this._snapshot, e);
+	}
+	[f]() {
+		return this;
+	}
+	getSnapshot() {
+		return this._snapshot;
+	}
+};
+function createActor(e, ...[t]) {
+	return new Actor(e, t);
+}
+function resolveCancel(e, t, n, r, { sendId: i }) {
+	return [
+		t,
+		{ sendId: typeof i == "function" ? i(n, r) : i },
+		void 0
+	];
+}
+function executeCancel(e, t) {
+	e.defer(() => {
+		e.system.scheduler.cancel(e.self, t.sendId);
+	});
+}
+function cancel(e) {
+	function cancel(e, t) {}
+	return cancel.type = "xstate.cancel", cancel.sendId = e, cancel.resolve = resolveCancel, cancel.execute = executeCancel, cancel;
+}
+function resolveSpawn(e, t, n, r, { id: i, systemId: a, src: o, input: s, syncSnapshot: c }) {
+	let l = typeof o == "string" ? resolveReferencedActor(t.machine, o) : o, u = typeof i == "function" ? i(n) : i, d, f;
+	return l && (f = typeof s == "function" ? s({
+		context: t.context,
+		event: n.event,
+		self: e.self
+	}) : s, d = createActor(l, {
+		id: u,
+		src: o,
+		parent: e.self,
+		syncSnapshot: c,
+		systemId: a,
+		input: f
+	})), [
+		cloneMachineSnapshot(t, { children: {
+			...t.children,
+			[u]: d
+		} }),
+		{
+			id: i,
+			systemId: a,
+			actorRef: d,
+			src: o,
+			input: f
+		},
+		void 0
+	];
+}
+function executeSpawn(e, { actorRef: t }) {
+	t && e.defer(() => {
+		t._processingStatus !== h.Stopped && t.start();
+	});
+}
+function spawnChild(...[e, { id: t, systemId: n, input: r, syncSnapshot: i = !1 } = {}]) {
+	function spawnChild(e, t) {}
+	return spawnChild.type = "xstate.spawnChild", spawnChild.id = t, spawnChild.systemId = n, spawnChild.src = e, spawnChild.input = r, spawnChild.syncSnapshot = i, spawnChild.resolve = resolveSpawn, spawnChild.execute = executeSpawn, spawnChild;
+}
+function resolveStop(e, t, n, r, { actorRef: i }) {
+	let a = typeof i == "function" ? i(n, r) : i, o = typeof a == "string" ? t.children[a] : a, s = t.children;
+	return o && (s = { ...s }, delete s[o.id]), [
+		cloneMachineSnapshot(t, { children: s }),
+		o,
+		void 0
+	];
+}
+function unregisterRecursively(e, t) {
+	let n = t.getSnapshot();
+	if (n && "children" in n) for (let t of Object.values(n.children)) unregisterRecursively(e, t);
+	e.system._unregister(t);
+}
+function executeStop(e, t) {
+	if (t) {
+		if (unregisterRecursively(e, t), t._processingStatus !== h.Running) {
+			e.stopChild(t);
+			return;
+		}
+		e.defer(() => {
+			e.stopChild(t);
+		});
+	}
+}
+function stopChild(e) {
+	function stop(e, t) {}
+	return stop.type = "xstate.stopChild", stop.actorRef = e, stop.resolve = resolveStop, stop.execute = executeStop, stop;
+}
+function checkAnd(e, { context: t, event: n }, { guards: r }) {
+	return r.every((r) => evaluateGuard(r, t, n, e));
+}
+function and(e) {
+	function and(e, t) {
+		return !1;
+	}
+	return and.check = checkAnd, and.guards = e, and;
+}
+function checkOr(e, { context: t, event: n }, { guards: r }) {
+	return r.some((r) => evaluateGuard(r, t, n, e));
+}
+function or(e) {
+	function or(e, t) {
+		return !1;
+	}
+	return or.check = checkOr, or.guards = e, or;
+}
+function evaluateGuard(e, t, n, r) {
+	let { machine: i } = r, a = typeof e == "function", o = a ? e : i.implementations.guards[typeof e == "string" ? e : e.type];
+	if (!a && !o) throw Error(`Guard '${typeof e == "string" ? e : e.type}' is not implemented.'.`);
+	if (typeof o != "function") return evaluateGuard(o, t, n, r);
+	let s = {
+		context: t,
+		event: n
+	}, c = a || typeof e == "string" ? void 0 : "params" in e ? typeof e.params == "function" ? e.params({
+		context: t,
+		event: n
+	}) : e.params : void 0;
+	return "check" in o ? o.check(r, s, o) : o(s, c);
+}
+function isAtomicStateNode(e) {
+	return e.type === "atomic" || e.type === "final";
+}
+function getChildren(e) {
+	return Object.values(e.states).filter((e) => e.type !== "history");
+}
+function getProperAncestors(e, t) {
+	let n = [];
+	if (t === e) return n;
+	let r = e.parent;
+	for (; r && r !== t;) n.push(r), r = r.parent;
+	return n;
+}
+function getAllStateNodes(e) {
+	let t = new Set(e), n = getAdjList(t);
+	for (let e of t) if (e.type === "compound" && (!n.get(e) || !n.get(e).length)) getInitialStateNodesWithTheirAncestors(e).forEach((e) => t.add(e));
+	else if (e.type === "parallel") {
+		for (let n of getChildren(e)) if (n.type !== "history" && !t.has(n)) {
+			let e = getInitialStateNodesWithTheirAncestors(n);
+			for (let n of e) t.add(n);
+		}
+	}
+	for (let e of t) {
+		let n = e.parent;
+		for (; n;) t.add(n), n = n.parent;
+	}
+	return t;
+}
+function getValueFromAdj(e, t) {
+	let n = t.get(e);
+	if (!n) return {};
+	if (e.type === "compound") {
+		let e = n[0];
+		if (e) {
+			if (isAtomicStateNode(e)) return e.key;
+		} else return {};
+	}
+	let r = {};
+	for (let e of n) r[e.key] = getValueFromAdj(e, t);
+	return r;
+}
+function getAdjList(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) t.has(n) || t.set(n, []), n.parent && (t.has(n.parent) || t.set(n.parent, []), t.get(n.parent).push(n));
+	return t;
+}
+function getStateValue(e, t) {
+	return getValueFromAdj(e, getAdjList(getAllStateNodes(t)));
+}
+function isInFinalState(e, t) {
+	return t.type === "compound" ? getChildren(t).some((t) => t.type === "final" && e.has(t)) : t.type === "parallel" ? getChildren(t).every((t) => isInFinalState(e, t)) : t.type === "final";
+}
+var isStateId = (e) => e[0] === c;
+function getCandidates(e, t) {
+	return e.transitions.get(t) || [...e.transitions.keys()].filter((e) => matchesEventDescriptor(t, e)).sort((e, t) => t.length - e.length).flatMap((t) => e.transitions.get(t));
+}
+function getDelayedTransitions(e) {
+	let t = e.config.after;
+	if (!t) return [];
+	let mutateEntryExit = (t) => {
+		let n = createAfterEvent(t, e.id), r = n.type;
+		return e.entry.push(raise(n, {
+			id: r,
+			delay: t
+		})), e.exit.push(cancel(r)), r;
+	};
+	return Object.keys(t).flatMap((e) => {
+		let n = t[e], r = typeof n == "string" ? { target: n } : n, i = Number.isNaN(+e) ? e : +e, a = mutateEntryExit(i);
+		return toArray(r).map((e) => ({
+			...e,
+			event: a,
+			delay: i
+		}));
+	}).map((t) => {
+		let { delay: n } = t;
+		return {
+			...formatTransition(e, t.event, t),
+			delay: n
+		};
+	});
+}
+function formatTransition(e, t, n) {
+	let r = normalizeTarget(n.target), i = n.reenter ?? !1, a = resolveTarget(e, r), o = {
+		...n,
+		actions: toArray(n.actions),
+		guard: n.guard,
+		target: a,
+		source: e,
+		reenter: i,
+		eventType: t,
+		toJSON: () => ({
+			...o,
+			source: `#${e.id}`,
+			target: a ? a.map((e) => `#${e.id}`) : void 0
+		})
+	};
+	return o;
+}
+function formatTransitions(e) {
+	let t = /* @__PURE__ */ new Map();
+	if (e.config.on) for (let n of Object.keys(e.config.on)) {
+		if (n === "") throw Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
+		let r = e.config.on[n];
+		t.set(n, toTransitionConfigArray(r).map((t) => formatTransition(e, n, t)));
+	}
+	if (e.config.onDone) {
+		let n = `xstate.done.state.${e.id}`;
+		t.set(n, toTransitionConfigArray(e.config.onDone).map((t) => formatTransition(e, n, t)));
+	}
+	for (let n of e.invoke) {
+		if (n.onDone) {
+			let r = `xstate.done.actor.${n.id}`;
+			t.set(r, toTransitionConfigArray(n.onDone).map((t) => formatTransition(e, r, t)));
+		}
+		if (n.onError) {
+			let r = `xstate.error.actor.${n.id}`;
+			t.set(r, toTransitionConfigArray(n.onError).map((t) => formatTransition(e, r, t)));
+		}
+		if (n.onSnapshot) {
+			let r = `xstate.snapshot.${n.id}`;
+			t.set(r, toTransitionConfigArray(n.onSnapshot).map((t) => formatTransition(e, r, t)));
+		}
+	}
+	for (let n of e.after) {
+		let e = t.get(n.eventType);
+		e || (e = [], t.set(n.eventType, e)), e.push(n);
+	}
+	return t;
+}
+function formatRouteTransitions(e) {
+	let t = [], collectRoutes = (n) => {
+		Object.values(n).forEach((n) => {
+			if (n.config.route && n.config.id) {
+				let r = n.config.id, i = n.config.route.guard, routeMatches = ({ event: e }) => e.to === `#${r}`, a = {
+					...n.config.route,
+					guard: i ? and([routeMatches, i]) : routeMatches,
+					target: `#${r}`
+				};
+				t.push(formatTransition(e, "xstate.route", a));
+			}
+			n.states && collectRoutes(n.states);
+		});
+	};
+	collectRoutes(e.states), t.length > 0 && e.transitions.set("xstate.route", t);
+}
+function formatInitialTransition(e, t) {
+	let n = typeof t == "string" ? e.states[t] : t ? e.states[t.target] : void 0;
+	if (!n && t) throw Error(`Initial state node "${t}" not found on parent state node #${e.id}`);
+	let r = {
+		source: e,
+		actions: !t || typeof t == "string" ? [] : toArray(t.actions),
+		eventType: null,
+		reenter: !1,
+		target: n ? [n] : [],
+		toJSON: () => ({
+			...r,
+			source: `#${e.id}`,
+			target: n ? [`#${n.id}`] : []
+		})
+	};
+	return r;
+}
+function resolveTarget(e, t) {
+	if (t !== void 0) return t.map((t) => {
+		if (typeof t != "string") return t;
+		if (isStateId(t)) return e.machine.getStateNodeById(t);
+		let n = t[0] === ".";
+		if (n && !e.parent) return getStateNodeByPath(e, t.slice(1));
+		let r = n ? e.key + t : t;
+		if (e.parent) try {
+			return getStateNodeByPath(e.parent, r);
+		} catch (t) {
+			throw Error(`Invalid transition definition for state node '${e.id}':\n${t.message}`);
+		}
+		else throw Error(`Invalid target: "${t}" is not a valid target from the root node. Did you mean ".${t}"?`);
+	});
+}
+function resolveHistoryDefaultTransition(e) {
+	let t = normalizeTarget(e.config.target);
+	return t ? { target: t.map((t) => typeof t == "string" ? getStateNodeByPath(e.parent, t) : t) } : e.parent.initial;
+}
+function isHistoryNode(e) {
+	return e.type === "history";
+}
+function getInitialStateNodesWithTheirAncestors(e) {
+	let t = getInitialStateNodes(e);
+	for (let n of t) for (let r of getProperAncestors(n, e)) t.add(r);
+	return t;
+}
+function getInitialStateNodes(e) {
+	let t = /* @__PURE__ */ new Set();
+	function iter(e) {
+		if (!t.has(e)) {
+			if (t.add(e), e.type === "compound") iter(e.initial.target[0]);
+			else if (e.type === "parallel") for (let t of getChildren(e)) iter(t);
+		}
+	}
+	return iter(e), t;
+}
+function getStateNode(e, t) {
+	if (isStateId(t)) return e.machine.getStateNodeById(t);
+	if (!e.states) throw Error(`Unable to retrieve child state '${t}' from '${e.id}'; no child states exist.`);
+	let n = e.states[t];
+	if (!n) throw Error(`Child state '${t}' does not exist on '${e.id}'`);
+	return n;
+}
+function getStateNodeByPath(e, t) {
+	if (typeof t == "string" && isStateId(t)) try {
+		return e.machine.getStateNodeById(t);
+	} catch {}
+	let n = toStatePath(t).slice(), r = e;
+	for (; n.length;) {
+		let e = n.shift();
+		if (!e.length) break;
+		r = getStateNode(r, e);
+	}
+	return r;
+}
+function getStateNodes(e, t) {
+	if (typeof t == "string") {
+		let n = e.states[t];
+		if (!n) throw Error(`State '${t}' does not exist on '${e.id}'`);
+		return [e, n];
+	}
+	let n = Object.keys(t), r = n.map((t) => getStateNode(e, t)).filter(Boolean);
+	return [e.machine.root, e].concat(r, n.reduce((n, r) => {
+		let i = getStateNode(e, r);
+		if (!i) return n;
+		let a = getStateNodes(i, t[r]);
+		return n.concat(a);
+	}, []));
+}
+function transitionAtomicNode(e, t, n, r) {
+	let i = getStateNode(e, t).next(n, r);
+	return !i || !i.length ? e.next(n, r) : i;
+}
+function transitionCompoundNode(e, t, n, r) {
+	let i = Object.keys(t), a = transitionNode(getStateNode(e, i[0]), t[i[0]], n, r);
+	return !a || !a.length ? e.next(n, r) : a;
+}
+function transitionParallelNode(e, t, n, r) {
+	let i = [];
+	for (let a of Object.keys(t)) {
+		let o = t[a];
+		if (!o) continue;
+		let s = transitionNode(getStateNode(e, a), o, n, r);
+		s && i.push(...s);
+	}
+	return i.length ? i : e.next(n, r);
+}
+function transitionNode(e, t, n, r) {
+	return typeof t == "string" ? transitionAtomicNode(e, t, n, r) : Object.keys(t).length === 1 ? transitionCompoundNode(e, t, n, r) : transitionParallelNode(e, t, n, r);
+}
+function getHistoryNodes(e) {
+	return Object.keys(e.states).map((t) => e.states[t]).filter((e) => e.type === "history");
+}
+function isDescendant(e, t) {
+	let n = e;
+	for (; n.parent && n.parent !== t;) n = n.parent;
+	return n.parent === t;
+}
+function hasIntersection(e, t) {
+	let n = new Set(e), r = new Set(t);
+	for (let e of n) if (r.has(e)) return !0;
+	for (let e of r) if (n.has(e)) return !0;
+	return !1;
+}
+function removeConflictingTransitions(e, t, n) {
+	let r = /* @__PURE__ */ new Set();
+	for (let i of e) {
+		let e = !1, a = /* @__PURE__ */ new Set();
+		for (let o of r) if (hasIntersection(computeExitSet([i], t, n), computeExitSet([o], t, n))) if (isDescendant(i.source, o.source)) a.add(o);
+		else {
+			e = !0;
+			break;
+		}
+		if (!e) {
+			for (let e of a) r.delete(e);
+			r.add(i);
+		}
+	}
+	return Array.from(r);
+}
+function findLeastCommonAncestor(e) {
+	let [t, ...n] = e;
+	for (let e of getProperAncestors(t, void 0)) if (n.every((t) => isDescendant(t, e))) return e;
+}
+function getEffectiveTargetStates(e, t) {
+	if (!e.target) return [];
+	let n = /* @__PURE__ */ new Set();
+	for (let r of e.target) if (isHistoryNode(r)) if (t[r.id]) for (let e of t[r.id]) n.add(e);
+	else for (let e of getEffectiveTargetStates(resolveHistoryDefaultTransition(r), t)) n.add(e);
+	else n.add(r);
+	return [...n];
+}
+function getTransitionDomain(e, t) {
+	let n = getEffectiveTargetStates(e, t);
+	if (!n) return;
+	if (!e.reenter && n.every((t) => t === e.source || isDescendant(t, e.source))) return e.source;
+	let r = findLeastCommonAncestor(n.concat(e.source));
+	if (r) return r;
+	if (!e.reenter) return e.source.machine.root;
+}
+function computeExitSet(e, t, n) {
+	let r = /* @__PURE__ */ new Set();
+	for (let i of e) if (i.target?.length) {
+		let e = getTransitionDomain(i, n);
+		i.reenter && i.source === e && r.add(e);
+		for (let n of t) isDescendant(n, e) && r.add(n);
+	}
+	return [...r];
+}
+function areStateNodeCollectionsEqual(e, t) {
+	if (e.length !== t.size) return !1;
+	for (let n of e) if (!t.has(n)) return !1;
+	return !0;
+}
+function initialMicrostep(e, t, n, r, i) {
+	return microstep([{
+		target: [...getInitialStateNodes(e)],
+		source: e,
+		reenter: !0,
+		actions: [],
+		eventType: null,
+		toJSON: null
+	}], t, n, r, !0, i);
+}
+function microstep(e, t, n, r, i, a) {
+	let o = [];
+	if (!e.length) return [t, o];
+	let s = n.actionExecutor;
+	n.actionExecutor = (e) => {
+		o.push(e), s(e);
+	};
+	try {
+		let s = new Set(t._nodes), c = t.historyValue, l = removeConflictingTransitions(e, s, c), u = t;
+		i || ([u, c] = exitStates(u, r, n, l, s, c, a, n.actionExecutor)), u = resolveActionsAndContext(u, r, n, l.flatMap((e) => e.actions), a, void 0), u = enterStates(u, r, n, l, s, a, c, i);
+		let d = [...s];
+		u.status === "done" && (u = resolveActionsAndContext(u, r, n, d.sort((e, t) => t.order - e.order).flatMap((e) => e.exit), a, void 0));
+		try {
+			return c === t.historyValue && areStateNodeCollectionsEqual(t._nodes, s) ? [u, o] : [cloneMachineSnapshot(u, {
+				_nodes: d,
+				historyValue: c
+			}), o];
+		} catch (e) {
+			throw e;
+		}
+	} finally {
+		n.actionExecutor = s;
+	}
+}
+function getMachineOutput(e, t, n, r, i) {
+	if (r.output === void 0) return;
+	let a = createDoneStateEvent(i.id, i.output !== void 0 && i.parent ? resolveOutput(i.output, e.context, t, n.self) : void 0);
+	return resolveOutput(r.output, e.context, a, n.self);
+}
+function enterStates(e, t, n, r, i, a, o, s) {
+	let c = e, l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
+	computeEntrySet(r, o, u, l), s && u.add(e.machine.root);
+	let d = /* @__PURE__ */ new Set();
+	for (let e of [...l].sort((e, t) => e.order - t.order)) {
+		i.add(e);
+		let r = [];
+		r.push(...e.entry);
+		for (let t of e.invoke) r.push(spawnChild(t.src, {
+			...t,
+			syncSnapshot: !!t.onSnapshot
+		}));
+		if (u.has(e)) {
+			let t = e.initial.actions;
+			r.push(...t);
+		}
+		if (c = resolveActionsAndContext(c, t, n, r, a, e.invoke.map((e) => e.id)), e.type === "final") {
+			let r = e.parent, o = r?.type === "parallel" ? r : r?.parent, s = o || e;
+			for (r?.type === "compound" && a.push(createDoneStateEvent(r.id, e.output === void 0 ? void 0 : resolveOutput(e.output, c.context, t, n.self))); o?.type === "parallel" && !d.has(o) && isInFinalState(i, o);) d.add(o), a.push(createDoneStateEvent(o.id)), s = o, o = o.parent;
+			if (o) continue;
+			c = cloneMachineSnapshot(c, {
+				status: "done",
+				output: getMachineOutput(c, t, n, c.machine.root, s)
+			});
+		}
+	}
+	return c;
+}
+function computeEntrySet(e, t, n, r) {
+	for (let i of e) {
+		let e = getTransitionDomain(i, t);
+		for (let a of i.target || []) !isHistoryNode(a) && (i.source !== a || i.source !== e || i.reenter) && (r.add(a), n.add(a)), addDescendantStatesToEnter(a, t, n, r);
+		let a = getEffectiveTargetStates(i, t);
+		for (let o of a) {
+			let a = getProperAncestors(o, e);
+			e?.type === "parallel" && a.push(e), addAncestorStatesToEnter(r, t, n, a, !i.source.parent && i.reenter ? void 0 : e);
+		}
+	}
+}
+function addDescendantStatesToEnter(e, t, n, r) {
+	if (isHistoryNode(e)) if (t[e.id]) {
+		let i = t[e.id];
+		for (let e of i) r.add(e), addDescendantStatesToEnter(e, t, n, r);
+		for (let a of i) addProperAncestorStatesToEnter(a, e.parent, r, t, n);
+	} else {
+		let i = resolveHistoryDefaultTransition(e);
+		for (let a of i.target) r.add(a), i === e.parent?.initial && n.add(e.parent), addDescendantStatesToEnter(a, t, n, r);
+		for (let a of i.target) addProperAncestorStatesToEnter(a, e.parent, r, t, n);
+	}
+	else if (e.type === "compound") {
+		let [i] = e.initial.target;
+		isHistoryNode(i) || (r.add(i), n.add(i)), addDescendantStatesToEnter(i, t, n, r), addProperAncestorStatesToEnter(i, e, r, t, n);
+	} else if (e.type === "parallel") for (let i of getChildren(e).filter((e) => !isHistoryNode(e))) [...r].some((e) => isDescendant(e, i)) || (isHistoryNode(i) || (r.add(i), n.add(i)), addDescendantStatesToEnter(i, t, n, r));
+}
+function addAncestorStatesToEnter(e, t, n, r, i) {
+	for (let a of r) if ((!i || isDescendant(a, i)) && e.add(a), a.type === "parallel") for (let r of getChildren(a).filter((e) => !isHistoryNode(e))) [...e].some((e) => isDescendant(e, r)) || (e.add(r), addDescendantStatesToEnter(r, t, n, e));
+}
+function addProperAncestorStatesToEnter(e, t, n, r, i) {
+	addAncestorStatesToEnter(n, r, i, getProperAncestors(e, t));
+}
+function exitStates(e, t, n, r, i, a, o, s) {
+	let c = e, l = computeExitSet(r, i, a);
+	l.sort((e, t) => t.order - e.order);
+	let u;
+	for (let e of l) for (let t of getHistoryNodes(e)) {
+		let n;
+		n = t.history === "deep" ? (t) => isAtomicStateNode(t) && isDescendant(t, e) : (t) => t.parent === e, u ??= { ...a }, u[t.id] = Array.from(i).filter(n);
+	}
+	for (let e of l) c = resolveActionsAndContext(c, t, n, [...e.exit, ...e.invoke.map((e) => stopChild(e.id))], o, void 0), i.delete(e);
+	return [c, u || a];
+}
+function getAction(e, t) {
+	return e.implementations.actions[t];
+}
+function resolveAndExecuteActionsWithContext(e, t, n, r, i, a) {
+	let { machine: o } = e, s = e;
+	for (let e of r) {
+		let r = typeof e == "function", c = r ? e : getAction(o, typeof e == "string" ? e : e.type), l = {
+			context: s.context,
+			event: t,
+			self: n.self,
+			system: n.system
+		}, u = r || typeof e == "string" ? void 0 : "params" in e ? typeof e.params == "function" ? e.params({
+			context: s.context,
+			event: t
+		}) : e.params : void 0;
+		if (!c || !("resolve" in c)) {
+			n.actionExecutor({
+				type: typeof e == "string" ? e : typeof e == "object" ? e.type : e.name || "(anonymous)",
+				info: l,
+				params: u,
+				exec: c
+			});
+			continue;
+		}
+		let d = c, [f, p, m] = d.resolve(n, s, l, u, c, i);
+		s = f, "retryResolve" in d && a?.push([d, p]), "execute" in d && n.actionExecutor({
+			type: d.type,
+			info: l,
+			params: p,
+			exec: d.execute.bind(null, n, p)
+		}), m && (s = resolveAndExecuteActionsWithContext(s, t, n, m, i, a));
+	}
+	return s;
+}
+function resolveActionsAndContext(e, t, n, r, i, a) {
+	let o = a ? [] : void 0, s = resolveAndExecuteActionsWithContext(e, t, n, r, {
+		internalQueue: i,
+		deferredActorIds: a
+	}, o);
+	return o?.forEach(([e, t]) => {
+		e.retryResolve(n, s, t);
+	}), s;
+}
+function macrostep(e, t, n, r) {
+	let i = e, a = [];
+	function addMicrostep(e, t, r) {
+		n.system._sendInspectionEvent({
+			type: "@xstate.microstep",
+			actorRef: n.self,
+			event: t,
+			snapshot: e[0],
+			_transitions: r
+		}), a.push(e);
+	}
+	if (t.type === "xstate.stop") return i = cloneMachineSnapshot(stopChildren(i, t, n), { status: "stopped" }), addMicrostep([i, []], t, []), {
+		snapshot: i,
+		microsteps: a
+	};
+	let o = t;
+	if (o.type !== u) {
+		let t = o, s = isErrorActorEvent(t), c = selectTransitions(t, i);
+		if (s && !c.length) return i = cloneMachineSnapshot(e, {
+			status: "error",
+			error: t.error
+		}), addMicrostep([i, []], t, []), {
+			snapshot: i,
+			microsteps: a
+		};
+		let l = microstep(c, e, n, o, !1, r);
+		i = l[0], addMicrostep(l, t, c);
+	}
+	let s = !0, c = e.machine.options?.maxIterations ?? Infinity, l = 0;
+	for (; i.status === "active";) {
+		if (l++, l > c) throw Error(`Infinite loop detected: the machine has processed more than ${c} microsteps without reaching a stable state. This usually happens when there's a cycle of transitions (e.g., eventless transitions or raised events causing state A -> B -> C -> A).`);
+		let e = s ? selectEventlessTransitions(i, o) : [], t = e.length ? i : void 0;
+		if (!e.length) {
+			if (!r.length) break;
+			o = r.shift(), e = selectTransitions(o, i);
+		}
+		let a = microstep(e, i, n, o, !1, r);
+		i = a[0], s = i !== t, addMicrostep(a, o, e);
+	}
+	return i.status !== "active" && stopChildren(i, o, n), {
+		snapshot: i,
+		microsteps: a
+	};
+}
+function stopChildren(e, t, n) {
+	return resolveActionsAndContext(e, t, n, Object.values(e.children).map((e) => stopChild(e)), [], void 0);
+}
+function selectTransitions(e, t) {
+	return t.machine.getTransitionData(t, e);
+}
+function selectEventlessTransitions(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = e._nodes.filter(isAtomicStateNode);
+	for (let i of r) loop: for (let r of [i].concat(getProperAncestors(i, void 0))) if (r.always) {
+		for (let i of r.always) if (i.guard === void 0 || evaluateGuard(i.guard, e.context, t, e)) {
+			n.add(i);
+			break loop;
+		}
+	}
+	return removeConflictingTransitions(Array.from(n), new Set(e._nodes), e.historyValue);
+}
+function resolveStateValue(e, t) {
+	return getStateValue(e, [...getAllStateNodes(getStateNodes(e, t))]);
+}
+function isMachineSnapshot(e) {
+	return !!e && typeof e == "object" && "machine" in e && "value" in e;
+}
+var _ = function matches(e) {
+	return matchesState(e, this.value);
+}, v = function hasTag(e) {
+	return this.tags.has(e);
+}, y = function can(e) {
+	let t = this.machine.getTransitionData(this, e);
+	return !!t?.length && t.some((e) => e.target !== void 0 || e.actions.length);
+}, b = function toJSON() {
+	let { _nodes: e, tags: t, machine: n, getMeta: r, toJSON: i, can: a, hasTag: o, matches: s, ...c } = this;
+	return {
+		...c,
+		tags: Array.from(t)
+	};
+}, x = function getMeta() {
+	return this._nodes.reduce((e, t) => (t.meta !== void 0 && (e[t.id] = t.meta), e), {});
+};
+function createMachineSnapshot(e, t) {
+	return {
+		status: e.status,
+		output: e.output,
+		error: e.error,
+		machine: t,
+		context: e.context,
+		_nodes: e._nodes,
+		value: getStateValue(t.root, e._nodes),
+		tags: new Set(e._nodes.flatMap((e) => e.tags)),
+		children: e.children,
+		historyValue: e.historyValue || {},
+		matches: _,
+		hasTag: v,
+		can: y,
+		getMeta: x,
+		toJSON: b
+	};
+}
+function cloneMachineSnapshot(e, t = {}) {
+	return createMachineSnapshot({
+		...e,
+		...t
+	}, e.machine);
+}
+function serializeHistoryValue(e) {
+	if (typeof e != "object" || !e) return {};
+	let t = {};
+	for (let n in e) {
+		let r = e[n];
+		Array.isArray(r) && (t[n] = r.map((e) => ({ id: e.id })));
+	}
+	return t;
+}
+function getPersistedSnapshot(e, t) {
+	let { _nodes: n, tags: r, machine: i, children: a, context: o, can: s, hasTag: c, matches: l, getMeta: u, toJSON: d, ...f } = e, p = {};
+	for (let e in a) {
+		let n = a[e];
+		p[e] = {
+			snapshot: n.getPersistedSnapshot(t),
+			src: n.src,
+			systemId: n.systemId,
+			syncSnapshot: n._syncSnapshot
+		};
+	}
+	return {
+		...f,
+		context: persistContext(o),
+		children: p,
+		historyValue: serializeHistoryValue(f.historyValue)
+	};
+}
+function persistContext(e) {
+	let t;
+	for (let n in e) {
+		let r = e[n];
+		if (r && typeof r == "object") if ("sessionId" in r && "send" in r && "ref" in r) t ??= Array.isArray(e) ? e.slice() : { ...e }, t[n] = {
+			xstate$$type: 1,
+			id: r.id
+		};
+		else {
+			let i = persistContext(r);
+			i !== r && (t ??= Array.isArray(e) ? e.slice() : { ...e }, t[n] = i);
+		}
+	}
+	return t ?? e;
+}
+function resolveRaise(e, t, n, r, { event: i, id: a, delay: o }, { internalQueue: s }) {
+	let c = t.machine.implementations.delays;
+	if (typeof i == "string") throw Error(`Only event objects may be used with raise; use raise({ type: "${i}" }) instead`);
+	let l = typeof i == "function" ? i(n, r) : i, u;
+	if (typeof o == "string") {
+		let e = c && c[o];
+		u = typeof e == "function" ? e(n, r) : e;
+	} else u = typeof o == "function" ? o(n, r) : o;
+	return typeof u != "number" && s.push(l), [
+		t,
+		{
+			event: l,
+			id: a,
+			delay: u
+		},
+		void 0
+	];
+}
+function executeRaise(e, t) {
+	let { event: n, delay: r, id: i } = t;
+	if (typeof r == "number") {
+		e.defer(() => {
+			let t = e.self;
+			e.system.scheduler.schedule(t, t, n, r, i);
+		});
+		return;
+	}
+}
+function raise(e, t) {
+	function raise(e, t) {}
+	return raise.type = "xstate.raise", raise.event = e, raise.id = t?.id, raise.delay = t?.delay, raise.resolve = resolveRaise, raise.execute = executeRaise, raise;
+}
+var S = /* @__PURE__ */ new WeakMap();
+function fromCallback(e) {
+	return {
+		config: e,
+		start: (t, n) => {
+			let { self: r, system: i, emit: a } = n, o = {
+				receivers: void 0,
+				dispose: void 0
+			};
+			S.set(r, o), o.dispose = e({
+				input: t.input,
+				system: i,
+				self: r,
+				sendBack: (e) => {
+					r.getSnapshot().status !== "stopped" && r._parent && i._relay(r, r._parent, e);
+				},
+				receive: (e) => {
+					o.receivers ??= /* @__PURE__ */ new Set(), o.receivers.add(e);
+				},
+				emit: a
+			});
+		},
+		transition: (e, t, n) => {
+			let r = S.get(n.self);
+			return t.type === "xstate.stop" ? (e = {
+				...e,
+				status: "stopped",
+				error: void 0
+			}, S.delete(n.self), r.receivers?.clear(), r.dispose?.(), e) : (r.receivers?.forEach((e) => e(t)), e);
+		},
+		getInitialSnapshot: (e, t) => ({
+			status: "active",
+			output: void 0,
+			error: void 0,
+			input: t
+		}),
+		getPersistedSnapshot: (e) => e,
+		restoreSnapshot: (e) => e
+	};
+}
+var C = "xstate.promise.resolve", w = "xstate.promise.reject", T = /* @__PURE__ */ new WeakMap();
+function fromPromise(e) {
+	return {
+		config: e,
+		transition: (e, t, n) => {
+			if (e.status !== "active") return e;
+			switch (t.type) {
+				case C: {
+					let n = t.data;
+					return {
+						...e,
+						status: "done",
+						output: n,
+						input: void 0
+					};
+				}
+				case w: return {
+					...e,
+					status: "error",
+					error: t.data,
+					input: void 0
+				};
+				case d: return T.get(n.self)?.abort(), T.delete(n.self), {
+					...e,
+					status: "stopped",
+					input: void 0
+				};
+				default: return e;
+			}
+		},
+		start: (t, { self: n, system: r, emit: i }) => {
+			if (t.status !== "active") return;
+			let a = new AbortController();
+			T.set(n, a), Promise.resolve(e({
+				input: t.input,
+				system: r,
+				self: n,
+				signal: a.signal,
+				emit: i
+			})).then((e) => {
+				n.getSnapshot().status === "active" && (T.delete(n), r._relay(n, n, {
+					type: C,
+					data: e
+				}));
+			}, (e) => {
+				n.getSnapshot().status === "active" && (T.delete(n), r._relay(n, n, {
+					type: w,
+					data: e
+				}));
+			});
+		},
+		getInitialSnapshot: (e, t) => ({
+			status: "active",
+			output: void 0,
+			error: void 0,
+			input: t
+		}),
+		getPersistedSnapshot: (e) => e,
+		restoreSnapshot: (e) => e
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.0/node_modules/xstate/dist/assign-2aa58daa.esm.js
+function createSpawner(e, { machine: t, context: n }, r, i) {
+	let spawn = (a, o) => {
+		if (typeof a == "string") {
+			let s = resolveReferencedActor(t, a);
+			if (!s) throw Error(`Actor logic '${a}' not implemented in machine '${t.id}'`);
+			let c = createActor(s, {
+				id: o?.id,
+				parent: e.self,
+				syncSnapshot: o?.syncSnapshot,
+				input: typeof o?.input == "function" ? o.input({
+					context: n,
+					event: r,
+					self: e.self
+				}) : o?.input,
+				src: a,
+				systemId: o?.systemId
+			});
+			return i[c.id] = c, c;
+		} else return createActor(a, {
+			id: o?.id,
+			parent: e.self,
+			syncSnapshot: o?.syncSnapshot,
+			input: o?.input,
+			src: a,
+			systemId: o?.systemId
+		});
+	};
+	return (t, n) => {
+		let r = spawn(t, n);
+		return i[r.id] = r, e.defer(() => {
+			r._processingStatus !== h.Stopped && r.start();
+		}), r;
+	};
+}
+function resolveAssign(e, t, n, r, { assignment: i }) {
+	if (!t.context) throw Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
+	let a = {}, o = {
+		context: t.context,
+		event: n.event,
+		spawn: createSpawner(e, t, n.event, a),
+		self: e.self,
+		system: e.system
+	}, s = {};
+	if (typeof i == "function") s = i(o, r);
+	else for (let e of Object.keys(i)) {
+		let t = i[e];
+		s[e] = typeof t == "function" ? t(o, r) : t;
+	}
+	return [
+		cloneMachineSnapshot(t, {
+			context: Object.assign({}, t.context, s),
+			children: Object.keys(a).length ? {
+				...t.children,
+				...a
+			} : t.children
+		}),
+		void 0,
+		void 0
+	];
+}
+function assign(e) {
+	function assign(e, t) {}
+	return assign.type = "xstate.assign", assign.assignment = e, assign.resolve = resolveAssign, assign;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.0/node_modules/xstate/dist/StateMachine-45e79c35.esm.js
+var E = /* @__PURE__ */ new WeakMap();
+function memo$1(e, t, n) {
+	let r = E.get(e);
+	return r ? t in r || (r[t] = n()) : (r = { [t]: n() }, E.set(e, r)), r[t];
+}
+e(memo$1, "memo");
+var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : typeof e == "function" ? "resolve" in e ? { type: e.type } : { type: e.name } : e, O = class StateNode {
+	constructor(e, t) {
+		if (this.config = e, this.key = void 0, this.id = void 0, this.type = void 0, this.path = void 0, this.states = void 0, this.history = void 0, this.entry = void 0, this.exit = void 0, this.parent = void 0, this.machine = void 0, this.meta = void 0, this.output = void 0, this.order = -1, this.description = void 0, this.tags = [], this.transitions = void 0, this.always = void 0, this.parent = t._parent, this.key = t._key, this.machine = t._machine, this.path = this.parent ? this.parent.path.concat(this.key) : [], this.id = this.config.id || [this.machine.id, ...this.path].join("."), this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic"), this.description = this.config.description, this.order = this.machine.idMap.size, this.machine.idMap.set(this.id, this), this.states = this.config.states ? mapValues(this.config.states, (e, t) => new StateNode(e, {
+			_parent: this,
+			_key: t,
+			_machine: this.machine
+		})) : D, this.type === "compound" && !this.config.initial) throw Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
+		this.history = this.config.history === !0 ? "shallow" : this.config.history || !1, this.entry = toArray(this.config.entry).slice(), this.exit = toArray(this.config.exit).slice(), this.meta = this.config.meta, this.output = this.type === "final" || !this.parent ? this.config.output : void 0, this.tags = toArray(e.tags).slice();
+	}
+	_initialize() {
+		this.transitions = formatTransitions(this), this.config.always && (this.always = toTransitionConfigArray(this.config.always).map((e) => formatTransition(this, "", e))), Object.keys(this.states).forEach((e) => {
+			this.states[e]._initialize();
+		});
+	}
+	get definition() {
+		return {
+			id: this.id,
+			key: this.key,
+			version: this.machine.version,
+			type: this.type,
+			initial: this.initial ? {
+				target: this.initial.target,
+				source: this,
+				actions: this.initial.actions.map(toSerializableAction),
+				eventType: null,
+				reenter: !1,
+				toJSON: () => ({
+					target: this.initial.target.map((e) => `#${e.id}`),
+					source: `#${this.id}`,
+					actions: this.initial.actions.map(toSerializableAction),
+					eventType: null
+				})
+			} : void 0,
+			history: this.history,
+			states: mapValues(this.states, (e) => e.definition),
+			on: this.on,
+			transitions: [...this.transitions.values()].flat().map((e) => ({
+				...e,
+				actions: e.actions.map(toSerializableAction)
+			})),
+			entry: this.entry.map(toSerializableAction),
+			exit: this.exit.map(toSerializableAction),
+			meta: this.meta,
+			order: this.order || -1,
+			output: this.output,
+			invoke: this.invoke,
+			description: this.description,
+			tags: this.tags
+		};
+	}
+	toJSON() {
+		return this.definition;
+	}
+	get invoke() {
+		return memo$1(this, "invoke", () => toArray(this.config.invoke).map((e, t) => {
+			let { src: n, systemId: r } = e, i = e.id ?? createInvokeId(this.id, t), a = typeof n == "string" ? n : `xstate.invoke.${createInvokeId(this.id, t)}`;
+			return {
+				...e,
+				src: a,
+				id: i,
+				systemId: r,
+				toJSON() {
+					let { onDone: t, onError: n, ...r } = e;
+					return {
+						...r,
+						type: "xstate.invoke",
+						src: a,
+						id: i
+					};
+				}
+			};
+		}));
+	}
+	get on() {
+		return memo$1(this, "on", () => [...this.transitions].flatMap(([e, t]) => t.map((t) => [e, t])).reduce((e, [t, n]) => (e[t] = e[t] || [], e[t].push(n), e), {}));
+	}
+	get after() {
+		return memo$1(this, "delayedTransitions", () => getDelayedTransitions(this));
+	}
+	get initial() {
+		return memo$1(this, "initial", () => formatInitialTransition(this, this.config.initial));
+	}
+	next(e, t) {
+		let n = t.type, r = [], i, a = memo$1(this, `candidates-${n}`, () => getCandidates(this, n));
+		for (let o of a) {
+			let { guard: a } = o, s = e.context, c = !1;
+			try {
+				c = !a || evaluateGuard(a, s, t, e);
+			} catch (e) {
+				let t = typeof a == "string" ? a : typeof a == "object" ? a.type : void 0;
+				throw Error(`Unable to evaluate guard ${t ? `'${t}' ` : ""}in transition for event '${n}' in state node '${this.id}':\n${e.message}`);
+			}
+			if (c) {
+				r.push(...o.actions), i = o;
+				break;
+			}
+		}
+		return i ? [i] : void 0;
+	}
+	get events() {
+		return memo$1(this, "events", () => {
+			let { states: e } = this, t = new Set(this.ownEvents);
+			if (e) for (let n of Object.keys(e)) {
+				let r = e[n];
+				if (r.states) for (let e of r.events) t.add(`${e}`);
+			}
+			return Array.from(t);
+		});
+	}
+	get ownEvents() {
+		let e = Object.keys(Object.fromEntries(this.transitions)), t = new Set(e.filter((e) => this.transitions.get(e).some((e) => !(!e.target && !e.actions.length && !e.reenter))));
+		return Array.from(t);
+	}
+}, k = class StateMachine {
+	constructor(e, t) {
+		this.config = e, this.version = void 0, this.schemas = void 0, this.implementations = void 0, this.options = void 0, this.__xstatenode = !0, this.idMap = /* @__PURE__ */ new Map(), this.root = void 0, this.id = void 0, this.states = void 0, this.events = void 0, this.id = e.id || "(machine)", this.implementations = {
+			actors: t?.actors ?? {},
+			actions: t?.actions ?? {},
+			delays: t?.delays ?? {},
+			guards: t?.guards ?? {}
+		}, this.version = this.config.version, this.schemas = this.config.schemas, this.options = {
+			maxIterations: Infinity,
+			...this.config.options
+		}, this.transition = this.transition.bind(this), this.getInitialSnapshot = this.getInitialSnapshot.bind(this), this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this), this.restoreSnapshot = this.restoreSnapshot.bind(this), this.start = this.start.bind(this), this.root = new O(e, {
+			_key: this.id,
+			_machine: this
+		}), this.root._initialize(), formatRouteTransitions(this.root), this.states = this.root.states, this.events = this.root.events;
+	}
+	provide(e) {
+		let { actions: t, guards: n, actors: r, delays: i } = this.implementations;
+		return new StateMachine(this.config, {
+			actions: {
+				...t,
+				...e.actions
+			},
+			guards: {
+				...n,
+				...e.guards
+			},
+			actors: {
+				...r,
+				...e.actors
+			},
+			delays: {
+				...i,
+				...e.delays
+			}
+		});
+	}
+	resolveState(e) {
+		let t = resolveStateValue(this.root, e.value), n = getAllStateNodes(getStateNodes(this.root, t));
+		return createMachineSnapshot({
+			_nodes: [...n],
+			context: e.context || {},
+			children: {},
+			status: isInFinalState(n, this.root) ? "done" : e.status || "active",
+			output: e.output,
+			error: e.error,
+			historyValue: e.historyValue
+		}, this);
+	}
+	transition(e, t, n) {
+		return macrostep(e, t, n, []).snapshot;
+	}
+	microstep(e, t, n) {
+		return macrostep(e, t, n, []).microsteps.map(([e]) => e);
+	}
+	getTransitionData(e, t) {
+		return transitionNode(this.root, e.value, e, t) || [];
+	}
+	_getPreInitialState(e, t, n) {
+		let { context: r } = this.config, i = createMachineSnapshot({
+			context: typeof r != "function" && r ? r : {},
+			_nodes: [this.root],
+			children: {},
+			status: "active"
+		}, this);
+		if (typeof r == "function") {
+			let assignment = ({ spawn: e, event: t, self: n }) => r({
+				spawn: e,
+				input: t.input,
+				self: n
+			});
+			return resolveActionsAndContext(i, t, e, [assign(assignment)], n, void 0);
+		}
+		return i;
+	}
+	getInitialSnapshot(e, t) {
+		let n = createInitEvent(t), r = [], i = this._getPreInitialState(e, n, r), [a] = initialMicrostep(this.root, i, e, n, r), { snapshot: o } = macrostep(a, n, e, r);
+		return o;
+	}
+	start(e) {
+		Object.values(e.children).forEach((e) => {
+			e.getSnapshot().status === "active" && e.start();
+		});
+	}
+	getStateNodeById(e) {
+		let t = toStatePath(e), n = t.slice(1), r = isStateId(t[0]) ? t[0].slice(1) : t[0], i = this.idMap.get(r);
+		if (!i) throw Error(`Child state node '#${r}' does not exist on machine '${this.id}'`);
+		return getStateNodeByPath(i, n);
+	}
+	get definition() {
+		return this.root.definition;
+	}
+	toJSON() {
+		return this.definition;
+	}
+	getPersistedSnapshot(e, t) {
+		return getPersistedSnapshot(e, t);
+	}
+	restoreSnapshot(e, t) {
+		let n = {}, r = e.children;
+		Object.keys(r).forEach((e) => {
+			let i = r[e], a = i.snapshot, o = i.src, s = typeof o == "string" ? resolveReferencedActor(this, o) : o;
+			s && (n[e] = createActor(s, {
+				id: e,
+				parent: t.self,
+				syncSnapshot: i.syncSnapshot,
+				snapshot: a,
+				src: o,
+				systemId: i.systemId
+			}));
+		});
+		function resolveHistoryReferencedState(e, t) {
+			if (t instanceof O) return t;
+			try {
+				return e.machine.getStateNodeById(t.id);
+			} catch {}
+		}
+		function reviveHistoryValue(e, t) {
+			if (!t || typeof t != "object") return {};
+			let n = {};
+			for (let r in t) {
+				let i = t[r];
+				for (let t of i) {
+					let i = resolveHistoryReferencedState(e, t);
+					i && (n[r] ??= [], n[r].push(i));
+				}
+			}
+			return n;
+		}
+		let i = reviveHistoryValue(this.root, e.historyValue), a = createMachineSnapshot({
+			...e,
+			children: n,
+			_nodes: Array.from(getAllStateNodes(getStateNodes(this.root, e.value))),
+			historyValue: i
+		}, this), o = /* @__PURE__ */ new Set();
+		function reviveContext(e, t) {
+			if (!o.has(e)) {
+				o.add(e);
+				for (let n in e) {
+					let r = e[n];
+					if (r && typeof r == "object") {
+						if ("xstate$$type" in r && r.xstate$$type === 1) {
+							e[n] = t[r.id];
+							continue;
+						}
+						reviveContext(r, t);
+					}
+				}
+			}
+		}
+		return reviveContext(a.context, n), a;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.0/node_modules/xstate/dist/log-605ef461.esm.js
+function resolveEmit(e, t, n, r, { event: i }) {
+	return [
+		t,
+		{ event: typeof i == "function" ? i(n, r) : i },
+		void 0
+	];
+}
+function executeEmit(e, { event: t }) {
+	e.defer(() => e.emit(t));
+}
+function emit(e) {
+	function emit(e, t) {}
+	return emit.type = "xstate.emit", emit.event = e, emit.resolve = resolveEmit, emit.execute = executeEmit, emit;
+}
+var A = /* @__PURE__ */ function(e) {
+	return e.Parent = "#_parent", e.Internal = "#_internal", e;
+}({});
+function resolveSendTo(e, t, n, r, { to: i, event: a, id: o, delay: s }, c) {
+	let l = t.machine.implementations.delays;
+	if (typeof a == "string") throw Error(`Only event objects may be used with sendTo; use sendTo({ type: "${a}" }) instead`);
+	let u = typeof a == "function" ? a(n, r) : a, d;
+	if (typeof s == "string") {
+		let e = l && l[s];
+		d = typeof e == "function" ? e(n, r) : e;
+	} else d = typeof s == "function" ? s(n, r) : s;
+	let f = typeof i == "function" ? i(n, r) : i, p;
+	if (typeof f == "string") {
+		if (p = f === A.Parent ? e.self._parent : f === A.Internal ? e.self : f.startsWith("#_") ? t.children[f.slice(2)] : c.deferredActorIds?.includes(f) ? f : t.children[f], !p) throw Error(`Unable to send event to actor '${f}' from machine '${t.machine.id}'.`);
+	} else p = f || e.self;
+	return [
+		t,
+		{
+			to: p,
+			targetId: typeof f == "string" ? f : void 0,
+			event: u,
+			id: o,
+			delay: d
+		},
+		void 0
+	];
+}
+function retryResolveSendTo(e, t, n) {
+	typeof n.to == "string" && (n.to = t.children[n.to]);
+}
+function executeSendTo(e, t) {
+	e.defer(() => {
+		let { to: n, event: r, delay: i, id: a } = t;
+		if (typeof i == "number") {
+			e.system.scheduler.schedule(e.self, n, r, i, a);
+			return;
+		}
+		e.system._relay(e.self, n, r.type === "xstate.error" ? createErrorActorEvent(e.self.id, r.data) : r);
+	});
+}
+function sendTo(e, t, n) {
+	function sendTo(e, t) {}
+	return sendTo.type = "xstate.sendTo", sendTo.to = e, sendTo.event = t, sendTo.id = n?.id, sendTo.delay = n?.delay, sendTo.resolve = resolveSendTo, sendTo.retryResolve = retryResolveSendTo, sendTo.execute = executeSendTo, sendTo;
+}
+function sendParent(e, t) {
+	return sendTo(A.Parent, e, t);
+}
+function resolveEnqueueActions(e, t, n, r, { collect: i }) {
+	let a = [], o = function enqueue(e) {
+		a.push(e);
+	};
+	return o.assign = (...e) => {
+		a.push(assign(...e));
+	}, o.cancel = (...e) => {
+		a.push(cancel(...e));
+	}, o.raise = (...e) => {
+		a.push(raise(...e));
+	}, o.sendTo = (...e) => {
+		a.push(sendTo(...e));
+	}, o.sendParent = (...e) => {
+		a.push(sendParent(...e));
+	}, o.spawnChild = (...e) => {
+		a.push(spawnChild(...e));
+	}, o.stopChild = (...e) => {
+		a.push(stopChild(...e));
+	}, o.emit = (...e) => {
+		a.push(emit(...e));
+	}, i({
+		context: n.context,
+		event: n.event,
+		enqueue: o,
+		check: (e) => evaluateGuard(e, t.context, n.event, t),
+		self: e.self,
+		system: e.system
+	}, r), [
+		t,
+		void 0,
+		a
+	];
+}
+function enqueueActions(e) {
+	function enqueueActions(e, t) {}
+	return enqueueActions.type = "xstate.enqueueActions", enqueueActions.collect = e, enqueueActions.resolve = resolveEnqueueActions, enqueueActions;
+}
+function resolveLog(e, t, n, r, { value: i, label: a }) {
+	return [
+		t,
+		{
+			value: typeof i == "function" ? i(n, r) : i,
+			label: a
+		},
+		void 0
+	];
+}
+function executeLog({ logger: e }, { value: t, label: n }) {
+	n ? e(n, t) : e(t);
+}
+function log(e = ({ context: e, event: t }) => ({
+	context: e,
+	event: t
+}), t) {
+	function log(e, t) {}
+	return log.type = "xstate.log", log.value = e, log.label = t, log.resolve = resolveLog, log.execute = executeLog, log;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.0/node_modules/xstate/dist/xstate.esm.js
+function assertEvent(e, t) {
+	let n = toArray(t);
+	if (!n.some((t) => matchesEventDescriptor(e.type, t))) {
+		let t = n.length === 1 ? `type matching "${n[0]}"` : `one of types matching "${n.join("\", \"")}"`;
+		throw Error(`Expected event ${JSON.stringify(e)} to have ${t}`);
+	}
+}
+function createMachine(e, t) {
+	return new k(e, t);
+}
+function setup({ schemas: e, actors: t, actions: n, guards: r, delays: i }) {
+	return {
+		assign,
+		sendTo,
+		raise,
+		log,
+		cancel,
+		stopChild,
+		enqueueActions,
+		emit,
+		spawnChild,
+		createStateConfig: (e) => e,
+		createAction: (e) => e,
+		createMachine: (a) => createMachine({
+			...a,
+			schemas: e
+		}, {
+			actors: t,
+			actions: n,
+			guards: r,
+			delays: i
+		}),
+		extend: (a) => setup({
+			schemas: e,
+			actors: t,
+			actions: {
+				...n,
+				...a.actions
+			},
+			guards: {
+				...r,
+				...a.guards
+			},
+			delays: {
+				...i,
+				...a.delays
+			}
+		})
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@xstate+react@6.1.0_@types+react@19.2.16_react@19.2.7_xstate@5.32.0/node_modules/@xstate/react/dist/xstate-react.esm.js
+var forEachActor = (e, t) => {
+	t(e);
+	let n = e.getSnapshot().children;
+	n && Object.values(n).forEach((e) => {
+		forEachActor(e, t);
+	});
+};
+function stopRootWithRehydration(e) {
+	let t = [];
+	forEachActor(e, (e) => {
+		t.push([e, e.getSnapshot()]), e.observers = /* @__PURE__ */ new Set();
+	});
+	let n = e.system.getSnapshot?.();
+	e.stop(), e.system._snapshot = n, t.forEach(([e, t]) => {
+		e._processingStatus = 0, e._snapshot = t;
+	});
+}
+function useIdleActorRef(e, ...[t]) {
+	let [[n, r], a] = i(() => {
+		let n = createActor(e, t);
+		return [e.config, n];
+	});
+	if (e.config !== n) {
+		let n = createActor(e, {
+			...t,
+			snapshot: r.getPersistedSnapshot({ __unsafeAllowInlineActors: !0 })
+		});
+		a([e.config, n]), r = n;
+	}
+	return o(() => {
+		r.logic.implementations = e.implementations;
+	}), r;
+}
+function useActorRef(e, ...[t, r]) {
+	let i = useIdleActorRef(e, t);
+	return n(() => {
+		if (!r) return;
+		let e = i.subscribe(toObserver(r));
+		return () => {
+			e.unsubscribe();
+		};
+	}, [r]), n(() => (i.start(), () => {
+		stopRootWithRehydration(i);
+	}), [i]), i;
+}
+function defaultCompare(e, t) {
+	return e === t;
+}
+function useSelector(e, n, r = defaultCompare) {
+	let i = t((t) => {
+		if (!e) return () => {};
+		let { unsubscribe: n } = e.subscribe({
+			next: t,
+			error: t
+		});
+		return n;
+	}, [e]), o = t(() => {
+		let t = e?.getSnapshot();
+		if (t && "status" in t && t.status === "error") throw t.error;
+		return t;
+	}, [e]);
+	return a(i, o, o, n, r);
+}
+//#endregion
+export { stopChild as _, emit as a, sendTo as c, fromPromise as d, and as f, spawnChild as g, raise as h, setup as i, assign as l, or as m, useSelector as n, enqueueActions as o, cancel as p, assertEvent as r, log as s, useActorRef as t, fromCallback as u };