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

package/dist/raise-a60c9290.development.esm.js

@@ -0,0 +1,1468 @@
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, l as createErrorActorEvent, o as toStateValue, q as STATE_IDENTIFIER, u as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, v as toStatePath, w as createDoneStateEvent, x as mapContext, W as WILDCARD, n as XSTATE_STOP, X as XSTATE_INIT, y as isArray, z as createAfterEvent, B as flatten, e as matchesState } from './interpreter-a77bb0ec.development.esm.js';
+
+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$3(_, state, actionArgs, {
+  sendId
+}) {
+  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
+  return [state, resolvedSendId];
+}
+function execute$3(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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  cancel.type = 'xstate.cancel';
+  cancel.sendId = sendId;
+  cancel.resolve = resolve$3;
+  cancel.execute = execute$3;
+  return cancel;
+}
+
+function resolve$2(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
+    });
+  }
+  if (!actorRef) {
+    console.warn(`Actor type '${src}' not found in machine '${actorContext.id}'.`);
+  }
+  return [cloneState(state, {
+    children: {
+      ...state.children,
+      [id]: actorRef
+    }
+  }), {
+    id,
+    actorRef
+  }];
+}
+function execute$2(actorContext, {
+  id,
+  actorRef
+}) {
+  if (!actorRef) {
+    return;
+  }
+  actorContext.defer(() => {
+    if (actorRef.status === ActorStatus.Stopped) {
+      return;
+    }
+    try {
+      actorRef.start?.();
+    } catch (err) {
+      actorContext.self.send(createErrorActorEvent(id, err));
+      return;
+    }
+  });
+}
+
+// we don't export this since it's an internal action that is not meant to be used in the user's code
+
+function invoke({
+  id,
+  systemId,
+  src,
+  input
+}) {
+  function invoke(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  invoke.type = 'xstate.invoke';
+  invoke.id = id;
+  invoke.systemId = systemId;
+  invoke.src = src;
+  invoke.input = input;
+  invoke.resolve = resolve$2;
+  invoke.execute = execute$2;
+  return invoke;
+}
+
+function resolve$1(_, 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$1(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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  stop.type = 'xstate.stop';
+  stop.actorRef = actorRef;
+  stop.resolve = resolve$1;
+  stop.execute = execute$1;
+  return stop;
+}
+
+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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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
+    } : typeof guard.params === 'function' ? {
+      type: guard.type,
+      params: guard.params({
+        context,
+        event
+      })
+    } : 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;
+    }
+    if (/.*\*.+/.test(descriptor)) {
+      console.warn(`Wildcards can only be the last token of an event descriptor (e.g., "event.*") or the entire event descriptor ("*"). Check the "${descriptor}" event.`);
+    }
+    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;
+        if (!isLastToken) {
+          console.warn(`Infix wildcards in transition events are not allowed. Check the "${descriptor}" transition.`);
+        }
+        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 afterEvent = createAfterEvent(delayRef, stateNode.id);
+    const eventType = afterEvent.type;
+    stateNode.entry.push(raise(afterEvent, {
+      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);
+
+  // TODO: should this be part of a lint rule instead?
+  if (transitionConfig.cond) {
+    throw new Error(`State "${stateNode.id}" has declared \`cond\` for one of its transitions. This property has been renamed to \`guard\`. Please update your code.`);
+  }
+  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 = `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) {
+  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.config.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(createDoneStateEvent(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(createDoneStateEvent(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
+      } : typeof action.params === 'function' ? {
+        type: action.type,
+        params: action.params({
+          context: intermediateState.context,
+          event
+        })
+      } :
+      // TS isn't able to narrow it down here
+      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) {
+  if (event.type === WILDCARD) {
+    throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
+  }
+  let nextState = state;
+  const states = [];
+
+  // Handle stop event
+  if (event.type === XSTATE_STOP) {
+    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 !== XSTATE_INIT) {
+    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) {
+    if (!this.machine) {
+      console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
+    }
+    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(_, 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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  raise.type = 'xstate.raise';
+  raise.event = eventOrExpr;
+  raise.id = options?.id;
+  raise.delay = options?.delay;
+  raise.resolve = resolve;
+  raise.execute = execute;
+  return raise;
+}
+
+export { raise as A, stop as B, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, isAtomicStateNode as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };