@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/xstate.esm-B_rda9yU.esm.js

@@ -0,0 +1,3261 @@
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dev/dist/xstate-dev.esm.js
+function getGlobal() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+}
+function getDevTools() {
+	const w = getGlobal();
+	if (w.__xstate__) return w.__xstate__;
+}
+const devToolsAdapter = (service) => {
+	if (typeof window === "undefined") return;
+	const devTools = getDevTools();
+	if (devTools) devTools.register(service);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/raise-9ad1c5c6.esm.js
+var Mailbox = class {
+	constructor(_process) {
+		this._process = _process;
+		this._active = false;
+		this._current = null;
+		this._last = null;
+	}
+	start() {
+		this._active = true;
+		this.flush();
+	}
+	clear() {
+		if (this._current) {
+			this._current.next = null;
+			this._last = this._current;
+		}
+	}
+	enqueue(event) {
+		const enqueued = {
+			value: event,
+			next: null
+		};
+		if (this._current) {
+			this._last.next = enqueued;
+			this._last = enqueued;
+			return;
+		}
+		this._current = enqueued;
+		this._last = enqueued;
+		if (this._active) this.flush();
+	}
+	flush() {
+		while (this._current) {
+			const consumed = this._current;
+			this._process(consumed.value);
+			this._current = consumed.next;
+		}
+		this._last = null;
+	}
+};
+const STATE_DELIMITER = ".";
+const TARGETLESS_KEY = "";
+const NULL_EVENT = "";
+const STATE_IDENTIFIER = "#";
+const WILDCARD = "*";
+const XSTATE_INIT = "xstate.init";
+const XSTATE_ERROR = "xstate.error";
+const XSTATE_STOP = "xstate.stop";
+/**
+* Returns an event that represents an implicit event that is sent after the
+* specified `delay`.
+*
+* @param delayRef The delay in milliseconds
+* @param id The state node ID where this event is handled
+*/
+function createAfterEvent(delayRef, id) {
+	return { type: `xstate.after.${delayRef}.${id}` };
+}
+/**
+* Returns an event that represents that a final state node has been reached in
+* the parent state node.
+*
+* @param id The final state node's parent state node `id`
+* @param output The data to pass into the event
+*/
+function createDoneStateEvent(id, output) {
+	return {
+		type: `xstate.done.state.${id}`,
+		output
+	};
+}
+/**
+* Returns an event that represents that an invoked service has terminated.
+*
+* An invoked service is terminated when it has reached a top-level final state
+* node, but not when it is canceled.
+*
+* @param invokeId The invoked service ID
+* @param output The data to pass into the event
+*/
+function createDoneActorEvent(invokeId, output) {
+	return {
+		type: `xstate.done.actor.${invokeId}`,
+		output,
+		actorId: invokeId
+	};
+}
+function createErrorActorEvent(id, error) {
+	return {
+		type: `xstate.error.actor.${id}`,
+		error,
+		actorId: id
+	};
+}
+function createInitEvent(input) {
+	return {
+		type: XSTATE_INIT,
+		input
+	};
+}
+/**
+* This function makes sure that unhandled errors are thrown in a separate
+* macrotask. It allows those errors to be detected by global error handlers and
+* reported to bug tracking services without interrupting our own stack of
+* execution.
+*
+* @param err Error to be thrown
+*/
+function reportUnhandledError(err) {
+	setTimeout(() => {
+		throw err;
+	});
+}
+const symbolObservable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+function matchesState(parentStateId, childStateId) {
+	const parentStateValue = toStateValue(parentStateId);
+	const childStateValue = toStateValue(childStateId);
+	if (typeof childStateValue === "string") {
+		if (typeof parentStateValue === "string") return childStateValue === parentStateValue;
+		return false;
+	}
+	if (typeof parentStateValue === "string") return parentStateValue in childStateValue;
+	return Object.keys(parentStateValue).every((key) => {
+		if (!(key in childStateValue)) return false;
+		return matchesState(parentStateValue[key], childStateValue[key]);
+	});
+}
+function toStatePath(stateId) {
+	if (isArray(stateId)) return stateId;
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < stateId.length; i++) {
+		switch (stateId.charCodeAt(i)) {
+			case 92:
+				segment += stateId[i + 1];
+				i++;
+				continue;
+			case 46:
+				result.push(segment);
+				segment = "";
+				continue;
+		}
+		segment += stateId[i];
+	}
+	result.push(segment);
+	return result;
+}
+function toStateValue(stateValue) {
+	if (isMachineSnapshot(stateValue)) return stateValue.value;
+	if (typeof stateValue !== "string") return stateValue;
+	return pathToStateValue(toStatePath(stateValue));
+}
+function pathToStateValue(statePath) {
+	if (statePath.length === 1) return statePath[0];
+	const value = {};
+	let marker = value;
+	for (let i = 0; i < statePath.length - 1; i++) if (i === statePath.length - 2) marker[statePath[i]] = statePath[i + 1];
+	else {
+		const previous = marker;
+		marker = {};
+		previous[statePath[i]] = marker;
+	}
+	return value;
+}
+function mapValues(collection, iteratee) {
+	const result = {};
+	const collectionKeys = Object.keys(collection);
+	for (let i = 0; i < collectionKeys.length; i++) {
+		const key = collectionKeys[i];
+		result[key] = iteratee(collection[key], key, collection, i);
+	}
+	return result;
+}
+function toArrayStrict(value) {
+	if (isArray(value)) return value;
+	return [value];
+}
+function toArray(value) {
+	if (value === void 0) return [];
+	return toArrayStrict(value);
+}
+function resolveOutput(mapper, context, event, self$1) {
+	if (typeof mapper === "function") return mapper({
+		context,
+		event,
+		self: self$1
+	});
+	return mapper;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isErrorActorEvent(event) {
+	return event.type.startsWith("xstate.error.actor");
+}
+function toTransitionConfigArray(configLike) {
+	return toArrayStrict(configLike).map((transitionLike) => {
+		if (typeof transitionLike === "undefined" || typeof transitionLike === "string") return { target: transitionLike };
+		return transitionLike;
+	});
+}
+function normalizeTarget(target) {
+	if (target === void 0 || target === TARGETLESS_KEY) return;
+	return toArray(target);
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self$1 = isObserver ? nextHandler : void 0;
+	return {
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self$1),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self$1),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self$1)
+	};
+}
+function createInvokeId(stateNodeId, index) {
+	return `${index}.${stateNodeId}`;
+}
+function resolveReferencedActor(machine, src) {
+	const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+	if (!match) return machine.implementations.actors[src];
+	const [, indexStr, nodeId] = match;
+	const invokeConfig = machine.getStateNodeById(nodeId).config.invoke;
+	return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+}
+function createScheduledEventId(actorRef, id) {
+	return `${actorRef.sessionId}.${id}`;
+}
+let idCounter = 0;
+function createSystem(rootActor, options) {
+	const children = /* @__PURE__ */ new Map();
+	const keyedActors = /* @__PURE__ */ new Map();
+	const reverseKeyedActors = /* @__PURE__ */ new WeakMap();
+	const inspectionObservers = /* @__PURE__ */ new Set();
+	const timerMap = {};
+	const { clock, logger } = options;
+	const scheduler = {
+		schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
+			const scheduledEvent = {
+				source,
+				target,
+				event,
+				delay,
+				id,
+				startedAt: Date.now()
+			};
+			const scheduledEventId = createScheduledEventId(source, id);
+			system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+			timerMap[scheduledEventId] = clock.setTimeout(() => {
+				delete timerMap[scheduledEventId];
+				delete system._snapshot._scheduledEvents[scheduledEventId];
+				system._relay(source, target, event);
+			}, delay);
+		},
+		cancel: (source, id) => {
+			const scheduledEventId = createScheduledEventId(source, id);
+			const timeout = timerMap[scheduledEventId];
+			delete timerMap[scheduledEventId];
+			delete system._snapshot._scheduledEvents[scheduledEventId];
+			if (timeout !== void 0) clock.clearTimeout(timeout);
+		},
+		cancelAll: (actorRef) => {
+			for (const scheduledEventId in system._snapshot._scheduledEvents) {
+				const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
+				if (scheduledEvent.source === actorRef) scheduler.cancel(actorRef, scheduledEvent.id);
+			}
+		}
+	};
+	const sendInspectionEvent = (event) => {
+		if (!inspectionObservers.size) return;
+		const resolvedInspectionEvent = {
+			...event,
+			rootId: rootActor.sessionId
+		};
+		inspectionObservers.forEach((observer) => observer.next?.(resolvedInspectionEvent));
+	};
+	const system = {
+		_snapshot: { _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {} },
+		_bookId: () => `x:${idCounter++}`,
+		_register: (sessionId, actorRef) => {
+			children.set(sessionId, actorRef);
+			return sessionId;
+		},
+		_unregister: (actorRef) => {
+			children.delete(actorRef.sessionId);
+			const systemId = reverseKeyedActors.get(actorRef);
+			if (systemId !== void 0) {
+				keyedActors.delete(systemId);
+				reverseKeyedActors.delete(actorRef);
+			}
+		},
+		get: (systemId) => {
+			return keyedActors.get(systemId);
+		},
+		getAll: () => {
+			return Object.fromEntries(keyedActors.entries());
+		},
+		_set: (systemId, actorRef) => {
+			const existing = keyedActors.get(systemId);
+			if (existing && existing !== actorRef) throw new Error(`Actor with system ID '${systemId}' already exists.`);
+			keyedActors.set(systemId, actorRef);
+			reverseKeyedActors.set(actorRef, systemId);
+		},
+		inspect: (observerOrFn) => {
+			const observer = toObserver(observerOrFn);
+			inspectionObservers.add(observer);
+			return { unsubscribe() {
+				inspectionObservers.delete(observer);
+			} };
+		},
+		_sendInspectionEvent: sendInspectionEvent,
+		_relay: (source, target, event) => {
+			system._sendInspectionEvent({
+				type: "@xstate.event",
+				sourceRef: source,
+				actorRef: target,
+				event
+			});
+			target._send(event);
+		},
+		scheduler,
+		getSnapshot: () => {
+			return { _scheduledEvents: { ...system._snapshot._scheduledEvents } };
+		},
+		start: () => {
+			const scheduledEvents = system._snapshot._scheduledEvents;
+			system._snapshot._scheduledEvents = {};
+			for (const scheduledId in scheduledEvents) {
+				const { source, target, event, delay, id } = scheduledEvents[scheduledId];
+				scheduler.schedule(source, target, event, delay, id);
+			}
+		},
+		_clock: clock,
+		_logger: logger
+	};
+	return system;
+}
+let executingCustomAction = false;
+const $$ACTOR_TYPE = 1;
+let ProcessingStatus = /* @__PURE__ */ function(ProcessingStatus$1) {
+	ProcessingStatus$1[ProcessingStatus$1["NotStarted"] = 0] = "NotStarted";
+	ProcessingStatus$1[ProcessingStatus$1["Running"] = 1] = "Running";
+	ProcessingStatus$1[ProcessingStatus$1["Stopped"] = 2] = "Stopped";
+	return ProcessingStatus$1;
+}({});
+const defaultOptions = {
+	clock: {
+		setTimeout: (fn, ms) => {
+			return setTimeout(fn, ms);
+		},
+		clearTimeout: (id) => {
+			return clearTimeout(id);
+		}
+	},
+	logger: console.log.bind(console),
+	devTools: false
+};
+/**
+* An Actor is a running process that can receive events, send events and change
+* its behavior based on the events it receives, which can cause effects outside
+* of the actor. When you run a state machine, it becomes an actor.
+*/
+var Actor = class {
+	/**
+	* Creates a new actor instance for the given logic with the provided options,
+	* if any.
+	*
+	* @param logic The logic to create an actor from
+	* @param options Actor options
+	*/
+	constructor(logic, options) {
+		this.logic = logic;
+		/** The current internal state of the actor. */
+		this._snapshot = void 0;
+		/**
+		* The clock that is responsible for setting and clearing timeouts, such as
+		* delayed events and transitions.
+		*/
+		this.clock = void 0;
+		this.options = void 0;
+		/** The unique identifier for this actor relative to its parent. */
+		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;
+		/** @internal */
+		this._processingStatus = ProcessingStatus.NotStarted;
+		this._parent = void 0;
+		/** @internal */
+		this._syncSnapshot = void 0;
+		this.ref = void 0;
+		this._actorScope = void 0;
+		this.systemId = void 0;
+		/** The globally unique process ID for this invocation. */
+		this.sessionId = void 0;
+		/** The system to which this actor belongs. */
+		this.system = void 0;
+		this._doneEvent = void 0;
+		this.src = void 0;
+		this._deferred = [];
+		const resolvedOptions = {
+			...defaultOptions,
+			...options
+		};
+		const { clock, logger, parent, syncSnapshot, id, systemId, inspect } = resolvedOptions;
+		this.system = parent ? parent.system : createSystem(this, {
+			clock,
+			logger
+		});
+		if (inspect && !parent) this.system.inspect(toObserver(inspect));
+		this.sessionId = this.system._bookId();
+		this.id = id ?? this.sessionId;
+		this.logger = options?.logger ?? this.system._logger;
+		this.clock = options?.clock ?? this.system._clock;
+		this._parent = parent;
+		this._syncSnapshot = syncSnapshot;
+		this.options = resolvedOptions;
+		this.src = resolvedOptions.src ?? logic;
+		this.ref = this;
+		this._actorScope = {
+			self: this,
+			id: this.id,
+			sessionId: this.sessionId,
+			logger: this.logger,
+			defer: (fn) => {
+				this._deferred.push(fn);
+			},
+			system: this.system,
+			stopChild: (child) => {
+				if (child._parent !== this) throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child`);
+				child._stop();
+			},
+			emit: (emittedEvent) => {
+				const listeners = this.eventListeners.get(emittedEvent.type);
+				const wildcardListener = this.eventListeners.get("*");
+				if (!listeners && !wildcardListener) return;
+				const allListeners = [...listeners ? listeners.values() : [], ...wildcardListener ? wildcardListener.values() : []];
+				for (const handler of allListeners) try {
+					handler(emittedEvent);
+				} catch (err) {
+					reportUnhandledError(err);
+				}
+			},
+			actionExecutor: (action) => {
+				const exec = () => {
+					this._actorScope.system._sendInspectionEvent({
+						type: "@xstate.action",
+						actorRef: this,
+						action: {
+							type: action.type,
+							params: action.params
+						}
+					});
+					if (!action.exec) return;
+					const saveExecutingCustomAction = executingCustomAction;
+					try {
+						executingCustomAction = true;
+						action.exec(action.info, action.params);
+					} finally {
+						executingCustomAction = saveExecutingCustomAction;
+					}
+				};
+				if (this._processingStatus === ProcessingStatus.Running) exec();
+				else this._deferred.push(exec);
+			}
+		};
+		this.send = this.send.bind(this);
+		this.system._sendInspectionEvent({
+			type: "@xstate.actor",
+			actorRef: this
+		});
+		if (systemId) {
+			this.systemId = systemId;
+			this.system._set(systemId, this);
+		}
+		this._initState(options?.snapshot ?? options?.state);
+		if (systemId && this._snapshot.status !== "active") this.system._unregister(this);
+	}
+	_initState(persistedState) {
+		try {
+			this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+		} catch (err) {
+			this._snapshot = {
+				status: "error",
+				output: void 0,
+				error: err
+			};
+		}
+	}
+	update(snapshot, event) {
+		this._snapshot = snapshot;
+		let deferredFn;
+		while (deferredFn = this._deferred.shift()) try {
+			deferredFn();
+		} catch (err) {
+			this._deferred.length = 0;
+			this._snapshot = {
+				...snapshot,
+				status: "error",
+				error: err
+			};
+		}
+		switch (this._snapshot.status) {
+			case "active":
+				for (const observer of this.observers) try {
+					observer.next?.(snapshot);
+				} catch (err) {
+					reportUnhandledError(err);
+				}
+				break;
+			case "done":
+				for (const observer of this.observers) try {
+					observer.next?.(snapshot);
+				} catch (err) {
+					reportUnhandledError(err);
+				}
+				this._stopProcedure();
+				this._complete();
+				this._doneEvent = createDoneActorEvent(this.id, this._snapshot.output);
+				if (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,
+			snapshot
+		});
+	}
+	/**
+	* Subscribe an observer to an actor’s snapshot values.
+	*
+	* @remarks
+	* The observer will receive the actor’s snapshot value when it is emitted.
+	* The observer can be:
+	*
+	* - A plain function that receives the latest snapshot, or
+	* - An observer object whose `.next(snapshot)` method receives the latest
+	*   snapshot
+	*
+	* @example
+	*
+	* ```ts
+	* // Observer as a plain function
+	* const subscription = actor.subscribe((snapshot) => {
+	*   console.log(snapshot);
+	* });
+	* ```
+	*
+	* @example
+	*
+	* ```ts
+	* // Observer as an object
+	* const subscription = actor.subscribe({
+	*   next(snapshot) {
+	*     console.log(snapshot);
+	*   },
+	*   error(err) {
+	*     // ...
+	*   },
+	*   complete() {
+	*     // ...
+	*   }
+	* });
+	* ```
+	*
+	* The return value of `actor.subscribe(observer)` is a subscription object
+	* that has an `.unsubscribe()` method. You can call
+	* `subscription.unsubscribe()` to unsubscribe the observer:
+	*
+	* @example
+	*
+	* ```ts
+	* const subscription = actor.subscribe((snapshot) => {
+	*   // ...
+	* });
+	*
+	* // Unsubscribe the observer
+	* subscription.unsubscribe();
+	* ```
+	*
+	* When the actor is stopped, all of its observers will automatically be
+	* unsubscribed.
+	*
+	* @param observer - Either a plain function that receives the latest
+	*   snapshot, or an observer object whose `.next(snapshot)` method receives
+	*   the latest snapshot
+	*/
+	subscribe(nextListenerOrObserver, errorListener, completeListener) {
+		const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+		if (this._processingStatus !== ProcessingStatus.Stopped) this.observers.add(observer);
+		else switch (this._snapshot.status) {
+			case "done":
+				try {
+					observer.complete?.();
+				} catch (err) {
+					reportUnhandledError(err);
+				}
+				break;
+			case "error": {
+				const err = this._snapshot.error;
+				if (!observer.error) reportUnhandledError(err);
+				else try {
+					observer.error(err);
+				} catch (err$1) {
+					reportUnhandledError(err$1);
+				}
+				break;
+			}
+		}
+		return { unsubscribe: () => {
+			this.observers.delete(observer);
+		} };
+	}
+	on(type, handler) {
+		let listeners = this.eventListeners.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.eventListeners.set(type, listeners);
+		}
+		const wrappedHandler = handler.bind(void 0);
+		listeners.add(wrappedHandler);
+		return { unsubscribe: () => {
+			listeners.delete(wrappedHandler);
+		} };
+	}
+	/** Starts the Actor from the initial state */
+	start() {
+		if (this._processingStatus === ProcessingStatus.Running) return this;
+		if (this._syncSnapshot) this.subscribe({
+			next: (snapshot) => {
+				if (snapshot.status === "active") this.system._relay(this, this._parent, {
+					type: `xstate.snapshot.${this.id}`,
+					snapshot
+				});
+			},
+			error: () => {}
+		});
+		this.system._register(this.sessionId, this);
+		if (this.systemId) this.system._set(this.systemId, this);
+		this._processingStatus = ProcessingStatus.Running;
+		const initEvent = createInitEvent(this.options.input);
+		this.system._sendInspectionEvent({
+			type: "@xstate.event",
+			sourceRef: this._parent,
+			actorRef: this,
+			event: initEvent
+		});
+		switch (this._snapshot.status) {
+			case "done":
+				this.update(this._snapshot, initEvent);
+				return this;
+			case "error":
+				this._error(this._snapshot.error);
+				return this;
+		}
+		if (!this._parent) this.system.start();
+		if (this.logic.start) try {
+			this.logic.start(this._snapshot, this._actorScope);
+		} catch (err) {
+			this._snapshot = {
+				...this._snapshot,
+				status: "error",
+				error: err
+			};
+			this._error(err);
+			return this;
+		}
+		this.update(this._snapshot, initEvent);
+		if (this.options.devTools) this.attachDevTools();
+		this.mailbox.start();
+		return this;
+	}
+	_process(event) {
+		let nextState;
+		let caughtError;
+		try {
+			nextState = this.logic.transition(this._snapshot, event, this._actorScope);
+		} catch (err) {
+			caughtError = { err };
+		}
+		if (caughtError) {
+			const { err } = caughtError;
+			this._snapshot = {
+				...this._snapshot,
+				status: "error",
+				error: err
+			};
+			this._error(err);
+			return;
+		}
+		this.update(nextState, event);
+		if (event.type === XSTATE_STOP) {
+			this._stopProcedure();
+			this._complete();
+		}
+	}
+	_stop() {
+		if (this._processingStatus === ProcessingStatus.Stopped) return this;
+		this.mailbox.clear();
+		if (this._processingStatus === ProcessingStatus.NotStarted) {
+			this._processingStatus = ProcessingStatus.Stopped;
+			return this;
+		}
+		this.mailbox.enqueue({ type: XSTATE_STOP });
+		return this;
+	}
+	/** Stops the Actor and unsubscribe all listeners. */
+	stop() {
+		if (this._parent) throw new Error("A non-root actor cannot be stopped directly.");
+		return this._stop();
+	}
+	_complete() {
+		for (const observer of this.observers) try {
+			observer.complete?.();
+		} catch (err) {
+			reportUnhandledError(err);
+		}
+		this.observers.clear();
+	}
+	_reportError(err) {
+		if (!this.observers.size) {
+			if (!this._parent) reportUnhandledError(err);
+			return;
+		}
+		let reportError = false;
+		for (const observer of this.observers) {
+			const errorListener = observer.error;
+			reportError ||= !errorListener;
+			try {
+				errorListener?.(err);
+			} catch (err2) {
+				reportUnhandledError(err2);
+			}
+		}
+		this.observers.clear();
+		if (reportError) reportUnhandledError(err);
+	}
+	_error(err) {
+		this._stopProcedure();
+		this._reportError(err);
+		if (this._parent) this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
+	}
+	_stopProcedure() {
+		if (this._processingStatus !== ProcessingStatus.Running) return this;
+		this.system.scheduler.cancelAll(this);
+		this.mailbox.clear();
+		this.mailbox = new Mailbox(this._process.bind(this));
+		this._processingStatus = ProcessingStatus.Stopped;
+		this.system._unregister(this);
+		return this;
+	}
+	/** @internal */
+	_send(event) {
+		if (this._processingStatus === ProcessingStatus.Stopped) return;
+		this.mailbox.enqueue(event);
+	}
+	/**
+	* Sends an event to the running Actor to trigger a transition.
+	*
+	* @param event The event to send
+	*/
+	send(event) {
+		this.system._relay(void 0, this, event);
+	}
+	attachDevTools() {
+		const { devTools } = this.options;
+		if (devTools) (typeof devTools === "function" ? devTools : devToolsAdapter)(this);
+	}
+	toJSON() {
+		return {
+			xstate$$type: $$ACTOR_TYPE,
+			id: this.id
+		};
+	}
+	/**
+	* Obtain the internal state of the actor, which can be persisted.
+	*
+	* @remarks
+	* The internal state can be persisted from any actor, not only machines.
+	*
+	* Note that the persisted state is not the same as the snapshot from
+	* {@link Actor.getSnapshot}. Persisted state represents the internal state of
+	* the actor, while snapshots represent the actor's last emitted value.
+	*
+	* Can be restored with {@link ActorOptions.state}
+	* @see https://stately.ai/docs/persistence
+	*/
+	getPersistedSnapshot(options) {
+		return this.logic.getPersistedSnapshot(this._snapshot, options);
+	}
+	[symbolObservable]() {
+		return this;
+	}
+	/**
+	* Read an actor’s snapshot synchronously.
+	*
+	* @remarks
+	* The snapshot represent an actor's last emitted value.
+	*
+	* When an actor receives an event, its internal state may change. An actor
+	* may emit a snapshot when a state transition occurs.
+	*
+	* Note that some actors, such as callback actors generated with
+	* `fromCallback`, will not emit snapshots.
+	* @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+	* @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
+	*/
+	getSnapshot() {
+		return this._snapshot;
+	}
+};
+/**
+* Creates a new actor instance for the given actor logic with the provided
+* options, if any.
+*
+* @remarks
+* When you create an actor from actor logic via `createActor(logic)`, you
+* implicitly create an actor system where the created actor is the root actor.
+* Any actors spawned from this root actor and its descendants are part of that
+* actor system.
+* @example
+*
+* ```ts
+* import { createActor } from 'xstate';
+* import { someActorLogic } from './someActorLogic.ts';
+*
+* // Creating the actor, which implicitly creates an actor system with itself as the root actor
+* const actor = createActor(someActorLogic);
+*
+* actor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+*
+* // Actors must be started by calling `actor.start()`, which will also start the actor system.
+* actor.start();
+*
+* // Actors can receive events
+* actor.send({ type: 'someEvent' });
+*
+* // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+* actor.stop();
+* ```
+*
+* @param logic - The actor logic to create an actor from. For a state machine
+*   actor logic creator, see {@link createMachine}. Other actor logic creators
+*   include {@link fromCallback}, {@link fromEventObservable},
+*   {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+* @param options - Actor options
+*/
+function createActor(logic, ...[options]) {
+	return new Actor(logic, options);
+}
+/**
+* @deprecated Use `Actor` instead.
+* @alias
+*/
+function resolveCancel(_, snapshot, actionArgs, actionParams, { sendId }) {
+	return [
+		snapshot,
+		{ sendId: typeof sendId === "function" ? sendId(actionArgs, actionParams) : sendId },
+		void 0
+	];
+}
+function executeCancel(actorScope, params) {
+	actorScope.defer(() => {
+		actorScope.system.scheduler.cancel(actorScope.self, params.sendId);
+	});
+}
+/**
+* Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
+* canceled `sendTo(...)` action will not send its event or execute, unless the
+* `delay` has already elapsed before `cancel(...)` is called.
+*
+* @example
+*
+* ```ts
+* import { createMachine, sendTo, cancel } from 'xstate';
+*
+* const machine = createMachine({
+*   // ...
+*   on: {
+*     sendEvent: {
+*       actions: sendTo(
+*         'some-actor',
+*         { type: 'someEvent' },
+*         {
+*           id: 'some-id',
+*           delay: 1000
+*         }
+*       )
+*     },
+*     cancelEvent: {
+*       actions: cancel('some-id')
+*     }
+*   }
+* });
+* ```
+*
+* @param sendId The `id` of the `sendTo(...)` action to cancel.
+*/
+function cancel(sendId) {
+	function cancel$1(_args, _params) {}
+	cancel$1.type = "xstate.cancel";
+	cancel$1.sendId = sendId;
+	cancel$1.resolve = resolveCancel;
+	cancel$1.execute = executeCancel;
+	return cancel$1;
+}
+function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, { id, systemId, src, input, syncSnapshot }) {
+	const logic = typeof src === "string" ? resolveReferencedActor(snapshot.machine, src) : src;
+	const resolvedId = typeof id === "function" ? id(actionArgs) : id;
+	let actorRef;
+	let resolvedInput = void 0;
+	if (logic) {
+		resolvedInput = typeof input === "function" ? input({
+			context: snapshot.context,
+			event: actionArgs.event,
+			self: actorScope.self
+		}) : input;
+		actorRef = createActor(logic, {
+			id: resolvedId,
+			src,
+			parent: actorScope.self,
+			syncSnapshot,
+			systemId,
+			input: resolvedInput
+		});
+	}
+	return [
+		cloneMachineSnapshot(snapshot, { children: {
+			...snapshot.children,
+			[resolvedId]: actorRef
+		} }),
+		{
+			id,
+			systemId,
+			actorRef,
+			src,
+			input: resolvedInput
+		},
+		void 0
+	];
+}
+function executeSpawn(actorScope, { actorRef }) {
+	if (!actorRef) return;
+	actorScope.defer(() => {
+		if (actorRef._processingStatus === ProcessingStatus.Stopped) return;
+		actorRef.start();
+	});
+}
+function spawnChild(...[src, { id, systemId, input, syncSnapshot = false } = {}]) {
+	function spawnChild$1(_args, _params) {}
+	spawnChild$1.type = "xstate.spawnChild";
+	spawnChild$1.id = id;
+	spawnChild$1.systemId = systemId;
+	spawnChild$1.src = src;
+	spawnChild$1.input = input;
+	spawnChild$1.syncSnapshot = syncSnapshot;
+	spawnChild$1.resolve = resolveSpawn;
+	spawnChild$1.execute = executeSpawn;
+	return spawnChild$1;
+}
+function resolveStop(_, snapshot, args, actionParams, { actorRef }) {
+	const actorRefOrString = typeof actorRef === "function" ? actorRef(args, actionParams) : actorRef;
+	const resolvedActorRef = typeof actorRefOrString === "string" ? snapshot.children[actorRefOrString] : actorRefOrString;
+	let children = snapshot.children;
+	if (resolvedActorRef) {
+		children = { ...children };
+		delete children[resolvedActorRef.id];
+	}
+	return [
+		cloneMachineSnapshot(snapshot, { children }),
+		resolvedActorRef,
+		void 0
+	];
+}
+function executeStop(actorScope, actorRef) {
+	if (!actorRef) return;
+	actorScope.system._unregister(actorRef);
+	if (actorRef._processingStatus !== ProcessingStatus.Running) {
+		actorScope.stopChild(actorRef);
+		return;
+	}
+	actorScope.defer(() => {
+		actorScope.stopChild(actorRef);
+	});
+}
+/**
+* Stops a child actor.
+*
+* @param actorRef The actor to stop.
+*/
+function stopChild(actorRef) {
+	function stop$1(_args, _params) {}
+	stop$1.type = "xstate.stopChild";
+	stop$1.actorRef = actorRef;
+	stop$1.resolve = resolveStop;
+	stop$1.execute = executeStop;
+	return stop$1;
+}
+function evaluateGuard(guard, context, event, snapshot) {
+	const { machine } = snapshot;
+	const isInline = typeof guard === "function";
+	const resolved = isInline ? guard : machine.implementations.guards[typeof guard === "string" ? guard : guard.type];
+	if (!isInline && !resolved) throw new Error(`Guard '${typeof guard === "string" ? guard : guard.type}' is not implemented.'.`);
+	if (typeof resolved !== "function") return evaluateGuard(resolved, context, event, snapshot);
+	const guardArgs = {
+		context,
+		event
+	};
+	const guardParams = isInline || typeof guard === "string" ? void 0 : "params" in guard ? typeof guard.params === "function" ? guard.params({
+		context,
+		event
+	}) : guard.params : void 0;
+	if (!("check" in resolved)) return resolved(guardArgs, guardParams);
+	return resolved.check(snapshot, guardArgs, resolved);
+}
+const isAtomicStateNode = (stateNode) => stateNode.type === "atomic" || stateNode.type === "final";
+function getChildren(stateNode) {
+	return Object.values(stateNode.states).filter((sn) => sn.type !== "history");
+}
+function getProperAncestors(stateNode, toStateNode) {
+	const ancestors = [];
+	if (toStateNode === stateNode) return ancestors;
+	let m = stateNode.parent;
+	while (m && m !== toStateNode) {
+		ancestors.push(m);
+		m = m.parent;
+	}
+	return ancestors;
+}
+function getAllStateNodes(stateNodes) {
+	const nodeSet = new Set(stateNodes);
+	const adjList = getAdjList(nodeSet);
+	for (const s of nodeSet) if (s.type === "compound" && (!adjList.get(s) || !adjList.get(s).length)) getInitialStateNodesWithTheirAncestors(s).forEach((sn) => nodeSet.add(sn));
+	else if (s.type === "parallel") for (const child of getChildren(s)) {
+		if (child.type === "history") continue;
+		if (!nodeSet.has(child)) {
+			const initialStates = getInitialStateNodesWithTheirAncestors(child);
+			for (const initialStateNode of initialStates) nodeSet.add(initialStateNode);
+		}
+	}
+	for (const s of nodeSet) {
+		let m = s.parent;
+		while (m) {
+			nodeSet.add(m);
+			m = m.parent;
+		}
+	}
+	return nodeSet;
+}
+function getValueFromAdj(baseNode, adjList) {
+	const childStateNodes = adjList.get(baseNode);
+	if (!childStateNodes) return {};
+	if (baseNode.type === "compound") {
+		const childStateNode = childStateNodes[0];
+		if (childStateNode) {
+			if (isAtomicStateNode(childStateNode)) return childStateNode.key;
+		} else return {};
+	}
+	const stateValue = {};
+	for (const childStateNode of childStateNodes) stateValue[childStateNode.key] = getValueFromAdj(childStateNode, adjList);
+	return stateValue;
+}
+function getAdjList(stateNodes) {
+	const adjList = /* @__PURE__ */ new Map();
+	for (const s of stateNodes) {
+		if (!adjList.has(s)) adjList.set(s, []);
+		if (s.parent) {
+			if (!adjList.has(s.parent)) adjList.set(s.parent, []);
+			adjList.get(s.parent).push(s);
+		}
+	}
+	return adjList;
+}
+function getStateValue(rootNode, stateNodes) {
+	return getValueFromAdj(rootNode, getAdjList(getAllStateNodes(stateNodes)));
+}
+function isInFinalState(stateNodeSet, stateNode) {
+	if (stateNode.type === "compound") return getChildren(stateNode).some((s) => s.type === "final" && stateNodeSet.has(s));
+	if (stateNode.type === "parallel") return getChildren(stateNode).every((sn) => isInFinalState(stateNodeSet, sn));
+	return stateNode.type === "final";
+}
+const isStateId = (str) => str[0] === STATE_IDENTIFIER;
+function getCandidates(stateNode, receivedEventType) {
+	return stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter((eventDescriptor) => {
+		if (eventDescriptor === WILDCARD) return true;
+		if (!eventDescriptor.endsWith(".*")) return false;
+		const partialEventTokens = eventDescriptor.split(".");
+		const eventTokens = receivedEventType.split(".");
+		for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+			const partialEventToken = partialEventTokens[tokenIndex];
+			const eventToken = eventTokens[tokenIndex];
+			if (partialEventToken === "*") return tokenIndex === partialEventTokens.length - 1;
+			if (partialEventToken !== eventToken) return false;
+		}
+		return true;
+	}).sort((a, b) => b.length - a.length).flatMap((key) => stateNode.transitions.get(key));
+}
+/** All delayed transitions from the config. */
+function getDelayedTransitions(stateNode) {
+	const afterConfig = stateNode.config.after;
+	if (!afterConfig) return [];
+	const mutateEntryExit = (delay) => {
+		const afterEvent = createAfterEvent(delay, stateNode.id);
+		const eventType = afterEvent.type;
+		stateNode.entry.push(raise(afterEvent, {
+			id: eventType,
+			delay
+		}));
+		stateNode.exit.push(cancel(eventType));
+		return eventType;
+	};
+	return Object.keys(afterConfig).flatMap((delay) => {
+		const configTransition = afterConfig[delay];
+		const resolvedTransition = typeof configTransition === "string" ? { target: configTransition } : configTransition;
+		const resolvedDelay = Number.isNaN(+delay) ? delay : +delay;
+		const eventType = mutateEntryExit(resolvedDelay);
+		return toArray(resolvedTransition).map((transition) => ({
+			...transition,
+			event: eventType,
+			delay: resolvedDelay
+		}));
+	}).map((delayedTransition) => {
+		const { delay } = delayedTransition;
+		return {
+			...formatTransition(stateNode, delayedTransition.event, delayedTransition),
+			delay
+		};
+	});
+}
+function formatTransition(stateNode, descriptor, transitionConfig) {
+	const normalizedTarget = normalizeTarget(transitionConfig.target);
+	const reenter = transitionConfig.reenter ?? false;
+	const target = resolveTarget(stateNode, normalizedTarget);
+	const transition = {
+		...transitionConfig,
+		actions: toArray(transitionConfig.actions),
+		guard: transitionConfig.guard,
+		target,
+		source: stateNode,
+		reenter,
+		eventType: descriptor,
+		toJSON: () => ({
+			...transition,
+			source: `#${stateNode.id}`,
+			target: target ? target.map((t) => `#${t.id}`) : void 0
+		})
+	};
+	return transition;
+}
+function formatTransitions(stateNode) {
+	const transitions = /* @__PURE__ */ new Map();
+	if (stateNode.config.on) for (const descriptor of Object.keys(stateNode.config.on)) {
+		if (descriptor === NULL_EVENT) throw new Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
+		const transitionsConfig = stateNode.config.on[descriptor];
+		transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map((t) => formatTransition(stateNode, descriptor, t)));
+	}
+	if (stateNode.config.onDone) {
+		const descriptor = `xstate.done.state.${stateNode.id}`;
+		transitions.set(descriptor, toTransitionConfigArray(stateNode.config.onDone).map((t) => formatTransition(stateNode, descriptor, t)));
+	}
+	for (const invokeDef of stateNode.invoke) {
+		if (invokeDef.onDone) {
+			const descriptor = `xstate.done.actor.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map((t) => formatTransition(stateNode, descriptor, t)));
+		}
+		if (invokeDef.onError) {
+			const descriptor = `xstate.error.actor.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onError).map((t) => formatTransition(stateNode, descriptor, t)));
+		}
+		if (invokeDef.onSnapshot) {
+			const descriptor = `xstate.snapshot.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onSnapshot).map((t) => formatTransition(stateNode, descriptor, t)));
+		}
+	}
+	for (const delayedTransition of stateNode.after) {
+		let existing = transitions.get(delayedTransition.eventType);
+		if (!existing) {
+			existing = [];
+			transitions.set(delayedTransition.eventType, existing);
+		}
+		existing.push(delayedTransition);
+	}
+	return transitions;
+}
+function formatInitialTransition(stateNode, _target) {
+	const resolvedTarget = typeof _target === "string" ? stateNode.states[_target] : _target ? stateNode.states[_target.target] : void 0;
+	if (!resolvedTarget && _target) throw new Error(`Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
+	const transition = {
+		source: stateNode,
+		actions: !_target || typeof _target === "string" ? [] : toArray(_target.actions),
+		eventType: null,
+		reenter: false,
+		target: resolvedTarget ? [resolvedTarget] : [],
+		toJSON: () => ({
+			...transition,
+			source: `#${stateNode.id}`,
+			target: resolvedTarget ? [`#${resolvedTarget.id}`] : []
+		})
+	};
+	return transition;
+}
+function resolveTarget(stateNode, targets) {
+	if (targets === void 0) return;
+	return targets.map((target) => {
+		if (typeof target !== "string") return target;
+		if (isStateId(target)) return stateNode.machine.getStateNodeById(target);
+		const isInternalTarget = target[0] === STATE_DELIMITER;
+		if (isInternalTarget && !stateNode.parent) return getStateNodeByPath(stateNode, target.slice(1));
+		const resolvedTarget = isInternalTarget ? stateNode.key + target : target;
+		if (stateNode.parent) try {
+			return getStateNodeByPath(stateNode.parent, resolvedTarget);
+		} catch (err) {
+			throw new Error(`Invalid transition definition for state node '${stateNode.id}':\n${err.message}`);
+		}
+		else throw new Error(`Invalid target: "${target}" is not a valid target from the root node. Did you mean ".${target}"?`);
+	});
+}
+function resolveHistoryDefaultTransition(stateNode) {
+	const normalizedTarget = normalizeTarget(stateNode.config.target);
+	if (!normalizedTarget) return stateNode.parent.initial;
+	return { target: normalizedTarget.map((t) => typeof t === "string" ? getStateNodeByPath(stateNode.parent, t) : t) };
+}
+function isHistoryNode(stateNode) {
+	return stateNode.type === "history";
+}
+function getInitialStateNodesWithTheirAncestors(stateNode) {
+	const states = getInitialStateNodes(stateNode);
+	for (const initialState of states) for (const ancestor of getProperAncestors(initialState, stateNode)) states.add(ancestor);
+	return states;
+}
+function getInitialStateNodes(stateNode) {
+	const set = /* @__PURE__ */ new Set();
+	function iter(descStateNode) {
+		if (set.has(descStateNode)) return;
+		set.add(descStateNode);
+		if (descStateNode.type === "compound") iter(descStateNode.initial.target[0]);
+		else if (descStateNode.type === "parallel") for (const child of getChildren(descStateNode)) iter(child);
+	}
+	iter(stateNode);
+	return set;
+}
+/** Returns the child state node from its relative `stateKey`, or throws. */
+function getStateNode(stateNode, stateKey) {
+	if (isStateId(stateKey)) return stateNode.machine.getStateNodeById(stateKey);
+	if (!stateNode.states) throw new Error(`Unable to retrieve child state '${stateKey}' from '${stateNode.id}'; no child states exist.`);
+	const result = stateNode.states[stateKey];
+	if (!result) throw new Error(`Child state '${stateKey}' does not exist on '${stateNode.id}'`);
+	return result;
+}
+/**
+* Returns the relative state node from the given `statePath`, or throws.
+*
+* @param statePath The string or string array relative path to the state node.
+*/
+function getStateNodeByPath(stateNode, statePath) {
+	if (typeof statePath === "string" && isStateId(statePath)) try {
+		return stateNode.machine.getStateNodeById(statePath);
+	} catch {}
+	const arrayStatePath = toStatePath(statePath).slice();
+	let currentStateNode = stateNode;
+	while (arrayStatePath.length) {
+		const key = arrayStatePath.shift();
+		if (!key.length) break;
+		currentStateNode = getStateNode(currentStateNode, key);
+	}
+	return currentStateNode;
+}
+/**
+* Returns the state nodes represented by the current state value.
+*
+* @param stateValue The state value or State instance
+*/
+function getStateNodes(stateNode, stateValue) {
+	if (typeof stateValue === "string") {
+		const childStateNode = stateNode.states[stateValue];
+		if (!childStateNode) throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+		return [stateNode, childStateNode];
+	}
+	const childStateKeys = Object.keys(stateValue);
+	const childStateNodes = childStateKeys.map((subStateKey) => getStateNode(stateNode, subStateKey)).filter(Boolean);
+	return [stateNode.machine.root, stateNode].concat(childStateNodes, childStateKeys.reduce((allSubStateNodes, subStateKey) => {
+		const subStateNode = getStateNode(stateNode, subStateKey);
+		if (!subStateNode) return allSubStateNodes;
+		const subStateNodes = getStateNodes(subStateNode, stateValue[subStateKey]);
+		return allSubStateNodes.concat(subStateNodes);
+	}, []));
+}
+function transitionAtomicNode(stateNode, stateValue, snapshot, event) {
+	const next = getStateNode(stateNode, stateValue).next(snapshot, event);
+	if (!next || !next.length) return stateNode.next(snapshot, event);
+	return next;
+}
+function transitionCompoundNode(stateNode, stateValue, snapshot, event) {
+	const subStateKeys = Object.keys(stateValue);
+	const next = transitionNode(getStateNode(stateNode, subStateKeys[0]), stateValue[subStateKeys[0]], snapshot, event);
+	if (!next || !next.length) return stateNode.next(snapshot, event);
+	return next;
+}
+function transitionParallelNode(stateNode, stateValue, snapshot, event) {
+	const allInnerTransitions = [];
+	for (const subStateKey of Object.keys(stateValue)) {
+		const subStateValue = stateValue[subStateKey];
+		if (!subStateValue) continue;
+		const innerTransitions = transitionNode(getStateNode(stateNode, subStateKey), subStateValue, snapshot, event);
+		if (innerTransitions) allInnerTransitions.push(...innerTransitions);
+	}
+	if (!allInnerTransitions.length) return stateNode.next(snapshot, event);
+	return allInnerTransitions;
+}
+function transitionNode(stateNode, stateValue, snapshot, event) {
+	if (typeof stateValue === "string") return transitionAtomicNode(stateNode, stateValue, snapshot, event);
+	if (Object.keys(stateValue).length === 1) return transitionCompoundNode(stateNode, stateValue, snapshot, event);
+	return transitionParallelNode(stateNode, stateValue, snapshot, event);
+}
+function getHistoryNodes(stateNode) {
+	return Object.keys(stateNode.states).map((key) => stateNode.states[key]).filter((sn) => sn.type === "history");
+}
+function isDescendant(childStateNode, parentStateNode) {
+	let marker = childStateNode;
+	while (marker.parent && marker.parent !== parentStateNode) marker = marker.parent;
+	return marker.parent === parentStateNode;
+}
+function hasIntersection(s1, s2) {
+	const set1 = new Set(s1);
+	const set2 = new Set(s2);
+	for (const item of set1) if (set2.has(item)) return true;
+	for (const item of set2) if (set1.has(item)) return true;
+	return false;
+}
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, historyValue) {
+	const filteredTransitions = /* @__PURE__ */ new Set();
+	for (const t1 of enabledTransitions) {
+		let t1Preempted = false;
+		const transitionsToRemove = /* @__PURE__ */ new Set();
+		for (const t2 of filteredTransitions) if (hasIntersection(computeExitSet([t1], stateNodeSet, historyValue), computeExitSet([t2], stateNodeSet, historyValue))) if (isDescendant(t1.source, t2.source)) transitionsToRemove.add(t2);
+		else {
+			t1Preempted = true;
+			break;
+		}
+		if (!t1Preempted) {
+			for (const t3 of transitionsToRemove) filteredTransitions.delete(t3);
+			filteredTransitions.add(t1);
+		}
+	}
+	return Array.from(filteredTransitions);
+}
+function findLeastCommonAncestor(stateNodes) {
+	const [head, ...tail] = stateNodes;
+	for (const ancestor of getProperAncestors(head, void 0)) if (tail.every((sn) => isDescendant(sn, ancestor))) return ancestor;
+}
+function getEffectiveTargetStates(transition, historyValue) {
+	if (!transition.target) return [];
+	const targets = /* @__PURE__ */ new Set();
+	for (const targetNode of transition.target) if (isHistoryNode(targetNode)) if (historyValue[targetNode.id]) for (const node of historyValue[targetNode.id]) targets.add(node);
+	else for (const node of getEffectiveTargetStates(resolveHistoryDefaultTransition(targetNode), historyValue)) targets.add(node);
+	else targets.add(targetNode);
+	return [...targets];
+}
+function getTransitionDomain(transition, historyValue) {
+	const targetStates = getEffectiveTargetStates(transition, historyValue);
+	if (!targetStates) return;
+	if (!transition.reenter && targetStates.every((target) => target === transition.source || isDescendant(target, transition.source))) return transition.source;
+	const lca = findLeastCommonAncestor(targetStates.concat(transition.source));
+	if (lca) return lca;
+	if (transition.reenter) return;
+	return transition.source.machine.root;
+}
+function computeExitSet(transitions, stateNodeSet, historyValue) {
+	const statesToExit = /* @__PURE__ */ new Set();
+	for (const t of transitions) if (t.target?.length) {
+		const domain = getTransitionDomain(t, historyValue);
+		if (t.reenter && t.source === domain) statesToExit.add(domain);
+		for (const stateNode of stateNodeSet) if (isDescendant(stateNode, domain)) statesToExit.add(stateNode);
+	}
+	return [...statesToExit];
+}
+function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
+	if (prevStateNodes.length !== nextStateNodeSet.size) return false;
+	for (const node of prevStateNodes) if (!nextStateNodeSet.has(node)) return false;
+	return true;
+}
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
+function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+	if (!transitions.length) return currentSnapshot;
+	const mutStateNodeSet = new Set(currentSnapshot._nodes);
+	let historyValue = currentSnapshot.historyValue;
+	const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
+	let nextState = currentSnapshot;
+	if (!isInitial) [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
+	nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap((t) => t.actions), internalQueue, void 0);
+	nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+	const nextStateNodes = [...mutStateNodeSet];
+	if (nextState.status === "done") nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap((state) => state.exit), internalQueue, void 0);
+	try {
+		if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) return nextState;
+		return cloneMachineSnapshot(nextState, {
+			_nodes: nextStateNodes,
+			historyValue
+		});
+	} catch (e) {
+		throw e;
+	}
+}
+function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
+	if (rootNode.output === void 0) return;
+	const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output !== void 0 && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, snapshot.context, event, actorScope.self) : void 0);
+	return resolveOutput(rootNode.output, snapshot.context, doneStateEvent, actorScope.self);
+}
+function enterStates(currentSnapshot, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
+	let nextSnapshot = currentSnapshot;
+	const statesToEnter = /* @__PURE__ */ new Set();
+	const statesForDefaultEntry = /* @__PURE__ */ new Set();
+	computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
+	if (isInitial) statesForDefaultEntry.add(currentSnapshot.machine.root);
+	const completedNodes = /* @__PURE__ */ new Set();
+	for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
+		mutStateNodeSet.add(stateNodeToEnter);
+		const actions = [];
+		actions.push(...stateNodeToEnter.entry);
+		for (const invokeDef of stateNodeToEnter.invoke) actions.push(spawnChild(invokeDef.src, {
+			...invokeDef,
+			syncSnapshot: !!invokeDef.onSnapshot
+		}));
+		if (statesForDefaultEntry.has(stateNodeToEnter)) {
+			const initialActions = stateNodeToEnter.initial.actions;
+			actions.push(...initialActions);
+		}
+		nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, actions, internalQueue, stateNodeToEnter.invoke.map((invokeDef) => invokeDef.id));
+		if (stateNodeToEnter.type === "final") {
+			const parent = stateNodeToEnter.parent;
+			let ancestorMarker = parent?.type === "parallel" ? parent : parent?.parent;
+			let rootCompletionNode = ancestorMarker || stateNodeToEnter;
+			if (parent?.type === "compound") internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output !== void 0 ? resolveOutput(stateNodeToEnter.output, nextSnapshot.context, event, actorScope.self) : void 0));
+			while (ancestorMarker?.type === "parallel" && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
+				completedNodes.add(ancestorMarker);
+				internalQueue.push(createDoneStateEvent(ancestorMarker.id));
+				rootCompletionNode = ancestorMarker;
+				ancestorMarker = ancestorMarker.parent;
+			}
+			if (ancestorMarker) continue;
+			nextSnapshot = cloneMachineSnapshot(nextSnapshot, {
+				status: "done",
+				output: getMachineOutput(nextSnapshot, event, actorScope, nextSnapshot.machine.root, rootCompletionNode)
+			});
+		}
+	}
+	return nextSnapshot;
+}
+function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
+	for (const t of transitions) {
+		const domain = getTransitionDomain(t, historyValue);
+		for (const s of t.target || []) {
+			if (!isHistoryNode(s) && (t.source !== s || t.source !== domain || t.reenter)) {
+				statesToEnter.add(s);
+				statesForDefaultEntry.add(s);
+			}
+			addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+		}
+		const targetStates = getEffectiveTargetStates(t, historyValue);
+		for (const s of targetStates) {
+			const ancestors = getProperAncestors(s, domain);
+			if (domain?.type === "parallel") ancestors.push(domain);
+			addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, !t.source.parent && t.reenter ? void 0 : domain);
+		}
+	}
+}
+function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEntry, statesToEnter) {
+	if (isHistoryNode(stateNode)) if (historyValue[stateNode.id]) {
+		const historyStateNodes = historyValue[stateNode.id];
+		for (const s of historyStateNodes) {
+			statesToEnter.add(s);
+			addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+		}
+		for (const s of historyStateNodes) addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+	} else {
+		const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+		for (const s of historyDefaultTransition.target) {
+			statesToEnter.add(s);
+			if (historyDefaultTransition === stateNode.parent?.initial) statesForDefaultEntry.add(stateNode.parent);
+			addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+		}
+		for (const s of historyDefaultTransition.target) addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+	}
+	else if (stateNode.type === "compound") {
+		const [initialState] = stateNode.initial.target;
+		if (!isHistoryNode(initialState)) {
+			statesToEnter.add(initialState);
+			statesForDefaultEntry.add(initialState);
+		}
+		addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
+		addProperAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+	} else if (stateNode.type === "parallel") {
+		for (const child of getChildren(stateNode).filter((sn) => !isHistoryNode(sn))) if (![...statesToEnter].some((s) => isDescendant(s, child))) {
+			if (!isHistoryNode(child)) {
+				statesToEnter.add(child);
+				statesForDefaultEntry.add(child);
+			}
+			addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
+		}
+	}
+}
+function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, reentrancyDomain) {
+	for (const anc of ancestors) {
+		if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) statesToEnter.add(anc);
+		if (anc.type === "parallel") {
+			for (const child of getChildren(anc).filter((sn) => !isHistoryNode(sn))) if (![...statesToEnter].some((s) => isDescendant(s, child))) {
+				statesToEnter.add(child);
+				addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
+			}
+		}
+	}
+}
+function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
+	addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
+}
+function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue, _actionExecutor) {
+	let nextSnapshot = currentSnapshot;
+	const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
+	statesToExit.sort((a, b) => b.order - a.order);
+	let changedHistory;
+	for (const exitStateNode of statesToExit) for (const historyNode of getHistoryNodes(exitStateNode)) {
+		let predicate;
+		if (historyNode.history === "deep") predicate = (sn) => isAtomicStateNode(sn) && isDescendant(sn, exitStateNode);
+		else predicate = (sn) => {
+			return sn.parent === exitStateNode;
+		};
+		changedHistory ??= { ...historyValue };
+		changedHistory[historyNode.id] = Array.from(mutStateNodeSet).filter(predicate);
+	}
+	for (const s of statesToExit) {
+		nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, [...s.exit, ...s.invoke.map((def) => stopChild(def.id))], internalQueue, void 0);
+		mutStateNodeSet.delete(s);
+	}
+	return [nextSnapshot, changedHistory || historyValue];
+}
+function getAction(machine, actionType) {
+	return machine.implementations.actions[actionType];
+}
+function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
+	const { machine } = currentSnapshot;
+	let intermediateSnapshot = currentSnapshot;
+	for (const action of actions) {
+		const isInline = typeof action === "function";
+		const resolvedAction = isInline ? action : getAction(machine, typeof action === "string" ? action : action.type);
+		const actionArgs = {
+			context: intermediateSnapshot.context,
+			event,
+			self: actorScope.self,
+			system: actorScope.system
+		};
+		const actionParams = isInline || typeof action === "string" ? void 0 : "params" in action ? typeof action.params === "function" ? action.params({
+			context: intermediateSnapshot.context,
+			event
+		}) : action.params : void 0;
+		if (!resolvedAction || !("resolve" in resolvedAction)) {
+			actorScope.actionExecutor({
+				type: typeof action === "string" ? action : typeof action === "object" ? action.type : action.name || "(anonymous)",
+				info: actionArgs,
+				params: actionParams,
+				exec: resolvedAction
+			});
+			continue;
+		}
+		const builtinAction = resolvedAction;
+		const [nextState, params, actions$1] = builtinAction.resolve(actorScope, intermediateSnapshot, actionArgs, actionParams, resolvedAction, extra);
+		intermediateSnapshot = nextState;
+		if ("retryResolve" in builtinAction) retries?.push([builtinAction, params]);
+		if ("execute" in builtinAction) actorScope.actionExecutor({
+			type: builtinAction.type,
+			info: actionArgs,
+			params,
+			exec: builtinAction.execute.bind(null, actorScope, params)
+		});
+		if (actions$1) intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions$1, extra, retries);
+	}
+	return intermediateSnapshot;
+}
+function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
+	const retries = deferredActorIds ? [] : void 0;
+	const nextState = resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, {
+		internalQueue,
+		deferredActorIds
+	}, retries);
+	retries?.forEach(([builtinAction, params]) => {
+		builtinAction.retryResolve(actorScope, nextState, params);
+	});
+	return nextState;
+}
+function macrostep(snapshot, event, actorScope, internalQueue) {
+	let nextSnapshot = snapshot;
+	const microstates = [];
+	function addMicrostate(microstate, event$1, transitions) {
+		actorScope.system._sendInspectionEvent({
+			type: "@xstate.microstep",
+			actorRef: actorScope.self,
+			event: event$1,
+			snapshot: microstate,
+			_transitions: transitions
+		});
+		microstates.push(microstate);
+	}
+	if (event.type === XSTATE_STOP) {
+		nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), { status: "stopped" });
+		addMicrostate(nextSnapshot, event, []);
+		return {
+			snapshot: nextSnapshot,
+			microstates
+		};
+	}
+	let nextEvent = event;
+	if (nextEvent.type !== XSTATE_INIT) {
+		const currentEvent = nextEvent;
+		const isErr = isErrorActorEvent(currentEvent);
+		const transitions = selectTransitions(currentEvent, nextSnapshot);
+		if (isErr && !transitions.length) {
+			nextSnapshot = cloneMachineSnapshot(snapshot, {
+				status: "error",
+				error: currentEvent.error
+			});
+			addMicrostate(nextSnapshot, currentEvent, []);
+			return {
+				snapshot: nextSnapshot,
+				microstates
+			};
+		}
+		nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false, internalQueue);
+		addMicrostate(nextSnapshot, currentEvent, transitions);
+	}
+	let shouldSelectEventlessTransitions = true;
+	while (nextSnapshot.status === "active") {
+		let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextSnapshot, nextEvent) : [];
+		const previousState = enabledTransitions.length ? nextSnapshot : void 0;
+		if (!enabledTransitions.length) {
+			if (!internalQueue.length) break;
+			nextEvent = internalQueue.shift();
+			enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
+		}
+		nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+		shouldSelectEventlessTransitions = nextSnapshot !== previousState;
+		addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
+	}
+	if (nextSnapshot.status !== "active") stopChildren(nextSnapshot, nextEvent, actorScope);
+	return {
+		snapshot: nextSnapshot,
+		microstates
+	};
+}
+function stopChildren(nextState, event, actorScope) {
+	return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map((child) => stopChild(child)), [], void 0);
+}
+function selectTransitions(event, nextState) {
+	return nextState.machine.getTransitionData(nextState, event);
+}
+function selectEventlessTransitions(nextState, event) {
+	const enabledTransitionSet = /* @__PURE__ */ new Set();
+	const atomicStates = nextState._nodes.filter(isAtomicStateNode);
+	for (const stateNode of atomicStates) loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, void 0))) {
+		if (!s.always) continue;
+		for (const transition of s.always) if (transition.guard === void 0 || evaluateGuard(transition.guard, nextState.context, event, nextState)) {
+			enabledTransitionSet.add(transition);
+			break loop;
+		}
+	}
+	return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState._nodes), nextState.historyValue);
+}
+/**
+* Resolves a partial state value with its full representation in the state
+* node's machine.
+*
+* @param stateValue The partial state value to resolve.
+*/
+function resolveStateValue(rootNode, stateValue) {
+	return getStateValue(rootNode, [...getAllStateNodes(getStateNodes(rootNode, stateValue))]);
+}
+function isMachineSnapshot(value) {
+	return !!value && typeof value === "object" && "machine" in value && "value" in value;
+}
+const machineSnapshotMatches = function matches(testValue) {
+	return matchesState(testValue, this.value);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+	return this.tags.has(tag);
+};
+const machineSnapshotCan = function can(event) {
+	const transitionData = this.machine.getTransitionData(this, event);
+	return !!transitionData?.length && transitionData.some((t) => t.target !== void 0 || t.actions.length);
+};
+const machineSnapshotToJSON = function toJSON() {
+	const { _nodes: nodes, tags, machine, getMeta, toJSON: toJSON$1, can, hasTag, matches, ...jsonValues } = this;
+	return {
+		...jsonValues,
+		tags: Array.from(tags)
+	};
+};
+const machineSnapshotGetMeta = function getMeta() {
+	return this._nodes.reduce((acc, stateNode) => {
+		if (stateNode.meta !== void 0) acc[stateNode.id] = stateNode.meta;
+		return acc;
+	}, {});
+};
+function createMachineSnapshot(config, machine) {
+	return {
+		status: config.status,
+		output: config.output,
+		error: config.error,
+		machine,
+		context: config.context,
+		_nodes: config._nodes,
+		value: getStateValue(machine.root, config._nodes),
+		tags: new Set(config._nodes.flatMap((sn) => sn.tags)),
+		children: config.children,
+		historyValue: config.historyValue || {},
+		matches: machineSnapshotMatches,
+		hasTag: machineSnapshotHasTag,
+		can: machineSnapshotCan,
+		getMeta: machineSnapshotGetMeta,
+		toJSON: machineSnapshotToJSON
+	};
+}
+function cloneMachineSnapshot(snapshot, config = {}) {
+	return createMachineSnapshot({
+		...snapshot,
+		...config
+	}, snapshot.machine);
+}
+function serializeHistoryValue(historyValue) {
+	if (typeof historyValue !== "object" || historyValue === null) return {};
+	const result = {};
+	for (const key in historyValue) {
+		const value = historyValue[key];
+		if (Array.isArray(value)) result[key] = value.map((item) => ({ id: item.id }));
+	}
+	return result;
+}
+function getPersistedSnapshot(snapshot, options) {
+	const { _nodes: nodes, tags, machine, children, context, can, hasTag, matches, getMeta, toJSON, ...jsonValues } = snapshot;
+	const childrenJson = {};
+	for (const id in children) {
+		const child = children[id];
+		childrenJson[id] = {
+			snapshot: child.getPersistedSnapshot(options),
+			src: child.src,
+			systemId: child.systemId,
+			syncSnapshot: child._syncSnapshot
+		};
+	}
+	return {
+		...jsonValues,
+		context: persistContext(context),
+		children: childrenJson,
+		historyValue: serializeHistoryValue(jsonValues.historyValue)
+	};
+}
+function persistContext(contextPart) {
+	let copy;
+	for (const key in contextPart) {
+		const value = contextPart[key];
+		if (value && typeof value === "object") if ("sessionId" in value && "send" in value && "ref" in value) {
+			copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+			copy[key] = {
+				xstate$$type: $$ACTOR_TYPE,
+				id: value.id
+			};
+		} else {
+			const result = persistContext(value);
+			if (result !== value) {
+				copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+				copy[key] = result;
+			}
+		}
+	}
+	return copy ?? contextPart;
+}
+function resolveRaise(_, snapshot, args, actionParams, { event: eventOrExpr, id, delay }, { internalQueue }) {
+	const delaysMap = snapshot.machine.implementations.delays;
+	if (typeof eventOrExpr === "string") throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
+	const resolvedEvent = typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr;
+	let resolvedDelay;
+	if (typeof delay === "string") {
+		const configDelay = delaysMap && delaysMap[delay];
+		resolvedDelay = typeof configDelay === "function" ? configDelay(args, actionParams) : configDelay;
+	} else resolvedDelay = typeof delay === "function" ? delay(args, actionParams) : delay;
+	if (typeof resolvedDelay !== "number") internalQueue.push(resolvedEvent);
+	return [
+		snapshot,
+		{
+			event: resolvedEvent,
+			id,
+			delay: resolvedDelay
+		},
+		void 0
+	];
+}
+function executeRaise(actorScope, params) {
+	const { event, delay, id } = params;
+	if (typeof delay === "number") {
+		actorScope.defer(() => {
+			const self$1 = actorScope.self;
+			actorScope.system.scheduler.schedule(self$1, self$1, event, delay, id);
+		});
+		return;
+	}
+}
+/**
+* Raises an event. This places the event in the internal event queue, so that
+* the event is immediately consumed by the machine in the current step.
+*
+* @param eventType The event to raise.
+*/
+function raise(eventOrExpr, options) {
+	function raise$1(_args, _params) {}
+	raise$1.type = "xstate.raise";
+	raise$1.event = eventOrExpr;
+	raise$1.id = options?.id;
+	raise$1.delay = options?.delay;
+	raise$1.resolve = resolveRaise;
+	raise$1.execute = executeRaise;
+	return raise$1;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/actors/dist/xstate-actors.esm.js
+/**
+* Represents an actor created by `fromTransition`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import {
+*   fromTransition,
+*   createActor,
+*   type AnyActorSystem
+* } from 'xstate';
+*
+* //* The actor's stored context.
+* type Context = {
+*   // The current count.
+*   count: number;
+*   // The amount to increase `count` by.
+*   step: number;
+* };
+* // The events the actor receives.
+* type Event = { type: 'increment' };
+* // The actor's input.
+* type Input = { step?: number };
+*
+* // Actor logic that increments `count` by `step` when it receives an event of
+* // type `increment`.
+* const logic = fromTransition<Context, Event, AnyActorSystem, Input>(
+*   (state, event, actorScope) => {
+*     actorScope.self;
+*     //         ^? TransitionActorRef<Context, Event>
+*
+*     if (event.type === 'increment') {
+*       return {
+*         ...state,
+*         count: state.count + state.step
+*       };
+*     }
+*     return state;
+*   },
+*   ({ input, self }) => {
+*     self;
+*     // ^? TransitionActorRef<Context, Event>
+*
+*     return {
+*       count: 0,
+*       step: input.step ?? 1
+*     };
+*   }
+* );
+*
+* const actor = createActor(logic, { input: { step: 10 } });
+* //    ^? TransitionActorRef<Context, Event>
+* ```
+*
+* @see {@link fromTransition}
+*/
+/**
+* Returns actor logic given a transition function and its initial state.
+*
+* A “transition function” is a function that takes the current `state` and
+* received `event` object as arguments, and returns the next state, similar to
+* a reducer.
+*
+* Actors created from transition logic (“transition actors”) can:
+*
+* - Receive events
+* - Emit snapshots of its state
+*
+* The transition function’s `state` is used as its transition actor’s
+* `context`.
+*
+* Note that the "state" for a transition function is provided by the initial
+* state argument, and is not the same as the State object of an actor or a
+* state within a machine configuration.
+*
+* @example
+*
+* ```ts
+* const transitionLogic = fromTransition(
+*   (state, event) => {
+*     if (event.type === 'increment') {
+*       return {
+*         ...state,
+*         count: state.count + 1
+*       };
+*     }
+*     return state;
+*   },
+*   { count: 0 }
+* );
+*
+* const transitionActor = createActor(transitionLogic);
+* transitionActor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+* transitionActor.start();
+* // => {
+* //   status: 'active',
+* //   context: { count: 0 },
+* //   ...
+* // }
+*
+* transitionActor.send({ type: 'increment' });
+* // => {
+* //   status: 'active',
+* //   context: { count: 1 },
+* //   ...
+* // }
+* ```
+*
+* @param transition The transition function used to describe the transition
+*   logic. It should return the next state given the current state and event.
+*   It receives the following arguments:
+*
+*   - `state` - the current state.
+*   - `event` - the received event.
+*   - `actorScope` - the actor scope object, with properties like `self` and
+*       `system`.
+*
+* @param initialContext The initial state of the transition function, either an
+*   object representing the state, or a function which returns a state object.
+*   If a function, it will receive as its only argument an object with the
+*   following properties:
+*
+*   - `input` - the `input` provided to its parent transition actor.
+*   - `self` - a reference to its parent transition actor.
+*
+* @returns Actor logic
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromTransition(transition, initialContext) {
+	return {
+		config: transition,
+		transition: (snapshot, event, actorScope) => {
+			return {
+				...snapshot,
+				context: transition(snapshot.context, event, actorScope)
+			};
+		},
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				context: typeof initialContext === "function" ? initialContext({ input }) : initialContext
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+}
+const instanceStates = /* @__PURE__ */ new WeakMap();
+/**
+* Represents an actor created by `fromCallback`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromCallback, createActor } from 'xstate';
+*
+* // The events the actor receives.
+* type Event = { type: 'someEvent' };
+* // The actor's input.
+* type Input = { name: string };
+*
+* // Actor logic that logs whenever it receives an event of type `someEvent`.
+* const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
+*   self;
+*   // ^? CallbackActorRef<Event, Input>
+*
+*   receive((event) => {
+*     if (event.type === 'someEvent') {
+*       console.log(`${input.name}: received "someEvent" event`);
+*       // logs 'myActor: received "someEvent" event'
+*     }
+*   });
+* });
+*
+* const actor = createActor(logic, { input: { name: 'myActor' } });
+* //    ^? CallbackActorRef<Event, Input>
+* ```
+*
+* @see {@link fromCallback}
+*/
+/**
+* An actor logic creator which returns callback logic as defined by a callback
+* function.
+*
+* @remarks
+* Useful for subscription-based or other free-form logic that can send events
+* back to the parent actor.
+*
+* Actors created from callback logic (“callback actors”) can:
+*
+* - Receive events via the `receive` function
+* - Send events to the parent actor via the `sendBack` function
+*
+* Callback actors are a bit different from other actors in that they:
+*
+* - Do not work with `onDone`
+* - Do not produce a snapshot using `.getSnapshot()`
+* - Do not emit values when used with `.subscribe()`
+* - Can not be stopped with `.stop()`
+*
+* @example
+*
+* ```typescript
+* const callbackLogic = fromCallback(({ sendBack, receive }) => {
+*   let lockStatus = 'unlocked';
+*
+*   const handler = (event) => {
+*     if (lockStatus === 'locked') {
+*       return;
+*     }
+*     sendBack(event);
+*   };
+*
+*   receive((event) => {
+*     if (event.type === 'lock') {
+*       lockStatus = 'locked';
+*     } else if (event.type === 'unlock') {
+*       lockStatus = 'unlocked';
+*     }
+*   });
+*
+*   document.body.addEventListener('click', handler);
+*
+*   return () => {
+*     document.body.removeEventListener('click', handler);
+*   };
+* });
+* ```
+*
+* @param callback - The callback function used to describe the callback logic
+*   The callback function is passed an object with the following properties:
+*
+*   - `receive` - A function that can send events back to the parent actor; the
+*       listener is then called whenever events are received by the callback
+*       actor
+*   - `sendBack` - A function that can send events back to the parent actor
+*   - `input` - Data that was provided to the callback actor
+*   - `self` - The parent actor of the callback actor
+*   - `system` - The actor system to which the callback actor belongs The callback
+*       function can (optionally) return a cleanup function, which is called
+*       when the actor is stopped.
+*
+* @returns Callback logic
+* @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromCallback(callback) {
+	return {
+		config: callback,
+		start: (state, actorScope) => {
+			const { self: self$1, system, emit: emit$1 } = actorScope;
+			const callbackState = {
+				receivers: void 0,
+				dispose: void 0
+			};
+			instanceStates.set(self$1, callbackState);
+			callbackState.dispose = callback({
+				input: state.input,
+				system,
+				self: self$1,
+				sendBack: (event) => {
+					if (self$1.getSnapshot().status === "stopped") return;
+					if (self$1._parent) system._relay(self$1, self$1._parent, event);
+				},
+				receive: (listener) => {
+					callbackState.receivers ??= /* @__PURE__ */ new Set();
+					callbackState.receivers.add(listener);
+				},
+				emit: emit$1
+			});
+		},
+		transition: (state, event, actorScope) => {
+			const callbackState = instanceStates.get(actorScope.self);
+			if (event.type === XSTATE_STOP) {
+				state = {
+					...state,
+					status: "stopped",
+					error: void 0
+				};
+				callbackState.dispose?.();
+				return state;
+			}
+			callbackState.receivers?.forEach((receiver) => receiver(event));
+			return state;
+		},
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+}
+const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
+const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
+/**
+* Represents an actor created by `fromPromise`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromPromise, createActor } from 'xstate';
+*
+* // The actor's resolved output
+* type Output = string;
+* // The actor's input.
+* type Input = { message: string };
+*
+* // Actor logic that fetches the url of an image of a cat saying `input.message`.
+* const logic = fromPromise<Output, Input>(async ({ input, self }) => {
+*   self;
+*   // ^? PromiseActorRef<Output, Input>
+*
+*   const data = await fetch(
+*     `https://cataas.com/cat/says/${input.message}`
+*   );
+*   const url = await data.json();
+*   return url;
+* });
+*
+* const actor = createActor(logic, { input: { message: 'hello world' } });
+* //    ^? PromiseActorRef<Output, Input>
+* ```
+*
+* @see {@link fromPromise}
+*/
+const controllerMap = /* @__PURE__ */ new WeakMap();
+/**
+* An actor logic creator which returns promise logic as defined by an async
+* process that resolves or rejects after some time.
+*
+* Actors created from promise actor logic (“promise actors”) can:
+*
+* - Emit the resolved value of the promise
+* - Output the resolved value of the promise
+*
+* Sending events to promise actors will have no effect.
+*
+* @example
+*
+* ```ts
+* const promiseLogic = fromPromise(async () => {
+*   const result = await fetch('https://example.com/...').then((data) =>
+*     data.json()
+*   );
+*
+*   return result;
+* });
+*
+* const promiseActor = createActor(promiseLogic);
+* promiseActor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+* promiseActor.start();
+* // => {
+* //   output: undefined,
+* //   status: 'active'
+* //   ...
+* // }
+*
+* // After promise resolves
+* // => {
+* //   output: { ... },
+* //   status: 'done',
+* //   ...
+* // }
+* ```
+*
+* @param promiseCreator A function which returns a Promise, and accepts an
+*   object with the following properties:
+*
+*   - `input` - Data that was provided to the promise actor
+*   - `self` - The parent actor of the promise actor
+*   - `system` - The actor system to which the promise actor belongs
+*
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromPromise(promiseCreator) {
+	return {
+		config: promiseCreator,
+		transition: (state, event, scope) => {
+			if (state.status !== "active") return state;
+			switch (event.type) {
+				case XSTATE_PROMISE_RESOLVE: {
+					const resolvedValue = event.data;
+					return {
+						...state,
+						status: "done",
+						output: resolvedValue,
+						input: void 0
+					};
+				}
+				case XSTATE_PROMISE_REJECT: return {
+					...state,
+					status: "error",
+					error: event.data,
+					input: void 0
+				};
+				case XSTATE_STOP:
+					controllerMap.get(scope.self)?.abort();
+					return {
+						...state,
+						status: "stopped",
+						input: void 0
+					};
+				default: return state;
+			}
+		},
+		start: (state, { self: self$1, system, emit: emit$1 }) => {
+			if (state.status !== "active") return;
+			const controller = new AbortController();
+			controllerMap.set(self$1, controller);
+			Promise.resolve(promiseCreator({
+				input: state.input,
+				system,
+				self: self$1,
+				signal: controller.signal,
+				emit: emit$1
+			})).then((response) => {
+				if (self$1.getSnapshot().status !== "active") return;
+				controllerMap.delete(self$1);
+				system._relay(self$1, self$1, {
+					type: XSTATE_PROMISE_RESOLVE,
+					data: response
+				});
+			}, (errorData) => {
+				if (self$1.getSnapshot().status !== "active") return;
+				controllerMap.delete(self$1);
+				system._relay(self$1, self$1, {
+					type: XSTATE_PROMISE_REJECT,
+					data: errorData
+				});
+			});
+		},
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+}
+const emptyLogic = fromTransition((_) => void 0, void 0);
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/assign-ab9cc19e.esm.js
+function createSpawner(actorScope, { machine, context }, event, spawnedChildren) {
+	const spawn = (src, options) => {
+		if (typeof src === "string") {
+			const logic = resolveReferencedActor(machine, src);
+			if (!logic) throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
+			const actorRef = createActor(logic, {
+				id: options?.id,
+				parent: actorScope.self,
+				syncSnapshot: options?.syncSnapshot,
+				input: typeof options?.input === "function" ? options.input({
+					context,
+					event,
+					self: actorScope.self
+				}) : options?.input,
+				src,
+				systemId: options?.systemId
+			});
+			spawnedChildren[actorRef.id] = actorRef;
+			return actorRef;
+		} else return createActor(src, {
+			id: options?.id,
+			parent: actorScope.self,
+			syncSnapshot: options?.syncSnapshot,
+			input: options?.input,
+			src,
+			systemId: options?.systemId
+		});
+	};
+	return (src, options) => {
+		const actorRef = spawn(src, options);
+		spawnedChildren[actorRef.id] = actorRef;
+		actorScope.defer(() => {
+			if (actorRef._processingStatus === ProcessingStatus.Stopped) return;
+			actorRef.start();
+		});
+		return actorRef;
+	};
+}
+function resolveAssign(actorScope, snapshot, actionArgs, actionParams, { assignment }) {
+	if (!snapshot.context) throw new Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
+	const spawnedChildren = {};
+	const assignArgs = {
+		context: snapshot.context,
+		event: actionArgs.event,
+		spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
+		self: actorScope.self,
+		system: actorScope.system
+	};
+	let partialUpdate = {};
+	if (typeof assignment === "function") partialUpdate = assignment(assignArgs, actionParams);
+	else for (const key of Object.keys(assignment)) {
+		const propAssignment = assignment[key];
+		partialUpdate[key] = typeof propAssignment === "function" ? propAssignment(assignArgs, actionParams) : propAssignment;
+	}
+	return [
+		cloneMachineSnapshot(snapshot, {
+			context: Object.assign({}, snapshot.context, partialUpdate),
+			children: Object.keys(spawnedChildren).length ? {
+				...snapshot.children,
+				...spawnedChildren
+			} : snapshot.children
+		}),
+		void 0,
+		void 0
+	];
+}
+/**
+* Updates the current context of the machine.
+*
+* @example
+*
+* ```ts
+* import { createMachine, assign } from 'xstate';
+*
+* const countMachine = createMachine({
+*   context: {
+*     count: 0,
+*     message: ''
+*   },
+*   on: {
+*     inc: {
+*       actions: assign({
+*         count: ({ context }) => context.count + 1
+*       })
+*     },
+*     updateMessage: {
+*       actions: assign(({ context, event }) => {
+*         return {
+*           message: event.message.trim()
+*         };
+*       })
+*     }
+*   }
+* });
+* ```
+*
+* @param assignment An object that represents the partial context to update, or
+*   a function that returns an object that represents the partial context to
+*   update.
+*/
+function assign(assignment) {
+	function assign$1(_args, _params) {}
+	assign$1.type = "xstate.assign";
+	assign$1.assignment = assignment;
+	assign$1.resolve = resolveAssign;
+	return assign$1;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/StateMachine-37bc3882.esm.js
+const cache = /* @__PURE__ */ new WeakMap();
+function memo(object, key, fn) {
+	let memoizedData = cache.get(object);
+	if (!memoizedData) {
+		memoizedData = { [key]: fn() };
+		cache.set(object, memoizedData);
+	} else if (!(key in memoizedData)) memoizedData[key] = fn();
+	return memoizedData[key];
+}
+const EMPTY_OBJECT = {};
+const toSerializableAction = (action) => {
+	if (typeof action === "string") return { type: action };
+	if (typeof action === "function") {
+		if ("resolve" in action) return { type: action.type };
+		return { type: action.name };
+	}
+	return action;
+};
+var StateNode = class StateNode {
+	constructor(config, options) {
+		this.config = config;
+		/**
+		* The relative key of the state node, which represents its location in the
+		* overall state value.
+		*/
+		this.key = void 0;
+		/** The unique ID of the state node. */
+		this.id = void 0;
+		/**
+		* The type of this state node:
+		*
+		* - `'atomic'` - no child state nodes
+		* - `'compound'` - nested child state nodes (XOR)
+		* - `'parallel'` - orthogonal nested child state nodes (AND)
+		* - `'history'` - history state node
+		* - `'final'` - final state node
+		*/
+		this.type = void 0;
+		/** The string path from the root machine node to this node. */
+		this.path = void 0;
+		/** The child state nodes. */
+		this.states = void 0;
+		/**
+		* The type of history on this state node. Can be:
+		*
+		* - `'shallow'` - recalls only top-level historical state value
+		* - `'deep'` - recalls historical state value at all levels
+		*/
+		this.history = void 0;
+		/** The action(s) to be executed upon entering the state node. */
+		this.entry = void 0;
+		/** The action(s) to be executed upon exiting the state node. */
+		this.exit = void 0;
+		/** The parent state node. */
+		this.parent = void 0;
+		/** The root machine node. */
+		this.machine = void 0;
+		/**
+		* The meta data associated with this state node, which will be returned in
+		* State instances.
+		*/
+		this.meta = void 0;
+		/**
+		* The output data sent with the "xstate.done.state._id_" event if this is a
+		* final state node.
+		*/
+		this.output = void 0;
+		/**
+		* The order this state node appears. Corresponds to the implicit document
+		* order.
+		*/
+		this.order = -1;
+		this.description = void 0;
+		this.tags = [];
+		this.transitions = void 0;
+		this.always = void 0;
+		this.parent = options._parent;
+		this.key = options._key;
+		this.machine = options._machine;
+		this.path = this.parent ? this.parent.path.concat(this.key) : [];
+		this.id = this.config.id || [this.machine.id, ...this.path].join(STATE_DELIMITER);
+		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, (stateConfig, key) => {
+			return new StateNode(stateConfig, {
+				_parent: this,
+				_key: key,
+				_machine: this.machine
+			});
+		}) : EMPTY_OBJECT;
+		if (this.type === "compound" && !this.config.initial) throw new 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 === true ? "shallow" : this.config.history || false;
+		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(config.tags).slice();
+	}
+	/** @internal */
+	_initialize() {
+		this.transitions = formatTransitions(this);
+		if (this.config.always) this.always = toTransitionConfigArray(this.config.always).map((t) => formatTransition(this, NULL_EVENT, t));
+		Object.keys(this.states).forEach((key) => {
+			this.states[key]._initialize();
+		});
+	}
+	/** The well-structured state node definition. */
+	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: false,
+				toJSON: () => ({
+					target: this.initial.target.map((t) => `#${t.id}`),
+					source: `#${this.id}`,
+					actions: this.initial.actions.map(toSerializableAction),
+					eventType: null
+				})
+			} : void 0,
+			history: this.history,
+			states: mapValues(this.states, (state) => {
+				return state.definition;
+			}),
+			on: this.on,
+			transitions: [...this.transitions.values()].flat().map((t) => ({
+				...t,
+				actions: t.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
+		};
+	}
+	/** @internal */
+	toJSON() {
+		return this.definition;
+	}
+	/** The logic invoked as actors by this state node. */
+	get invoke() {
+		return memo(this, "invoke", () => toArray(this.config.invoke).map((invokeConfig, i) => {
+			const { src, systemId } = invokeConfig;
+			const resolvedId = invokeConfig.id ?? createInvokeId(this.id, i);
+			const sourceName = typeof src === "string" ? src : `xstate.invoke.${createInvokeId(this.id, i)}`;
+			return {
+				...invokeConfig,
+				src: sourceName,
+				id: resolvedId,
+				systemId,
+				toJSON() {
+					const { onDone, onError, ...invokeDefValues } = invokeConfig;
+					return {
+						...invokeDefValues,
+						type: "xstate.invoke",
+						src: sourceName,
+						id: resolvedId
+					};
+				}
+			};
+		}));
+	}
+	/** The mapping of events to transitions. */
+	get on() {
+		return memo(this, "on", () => {
+			return [...this.transitions].flatMap(([descriptor, t]) => t.map((t$1) => [descriptor, t$1])).reduce((map, [descriptor, transition]) => {
+				map[descriptor] = map[descriptor] || [];
+				map[descriptor].push(transition);
+				return map;
+			}, {});
+		});
+	}
+	get after() {
+		return memo(this, "delayedTransitions", () => getDelayedTransitions(this));
+	}
+	get initial() {
+		return memo(this, "initial", () => formatInitialTransition(this, this.config.initial));
+	}
+	/** @internal */
+	next(snapshot, event) {
+		const eventType = event.type;
+		const actions = [];
+		let selectedTransition;
+		const candidates = memo(this, `candidates-${eventType}`, () => getCandidates(this, eventType));
+		for (const candidate of candidates) {
+			const { guard } = candidate;
+			const resolvedContext = snapshot.context;
+			let guardPassed = false;
+			try {
+				guardPassed = !guard || evaluateGuard(guard, resolvedContext, event, snapshot);
+			} catch (err) {
+				const guardType = typeof guard === "string" ? guard : typeof guard === "object" ? guard.type : void 0;
+				throw new Error(`Unable to evaluate guard ${guardType ? `'${guardType}' ` : ""}in transition for event '${eventType}' in state node '${this.id}':\n${err.message}`);
+			}
+			if (guardPassed) {
+				actions.push(...candidate.actions);
+				selectedTransition = candidate;
+				break;
+			}
+		}
+		return selectedTransition ? [selectedTransition] : void 0;
+	}
+	/** All the event types accepted by this state node and its descendants. */
+	get events() {
+		return memo(this, "events", () => {
+			const { states } = this;
+			const events = new Set(this.ownEvents);
+			if (states) for (const stateId of Object.keys(states)) {
+				const state = states[stateId];
+				if (state.states) for (const event of state.events) events.add(`${event}`);
+			}
+			return Array.from(events);
+		});
+	}
+	/**
+	* All the events that have transitions directly from this state node.
+	*
+	* Excludes any inert events.
+	*/
+	get ownEvents() {
+		const events = new Set([...this.transitions.keys()].filter((descriptor) => {
+			return this.transitions.get(descriptor).some((transition) => !(!transition.target && !transition.actions.length && !transition.reenter));
+		}));
+		return Array.from(events);
+	}
+};
+var StateMachine = class StateMachine {
+	constructor(config, implementations) {
+		this.config = config;
+		/** The machine's own version. */
+		this.version = void 0;
+		this.schemas = void 0;
+		this.implementations = void 0;
+		/** @internal */
+		this.__xstatenode = true;
+		/** @internal */
+		this.idMap = /* @__PURE__ */ new Map();
+		this.root = void 0;
+		this.id = void 0;
+		this.states = void 0;
+		this.events = void 0;
+		this.id = config.id || "(machine)";
+		this.implementations = {
+			actors: implementations?.actors ?? {},
+			actions: implementations?.actions ?? {},
+			delays: implementations?.delays ?? {},
+			guards: implementations?.guards ?? {}
+		};
+		this.version = this.config.version;
+		this.schemas = this.config.schemas;
+		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 StateNode(config, {
+			_key: this.id,
+			_machine: this
+		});
+		this.root._initialize();
+		this.states = this.root.states;
+		this.events = this.root.events;
+	}
+	/**
+	* Clones this state machine with the provided implementations.
+	*
+	* @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
+	*   recursively merge with the existing options.
+	* @returns A new `StateMachine` instance with the provided implementations.
+	*/
+	provide(implementations) {
+		const { actions, guards, actors, delays } = this.implementations;
+		return new StateMachine(this.config, {
+			actions: {
+				...actions,
+				...implementations.actions
+			},
+			guards: {
+				...guards,
+				...implementations.guards
+			},
+			actors: {
+				...actors,
+				...implementations.actors
+			},
+			delays: {
+				...delays,
+				...implementations.delays
+			}
+		});
+	}
+	resolveState(config) {
+		const resolvedStateValue = resolveStateValue(this.root, config.value);
+		const nodeSet = getAllStateNodes(getStateNodes(this.root, resolvedStateValue));
+		return createMachineSnapshot({
+			_nodes: [...nodeSet],
+			context: config.context || {},
+			children: {},
+			status: isInFinalState(nodeSet, this.root) ? "done" : config.status || "active",
+			output: config.output,
+			error: config.error,
+			historyValue: config.historyValue
+		}, this);
+	}
+	/**
+	* Determines the next snapshot given the current `snapshot` and received
+	* `event`. Calculates a full macrostep from all microsteps.
+	*
+	* @param snapshot The current snapshot
+	* @param event The received event
+	*/
+	transition(snapshot, event, actorScope) {
+		return macrostep(snapshot, event, actorScope, []).snapshot;
+	}
+	/**
+	* Determines the next state given the current `state` and `event`. Calculates
+	* a microstep.
+	*
+	* @param state The current state
+	* @param event The received event
+	*/
+	microstep(snapshot, event, actorScope) {
+		return macrostep(snapshot, event, actorScope, []).microstates;
+	}
+	getTransitionData(snapshot, event) {
+		return transitionNode(this.root, snapshot.value, snapshot, event) || [];
+	}
+	/**
+	* The initial state _before_ evaluating any microsteps. This "pre-initial"
+	* state is provided to initial actions executed in the initial state.
+	*/
+	getPreInitialState(actorScope, initEvent, internalQueue) {
+		const { context } = this.config;
+		const preInitial = createMachineSnapshot({
+			context: typeof context !== "function" && context ? context : {},
+			_nodes: [this.root],
+			children: {},
+			status: "active"
+		}, this);
+		if (typeof context === "function") {
+			const assignment = ({ spawn, event, self: self$1 }) => context({
+				spawn,
+				input: event.input,
+				self: self$1
+			});
+			return resolveActionsAndContext(preInitial, initEvent, actorScope, [assign(assignment)], internalQueue, void 0);
+		}
+		return preInitial;
+	}
+	/**
+	* Returns the initial `State` instance, with reference to `self` as an
+	* `ActorRef`.
+	*/
+	getInitialSnapshot(actorScope, input) {
+		const initEvent = createInitEvent(input);
+		const internalQueue = [];
+		const preInitialState = this.getPreInitialState(actorScope, initEvent, internalQueue);
+		const { snapshot: macroState } = macrostep(microstep([{
+			target: [...getInitialStateNodes(this.root)],
+			source: this.root,
+			reenter: true,
+			actions: [],
+			eventType: null,
+			toJSON: null
+		}], preInitialState, actorScope, initEvent, true, internalQueue), initEvent, actorScope, internalQueue);
+		return macroState;
+	}
+	start(snapshot) {
+		Object.values(snapshot.children).forEach((child) => {
+			if (child.getSnapshot().status === "active") child.start();
+		});
+	}
+	getStateNodeById(stateId) {
+		const fullPath = toStatePath(stateId);
+		const relativePath = fullPath.slice(1);
+		const resolvedStateId = isStateId(fullPath[0]) ? fullPath[0].slice(1) : fullPath[0];
+		const stateNode = this.idMap.get(resolvedStateId);
+		if (!stateNode) throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
+		return getStateNodeByPath(stateNode, relativePath);
+	}
+	get definition() {
+		return this.root.definition;
+	}
+	toJSON() {
+		return this.definition;
+	}
+	getPersistedSnapshot(snapshot, options) {
+		return getPersistedSnapshot(snapshot, options);
+	}
+	restoreSnapshot(snapshot, _actorScope) {
+		const children = {};
+		const snapshotChildren = snapshot.children;
+		Object.keys(snapshotChildren).forEach((actorId) => {
+			const actorData = snapshotChildren[actorId];
+			const childState = actorData.snapshot;
+			const src = actorData.src;
+			const logic = typeof src === "string" ? resolveReferencedActor(this, src) : src;
+			if (!logic) return;
+			children[actorId] = createActor(logic, {
+				id: actorId,
+				parent: _actorScope.self,
+				syncSnapshot: actorData.syncSnapshot,
+				snapshot: childState,
+				src,
+				systemId: actorData.systemId
+			});
+		});
+		function resolveHistoryReferencedState(root, referenced) {
+			if (referenced instanceof StateNode) return referenced;
+			try {
+				return root.machine.getStateNodeById(referenced.id);
+			} catch {}
+		}
+		function reviveHistoryValue(root, historyValue) {
+			if (!historyValue || typeof historyValue !== "object") return {};
+			const revived = {};
+			for (const key in historyValue) {
+				const arr = historyValue[key];
+				for (const item of arr) {
+					const resolved = resolveHistoryReferencedState(root, item);
+					if (!resolved) continue;
+					revived[key] ??= [];
+					revived[key].push(resolved);
+				}
+			}
+			return revived;
+		}
+		const revivedHistoryValue = reviveHistoryValue(this.root, snapshot.historyValue);
+		const restoredSnapshot = createMachineSnapshot({
+			...snapshot,
+			children,
+			_nodes: Array.from(getAllStateNodes(getStateNodes(this.root, snapshot.value))),
+			historyValue: revivedHistoryValue
+		}, this);
+		const seen = /* @__PURE__ */ new Set();
+		function reviveContext(contextPart, children$1) {
+			if (seen.has(contextPart)) return;
+			seen.add(contextPart);
+			for (const key in contextPart) {
+				const value = contextPart[key];
+				if (value && typeof value === "object") {
+					if ("xstate$$type" in value && value.xstate$$type === $$ACTOR_TYPE) {
+						contextPart[key] = children$1[value.id];
+						continue;
+					}
+					reviveContext(value, children$1);
+				}
+			}
+		}
+		reviveContext(restoredSnapshot.context, children);
+		return restoredSnapshot;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/log-7cbae384.esm.js
+function resolveEmit(_, snapshot, args, actionParams, { event: eventOrExpr }) {
+	return [
+		snapshot,
+		{ event: typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr },
+		void 0
+	];
+}
+function executeEmit(actorScope, { event }) {
+	actorScope.defer(() => actorScope.emit(event));
+}
+/**
+* Emits an event to event handlers registered on the actor via `actor.on(event,
+* handler)`.
+*
+* @example
+*
+* ```ts
+* import { emit } from 'xstate';
+*
+* const machine = createMachine({
+*   // ...
+*   on: {
+*     something: {
+*       actions: emit({
+*         type: 'emitted',
+*         some: 'data'
+*       })
+*     }
+*   }
+*   // ...
+* });
+*
+* const actor = createActor(machine).start();
+*
+* actor.on('emitted', (event) => {
+*   console.log(event);
+* });
+*
+* actor.send({ type: 'something' });
+* // logs:
+* // {
+* //   type: 'emitted',
+* //   some: 'data'
+* // }
+* ```
+*/
+function emit(eventOrExpr) {
+	function emit$1(_args, _params) {}
+	emit$1.type = "xstate.emit";
+	emit$1.event = eventOrExpr;
+	emit$1.resolve = resolveEmit;
+	emit$1.execute = executeEmit;
+	return emit$1;
+}
+/**
+* @remarks
+* `T | unknown` reduces to `unknown` and that can be problematic when it comes
+* to contextual typing. It especially is a problem when the union has a
+* function member, like here:
+*
+* ```ts
+* declare function test(
+*   cbOrVal: ((arg: number) => unknown) | unknown
+* ): void;
+* test((arg) => {}); // oops, implicit any
+* ```
+*
+* This type can be used to avoid this problem. This union represents the same
+* value space as `unknown`.
+*/
+/** @deprecated Use the built-in `NoInfer` type instead */
+/** The full definition of an event, with a string `type`. */
+/**
+* The string or object representing the state value relative to the parent
+* state node.
+*
+* @remarks
+* - For a child atomic state node, this is a string, e.g., `"pending"`.
+* - For complex state nodes, this is an object, e.g., `{ success:
+*   "someChildState" }`.
+*/
+/** @deprecated Use `AnyMachineSnapshot` instead */
+/** @ignore */
+let SpecialTargets = /* @__PURE__ */ function(SpecialTargets$1) {
+	SpecialTargets$1["Parent"] = "#_parent";
+	SpecialTargets$1["Internal"] = "#_internal";
+	return SpecialTargets$1;
+}({});
+/** @deprecated Use `AnyActor` instead. */
+/** @deprecated Use `Actor<T>` instead. */
+/**
+* Represents logic which can be used by an actor.
+*
+* @template TSnapshot - The type of the snapshot.
+* @template TEvent - The type of the event object.
+* @template TInput - The type of the input.
+* @template TSystem - The type of the actor system.
+*/
+/** @deprecated */
+function resolveSendTo(actorScope, snapshot, args, actionParams, { to, event: eventOrExpr, id, delay }, extra) {
+	const delaysMap = snapshot.machine.implementations.delays;
+	if (typeof eventOrExpr === "string") throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
+	const resolvedEvent = typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr;
+	let resolvedDelay;
+	if (typeof delay === "string") {
+		const configDelay = delaysMap && delaysMap[delay];
+		resolvedDelay = typeof configDelay === "function" ? configDelay(args, actionParams) : configDelay;
+	} else resolvedDelay = typeof delay === "function" ? delay(args, actionParams) : delay;
+	const resolvedTarget = typeof to === "function" ? to(args, actionParams) : to;
+	let targetActorRef;
+	if (typeof resolvedTarget === "string") {
+		if (resolvedTarget === SpecialTargets.Parent) targetActorRef = actorScope.self._parent;
+		else if (resolvedTarget === SpecialTargets.Internal) targetActorRef = actorScope.self;
+		else if (resolvedTarget.startsWith("#_")) targetActorRef = snapshot.children[resolvedTarget.slice(2)];
+		else targetActorRef = extra.deferredActorIds?.includes(resolvedTarget) ? resolvedTarget : snapshot.children[resolvedTarget];
+		if (!targetActorRef) throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${snapshot.machine.id}'.`);
+	} else targetActorRef = resolvedTarget || actorScope.self;
+	return [
+		snapshot,
+		{
+			to: targetActorRef,
+			targetId: typeof resolvedTarget === "string" ? resolvedTarget : void 0,
+			event: resolvedEvent,
+			id,
+			delay: resolvedDelay
+		},
+		void 0
+	];
+}
+function retryResolveSendTo(_, snapshot, params) {
+	if (typeof params.to === "string") params.to = snapshot.children[params.to];
+}
+function executeSendTo(actorScope, params) {
+	actorScope.defer(() => {
+		const { to, event, delay, id } = params;
+		if (typeof delay === "number") {
+			actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
+			return;
+		}
+		actorScope.system._relay(actorScope.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
+	});
+}
+/**
+* Sends an event to an actor.
+*
+* @param actor The `ActorRef` to send the event to.
+* @param event The event to send, or an expression that evaluates to the event
+*   to send
+* @param options Send action options
+*
+*   - `id` - The unique send event identifier (used with `cancel()`).
+*   - `delay` - The number of milliseconds to delay the sending of the event.
+*/
+function sendTo(to, eventOrExpr, options) {
+	function sendTo$1(_args, _params) {}
+	sendTo$1.type = "xstate.sendTo";
+	sendTo$1.to = to;
+	sendTo$1.event = eventOrExpr;
+	sendTo$1.id = options?.id;
+	sendTo$1.delay = options?.delay;
+	sendTo$1.resolve = resolveSendTo;
+	sendTo$1.retryResolve = retryResolveSendTo;
+	sendTo$1.execute = executeSendTo;
+	return sendTo$1;
+}
+/**
+* Sends an event to this machine's parent.
+*
+* @param event The event to send to the parent machine.
+* @param options Options to pass into the send event.
+*/
+function sendParent(event, options) {
+	return sendTo(SpecialTargets.Parent, event, options);
+}
+function resolveEnqueueActions(actorScope, snapshot, args, actionParams, { collect }) {
+	const actions = [];
+	const enqueue = function enqueue$1(action) {
+		actions.push(action);
+	};
+	enqueue.assign = (...args$1) => {
+		actions.push(assign(...args$1));
+	};
+	enqueue.cancel = (...args$1) => {
+		actions.push(cancel(...args$1));
+	};
+	enqueue.raise = (...args$1) => {
+		actions.push(raise(...args$1));
+	};
+	enqueue.sendTo = (...args$1) => {
+		actions.push(sendTo(...args$1));
+	};
+	enqueue.sendParent = (...args$1) => {
+		actions.push(sendParent(...args$1));
+	};
+	enqueue.spawnChild = (...args$1) => {
+		actions.push(spawnChild(...args$1));
+	};
+	enqueue.stopChild = (...args$1) => {
+		actions.push(stopChild(...args$1));
+	};
+	enqueue.emit = (...args$1) => {
+		actions.push(emit(...args$1));
+	};
+	collect({
+		context: args.context,
+		event: args.event,
+		enqueue,
+		check: (guard) => evaluateGuard(guard, snapshot.context, args.event, snapshot),
+		self: actorScope.self,
+		system: actorScope.system
+	}, actionParams);
+	return [
+		snapshot,
+		void 0,
+		actions
+	];
+}
+/**
+* Creates an action object that will execute actions that are queued by the
+* `enqueue(action)` function.
+*
+* @example
+*
+* ```ts
+* import { createMachine, enqueueActions } from 'xstate';
+*
+* const machine = createMachine({
+*   entry: enqueueActions(({ enqueue, check }) => {
+*     enqueue.assign({ count: 0 });
+*
+*     if (check('someGuard')) {
+*       enqueue.assign({ count: 1 });
+*     }
+*
+*     enqueue('someAction');
+*   })
+* });
+* ```
+*/
+function enqueueActions(collect) {
+	function enqueueActions$1(_args, _params) {}
+	enqueueActions$1.type = "xstate.enqueueActions";
+	enqueueActions$1.collect = collect;
+	enqueueActions$1.resolve = resolveEnqueueActions;
+	return enqueueActions$1;
+}
+function resolveLog(_, snapshot, actionArgs, actionParams, { value, label }) {
+	return [
+		snapshot,
+		{
+			value: typeof value === "function" ? value(actionArgs, actionParams) : value,
+			label
+		},
+		void 0
+	];
+}
+function executeLog({ logger }, { value, label }) {
+	if (label) logger(label, value);
+	else logger(value);
+}
+/**
+* @param expr The expression function to evaluate which will be logged. Takes
+*   in 2 arguments:
+*
+*   - `ctx` - the current state context
+*   - `event` - the event that caused this action to be executed.
+*
+* @param label The label to give to the logged expression.
+*/
+function log(value = ({ context, event }) => ({
+	context,
+	event
+}), label) {
+	function log$1(_args, _params) {}
+	log$1.type = "xstate.log";
+	log$1.value = value;
+	log$1.label = label;
+	log$1.resolve = resolveLog;
+	log$1.execute = executeLog;
+	return log$1;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/xstate.esm.js
+/**
+* Creates a state machine (statechart) with the given configuration.
+*
+* The state machine represents the pure logic of a state machine actor.
+*
+* @example
+*
+* ```ts
+* import { createMachine } from 'xstate';
+*
+* const lightMachine = createMachine({
+*   id: 'light',
+*   initial: 'green',
+*   states: {
+*     green: {
+*       on: {
+*         TIMER: { target: 'yellow' }
+*       }
+*     },
+*     yellow: {
+*       on: {
+*         TIMER: { target: 'red' }
+*       }
+*     },
+*     red: {
+*       on: {
+*         TIMER: { target: 'green' }
+*       }
+*     }
+*   }
+* });
+*
+* const lightActor = createActor(lightMachine);
+* lightActor.start();
+*
+* lightActor.send({ type: 'TIMER' });
+* ```
+*
+* @param config The state machine configuration.
+* @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+*   to provide machine implementations instead.
+*/
+function createMachine(config, implementations) {
+	return new StateMachine(config, implementations);
+}
+function setup({ schemas, actors, actions, guards, delays }) {
+	return {
+		assign,
+		sendTo,
+		raise,
+		log,
+		cancel,
+		stopChild,
+		enqueueActions,
+		emit,
+		spawnChild,
+		createStateConfig: (config) => config,
+		createAction: (fn) => fn,
+		createMachine: (config) => createMachine({
+			...config,
+			schemas
+		}, {
+			actors,
+			actions,
+			guards,
+			delays
+		}),
+		extend: (extended) => setup({
+			schemas,
+			actors,
+			actions: {
+				...actions,
+				...extended.actions
+			},
+			guards: {
+				...guards,
+				...extended.guards
+			},
+			delays: {
+				...delays,
+				...extended.delays
+			}
+		})
+	};
+}
+
+//#endregion
+export { createActor as a, fromPromise as i, assign as n, fromCallback as r, setup as t };