xstate 5.0.0-beta.9 → 5.0.1

package/dist/xstate.esm.js

@@ -1,431 +1,395 @@
-import { _ as _createClass, f as formatTransitions, t as toTransitionConfigArray, N as NULL_EVENT, a as formatTransition, m as mapValues, b as memo, c as _createForOfIteratorHelper, e as evaluateGuard, d as _toConsumableArray, g as flatten, h as _classCallCheck, i as _defineProperty, j as toActionObjects, k as toArray, l as createInvokeId, n as toInvokeConfig, o as _objectSpread2, p as invoke, q as _objectWithoutProperties, r as getDelayedTransitions, s as formatInitialTransition, u as getCandidates, v as isString, w as createSpawner, x as createInitEvent, y as getConfiguration, z as getStateNodes, A as resolveStateValue, B as isInFinalState, S as State, C as toSCXMLEvent, D as isSCXMLErrorEvent, E as macrostep, F as transitionNode, G as _slicedToArray, H as getInitialConfiguration, I as resolveActionsAndContext, J as microstep, K as error, L as isStateId, M as getStateNodeByPath, O as getPersistedState, P as resolveReferencedActor, Q as interpret, R as STATE_DELIMITER, T as initEvent, U as matchesState } from './actions-de434a04.esm.js';
-export { ai as ActionTypes, Y as Interpreter, Z as InterpreterStatus, aj as SpecialTargets, S as State, ag as and, a0 as assign, a1 as cancel, a2 as choose, $ as doneInvoke, X as forwardTo, ab as fromCallback, ac as fromEventObservable, aa as fromObservable, a9 as fromPromise, ad as fromTransition, z as getStateNodes, Q as interpret, a3 as log, U as matchesState, af as not, ah as or, a7 as pathToStateValue, a4 as pure, a5 as raise, W as sendParent, V as sendTo, ae as stateIn, a6 as stop, a8 as toObserver, C as toSCXMLEvent } from './actions-de434a04.esm.js';
-import './index-50bd0aff.esm.js';
-
-var _excluded = ["onDone", "onError"];
-var EMPTY_OBJECT = {};
-var StateNode = /*#__PURE__*/function () {
-  /**
-   * The relative key of the state node, which represents its location in the overall state value.
-   */
-
-  /**
-   * The unique ID of the state node.
-   */
-
-  /**
-   * The type of this state node:
-   *
-   *  - `'atomic'` - no child state nodes
-   *  - `'compound'` - nested child state nodes (XOR)
-   *  - `'parallel'` - orthogonal nested child state nodes (AND)
-   *  - `'history'` - history state node
-   *  - `'final'` - final state node
-   */
-
-  /**
-   * The string path from the root machine node to this node.
-   */
-
-  /**
-   * The child state nodes.
-   */
-
-  /**
-   * The type of history on this state node. Can be:
-   *
-   *  - `'shallow'` - recalls only top-level historical state value
-   *  - `'deep'` - recalls historical state value at all levels
-   */
-
-  /**
-   * The action(s) to be executed upon entering the state node.
-   */
-
-  /**
-   * The action(s) to be executed upon exiting the state node.
-   */
-
-  /**
-   * The parent state node.
-   */
-
-  /**
-   * The root machine node.
-   */
-
-  /**
-   * The meta data associated with this state node, which will be returned in State instances.
-   */
-
-  /**
-   * The output data sent with the "done.state._id_" event if this is a final state node.
-   */
+export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as isStateId, w as getStateNodeByPath, x as getPersistedSnapshot, y as resolveReferencedActor, z as createActor, $ as $$ACTOR_TYPE } from './raise-8bc422d1.esm.js';
+export { A as Actor, G as __unsafe_getAllOwnEventDescriptors, H as and, L as cancel, z as createActor, j as getStateNodes, B as interpret, C as isMachineSnapshot, D as matchesState, I as not, J as or, E as pathToStateValue, M as raise, O as spawnChild, K as stateIn, P as stop, Q as stopChild, F as toObserver } from './raise-8bc422d1.esm.js';
+import { a as assign } from './log-22e678c5.esm.js';
+export { S as SpecialTargets, a as assign, e as enqueueActions, f as forwardTo, l as log, s as sendParent, b as sendTo } from './log-22e678c5.esm.js';
+import '../dev/dist/xstate-dev.esm.js';
+
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(([id, timeout]) => {
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    });
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
 
