xstate 4.35.2 → 5.0.0-alpha.1

package/dist/actions-b673cb13.esm.js

@@ -0,0 +1,4660 @@
+import { I as IS_PRODUCTION, d as devToolsAdapter } from './index-20b364c4.esm.js';
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+// TODO: replace in v5 with:
+// export type IndexByType<T extends { type: string }> = { [E in T as E['type']]: E; };
+
+/**
+ * The full definition of an event, with a string `type`.
+ */
+// TODO: do not accept machines without all implementations
+// we should also accept a raw machine as a behavior here
+// or just make machine a behavior
+// TODO: narrow this to behaviors from machine
+// TODO: fix last param
+
+/**
+ * Extracts action objects that have no extra properties.
+ */
+
+/**
+ * The string or object representing the state value relative to the parent state node.
+ *
+ * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
+ */
+// TODO: remove once TS fixes this type-widening issue
+// TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
+var ActionTypes;
+
+(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";
+})(ActionTypes || (ActionTypes = {}));
+
+var SpecialTargets;
+
+(function (SpecialTargets) {
+  SpecialTargets["Parent"] = "#_parent";
+  SpecialTargets["Internal"] = "#_internal";
+})(SpecialTargets || (SpecialTargets = {}));
+
+var stop = ActionTypes.Stop;
+var raise = ActionTypes.Raise;
+var send = ActionTypes.Send;
+var cancel = ActionTypes.Cancel;
+var assign = ActionTypes.Assign;
+var after = ActionTypes.After;
+var doneState = ActionTypes.DoneState;
+var log = ActionTypes.Log;
+var init = ActionTypes.Init;
+var invoke = ActionTypes.Invoke;
+var errorExecution = ActionTypes.ErrorExecution;
+var errorPlatform = ActionTypes.ErrorPlatform;
+var error = ActionTypes.ErrorCustom;
+var choose = ActionTypes.Choose;
+var pure = 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() {};
+
+if (!IS_PRODUCTION) {
+  warn = function warn(condition, message) {
+    var error = condition instanceof Error ? condition : undefined;
+
+    if (!error && condition) {
+      return;
+    }
+
+    if (console !== undefined) {
+      var args = ["Warning: ".concat(message)];
+
+      if (error) {
+        args.push(error);
+      } // tslint:disable-next-line:no-console
+
+
+      console.warn.apply(console, args);
+    }
+  };
+}
+
+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 === SpecialTargets.Parent) {
+        targetActorRef = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self._parent;
+      } else if (resolvedTarget === 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 === 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: 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: 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", 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];
+  }
+}
+
+var ActorStatus;
+
+(function (ActorStatus) {
+  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
+  ActorStatus[ActorStatus["Running"] = 1] = "Running";
+  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
+})(ActorStatus || (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", 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 === 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 !== 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 === 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 === ActorStatus.Running) {
+        // Do not restart the service if it is already started
+        return this;
+      }
+
+      registry.register(this.sessionId, this.ref);
+      this.status = 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 === ActorStatus.Stopped) {
+        return this;
+      }
+
+      this.mailbox.clear();
+
+      if (this.status === ActorStatus.NotStarted) {
+        this.status = 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 !== 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 = 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 === ActorStatus.Stopped) {
+        // do nothing
+        if (!IS_PRODUCTION) {
+          var eventString = JSON.stringify(_event.data);
+          warn(false, "Event \"".concat(_event.name.toString(), "\" was sent to stopped actor \"").concat(this.id, " (").concat(this.sessionId, ")\". This actor has already reached its final state, and will not transition.\nEvent: ").concat(eventString));
+        }
+
+        return;
+      }
+
+      if (this.status !== 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 : 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 === 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 !== 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;
+    }
+
+    if (!IS_PRODUCTION) {
+      warn(!/.*\*.+/.test(eventType), "Wildcards can only be the last token of an event descriptor (e.g., \"event.*\") or the entire event descriptor (\"*\"). Check the \"".concat(eventType, "\" event."));
+    }
+
+    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;
+
+        if (!IS_PRODUCTION) {
+          warn(isLastToken, "Infix wildcards in transition events are not allowed. Check the \"".concat(eventType, "\" event."));
+        }
+
+        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?
+
+  if (!IS_PRODUCTION && transitionConfig.cond) {
+    throw new Error("State \"".concat(stateNode.id, "\" has declared `cond` for one of its transitions. This property has been renamed to `guard`. Please update your code."));
+  }
+
+  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) === 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) {
+  if (!IS_PRODUCTION && scxmlEvent.name === WILDCARD) {
+    throw new Error("An event cannot have the wildcard type ('".concat(WILDCARD, "')"));
+  }
+
+  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) {
+      if (IS_PRODUCTION) {
+        warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
+      }
+
+      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) {
+        if (!IS_PRODUCTION) {
+          warn(false, "Actor type '".concat(resolvedInvokeAction.params.src.type, "' not found in machine '").concat(actorCtx.id, "'."));
+        }
+
+        return;
+      }
+
+      ref._parent = interpreter; // TODO: fix
+
+      actorCtx.defer(function () {
+        if (actorRef.status === 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(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(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(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(ActionTypes.ErrorPlatform, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+
+export { stop$1 as $, getConfiguration as A, getStateNodes as B, resolveStateValue as C, isInFinalState as D, toSCXMLEvent as E, isSCXMLErrorEvent as F, macrostep as G, transitionNode as H, _slicedToArray as I, getInitialConfiguration as J, initEvent as K, resolveActionsAndContext as L, microstep as M, NULL_EVENT as N, isStateId as O, isStateConfig as P, isFunction as Q, STATE_DELIMITER as R, State as S, matchesState as T, raise$1 as U, send$1 as V, sendParent as W, sendTo as X, log$1 as Y, cancel$1 as Z, _createClass as _, toTransitionConfigArray as a, assign$1 as a0, after$1 as a1, done as a2, respond as a3, forwardTo as a4, escalate as a5, choose$1 as a6, interpret as a7, Interpreter as a8, ActorStatus as a9, doneInvoke as aa, pathToStateValue as ab, toObserver as ac, ActionTypes as ad, SpecialTargets as ae, fromReducer as af, startSignalType as ag, stopSignalType as ah, startSignal as ai, stopSignal as aj, fromCallback as ak, fromPromise as al, fromObservable as am, fromEventObservable as an, isActorRef as ao, toActorRef as ap, stateIn as aq, not as ar, and as as, or as at, toGuardDefinition as au, actionTypes as av, resolveActionObject as aw, toActionObject as ax, error$1 as ay, formatTransition as b, createDynamicAction as c, memo as d, _createForOfIteratorHelper as e, formatTransitions as f, evaluateGuard as g, _toConsumableArray as h, flatten as i, _classCallCheck as j, _defineProperty as k, toActionObjects as l, mapValues as m, createInvokeId as n, toInvokeConfig as o, pure as p, _objectSpread2 as q, invoke as r, _objectWithoutProperties as s, toArray as t, getDelayedTransitions as u, formatInitialTransition as v, getCandidates as w, toInvokeSource as x, isString as y, createSpawner as z };