xstate 5.0.0-beta.26 → 5.0.0-beta.28

package/dist/actions-5943a9db.esm.js

@@ -1,3018 +0,0 @@
-import { devToolsAdapter } from '../dev/dist/xstate-dev.esm.js';
-
-/**
- * `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`.
- */
-
-// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
-
-/**
- * The full definition of an event, with a string `type`.
- */
-
-// TODO: do not accept machines without all implementations
-// we should also accept a raw machine as actor logic here
-// or just make machine actor logic
-
-/**
- * The string or object representing the state value relative to the parent state node.
- *
- * - 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" }`.
- */
-
-// TODO: remove once TS fixes this type-widening issue
-
-// TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
-
-let ConstantPrefix = /*#__PURE__*/function (ConstantPrefix) {
-  ConstantPrefix["After"] = "xstate.after";
-  ConstantPrefix["DoneState"] = "done.state";
-  ConstantPrefix["DoneInvoke"] = "done.invoke";
-  ConstantPrefix["ErrorExecution"] = "error.execution";
-  ConstantPrefix["ErrorCommunication"] = "error.communication";
-  ConstantPrefix["ErrorPlatform"] = "error.platform";
-  ConstantPrefix["ErrorCustom"] = "xstate.error";
-  return ConstantPrefix;
-}({});
-let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
-  SpecialTargets["Parent"] = "#_parent";
-  SpecialTargets["Internal"] = "#_internal";
-  return SpecialTargets;
-}({});
-
-const after$1 = ConstantPrefix.After;
-const doneState = ConstantPrefix.DoneState;
-const errorExecution = ConstantPrefix.ErrorExecution;
-const errorPlatform = ConstantPrefix.ErrorPlatform;
-const error$1 = ConstantPrefix.ErrorCustom;
-
-var constantPrefixes = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  after: after$1,
-  doneState: doneState,
-  errorExecution: errorExecution,
-  errorPlatform: errorPlatform,
-  error: error$1
-});
-
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const INIT_TYPE = 'xstate.init';
-
-function resolve$8(actorContext, state, args, {
-  to,
-  event: eventOrExpr,
-  id,
-  delay
-}) {
-  const delaysMap = state.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) : eventOrExpr;
-  let resolvedDelay;
-  if (typeof delay === 'string') {
-    const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
-  } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
-  }
-  const resolvedTarget = typeof to === 'function' ? to(args) : to;
-  let targetActorRef;
-  if (typeof resolvedTarget === 'string') {
-    if (resolvedTarget === SpecialTargets.Parent) {
-      targetActorRef = actorContext?.self._parent;
-    } else if (resolvedTarget === SpecialTargets.Internal) {
-      targetActorRef = actorContext?.self;
-    } else if (resolvedTarget.startsWith('#_')) {
-      // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
-      // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
-      targetActorRef = state.children[resolvedTarget.slice(2)];
-    } else {
-      targetActorRef = state.children[resolvedTarget];
-    }
-    if (!targetActorRef) {
-      throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
-    }
-  } else {
-    targetActorRef = resolvedTarget || actorContext?.self;
-  }
-  return [state, {
-    to: targetActorRef,
-    event: resolvedEvent,
-    id,
-    delay: resolvedDelay
-  }];
-}
-function execute$5(actorContext, params) {
-  if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
-    return;
-  }
-  const {
-    to,
-    event
-  } = params;
-  actorContext.defer(() => {
-    to.send(event.type === error$1 ? {
-      type: `${error(actorContext.self.id)}`,
-      data: 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(_) {
-  }
-  sendTo.type = 'xstate.sendTo';
-  sendTo.to = to;
-  sendTo.event = eventOrExpr;
-  sendTo.id = options?.id;
-  sendTo.delay = options?.delay;
-  sendTo.resolve = resolve$8;
-  sendTo.execute = execute$5;
-  return sendTo;
-}
-
-/**
- * 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);
-}
-/**
- * Forwards (sends) an event to a specified service.
- *
- * @param target The target service to forward the event to.
- * @param options Options to pass into the send action creator.
- */
-function forwardTo(target, options) {
-  return sendTo(target, ({
-    event
-  }) => event, options);
-}
-
-/**
- * Escalates an error by sending it as an event to this machine's parent.
- *
- * @param errorData The error data to send, or the expression function that
- * takes in the `context`, `event`, and `meta`, and returns the error data to send.
- * @param options Options to pass into the send action creator.
- */
-function escalate(errorData, options) {
-  return sendParent(arg => {
-    return {
-      type: error$1,
-      data: typeof errorData === 'function' ? errorData(arg) : errorData
-    };
-  }, options);
-}
-
-const cache = 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];
-}
-
-function resolve$7(_, state, actionArgs, {
-  sendId
-}) {
-  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
-  return [state, resolvedSendId];
-}
-function execute$4(actorContext, resolvedSendId) {
-  actorContext.self.cancel(resolvedSendId);
-}
-
-/**
- * Cancels an in-flight `send(...)` action. A canceled sent action will not
- * be executed, nor will its event be sent, unless it has already been sent
- * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
- *
- * @param sendId The `id` of the `send(...)` action to cancel.
- */
-function cancel(sendId) {
-  function cancel(_) {
-  }
-  cancel.type = 'xstate.cancel';
-  cancel.sendId = sendId;
-  cancel.resolve = resolve$7;
-  cancel.execute = execute$4;
-  return cancel;
-}
-
-class Mailbox {
-  constructor(_process) {
-    this._process = _process;
-    this._active = false;
-    this._current = null;
-    this._last = null;
-  }
-  start() {
-    this._active = true;
-    this.flush();
-  }
-  clear() {
-    // we can't set _current to null because we might be currently processing
-    // and enqueue following clear shouldnt start processing the enqueued item immediately
-    if (this._current) {
-      this._current.next = null;
-      this._last = this._current;
-    }
-  }
-
-  // TODO: rethink this design
-  prepend(event) {
-    if (!this._current) {
-      this.enqueue(event);
-      return;
-    }
-
-    // we know that something is already queued up
-    // so the mailbox is already flushing or it's inactive
-    // therefore the only thing that we need to do is to reassign `this._current`
-    this._current = {
-      value: event,
-      next: 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) {
-      // atm the given _process is responsible for implementing proper try/catch handling
-      // we assume here that this won't throw in a way that can affect this mailbox
-      const consumed = this._current;
-      this._process(consumed.value);
-      // something could have been prepended in the meantime
-      // so we need to be defensive here to avoid skipping over a prepended item
-      if (consumed === this._current) {
-        this._current = this._current.next;
-      }
-    }
-    this._last = null;
-  }
-}
-
-const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
-/**
- * Returns actor logic from a transition function and its initial state.
- *
- * A transition function is a function that takes the current state and an event and returns the next state.
- *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
- * @returns Actor logic
- */
-function fromTransition(transition, initialState) {
-  return {
-    config: transition,
-    transition: (state, event, actorContext) => {
-      return transition(state, event, actorContext);
-    },
-    getInitialState: (_, input) => {
-      return typeof initialState === 'function' ? initialState({
-        input
-      }) : initialState;
-    },
-    getSnapshot: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-}
-
-function matchesState(parentStateId, childStateId) {
-  const parentStateValue = toStateValue(parentStateId);
-  const childStateValue = toStateValue(childStateId);
-  if (typeof childStateValue === 'string') {
-    if (typeof parentStateValue === 'string') {
-      return childStateValue === parentStateValue;
-    }
-
-    // Parent more specific than child
-    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) {
-  try {
-    if (isArray(stateId)) {
-      return stateId;
-    }
-    return stateId.toString().split(STATE_DELIMITER);
-  } catch (e) {
-    throw new Error(`'${stateId}' is not a valid state path.`);
-  }
-}
-function isStateLike(state) {
-  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state;
-}
-function toStateValue(stateValue) {
-  if (isStateLike(stateValue)) {
-    return stateValue.value;
-  }
-  if (isArray(stateValue)) {
-    return pathToStateValue(stateValue);
-  }
-  if (typeof stateValue !== 'string') {
-    return stateValue;
-  }
-  const statePath = toStatePath(stateValue);
-  return pathToStateValue(statePath);
-}
-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 flatten(array) {
-  return [].concat(...array);
-}
-function toArrayStrict(value) {
-  if (isArray(value)) {
-    return value;
-  }
-  return [value];
-}
-function toArray(value) {
-  if (value === undefined) {
-    return [];
-  }
-  return toArrayStrict(value);
-}
-function mapContext(mapper, context, event, self) {
-  if (typeof mapper === 'function') {
-    return mapper({
-      context,
-      event,
-      self
-    });
-  }
-  return mapper;
-}
-function isPromiseLike(value) {
-  if (value instanceof Promise) {
-    return true;
-  }
-  // Check if shape matches the Promise/A+ specification for a "thenable".
-  if (value !== null && (typeof value === 'function' || typeof value === 'object') && typeof value.then === 'function') {
-    return true;
-  }
-  return false;
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isErrorEvent(event) {
-  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
-}
-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 === undefined || target === TARGETLESS_KEY) {
-    return undefined;
-  }
-  return toArray(target);
-}
-function toInvokeConfig(invocable, id) {
-  if (typeof invocable === 'object') {
-    if ('src' in invocable) {
-      return invocable;
-    }
-    if ('transition' in invocable) {
-      return {
-        id,
-        src: invocable
-      };
-    }
-  }
-  return {
-    id,
-    src: invocable
-  };
-}
-function toObserver(nextHandler, errorHandler, completionHandler) {
-  const isObserver = typeof nextHandler === 'object';
-  const self = isObserver ? nextHandler : undefined;
-  return {
-    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
-    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
-  };
-}
-function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
-}
-function resolveReferencedActor(referenced) {
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
-}
-
-function fromCallback(invokeCallback) {
-  return {
-    config: invokeCallback,
-    start: (_state, {
-      self
-    }) => {
-      self.send({
-        type: startSignalType
-      });
-    },
-    transition: (state, event, {
-      self,
-      id,
-      system
-    }) => {
-      if (event.type === startSignalType) {
-        const sendBack = eventForParent => {
-          if (state.canceled) {
-            return;
-          }
-          self._parent?.send(eventForParent);
-        };
-        const receive = newListener => {
-          state.receivers.add(newListener);
-        };
-        state.dispose = invokeCallback({
-          input: state.input,
-          system,
-          self: self,
-          sendBack,
-          receive
-        });
-        if (isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(doneInvoke(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(error(id, errorData));
-          });
-        }
-        return state;
-      }
-      if (event.type === stopSignalType) {
-        state.canceled = true;
-        if (typeof state.dispose === 'function') {
-          state.dispose();
-        }
-        return state;
-      }
-      if (isSignal(event)) {
-        // TODO: unrecognized signal
-        return state;
-      }
-      state.receivers.forEach(receiver => receiver(event));
-      return state;
-    },
-    getInitialState: (_, input) => {
-      return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
-        input
-      };
-    },
-    getSnapshot: () => undefined,
-    getPersistedState: ({
-      input,
-      canceled
-    }) => ({
-      input,
-      canceled
-    })
-  };
-}
-
-function fromObservable(observableCreator) {
-  const nextEventType = '$$xstate.next';
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-  return {
-    config: observableCreator,
-    transition: (state, event, {
-      self,
-      id,
-      defer
-    }) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case nextEventType:
-          // match the exact timing of events sent by machines
-          // send actions are not executed immediately
-          defer(() => {
-            self._parent?.send({
-              type: `xstate.snapshot.${id}`,
-              data: event.data
-            });
-          });
-          return {
-            ...state,
-            data: event.data
-          };
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = observableCreator({
-        input: state.input,
-        system,
-        self
-      }).subscribe({
-        next: value => {
-          self.send({
-            type: nextEventType,
-            data: value
-          });
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: state => state.data,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-}
-
-/**
- * Creates event observable logic that listens to an observable
- * that delivers event objects.
- *
- *
- * @param lazyObservable A function that creates an observable
- * @returns Event observable logic
- */
-
-function fromEventObservable(lazyObservable) {
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-
-  // TODO: event types
-  return {
-    config: lazyObservable,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = lazyObservable({
-        input: state.input,
-        system,
-        self
-      }).subscribe({
-        next: value => {
-          self._parent?.send(value);
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: _ => undefined,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-}
-
-const resolveEventType = '$$xstate.resolve';
-const rejectEventType = '$$xstate.reject';
-function fromPromise(
-// TODO: add types
-promiseCreator) {
-  // TODO: add event types
-  const logic = {
-    config: promiseCreator,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
-        case rejectEventType:
-          return {
-            ...state,
-            status: 'error',
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            input: undefined
-          };
-        case stopSignalType:
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      // TODO: determine how to allow customizing this so that promises
-      // can be restarted if necessary
-      if (state.status !== 'active') {
-        return;
-      }
-      const resolvedPromise = Promise.resolve(promiseCreator({
-        input: state.input,
-        system,
-        self
-      }));
-      resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: resolveEventType,
-          data: response
-        });
-      }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: rejectEventType,
-          data: errorData
-        });
-      });
-    },
-    getInitialState: (_, input) => {
-      return {
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-  return logic;
-}
-
-const startSignalType = 'xstate.init';
-const stopSignalType = 'xstate.stop';
-const startSignal = {
-  type: 'xstate.init'
-};
-const stopSignal = {
-  type: 'xstate.stop'
-};
-/**
- * An object that expresses the actor logic in reaction to received events,
- * as well as an optionally emitted stream of values.
- *
- * @template TReceived The received event
- * @template TSnapshot The emitted value
- */
-
-function isSignal(event) {
-  return event.type === startSignalType || event.type === stopSignalType;
-}
-function isActorRef(item) {
-  return !!item && typeof item === 'object' && typeof item.send === 'function';
-}
-
-// TODO: refactor the return type, this could be written in a better way
-// but it's best to avoid unneccessary breaking changes now
-// @deprecated use `interpret(actorLogic)` instead
-function toActorRef(actorRefLike) {
-  return {
-    subscribe: () => ({
-      unsubscribe: () => void 0
-    }),
-    id: 'anonymous',
-    sessionId: '',
-    getSnapshot: () => undefined,
-    // TODO: this isn't safe
-    [symbolObservable]: function () {
-      return this;
-    },
-    status: ActorStatus.Running,
-    stop: () => void 0,
-    ...actorRefLike
-  };
-}
-const emptyLogic = fromTransition(_ => undefined, undefined);
-function createEmptyActor() {
-  return createActor(emptyLogic);
-}
-
-/**
- * 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;
-  });
-}
-
-function createSystem() {
-  let sessionIdCounter = 0;
-  const children = new Map();
-  const keyedActors = new Map();
-  const reverseKeyedActors = new WeakMap();
-  const system = {
-    _bookId: () => `x:${sessionIdCounter++}`,
-    _register: (sessionId, actorRef) => {
-      children.set(sessionId, actorRef);
-      return sessionId;
-    },
-    _unregister: actorRef => {
-      children.delete(actorRef.sessionId);
-      const systemId = reverseKeyedActors.get(actorRef);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actorRef);
-      }
-    },
-    get: systemId => {
-      return keyedActors.get(systemId);
-    },
-    _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);
-    }
-  };
-  return system;
-}
-
-let ActorStatus = /*#__PURE__*/function (ActorStatus) {
-  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
-  ActorStatus[ActorStatus["Running"] = 1] = "Running";
-  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
-  return ActorStatus;
-}({});
-
-/**
- * @deprecated Use `ActorStatus` instead.
- */
-const InterpreterStatus = ActorStatus;
-const defaultOptions = {
-  deferEvents: true,
-  clock: {
-    setTimeout: (fn, ms) => {
-      return setTimeout(fn, ms);
-    },
-    clearTimeout: id => {
-      return clearTimeout(id);
-    }
-  },
-  logger: console.log.bind(console),
-  devTools: false
-};
-class Actor {
-  /**
-   * The current internal state of the actor.
-   */
-
-  /**
-   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
-   */
-
-  /**
-   * The unique identifier for this actor relative to its parent.
-   */
-
-  /**
-   * Whether the service is started.
-   */
-
-  // Actor Ref
-
-  // TODO: add typings for system
-
-  /**
-   * The globally unique process ID for this invocation.
-   */
-
-  /**
-   * 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;
-    this._state = void 0;
-    this.clock = void 0;
-    this.options = void 0;
-    this.id = void 0;
-    this.mailbox = new Mailbox(this._process.bind(this));
-    this.delayedEventsMap = {};
-    this.observers = new Set();
-    this.logger = void 0;
-    this.status = ActorStatus.NotStarted;
-    this._parent = void 0;
-    this.ref = void 0;
-    this._actorContext = void 0;
-    this._systemId = void 0;
-    this.sessionId = void 0;
-    this.system = void 0;
-    this._doneEvent = void 0;
-    this.src = void 0;
-    this._deferred = [];
-    const resolvedOptions = {
-      ...defaultOptions,
-      ...options
-    };
-    const {
-      clock,
-      logger,
-      parent,
-      id,
-      systemId
-    } = resolvedOptions;
-    const self = this;
-    this.system = parent?.system ?? createSystem();
-    if (systemId) {
-      this._systemId = systemId;
-      this.system._set(systemId, this);
-    }
-    this.sessionId = this.system._bookId();
-    this.id = id ?? this.sessionId;
-    this.logger = logger;
-    this.clock = clock;
-    this._parent = parent;
-    this.options = resolvedOptions;
-    this.src = resolvedOptions.src;
-    this.ref = this;
-    this._actorContext = {
-      self,
-      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();
-      }
-    };
-
-    // Ensure that the send method is bound to this Actor instance
-    // if destructured
-    this.send = this.send.bind(this);
-    this._initState();
-  }
-  _initState() {
-    this._state = this.options.state ? this.logic.restoreState ? this.logic.restoreState(this.options.state, this._actorContext) : this.options.state : this.logic.getInitialState(this._actorContext, this.options?.input);
-  }
-
-  // array of functions to defer
-
-  update(state) {
-    // Update state
-    this._state = state;
-    const snapshot = this.getSnapshot();
-
-    // Execute deferred effects
-    let deferredFn;
-    while (deferredFn = this._deferred.shift()) {
-      deferredFn();
-    }
-    for (const observer of this.observers) {
-      // TODO: should observers be notified in case of the error?
-      try {
-        observer.next?.(snapshot);
-      } catch (err) {
-        reportUnhandledError(err);
-      }
-    }
-    const status = this.logic.getStatus?.(state);
-    switch (status?.status) {
-      case 'done':
-        this._stopProcedure();
-        this._complete();
-        this._doneEvent = doneInvoke(this.id, status.data);
-        this._parent?.send(this._doneEvent);
-        break;
-      case 'error':
-        this._stopProcedure();
-        this._error(status.data);
-        this._parent?.send(error(this.id, status.data));
-        break;
-    }
-  }
-  subscribe(nextListenerOrObserver, errorListener, completeListener) {
-    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
-    if (this.status !== ActorStatus.Stopped) {
-      this.observers.add(observer);
-    } else {
-      try {
-        observer.complete?.();
-      } catch (err) {
-        reportUnhandledError(err);
-      }
-    }
-    return {
-      unsubscribe: () => {
-        this.observers.delete(observer);
-      }
-    };
-  }
-
-  /**
-   * Starts the Actor from the initial state
-   */
-  start() {
-    if (this.status === ActorStatus.Running) {
-      // Do not restart the service if it is already started
-      return this;
-    }
-    this.system._register(this.sessionId, this);
-    if (this._systemId) {
-      this.system._set(this._systemId, this);
-    }
-    this.status = ActorStatus.Running;
-    const status = this.logic.getStatus?.(this._state);
-    switch (status?.status) {
-      case 'done':
-        // a state machine can be "done" upon intialization (it could reach a final state using initial microsteps)
-        // we still need to complete observers, flush deferreds etc
-        this.update(this._state);
-      // fallthrough
-      case 'error':
-        // TODO: rethink cleanup of observers, mailbox, etc
-        return this;
-    }
-    if (this.logic.start) {
-      try {
-        this.logic.start(this._state, this._actorContext);
-      } catch (err) {
-        this._stopProcedure();
-        this._error(err);
-        this._parent?.send(error(this.id, err));
-        return this;
-      }
-    }
-
-    // TODO: this notifies all subscribers but usually this is redundant
-    // there is no real change happening here
-    // we need to rethink if this needs to be refactored
-    this.update(this._state);
-    if (this.options.devTools) {
-      this.attachDevTools();
-    }
-    this.mailbox.start();
-    return this;
-  }
-  _process(event) {
-    // TODO: reexamine what happens when an action (or a guard or smth) throws
-    let nextState;
-    let caughtError;
-    try {
-      nextState = this.logic.transition(this._state, event, this._actorContext);
-    } catch (err) {
-      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
-      caughtError = {
-        err
-      };
-    }
-    if (caughtError) {
-      const {
-        err
-      } = caughtError;
-      this._stopProcedure();
-      this._error(err);
-      this._parent?.send(error(this.id, err));
-      return;
-    }
-    this.update(nextState);
-    if (event.type === stopSignalType) {
-      this._stopProcedure();
-      this._complete();
-    }
-  }
-  _stop() {
-    if (this.status === ActorStatus.Stopped) {
-      return this;
-    }
-    this.mailbox.clear();
-    if (this.status === ActorStatus.NotStarted) {
-      this.status = ActorStatus.Stopped;
-      return this;
-    }
-    this.mailbox.enqueue({
-      type: stopSignalType
-    });
-    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();
-  }
-  _error(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);
-    }
-  }
-  _stopProcedure() {
-    if (this.status !== ActorStatus.Running) {
-      // Actor already stopped; do nothing
-      return this;
-    }
-
-    // Cancel all delayed events
-    for (const key of Object.keys(this.delayedEventsMap)) {
-      this.clock.clearTimeout(this.delayedEventsMap[key]);
-    }
-
-    // TODO: mailbox.reset
-    this.mailbox.clear();
-    // TODO: after `stop` we must prepare ourselves for receiving events again
-    // events sent *after* stop signal must be queued
-    // it seems like this should be the common behavior for all of our consumers
-    // so perhaps this should be unified somehow for all of them
-    this.mailbox = new Mailbox(this._process.bind(this));
-    this.status = ActorStatus.Stopped;
-    this.system._unregister(this);
-    return this;
-  }
-
-  /**
-   * Sends an event to the running Actor to trigger a transition.
-   *
-   * @param event The event to send
-   */
-  send(event) {
-    if (typeof event === 'string') {
-      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
-    }
-    if (this.status === ActorStatus.Stopped) {
-      return;
-    }
-    if (this.status !== ActorStatus.Running && !this.options.deferEvents) {
-      throw new Error(`Event "${event.type}" was sent to uninitialized actor "${this.id
-      // tslint:disable-next-line:max-line-length
-      }". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ${JSON.stringify(event)}`);
-    }
-    this.mailbox.enqueue(event);
-  }
-
-  // TODO: make private (and figure out a way to do this within the machine)
-  delaySend({
-    event,
-    id,
-    delay,
-    to
-  }) {
-    const timerId = this.clock.setTimeout(() => {
-      if (to) {
-        to.send(event);
-      } else {
-        this.send(event);
-      }
-    }, delay);
-
-    // TODO: consider the rehydration story here
-    if (id) {
-      this.delayedEventsMap[id] = timerId;
-    }
-  }
-
-  // TODO: make private (and figure out a way to do this within the machine)
-  cancel(sendId) {
-    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
-    delete this.delayedEventsMap[sendId];
-  }
-  attachDevTools() {
-    const {
-      devTools
-    } = this.options;
-    if (devTools) {
-      const resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : devToolsAdapter;
-      resolvedDevToolsAdapter(this);
-    }
-  }
-  toJSON() {
-    return {
-      id: this.id
-    };
-  }
-  getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
-  }
-  [symbolObservable]() {
-    return this;
-  }
-  getSnapshot() {
-    return this.logic.getSnapshot ? this.logic.getSnapshot(this._state) : this._state;
-  }
-}
-
-/**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
- */
-
-function createActor(logic, options) {
-  const interpreter = new Actor(logic, options);
-  return interpreter;
-}
-
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @deprecated Use `createActor` instead
- */
-const interpret = createActor;
-
-/**
- * @deprecated Use `Actor` instead.
- */
-
-function resolve$6(actorContext, state, actionArgs, {
-  id,
-  systemId,
-  src,
-  input
-}) {
-  const referenced = resolveReferencedActor(state.machine.implementations.actors[src]);
-  let actorRef;
-  if (referenced) {
-    // TODO: inline `input: undefined` should win over the referenced one
-    const configuredInput = input || referenced.input;
-    actorRef = createActor(referenced.src, {
-      id,
-      src,
-      parent: actorContext?.self,
-      systemId,
-      input: typeof configuredInput === 'function' ? configuredInput({
-        context: state.context,
-        event: actionArgs.event,
-        self: actorContext?.self
-      }) : configuredInput
-    });
-  }
-  return [cloneState(state, {
-    children: {
-      ...state.children,
-      [id]: actorRef
-    }
-  }), {
-    id,
-    actorRef
-  }];
-}
-function execute$3(actorContext, {
-  id,
-  actorRef
-}) {
-  if (!actorRef) {
-    return;
-  }
-  actorContext.defer(() => {
-    if (actorRef.status === ActorStatus.Stopped) {
-      return;
-    }
-    try {
-      actorRef.start?.();
-    } catch (err) {
-      actorContext.self.send(error(id, err));
-      return;
-    }
-  });
-}
-function invoke({
-  id,
-  systemId,
-  src,
-  input
-}) {
-  function invoke(_) {
-  }
-  invoke.type = 'xstate.invoke';
-  invoke.id = id;
-  invoke.systemId = systemId;
-  invoke.src = src;
-  invoke.input = input;
-  invoke.resolve = resolve$6;
-  invoke.execute = execute$3;
-  return invoke;
-}
-
-function checkStateIn(state, _, {
-  stateValue
-}) {
-  if (typeof stateValue === 'string' && isStateId(stateValue)) {
-    return state.configuration.some(sn => sn.id === stateValue.slice(1));
-  }
-  return state.matches(stateValue);
-}
-function stateIn(stateValue) {
-  function stateIn(_) {
-    return false;
-  }
-  stateIn.check = checkStateIn;
-  stateIn.stateValue = stateValue;
-  return stateIn;
-}
-function checkNot(state, {
-  context,
-  event
-}, {
-  guards
-}) {
-  return !evaluateGuard(guards[0], context, event, state);
-}
-function not(guard) {
-  function not(_) {
-    return false;
-  }
-  not.check = checkNot;
-  not.guards = [guard];
-  return not;
-}
-function checkAnd(state, {
-  context,
-  event
-}, {
-  guards
-}) {
-  return guards.every(guard => evaluateGuard(guard, context, event, state));
-}
-function and(guards) {
-  function and(_) {
-    return false;
-  }
-  and.check = checkAnd;
-  and.guards = guards;
-  return and;
-}
-function checkOr(state, {
-  context,
-  event
-}, {
-  guards
-}) {
-  return guards.some(guard => evaluateGuard(guard, context, event, state));
-}
-function or(guards) {
-  function or(_) {
-    return false;
-  }
-  or.check = checkOr;
-  or.guards = guards;
-  return or;
-}
-
-// TODO: throw on cycles (depth check should be enough)
-function evaluateGuard(guard, context, event, state) {
-  const {
-    machine
-  } = state;
-  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, state);
-  }
-  const guardArgs = {
-    context,
-    event,
-    guard: isInline ? undefined : typeof guard === 'string' ? {
-      type: guard
-    } : guard
-  };
-  if (!('check' in resolved)) {
-    // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
-    // inline guards expect `TExpressionGuard` to be set to `undefined`
-    // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
-    return resolved(guardArgs);
-  }
-  const builtinGuard = resolved;
-  return builtinGuard.check(state, guardArgs, resolved // this holds all params
-  );
-}
-
-function getOutput(configuration, context, event, self) {
-  const machine = configuration[0].machine;
-  const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, event, self) : undefined;
-}
-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 = [];
-
-  // add all ancestors
-  let m = stateNode.parent;
-  while (m && m !== toStateNode) {
-    ancestors.push(m);
-    m = m.parent;
-  }
-  return ancestors;
-}
-function getConfiguration(stateNodes) {
-  const configuration = new Set(stateNodes);
-  const configurationSet = new Set(stateNodes);
-  const adjList = getAdjList(configurationSet);
-
-  // add descendants
-  for (const s of configuration) {
-    // if previously active, add existing child nodes
-    if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodes(s).forEach(sn => configurationSet.add(sn));
-    } else {
-      if (s.type === 'parallel') {
-        for (const child of getChildren(s)) {
-          if (child.type === 'history') {
-            continue;
-          }
-          if (!configurationSet.has(child)) {
-            for (const initialStateNode of getInitialStateNodes(child)) {
-              configurationSet.add(initialStateNode);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // add all ancestors
-  for (const s of configurationSet) {
-    let m = s.parent;
-    while (m) {
-      configurationSet.add(m);
-      m = m.parent;
-    }
-  }
-  return configurationSet;
-}
-function getValueFromAdj(baseNode, adjList) {
-  const childStateNodes = adjList.get(baseNode);
-  if (!childStateNodes) {
-    return {}; // todo: fix?
-  }
-
-  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(configuration) {
-  const adjList = new Map();
-  for (const s of configuration) {
-    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, configuration) {
-  const config = getConfiguration(configuration);
-  return getValueFromAdj(rootNode, getAdjList(config));
-}
-function isInFinalState(configuration, stateNode = configuration[0].machine.root) {
-  if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.includes(s));
-  }
-  if (stateNode.type === 'parallel') {
-    return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
-  }
-  return false;
-}
-const isStateId = str => str[0] === STATE_IDENTIFIER;
-function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(descriptor => {
-    // check if transition is a wildcard transition,
-    // which matches any non-transient events
-    if (descriptor === WILDCARD) {
-      return true;
-    }
-    if (!descriptor.endsWith('.*')) {
-      return false;
-    }
-    const partialEventTokens = descriptor.split('.');
-    const eventTokens = receivedEventType.split('.');
-    for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
-      const partialEventToken = partialEventTokens[tokenIndex];
-      const eventToken = eventTokens[tokenIndex];
-      if (partialEventToken === '*') {
-        const isLastToken = tokenIndex === partialEventTokens.length - 1;
-        return isLastToken;
-      }
-      if (partialEventToken !== eventToken) {
-        return false;
-      }
-    }
-    return true;
-  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
-  return candidates;
-}
-
-/**
- * All delayed transitions from the config.
- */
-function getDelayedTransitions(stateNode) {
-  const afterConfig = stateNode.config.after;
-  if (!afterConfig) {
-    return [];
-  }
-  const mutateEntryExit = (delay, i) => {
-    const delayRef = typeof delay === 'function' ? `${stateNode.id}:delay[${i}]` : delay;
-    const eventType = after(delayRef, stateNode.id);
-    stateNode.entry.push(raise({
-      type: eventType
-    }, {
-      id: eventType,
-      delay
-    }));
-    stateNode.exit.push(cancel(eventType));
-    return eventType;
-  };
-  const delayedTransitions = isArray(afterConfig) ? afterConfig.map((transition, i) => {
-    const eventType = mutateEntryExit(transition.delay, i);
-    return {
-      ...transition,
-      event: eventType
-    };
-  }) : Object.keys(afterConfig).flatMap((delay, i) => {
-    const configTransition = afterConfig[delay];
-    const resolvedTransition = typeof configTransition === 'string' ? {
-      target: configTransition
-    } : configTransition;
-    const resolvedDelay = !isNaN(+delay) ? +delay : delay;
-    const eventType = mutateEntryExit(resolvedDelay, i);
-    return toArray(resolvedTransition).map(transition => ({
-      ...transition,
-      event: eventType,
-      delay: resolvedDelay
-    }));
-  });
-  return delayedTransitions.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}`) : undefined
-    })
-  };
-  return transition;
-}
-function formatTransitions(stateNode) {
-  const transitions = 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 = String(done(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 = `done.invoke.${invokeDef.id}`;
-      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
-    }
-    if (invokeDef.onError) {
-      const descriptor = `error.platform.${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) {
-  if (typeof _target === 'string' || isArray(_target)) {
-    const targets = toArray(_target).map(t => {
-      // Resolve state string keys (which represent children)
-      // to their state node
-      const descStateNode = typeof t === 'string' ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
-      if (!descStateNode) {
-        throw new Error(`Initial state node "${t}" not found on parent state node #${stateNode.id}`);
-      }
-      if (!isDescendant(descStateNode, stateNode)) {
-        throw new Error(`Invalid initial target: state node #${descStateNode.id} is not a descendant of #${stateNode.id}`);
-      }
-      return descStateNode;
-    });
-    const resolvedTarget = resolveTarget(stateNode, targets);
-    const transition = {
-      source: stateNode,
-      actions: [],
-      eventType: null,
-      reenter: false,
-      target: resolvedTarget,
-      toJSON: () => ({
-        ...transition,
-        source: `#${stateNode.id}`,
-        target: resolvedTarget ? resolvedTarget.map(t => `#${t.id}`) : undefined
-      })
-    };
-    return transition;
-  }
-  return formatTransition(stateNode, '__INITIAL__', {
-    target: toArray(_target.target).map(t => {
-      if (typeof t === 'string') {
-        return isStateId(t) ? t : `${STATE_DELIMITER}${t}`;
-      }
-      return t;
-    }),
-    actions: _target.actions
-  });
-}
-function resolveTarget(stateNode, targets) {
-  if (targets === undefined) {
-    // an undefined target signals that the state node should not transition from that state when receiving that event
-    return undefined;
-  }
-  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 internal target is defined on machine,
-    // do not include machine key on target
-    if (isInternalTarget && !stateNode.parent) {
-      return getStateNodeByPath(stateNode, target.slice(1));
-    }
-    const resolvedTarget = isInternalTarget ? stateNode.key + target : target;
-    if (stateNode.parent) {
-      try {
-        const targetStateNode = getStateNodeByPath(stateNode.parent, resolvedTarget);
-        return targetStateNode;
-      } 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 resolveHistoryTarget(stateNode) {
-  const normalizedTarget = normalizeTarget(stateNode.target);
-  if (!normalizedTarget) {
-    return stateNode.parent.initial.target;
-  }
-  return normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t);
-}
-function isHistoryNode(stateNode) {
-  return stateNode.type === 'history';
-}
-function getInitialStateNodes(stateNode) {
-  const set = new Set();
-  function iter(descStateNode) {
-    if (set.has(descStateNode)) {
-      return;
-    }
-    set.add(descStateNode);
-    if (descStateNode.type === 'compound') {
-      for (const targetStateNode of descStateNode.initial.target) {
-        for (const a of getProperAncestors(targetStateNode, stateNode)) {
-          set.add(a);
-        }
-        iter(targetStateNode);
-      }
-    } 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 (e) {
-      // try individual paths
-      // throw e;
-    }
-  }
-  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 state The state value or State instance
- */
-function getStateNodes(stateNode, state) {
-  const stateValue = state instanceof State ? state.value : toStateValue(state);
-  if (typeof stateValue === 'string') {
-    return [stateNode, stateNode.states[stateValue]];
-  }
-  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, state, event) {
-  const childStateNode = getStateNode(stateNode, stateValue);
-  const next = childStateNode.next(state, event);
-  if (!next || !next.length) {
-    return stateNode.next(state, event);
-  }
-  return next;
-}
-function transitionCompoundNode(stateNode, stateValue, state, event) {
-  const subStateKeys = Object.keys(stateValue);
-  const childStateNode = getStateNode(stateNode, subStateKeys[0]);
-  const next = transitionNode(childStateNode, stateValue[subStateKeys[0]], state, event);
-  if (!next || !next.length) {
-    return stateNode.next(state, event);
-  }
-  return next;
-}
-function transitionParallelNode(stateNode, stateValue, state, event) {
-  const allInnerTransitions = [];
-  for (const subStateKey of Object.keys(stateValue)) {
-    const subStateValue = stateValue[subStateKey];
-    if (!subStateValue) {
-      continue;
-    }
-    const subStateNode = getStateNode(stateNode, subStateKey);
-    const innerTransitions = transitionNode(subStateNode, subStateValue, state, event);
-    if (innerTransitions) {
-      allInnerTransitions.push(...innerTransitions);
-    }
-  }
-  if (!allInnerTransitions.length) {
-    return stateNode.next(state, event);
-  }
-  return allInnerTransitions;
-}
-function transitionNode(stateNode, stateValue, state, event) {
-  // leaf node
-  if (typeof stateValue === 'string') {
-    return transitionAtomicNode(stateNode, stateValue, state, event);
-  }
-
-  // compound node
-  if (Object.keys(stateValue).length === 1) {
-    return transitionCompoundNode(stateNode, stateValue, state, event);
-  }
-
-  // parallel node
-  return transitionParallelNode(stateNode, stateValue, state, 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 getPathFromRootToNode(stateNode) {
-  const path = [];
-  let marker = stateNode.parent;
-  while (marker) {
-    path.unshift(marker);
-    marker = marker.parent;
-  }
-  return path;
-}
-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, configuration, historyValue) {
-  const filteredTransitions = new Set();
-  for (const t1 of enabledTransitions) {
-    let t1Preempted = false;
-    const transitionsToRemove = new Set();
-    for (const t2 of filteredTransitions) {
-      if (hasIntersection(computeExitSet([t1], configuration, historyValue), computeExitSet([t2], configuration, 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 findLCCA(stateNodes) {
-  const [head] = stateNodes;
-  let current = getPathFromRootToNode(head);
-  let candidates = [];
-  for (const stateNode of stateNodes) {
-    const path = getPathFromRootToNode(stateNode);
-    candidates = current.filter(sn => path.includes(sn));
-    current = candidates;
-    candidates = [];
-  }
-  return current[current.length - 1];
-}
-function getEffectiveTargetStates(transition, historyValue) {
-  if (!transition.target) {
-    return [];
-  }
-  const targets = 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({
-          target: resolveHistoryTarget(targetNode)
-        }, historyValue)) {
-          targets.add(node);
-        }
-      }
-    } else {
-      targets.add(targetNode);
-    }
-  }
-  return [...targets];
-}
-function getTransitionDomain(transition, historyValue) {
-  const targetStates = getEffectiveTargetStates(transition, historyValue);
-  if (!targetStates) {
-    return null;
-  }
-  if (!transition.reenter && transition.source.type !== 'parallel' && targetStates.every(targetStateNode => isDescendant(targetStateNode, transition.source))) {
-    return transition.source;
-  }
-  const lcca = findLCCA(targetStates.concat(transition.source));
-  return lcca;
-}
-function computeExitSet(transitions, configuration, historyValue) {
-  const statesToExit = new Set();
-  for (const t of transitions) {
-    if (t.target?.length) {
-      const domain = getTransitionDomain(t, historyValue);
-      for (const stateNode of configuration) {
-        if (isDescendant(stateNode, domain)) {
-          statesToExit.add(stateNode);
-        }
-      }
-    }
-  }
-  return [...statesToExit];
-}
-
-/**
- * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
- */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
-  if (!transitions.length) {
-    return currentState;
-  }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const actions = [];
-  const historyValue = {
-    ...currentState.historyValue
-  };
-  const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
-  const internalQueue = [...currentState._internalQueue];
-
-  // Exit states
-  if (!isInitial) {
-    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
-  }
-
-  // Execute transition content
-  actions.push(...filteredTransitions.flatMap(t => t.actions));
-
-  // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
-  const nextConfiguration = [...mutConfiguration];
-  const done = isInFinalState(nextConfiguration);
-  if (done) {
-    const finalActions = nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit);
-    actions.push(...finalActions);
-  }
-  try {
-    const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
-    const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
-    internalQueue.push(...nextState._internalQueue);
-    return cloneState(currentState, {
-      configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue,
-      context: nextState.context,
-      done,
-      output,
-      children: nextState.children
-    });
-  } catch (e) {
-    // TODO: Refactor this once proper error handling is implemented.
-    // See https://github.com/statelyai/rfcs/pull/4
-    throw e;
-  }
-}
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
-  const statesToEnter = new Set();
-  const statesForDefaultEntry = new Set();
-  computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
-
-  // In the initial state, the root state node is "entered".
-  if (isInitial) {
-    statesForDefaultEntry.add(currentState.machine.root);
-  }
-  for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
-    mutConfiguration.add(stateNodeToEnter);
-    for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
-    }
-
-    // Add entry actions
-    actions.push(...stateNodeToEnter.entry);
-    if (statesForDefaultEntry.has(stateNodeToEnter)) {
-      for (const stateNode of statesForDefaultEntry) {
-        const initialActions = stateNode.initial.actions;
-        actions.push(...initialActions);
-      }
-    }
-    if (stateNodeToEnter.type === 'final') {
-      const parent = stateNodeToEnter.parent;
-      if (!parent.parent) {
-        continue;
-      }
-      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
-      if (parent.parent) {
-        const grandparent = parent.parent;
-        if (grandparent.type === 'parallel') {
-          if (getChildren(grandparent).every(parentNode => isInFinalState([...mutConfiguration], parentNode))) {
-            internalQueue.push(done(grandparent.id));
-          }
-        }
-      }
-    }
-  }
-}
-function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
-  for (const t of transitions) {
-    for (const s of t.target || []) {
-      addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
-    }
-    const ancestor = getTransitionDomain(t, historyValue);
-    const targetStates = getEffectiveTargetStates(t, historyValue);
-    for (const s of targetStates) {
-      addAncestorStatesToEnter(s, ancestor, statesToEnter, historyValue, statesForDefaultEntry);
-    }
-  }
-}
-function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEntry, statesToEnter) {
-  if (isHistoryNode(stateNode)) {
-    if (historyValue[stateNode.id]) {
-      const historyStateNodes = historyValue[stateNode.id];
-      for (const s of historyStateNodes) {
-        addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const s of historyStateNodes) {
-        addAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
-      }
-    } else {
-      const targets = resolveHistoryTarget(stateNode);
-      for (const s of targets) {
-        addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const s of targets) {
-        addAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
-      }
-    }
-  } else {
-    statesToEnter.add(stateNode);
-    if (stateNode.type === 'compound') {
-      statesForDefaultEntry.add(stateNode);
-      const initialStates = stateNode.initial.target;
-      for (const initialState of initialStates) {
-        addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const initialState of initialStates) {
-        addAncestorStatesToEnter(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))) {
-            addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
-          }
-        }
-      }
-    }
-  }
-}
-function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
-  const properAncestors = getProperAncestors(stateNode, toStateNode);
-  for (const anc of properAncestors) {
-    statesToEnter.add(anc);
-    if (anc.type === 'parallel') {
-      for (const child of getChildren(anc).filter(sn => !isHistoryNode(sn))) {
-        if (![...statesToEnter].some(s => isDescendant(s, child))) {
-          addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
-        }
-      }
-    }
-  }
-}
-function exitStates(transitions, mutConfiguration, historyValue, actions) {
-  const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
-  statesToExit.sort((a, b) => b.order - a.order);
-
-  // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
-  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;
-        };
-      }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
-    }
-  }
-  for (const s of statesToExit) {
-    actions.push(...s.exit, ...s.invoke.map(def => stop(def.id)));
-    mutConfiguration.delete(s);
-  }
-}
-function resolveActionsAndContext(actions, event, currentState, actorCtx) {
-  const {
-    machine
-  } = currentState;
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let intermediateState = cloneState(currentState, {
-    _internalQueue: []
-  });
-  for (const action of actions) {
-    const isInline = typeof action === 'function';
-    const resolved = isInline ? action :
-    // the existing type of `.actions` assumes non-nullable `TExpressionAction`
-    // it's fine to cast this here to get a common type and lack of errors in the rest of the code
-    // our logic below makes sure that we call those 2 "variants" correctly
-    machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolved) {
-      continue;
-    }
-    const actionArgs = {
-      context: intermediateState.context,
-      event,
-      self: actorCtx?.self,
-      system: actorCtx?.system,
-      action: isInline ? undefined : typeof action === 'string' ? {
-        type: action
-      } : action
-    };
-    if (!('resolve' in resolved)) {
-      if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(actionArgs);
-      } else {
-        actorCtx?.defer(() => resolved(actionArgs));
-      }
-      continue;
-    }
-    const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
-    );
-
-    intermediateState = nextState;
-    if ('execute' in resolved) {
-      if (actorCtx?.self.status === ActorStatus.Running) {
-        builtinAction.execute(actorCtx, params);
-      } else {
-        actorCtx?.defer(builtinAction.execute.bind(null, actorCtx, params));
-      }
-    }
-    if (actions) {
-      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
-    }
-  }
-  return intermediateState;
-}
-function macrostep(state, event, actorCtx) {
-  let nextState = state;
-  const states = [];
-
-  // Handle stop event
-  if (event.type === stopSignalType) {
-    nextState = stopStep(event, nextState, actorCtx);
-    states.push(nextState);
-    return {
-      state: nextState,
-      microstates: states
-    };
-  }
-  let nextEvent = event;
-
-  // Assume the state is at rest (no raised events)
-  // Determine the next state based on the next microstep
-  if (nextEvent.type !== INIT_TYPE) {
-    const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
-    states.push(nextState);
-  }
-  while (!nextState.done) {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
-    if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
-        break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
-      }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
-    }
-  }
-  if (nextState.done) {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
-  }
-  return {
-    state: nextState,
-    microstates: states
-  };
-}
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(actions, event, nextState, actorCtx);
-}
-function selectTransitions(event, nextState) {
-  return nextState.machine.getTransitionData(nextState, event);
-}
-function selectEventlessTransitions(nextState, event) {
-  const enabledTransitionSet = new Set();
-  const atomicStates = nextState.configuration.filter(isAtomicStateNode);
-  for (const stateNode of atomicStates) {
-    loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, null))) {
-      if (!s.always) {
-        continue;
-      }
-      for (const transition of s.always) {
-        if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, event, nextState)) {
-          enabledTransitionSet.add(transition);
-          break loop;
-        }
-      }
-    }
-  }
-  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState.configuration), 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) {
-  const configuration = getConfiguration(getStateNodes(rootNode, stateValue));
-  return getStateValue(rootNode, [...configuration]);
-}
-function getInitialConfiguration(rootNode) {
-  const configuration = [];
-  const initialTransition = rootNode.initial;
-  const statesToEnter = new Set();
-  const statesForDefaultEntry = new Set([rootNode]);
-  computeEntrySet([initialTransition], {}, statesForDefaultEntry, statesToEnter);
-  for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
-    configuration.push(stateNodeToEnter);
-  }
-  return configuration;
-}
-
-class State {
-  /**
-   * Indicates whether the state is a final state.
-   */
-
-  /**
-   * The output data of the top-level finite state.
-   */
-
-  /**
-   * The enabled state nodes representative of the state value.
-   */
-
-  /**
-   * An object mapping actor names to spawned/invoked actors.
-   */
-
-  /**
-   * Creates a new State instance for the given `stateValue` and `context`.
-   * @param stateValue
-   * @param context
-   */
-  static from(stateValue, context = {}, machine) {
-    if (stateValue instanceof State) {
-      if (stateValue.context !== context) {
-        return new State({
-          value: stateValue.value,
-          context,
-          meta: {},
-          configuration: [],
-          // TODO: fix,
-          children: {}
-        }, machine);
-      }
-      return stateValue;
-    }
-    const configuration = getConfiguration(getStateNodes(machine.root, stateValue));
-    return new State({
-      value: stateValue,
-      context,
-      meta: undefined,
-      configuration: Array.from(configuration),
-      children: {}
-    }, machine);
-  }
-
-  /**
-   * Creates a new `State` instance that represents the current state of a running machine.
-   *
-   * @param config
-   */
-  constructor(config, machine) {
-    this.machine = machine;
-    this.tags = void 0;
-    this.value = void 0;
-    this.done = void 0;
-    this.output = void 0;
-    this.error = void 0;
-    this.context = void 0;
-    this.historyValue = {};
-    this._internalQueue = void 0;
-    this.configuration = void 0;
-    this.children = void 0;
-    this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
-    this.historyValue = config.historyValue || {};
-    this.matches = this.matches.bind(this);
-    this.toStrings = this.toStrings.bind(this);
-    this.configuration = config.configuration ?? Array.from(getConfiguration(getStateNodes(machine.root, config.value)));
-    this.children = config.children;
-    this.value = getStateValue(machine.root, this.configuration);
-    this.tags = new Set(flatten(this.configuration.map(sn => sn.tags)));
-    this.done = config.done ?? false;
-    this.output = config.output;
-    this.error = config.error;
-  }
-
-  /**
-   * Returns an array of all the string leaf state node paths.
-   * @param stateValue
-   * @param delimiter The character(s) that separate each subpath in the string state node path.
-   */
-  toStrings(stateValue = this.value) {
-    if (typeof stateValue === 'string') {
-      return [stateValue];
-    }
-    const valueKeys = Object.keys(stateValue);
-    return valueKeys.concat(...valueKeys.map(key => this.toStrings(stateValue[key]).map(s => key + STATE_DELIMITER + s)));
-  }
-  toJSON() {
-    const {
-      configuration,
-      tags,
-      machine,
-      ...jsonValues
-    } = this;
-    return {
-      ...jsonValues,
-      tags: Array.from(tags),
-      meta: this.meta
-    };
-  }
-
-  /**
-   * Whether the current state value is a subset of the given parent state value.
-   * @param parentStateValue
-   */
-  matches(parentStateValue) {
-    return matchesState(parentStateValue, this.value);
-  }
-
-  /**
-   * Whether the current state configuration has a state node with the specified `tag`.
-   * @param tag
-   */
-  hasTag(tag) {
-    return this.tags.has(tag);
-  }
-
-  /**
-   * Determines whether sending the `event` will cause a non-forbidden transition
-   * to be selected, even if the transitions have no actions nor
-   * change the state value.
-   *
-   * @param event The event to test
-   * @returns Whether the event will cause a transition
-   */
-  can(event) {
-    const transitionData = this.machine.getTransitionData(this, event);
-    return !!transitionData?.length &&
-    // Check that at least one transition is not forbidden
-    transitionData.some(t => t.target !== undefined || t.actions.length);
-  }
-
-  /**
-   * The next events that will cause a transition from the current state.
-   */
-  get nextEvents() {
-    return memo(this, 'nextEvents', () => {
-      return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-    });
-  }
-  get meta() {
-    return this.configuration.reduce((acc, stateNode) => {
-      if (stateNode.meta !== undefined) {
-        acc[stateNode.id] = stateNode.meta;
-      }
-      return acc;
-    }, {});
-  }
-}
-function cloneState(state, config = {}) {
-  return new State({
-    ...state,
-    ...config
-  }, state.machine);
-}
-function getPersistedState(state) {
-  const {
-    configuration,
-    tags,
-    machine,
-    children,
-    ...jsonValues
-  } = state;
-  const childrenJson = {};
-  for (const id in children) {
-    childrenJson[id] = {
-      state: children[id].getPersistedState?.(),
-      src: children[id].src
-    };
-  }
-  return {
-    ...jsonValues,
-    children: childrenJson
-  };
-}
-
-function resolve$5(_, state, args, {
-  actorRef
-}) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args) : actorRef;
-  const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
-  let children = state.children;
-  if (resolvedActorRef) {
-    children = {
-      ...children
-    };
-    delete children[resolvedActorRef.id];
-  }
-  return [cloneState(state, {
-    children
-  }), resolvedActorRef];
-}
-function execute$2(actorContext, actorRef) {
-  if (!actorRef) {
-    return;
-  }
-  if (actorRef.status !== ActorStatus.Running) {
-    actorContext.stopChild(actorRef);
-    return;
-  }
-  // TODO: recheck why this one has to be deferred
-  actorContext.defer(() => {
-    actorContext.stopChild(actorRef);
-  });
-}
-
-/**
- * Stops an actor.
- *
- * @param actorRef The actor to stop.
- */
-
-function stop(actorRef) {
-  function stop(_) {
-  }
-  stop.type = 'xstate.stop';
-  stop.actorRef = actorRef;
-  stop.resolve = resolve$5;
-  stop.execute = execute$2;
-  return stop;
-}
-
-function resolve$4(_, state, actionArgs, {
-  value,
-  label
-}) {
-  return [state, {
-    value: typeof value === 'function' ? value(actionArgs) : value,
-    label
-  }];
-}
-function execute$1({
-  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(_) {
-  }
-  log.type = 'xstate.log';
-  log.value = value;
-  log.label = label;
-  log.resolve = resolve$4;
-  log.execute = execute$1;
-  return log;
-}
-
-function createSpawner(actorContext, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options = {}) => {
-    const {
-      systemId
-    } = options;
-    if (typeof src === 'string') {
-      const referenced = resolveReferencedActor(machine.implementations.actors[src]);
-      if (!referenced) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const input = 'input' in options ? options.input : referenced.input;
-
-      // TODO: this should also receive `src`
-      const actor = createActor(referenced.src, {
-        id: options.id,
-        parent: actorContext.self,
-        input: typeof input === 'function' ? input({
-          context,
-          event,
-          self: actorContext.self
-        }) : input,
-        systemId
-      });
-      spawnedChildren[actor.id] = actor;
-      return actor;
-    } else {
-      // TODO: this should also receive `src`
-      return createActor(src, {
-        id: options.id,
-        parent: actorContext.self,
-        input: options.input,
-        systemId
-      });
-    }
-  };
-  return (src, options) => {
-    const actorRef = spawn(src, options); // TODO: fix types
-    spawnedChildren[actorRef.id] = actorRef;
-    actorContext.defer(() => {
-      if (actorRef.status === ActorStatus.Stopped) {
-        return;
-      }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorContext.self.send(error(actorRef.id, err));
-        return;
-      }
-    });
-    return actorRef;
-  };
-}
-
-function resolve$3(actorContext, state, actionArgs, {
-  assignment
-}) {
-  if (!state.context) {
-    throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-  }
-  const spawnedChildren = {};
-  const assignArgs = {
-    context: state.context,
-    event: actionArgs.event,
-    action: actionArgs.action,
-    spawn: createSpawner(actorContext, state, actionArgs.event, spawnedChildren),
-    self: actorContext?.self,
-    system: actorContext?.system
-  };
-  let partialUpdate = {};
-  if (typeof assignment === 'function') {
-    partialUpdate = assignment(assignArgs);
-  } else {
-    for (const key of Object.keys(assignment)) {
-      const propAssignment = assignment[key];
-      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs) : propAssignment;
-    }
-  }
-  const updatedContext = Object.assign({}, state.context, partialUpdate);
-  return [cloneState(state, {
-    context: updatedContext,
-    children: Object.keys(spawnedChildren).length ? {
-      ...state.children,
-      ...spawnedChildren
-    } : state.children
-  })];
-}
-
-/**
- * Updates the current context of the machine.
- *
- * @param assignment An object that represents the partial context to update.
- */
-function assign(assignment) {
-  function assign(_) {
-  }
-  assign.type = 'xstate.assign';
-  assign.assignment = assignment;
-  assign.resolve = resolve$3;
-  return assign;
-}
-
-function resolve$2(_, state, args, {
-  event: eventOrExpr,
-  id,
-  delay
-}) {
-  const delaysMap = state.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) : eventOrExpr;
-  let resolvedDelay;
-  if (typeof delay === 'string') {
-    const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
-  } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
-  }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
-    event: resolvedEvent,
-    id,
-    delay: resolvedDelay
-  }];
-}
-function execute(actorContext, params) {
-  if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
-    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(_) {
-  }
-  raise.type = 'xstate.raise';
-  raise.event = eventOrExpr;
-  raise.id = options?.id;
-  raise.delay = options?.delay;
-  raise.resolve = resolve$2;
-  raise.execute = execute;
-  return raise;
-}
-
-function resolve$1(_, state, actionArgs, {
-  branches
-}) {
-  const matchedActions = branches.find(condition => {
-    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
-  })?.actions;
-  return [state, undefined, toArray(matchedActions)];
-}
-function choose(branches) {
-  function choose(_) {
-  }
-  choose.type = 'xstate.choose';
-  choose.branches = branches;
-  choose.resolve = resolve$1;
-  return choose;
-}
-
-function resolve(_, state, args, {
-  get
-}) {
-  return [state, undefined, toArray(get({
-    context: args.context,
-    event: args.event
-  }))];
-}
-function pure(getActions) {
-  function pure(_) {
-  }
-  pure.type = 'xstate.pure';
-  pure.get = getActions;
-  pure.resolve = resolve;
-  return pure;
-}
-
-/**
- * Returns an event type 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 after(delayRef, id) {
-  const idSuffix = id ? `#${id}` : '';
-  return `${ConstantPrefix.After}(${delayRef})${idSuffix}`;
-}
-
-/**
- * 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 done(id, output) {
-  const type = `${ConstantPrefix.DoneState}.${id}`;
-  const eventObject = {
-    type,
-    output
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-
-/**
- * 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 doneInvoke(invokeId, output) {
-  const type = `${ConstantPrefix.DoneInvoke}.${invokeId}`;
-  const eventObject = {
-    type,
-    output
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-function error(id, data) {
-  const type = `${ConstantPrefix.ErrorPlatform}.${id}`;
-  const eventObject = {
-    type,
-    data
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-function createInitEvent(input) {
-  return {
-    type: INIT_TYPE,
-    input
-  };
-}
-
-export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, constantPrefixes as ah, after as ai, done as aj, error as ak, escalate as al, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };