xstate 4.35.2 → 5.0.0-alpha.1

package/dist/actions-7ea9280f.cjs.prod.js

@@ -0,0 +1,4674 @@
+'use strict';
+
+var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.prod.js');
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+(function (ActionTypes) {
+  ActionTypes["Stop"] = "xstate.stop";
+  ActionTypes["Raise"] = "xstate.raise";
+  ActionTypes["Send"] = "xstate.send";
+  ActionTypes["Cancel"] = "xstate.cancel";
+  ActionTypes["Assign"] = "xstate.assign";
+  ActionTypes["After"] = "xstate.after";
+  ActionTypes["DoneState"] = "done.state";
+  ActionTypes["DoneInvoke"] = "done.invoke";
+  ActionTypes["Log"] = "xstate.log";
+  ActionTypes["Init"] = "xstate.init";
+  ActionTypes["Invoke"] = "xstate.invoke";
+  ActionTypes["ErrorExecution"] = "error.execution";
+  ActionTypes["ErrorCommunication"] = "error.communication";
+  ActionTypes["ErrorPlatform"] = "error.platform";
+  ActionTypes["ErrorCustom"] = "xstate.error";
+  ActionTypes["Pure"] = "xstate.pure";
+  ActionTypes["Choose"] = "xstate.choose";
+})(exports.ActionTypes || (exports.ActionTypes = {}));
+
+(function (SpecialTargets) {
+  SpecialTargets["Parent"] = "#_parent";
+  SpecialTargets["Internal"] = "#_internal";
+})(exports.SpecialTargets || (exports.SpecialTargets = {}));
+
+var stop = exports.ActionTypes.Stop;
+var raise = exports.ActionTypes.Raise;
+var send = exports.ActionTypes.Send;
+var cancel = exports.ActionTypes.Cancel;
+var assign = exports.ActionTypes.Assign;
+var after = exports.ActionTypes.After;
+var doneState = exports.ActionTypes.DoneState;
+var log = exports.ActionTypes.Log;
+var init = exports.ActionTypes.Init;
+var invoke = exports.ActionTypes.Invoke;
+var errorExecution = exports.ActionTypes.ErrorExecution;
+var errorPlatform = exports.ActionTypes.ErrorPlatform;
+var error = exports.ActionTypes.ErrorCustom;
+var choose = exports.ActionTypes.Choose;
+var pure = exports.ActionTypes.Pure;
+
+var actionTypes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  stop: stop,
+  raise: raise,
+  send: send,
+  cancel: cancel,
+  assign: assign,
+  after: after,
+  doneState: doneState,
+  log: log,
+  init: init,
+  invoke: invoke,
+  errorExecution: errorExecution,
+  errorPlatform: errorPlatform,
+  error: error,
+  choose: choose,
+  pure: pure
+});
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function () {};
+
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var normalCompletion = true,
+      didErr = false,
+      err;
+  return {
+    s: function () {
+      it = o[Symbol.iterator]();
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+var STATE_DELIMITER = '.';
+var TARGETLESS_KEY = '';
+var NULL_EVENT = '';
+var STATE_IDENTIFIER = '#';
+var WILDCARD = '*';
+
+function matchesState(parentStateId, childStateId) {
+  var delimiter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : STATE_DELIMITER;
+  var parentStateValue = toStateValue(parentStateId, delimiter);
+  var childStateValue = toStateValue(childStateId, delimiter);
+
+  if (isString(childStateValue)) {
+    if (isString(parentStateValue)) {
+      return childStateValue === parentStateValue;
+    } // Parent more specific than child
+
+
+    return false;
+  }
+
+  if (isString(parentStateValue)) {
+    return parentStateValue in childStateValue;
+  }
+
+  return Object.keys(parentStateValue).every(function (key) {
+    if (!(key in childStateValue)) {
+      return false;
+    }
+
+    return matchesState(parentStateValue[key], childStateValue[key]);
+  });
+}
+function toStatePath(stateId, delimiter) {
+  try {
+    if (isArray(stateId)) {
+      return stateId;
+    }
+
+    return stateId.toString().split(delimiter);
+  } catch (e) {
+    throw new Error("'".concat(stateId, "' is not a valid state path."));
+  }
+}
+function isStateLike(state) {
+  return _typeof(state) === 'object' && 'value' in state && 'context' in state && 'event' in state && '_event' in state;
+}
+function toStateValue(stateValue, delimiter) {
+  if (isStateLike(stateValue)) {
+    return stateValue.value;
+  }
+
+  if (isArray(stateValue)) {
+    return pathToStateValue(stateValue);
+  }
+
+  if (typeof stateValue !== 'string') {
+    return stateValue;
+  }
+
+  var statePath = toStatePath(stateValue, delimiter);
+  return pathToStateValue(statePath);
+}
+function pathToStateValue(statePath) {
+  if (statePath.length === 1) {
+    return statePath[0];
+  }
+
+  var value = {};
+  var marker = value;
+
+  for (var _i = 0; _i < statePath.length - 1; _i++) {
+    if (_i === statePath.length - 2) {
+      marker[statePath[_i]] = statePath[_i + 1];
+    } else {
+      marker[statePath[_i]] = {};
+      marker = marker[statePath[_i]];
+    }
+  }
+
+  return value;
+}
+function mapValues(collection, iteratee) {
+  var result = {};
+  var collectionKeys = Object.keys(collection);
+
+  for (var _i2 = 0; _i2 < collectionKeys.length; _i2++) {
+    var _key = collectionKeys[_i2];
+    result[_key] = iteratee(collection[_key], _key, collection, _i2);
+  }
+
+  return result;
+}
+function flatten(array) {
+  var _ref;
+
+  return (_ref = []).concat.apply(_ref, _toConsumableArray(array));
+}
+function toArrayStrict(value) {
+  if (isArray(value)) {
+    return value;
+  }
+
+  return [value];
+}
+function toArray(value) {
+  if (value === undefined) {
+    return [];
+  }
+
+  return toArrayStrict(value);
+}
+function mapContext(mapper, context, _event) {
+  if (isFunction(mapper)) {
+    return mapper(context, _event.data);
+  }
+
+  var result = {};
+
+  for (var _i4 = 0, _Object$keys2 = Object.keys(mapper); _i4 < _Object$keys2.length; _i4++) {
+    var _key3 = _Object$keys2[_i4];
+    var subMapper = mapper[_key3];
+
+    if (isFunction(subMapper)) {
+      result[_key3] = subMapper(context, _event.data);
+    } else {
+      result[_key3] = subMapper;
+    }
+  }
+
+  return result;
+}
+function isPromiseLike(value) {
+  if (value instanceof Promise) {
+    return true;
+  } // Check if shape matches the Promise/A+ specification for a "thenable".
+
+
+  if (value !== null && (isFunction(value) || _typeof(value) === 'object') && isFunction(value.then)) {
+    return true;
+  }
+
+  return false;
+}
+
+var warn = function warn() {};
+
+function isArray(value) {
+  return Array.isArray(value);
+} // tslint:disable-next-line:ban-types
+
+function isFunction(value) {
+  return typeof value === 'function';
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+function isStateMachine(value) {
+  return !!value && '__xstatenode' in value;
+}
+function isSCXMLEvent(event) {
+  return '$$type' in event && event.$$type === 'scxml';
+}
+function isSCXMLErrorEvent(event) {
+  return typeof event.name === 'string' && (event.name === errorExecution || event.name.startsWith(errorPlatform));
+}
+function toSCXMLEvent(event, scxmlEvent) {
+  if (isSCXMLEvent(event)) {
+    return event;
+  }
+
+  return _objectSpread2({
+    name: event.type,
+    data: event,
+    $$type: 'scxml',
+    type: 'external'
+  }, scxmlEvent);
+}
+function toTransitionConfigArray(event, configLike) {
+  var transitions = toArrayStrict(configLike).map(function (transitionLike) {
+    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string' || isStateMachine(transitionLike)) {
+      return {
+        target: transitionLike,
+        event: event
+      };
+    }
+
+    return _objectSpread2(_objectSpread2({}, transitionLike), {}, {
+      event: event
+    });
+  });
+  return transitions;
+}
+function normalizeTarget(target) {
+  if (target === undefined || target === TARGETLESS_KEY) {
+    return undefined;
+  }
+
+  return toArray(target);
+}
+function toInvokeConfig(invocable, id) {
+  if (_typeof(invocable) === 'object') {
+    if ('src' in invocable) {
+      return invocable;
+    }
+
+    if ('transition' in invocable) {
+      return {
+        id: id,
+        src: invocable
+      };
+    }
+  }
+
+  return {
+    id: id,
+    src: invocable
+  };
+}
+function toInvokeSource(src) {
+  if (typeof src === 'string') {
+    return {
+      type: src
+    };
+  }
+
+  return src;
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+  var noop = function noop() {};
+
+  var isObserver = _typeof(nextHandler) === 'object';
+  var self = isObserver ? nextHandler : null;
+  return {
+    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
+    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
+    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
+  };
+}
+function createInvokeId(stateNodeId, index) {
+  return "".concat(stateNodeId, ":invocation[").concat(index, "]");
+}
+
+function createDynamicAction(action, resolve) {
+  return {
+    type: action.type,
+    params: action.params,
+    resolve: resolve
+  };
+}
+function isDynamicAction(action) {
+  return _typeof(action) === 'object' && action !== null && 'resolve' in action;
+}
+
+/**
+ * Sends an event. This returns an action that will be read by an interpreter to
+ * send the event in the next step, after the current step is finished executing.
+ *
+ * @param event The event to send.
+ * @param options Options to pass into the send event:
+ *  - `id` - The unique send event identifier (used with `cancel()`).
+ *  - `delay` - The number of milliseconds to delay the sending of the event.
+ *  - `to` - The target of this event (by default, the machine the event was sent from).
+ */
+
+function send$1(event, options) {
+  var eventOrExpr = isFunction(event) ? event : event;
+  return createDynamicAction({
+    type: send,
+    params: {
+      to: options ? options.to : undefined,
+      delay: options ? options.delay : undefined,
+      event: eventOrExpr,
+      id: options && options.id !== undefined ? options.id : isFunction(event) ? event.name : event.type
+    }
+  }, function (_event, _ref) {
+    var actorContext = _ref.actorContext,
+        state = _ref.state;
+    var params = {
+      to: options ? options.to : undefined,
+      delay: options ? options.delay : undefined,
+      event: eventOrExpr,
+      id: options && options.id !== undefined ? options.id : isFunction(event) ? event.name : event.type
+    };
+    var meta = {
+      _event: _event
+    };
+    var delaysMap = state.machine.options.delays; // TODO: helper function for resolving Expr
+
+    var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(state.context, _event.data, meta) : eventOrExpr);
+    var resolvedDelay;
+
+    if (isString(params.delay)) {
+      var configDelay = delaysMap && delaysMap[params.delay];
+      resolvedDelay = isFunction(configDelay) ? configDelay(state.context, _event.data, meta) : configDelay;
+    } else {
+      resolvedDelay = isFunction(params.delay) ? params.delay(state.context, _event.data, meta) : params.delay;
+    }
+
+    var resolvedTarget = isFunction(params.to) ? params.to(state.context, _event.data, meta) : params.to;
+    var targetActorRef;
+
+    if (typeof resolvedTarget === 'string') {
+      if (resolvedTarget === exports.SpecialTargets.Parent) {
+        targetActorRef = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self._parent;
+      } else if (resolvedTarget === exports.SpecialTargets.Internal) {
+        targetActorRef = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self;
+      } else if (resolvedTarget.startsWith('#_')) {
+        // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
+        // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
+        targetActorRef = state.children[resolvedTarget.slice(2)];
+      } else {
+        targetActorRef = state.children[resolvedTarget];
+      }
+
+      if (!targetActorRef) {
+        throw new Error("Unable to send event to actor '".concat(resolvedTarget, "' from machine '").concat(state.machine.id, "'."));
+      }
+    } else {
+      targetActorRef = resolvedTarget || (actorContext === null || actorContext === void 0 ? void 0 : actorContext.self);
+    }
+
+    var resolvedAction = {
+      type: send,
+      params: _objectSpread2(_objectSpread2({}, params), {}, {
+        to: targetActorRef,
+        _event: resolvedEvent,
+        event: resolvedEvent.data,
+        delay: resolvedDelay,
+        internal: resolvedTarget === exports.SpecialTargets.Internal
+      }),
+      execute: function execute(actorCtx) {
+        var sendAction = resolvedAction;
+
+        if (typeof sendAction.params.delay === 'number') {
+          actorCtx.self.delaySend(sendAction);
+          return;
+        } else {
+          var target = sendAction.params.to;
+          var _event2 = sendAction.params._event;
+          actorCtx.defer(function () {
+            var origin = actorCtx.self;
+
+            var resolvedEvent = _objectSpread2(_objectSpread2({}, _event2), {}, {
+              name: _event2.name === error ? "".concat(error$1(origin.id)) : _event2.name,
+              origin: origin
+            });
+
+            target.send(resolvedEvent);
+          });
+        }
+      }
+    };
+    return [state, resolvedAction];
+  });
+}
+/**
+ * Sends an event to this machine's parent.
+ *
+ * @param event The event to send to the parent machine.
+ * @param options Options to pass into the send event.
+ */
+
+function sendParent(event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: exports.SpecialTargets.Parent
+  }));
+}
+/**
+ * Sends an event back to the sender of the original event.
+ *
+ * @param event The event to send back to the sender
+ * @param options Options to pass into the send event
+ */
+
+function respond(event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: function to(_, __, _ref2) {
+      var _event = _ref2._event;
+      return _event.origin; // TODO: handle when _event.origin is undefined
+    }
+  }));
+}
+/**
+ * Forwards (sends) an event to a specified service.
+ *
+ * @param target The target service to forward the event to.
+ * @param options Options to pass into the send action creator.
+ */
+
+function forwardTo(target, options) {
+  if (process.env.NODE_END !== 'production' && (!target || typeof target === 'function')) {
+    var originalTarget = target;
+
+    target = function target() {
+      var resolvedTarget = typeof originalTarget === 'function' ? originalTarget.apply(void 0, arguments) : originalTarget;
+
+      if (!resolvedTarget) {
+        throw new Error("Attempted to forward event to undefined actor. This risks an infinite loop in the sender.");
+      }
+
+      return resolvedTarget;
+    };
+  }
+
+  return send$1(function (_, event) {
+    return event;
+  }, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: target
+  }));
+}
+/**
+ * Escalates an error by sending it as an event to this machine's parent.
+ *
+ * @param errorData The error data to send, or the expression function that
+ * takes in the `context`, `event`, and `meta`, and returns the error data to send.
+ * @param options Options to pass into the send action creator.
+ */
+
+function escalate(errorData, options) {
+  return sendParent(function (context, event, meta) {
+    return {
+      type: error,
+      data: isFunction(errorData) ? errorData(context, event, meta) : errorData
+    };
+  }, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: exports.SpecialTargets.Parent
+  }));
+}
+/**
+ * Sends an event to an actor.
+ *
+ * @param actor The `ActorRef` to send the event to.
+ * @param event The event to send, or an expression that evaluates to the event to send
+ * @param options Send action options
+ * @returns An XState send action object
+ */
+
+function sendTo(actor, event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: actor
+  }));
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+var symbolObservable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
+
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+
+function fromReducer(_transition, initialState) {
+  return {
+    transition: function transition(state, event, actorCtx) {
+      // @ts-ignore TODO
+      var resolvedEvent = isSCXMLEvent(event) ? event.data : event; // @ts-ignore TODO
+
+      return _transition(state, resolvedEvent, actorCtx);
+    },
+    getInitialState: function getInitialState() {
+      return initialState;
+    },
+    getSnapshot: function getSnapshot(state) {
+      return state;
+    }
+  };
+}
+var startSignalType = 'xstate.init';
+var stopSignalType = 'xstate.stop';
+var startSignal = {
+  type: 'xstate.init'
+};
+var stopSignal = {
+  type: 'xstate.stop'
+};
+
+/**
+ * An object that expresses the behavior of an actor in reaction to received events,
+ * as well as an optionally emitted stream of values.
+ *
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
+ */
+function isSignal(eventType) {
+  return eventType === startSignalType || eventType === stopSignalType;
+}
+
+function fromCallback(invokeCallback) {
+  var behavior = {
+    start: function start(state, _ref) {
+      var self = _ref.self;
+      self.send({
+        type: startSignalType
+      });
+      return state;
+    },
+    transition: function transition(state, event, _ref2) {
+      var self = _ref2.self,
+          id = _ref2.id;
+
+      var _event = toSCXMLEvent(event);
+
+      if (_event.name === startSignalType) {
+        var sender = function sender(eventForParent) {
+          var _self$_parent;
+
+          if (state.canceled) {
+            return state;
+          }
+
+          (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(toSCXMLEvent(eventForParent, {
+            origin: self
+          }));
+        };
+
+        var receiver = function receiver(newListener) {
+          state.receivers.add(newListener);
+        };
+
+        state.dispose = invokeCallback(sender, receiver);
+
+        if (isPromiseLike(state.dispose)) {
+          state.dispose.then(function (resolved) {
+            var _self$_parent2;
+
+            (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(toSCXMLEvent(doneInvoke(id, resolved), {
+              origin: self
+            }));
+            state.canceled = true;
+          }, function (errorData) {
+            var _self$_parent3;
+
+            var errorEvent = error$1(id, errorData);
+            (_self$_parent3 = self._parent) === null || _self$_parent3 === void 0 ? void 0 : _self$_parent3.send(toSCXMLEvent(errorEvent, {
+              origin: self
+            }));
+            state.canceled = true;
+          });
+        }
+
+        return state;
+      }
+
+      if (_event.name === stopSignalType) {
+        state.canceled = true;
+
+        if (isFunction(state.dispose)) {
+          state.dispose();
+        }
+
+        return state;
+      }
+
+      if (isSignal(_event.name)) {
+        // TODO: unrecognized signal
+        return state;
+      }
+
+      var plainEvent = isSCXMLEvent(event) ? event.data : event;
+
+      if (!isSignal(plainEvent.type)) {
+        state.receivers.forEach(function (receiver) {
+          return receiver(plainEvent);
+        });
+      }
+
+      return state;
+    },
+    getInitialState: function getInitialState() {
+      return {
+        canceled: false,
+        receivers: new Set(),
+        dispose: undefined
+      };
+    },
+    getSnapshot: function getSnapshot() {
+      return undefined;
+    }
+  };
+  return behavior;
+}
+function fromPromise(lazyPromise) {
+  var resolveEventType = '$$xstate.resolve';
+  var rejectEventType = '$$xstate.reject'; // TODO: add event types
+
+  var behavior = {
+    transition: function transition(state, event) {
+      var _event = toSCXMLEvent(event);
+
+      if (state.canceled) {
+        return state;
+      }
+
+      var eventObject = _event.data;
+
+      switch (_event.name) {
+        case resolveEventType:
+          state.status = 'done';
+          state.data = eventObject.data;
+          return state;
+
+        case rejectEventType:
+          state.status = 'error';
+          state.data = eventObject.data;
+          return state;
+
+        case stopSignalType:
+          state.canceled = true;
+          return state;
+
+        default:
+          return state;
+      }
+    },
+    start: function start(state, _ref3) {
+      var self = _ref3.self;
+      var resolvedPromise = Promise.resolve(lazyPromise());
+      resolvedPromise.then(function (response) {
+        self.send({
+          type: resolveEventType,
+          data: response
+        });
+      }, function (errorData) {
+        self.send({
+          type: rejectEventType,
+          data: errorData
+        });
+      });
+      return state;
+    },
+    getInitialState: function getInitialState() {
+      return {
+        canceled: false,
+        status: 'active',
+        data: undefined
+      };
+    },
+    getSnapshot: function getSnapshot(state) {
+      return state.data;
+    },
+    getStatus: function getStatus(state) {
+      return state;
+    }
+  };
+  return behavior;
+}
+function fromObservable(lazyObservable) {
+  var nextEventType = '$$xstate.next';
+  var errorEventType = '$$xstate.error';
+  var completeEventType = '$$xstate.complete'; // TODO: add event types
+
+  var behavior = {
+    transition: function transition(state, event, _ref4) {
+      var self = _ref4.self,
+          id = _ref4.id,
+          defer = _ref4.defer;
+
+      var _event = toSCXMLEvent(event);
+
+      if (state.canceled) {
+        return state;
+      }
+
+      switch (_event.name) {
+        case nextEventType:
+          state.data = event.data.data; // match the exact timing of events sent by machines
+          // send actions are not executed immediately
+
+          defer(function () {
+            var _self$_parent4;
+
+            (_self$_parent4 = self._parent) === null || _self$_parent4 === void 0 ? void 0 : _self$_parent4.send(toSCXMLEvent({
+              type: "xstate.snapshot.".concat(id),
+              data: _event.data.data
+            }, {
+              origin: self
+            }));
+          });
+          return state;
+
+        case errorEventType:
+          state.status = 'error';
+          state.data = _event.data.data;
+          return state;
+
+        case completeEventType:
+          state.status = 'done';
+          return state;
+
+        case stopSignalType:
+          state.canceled = true;
+          state.subscription.unsubscribe();
+          return state;
+
+        default:
+          return state;
+      }
+    },
+    getInitialState: function getInitialState() {
+      return {
+        subscription: undefined,
+        canceled: false,
+        status: 'active',
+        data: undefined
+      };
+    },
+    start: function start(state, _ref5) {
+      var self = _ref5.self;
+      state.subscription = lazyObservable().subscribe({
+        next: function next(value) {
+          self.send({
+            type: nextEventType,
+            data: value
+          });
+        },
+        error: function error(err) {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: function complete() {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+      return state;
+    },
+    getSnapshot: function getSnapshot(state) {
+      return state.data;
+    },
+    getStatus: function getStatus(state) {
+      return state;
+    }
+  };
+  return behavior;
+}
+/**
+ * Creates an event observable behavior that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns An event observable behavior
+ */
+
+function fromEventObservable(lazyObservable) {
+  var errorEventType = '$$xstate.error';
+  var completeEventType = '$$xstate.complete'; // TODO: event types
+
+  var behavior = {
+    transition: function transition(state, event) {
+      var _event = toSCXMLEvent(event);
+
+      if (state.canceled) {
+        return state;
+      }
+
+      switch (_event.name) {
+        case errorEventType:
+          state.status = 'error';
+          state.data = _event.data.data;
+          return state;
+
+        case completeEventType:
+          state.status = 'done';
+          return state;
+
+        case stopSignalType:
+          state.canceled = true;
+          state.subscription.unsubscribe();
+          return state;
+
+        default:
+          return state;
+      }
+    },
+    getInitialState: function getInitialState() {
+      return {
+        subscription: undefined,
+        canceled: false,
+        status: 'active',
+        data: undefined
+      };
+    },
+    start: function start(state, _ref6) {
+      var self = _ref6.self;
+      state.subscription = lazyObservable().subscribe({
+        next: function next(value) {
+          var _self$_parent5;
+
+          (_self$_parent5 = self._parent) === null || _self$_parent5 === void 0 ? void 0 : _self$_parent5.send(toSCXMLEvent(value, {
+            origin: self
+          }));
+        },
+        error: function error(err) {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: function complete() {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+      return state;
+    },
+    getSnapshot: function getSnapshot(_) {
+      return undefined;
+    },
+    getStatus: function getStatus(state) {
+      return state;
+    }
+  };
+  return behavior;
+}
+function isActorRef(item) {
+  return !!item && _typeof(item) === 'object' && typeof item.send === 'function';
+} // TODO: refactor the return type, this could be written in a better way
+// but it's best to avoid unneccessary breaking changes now
+// @deprecated use `interpret(behavior)` instead
+
+function toActorRef(actorRefLike) {
+  var _objectSpread2$1;
+
+  return _objectSpread2((_objectSpread2$1 = {
+    subscribe: function subscribe() {
+      return {
+        unsubscribe: function unsubscribe() {
+          return void 0;
+        }
+      };
+    },
+    id: 'anonymous',
+    getSnapshot: function getSnapshot() {
+      return undefined;
+    }
+  }, _defineProperty(_objectSpread2$1, symbolObservable, function () {
+    return this;
+  }), _defineProperty(_objectSpread2$1, "status", exports.ActorStatus.Running), _objectSpread2$1), actorRefLike);
+}
+
+var Mailbox = /*#__PURE__*/function () {
+  function Mailbox(_process) {
+    _classCallCheck(this, Mailbox);
+
+    this._process = _process;
+
+    _defineProperty(this, "_active", false);
+
+    _defineProperty(this, "_current", null);
+
+    _defineProperty(this, "_last", null);
+  }
+
+  _createClass(Mailbox, [{
+    key: "start",
+    value: function start() {
+      this._active = true;
+      this.flush();
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      // we can't set _current to null because we might be currently processing
+      // and enqueue following clear shouldnt start processing the enqueued item immediately
+      if (this._current) {
+        this._current.next = null;
+        this._last = this._current;
+      }
+    } // TODO: rethink this design
+
+  }, {
+    key: "prepend",
+    value: function prepend(event) {
+      if (!this._current) {
+        this.enqueue(event);
+        return;
+      } // we know that something is already queued up
+      // so the mailbox is already flushing or it's inactive
+      // therefore the only thing that we need to do is to reassign `this._current`
+
+
+      this._current = {
+        value: event,
+        next: this._current
+      };
+    }
+  }, {
+    key: "enqueue",
+    value: function enqueue(event) {
+      var enqueued = {
+        value: event,
+        next: null
+      };
+
+      if (this._current) {
+        this._last.next = enqueued;
+        this._last = enqueued;
+        return;
+      }
+
+      this._current = enqueued;
+      this._last = enqueued;
+
+      if (this._active) {
+        this.flush();
+      }
+    }
+  }, {
+    key: "flush",
+    value: function flush() {
+      while (this._current) {
+        // atm the given _process is responsible for implementing proper try/catch handling
+        // we assume here that this won't throw in a way that can affect this mailbox
+        var consumed = this._current;
+
+        this._process(consumed.value); // something could have been prepended in the meantime
+        // so we need to be defensive here to avoid skipping over a prepended item
+
+
+        if (consumed === this._current) {
+          this._current = this._current.next;
+        }
+      }
+
+      this._last = null;
+    }
+  }]);
+
+  return Mailbox;
+}();
+
+var children = new Map();
+var sessionIdIndex = 0;
+var registry = {
+  bookId: function bookId() {
+    return "x:".concat(sessionIdIndex++);
+  },
+  register: function register(id, actor) {
+    children.set(id, actor);
+    return id;
+  },
+  get: function get(id) {
+    return children.get(id);
+  },
+  free: function free(id) {
+    children["delete"](id);
+  }
+};
+
+var cache = new WeakMap();
+function memo(object, key, fn) {
+  var memoizedData = cache.get(object);
+
+  if (!memoizedData) {
+    memoizedData = _defineProperty({}, key, fn());
+    cache.set(object, memoizedData);
+  } else if (!(key in memoizedData)) {
+    memoizedData[key] = fn();
+  }
+
+  return memoizedData[key];
+}
+function evict(object, key) {
+  if (!key) {
+    return void cache["delete"](object);
+  }
+
+  var memoizedData = cache.get(object);
+
+  if (memoizedData) {
+    delete memoizedData[key];
+  }
+}
+
+(function (ActorStatus) {
+  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
+  ActorStatus[ActorStatus["Running"] = 1] = "Running";
+  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
+})(exports.ActorStatus || (exports.ActorStatus = {}));
+
+var defaultOptions = {
+  deferEvents: true,
+  clock: {
+    setTimeout: function (_setTimeout) {
+      function setTimeout(_x, _x2) {
+        return _setTimeout.apply(this, arguments);
+      }
+
+      setTimeout.toString = function () {
+        return _setTimeout.toString();
+      };
+
+      return setTimeout;
+    }(function (fn, ms) {
+      return setTimeout(fn, ms);
+    }),
+    clearTimeout: function (_clearTimeout) {
+      function clearTimeout(_x3) {
+        return _clearTimeout.apply(this, arguments);
+      }
+
+      clearTimeout.toString = function () {
+        return _clearTimeout.toString();
+      };
+
+      return clearTimeout;
+    }(function (id) {
+      return clearTimeout(id);
+    })
+  },
+  logger: console.log.bind(console),
+  devTools: false
+};
+var Interpreter = /*#__PURE__*/function () {
+  /**
+   * The current state of the interpreted behavior.
+   */
+
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+   */
+
+  /**
+   * The unique identifier for this actor relative to its parent.
+   */
+
+  /**
+   * Whether the service is started.
+   */
+  // Actor Ref
+
+  /**
+   * The globally unique process ID for this invocation.
+   */
+  // TODO: remove
+
+  /**
+   * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+   *
+   * @param behavior The behavior to be interpreted
+   * @param options Interpreter options
+   */
+  function Interpreter(behavior, options) {
+    var _this = this;
+
+    _classCallCheck(this, Interpreter);
+
+    this.behavior = behavior;
+
+    _defineProperty(this, "_state", void 0);
+
+    _defineProperty(this, "clock", void 0);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "mailbox", new Mailbox(this._process.bind(this)));
+
+    _defineProperty(this, "delayedEventsMap", {});
+
+    _defineProperty(this, "observers", new Set());
+
+    _defineProperty(this, "logger", void 0);
+
+    _defineProperty(this, "status", exports.ActorStatus.NotStarted);
+
+    _defineProperty(this, "_parent", void 0);
+
+    _defineProperty(this, "ref", void 0);
+
+    _defineProperty(this, "_actorContext", void 0);
+
+    _defineProperty(this, "sessionId", void 0);
+
+    _defineProperty(this, "_forwardTo", new Set());
+
+    _defineProperty(this, "_deferred", []);
+
+    var resolvedOptions = _objectSpread2(_objectSpread2({}, defaultOptions), options);
+
+    var clock = resolvedOptions.clock,
+        logger = resolvedOptions.logger,
+        parent = resolvedOptions.parent,
+        id = resolvedOptions.id;
+    var self = this; // TODO: this should come from a "system"
+
+    this.sessionId = registry.bookId();
+    this.id = id !== null && id !== void 0 ? id : this.sessionId;
+    this.logger = logger;
+    this.clock = clock;
+    this._parent = parent;
+    this.options = resolvedOptions;
+    this.ref = this;
+    this._actorContext = {
+      self: self,
+      id: this.id,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      defer: function defer(fn) {
+        _this._deferred.push(fn);
+      }
+    }; // Ensure that the send method is bound to this interpreter instance
+    // if destructured
+
+    this.send = this.send.bind(this);
+  } // array of functions to defer
+
+
+  _createClass(Interpreter, [{
+    key: "_getInitialState",
+    value: function _getInitialState() {
+      var _this2 = this;
+
+      return memo(this, 'initial', function () {
+        return _this2.behavior.getInitialState(_this2._actorContext);
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(state) {
+      var _this$behavior$getSta, _this$behavior, _this$_parent, _this$_parent2;
+
+      // Update state
+      this._state = state;
+      var snapshot = this.getSnapshot(); // Execute deferred effects
+
+      var deferredFn;
+
+      while (deferredFn = this._deferred.shift()) {
+        deferredFn(state);
+      }
+
+      var _iterator = _createForOfIteratorHelper(this.observers),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _observer2$next;
+
+          var _observer2 = _step.value;
+          (_observer2$next = _observer2.next) === null || _observer2$next === void 0 ? void 0 : _observer2$next.call(_observer2, snapshot);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      var status = (_this$behavior$getSta = (_this$behavior = this.behavior).getStatus) === null || _this$behavior$getSta === void 0 ? void 0 : _this$behavior$getSta.call(_this$behavior, state);
+
+      switch (status === null || status === void 0 ? void 0 : status.status) {
+        case 'done':
+          (_this$_parent = this._parent) === null || _this$_parent === void 0 ? void 0 : _this$_parent.send(toSCXMLEvent(doneInvoke(this.id, status.data), {
+            origin: this,
+            invokeid: this.id
+          }));
+
+          this._stop();
+
+          break;
+
+        case 'error':
+          (_this$_parent2 = this._parent) === null || _this$_parent2 === void 0 ? void 0 : _this$_parent2.send(toSCXMLEvent(error$1(this.id, status.data), {
+            origin: this
+          }));
+
+          var _iterator2 = _createForOfIteratorHelper(this.observers),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var _observer$error;
+
+              var _observer = _step2.value;
+              (_observer$error = _observer.error) === null || _observer$error === void 0 ? void 0 : _observer$error.call(_observer, status.data);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          break;
+      }
+    }
+    /*
+     * Adds a listener that is notified whenever a state transition happens. The listener is called with
+     * the next state and the event object that caused the state transition.
+     *
+     * @param listener The state listener
+     * @deprecated Use .subscribe(listener) instead
+     */
+
+  }, {
+    key: "onTransition",
+    value: function onTransition(listener) {
+      var observer = toObserver(listener);
+      this.observers.add(observer); // Send current state to listener
+
+      if (this.status === exports.ActorStatus.Running) {
+        var _observer$next;
+
+        (_observer$next = observer.next) === null || _observer$next === void 0 ? void 0 : _observer$next.call(observer, this.getSnapshot());
+      }
+
+      return this;
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(nextListenerOrObserver, errorListener, completeListener) {
+      var _this3 = this;
+
+      var observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+      this.observers.add(observer); // Send current state to listener
+
+      if (this.status !== exports.ActorStatus.NotStarted) {
+        var _observer$next2;
+
+        (_observer$next2 = observer.next) === null || _observer$next2 === void 0 ? void 0 : _observer$next2.call(observer, this.getSnapshot());
+      }
+
+      if (this.status === exports.ActorStatus.Stopped) {
+        var _observer$complete;
+
+        (_observer$complete = observer.complete) === null || _observer$complete === void 0 ? void 0 : _observer$complete.call(observer);
+        this.observers["delete"](observer);
+      }
+
+      return {
+        unsubscribe: function unsubscribe() {
+          _this3.observers["delete"](observer);
+        }
+      };
+    }
+    /**
+     * Adds a state listener that is notified when the statechart has reached its final state.
+     * @param listener The state listener
+     */
+
+  }, {
+    key: "onDone",
+    value: function onDone(listener) {
+      var _this4 = this;
+
+      this.observers.add({
+        complete: function complete() {
+          var snapshot = _this4.getSnapshot();
+
+          if (snapshot.done) {
+            listener(doneInvoke(_this4.id, snapshot.output));
+          }
+        }
+      });
+      return this;
+    }
+    /**
+     * Starts the interpreter from the given state, or the initial state.
+     * @param initialState The state to start the statechart from
+     */
+
+  }, {
+    key: "start",
+    value: function start( // TODO: remove this argument
+    initialState) {
+      var _this$behavior$restor, _this$behavior2, _this$_getInitialStat;
+
+      if (this.status === exports.ActorStatus.Running) {
+        // Do not restart the service if it is already started
+        return this;
+      }
+
+      registry.register(this.sessionId, this.ref);
+      this.status = exports.ActorStatus.Running;
+      var resolvedState = initialState ? (_this$behavior$restor = (_this$behavior2 = this.behavior).restoreState) === null || _this$behavior$restor === void 0 ? void 0 : _this$behavior$restor.call(_this$behavior2, initialState, this._actorContext) : (_this$_getInitialStat = this._getInitialState()) !== null && _this$_getInitialStat !== void 0 ? _this$_getInitialStat : undefined;
+
+      if (this.behavior.start) {
+        resolvedState = this.behavior.start(resolvedState, this._actorContext);
+      } // TODO: this notifies all subscribers but usually this is redundant
+      // if we are using the initialState as `resolvedState` then there is no real change happening here
+      // we need to rethink if this needs to be refactored
+
+
+      this.update(resolvedState);
+
+      if (this.options.devTools) {
+        this.attachDevTools();
+      }
+
+      this.mailbox.start();
+      return this;
+    }
+  }, {
+    key: "_process",
+    value: function _process(event) {
+      this.forward(event);
+
+      try {
+        var nextState = this.behavior.transition(this._state, event, this._actorContext);
+        this.update(nextState);
+
+        if (event.name === stopSignalType) {
+          this._stop();
+        }
+      } catch (err) {
+        // TODO: properly handle errors
+        if (this.observers.size > 0) {
+          this.observers.forEach(function (observer) {
+            var _observer$error2;
+
+            (_observer$error2 = observer.error) === null || _observer$error2 === void 0 ? void 0 : _observer$error2.call(observer, err);
+          });
+          this.stop();
+        } else {
+          throw err;
+        }
+      }
+    }
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     */
+
+  }, {
+    key: "stop",
+    value: function stop() {
+      evict(this, 'initial');
+
+      if (this.status === exports.ActorStatus.Stopped) {
+        return this;
+      }
+
+      this.mailbox.clear();
+
+      if (this.status === exports.ActorStatus.NotStarted) {
+        this.status = exports.ActorStatus.Stopped;
+        return this;
+      }
+
+      this.mailbox.enqueue(toSCXMLEvent({
+        type: stopSignalType
+      }));
+      return this;
+    }
+  }, {
+    key: "_complete",
+    value: function _complete() {
+      var _iterator3 = _createForOfIteratorHelper(this.observers),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _observer3$complete;
+
+          var _observer3 = _step3.value;
+          (_observer3$complete = _observer3.complete) === null || _observer3$complete === void 0 ? void 0 : _observer3$complete.call(_observer3);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      this.observers.clear();
+    }
+  }, {
+    key: "_stop",
+    value: function _stop() {
+      this._complete();
+
+      if (this.status !== exports.ActorStatus.Running) {
+        // Interpreter already stopped; do nothing
+        return this;
+      } // Cancel all delayed events
+
+
+      for (var _i = 0, _Object$keys = Object.keys(this.delayedEventsMap); _i < _Object$keys.length; _i++) {
+        var key = _Object$keys[_i];
+        this.clock.clearTimeout(this.delayedEventsMap[key]);
+      } // TODO: mailbox.reset
+
+
+      this.mailbox.clear(); // TODO: after `stop` we must prepare ourselves for receiving events again
+      // events sent *after* stop signal must be queued
+      // it seems like this should be the common behavior for all of our consumers
+      // so perhaps this should be unified somehow for all of them
+
+      this.mailbox = new Mailbox(this._process.bind(this));
+      this.status = exports.ActorStatus.Stopped;
+      registry.free(this.sessionId);
+      return this;
+    }
+    /**
+     * Sends an event to the running interpreter to trigger a transition.
+     *
+     * An array of events (batched) can be sent as well, which will send all
+     * batched events to the running interpreter. The listeners will be
+     * notified only **once** when all events are processed.
+     *
+     * @param event The event(s) to send
+     */
+
+  }, {
+    key: "send",
+    value: function send(event) {
+      var _event = toSCXMLEvent(event);
+
+      if (this.status === exports.ActorStatus.Stopped) {
+
+        return;
+      }
+
+      if (this.status !== exports.ActorStatus.Running && !this.options.deferEvents) {
+        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized actor \"").concat(this.id // tslint:disable-next-line:max-line-length
+        , "\". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ").concat(JSON.stringify(_event.data)));
+      }
+
+      this.mailbox.enqueue(_event);
+    } // TODO: remove
+
+  }, {
+    key: "forward",
+    value: function forward(event) {
+      // The _forwardTo set will be empty for non-machine actors anyway
+      var _iterator4 = _createForOfIteratorHelper(this._forwardTo),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var child = _step4.value;
+          child.send(event);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    } // TODO: make private (and figure out a way to do this within the machine)
+
+  }, {
+    key: "delaySend",
+    value: function delaySend(sendAction) {
+      var _this5 = this;
+
+      this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(function () {
+        if (sendAction.params.to) {
+          sendAction.params.to.send(sendAction.params._event);
+        } else {
+          _this5.send(sendAction.params._event);
+        }
+      }, sendAction.params.delay);
+    } // TODO: make private (and figure out a way to do this within the machine)
+
+  }, {
+    key: "cancel",
+    value: function cancel(sendId) {
+      this.clock.clearTimeout(this.delayedEventsMap[sendId]);
+      delete this.delayedEventsMap[sendId];
+    }
+  }, {
+    key: "attachDevTools",
+    value: function attachDevTools() {
+      var devTools = this.options.devTools;
+
+      if (devTools) {
+        var resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
+        resolvedDevToolsAdapter(this);
+      }
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        id: this.id
+      };
+    }
+  }, {
+    key: symbolObservable,
+    value: function value() {
+      return this;
+    }
+  }, {
+    key: "getSnapshot",
+    value: function getSnapshot() {
+      var _this$behavior$getSna;
+
+      var getter = (_this$behavior$getSna = this.behavior.getSnapshot) !== null && _this$behavior$getSna !== void 0 ? _this$behavior$getSna : function (s) {
+        return s;
+      };
+
+      if (this.status === exports.ActorStatus.NotStarted) {
+        return getter(this._getInitialState());
+      }
+
+      return getter(this._state);
+    }
+  }]);
+
+  return Interpreter;
+}();
+/**
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to interpret
+ * @param options Interpreter options
+ */
+
+function interpret(behavior, options) {
+  var interpreter = new Interpreter(behavior, options);
+  return interpreter;
+}
+
+/**
+ * Stops an actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+
+function stop$1(actorRef) {
+  var actor = actorRef;
+  return createDynamicAction({
+    type: stop,
+    params: {
+      actor: actor
+    }
+  }, function (_event, _ref) {
+    var state = _ref.state;
+    var actorRefOrString = isFunction(actor) ? actor(state.context, _event.data) : actor;
+    var actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
+    return [state, {
+      type: 'xstate.stop',
+      params: {
+        actor: actorRef
+      },
+      execute: function execute(actorCtx) {
+        if (!actorRef) {
+          return;
+        }
+
+        if (actorRef.status !== exports.ActorStatus.Running) {
+          var _actorRef$stop;
+
+          (_actorRef$stop = actorRef.stop) === null || _actorRef$stop === void 0 ? void 0 : _actorRef$stop.call(actorRef);
+          return;
+        }
+
+        actorCtx.defer(function () {
+          var _actorRef$stop2;
+
+          (_actorRef$stop2 = actorRef.stop) === null || _actorRef$stop2 === void 0 ? void 0 : _actorRef$stop2.call(actorRef);
+        });
+      }
+    }];
+  });
+}
+
+var defaultLogExpr = function defaultLogExpr(context, event) {
+  return {
+    context: context,
+    event: event
+  };
+};
+/**
+ *
+ * @param expr The expression function to evaluate which will be logged.
+ *  Takes in 2 arguments:
+ *  - `ctx` - the current state context
+ *  - `event` - the event that caused this action to be executed.
+ * @param label The label to give to the logged expression.
+ */
+
+
+function log$1() {
+  var expr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultLogExpr;
+  var label = arguments.length > 1 ? arguments[1] : undefined;
+  return createDynamicAction({
+    type: log,
+    params: {
+      label: label,
+      expr: expr
+    }
+  }, function (_event, _ref) {
+    var state = _ref.state;
+    var resolvedValue = typeof expr === 'function' ? expr(state.context, _event.data, {
+      _event: _event
+    }) : expr;
+    return [state, {
+      type: 'xstate.log',
+      params: {
+        label: label,
+        value: resolvedValue
+      },
+      execute: function execute(actorCtx) {
+        if (label) {
+          var _actorCtx$logger;
+
+          (_actorCtx$logger = actorCtx.logger) === null || _actorCtx$logger === void 0 ? void 0 : _actorCtx$logger.call(actorCtx, label, resolvedValue);
+        } else {
+          var _actorCtx$logger2;
+
+          (_actorCtx$logger2 = actorCtx.logger) === null || _actorCtx$logger2 === void 0 ? void 0 : _actorCtx$logger2.call(actorCtx, resolvedValue);
+        }
+      }
+    }];
+  });
+}
+
+/**
+ * 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$1(sendId) {
+  return createDynamicAction({
+    type: cancel,
+    params: {
+      sendId: sendId
+    }
+  }, function (_event, _ref) {
+    var state = _ref.state;
+    var resolvedSendId = isFunction(sendId) ? sendId(state.context, _event.data, {
+      _event: _event
+    }) : sendId;
+    return [state, {
+      type: 'xstate.cancel',
+      params: {
+        sendId: resolvedSendId
+      },
+      execute: function execute(actorCtx) {
+        var interpreter = actorCtx.self;
+        interpreter.cancel(resolvedSendId);
+      }
+    }];
+  });
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+function stateIn(stateValue) {
+  return {
+    type: 'xstate.guard:in',
+    params: {
+      stateValue: stateValue
+    },
+    predicate: function predicate(_, __, _ref) {
+      var state = _ref.state;
+
+      if (isString(stateValue) && isStateId(stateValue)) {
+        return state.configuration.some(function (sn) {
+          return sn.id === stateValue.slice(1);
+        });
+      }
+
+      return state.matches(stateValue);
+    }
+  };
+}
+function not(guard) {
+  return {
+    type: 'xstate.boolean',
+    params: {
+      op: 'not'
+    },
+    children: [toGuardDefinition(guard)],
+    predicate: function predicate(ctx, _, meta) {
+      return !meta.evaluate(meta.guard.children[0], ctx, meta._event, meta.state, meta.state.machine);
+    }
+  };
+}
+function and(guards) {
+  return {
+    type: 'xstate.boolean',
+    params: {
+      op: 'and'
+    },
+    children: guards.map(function (guard) {
+      return toGuardDefinition(guard);
+    }),
+    predicate: function predicate(ctx, _, meta) {
+      return meta.guard.children.every(function (childGuard) {
+        return meta.evaluate(childGuard, ctx, meta._event, meta.state, meta.state.machine);
+      });
+    }
+  };
+}
+function or(guards) {
+  return {
+    type: 'xstate.boolean',
+    params: {
+      op: 'or'
+    },
+    children: guards.map(function (guard) {
+      return toGuardDefinition(guard);
+    }),
+    predicate: function predicate(ctx, _, meta) {
+      return meta.guard.children.some(function (childGuard) {
+        return meta.evaluate(childGuard, ctx, meta._event, meta.state, meta.state.machine);
+      });
+    }
+  };
+}
+function evaluateGuard(guard, context, _event, state) {
+  var _machine$options$guar, _machine$options, _machine$options$guar2;
+
+  var machine = state.machine;
+  var guardMeta = {
+    state: state,
+    guard: guard,
+    _event: _event,
+    evaluate: evaluateGuard
+  };
+  var predicate = (_machine$options$guar = machine === null || machine === void 0 ? void 0 : (_machine$options = machine.options) === null || _machine$options === void 0 ? void 0 : (_machine$options$guar2 = _machine$options.guards) === null || _machine$options$guar2 === void 0 ? void 0 : _machine$options$guar2[guard.type]) !== null && _machine$options$guar !== void 0 ? _machine$options$guar : guard.predicate;
+
+  if (!predicate) {
+    throw new Error("Guard '".concat(guard.type, "' is not implemented.'."));
+  }
+
+  return predicate(context, _event.data, guardMeta);
+}
+function toGuardDefinition(guardConfig, getPredicate) {
+  var _guardConfig$children;
+
+  if (isString(guardConfig)) {
+    return {
+      type: guardConfig,
+      predicate: (getPredicate === null || getPredicate === void 0 ? void 0 : getPredicate(guardConfig)) || undefined,
+      params: {
+        type: guardConfig
+      }
+    };
+  }
+
+  if (isFunction(guardConfig)) {
+    return {
+      type: guardConfig.name,
+      predicate: guardConfig,
+      params: {
+        type: guardConfig.name,
+        name: guardConfig.name
+      }
+    };
+  }
+
+  return {
+    type: guardConfig.type,
+    params: guardConfig.params || guardConfig,
+    children: (_guardConfig$children = guardConfig.children) === null || _guardConfig$children === void 0 ? void 0 : _guardConfig$children.map(function (childGuard) {
+      return toGuardDefinition(childGuard, getPredicate);
+    }),
+    predicate: (getPredicate === null || getPredicate === void 0 ? void 0 : getPredicate(guardConfig.type)) || guardConfig.predicate
+  };
+}
+
+function getOutput(configuration, context, _event) {
+  var machine = configuration[0].machine;
+  var finalChildStateNode = configuration.find(function (stateNode) {
+    return stateNode.type === 'final' && stateNode.parent === machine.root;
+  });
+  var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, context, _event) : undefined;
+  return doneData;
+}
+
+var isAtomicStateNode = function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+};
+
+function getChildren(stateNode) {
+  return Object.values(stateNode.states).filter(function (sn) {
+    return sn.type !== 'history';
+  });
+}
+
+function getProperAncestors(stateNode, toStateNode) {
+  var ancestors = []; // add all ancestors
+
+  var m = stateNode.parent;
+
+  while (m && m !== toStateNode) {
+    ancestors.push(m);
+    m = m.parent;
+  }
+
+  return ancestors;
+}
+
+function getConfiguration(stateNodes) {
+  var configuration = new Set(stateNodes);
+  var configurationSet = new Set(stateNodes);
+  var adjList = getAdjList(configurationSet); // add descendants
+
+  var _iterator = _createForOfIteratorHelper(configuration),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var s = _step.value;
+
+      // if previously active, add existing child nodes
+      if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
+        getInitialStateNodes(s).forEach(function (sn) {
+          return configurationSet.add(sn);
+        });
+      } else {
+        if (s.type === 'parallel') {
+          var _iterator3 = _createForOfIteratorHelper(getChildren(s)),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var child = _step3.value;
+
+              if (child.type === 'history') {
+                continue;
+              }
+
+              if (!configurationSet.has(child)) {
+                var _iterator4 = _createForOfIteratorHelper(getInitialStateNodes(child)),
+                    _step4;
+
+                try {
+                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                    var initialStateNode = _step4.value;
+                    configurationSet.add(initialStateNode);
+                  }
+                } catch (err) {
+                  _iterator4.e(err);
+                } finally {
+                  _iterator4.f();
+                }
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+    } // add all ancestors
+
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var _iterator2 = _createForOfIteratorHelper(configurationSet),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _s = _step2.value;
+      var m = _s.parent;
+
+      while (m) {
+        configurationSet.add(m);
+        m = m.parent;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return configurationSet;
+}
+
+function getValueFromAdj(baseNode, adjList) {
+  var childStateNodes = adjList.get(baseNode);
+
+  if (!childStateNodes) {
+    return {}; // todo: fix?
+  }
+
+  if (baseNode.type === 'compound') {
+    var childStateNode = childStateNodes[0];
+
+    if (childStateNode) {
+      if (isAtomicStateNode(childStateNode)) {
+        return childStateNode.key;
+      }
+    } else {
+      return {};
+    }
+  }
+
+  var stateValue = {};
+
+  var _iterator5 = _createForOfIteratorHelper(childStateNodes),
+      _step5;
+
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _childStateNode = _step5.value;
+      stateValue[_childStateNode.key] = getValueFromAdj(_childStateNode, adjList);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+
+  return stateValue;
+}
+
+function getAdjList(configuration) {
+  var adjList = new Map();
+
+  var _iterator6 = _createForOfIteratorHelper(configuration),
+      _step6;
+
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var s = _step6.value;
+
+      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);
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+
+  return adjList;
+}
+function getStateValue(rootNode, configuration) {
+  var config = getConfiguration(configuration);
+  return getValueFromAdj(rootNode, getAdjList(config));
+}
+function isInFinalState(configuration) {
+  var stateNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : configuration[0].machine.root;
+
+  if (stateNode.type === 'compound') {
+    return getChildren(stateNode).some(function (s) {
+      return s.type === 'final' && configuration.includes(s);
+    });
+  }
+
+  if (stateNode.type === 'parallel') {
+    return getChildren(stateNode).every(function (sn) {
+      return isInFinalState(configuration, sn);
+    });
+  }
+
+  return false;
+}
+var isStateId = function isStateId(str) {
+  return str[0] === STATE_IDENTIFIER;
+};
+function getCandidates(stateNode, receivedEventType) {
+  var partialMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var candidates = stateNode.transitions.filter(function (transition) {
+    var eventType = transition.eventType; // First, check the trivial case: event names are exactly equal
+
+    if (eventType === receivedEventType) {
+      return true;
+    } // Then, check if transition is a wildcard transition,
+    // which matches any non-transient events
+
+
+    if (eventType === WILDCARD) {
+      return true;
+    }
+
+    if (!partialMatch && !eventType.endsWith('.*')) {
+      return false;
+    }
+
+    var partialEventTokens = eventType.split('.');
+    var eventTokens = receivedEventType.split('.');
+
+    for (var tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+      var partialEventToken = partialEventTokens[tokenIndex];
+      var eventToken = eventTokens[tokenIndex];
+
+      if (partialEventToken === '*') {
+        var isLastToken = tokenIndex === partialEventTokens.length - 1;
+
+        return isLastToken;
+      }
+
+      if (partialEventToken !== eventToken) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+  return candidates;
+}
+/**
+ * All delayed transitions from the config.
+ */
+
+function getDelayedTransitions(stateNode) {
+  var afterConfig = stateNode.config.after;
+
+  if (!afterConfig) {
+    return [];
+  }
+
+  var mutateEntryExit = function mutateEntryExit(delay, i) {
+    var delayRef = isFunction(delay) ? "".concat(stateNode.id, ":delay[").concat(i, "]") : delay;
+    var eventType = after$1(delayRef, stateNode.id);
+    stateNode.entry.push(send$1({
+      type: eventType
+    }, {
+      delay: delay
+    }));
+    stateNode.exit.push(cancel$1(eventType));
+    return eventType;
+  };
+
+  var delayedTransitions = isArray(afterConfig) ? afterConfig.map(function (transition, i) {
+    var eventType = mutateEntryExit(transition.delay, i);
+    return _objectSpread2(_objectSpread2({}, transition), {}, {
+      event: eventType
+    });
+  }) : Object.keys(afterConfig).flatMap(function (delay, i) {
+    var configTransition = afterConfig[delay];
+    var resolvedTransition = isString(configTransition) ? {
+      target: configTransition
+    } : configTransition;
+    var resolvedDelay = !isNaN(+delay) ? +delay : delay;
+    var eventType = mutateEntryExit(resolvedDelay, i);
+    return toArray(resolvedTransition).map(function (transition) {
+      return _objectSpread2(_objectSpread2({}, transition), {}, {
+        event: eventType,
+        delay: resolvedDelay
+      });
+    });
+  });
+  return delayedTransitions.map(function (delayedTransition) {
+    var delay = delayedTransition.delay;
+    return _objectSpread2(_objectSpread2({}, formatTransition(stateNode, delayedTransition)), {}, {
+      delay: delay
+    });
+  });
+}
+function formatTransition(stateNode, transitionConfig) {
+  var normalizedTarget = normalizeTarget(transitionConfig.target);
+  var internal = stateNode === stateNode.machine.root ? true // always internal for root
+  : 'internal' in transitionConfig ? transitionConfig.internal : normalizedTarget ? normalizedTarget.some(function (_target) {
+    return isString(_target) && _target[0] === stateNode.machine.delimiter;
+  }) : true;
+  var guards = stateNode.machine.options.guards;
+  var target = resolveTarget(stateNode, normalizedTarget); // TODO: should this be part of a lint rule instead?
+
+  var transition = _objectSpread2(_objectSpread2({}, transitionConfig), {}, {
+    actions: toActionObjects(toArray(transitionConfig.actions)),
+    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, function (guardType) {
+      return guards[guardType];
+    }) : undefined,
+    target: target,
+    source: stateNode,
+    internal: internal,
+    eventType: transitionConfig.event,
+    toJSON: function toJSON() {
+      return _objectSpread2(_objectSpread2({}, transition), {}, {
+        source: "#".concat(stateNode.id),
+        target: target ? target.map(function (t) {
+          return "#".concat(t.id);
+        }) : undefined
+      });
+    }
+  });
+
+  return transition;
+}
+function formatTransitions(stateNode) {
+  var transitionConfigs = [];
+
+  if (Array.isArray(stateNode.config.on)) {
+    transitionConfigs.push.apply(transitionConfigs, _toConsumableArray(stateNode.config.on));
+  } else if (stateNode.config.on) {
+    var _stateNode$config$on = stateNode.config.on,
+        _stateNode$config$on$ = _stateNode$config$on[WILDCARD],
+        wildcardConfigs = _stateNode$config$on$ === void 0 ? [] : _stateNode$config$on$,
+        namedTransitionConfigs = _objectWithoutProperties(_stateNode$config$on, [WILDCARD].map(_toPropertyKey));
+
+    for (var _i = 0, _Object$keys = Object.keys(namedTransitionConfigs); _i < _Object$keys.length; _i++) {
+      var eventType = _Object$keys[_i];
+
+      if (eventType === NULL_EVENT) {
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+      }
+
+      var eventTransitionConfigs = toTransitionConfigArray(eventType, namedTransitionConfigs[eventType]);
+      transitionConfigs.push.apply(transitionConfigs, _toConsumableArray(eventTransitionConfigs)); // TODO: add dev-mode validation for unreachable transitions
+    }
+
+    transitionConfigs.push.apply(transitionConfigs, _toConsumableArray(toTransitionConfigArray(WILDCARD, wildcardConfigs)));
+  }
+
+  var doneConfig = stateNode.config.onDone ? toTransitionConfigArray(String(done(stateNode.id)), stateNode.config.onDone) : [];
+  var invokeConfig = stateNode.invoke.flatMap(function (invokeDef) {
+    var settleTransitions = [];
+
+    if (invokeDef.onDone) {
+      settleTransitions.push.apply(settleTransitions, _toConsumableArray(toTransitionConfigArray("done.invoke.".concat(invokeDef.id), invokeDef.onDone)));
+    }
+
+    if (invokeDef.onError) {
+      settleTransitions.push.apply(settleTransitions, _toConsumableArray(toTransitionConfigArray("error.platform.".concat(invokeDef.id), invokeDef.onError)));
+    }
+
+    if (invokeDef.onSnapshot) {
+      settleTransitions.push.apply(settleTransitions, _toConsumableArray(toTransitionConfigArray("xstate.snapshot.".concat(invokeDef.id), invokeDef.onSnapshot)));
+    }
+
+    return settleTransitions;
+  });
+  var delayedTransitions = stateNode.after;
+  var formattedTransitions = [].concat(_toConsumableArray(doneConfig), _toConsumableArray(invokeConfig), transitionConfigs).flatMap(function (transitionConfig) {
+    return toArray(transitionConfig).map(function (transition) {
+      return formatTransition(stateNode, transition);
+    });
+  });
+
+  var _iterator7 = _createForOfIteratorHelper(delayedTransitions),
+      _step7;
+
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var delayedTransition = _step7.value;
+      formattedTransitions.push(delayedTransition);
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+
+  return formattedTransitions;
+}
+function formatInitialTransition(stateNode, _target) {
+  if (isString(_target) || isArray(_target)) {
+    var targets = toArray(_target).map(function (t) {
+      // Resolve state string keys (which represent children)
+      // to their state node
+      var descStateNode = isString(t) ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
+
+      if (!descStateNode) {
+        throw new Error("Initial state node \"".concat(t, "\" not found on parent state node #").concat(stateNode.id));
+      }
+
+      if (!isDescendant(descStateNode, stateNode)) {
+        throw new Error("Invalid initial target: state node #".concat(descStateNode.id, " is not a descendant of #").concat(stateNode.id));
+      }
+
+      return descStateNode;
+    });
+    var resolvedTarget = resolveTarget(stateNode, targets);
+    var transition = {
+      source: stateNode,
+      actions: [],
+      eventType: null,
+      target: resolvedTarget,
+      toJSON: function toJSON() {
+        return _objectSpread2(_objectSpread2({}, transition), {}, {
+          source: "#".concat(stateNode.id),
+          target: resolvedTarget ? resolvedTarget.map(function (t) {
+            return "#".concat(t.id);
+          }) : undefined
+        });
+      }
+    };
+    return transition;
+  }
+
+  return formatTransition(stateNode, {
+    target: toArray(_target.target).map(function (t) {
+      if (isString(t)) {
+        return isStateId(t) ? t : "".concat(stateNode.machine.delimiter).concat(t);
+      }
+
+      return t;
+    }),
+    actions: _target.actions,
+    event: null
+  });
+}
+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(function (target) {
+    if (!isString(target)) {
+      return target;
+    }
+
+    var isInternalTarget = target[0] === stateNode.machine.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));
+    }
+
+    var resolvedTarget = isInternalTarget ? stateNode.key + target : target;
+
+    if (stateNode.parent) {
+      try {
+        var targetStateNode = getStateNodeByPath(stateNode.parent, resolvedTarget);
+        return targetStateNode;
+      } catch (err) {
+        throw new Error("Invalid transition definition for state node '".concat(stateNode.id, "':\n").concat(err.message));
+      }
+    } else {
+      return getStateNodeByPath(stateNode, resolvedTarget);
+    }
+  });
+}
+
+function resolveHistoryTarget(stateNode) {
+  var normalizedTarget = normalizeTarget(stateNode.target);
+
+  if (!normalizedTarget) {
+    return stateNode.parent.initial.target;
+  }
+
+  return normalizedTarget.map(function (t) {
+    return typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t;
+  });
+}
+
+function isHistoryNode(stateNode) {
+  return stateNode.type === 'history';
+}
+
+function getInitialStateNodes(stateNode) {
+  var set = new Set();
+
+  function iter(descStateNode) {
+    if (set.has(descStateNode)) {
+      return;
+    }
+
+    set.add(descStateNode);
+
+    if (descStateNode.type === 'compound') {
+      var _iterator8 = _createForOfIteratorHelper(descStateNode.initial.target),
+          _step8;
+
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var targetStateNode = _step8.value;
+
+          var _iterator9 = _createForOfIteratorHelper(getProperAncestors(targetStateNode, stateNode)),
+              _step9;
+
+          try {
+            for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+              var a = _step9.value;
+              set.add(a);
+            }
+          } catch (err) {
+            _iterator9.e(err);
+          } finally {
+            _iterator9.f();
+          }
+
+          iter(targetStateNode);
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+    } else if (descStateNode.type === 'parallel') {
+      var _iterator10 = _createForOfIteratorHelper(getChildren(descStateNode)),
+          _step10;
+
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var child = _step10.value;
+          iter(child);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+    }
+  }
+
+  iter(stateNode);
+  return _toConsumableArray(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 '".concat(stateKey, "' from '").concat(stateNode.id, "'; no child states exist."));
+  }
+
+  var result = stateNode.states[stateKey];
+
+  if (!result) {
+    throw new Error("Child state '".concat(stateKey, "' does not exist on '").concat(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;
+    }
+  }
+
+  var arrayStatePath = toStatePath(statePath, stateNode.machine.delimiter).slice();
+  var currentStateNode = stateNode;
+
+  while (arrayStatePath.length) {
+    var 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) {
+  var stateValue = state instanceof State ? state.value : toStateValue(state, stateNode.machine.delimiter);
+
+  if (isString(stateValue)) {
+    return [stateNode, stateNode.states[stateValue]];
+  }
+
+  var childStateKeys = Object.keys(stateValue);
+  var childStateNodes = childStateKeys.map(function (subStateKey) {
+    return getStateNode(stateNode, subStateKey);
+  }).filter(Boolean);
+  return [stateNode.machine.root, stateNode].concat(childStateNodes, childStateKeys.reduce(function (allSubStateNodes, subStateKey) {
+    var subStateNode = getStateNode(stateNode, subStateKey);
+
+    if (!subStateNode) {
+      return allSubStateNodes;
+    }
+
+    var subStateNodes = getStateNodes(subStateNode, stateValue[subStateKey]);
+    return allSubStateNodes.concat(subStateNodes);
+  }, []));
+}
+function transitionAtomicNode(stateNode, stateValue, state, _event) {
+  var childStateNode = getStateNode(stateNode, stateValue);
+  var next = childStateNode.next(state, _event);
+
+  if (!next || !next.length) {
+    return stateNode.next(state, _event);
+  }
+
+  return next;
+}
+function transitionCompoundNode(stateNode, stateValue, state, _event) {
+  var subStateKeys = Object.keys(stateValue);
+  var childStateNode = getStateNode(stateNode, subStateKeys[0]);
+  var 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) {
+  var allInnerTransitions = [];
+
+  for (var _i2 = 0, _Object$keys2 = Object.keys(stateValue); _i2 < _Object$keys2.length; _i2++) {
+    var subStateKey = _Object$keys2[_i2];
+    var subStateValue = stateValue[subStateKey];
+
+    if (!subStateValue) {
+      continue;
+    }
+
+    var subStateNode = getStateNode(stateNode, subStateKey);
+    var innerTransitions = transitionNode(subStateNode, subStateValue, state, _event);
+
+    if (innerTransitions) {
+      allInnerTransitions.push.apply(allInnerTransitions, _toConsumableArray(innerTransitions));
+    }
+  }
+
+  if (!allInnerTransitions.length) {
+    return stateNode.next(state, _event);
+  }
+
+  return allInnerTransitions;
+}
+function transitionNode(stateNode, stateValue, state, _event) {
+  // leaf node
+  if (isString(stateValue)) {
+    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(function (key) {
+    return stateNode.states[key];
+  }).filter(function (sn) {
+    return sn.type === 'history';
+  });
+}
+
+function isDescendant(childStateNode, parentStateNode) {
+  var marker = childStateNode;
+
+  while (marker.parent && marker.parent !== parentStateNode) {
+    marker = marker.parent;
+  }
+
+  return marker.parent === parentStateNode;
+}
+
+function getPathFromRootToNode(stateNode) {
+  var path = [];
+  var marker = stateNode.parent;
+
+  while (marker) {
+    path.unshift(marker);
+    marker = marker.parent;
+  }
+
+  return path;
+}
+
+function hasIntersection(s1, s2) {
+  var set1 = new Set(s1);
+  var set2 = new Set(s2);
+
+  var _iterator11 = _createForOfIteratorHelper(set1),
+      _step11;
+
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var item = _step11.value;
+
+      if (set2.has(item)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
+
+  var _iterator12 = _createForOfIteratorHelper(set2),
+      _step12;
+
+  try {
+    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+      var _item = _step12.value;
+
+      if (set1.has(_item)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator12.e(err);
+  } finally {
+    _iterator12.f();
+  }
+
+  return false;
+}
+
+function removeConflictingTransitions(enabledTransitions, configuration, historyValue) {
+  var filteredTransitions = new Set();
+
+  var _iterator13 = _createForOfIteratorHelper(enabledTransitions),
+      _step13;
+
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var t1 = _step13.value;
+      var t1Preempted = false;
+      var transitionsToRemove = new Set();
+
+      var _iterator14 = _createForOfIteratorHelper(filteredTransitions),
+          _step14;
+
+      try {
+        for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+          var t2 = _step14.value;
+
+          if (hasIntersection(computeExitSet([t1], configuration, historyValue), computeExitSet([t2], configuration, historyValue))) {
+            if (isDescendant(t1.source, t2.source)) {
+              transitionsToRemove.add(t2);
+            } else {
+              t1Preempted = true;
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator14.e(err);
+      } finally {
+        _iterator14.f();
+      }
+
+      if (!t1Preempted) {
+        var _iterator15 = _createForOfIteratorHelper(transitionsToRemove),
+            _step15;
+
+        try {
+          for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+            var t3 = _step15.value;
+            filteredTransitions["delete"](t3);
+          }
+        } catch (err) {
+          _iterator15.e(err);
+        } finally {
+          _iterator15.f();
+        }
+
+        filteredTransitions.add(t1);
+      }
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
+  }
+
+  return Array.from(filteredTransitions);
+}
+
+function findLCCA(stateNodes) {
+  var _stateNodes = _slicedToArray(stateNodes, 1),
+      head = _stateNodes[0];
+
+  var current = getPathFromRootToNode(head);
+  var candidates = [];
+
+  var _iterator16 = _createForOfIteratorHelper(stateNodes),
+      _step16;
+
+  try {
+    var _loop = function _loop() {
+      var stateNode = _step16.value;
+      var path = getPathFromRootToNode(stateNode);
+      candidates = current.filter(function (sn) {
+        return path.includes(sn);
+      });
+      current = candidates;
+      candidates = [];
+    };
+
+    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator16.e(err);
+  } finally {
+    _iterator16.f();
+  }
+
+  return current[current.length - 1];
+}
+
+function getEffectiveTargetStates(transition, historyValue) {
+  if (!transition.target) {
+    return [];
+  }
+
+  var targets = new Set();
+
+  var _iterator17 = _createForOfIteratorHelper(transition.target),
+      _step17;
+
+  try {
+    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+      var targetNode = _step17.value;
+
+      if (isHistoryNode(targetNode)) {
+        if (historyValue[targetNode.id]) {
+          var _iterator18 = _createForOfIteratorHelper(historyValue[targetNode.id]),
+              _step18;
+
+          try {
+            for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+              var node = _step18.value;
+              targets.add(node);
+            }
+          } catch (err) {
+            _iterator18.e(err);
+          } finally {
+            _iterator18.f();
+          }
+        } else {
+          var _iterator19 = _createForOfIteratorHelper(getEffectiveTargetStates({
+            target: resolveHistoryTarget(targetNode)
+          }, historyValue)),
+              _step19;
+
+          try {
+            for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+              var _node = _step19.value;
+              targets.add(_node);
+            }
+          } catch (err) {
+            _iterator19.e(err);
+          } finally {
+            _iterator19.f();
+          }
+        }
+      } else {
+        targets.add(targetNode);
+      }
+    }
+  } catch (err) {
+    _iterator17.e(err);
+  } finally {
+    _iterator17.f();
+  }
+
+  return _toConsumableArray(targets);
+}
+
+function getTransitionDomain(transition, historyValue) {
+  var targetStates = getEffectiveTargetStates(transition, historyValue);
+
+  if (!targetStates) {
+    return null;
+  }
+
+  if (transition.internal && transition.source.type === 'compound' && targetStates.every(function (targetStateNode) {
+    return isDescendant(targetStateNode, transition.source);
+  })) {
+    return transition.source;
+  }
+
+  var lcca = findLCCA(targetStates.concat(transition.source));
+  return lcca;
+}
+
+function computeExitSet(transitions, configuration, historyValue) {
+  var statesToExit = new Set();
+
+  var _iterator20 = _createForOfIteratorHelper(transitions),
+      _step20;
+
+  try {
+    for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+      var _t$target;
+
+      var t = _step20.value;
+
+      if ((_t$target = t.target) !== null && _t$target !== void 0 && _t$target.length) {
+        var domain = getTransitionDomain(t, historyValue);
+
+        var _iterator21 = _createForOfIteratorHelper(configuration),
+            _step21;
+
+        try {
+          for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+            var stateNode = _step21.value;
+
+            if (isDescendant(stateNode, domain)) {
+              statesToExit.add(stateNode);
+            }
+          }
+        } catch (err) {
+          _iterator21.e(err);
+        } finally {
+          _iterator21.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator20.e(err);
+  } finally {
+    _iterator20.f();
+  }
+
+  return _toConsumableArray(statesToExit);
+}
+/**
+ * https://www.w3.org/TR/scxml/#microstepProcedure
+ *
+ * @private
+ * @param transitions
+ * @param currentState
+ * @param mutConfiguration
+ */
+
+
+function microstep(transitions, currentState, actorCtx, scxmlEvent) {
+  var machine = currentState.machine; // Transition will "apply" if:
+  // - the state node is the initial state (there is no current state)
+  // - OR there are transitions
+
+  var willTransition = currentState._initial || transitions.length > 0;
+  var mutConfiguration = new Set(currentState.configuration);
+
+  if (!currentState._initial && !willTransition) {
+    var inertState = cloneState(currentState, {
+      _event: scxmlEvent,
+      actions: [],
+      transitions: []
+    });
+    inertState.changed = false;
+    return inertState;
+  }
+
+  var microstate = microstepProcedure(currentState._initial ? [{
+    target: _toConsumableArray(currentState.configuration).filter(isAtomicStateNode),
+    source: machine.root,
+    actions: [],
+    eventType: null,
+    toJSON: null // TODO: fix
+
+  }] : transitions, currentState, mutConfiguration, scxmlEvent, actorCtx);
+  var context = microstate.context,
+      nonRaisedActions = microstate.actions;
+  var children = setChildren(currentState, nonRaisedActions);
+  var nextState = cloneState(microstate, {
+    value: {},
+    // TODO: make optional
+    transitions: transitions,
+    children: children
+  });
+  nextState.changed = currentState._initial ? undefined : !stateValuesEqual(nextState.value, currentState.value) || nextState.actions.length > 0 || context !== currentState.context;
+  return nextState;
+}
+
+function setChildren(currentState, nonRaisedActions) {
+  var children = _objectSpread2({}, currentState.children);
+
+  var _iterator22 = _createForOfIteratorHelper(nonRaisedActions),
+      _step22;
+
+  try {
+    for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+      var action = _step22.value;
+
+      if (action.type === invoke && action.params.ref) {
+        var ref = action.params.ref;
+
+        if (ref) {
+          children[ref.id] = ref;
+        }
+      } else if (action.type === stop) {
+        var _ref = action.params.actor;
+
+        if (_ref) {
+          delete children[_ref.id];
+        }
+      }
+    }
+  } catch (err) {
+    _iterator22.e(err);
+  } finally {
+    _iterator22.f();
+  }
+
+  return children;
+}
+
+function microstepProcedure(transitions, currentState, mutConfiguration, scxmlEvent, actorCtx) {
+  var machine = currentState.machine;
+  var actions = [];
+
+  var historyValue = _objectSpread2({}, currentState.historyValue);
+
+  var filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
+
+  var internalQueue = _toConsumableArray(currentState._internalQueue); // Exit states
+
+
+  if (!currentState._initial) {
+    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
+  } // Execute transition content
+
+
+  actions.push.apply(actions, _toConsumableArray(filteredTransitions.flatMap(function (t) {
+    return t.actions;
+  }))); // Enter states
+
+  enterStates(filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue);
+
+  var nextConfiguration = _toConsumableArray(mutConfiguration);
+
+  var done = isInFinalState(nextConfiguration);
+
+  if (done) {
+    var finalActions = nextConfiguration.sort(function (a, b) {
+      return b.order - a.order;
+    }).flatMap(function (state) {
+      return state.exit;
+    });
+    actions.push.apply(actions, _toConsumableArray(finalActions));
+  }
+
+  try {
+    var _resolveActionsAndCon = resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx),
+        nextState = _resolveActionsAndCon.nextState;
+
+    var output = done ? getOutput(nextConfiguration, nextState.context, scxmlEvent) : undefined;
+    internalQueue.push.apply(internalQueue, _toConsumableArray(nextState._internalQueue));
+    return cloneState(currentState, {
+      actions: nextState.actions,
+      configuration: nextConfiguration,
+      historyValue: historyValue,
+      _internalQueue: internalQueue,
+      context: nextState.context,
+      _event: scxmlEvent,
+      done: done,
+      output: output,
+      children: nextState.children
+    });
+  } catch (e) {
+    // TODO: Refactor this once proper error handling is implemented.
+    // See https://github.com/statelyai/rfcs/pull/4
+    if (machine.config.scxml) {
+      return cloneState(currentState, {
+        actions: [],
+        configuration: Array.from(mutConfiguration),
+        historyValue: historyValue,
+        _internalQueue: [toSCXMLEvent({
+          type: 'error.execution'
+        })],
+        context: machine.context
+      });
+    } else {
+      throw e;
+    }
+  }
+}
+
+function enterStates(filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue) {
+  var statesToEnter = new Set();
+  var statesForDefaultEntry = new Set();
+  computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter); // In the initial state, the root state node is "entered".
+
+  if (currentState._initial) {
+    statesForDefaultEntry.add(currentState.machine.root);
+  }
+
+  var _iterator23 = _createForOfIteratorHelper(_toConsumableArray(statesToEnter).sort(function (a, b) {
+    return a.order - b.order;
+  })),
+      _step23;
+
+  try {
+    for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+      var stateNodeToEnter = _step23.value;
+      mutConfiguration.add(stateNodeToEnter);
+
+      var _iterator24 = _createForOfIteratorHelper(stateNodeToEnter.invoke),
+          _step24;
+
+      try {
+        for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
+          var invokeDef = _step24.value;
+          actions.push(invoke$1(invokeDef));
+        } // Add entry actions
+
+      } catch (err) {
+        _iterator24.e(err);
+      } finally {
+        _iterator24.f();
+      }
+
+      actions.push.apply(actions, _toConsumableArray(stateNodeToEnter.entry));
+
+      if (statesForDefaultEntry.has(stateNodeToEnter)) {
+        var _iterator25 = _createForOfIteratorHelper(statesForDefaultEntry),
+            _step25;
+
+        try {
+          for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
+            var stateNode = _step25.value;
+            var initialActions = stateNode.initial.actions;
+            actions.push.apply(actions, _toConsumableArray(initialActions));
+          }
+        } catch (err) {
+          _iterator25.e(err);
+        } finally {
+          _iterator25.f();
+        }
+      }
+
+      if (stateNodeToEnter.type === 'final') {
+        var parent = stateNodeToEnter.parent;
+
+        if (!parent.parent) {
+          continue;
+        }
+
+        internalQueue.push(toSCXMLEvent(done(parent.id, stateNodeToEnter.doneData ? mapContext(stateNodeToEnter.doneData, currentState.context, currentState._event) : undefined)));
+
+        if (parent.parent) {
+          var grandparent = parent.parent;
+
+          if (grandparent.type === 'parallel') {
+            if (getChildren(grandparent).every(function (parentNode) {
+              return isInFinalState(_toConsumableArray(mutConfiguration), parentNode);
+            })) {
+              internalQueue.push(toSCXMLEvent(done(grandparent.id)));
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator23.e(err);
+  } finally {
+    _iterator23.f();
+  }
+}
+
+function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
+  var _iterator26 = _createForOfIteratorHelper(transitions),
+      _step26;
+
+  try {
+    for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+      var t = _step26.value;
+
+      var _iterator27 = _createForOfIteratorHelper(t.target || []),
+          _step27;
+
+      try {
+        for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {
+          var s = _step27.value;
+          addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+        }
+      } catch (err) {
+        _iterator27.e(err);
+      } finally {
+        _iterator27.f();
+      }
+
+      var ancestor = getTransitionDomain(t, historyValue);
+      var targetStates = getEffectiveTargetStates(t, historyValue);
+
+      var _iterator28 = _createForOfIteratorHelper(targetStates),
+          _step28;
+
+      try {
+        for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
+          var _s2 = _step28.value;
+          addAncestorStatesToEnter(_s2, ancestor, statesToEnter, historyValue, statesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator28.e(err);
+      } finally {
+        _iterator28.f();
+      }
+    }
+  } catch (err) {
+    _iterator26.e(err);
+  } finally {
+    _iterator26.f();
+  }
+}
+
+function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEntry, statesToEnter) {
+  if (isHistoryNode(stateNode)) {
+    if (historyValue[stateNode.id]) {
+      var historyStateNodes = historyValue[stateNode.id];
+
+      var _iterator29 = _createForOfIteratorHelper(historyStateNodes),
+          _step29;
+
+      try {
+        for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {
+          var s = _step29.value;
+          addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+        }
+      } catch (err) {
+        _iterator29.e(err);
+      } finally {
+        _iterator29.f();
+      }
+
+      var _iterator30 = _createForOfIteratorHelper(historyStateNodes),
+          _step30;
+
+      try {
+        for (_iterator30.s(); !(_step30 = _iterator30.n()).done;) {
+          var _s3 = _step30.value;
+          addAncestorStatesToEnter(_s3, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+
+          var _iterator31 = _createForOfIteratorHelper(statesForDefaultEntry),
+              _step31;
+
+          try {
+            for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {
+              var stateForDefaultEntry = _step31.value;
+              statesForDefaultEntry.add(stateForDefaultEntry);
+            }
+          } catch (err) {
+            _iterator31.e(err);
+          } finally {
+            _iterator31.f();
+          }
+        }
+      } catch (err) {
+        _iterator30.e(err);
+      } finally {
+        _iterator30.f();
+      }
+    } else {
+      var targets = resolveHistoryTarget(stateNode);
+
+      var _iterator32 = _createForOfIteratorHelper(targets),
+          _step32;
+
+      try {
+        for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {
+          var _s4 = _step32.value;
+          addDescendantStatesToEnter(_s4, historyValue, statesForDefaultEntry, statesToEnter);
+        }
+      } catch (err) {
+        _iterator32.e(err);
+      } finally {
+        _iterator32.f();
+      }
+
+      var _iterator33 = _createForOfIteratorHelper(targets),
+          _step33;
+
+      try {
+        for (_iterator33.s(); !(_step33 = _iterator33.n()).done;) {
+          var _s5 = _step33.value;
+          addAncestorStatesToEnter(_s5, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+
+          var _iterator34 = _createForOfIteratorHelper(statesForDefaultEntry),
+              _step34;
+
+          try {
+            for (_iterator34.s(); !(_step34 = _iterator34.n()).done;) {
+              var _stateForDefaultEntry = _step34.value;
+              statesForDefaultEntry.add(_stateForDefaultEntry);
+            }
+          } catch (err) {
+            _iterator34.e(err);
+          } finally {
+            _iterator34.f();
+          }
+        }
+      } catch (err) {
+        _iterator33.e(err);
+      } finally {
+        _iterator33.f();
+      }
+    }
+  } else {
+    statesToEnter.add(stateNode);
+
+    if (stateNode.type === 'compound') {
+      statesForDefaultEntry.add(stateNode);
+      var initialStates = stateNode.initial.target;
+
+      var _iterator35 = _createForOfIteratorHelper(initialStates),
+          _step35;
+
+      try {
+        for (_iterator35.s(); !(_step35 = _iterator35.n()).done;) {
+          var initialState = _step35.value;
+          addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
+        }
+      } catch (err) {
+        _iterator35.e(err);
+      } finally {
+        _iterator35.f();
+      }
+
+      var _iterator36 = _createForOfIteratorHelper(initialStates),
+          _step36;
+
+      try {
+        for (_iterator36.s(); !(_step36 = _iterator36.n()).done;) {
+          var _initialState = _step36.value;
+          addAncestorStatesToEnter(_initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator36.e(err);
+      } finally {
+        _iterator36.f();
+      }
+    } else {
+      if (stateNode.type === 'parallel') {
+        var _iterator37 = _createForOfIteratorHelper(getChildren(stateNode).filter(function (sn) {
+          return !isHistoryNode(sn);
+        })),
+            _step37;
+
+        try {
+          var _loop2 = function _loop2() {
+            var child = _step37.value;
+
+            if (!_toConsumableArray(statesToEnter).some(function (s) {
+              return isDescendant(s, child);
+            })) {
+              addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
+            }
+          };
+
+          for (_iterator37.s(); !(_step37 = _iterator37.n()).done;) {
+            _loop2();
+          }
+        } catch (err) {
+          _iterator37.e(err);
+        } finally {
+          _iterator37.f();
+        }
+      }
+    }
+  }
+}
+
+function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
+  var properAncestors = getProperAncestors(stateNode, toStateNode);
+
+  var _iterator38 = _createForOfIteratorHelper(properAncestors),
+      _step38;
+
+  try {
+    for (_iterator38.s(); !(_step38 = _iterator38.n()).done;) {
+      var anc = _step38.value;
+      statesToEnter.add(anc);
+
+      if (anc.type === 'parallel') {
+        var _iterator39 = _createForOfIteratorHelper(getChildren(anc).filter(function (sn) {
+          return !isHistoryNode(sn);
+        })),
+            _step39;
+
+        try {
+          var _loop3 = function _loop3() {
+            var child = _step39.value;
+
+            if (!_toConsumableArray(statesToEnter).some(function (s) {
+              return isDescendant(s, child);
+            })) {
+              addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
+            }
+          };
+
+          for (_iterator39.s(); !(_step39 = _iterator39.n()).done;) {
+            _loop3();
+          }
+        } catch (err) {
+          _iterator39.e(err);
+        } finally {
+          _iterator39.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator38.e(err);
+  } finally {
+    _iterator38.f();
+  }
+}
+
+function exitStates(transitions, mutConfiguration, historyValue, actions) {
+  var statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
+
+  var _iterator40 = _createForOfIteratorHelper(statesToExit),
+      _step40;
+
+  try {
+    for (_iterator40.s(); !(_step40 = _iterator40.n()).done;) {
+      var _sn = _step40.value;
+      actions.push.apply(actions, _toConsumableArray(_sn.invoke.map(function (def) {
+        return stop$1(def.id);
+      })));
+    }
+  } catch (err) {
+    _iterator40.e(err);
+  } finally {
+    _iterator40.f();
+  }
+
+  statesToExit.sort(function (a, b) {
+    return b.order - a.order;
+  }); // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
+
+  var _iterator41 = _createForOfIteratorHelper(statesToExit),
+      _step41;
+
+  try {
+    var _loop4 = function _loop4() {
+      var exitStateNode = _step41.value;
+
+      var _iterator43 = _createForOfIteratorHelper(getHistoryNodes(exitStateNode)),
+          _step43;
+
+      try {
+        for (_iterator43.s(); !(_step43 = _iterator43.n()).done;) {
+          var historyNode = _step43.value;
+          var predicate = void 0;
+
+          if (historyNode.history === 'deep') {
+            predicate = function predicate(sn) {
+              return isAtomicStateNode(sn) && isDescendant(sn, exitStateNode);
+            };
+          } else {
+            predicate = function predicate(sn) {
+              return sn.parent === exitStateNode;
+            };
+          }
+
+          historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+        }
+      } catch (err) {
+        _iterator43.e(err);
+      } finally {
+        _iterator43.f();
+      }
+    };
+
+    for (_iterator41.s(); !(_step41 = _iterator41.n()).done;) {
+      _loop4();
+    }
+  } catch (err) {
+    _iterator41.e(err);
+  } finally {
+    _iterator41.f();
+  }
+
+  var _iterator42 = _createForOfIteratorHelper(statesToExit),
+      _step42;
+
+  try {
+    for (_iterator42.s(); !(_step42 = _iterator42.n()).done;) {
+      var s = _step42.value;
+      actions.push.apply(actions, _toConsumableArray(s.exit.flat()));
+      mutConfiguration["delete"](s);
+    }
+  } catch (err) {
+    _iterator42.e(err);
+  } finally {
+    _iterator42.f();
+  }
+}
+
+function resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx) {
+  var machine = currentState.machine;
+  var resolvedActions = [];
+  var raiseActions = [];
+  var intermediateState = currentState;
+
+  function handleAction(action) {
+    resolvedActions.push(action);
+
+    if ((actorCtx === null || actorCtx === void 0 ? void 0 : actorCtx.self.status) === exports.ActorStatus.Running) {
+      var _action$execute;
+
+      (_action$execute = action.execute) === null || _action$execute === void 0 ? void 0 : _action$execute.call(action, actorCtx); // TODO: this is hacky; re-evaluate
+
+      delete action.execute;
+    }
+  }
+
+  function resolveAction(actionObject) {
+    var executableActionObject = resolveActionObject(actionObject, machine.options.actions);
+
+    if (isDynamicAction(executableActionObject)) {
+      var _resolvedAction$param;
+
+      var _executableActionObje = executableActionObject.resolve(scxmlEvent, {
+        state: intermediateState,
+        action: actionObject,
+        actorContext: actorCtx
+      }),
+          _executableActionObje2 = _slicedToArray(_executableActionObje, 2),
+          nextState = _executableActionObje2[0],
+          resolvedAction = _executableActionObje2[1];
+
+      var matchedActions = (_resolvedAction$param = resolvedAction.params) === null || _resolvedAction$param === void 0 ? void 0 : _resolvedAction$param.actions;
+      intermediateState = nextState;
+
+      if (resolvedAction.type === raise || resolvedAction.type === send && resolvedAction.params.internal) {
+        raiseActions.push(resolvedAction);
+      } // TODO: remove the check; just handleAction
+
+
+      if (resolvedAction.type !== pure) {
+        handleAction(resolvedAction);
+      }
+
+      toActionObjects(matchedActions).forEach(resolveAction);
+      return;
+    }
+
+    handleAction(executableActionObject);
+  }
+
+  var _iterator44 = _createForOfIteratorHelper(actions),
+      _step44;
+
+  try {
+    for (_iterator44.s(); !(_step44 = _iterator44.n()).done;) {
+      var actionObject = _step44.value;
+      resolveAction(actionObject);
+    }
+  } catch (err) {
+    _iterator44.e(err);
+  } finally {
+    _iterator44.f();
+  }
+
+  return {
+    nextState: cloneState(intermediateState, {
+      actions: resolvedActions,
+      _internalQueue: raiseActions.map(function (a) {
+        return a.params._event;
+      })
+    })
+  };
+}
+function macrostep(state, scxmlEvent, actorCtx) {
+
+  var nextState = state;
+  var states = []; // Handle stop event
+
+  if ((scxmlEvent === null || scxmlEvent === void 0 ? void 0 : scxmlEvent.name) === stopSignalType) {
+    nextState = stopStep(scxmlEvent, nextState, actorCtx);
+    states.push(nextState);
+    return {
+      state: nextState,
+      microstates: states
+    };
+  } // Assume the state is at rest (no raised events)
+  // Determine the next state based on the next microstep
+
+
+  if (scxmlEvent.name !== init) {
+    var transitions = selectTransitions(scxmlEvent, nextState);
+    nextState = microstep(transitions, state, actorCtx, scxmlEvent);
+    states.push(nextState);
+  }
+
+  while (!nextState.done) {
+    var enabledTransitions = selectEventlessTransitions(nextState);
+
+    if (enabledTransitions.length === 0) {
+      // TODO: this is a bit of a hack, we need to review this
+      // this matches the behavior from v4 for eventless transitions
+      // where for `hasAlwaysTransitions` we were always trying to resolve with a NULL event
+      // and if a transition was not selected the `state.transitions` stayed empty
+      // without this we get into an infinite loop in the dieHard test in `@xstate/test` for the `simplePathsTo`
+      if (nextState.configuration.some(function (state) {
+        return state.always;
+      })) {
+        nextState.transitions = [];
+      }
+
+      if (!nextState._internalQueue.length) {
+        break;
+      } else {
+        var _nextState$actions;
+
+        var currentActions = nextState.actions;
+        var nextEvent = nextState._internalQueue[0];
+
+        var _transitions = selectTransitions(nextEvent, nextState);
+
+        nextState = microstep(_transitions, nextState, actorCtx, nextEvent);
+
+        nextState._internalQueue.shift();
+
+        (_nextState$actions = nextState.actions).unshift.apply(_nextState$actions, _toConsumableArray(currentActions));
+
+        states.push(nextState);
+      }
+    }
+
+    if (enabledTransitions.length) {
+      var _nextState$actions2;
+
+      var _currentActions = nextState.actions;
+      nextState = microstep(enabledTransitions, nextState, actorCtx, nextState._event);
+
+      (_nextState$actions2 = nextState.actions).unshift.apply(_nextState$actions2, _toConsumableArray(_currentActions));
+
+      states.push(nextState);
+    }
+  }
+
+  if (nextState.done) {
+    // Perform the stop step to ensure that child actors are stopped
+    stopStep(nextState._event, nextState, actorCtx);
+  }
+
+  return {
+    state: nextState,
+    microstates: states
+  };
+}
+
+function stopStep(scxmlEvent, nextState, actorCtx) {
+  var actions = [];
+
+  var _iterator45 = _createForOfIteratorHelper(nextState.configuration.sort(function (a, b) {
+    return b.order - a.order;
+  })),
+      _step45;
+
+  try {
+    for (_iterator45.s(); !(_step45 = _iterator45.n()).done;) {
+      var stateNode = _step45.value;
+      actions.push.apply(actions, _toConsumableArray(stateNode.exit));
+    }
+  } catch (err) {
+    _iterator45.e(err);
+  } finally {
+    _iterator45.f();
+  }
+
+  for (var _i3 = 0, _Object$values = Object.values(nextState.children); _i3 < _Object$values.length; _i3++) {
+    var child = _Object$values[_i3];
+    actions.push(stop$1(child));
+  }
+
+  var _resolveActionsAndCon2 = resolveActionsAndContext(actions, scxmlEvent, nextState, actorCtx),
+      stoppedState = _resolveActionsAndCon2.nextState;
+
+  return stoppedState;
+}
+
+function selectTransitions(scxmlEvent, nextState) {
+  return nextState.machine.getTransitionData(nextState, scxmlEvent);
+}
+
+function selectEventlessTransitions(nextState) {
+  var enabledTransitionSet = new Set();
+  var atomicStates = nextState.configuration.filter(isAtomicStateNode);
+
+  var _iterator46 = _createForOfIteratorHelper(atomicStates),
+      _step46;
+
+  try {
+    for (_iterator46.s(); !(_step46 = _iterator46.n()).done;) {
+      var stateNode = _step46.value;
+
+      var _iterator47 = _createForOfIteratorHelper([stateNode].concat(getProperAncestors(stateNode, null))),
+          _step47;
+
+      try {
+        loop: for (_iterator47.s(); !(_step47 = _iterator47.n()).done;) {
+          var s = _step47.value;
+
+          if (!s.always) {
+            continue;
+          }
+
+          var _iterator48 = _createForOfIteratorHelper(s.always),
+              _step48;
+
+          try {
+            for (_iterator48.s(); !(_step48 = _iterator48.n()).done;) {
+              var transition = _step48.value;
+
+              if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, nextState._event, nextState)) {
+                enabledTransitionSet.add(transition);
+                break loop;
+              }
+            }
+          } catch (err) {
+            _iterator48.e(err);
+          } finally {
+            _iterator48.f();
+          }
+        }
+      } catch (err) {
+        _iterator47.e(err);
+      } finally {
+        _iterator47.f();
+      }
+    }
+  } catch (err) {
+    _iterator46.e(err);
+  } finally {
+    _iterator46.f();
+  }
+
+  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) {
+  var configuration = getConfiguration(getStateNodes(rootNode, stateValue));
+  return getStateValue(rootNode, _toConsumableArray(configuration));
+}
+function stateValuesEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+
+  if (a === undefined || b === undefined) {
+    return false;
+  }
+
+  if (isString(a) || isString(b)) {
+    return a === b;
+  }
+
+  var aKeys = Object.keys(a);
+  var bKeys = Object.keys(b);
+  return aKeys.length === bKeys.length && aKeys.every(function (key) {
+    return stateValuesEqual(a[key], b[key]);
+  });
+}
+function getInitialConfiguration(rootNode) {
+  var configuration = [];
+  var initialTransition = rootNode.initial;
+  var statesToEnter = new Set();
+  var statesForDefaultEntry = new Set([rootNode]);
+  computeEntrySet([initialTransition], {}, statesForDefaultEntry, statesToEnter);
+
+  var _iterator49 = _createForOfIteratorHelper(_toConsumableArray(statesToEnter).sort(function (a, b) {
+    return a.order - b.order;
+  })),
+      _step49;
+
+  try {
+    for (_iterator49.s(); !(_step49 = _iterator49.n()).done;) {
+      var stateNodeToEnter = _step49.value;
+      configuration.push(stateNodeToEnter);
+    }
+  } catch (err) {
+    _iterator49.e(err);
+  } finally {
+    _iterator49.f();
+  }
+
+  return configuration;
+}
+
+var _excluded = ["configuration", "transitions", "tags", "machine"];
+function isStateConfig(state) {
+  if (_typeof(state) !== 'object' || state === null) {
+    return false;
+  }
+
+  return 'value' in state && '_event' in state;
+}
+var State = /*#__PURE__*/function () {
+  /**
+   * Creates a new `State` instance that represents the current state of a running machine.
+   *
+   * @param config
+   */
+  function State(config, machine) {
+    var _config$_internalQueu, _config$actions, _config$configuration, _config$done;
+
+    _classCallCheck(this, State);
+
+    this.machine = machine;
+
+    _defineProperty(this, "value", void 0);
+
+    _defineProperty(this, "done", void 0);
+
+    _defineProperty(this, "output", void 0);
+
+    _defineProperty(this, "context", void 0);
+
+    _defineProperty(this, "historyValue", {});
+
+    _defineProperty(this, "actions", []);
+
+    _defineProperty(this, "event", void 0);
+
+    _defineProperty(this, "_internalQueue", void 0);
+
+    _defineProperty(this, "_event", void 0);
+
+    _defineProperty(this, "_sessionid", void 0);
+
+    _defineProperty(this, "_initial", false);
+
+    _defineProperty(this, "changed", void 0);
+
+    _defineProperty(this, "configuration", void 0);
+
+    _defineProperty(this, "transitions", void 0);
+
+    _defineProperty(this, "children", void 0);
+
+    this.context = config.context;
+    this._event = config._event;
+    this._sessionid = config._sessionid;
+    this._internalQueue = (_config$_internalQueu = config._internalQueue) !== null && _config$_internalQueu !== void 0 ? _config$_internalQueu : [];
+    this.event = this._event.data;
+    this.historyValue = config.historyValue || {};
+    this.actions = (_config$actions = config.actions) !== null && _config$actions !== void 0 ? _config$actions : [];
+    this.matches = this.matches.bind(this);
+    this.toStrings = this.toStrings.bind(this);
+    this.configuration = (_config$configuration = config.configuration) !== null && _config$configuration !== void 0 ? _config$configuration : Array.from(getConfiguration(getStateNodes(machine.root, config.value)));
+    this.transitions = config.transitions;
+    this.children = config.children;
+    this.value = getStateValue(machine.root, this.configuration);
+    this.done = (_config$done = config.done) !== null && _config$done !== void 0 ? _config$done : false;
+    this.output = config.output;
+  }
+  /**
+   * 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.
+   */
+
+
+  _createClass(State, [{
+    key: "toStrings",
+    value: function toStrings() {
+      var _this = this;
+
+      var stateValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.value;
+      var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.';
+
+      if (isString(stateValue)) {
+        return [stateValue];
+      }
+
+      var valueKeys = Object.keys(stateValue);
+      return valueKeys.concat.apply(valueKeys, _toConsumableArray(valueKeys.map(function (key) {
+        return _this.toStrings(stateValue[key], delimiter).map(function (s) {
+          return key + delimiter + s;
+        });
+      })));
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      var configuration = this.configuration,
+          transitions = this.transitions,
+          tags = this.tags,
+          machine = this.machine,
+          jsonValues = _objectWithoutProperties(this, _excluded);
+
+      return _objectSpread2(_objectSpread2({}, jsonValues), {}, {
+        tags: Array.from(tags),
+        meta: this.meta
+      });
+    }
+    /**
+     * Whether the current state value is a subset of the given parent state value.
+     * @param parentStateValue
+     */
+
+  }, {
+    key: "matches",
+    value: function matches(parentStateValue) {
+      return matchesState(parentStateValue, this.value);
+    }
+    /**
+     * Whether the current state configuration has a state node with the specified `tag`.
+     * @param tag
+     */
+
+  }, {
+    key: "hasTag",
+    value: function 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
+     */
+
+  }, {
+    key: "can",
+    value: function can(event) {
+      {
+        warn(!!this.machine);
+      }
+
+      var transitionData = this.machine.getTransitionData(this, toSCXMLEvent(event));
+      return !!(transitionData !== null && transitionData !== void 0 && transitionData.length) && // Check that at least one transition is not forbidden
+      transitionData.some(function (t) {
+        return t.target !== undefined || t.actions.length;
+      });
+    }
+    /**
+     * The next events that will cause a transition from the current state.
+     */
+
+  }, {
+    key: "nextEvents",
+    get: function get() {
+      var _this2 = this;
+
+      return memo(this, 'nextEvents', function () {
+        return _toConsumableArray(new Set(flatten(_toConsumableArray(_this2.configuration.map(function (sn) {
+          return sn.ownEvents;
+        })))));
+      });
+    }
+  }, {
+    key: "meta",
+    get: function get() {
+      return this.configuration.reduce(function (acc, stateNode) {
+        if (stateNode.meta !== undefined) {
+          acc[stateNode.id] = stateNode.meta;
+        }
+
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "tags",
+    get: function get() {
+      return new Set(flatten(this.configuration.map(function (sn) {
+        return sn.tags;
+      })));
+    }
+  }], [{
+    key: "from",
+    value:
+    /**
+     * Indicates whether the state is a final state.
+     */
+
+    /**
+     * The done data of the top-level finite state.
+     */
+    // TODO: add an explicit type for `output`
+
+    /**
+     * Indicates whether the state has changed from the previous state. A state is considered "changed" if:
+     *
+     * - Its value is not equal to its previous value, or:
+     * - It has any new actions (side-effects) to execute.
+     *
+     * An initial state (with no history) will return `undefined`.
+     */
+
+    /**
+     * The enabled state nodes representative of the state value.
+     */
+
+    /**
+     * The transition definitions that resulted in this state.
+     */
+
+    /**
+     * An object mapping actor names to spawned/invoked actors.
+     */
+
+    /**
+     * Creates a new State instance for the given `stateValue` and `context`.
+     * @param stateValue
+     * @param context
+     */
+    function from(stateValue) {
+      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var machine = arguments.length > 2 ? arguments[2] : undefined;
+
+      if (stateValue instanceof State) {
+        if (stateValue.context !== context) {
+          return new State({
+            value: stateValue.value,
+            context: context,
+            _event: stateValue._event,
+            _sessionid: undefined,
+            actions: [],
+            meta: {},
+            configuration: [],
+            // TODO: fix,
+            transitions: [],
+            children: {}
+          }, machine);
+        }
+
+        return stateValue;
+      }
+
+      var _event = initEvent;
+      var configuration = getConfiguration(getStateNodes(machine.root, stateValue));
+      return new State({
+        value: stateValue,
+        context: context,
+        _event: _event,
+        _sessionid: undefined,
+        actions: [],
+        meta: undefined,
+        configuration: Array.from(configuration),
+        transitions: [],
+        children: {}
+      }, machine);
+    }
+  }]);
+
+  return State;
+}();
+function cloneState(state) {
+  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return new State(_objectSpread2(_objectSpread2({}, state), config), state.machine);
+}
+
+function invoke$1(invokeDef) {
+  return createDynamicAction({
+    type: invoke,
+    params: invokeDef
+  }, function (_event, _ref) {
+    var state = _ref.state;
+    var type = invoke;
+    var id = invokeDef.id,
+        data = invokeDef.data,
+        src = invokeDef.src,
+        meta = invokeDef.meta;
+    var resolvedInvokeAction;
+
+    if (isActorRef(src)) {
+      resolvedInvokeAction = {
+        type: type,
+        params: _objectSpread2(_objectSpread2({}, invokeDef), {}, {
+          ref: src
+        })
+      };
+    } else {
+      var behaviorImpl = state.machine.options.actors[src.type];
+
+      if (!behaviorImpl) {
+        resolvedInvokeAction = {
+          type: type,
+          params: invokeDef
+        };
+      } else {
+        var behavior = typeof behaviorImpl === 'function' ? behaviorImpl(state.context, _event.data, {
+          id: id,
+          data: data && mapContext(data, state.context, _event),
+          src: src,
+          _event: _event,
+          meta: meta
+        }) : behaviorImpl;
+        resolvedInvokeAction = {
+          type: type,
+          params: _objectSpread2(_objectSpread2({}, invokeDef), {}, {
+            ref: interpret(behavior, {
+              id: id
+            })
+          })
+        };
+      }
+    }
+
+    var actorRef = resolvedInvokeAction.params.ref;
+    var invokedState = cloneState(state, {
+      children: _objectSpread2(_objectSpread2({}, state.children), {}, _defineProperty({}, id, actorRef))
+    });
+
+    resolvedInvokeAction.execute = function (actorCtx) {
+      var interpreter = actorCtx.self;
+      var _resolvedInvokeAction = resolvedInvokeAction.params,
+          id = _resolvedInvokeAction.id,
+          autoForward = _resolvedInvokeAction.autoForward,
+          ref = _resolvedInvokeAction.ref;
+
+      if (!ref) {
+
+        return;
+      }
+
+      ref._parent = interpreter; // TODO: fix
+
+      actorCtx.defer(function () {
+        if (actorRef.status === exports.ActorStatus.Stopped) {
+          return;
+        }
+
+        try {
+          var _actorRef$start;
+
+          if (autoForward) {
+            interpreter._forwardTo.add(actorRef);
+          }
+
+          (_actorRef$start = actorRef.start) === null || _actorRef$start === void 0 ? void 0 : _actorRef$start.call(actorRef);
+        } catch (err) {
+          interpreter.send(error$1(id, err));
+          return;
+        }
+      });
+    };
+
+    return [invokedState, resolvedInvokeAction];
+  });
+}
+
+function createSpawner(machine, context, _event, mutCapturedActions) {
+  return function (behavior, name) {
+    if (isString(behavior)) {
+      var behaviorCreator = machine.options.actors[behavior];
+
+      if (behaviorCreator) {
+        var resolvedName = name !== null && name !== void 0 ? name : 'anon'; // TODO: better name
+
+        var createdBehavior = typeof behaviorCreator === 'function' ? behaviorCreator(context, _event.data, {
+          id: resolvedName,
+          src: {
+            type: behavior
+          },
+          _event: _event,
+          meta: undefined
+        }) : behaviorCreator;
+        var actorRef = interpret(createdBehavior, {
+          id: resolvedName
+        });
+        mutCapturedActions.push(invoke$1({
+          id: actorRef.id,
+          // @ts-ignore TODO: fix types
+          src: actorRef,
+          // TODO
+          ref: actorRef,
+          meta: undefined
+        }));
+        return actorRef; // TODO: fix types
+      }
+
+      throw new Error("Behavior '".concat(behavior, "' not implemented in machine '").concat(machine.id, "'"));
+    } else {
+      var _actorRef = interpret(behavior, {
+        id: name || 'anonymous'
+      });
+
+      mutCapturedActions.push(invoke$1({
+        // @ts-ignore TODO: fix types
+        src: _actorRef,
+        ref: _actorRef,
+        id: _actorRef.id,
+        meta: undefined
+      }));
+      return _actorRef; // TODO: fix types
+    }
+  };
+}
+
+/**
+ * Updates the current context of the machine.
+ *
+ * @param assignment An object that represents the partial context to update.
+ */
+
+function assign$1(assignment) {
+  return createDynamicAction({
+    type: assign,
+    params: {
+      assignment: assignment
+    }
+  }, function (_event, _ref) {
+    var state = _ref.state,
+        action = _ref.action;
+    var capturedActions = [];
+
+    if (!state.context) {
+      throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
+    }
+
+    var meta = {
+      state: state,
+      action: action,
+      _event: _event,
+      spawn: createSpawner(state.machine, state.context, _event, capturedActions)
+    };
+    var partialUpdate = {};
+
+    if (isFunction(assignment)) {
+      partialUpdate = assignment(state.context, _event.data, meta);
+    } else {
+      for (var _i = 0, _Object$keys = Object.keys(assignment); _i < _Object$keys.length; _i++) {
+        var key = _Object$keys[_i];
+        var propAssignment = assignment[key];
+        partialUpdate[key] = isFunction(propAssignment) ? propAssignment(state.context, _event.data, meta) : propAssignment;
+      }
+    }
+
+    var updatedContext = Object.assign({}, state.context, partialUpdate);
+    return [cloneState(state, {
+      context: updatedContext
+    }), {
+      type: assign,
+      params: {
+        context: updatedContext,
+        actions: capturedActions
+      }
+    }];
+  });
+}
+
+/**
+ * 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$1(event) {
+  return createDynamicAction({
+    type: raise,
+    params: {
+      _event: toSCXMLEvent(event)
+    }
+  }, function (_event, _ref) {
+    var state = _ref.state;
+    return [state, {
+      type: raise,
+      params: {
+        _event: toSCXMLEvent(event)
+      }
+    }];
+  });
+}
+
+function choose$1(guards) {
+  return createDynamicAction({
+    type: choose,
+    params: {
+      guards: guards
+    }
+  }, function (_event, _ref) {
+    var _guards$find;
+
+    var state = _ref.state;
+    var matchedActions = (_guards$find = guards.find(function (condition) {
+      var guard = condition.guard && toGuardDefinition(condition.guard, function (guardType) {
+        return state.machine.options.guards[guardType];
+      });
+      return !guard || evaluateGuard(guard, state.context, _event, state);
+    })) === null || _guards$find === void 0 ? void 0 : _guards$find.actions;
+    return [state, {
+      type: choose,
+      params: {
+        actions: toActionObjects(matchedActions)
+      }
+    }];
+  });
+}
+
+var initEvent = toSCXMLEvent({
+  type: init
+});
+function resolveActionObject(actionObject, actionFunctionMap) {
+  if (isDynamicAction(actionObject)) {
+    return actionObject;
+  }
+
+  var dereferencedAction = actionFunctionMap[actionObject.type];
+
+  if (typeof dereferencedAction === 'function') {
+    var _actionObject$params;
+
+    return createDynamicAction({
+      type: 'xstate.expr',
+      params: (_actionObject$params = actionObject.params) !== null && _actionObject$params !== void 0 ? _actionObject$params : {}
+    }, function (_event, _ref) {
+      var state = _ref.state;
+      var a = {
+        type: actionObject.type,
+        params: actionObject.params,
+        execute: function execute(_actorCtx) {
+          return dereferencedAction(state.context, state.event, {
+            action: a,
+            _event: state._event,
+            state: state
+          });
+        }
+      };
+      return [state, a];
+    });
+  } else if (dereferencedAction) {
+    return dereferencedAction;
+  } else {
+    return actionObject;
+  }
+}
+function toActionObject(action) {
+  if (isDynamicAction(action)) {
+    return action;
+  }
+
+  if (typeof action === 'string') {
+    return {
+      type: action,
+      params: {}
+    };
+  }
+
+  if (typeof action === 'function') {
+    var type = 'xstate.function';
+    return createDynamicAction({
+      type: type,
+      params: {}
+    }, function (_event, _ref2) {
+      var state = _ref2.state;
+      var a = {
+        type: type,
+        params: {
+          "function": action
+        },
+        execute: function execute(_actorCtx) {
+          return action(state.context, _event.data, {
+            action: a,
+            _event: _event,
+            state: state
+          });
+        }
+      };
+      return [state, a];
+    });
+  } // action is already a BaseActionObject
+
+
+  return action;
+}
+var toActionObjects = function toActionObjects(action) {
+  if (!action) {
+    return [];
+  }
+
+  var actions = isArray(action) ? action : [action];
+  return actions.map(toActionObject);
+};
+/**
+ * Returns an event type that represents an implicit event that
+ * is sent after the specified `delay`.
+ *
+ * @param delayRef The delay in milliseconds
+ * @param id The state node ID where this event is handled
+ */
+
+function after$1(delayRef, id) {
+  var idSuffix = id ? "#".concat(id) : '';
+  return "".concat(exports.ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
+}
+/**
+ * Returns an event that represents that a final state node
+ * has been reached in the parent state node.
+ *
+ * @param id The final state node's parent state node `id`
+ * @param data The data to pass into the event
+ */
+
+function done(id, data) {
+  var type = "".concat(exports.ActionTypes.DoneState, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+/**
+ * Returns an event that represents that an invoked service has terminated.
+ *
+ * An invoked service is terminated when it has reached a top-level final state node,
+ * but not when it is canceled.
+ *
+ * @param invokeId The invoked service ID
+ * @param data The data to pass into the event
+ */
+
+function doneInvoke(invokeId, data) {
+  var type = "".concat(exports.ActionTypes.DoneInvoke, ".").concat(invokeId);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+function error$1(id, data) {
+  var type = "".concat(exports.ActionTypes.ErrorPlatform, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+
+exports.Interpreter = Interpreter;
+exports.NULL_EVENT = NULL_EVENT;
+exports.STATE_DELIMITER = STATE_DELIMITER;
+exports.State = State;
+exports._classCallCheck = _classCallCheck;
+exports._createClass = _createClass;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._defineProperty = _defineProperty;
+exports._objectSpread2 = _objectSpread2;
+exports._objectWithoutProperties = _objectWithoutProperties;
+exports._slicedToArray = _slicedToArray;
+exports._toConsumableArray = _toConsumableArray;
+exports.actionTypes = actionTypes;
+exports.after = after$1;
+exports.and = and;
+exports.assign = assign$1;
+exports.cancel = cancel$1;
+exports.choose = choose$1;
+exports.createDynamicAction = createDynamicAction;
+exports.createInvokeId = createInvokeId;
+exports.createSpawner = createSpawner;
+exports.done = done;
+exports.doneInvoke = doneInvoke;
+exports.error = error$1;
+exports.escalate = escalate;
+exports.evaluateGuard = evaluateGuard;
+exports.flatten = flatten;
+exports.formatInitialTransition = formatInitialTransition;
+exports.formatTransition = formatTransition;
+exports.formatTransitions = formatTransitions;
+exports.forwardTo = forwardTo;
+exports.fromCallback = fromCallback;
+exports.fromEventObservable = fromEventObservable;
+exports.fromObservable = fromObservable;
+exports.fromPromise = fromPromise;
+exports.fromReducer = fromReducer;
+exports.getCandidates = getCandidates;
+exports.getConfiguration = getConfiguration;
+exports.getDelayedTransitions = getDelayedTransitions;
+exports.getInitialConfiguration = getInitialConfiguration;
+exports.getStateNodes = getStateNodes;
+exports.initEvent = initEvent;
+exports.interpret = interpret;
+exports.invoke = invoke;
+exports.isActorRef = isActorRef;
+exports.isFunction = isFunction;
+exports.isInFinalState = isInFinalState;
+exports.isSCXMLErrorEvent = isSCXMLErrorEvent;
+exports.isStateConfig = isStateConfig;
+exports.isStateId = isStateId;
+exports.isString = isString;
+exports.log = log$1;
+exports.macrostep = macrostep;
+exports.mapValues = mapValues;
+exports.matchesState = matchesState;
+exports.memo = memo;
+exports.microstep = microstep;
+exports.not = not;
+exports.or = or;
+exports.pathToStateValue = pathToStateValue;
+exports.pure = pure;
+exports.raise = raise$1;
+exports.resolveActionObject = resolveActionObject;
+exports.resolveActionsAndContext = resolveActionsAndContext;
+exports.resolveStateValue = resolveStateValue;
+exports.respond = respond;
+exports.send = send$1;
+exports.sendParent = sendParent;
+exports.sendTo = sendTo;
+exports.startSignal = startSignal;
+exports.startSignalType = startSignalType;
+exports.stateIn = stateIn;
+exports.stop = stop$1;
+exports.stopSignal = stopSignal;
+exports.stopSignalType = stopSignalType;
+exports.toActionObject = toActionObject;
+exports.toActionObjects = toActionObjects;
+exports.toActorRef = toActorRef;
+exports.toArray = toArray;
+exports.toGuardDefinition = toGuardDefinition;
+exports.toInvokeConfig = toInvokeConfig;
+exports.toInvokeSource = toInvokeSource;
+exports.toObserver = toObserver;
+exports.toSCXMLEvent = toSCXMLEvent;
+exports.toTransitionConfigArray = toTransitionConfigArray;
+exports.transitionNode = transitionNode;