-  /**
-   * The order this state node appears. Corresponds to the implicit SCXML document order.
-   */
+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 StateNode(
+const EMPTY_OBJECT = {};
+const toSerializableAction = action => {
+  if (typeof action === 'string') {
+    return {
+      type: action
+    };
+  }
+  if (typeof action === 'function') {
+    if ('resolve' in action) {
+      return {
+        type: action.type
+      };
+    }
+    return {
+      type: action.name
+    };
+  }
+  return action;
+};
+class StateNode {
+  constructor(
   /**
    * The raw config used to create the machine.
    */
   config, options) {
-    var _this = this;
-    _classCallCheck(this, StateNode);
     this.config = config;
-    _defineProperty(this, "key", void 0);
-    _defineProperty(this, "id", void 0);
-    _defineProperty(this, "type", void 0);
-    _defineProperty(this, "path", void 0);
-    _defineProperty(this, "states", void 0);
-    _defineProperty(this, "history", void 0);
-    _defineProperty(this, "entry", void 0);
-    _defineProperty(this, "exit", void 0);
-    _defineProperty(this, "parent", void 0);
-    _defineProperty(this, "machine", void 0);
-    _defineProperty(this, "meta", void 0);
-    _defineProperty(this, "output", void 0);
-    _defineProperty(this, "order", -1);
-    _defineProperty(this, "description", void 0);
-    _defineProperty(this, "tags", []);
-    _defineProperty(this, "transitions", void 0);
-    _defineProperty(this, "always", void 0);
+    /**
+     * The relative key of the state node, which represents its location in the overall state value.
+     */
+    this.key = void 0;
+    /**
+     * The unique ID of the state node.
+     */
+    this.id = void 0;
+    /**
+     * The type of this state node:
+     *
+     *  - `'atomic'` - no child state nodes
+     *  - `'compound'` - nested child state nodes (XOR)
+     *  - `'parallel'` - orthogonal nested child state nodes (AND)
+     *  - `'history'` - history state node
+     *  - `'final'` - final state node
+     */
+    this.type = void 0;
+    /**
+     * The string path from the root machine node to this node.
+     */
+    this.path = void 0;
+    /**
+     * The child state nodes.
+     */
+    this.states = void 0;
+    /**
+     * The type of history on this state node. Can be:
+     *
+     *  - `'shallow'` - recalls only top-level historical state value
+     *  - `'deep'` - recalls historical state value at all levels
+     */
+    this.history = void 0;
+    /**
+     * The action(s) to be executed upon entering the state node.
+     */
+    this.entry = void 0;
+    /**
+     * The action(s) to be executed upon exiting the state node.
+     */
+    this.exit = void 0;
+    /**
+     * The parent state node.
+     */
+    this.parent = void 0;
+    /**
+     * The root machine node.
+     */
+    this.machine = void 0;
+    /**
+     * The meta data associated with this state node, which will be returned in State instances.
+     */
+    this.meta = void 0;
+    /**
+     * The output data sent with the "xstate.done.state._id_" event if this is a final state node.
+     */
+    this.output = void 0;
+    /**
+     * The order this state node appears. Corresponds to the implicit document order.
+     */
+    this.order = -1;
+    this.description = void 0;
+    this.tags = [];
+    this.transitions = void 0;
+    this.always = void 0;
     this.parent = options._parent;
     this.key = options._key;
     this.machine = options._machine;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
-    this.id = this.config.id || [this.machine.id].concat(_toConsumableArray(this.path)).join(this.machine.delimiter);
+    this.id = this.config.id || [this.machine.id, ...this.path].join(STATE_DELIMITER);
     this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
-    this.states = this.config.states ? mapValues(this.config.states, function (stateConfig, key) {
-      var stateNode = new StateNode(stateConfig, {
-        _parent: _this,
+    this.states = this.config.states ? mapValues(this.config.states, (stateConfig, key) => {
+      const stateNode = new StateNode(stateConfig, {
+        _parent: this,
         _key: key,
-        _machine: _this.machine
+        _machine: this.machine
       });
       return stateNode;
     }) : EMPTY_OBJECT;
     if (this.type === 'compound' && !this.config.initial) {
-      throw new Error("No initial state specified for compound state node \"#".concat(this.id, "\". Try adding { initial: \"").concat(Object.keys(this.states)[0], "\" } to the state config."));
+      throw new Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
     }
 
     // History config
     this.history = this.config.history === true ? 'shallow' : this.config.history || false;
-    this.entry = toActionObjects(this.config.entry);
-    this.exit = toActionObjects(this.config.exit);
+    this.entry = toArray(this.config.entry).slice();
+    this.exit = toArray(this.config.exit).slice();
     this.meta = this.config.meta;
-    this.output = this.type === 'final' ? this.config.output : undefined;
-    this.tags = toArray(config.tags);
-  }
-  _createClass(StateNode, [{
-    key: "_initialize",
-    value: function _initialize() {
-      var _this2 = this;
-      this.transitions = formatTransitions(this);
-      if (this.config.always) {
-        this.always = toTransitionConfigArray(NULL_EVENT, this.config.always).map(function (t) {
-          return formatTransition(_this2, t);
-        });
-      }
-      Object.keys(this.states).forEach(function (key) {
-        _this2.states[key]._initialize();
-      });
+    this.output = this.type === 'final' || !this.parent ? this.config.output : undefined;
+    this.tags = toArray(config.tags).slice();
+  }
+  _initialize() {
+    this.transitions = formatTransitions(this);
+    if (this.config.always) {
+      this.always = toTransitionConfigArray(this.config.always).map(t => formatTransition(this, NULL_EVENT, t));
     }
+    Object.keys(this.states).forEach(key => {
+      this.states[key]._initialize();
+    });
+  }
 
-    /**
-     * The well-structured state node definition.
-     */
-  }, {
-    key: "definition",
-    get: function get() {
-      var _this3 = this;
-      return {
-        id: this.id,
-        key: this.key,
-        version: this.machine.version,
-        type: this.type,
-        initial: this.initial ? {
-          target: this.initial.target,
-          source: this,
-          actions: this.initial.actions,
-          eventType: null,
-          reenter: false,
-          toJSON: function toJSON() {
-            return {
-              target: _this3.initial.target.map(function (t) {
-                return "#".concat(t.id);
-              }),
-              source: "#".concat(_this3.id),
-              actions: _this3.initial.actions,
-              eventType: null
-            };
-          }
-        } : undefined,
-        history: this.history,
-        states: mapValues(this.states, function (state) {
-          return state.definition;
-        }),
-        on: this.on,
-        transitions: this.transitions,
-        entry: this.entry,
-        exit: this.exit,
-        meta: this.meta,
-        order: this.order || -1,
-        output: this.output,
-        invoke: this.invoke,
-        description: this.description,
-        tags: this.tags
-      };
-    }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return this.definition;
-    }
+  /**
+   * The well-structured state node definition.
+   */
+  get definition() {
+    return {
+      id: this.id,
+      key: this.key,
+      version: this.machine.version,
+      type: this.type,
+      initial: this.initial ? {
+        target: this.initial.target,
+        source: this,
+        actions: this.initial.actions.map(toSerializableAction),
+        eventType: null,
+        reenter: false,
+        toJSON: () => ({
+          target: this.initial.target.map(t => `#${t.id}`),
+          source: `#${this.id}`,
+          actions: this.initial.actions.map(toSerializableAction),
+          eventType: null
+        })
+      } : undefined,
+      history: this.history,
+      states: mapValues(this.states, state => {
+        return state.definition;
+      }),
+      on: this.on,
+      transitions: [...this.transitions.values()].flat().map(t => ({
+        ...t,
+        actions: t.actions.map(toSerializableAction)
+      })),
+      entry: this.entry.map(toSerializableAction),
+      exit: this.exit.map(toSerializableAction),
+      meta: this.meta,
+      order: this.order || -1,
+      output: this.output,
+      invoke: this.invoke,
+      description: this.description,
+      tags: this.tags
+    };
+  }
+  toJSON() {
+    return this.definition;
+  }
 
-    /**
-     * The behaviors invoked as actors by this state node.
-     */
-  }, {
-    key: "invoke",
-    get: function get() {
-      var _this4 = this;
-      return memo(this, 'invoke', function () {
-        return toArray(_this4.config.invoke).map(function (invocable, i) {
-          var generatedId = createInvokeId(_this4.id, i);
-          var invokeConfig = toInvokeConfig(invocable, generatedId);
-          var resolvedId = invokeConfig.id || generatedId;
-          var src = invokeConfig.src,
-            systemId = invokeConfig.systemId;
-          var resolvedSrc = isString(src) ? src : !('type' in src) ? resolvedId : src;
-          if (!_this4.machine.options.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
-            _this4.machine.options.actors = _objectSpread2(_objectSpread2({}, _this4.machine.options.actors), {}, _defineProperty({}, resolvedId, src));
-          }
-          return _objectSpread2(_objectSpread2({
-            type: invoke
-          }, invokeConfig), {}, {
+  /**
+   * The logic invoked as actors by this state node.
+   */
+  get invoke() {
+    return memo(this, 'invoke', () => toArray(this.config.invoke).map((invokeConfig, i) => {
+      const {
+        src,
+        systemId
+      } = invokeConfig;
+      const resolvedId = invokeConfig.id ?? createInvokeId(this.id, i);
+      const resolvedSrc = typeof src === 'string' ? src : `xstate.invoke.${createInvokeId(this.id, i)}`;
+      return {
+        ...invokeConfig,
+        src: resolvedSrc,
+        id: resolvedId,
+        systemId: systemId,
+        toJSON() {
+          const {
+            onDone,
+            onError,
+            ...invokeDefValues
+          } = invokeConfig;
+          return {
+            ...invokeDefValues,
+            type: 'xstate.invoke',
             src: resolvedSrc,
-            id: resolvedId,
-            systemId: systemId,
-            toJSON: function toJSON() {
-              invokeConfig.onDone;
-                invokeConfig.onError;
-                var invokeDefValues = _objectWithoutProperties(invokeConfig, _excluded);
-              return _objectSpread2(_objectSpread2({}, invokeDefValues), {}, {
-                type: invoke,
-                src: resolvedSrc,
-                id: resolvedId
-              });
-            }
-          });
-        });
-      });
-    }
-
-    /**
-     * The mapping of events to transitions.
-     */
-  }, {
-    key: "on",
-    get: function get() {
-      var _this5 = this;
-      return memo(this, 'on', function () {
-        var transitions = _this5.transitions;
-        return transitions.reduce(function (map, transition) {
-          map[transition.eventType] = map[transition.eventType] || [];
-          map[transition.eventType].push(transition);
-          return map;
-        }, {});
-      });
-    }
-  }, {
-    key: "after",
-    get: function get() {
-      var _this6 = this;
-      return memo(this, 'delayedTransitions', function () {
-        return getDelayedTransitions(_this6);
-      });
-    }
-  }, {
-    key: "initial",
-    get: function get() {
-      var _this7 = this;
-      return memo(this, 'initial', function () {
-        return formatInitialTransition(_this7, _this7.config.initial || []);
-      });
-    }
+            id: resolvedId
+          };
+        }
+      };
+    }));
+  }
 
-    /**
-     * Returns `true` if this state node explicitly handles the given event.
-     *
-     * @param event The event in question
-     */
-  }, {
-    key: "handles",
-    value: function handles(event) {
-      return this.events.includes(event.type);
-    }
-  }, {
-    key: "next",
-    value: function next(state, _event) {
-      var _this8 = this;
-      var eventName = _event.name;
-      var actions = [];
-      var selectedTransition;
-      var candidates = memo(this, "candidates-".concat(eventName.toString()), function () {
-        return getCandidates(_this8, eventName, _this8.machine.config.scxml // Whether token matching should be used
-        );
-      });
-      var _iterator = _createForOfIteratorHelper(candidates),
-        _step;
+  /**
+   * The mapping of events to transitions.
+   */
+  get on() {
+    return memo(this, 'on', () => {
+      const transitions = this.transitions;
+      return [...transitions].flatMap(([descriptor, t]) => t.map(t => [descriptor, t])).reduce((map, [descriptor, transition]) => {
+        map[descriptor] = map[descriptor] || [];
+        map[descriptor].push(transition);
+        return map;
+      }, {});
+    });
+  }
+  get after() {
+    return memo(this, 'delayedTransitions', () => getDelayedTransitions(this));
+  }
+  get initial() {
+    return memo(this, 'initial', () => formatInitialTransition(this, this.config.initial));
+  }
+  next(snapshot, event) {
+    const eventType = event.type;
+    const actions = [];
+    let selectedTransition;
+    const candidates = memo(this, `candidates-${eventType}`, () => getCandidates(this, eventType));
+    for (const candidate of candidates) {
+      const {
+        guard
+      } = candidate;
+      const resolvedContext = snapshot.context;
+      let guardPassed = false;
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var candidate = _step.value;
-          var guard = candidate.guard;
-          var resolvedContext = state.context;
-          var guardPassed = false;
-          try {
-            guardPassed = !guard || evaluateGuard(guard, resolvedContext, _event, state);
-          } catch (err) {
-            throw new Error("Unable to evaluate guard '".concat(guard.type, "' in transition for event '").concat(eventName, "' in state node '").concat(this.id, "':\n").concat(err.message));
-          }
-          if (guardPassed) {
-            actions.push.apply(actions, _toConsumableArray(candidate.actions));
-            selectedTransition = candidate;
-            break;
-          }
-        }
+        guardPassed = !guard || evaluateGuard(guard, resolvedContext, event, snapshot);
       } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+        const guardType = typeof guard === 'string' ? guard : typeof guard === 'object' ? guard.type : undefined;
+        throw new Error(`Unable to evaluate guard ${guardType ? `'${guardType}' ` : ''}in transition for event '${eventType}' in state node '${this.id}':\n${err.message}`);
       }
-      return selectedTransition ? [selectedTransition] : undefined;
-    }
-
-    /**
-     * The target state value of the history state node, if it exists. This represents the
-     * default state value to transition to if no history value exists yet.
-     */
-  }, {
-    key: "target",
-    get: function get() {
-      if (this.type === 'history') {
-        var historyConfig = this.config;
-        return historyConfig.target;
+      if (guardPassed) {
+        actions.push(...candidate.actions);
+        selectedTransition = candidate;
+        break;
       }
-      return undefined;
-    }
-
-    /**
-     * All the state node IDs of this state node and its descendant state nodes.
-     */
-  }, {
-    key: "stateIds",
-    get: function get() {
-      var _this9 = this;
-      var childStateIds = flatten(Object.keys(this.states).map(function (stateKey) {
-        return _this9.states[stateKey].stateIds;
-      }));
-      return [this.id].concat(childStateIds);
     }
+    return selectedTransition ? [selectedTransition] : undefined;
+  }
 
-    /**
-     * All the event types accepted by this state node and its descendants.
-     */
-  }, {
-    key: "events",
-    get: function get() {
-      var _this10 = this;
-      return memo(this, 'events', function () {
-        var states = _this10.states;
-        var events = new Set(_this10.ownEvents);
-        if (states) {
-          for (var _i = 0, _Object$keys = Object.keys(states); _i < _Object$keys.length; _i++) {
-            var stateId = _Object$keys[_i];
-            var state = states[stateId];
-            if (state.states) {
-              var _iterator2 = _createForOfIteratorHelper(state.events),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var event = _step2.value;
-                  events.add("".concat(event));
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
-              }
+  /**
+   * All the event types accepted by this state node and its descendants.
+   */
+  get events() {
+    return memo(this, 'events', () => {
+      const {
+        states
+      } = this;
+      const events = new Set(this.ownEvents);
+      if (states) {
+        for (const stateId of Object.keys(states)) {
+          const state = states[stateId];
+          if (state.states) {
+            for (const event of state.events) {
+              events.add(`${event}`);
             }
           }
         }
-        return Array.from(events);
-      });
-    }
-
-    /**
-     * All the events that have transitions directly from this state node.
-     *
-     * Excludes any inert events.
-     */
-  }, {
-    key: "ownEvents",
-    get: function get() {
-      var events = new Set(this.transitions.filter(function (transition) {
-        return !(!transition.target && !transition.actions.length && !transition.reenter);
-      }).map(function (transition) {
-        return transition.eventType;
-      }));
+      }
       return Array.from(events);
-    }
-  }]);
-  return StateNode;
-}();
+    });
+  }
 
-var STATE_IDENTIFIER = '#';
-function createDefaultOptions() {
-  return {
-    actions: {},
-    actors: {},
-    delays: {},
-    guards: {},
-    context: {}
-  };
+  /**
+   * All the events that have transitions directly from this state node.
+   *
+   * Excludes any inert events.
+   */
+  get ownEvents() {
+    const events = new Set([...this.transitions.keys()].filter(descriptor => {
+      return this.transitions.get(descriptor).some(transition => !(!transition.target && !transition.actions.length && !transition.reenter));
+    }));
+    return Array.from(events);
+  }
 }
-var StateMachine = /*#__PURE__*/function () {
-  function StateMachine(
+
+const STATE_IDENTIFIER = '#';
+class StateMachine {
+  constructor(
   /**
    * The raw config used to create the machine.
    */
-  config, options) {
-    var _this$config$types;
-    _classCallCheck(this, StateMachine);
+  config, implementations) {
     this.config = config;
-    _defineProperty(this, "version", void 0);
-    _defineProperty(this, "delimiter", void 0);
-    _defineProperty(this, "options", void 0);
-    _defineProperty(this, "types", void 0);
-    _defineProperty(this, "__xstatenode", true);
-    _defineProperty(this, "idMap", new Map());
-    _defineProperty(this, "root", void 0);
-    _defineProperty(this, "id", void 0);
-    _defineProperty(this, "states", void 0);
-    _defineProperty(this, "events", void 0);
-    _defineProperty(this, "__TContext", void 0);
-    _defineProperty(this, "__TEvent", void 0);
-    _defineProperty(this, "__TAction", void 0);
-    _defineProperty(this, "__TActorMap", void 0);
-    _defineProperty(this, "__TResolvedTypesMeta", void 0);
+    /**
+     * The machine's own version.
+     */
+    this.version = void 0;
+    this.implementations = void 0;
+    this.__xstatenode = true;
+    this.idMap = new Map();
+    this.root = void 0;
+    this.id = void 0;
+    this.states = void 0;
+    this.events = void 0;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    this.__TResolvedTypesMeta = void 0;
     this.id = config.id || '(machine)';
-    this.options = Object.assign(createDefaultOptions(), options);
-    this.delimiter = this.config.delimiter || STATE_DELIMITER;
+    this.implementations = {
+      actors: implementations?.actors ?? {},
+      actions: implementations?.actions ?? {},
+      delays: implementations?.delays ?? {},
+      guards: implementations?.guards ?? {}
+    };
     this.version = this.config.version;
-    this.types = (_this$config$types = this.config.types) !== null && _this$config$types !== void 0 ? _this$config$types : {};
     this.transition = this.transition.bind(this);
+    this.getInitialSnapshot = this.getInitialSnapshot.bind(this);
+    this.restoreSnapshot = this.restoreSnapshot.bind(this);
+    this.start = this.start.bind(this);
     this.root = new StateNode(config, {
       _key: this.id,
       _machine: this
@@ -444,396 +408,194 @@ var StateMachine = /*#__PURE__*/function () {
    *
    * @returns A new `StateMachine` instance with the provided implementations.
    */
-  _createClass(StateMachine, [{
-    key: "getContext",
-    value:
-    // TODO: this getter should be removed
-    function getContext(input) {
-      return this.getContextAndActions(undefined, input)[0];
-    }
-  }, {
-    key: "getContextAndActions",
-    value: function getContextAndActions(actorCtx, input) {
-      var actions = [];
-      var context = this.config.context;
-      var resolvedContext = typeof context === 'function' ? context({
-        spawn: createSpawner(actorCtx === null || actorCtx === void 0 ? void 0 : actorCtx.self, this, undefined,
-        // TODO: this requires `| undefined` for all referenced dynamic inputs that are spawnable in the context factory,
-        createInitEvent(input), actions),
-        input: input
-      }) : context;
-      return [resolvedContext || {}, actions];
-    }
-    /**
-     * The machine's own version.
-     */
-  }, {
-    key: "provide",
-    value: function provide(implementations) {
-      var _this$options = this.options,
-        actions = _this$options.actions,
-        guards = _this$options.guards,
-        actors = _this$options.actors,
-        delays = _this$options.delays;
-      return new StateMachine(this.config, {
-        actions: _objectSpread2(_objectSpread2({}, actions), implementations.actions),
-        guards: _objectSpread2(_objectSpread2({}, guards), implementations.guards),
-        actors: _objectSpread2(_objectSpread2({}, actors), implementations.actors),
-        delays: _objectSpread2(_objectSpread2({}, delays), implementations.delays)
-      });
-    }
-
-    /**
-     * Resolves the given `state` to a new `State` instance relative to this machine.
-     *
-     * This ensures that `.nextEvents` represent the correct values.
-     *
-     * @param state The state to resolve
-     */
-  }, {
-    key: "resolveState",
-    value: function resolveState(state) {
-      var configurationSet = getConfiguration(getStateNodes(this.root, state.value));
-      var configuration = Array.from(configurationSet);
-      return this.createState(_objectSpread2(_objectSpread2({}, state), {}, {
-        value: resolveStateValue(this.root, state.value),
-        configuration: configuration,
-        done: isInFinalState(configuration)
-      }));
-    }
-  }, {
-    key: "resolveStateValue",
-    value: function resolveStateValue$1(stateValue) {
-      var resolvedStateValue = resolveStateValue(this.root, stateValue);
-      var resolvedContext = this.getContext();
-      return this.resolveState(State.from(resolvedStateValue, resolvedContext, this));
-    }
-
-    /**
-     * Determines the next state given the current `state` and received `event`.
-     * Calculates a full macrostep from all microsteps.
-     *
-     * @param state The current State instance or state value
-     * @param event The received event
-     */
-  }, {
-    key: "transition",
-    value: function transition() {
-      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.initialState;
-      var event = arguments.length > 1 ? arguments[1] : undefined;
-      var actorCtx = arguments.length > 2 ? arguments[2] : undefined;
-      var currentState = state instanceof State ? state : this.resolveStateValue(state);
-      // TODO: handle error events in a better way
-      var scxmlEvent = toSCXMLEvent(event);
-      if (isSCXMLErrorEvent(scxmlEvent) && !currentState.nextEvents.some(function (nextEvent) {
-        return nextEvent === scxmlEvent.name;
-      })) {
-        throw scxmlEvent.data.data;
+  provide(implementations) {
+    const {
+      actions,
+      guards,
+      actors,
+      delays
+    } = this.implementations;
+    return new StateMachine(this.config, {
+      actions: {
+        ...actions,
+        ...implementations.actions
+      },
+      guards: {
+        ...guards,
+        ...implementations.guards
+      },
+      actors: {
+        ...actors,
+        ...implementations.actors
+      },
+      delays: {
+        ...delays,
+        ...implementations.delays
       }
-      var _macrostep = macrostep(currentState, scxmlEvent, actorCtx),
-        nextState = _macrostep.state;
-      return nextState;
-    }
+    });
+  }
+  resolveState(config) {
+    const resolvedStateValue = resolveStateValue(this.root, config.value);
+    const nodeSet = getAllStateNodes(getStateNodes(this.root, resolvedStateValue));
+    return createMachineSnapshot({
+      _nodes: [...nodeSet],
+      context: config.context || {},
+      children: {},
+      status: isInFinalState(nodeSet, this.root) ? 'done' : config.status || 'active',
+      output: config.output,
+      error: config.error,
+      historyValue: config.historyValue
+    }, this);
+  }
 
-    /**
-     * Determines the next state given the current `state` and `event`.
-     * Calculates a microstep.
-     *
-     * @param state The current state
-     * @param event The received event
-     */
-  }, {
-    key: "microstep",
-    value: function microstep() {
-      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.initialState;
-      var event = arguments.length > 1 ? arguments[1] : undefined;
-      var actorCtx = arguments.length > 2 ? arguments[2] : undefined;
-      var scxmlEvent = toSCXMLEvent(event);
-      var _macrostep2 = macrostep(state, scxmlEvent, actorCtx),
-        microstates = _macrostep2.microstates;
-      return microstates;
-    }
-  }, {
-    key: "getTransitionData",
-    value: function getTransitionData(state, _event) {
-      return transitionNode(this.root, state.value, state, _event) || [];
-    }
+  /**
+   * Determines the next snapshot given the current `snapshot` and received `event`.
+   * Calculates a full macrostep from all microsteps.
+   *
+   * @param snapshot The current snapshot
+   * @param event The received event
+   */
+  transition(snapshot, event, actorScope) {
+    return macrostep(snapshot, event, actorScope).snapshot;
+  }
 
-    /**
-     * The initial state _before_ evaluating any microsteps.
-     * This "pre-initial" state is provided to initial actions executed in the initial state.
-     */
-  }, {
-    key: "getPreInitialState",
-    value: function getPreInitialState(actorCtx, input) {
-      var _preInitial$actions;
-      var _this$getContextAndAc = this.getContextAndActions(actorCtx, input),
-        _this$getContextAndAc2 = _slicedToArray(_this$getContextAndAc, 2),
-        context = _this$getContextAndAc2[0],
-        actions = _this$getContextAndAc2[1];
-      var config = getInitialConfiguration(this.root);
-      var preInitial = this.resolveState(this.createState({
-        value: {},
-        // TODO: this is computed in state constructor
-        context: context,
-        _event: createInitEvent({}),
-        actions: [],
-        meta: undefined,
-        configuration: config,
-        transitions: [],
-        children: {}
-      }));
-      preInitial._initial = true;
-      (_preInitial$actions = preInitial.actions).unshift.apply(_preInitial$actions, _toConsumableArray(actions));
-      if (actorCtx) {
-        var _resolveActionsAndCon = resolveActionsAndContext(actions, initEvent, preInitial, actorCtx),
-          nextState = _resolveActionsAndCon.nextState;
-        preInitial.children = nextState.children;
-        preInitial.actions = nextState.actions;
-      }
-      return preInitial;
-    }
+  /**
+   * Determines the next state given the current `state` and `event`.
+   * Calculates a microstep.
+   *
+   * @param state The current state
+   * @param event The received event
+   */
+  microstep(snapshot, event, actorScope) {
+    return macrostep(snapshot, event, actorScope).microstates;
+  }
+  getTransitionData(snapshot, event) {
+    return transitionNode(this.root, snapshot.value, snapshot, event) || [];
+  }
 
-    /**
-     * The initial State instance, which includes all actions to be executed from
-     * entering the initial state.
-     */
-  }, {
-    key: "initialState",
-    get: function get() {
-      return this.getInitialState();
+  /**
+   * The initial state _before_ evaluating any microsteps.
+   * This "pre-initial" state is provided to initial actions executed in the initial state.
+   */
+  getPreInitialState(actorScope, initEvent, internalQueue) {
+    const {
+      context
+    } = this.config;
+    const preInitial = createMachineSnapshot({
+      context: typeof context !== 'function' && context ? context : {},
+      _nodes: [this.root],
+      children: {},
+      status: 'active'
+    }, this);
+    if (typeof context === 'function') {
+      const assignment = ({
+        spawn,
+        event
+      }) => context({
+        spawn,
+        input: event.input
+      });
+      return resolveActionsAndContext(preInitial, initEvent, actorScope, [assign(assignment)], internalQueue);
     }
+    return preInitial;
+  }
 
-    /**
-     * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
-     */
-  }, {
-    key: "getInitialState",
-    value: function getInitialState(actorCtx, input) {
-      var _nextState$actions;
-      var initEvent = createInitEvent(input); // TODO: fix;
-
-      var preInitialState = this.getPreInitialState(actorCtx, input);
-      var nextState = microstep([], preInitialState, actorCtx, initEvent);
-      (_nextState$actions = nextState.actions).unshift.apply(_nextState$actions, _toConsumableArray(preInitialState.actions));
-      var _macrostep3 = macrostep(nextState, initEvent, actorCtx),
-        macroState = _macrostep3.state;
-      return macroState;
-    }
-  }, {
-    key: "start",
-    value: function start(state, actorCtx) {
-      state.actions.forEach(function (action) {
-        var _action$execute;
-        (_action$execute = action.execute) === null || _action$execute === void 0 ? void 0 : _action$execute.call(action, actorCtx);
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
+   */
+  getInitialSnapshot(actorScope, input) {
+    const initEvent = createInitEvent(input); // TODO: fix;
+    const internalQueue = [];
+    const preInitialState = this.getPreInitialState(actorScope, initEvent, internalQueue);
+    const nextState = microstep([{
+      target: [...getInitialStateNodes(this.root)],
+      source: this.root,
+      reenter: true,
+      actions: [],
+      eventType: null,
+      toJSON: null // TODO: fix
+    }], preInitialState, actorScope, initEvent, true, internalQueue);
+    const {
+      snapshot: macroState
+    } = macrostep(nextState, initEvent, actorScope, internalQueue);
+    return macroState;
+  }
+  start(snapshot) {
+    Object.values(snapshot.children).forEach(child => {
+      if (child.getSnapshot().status === 'active') {
+        child.start();
+      }
+    });
+  }
+  getStateNodeById(stateId) {
+    const fullPath = stateId.split(STATE_DELIMITER);
+    const relativePath = fullPath.slice(1);
+    const resolvedStateId = isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
+    const stateNode = this.idMap.get(resolvedStateId);
+    if (!stateNode) {
+      throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
+    }
+    return getStateNodeByPath(stateNode, relativePath);
+  }
+  get definition() {
+    return this.root.definition;
+  }
+  toJSON() {
+    return this.definition;
+  }
+  getPersistedSnapshot(snapshot, options) {
+    return getPersistedSnapshot(snapshot, options);
+  }
+  restoreSnapshot(snapshot, _actorScope) {
+    const children = {};
+    const snapshotChildren = snapshot.children;
+    Object.keys(snapshotChildren).forEach(actorId => {
+      const actorData = snapshotChildren[actorId];
+      const childState = actorData.snapshot;
+      const src = actorData.src;
+      const logic = typeof src === 'string' ? resolveReferencedActor(this, src) : src;
+      if (!logic) {
+        return;
+      }
+      const actorRef = createActor(logic, {
+        id: actorId,
+        parent: _actorScope?.self,
+        syncSnapshot: actorData.syncSnapshot,
+        snapshot: childState,
+        src,
+        systemId: actorData.systemId
       });
-      Object.values(state.children).forEach(function (child) {
-        if (child.status === 0) {
-          try {
-            var _child$start;
-            (_child$start = child.start) === null || _child$start === void 0 ? void 0 : _child$start.call(child);
-          } catch (err) {
-            // TODO: unify error handling when child starts
-            actorCtx.self.send(error(child.id, err));
+      children[actorId] = actorRef;
+    });
+    const restoredSnapshot = createMachineSnapshot({
+      ...snapshot,
+      children,
+      _nodes: Array.from(getAllStateNodes(getStateNodes(this.root, snapshot.value)))
+    }, this);
+    let seen = new Set();
+    function reviveContext(contextPart, children) {
+      if (seen.has(contextPart)) {
+        return;
+      }
+      seen.add(contextPart);
+      for (let key in contextPart) {
+        const value = contextPart[key];
+        if (value && typeof value === 'object') {
+          if ('xstate$$type' in value && value.xstate$$type === $$ACTOR_TYPE) {
+            contextPart[key] = children[value.id];
+            continue;
           }
+          reviveContext(value, children);
         }
-      });
-    }
-  }, {
-    key: "getStateNodeById",
-    value: function getStateNodeById(stateId) {
-      var fullPath = stateId.split(this.delimiter);
-      var relativePath = fullPath.slice(1);
-      var resolvedStateId = isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
-      var stateNode = this.idMap.get(resolvedStateId);
-      if (!stateNode) {
-        throw new Error("Child state node '#".concat(resolvedStateId, "' does not exist on machine '").concat(this.id, "'"));
       }
-      return getStateNodeByPath(stateNode, relativePath);
-    }
-  }, {
-    key: "definition",
-    get: function get() {
-      return _objectSpread2({
-        context: this.getContext()
-      }, this.root.definition);
-    }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return this.definition;
-    }
-  }, {
-    key: "getPersistedState",
-    value: function getPersistedState$1(state) {
-      return getPersistedState(state);
-    }
-  }, {
-    key: "createState",
-    value: function createState(stateConfig) {
-      var state = stateConfig instanceof State ? stateConfig : new State(stateConfig, this);
-      var _resolveActionsAndCon2 = resolveActionsAndContext(state.actions, state._event, state, undefined),
-        resolvedState = _resolveActionsAndCon2.nextState;
-      return resolvedState;
-    }
-  }, {
-    key: "getStatus",
-    value: function getStatus(state) {
-      return state.done ? {
-        status: 'done',
-        data: state.output
-      } : {
-        status: 'active'
-      };
-    }
-  }, {
-    key: "restoreState",
-    value: function restoreState(state, _actorCtx) {
-      var _this = this;
-      var children = {};
-      Object.keys(state.children).forEach(function (actorId) {
-        var _resolveReferencedAct, _behavior$restoreStat;
-        var actorData = state.children[actorId];
-        var childState = actorData.state;
-        var src = actorData.src;
-        var behavior = src ? (_resolveReferencedAct = resolveReferencedActor(_this.options.actors[src])) === null || _resolveReferencedAct === void 0 ? void 0 : _resolveReferencedAct.src : undefined;
-        if (!behavior) {
-          return;
-        }
-        var actorState = (_behavior$restoreStat = behavior.restoreState) === null || _behavior$restoreStat === void 0 ? void 0 : _behavior$restoreStat.call(behavior, childState, _actorCtx);
-        var actorRef = interpret(behavior, {
-          id: actorId,
-          state: actorState
-        });
-        children[actorId] = actorRef;
-      });
-      var restoredState = this.createState(new State(_objectSpread2(_objectSpread2({}, state), {}, {
-        children: children
-      }), this));
-
-      // TODO: DRY this up
-      restoredState.configuration.forEach(function (stateNode) {
-        if (stateNode.invoke) {
-          stateNode.invoke.forEach(function (invokeConfig) {
-            var id = invokeConfig.id,
-              src = invokeConfig.src;
-            if (children[id]) {
-              return;
-            }
-            var referenced = resolveReferencedActor(_this.options.actors[src]);
-            if (referenced) {
-              var actorRef = interpret(referenced.src, {
-                id: id,
-                parent: _actorCtx === null || _actorCtx === void 0 ? void 0 : _actorCtx.self,
-                input: 'input' in invokeConfig ? invokeConfig.input : referenced.input
-              });
-              children[id] = actorRef;
-            }
-          });
-        }
-      });
-      restoredState.actions = [];
-      return restoredState;
-    }
-
-    /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-  }]);
-  return StateMachine;
-}();
-
-function createMachine(config, implementations) {
-  return new StateMachine(config, implementations);
-}
-
-function mapState(stateMap, stateId) {
-  var foundStateId;
-  for (var _i = 0, _Object$keys = Object.keys(stateMap); _i < _Object$keys.length; _i++) {
-    var mappedStateId = _Object$keys[_i];
-    if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
-      foundStateId = mappedStateId;
     }
+    reviveContext(restoredSnapshot.context, children);
+    return restoredSnapshot;
   }
-  return stateMap[foundStateId];
 }
 
-var SimulatedClock = /*#__PURE__*/function () {
-  function SimulatedClock() {
-    _classCallCheck(this, SimulatedClock);
-    _defineProperty(this, "timeouts", new Map());
-    _defineProperty(this, "_now", 0);
-    _defineProperty(this, "_id", 0);
-  }
-  _createClass(SimulatedClock, [{
-    key: "now",
-    value: function now() {
-      return this._now;
-    }
-  }, {
-    key: "getId",
-    value: function getId() {
-      return this._id++;
-    }
-  }, {
-    key: "setTimeout",
-    value: function setTimeout(fn, timeout) {
-      var id = this.getId();
-      this.timeouts.set(id, {
-        start: this.now(),
-        timeout: timeout,
-        fn: fn
-      });
-      return id;
-    }
-  }, {
-    key: "clearTimeout",
-    value: function clearTimeout(id) {
-      this.timeouts["delete"](id);
-    }
-  }, {
-    key: "set",
-    value: function set(time) {
-      if (this._now > time) {
-        throw new Error('Unable to travel back in time');
-      }
-      this._now = time;
-      this.flushTimeouts();
-    }
-  }, {
-    key: "flushTimeouts",
-    value: function flushTimeouts() {
-      var _this = this;
-      _toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
-        var _ref3 = _slicedToArray(_ref, 2);
-          _ref3[0];
-          var timeoutA = _ref3[1];
-        var _ref4 = _slicedToArray(_ref2, 2);
-          _ref4[0];
-          var timeoutB = _ref4[1];
-        var endA = timeoutA.start + timeoutA.timeout;
-        var endB = timeoutB.start + timeoutB.timeout;
-        return endB > endA ? -1 : 1;
-      }).forEach(function (_ref5) {
-        var _ref6 = _slicedToArray(_ref5, 2),
-          id = _ref6[0],
-          timeout = _ref6[1];
-        if (_this.now() - timeout.start >= timeout.timeout) {
-          _this.timeouts["delete"](id);
-          timeout.fn.call(null);
-        }
-      });
-    }
-  }, {
-    key: "increment",
-    value: function increment(ms) {
-      this._now += ms;
-      this.flushTimeouts();
-    }
-  }]);
-  return SimulatedClock;
-}();
-
-var defaultWaitForOptions = {
-  timeout: 10000 // 10 seconds
+const defaultWaitForOptions = {
+  timeout: Infinity // much more than 10 seconds
 };
 
 /**
@@ -858,20 +620,20 @@ var defaultWaitForOptions = {
  * that matches the condition
  */
 function waitFor(actorRef, predicate, options) {
-  var resolvedOptions = _objectSpread2(_objectSpread2({}, defaultWaitForOptions), options);
-  return new Promise(function (res, rej) {
-    var done = false;
-    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
-      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
-    }
-    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
       sub.unsubscribe();
-      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
     }, resolvedOptions.timeout);
-    var dispose = function dispose() {
+    const dispose = () => {
       clearTimeout(handle);
       done = true;
-      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+      sub?.unsubscribe();
     };
     function checkEmitted(emitted) {
       if (predicate(emitted)) {
@@ -879,18 +641,22 @@ function waitFor(actorRef, predicate, options) {
         res(emitted);
       }
     }
+    let sub; // avoid TDZ when disposing synchronously
 
     // See if the current snapshot already matches the predicate
     checkEmitted(actorRef.getSnapshot());
-    var sub = actorRef.subscribe({
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
       next: checkEmitted,
-      error: function error(err) {
+      error: err => {
         dispose();
         rej(err);
       },
-      complete: function complete() {
+      complete: () => {
         dispose();
-        rej(new Error("Actor terminated without satisfying predicate"));
+        rej(new Error(`Actor terminated without satisfying predicate`));
       }
     });
     if (done) {
@@ -899,4 +665,29 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
-export { SimulatedClock, StateMachine, StateNode, createMachine, mapState, waitFor };
+// this is not 100% accurate since we can't make parallel regions required in the result
+// `TTestValue` doesn't encode this information anyhow for us to be able to do that
+// this is fine for most practical use cases anyway though
+function createMachine(config, implementations) {
+  return new StateMachine(config, implementations);
+}
+
+// at the moment we allow extra actors - ones that are not specified by `children`
+// this could be reconsidered in the future
+function setup({
+  actors,
+  actions,
+  guards,
+  delays
+}) {
+  return {
+    createMachine: config => createMachine(config, {
+      actors,
+      actions,
+      guards,
+      delays
+    })
+  };
+}
+
+export { SimulatedClock, StateMachine, StateNode, createMachine, setup, waitFor };