xstate 4.31.0 → 5.0.0-alpha.0

package/dist/actions-70094c93.cjs.prod.js

@@ -0,0 +1,4765 @@
+'use strict';
+
+var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.prod.js');
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+(function (ActionTypes) {
+  ActionTypes["Stop"] = "xstate.stop";
+  ActionTypes["Raise"] = "xstate.raise";
+  ActionTypes["Send"] = "xstate.send";
+  ActionTypes["Cancel"] = "xstate.cancel";
+  ActionTypes["Assign"] = "xstate.assign";
+  ActionTypes["After"] = "xstate.after";
+  ActionTypes["DoneState"] = "done.state";
+  ActionTypes["DoneInvoke"] = "done.invoke";
+  ActionTypes["Log"] = "xstate.log";
+  ActionTypes["Init"] = "xstate.init";
+  ActionTypes["Invoke"] = "xstate.invoke";
+  ActionTypes["ErrorExecution"] = "error.execution";
+  ActionTypes["ErrorCommunication"] = "error.communication";
+  ActionTypes["ErrorPlatform"] = "error.platform";
+  ActionTypes["ErrorCustom"] = "xstate.error";
+  ActionTypes["Update"] = "xstate.update";
+  ActionTypes["Pure"] = "xstate.pure";
+  ActionTypes["Choose"] = "xstate.choose";
+})(exports.ActionTypes || (exports.ActionTypes = {}));
+
+(function (SpecialTargets) {
+  SpecialTargets["Parent"] = "#_parent";
+  SpecialTargets["Internal"] = "#_internal";
+})(exports.SpecialTargets || (exports.SpecialTargets = {}));
+
+var stop = exports.ActionTypes.Stop;
+var raise = exports.ActionTypes.Raise;
+var send = exports.ActionTypes.Send;
+var cancel = exports.ActionTypes.Cancel;
+var assign = exports.ActionTypes.Assign;
+var after = exports.ActionTypes.After;
+var doneState = exports.ActionTypes.DoneState;
+var log = exports.ActionTypes.Log;
+var init = exports.ActionTypes.Init;
+var invoke = exports.ActionTypes.Invoke;
+var errorExecution = exports.ActionTypes.ErrorExecution;
+var errorPlatform = exports.ActionTypes.ErrorPlatform;
+var error = exports.ActionTypes.ErrorCustom;
+var update = exports.ActionTypes.Update;
+var choose = exports.ActionTypes.Choose;
+var pure = exports.ActionTypes.Pure;
+
+var actionTypes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  stop: stop,
+  raise: raise,
+  send: send,
+  cancel: cancel,
+  assign: assign,
+  after: after,
+  doneState: doneState,
+  log: log,
+  init: init,
+  invoke: invoke,
+  errorExecution: errorExecution,
+  errorPlatform: errorPlatform,
+  error: error,
+  update: update,
+  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 getEventType(event) {
+  try {
+    return isString(event) || typeof event === 'number' ? "".concat(event) : event.type;
+  } catch (e) {
+    throw new Error('Events must be strings or objects with a string event.type property.');
+  }
+}
+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 isBuiltInEvent(eventType) {
+  return /^(done|error)\./.test(eventType);
+}
+function isPromiseLike(value) {
+  if (value instanceof Promise) {
+    return true;
+  } // Check if shape matches the Promise/A+ specification for a "thenable".
+
+
+  if (value !== null && (isFunction(value) || _typeof(value) === 'object') && isFunction(value.then)) {
+    return true;
+  }
+
+  return false;
+}
+
+var warn = function warn() {};
+
+function isArray(value) {
+  return Array.isArray(value);
+} // tslint:disable-next-line:ban-types
+
+function isFunction(value) {
+  return typeof value === 'function';
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+var symbolObservable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
+function isStateMachine(value) {
+  return !!value && '__xstatenode' in value;
+}
+function toEventObject(event, payload) {
+  if (isString(event)) {
+    return _objectSpread2({
+      type: event
+    }, payload);
+  }
+
+  return event;
+}
+function isSCXMLEvent(event) {
+  return !isString(event) && '$$type' in event && event.$$type === 'scxml';
+}
+function isSCXMLErrorEvent(event) {
+  return event.name === errorExecution || event.name.startsWith(errorPlatform);
+}
+function toSCXMLEvent(event, scxmlEvent) {
+  if (isSCXMLEvent(event)) {
+    return event;
+  }
+
+  var eventObject = toEventObject(event);
+  return _objectSpread2({
+    name: eventObject.type,
+    data: eventObject,
+    $$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: function src() {
+          return invocable;
+        }
+      };
+    }
+  }
+
+  return {
+    id: id,
+    src: invocable
+  };
+}
+function toInvokeSource(src) {
+  if (typeof src === 'string') {
+    return {
+      type: src
+    };
+  }
+
+  return src;
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+  if (_typeof(nextHandler) === 'object') {
+    return nextHandler;
+  }
+
+  var noop = function noop() {
+    return void 0;
+  };
+
+  return {
+    next: nextHandler,
+    error: errorHandler || noop,
+    complete: completionHandler || noop
+  };
+}
+function createInvokeId(stateNodeId, index) {
+  return "".concat(stateNodeId, ":invocation[").concat(index, "]");
+}
+
+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;
+}
+
+// TODO: refactor out of class
+var ExecutableAction = /*#__PURE__*/function () {
+  function ExecutableAction(actionObject, _exec) {
+    var _actionObject$params;
+
+    _classCallCheck(this, ExecutableAction);
+
+    this.actionObject = actionObject;
+    this._exec = _exec;
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "params", void 0);
+
+    _defineProperty(this, "context", undefined);
+
+    this.type = actionObject.type;
+    this.params = (_actionObject$params = actionObject.params) !== null && _actionObject$params !== void 0 ? _actionObject$params : {};
+  }
+
+  _createClass(ExecutableAction, [{
+    key: "execute",
+    value: function execute(state) {
+      var _this$context, _this$_exec;
+
+      var context = (_this$context = this.context) !== null && _this$context !== void 0 ? _this$context : state.context;
+      return (_this$_exec = this._exec) === null || _this$_exec === void 0 ? void 0 : _this$_exec.call(this, context, state.event, {
+        action: this.actionObject,
+        _event: state._event,
+        state: state
+      });
+    }
+  }, {
+    key: "setContext",
+    value: function setContext(context) {
+      this.context = context;
+    }
+  }]);
+
+  return ExecutableAction;
+}();
+function isExecutableAction(action) {
+  return 'execute' in action && typeof action.execute === 'function';
+}
+
+function createDynamicAction(type, params, resolve) {
+  return {
+    type: type,
+    params: 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 : toEventObject(event);
+  return createDynamicAction(send, {
+    to: options ? options.to : undefined,
+    delay: options ? options.delay : undefined,
+    event: eventOrExpr,
+    id: options && options.id !== undefined ? options.id : isFunction(event) ? event.name : getEventType(event)
+  }, function (_ref, ctx, _event, _ref2) {
+    var params = _ref.params;
+    var machine = _ref2.machine;
+    var meta = {
+      _event: _event
+    };
+    var delaysMap = machine.options.delays; // TODO: helper function for resolving Expr
+
+    var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(ctx, _event.data, meta) : eventOrExpr);
+    var resolvedDelay;
+
+    if (isString(params.delay)) {
+      var configDelay = delaysMap && delaysMap[params.delay];
+      resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+    } else {
+      resolvedDelay = isFunction(params.delay) ? params.delay(ctx, _event.data, meta) : params.delay;
+    }
+
+    var resolvedTarget = isFunction(params.to) ? params.to(ctx, _event.data, meta) : params.to;
+    resolvedTarget = isString(resolvedTarget) && resolvedTarget !== exports.SpecialTargets.Parent && resolvedTarget !== exports.SpecialTargets.Internal && resolvedTarget.startsWith('#_') ? resolvedTarget.slice(2) : resolvedTarget;
+    return {
+      type: send,
+      params: _objectSpread2(_objectSpread2({
+        id: ''
+      }, params), {}, {
+        to: resolvedTarget,
+        _event: resolvedEvent,
+        event: resolvedEvent.data,
+        delay: resolvedDelay
+      })
+    };
+  });
+}
+/**
+ * Sends an update event to this machine's parent.
+ */
+
+function sendUpdate() {
+  return sendParent(update);
+}
+/**
+ * Sends an event to this machine's parent.
+ *
+ * @param event The event to send to the parent machine.
+ * @param options Options to pass into the send event.
+ */
+
+function sendParent(event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: exports.SpecialTargets.Parent
+  }));
+}
+/**
+ * Sends an event back to the sender of the original event.
+ *
+ * @param event The event to send back to the sender
+ * @param options Options to pass into the send event
+ */
+
+function respond(event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: function to(_, __, _ref3) {
+      var _event = _ref3._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) {
+  return send$1(function (_, event) {
+    return event;
+  }, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: target
+  }));
+}
+/**
+ * Escalates an error by sending it as an event to this machine's parent.
+ *
+ * @param errorData The error data to send, or the expression function that
+ * takes in the `context`, `event`, and `meta`, and returns the error data to send.
+ * @param options Options to pass into the send action creator.
+ */
+
+function escalate(errorData, options) {
+  return sendParent(function (context, event, meta) {
+    return {
+      type: error,
+      data: isFunction(errorData) ? errorData(context, event, meta) : errorData
+    };
+  }, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: exports.SpecialTargets.Parent
+  }));
+}
+/**
+ * Sends an event to an actor.
+ *
+ * @param actor The `ActorRef` to send the event to.
+ * @param event The event to send, or an expression that evaluates to the event to send
+ * @param options Send action options
+ * @returns An XState send action object
+ */
+
+function sendTo(actor, event, options) {
+  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+    to: actor
+  }));
+}
+
+/**
+ * Stops an actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+function stop$1(actorRef) {
+  var actor = actorRef;
+  return createDynamicAction(stop, {
+    actor: actor
+  }, function (_ref, context, _event) {
+    var params = _ref.params,
+        type = _ref.type;
+    var actorRefOrString = isFunction(params.actor) ? params.actor(context, _event.data) : params.actor;
+    return {
+      type: type,
+      params: {
+        actor: actorRefOrString
+      }
+    };
+  });
+}
+
+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(log, {
+    label: label,
+    expr: expr
+  }, function (_ref, ctx, _event) {
+    var type = _ref.type;
+    return {
+      type: type,
+      params: {
+        label: label,
+        value: typeof expr === 'function' ? expr(ctx, _event.data, {
+          _event: _event
+        }) : expr
+      }
+    };
+  });
+}
+
+/**
+ * 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(cancel, {
+    sendId: sendId
+  }, function (_ref, ctx, _event) {
+    var params = _ref.params,
+        type = _ref.type;
+    var resolvedSendId = isFunction(params.sendId) ? params.sendId(ctx, _event.data, {
+      _event: _event
+    }) : params.sendId;
+    return {
+      type: type,
+      params: {
+        sendId: resolvedSendId
+      }
+    };
+  });
+}
+
+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);
+  }
+};
+
+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;
+}
+
+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 _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 invoke$1(invokeDef) {
+  return createDynamicAction(invoke, invokeDef, function (_ref, context, _event, _ref2) {
+    var params = _ref.params;
+    var machine = _ref2.machine;
+    var type = invoke;
+    var id = params.id,
+        data = params.data,
+        src = params.src,
+        meta = params.meta;
+
+    if (isActorRef(src)) {
+      return {
+        type: type,
+        params: _objectSpread2(_objectSpread2({}, params), {}, {
+          ref: src
+        })
+      };
+    }
+
+    var behaviorImpl = machine.options.actors[src.type];
+
+    if (!behaviorImpl) {
+      return {
+        type: type,
+        params: params
+      };
+    }
+
+    var behavior = typeof behaviorImpl === 'function' ? behaviorImpl(context, _event.data, {
+      id: id,
+      data: data && mapContext(data, context, _event),
+      src: src,
+      _event: _event,
+      meta: meta
+    }) : behaviorImpl;
+    return {
+      type: type,
+      params: _objectSpread2(_objectSpread2({}, params), {}, {
+        id: params.id,
+        src: params.src,
+        ref: new ObservableActorRef(behavior, id),
+        meta: meta
+      })
+    };
+  });
+}
+
+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, machine) {
+  var _machine$options$guar, _machine$options, _machine$options$guar2;
+
+  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
+  };
+}
+
+var isAtomicStateNode = function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+};
+function getChildren(stateNode) {
+  return Object.keys(stateNode.states).map(function (key) {
+    return stateNode.states[key];
+  }); // .filter((sn) => 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 mutConfiguration = new Set(stateNodes);
+  var adjList = getAdjList(mutConfiguration); // 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 mutConfiguration.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 (!mutConfiguration.has(child)) {
+                getInitialStateNodes(child).forEach(function (sn) {
+                  return mutConfiguration.add(sn);
+                });
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+    } // add all ancestors
+
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var _iterator2 = _createForOfIteratorHelper(mutConfiguration),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _s = _step2.value;
+      var m = _s.parent;
+
+      while (m) {
+        mutConfiguration.add(m);
+        m = m.parent;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return mutConfiguration;
+}
+
+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 = {};
+  childStateNodes.forEach(function (csn) {
+    stateValue[csn.key] = getValueFromAdj(csn, adjList);
+  });
+  return stateValue;
+}
+
+function getAdjList(configuration) {
+  var adjList = new Map();
+
+  var _iterator4 = _createForOfIteratorHelper(configuration),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var s = _step4.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) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  return adjList;
+}
+function getStateValue(rootNode, configuration) {
+  var config = getConfiguration(configuration);
+  return getValueFromAdj(rootNode, getAdjList(config));
+}
+function has(iterable, item) {
+  if (Array.isArray(iterable)) {
+    return iterable.some(function (member) {
+      return member === item;
+    });
+  }
+
+  if (iterable instanceof Set) {
+    return iterable.has(item);
+  }
+
+  return false; // TODO: fix
+}
+function nextEvents(configuration) {
+  return _toConsumableArray(new Set(flatten(_toConsumableArray(configuration.map(function (sn) {
+    return sn.ownEvents;
+  })))));
+}
+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' && has(configuration, s);
+    });
+  }
+
+  if (stateNode.type === 'parallel') {
+    return getChildren(stateNode).every(function (sn) {
+      return isInFinalState(configuration, sn);
+    });
+  }
+
+  return false;
+}
+var isStateId = function isStateId(str) {
+  return str[0] === STATE_IDENTIFIER;
+};
+function getCandidates(stateNode, receivedEventType) {
+  var partialMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var candidates = stateNode.transitions.filter(function (transition) {
+    var eventType = transition.eventType; // First, check the trivial case: event names are exactly equal
+
+    if (eventType === receivedEventType) {
+      return true;
+    } // Then, check if transition is a wildcard transition,
+    // which matches any non-transient events
+
+
+    if (eventType === WILDCARD) {
+      return true;
+    }
+
+    if (!partialMatch && !eventType.endsWith('.*')) {
+      return false;
+    }
+
+    var partialEventTokens = eventType.split('.');
+    var eventTokens = receivedEventType.split('.');
+
+    for (var tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+      var partialEventToken = partialEventTokens[tokenIndex];
+      var eventToken = eventTokens[tokenIndex];
+
+      if (partialEventToken === '*') {
+        var isLastToken = tokenIndex === partialEventTokens.length - 1;
+
+        return isLastToken;
+      }
+
+      if (partialEventToken !== eventToken) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+  return candidates;
+}
+/**
+ * All delayed transitions from the config.
+ */
+
+function getDelayedTransitions(stateNode) {
+  var afterConfig = stateNode.config.after;
+
+  if (!afterConfig) {
+    return [];
+  }
+
+  var mutateEntryExit = function mutateEntryExit(delay, i) {
+    var delayRef = isFunction(delay) ? "".concat(stateNode.id, ":delay[").concat(i, "]") : delay;
+    var eventType = after$1(delayRef, stateNode.id);
+    stateNode.entry.push(send$1(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
+    });
+  }) : flatten(Object.keys(afterConfig).map(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 = '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);
+
+  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));
+
+    Object.keys(namedTransitionConfigs).forEach(function (eventType) {
+      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 = flatten(stateNode.invoke.map(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 = flatten([].concat(_toConsumableArray(doneConfig), _toConsumableArray(invokeConfig), transitionConfigs).map(function (transitionConfig) {
+    return toArray(transitionConfig).map(function (transition) {
+      return formatTransition(stateNode, transition);
+    });
+  }));
+
+  var _iterator5 = _createForOfIteratorHelper(delayedTransitions),
+      _step5;
+
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var delayedTransition = _step5.value;
+      formattedTransitions.push(delayedTransition);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.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, _target) {
+  if (_target === undefined) {
+    // an undefined target signals that the state node should not transition from that state when receiving that event
+    return undefined;
+  }
+
+  return _target.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, t) : t;
+  });
+}
+
+function isHistoryNode(stateNode) {
+  return stateNode.type === 'history';
+}
+
+function getInitialStateNodes(stateNode) {
+  var transitions = [{
+    target: [stateNode],
+    source: stateNode,
+    actions: [],
+    eventType: 'init',
+    toJSON: null // TODO: fix
+
+  }];
+  var mutStatesToEnter = new Set();
+  var mutStatesForDefaultEntry = new Set();
+  computeEntrySet(transitions, State.from({}), mutStatesToEnter, mutStatesForDefaultEntry);
+  return _toConsumableArray(mutStatesToEnter);
+}
+/**
+ * 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.states[stateValue]];
+  }
+
+  var childStateKeys = Object.keys(stateValue);
+  var childStateNodes = childStateKeys.map(function (subStateKey) {
+    return getStateNode(stateNode, subStateKey);
+  }).filter(Boolean);
+  return childStateNodes.concat(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 transitionLeafNode(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 transitionMap = {};
+
+  for (var _i = 0, _Object$keys = Object.keys(stateValue); _i < _Object$keys.length; _i++) {
+    var subStateKey = _Object$keys[_i];
+    var subStateValue = stateValue[subStateKey];
+
+    if (!subStateValue) {
+      continue;
+    }
+
+    var subStateNode = getStateNode(stateNode, subStateKey);
+    var nextStateNode = transitionNode(subStateNode, subStateValue, state, _event);
+
+    if (nextStateNode) {
+      transitionMap[subStateKey] = nextStateNode;
+    }
+  }
+
+  var transitions = Object.keys(transitionMap).map(function (key) {
+    return transitionMap[key];
+  });
+  var enabledTransitions = flatten(transitions);
+  var willTransition = transitions.some(function (st) {
+    return st.length > 0;
+  });
+
+  if (!willTransition) {
+    return stateNode.next(state, _event);
+  }
+
+  return enabledTransitions;
+}
+function transitionNode(stateNode, stateValue, state, _event) {
+  // leaf node
+  if (isString(stateValue)) {
+    return transitionLeafNode(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 getChildren(stateNode).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 _iterator6 = _createForOfIteratorHelper(set1),
+      _step6;
+
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var item = _step6.value;
+
+      if (set2.has(item)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+
+  var _iterator7 = _createForOfIteratorHelper(set2),
+      _step7;
+
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var _item = _step7.value;
+
+      if (set1.has(_item)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+
+  return false;
+}
+
+function removeConflictingTransitions(enabledTransitions, configuration, state) {
+  var filteredTransitions = new Set();
+
+  var _iterator8 = _createForOfIteratorHelper(enabledTransitions),
+      _step8;
+
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var t1 = _step8.value;
+      var t1Preempted = false;
+      var transitionsToRemove = new Set();
+
+      var _iterator9 = _createForOfIteratorHelper(filteredTransitions),
+          _step9;
+
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var t2 = _step9.value;
+
+          if (hasIntersection(computeExitSet([t1], configuration, state), computeExitSet([t2], configuration, state))) {
+            if (isDescendant(t1.source, t2.source)) {
+              transitionsToRemove.add(t2);
+            } else {
+              t1Preempted = true;
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+
+      if (!t1Preempted) {
+        var _iterator10 = _createForOfIteratorHelper(transitionsToRemove),
+            _step10;
+
+        try {
+          for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+            var t3 = _step10.value;
+            filteredTransitions["delete"](t3);
+          }
+        } catch (err) {
+          _iterator10.e(err);
+        } finally {
+          _iterator10.f();
+        }
+
+        filteredTransitions.add(t1);
+      }
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+
+  return Array.from(filteredTransitions);
+}
+
+function findLCCA(stateNodes) {
+  var _stateNodes = _slicedToArray(stateNodes, 1),
+      head = _stateNodes[0];
+
+  var current = getPathFromRootToNode(head);
+  var candidates = [];
+  stateNodes.forEach(function (stateNode) {
+    var path = getPathFromRootToNode(stateNode);
+    candidates = current.filter(function (sn) {
+      return path.includes(sn);
+    });
+    current = candidates;
+    candidates = [];
+  });
+  return current[current.length - 1];
+}
+
+function getEffectiveTargetStates(transition, state) {
+  if (!transition.target) {
+    return [];
+  }
+
+  var targets = new Set();
+
+  var _iterator11 = _createForOfIteratorHelper(transition.target),
+      _step11;
+
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var s = _step11.value;
+
+      if (isHistoryNode(s)) {
+        if (state.historyValue[s.id]) {
+          state.historyValue[s.id].forEach(function (node) {
+            targets.add(node);
+          });
+        } else {
+          getEffectiveTargetStates({
+            target: resolveHistoryTarget(s)
+          }, state).forEach(function (node) {
+            targets.add(node);
+          });
+        }
+      } else {
+        targets.add(s);
+      }
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
+
+  return _toConsumableArray(targets);
+}
+
+function getTransitionDomain(transition, state) {
+  var targetStates = getEffectiveTargetStates(transition, state);
+
+  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 exitStates(transitions, mutConfiguration, state) {
+  var statesToExit = computeExitSet(transitions, mutConfiguration, state);
+  var actions = [];
+  statesToExit.forEach(function (stateNode) {
+    actions.push.apply(actions, _toConsumableArray(stateNode.invoke.map(function (def) {
+      return stop$1(def.id);
+    })));
+  });
+  statesToExit.sort(function (a, b) {
+    return b.order - a.order;
+  });
+  var historyValue = resolveHistoryValue(state, statesToExit);
+
+  var _iterator12 = _createForOfIteratorHelper(statesToExit),
+      _step12;
+
+  try {
+    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+      var s = _step12.value;
+      actions.push.apply(actions, _toConsumableArray(flatten(s.exit)));
+      mutConfiguration["delete"](s);
+    }
+  } catch (err) {
+    _iterator12.e(err);
+  } finally {
+    _iterator12.f();
+  }
+
+  return {
+    exitSet: statesToExit,
+    historyValue: historyValue,
+    actions: actions,
+    configuration: mutConfiguration
+  };
+}
+
+function enterStates(transitions, mutConfiguration, state) {
+  var statesToInvoke = new Set();
+  var internalQueue = [];
+  var actions = [];
+  var mutStatesToEnter = new Set();
+  var mutStatesForDefaultEntry = new Set();
+  computeEntrySet(transitions, state, mutStatesToEnter, mutStatesForDefaultEntry);
+
+  var _iterator13 = _createForOfIteratorHelper(_toConsumableArray(mutStatesToEnter).sort(function (a, b) {
+    return a.order - b.order;
+  })),
+      _step13;
+
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var stateNodeToEnter = _step13.value;
+      mutConfiguration.add(stateNodeToEnter);
+      statesToInvoke.add(stateNodeToEnter); // Add entry actions
+
+      actions.push.apply(actions, _toConsumableArray(stateNodeToEnter.entry));
+
+      if (mutStatesForDefaultEntry.has(stateNodeToEnter)) {
+        mutStatesForDefaultEntry.forEach(function (stateNode) {
+          actions.push.apply(actions, _toConsumableArray(stateNode.initial.actions));
+        });
+      } // if (defaultHistoryContent[s.id]) {
+      //   actions.push(...defaultHistoryContent[s.id])
+      // }
+
+
+      if (stateNodeToEnter.type === 'final') {
+        var parent = stateNodeToEnter.parent;
+
+        if (!parent.parent) {
+          continue;
+        }
+
+        internalQueue.push(toSCXMLEvent(done(parent.id, stateNodeToEnter.doneData ? mapContext(stateNodeToEnter.doneData, state.context, state._event) : undefined)));
+
+        if (parent.parent) {
+          var grandparent = parent.parent;
+
+          if (grandparent.type === 'parallel') {
+            if (getChildren(grandparent).filter(function (child) {
+              return child.type !== 'history';
+            }).every(function (parentNode) {
+              return isInFinalState(_toConsumableArray(mutConfiguration), parentNode);
+            })) {
+              internalQueue.push(toSCXMLEvent(done(grandparent.id)));
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
+  }
+
+  return {
+    statesToInvoke: statesToInvoke,
+    internalQueue: internalQueue,
+    actions: actions
+  };
+}
+
+function computeExitSet(transitions, configuration, state) {
+  var statesToExit = new Set();
+
+  var _iterator14 = _createForOfIteratorHelper(transitions),
+      _step14;
+
+  try {
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var t = _step14.value;
+
+      if (t.target && t.target.length) {
+        var domain = getTransitionDomain(t, state);
+
+        var _iterator15 = _createForOfIteratorHelper(configuration),
+            _step15;
+
+        try {
+          for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+            var s = _step15.value;
+
+            if (isDescendant(s, domain)) {
+              statesToExit.add(s);
+            }
+          }
+        } catch (err) {
+          _iterator15.e(err);
+        } finally {
+          _iterator15.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator14.e(err);
+  } finally {
+    _iterator14.f();
+  }
+
+  return _toConsumableArray(statesToExit);
+}
+
+function computeEntrySet(transitions, state, mutStatesToEnter, mutStatesForDefaultEntry) {
+  var _iterator16 = _createForOfIteratorHelper(transitions),
+      _step16;
+
+  try {
+    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      var t = _step16.value;
+
+      var _iterator17 = _createForOfIteratorHelper(t.target || []),
+          _step17;
+
+      try {
+        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+          var s = _step17.value;
+          addDescendantStatesToEnter(s, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator17.e(err);
+      } finally {
+        _iterator17.f();
+      }
+
+      var ancestor = getTransitionDomain(t, state);
+      var targetStates = getEffectiveTargetStates(t, state);
+
+      var _iterator18 = _createForOfIteratorHelper(targetStates),
+          _step18;
+
+      try {
+        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+          var _s2 = _step18.value;
+          addAncestorStatesToEnter(_s2, ancestor, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator18.e(err);
+      } finally {
+        _iterator18.f();
+      }
+    }
+  } catch (err) {
+    _iterator16.e(err);
+  } finally {
+    _iterator16.f();
+  }
+}
+
+function addDescendantStatesToEnter(stateNode, state, mutStatesToEnter, mutStatesForDefaultEntry) {
+  if (isHistoryNode(stateNode)) {
+    if (state.historyValue[stateNode.id]) {
+      var historyStateNodes = state.historyValue[stateNode.id];
+
+      var _iterator19 = _createForOfIteratorHelper(historyStateNodes),
+          _step19;
+
+      try {
+        for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+          var s = _step19.value;
+          addDescendantStatesToEnter(s, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator19.e(err);
+      } finally {
+        _iterator19.f();
+      }
+
+      var _iterator20 = _createForOfIteratorHelper(historyStateNodes),
+          _step20;
+
+      try {
+        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+          var _s3 = _step20.value;
+          addAncestorStatesToEnter(_s3, stateNode.parent, state, mutStatesToEnter, mutStatesForDefaultEntry);
+          mutStatesForDefaultEntry.forEach(function (stateForDefaultEntry) {
+            return mutStatesForDefaultEntry.add(stateForDefaultEntry);
+          });
+        }
+      } catch (err) {
+        _iterator20.e(err);
+      } finally {
+        _iterator20.f();
+      }
+    } else {
+      var targets = resolveHistoryTarget(stateNode);
+
+      var _iterator21 = _createForOfIteratorHelper(targets),
+          _step21;
+
+      try {
+        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+          var _s4 = _step21.value;
+          addDescendantStatesToEnter(_s4, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator21.e(err);
+      } finally {
+        _iterator21.f();
+      }
+
+      var _iterator22 = _createForOfIteratorHelper(targets),
+          _step22;
+
+      try {
+        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+          var _s5 = _step22.value;
+          addAncestorStatesToEnter(_s5, stateNode, state, mutStatesToEnter, mutStatesForDefaultEntry);
+          mutStatesForDefaultEntry.forEach(function (stateForDefaultEntry) {
+            return mutStatesForDefaultEntry.add(stateForDefaultEntry);
+          });
+        }
+      } catch (err) {
+        _iterator22.e(err);
+      } finally {
+        _iterator22.f();
+      }
+    }
+  } else {
+    mutStatesToEnter.add(stateNode);
+
+    if (stateNode.type === 'compound') {
+      mutStatesForDefaultEntry.add(stateNode);
+      var initialStates = stateNode.initial.target;
+
+      var _iterator23 = _createForOfIteratorHelper(initialStates),
+          _step23;
+
+      try {
+        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+          var initialState = _step23.value;
+          addDescendantStatesToEnter(initialState, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator23.e(err);
+      } finally {
+        _iterator23.f();
+      }
+
+      var _iterator24 = _createForOfIteratorHelper(initialStates),
+          _step24;
+
+      try {
+        for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
+          var _initialState = _step24.value;
+          addAncestorStatesToEnter(_initialState, stateNode, state, mutStatesToEnter, mutStatesForDefaultEntry);
+        }
+      } catch (err) {
+        _iterator24.e(err);
+      } finally {
+        _iterator24.f();
+      }
+    } else {
+      if (stateNode.type === 'parallel') {
+        var _iterator25 = _createForOfIteratorHelper(getChildren(stateNode).filter(function (sn) {
+          return !isHistoryNode(sn);
+        })),
+            _step25;
+
+        try {
+          var _loop = function _loop() {
+            var child = _step25.value;
+
+            if (!_toConsumableArray(mutStatesToEnter).some(function (s) {
+              return isDescendant(s, child);
+            })) {
+              addDescendantStatesToEnter(child, state, mutStatesToEnter, mutStatesForDefaultEntry);
+            }
+          };
+
+          for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
+            _loop();
+          }
+        } catch (err) {
+          _iterator25.e(err);
+        } finally {
+          _iterator25.f();
+        }
+      }
+    }
+  }
+}
+
+function addAncestorStatesToEnter(stateNode, toStateNode, state, mutStatesToEnter, mutStatesForDefaultEntry) {
+  var properAncestors = getProperAncestors(stateNode, toStateNode);
+
+  var _iterator26 = _createForOfIteratorHelper(properAncestors),
+      _step26;
+
+  try {
+    for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+      var anc = _step26.value;
+      mutStatesToEnter.add(anc);
+
+      if (anc.type === 'parallel') {
+        var _iterator27 = _createForOfIteratorHelper(getChildren(anc).filter(function (sn) {
+          return !isHistoryNode(sn);
+        })),
+            _step27;
+
+        try {
+          var _loop2 = function _loop2() {
+            var child = _step27.value;
+
+            if (!_toConsumableArray(mutStatesToEnter).some(function (s) {
+              return isDescendant(s, child);
+            })) {
+              addDescendantStatesToEnter(child, state, mutStatesToEnter, mutStatesForDefaultEntry);
+            }
+          };
+
+          for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {
+            _loop2();
+          }
+        } catch (err) {
+          _iterator27.e(err);
+        } finally {
+          _iterator27.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator26.e(err);
+  } finally {
+    _iterator26.f();
+  }
+}
+/**
+ * https://www.w3.org/TR/scxml/#microstepProcedure
+ *
+ * @private
+ * @param transitions
+ * @param currentState
+ * @param mutConfiguration
+ */
+
+
+function microstep(transitions, currentState, context, mutConfiguration, machine, _event) {
+  var actions = [];
+  var filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, currentState || State.from({}));
+  var historyValue = {};
+  var internalQueue = []; // Exit states
+
+  if (!currentState._initial) {
+    var _exitStates = exitStates(filteredTransitions, mutConfiguration, currentState),
+        exitHistoryValue = _exitStates.historyValue,
+        exitActions = _exitStates.actions;
+
+    actions.push.apply(actions, _toConsumableArray(exitActions));
+    historyValue = exitHistoryValue;
+  } // Transition
+
+
+  var transitionActions = flatten(filteredTransitions.map(function (t) {
+    return t.actions;
+  }));
+  actions.push.apply(actions, _toConsumableArray(transitionActions)); // Enter states
+
+  var res = enterStates(filteredTransitions, mutConfiguration, currentState || State.from({})); // Start invocations
+
+  actions.push.apply(actions, _toConsumableArray(flatten(_toConsumableArray(res.statesToInvoke).map(function (s) {
+    return s.invoke.map(function (invokeDef) {
+      return invoke$1(invokeDef);
+    });
+  }))));
+  actions.push.apply(actions, _toConsumableArray(res.actions));
+
+  try {
+    var _resolveActionsAndCon = resolveActionsAndContext(actions, machine, _event, currentState, context),
+        resolvedActions = _resolveActionsAndCon.actions,
+        raised = _resolveActionsAndCon.raised,
+        resolvedContext = _resolveActionsAndCon.context;
+
+    internalQueue.push.apply(internalQueue, _toConsumableArray(res.internalQueue));
+    internalQueue.push.apply(internalQueue, _toConsumableArray(raised.map(function (a) {
+      return a.params._event;
+    })));
+    return {
+      actions: resolvedActions,
+      configuration: mutConfiguration,
+      historyValue: historyValue,
+      internalQueue: internalQueue,
+      context: resolvedContext
+    };
+  } catch (e) {
+    // TODO: Refactor this once proper error handling is implemented.
+    // See https://github.com/statelyai/rfcs/pull/4
+    if (machine.config.scxml) {
+      return {
+        actions: [],
+        configuration: mutConfiguration,
+        historyValue: historyValue,
+        internalQueue: [toSCXMLEvent({
+          type: 'error.execution'
+        })],
+        context: machine.context
+      };
+    } else {
+      throw e;
+    }
+  }
+}
+
+function selectEventlessTransitions(state, machine) {
+  var enabledTransitions = new Set();
+  var atomicStates = state.configuration.filter(isAtomicStateNode);
+
+  var _iterator28 = _createForOfIteratorHelper(atomicStates),
+      _step28;
+
+  try {
+    for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
+      var stateNode = _step28.value;
+
+      var _iterator29 = _createForOfIteratorHelper([stateNode].concat(getProperAncestors(stateNode, null))),
+          _step29;
+
+      try {
+        loop: for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {
+          var s = _step29.value;
+
+          if (!s.always) {
+            continue;
+          }
+
+          var _iterator30 = _createForOfIteratorHelper(s.always),
+              _step30;
+
+          try {
+            for (_iterator30.s(); !(_step30 = _iterator30.n()).done;) {
+              var t = _step30.value;
+
+              if (t.guard === undefined || evaluateGuard(t.guard, state.context, state._event, state, machine)) {
+                enabledTransitions.add(t);
+                break loop;
+              }
+            }
+          } catch (err) {
+            _iterator30.e(err);
+          } finally {
+            _iterator30.f();
+          }
+        }
+      } catch (err) {
+        _iterator29.e(err);
+      } finally {
+        _iterator29.f();
+      }
+    }
+  } catch (err) {
+    _iterator28.e(err);
+  } finally {
+    _iterator28.f();
+  }
+
+  return removeConflictingTransitions(Array.from(enabledTransitions), new Set(state.configuration), state);
+}
+
+function resolveMicroTransition(machine, transitions, currentState) {
+  var _event = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : initEvent;
+
+  // Transition will "apply" if:
+  // - the state node is the initial state (there is no current state)
+  // - OR there are transitions
+  // - OR there are eventless transitions (if there are no transitions)
+  var willTransition = currentState._initial || transitions.length > 0 || selectEventlessTransitions(currentState, machine).length > 0;
+  var prevConfig = getConfiguration(!currentState._initial ? currentState.configuration : [machine.root]);
+  var resolved = microstep(!currentState._initial ? transitions : [{
+    target: _toConsumableArray(prevConfig).filter(isAtomicStateNode),
+    source: machine.root,
+    actions: [],
+    eventType: null,
+    toJSON: null // TODO: fix
+
+  }], currentState, currentState.context, new Set(prevConfig), machine, _event);
+
+  if (!currentState._initial && !willTransition) {
+    var inertState = State.inert(currentState);
+    inertState.event = _event.data;
+    inertState._event = _event;
+    inertState.changed = _event.name === update;
+    return inertState;
+  }
+
+  var children = _objectSpread2({}, currentState.children);
+
+  var resolvedConfiguration = willTransition ? Array.from(resolved.configuration) : !currentState._initial ? currentState.configuration : [];
+  var meta = resolvedConfiguration.reduce(function (acc, subStateNode) {
+    if (subStateNode.meta !== undefined) {
+      acc[subStateNode.id] = subStateNode.meta;
+    }
+
+    return acc;
+  }, {});
+  var context = resolved.context,
+      nonRaisedActions = resolved.actions;
+  var nextState = machine.createState({
+    value: getStateValue(machine.root, resolved.configuration),
+    context: context,
+    _event: _event,
+    // Persist _sessionid between states
+    _sessionid: !currentState._initial ? currentState._sessionid : null,
+    actions: nonRaisedActions,
+    meta: meta,
+    configuration: resolvedConfiguration,
+    transitions: transitions,
+    children: children,
+    historyValue: resolved.historyValue
+  });
+  nextState.changed = currentState._initial ? undefined : !stateValuesEqual(nextState.value, currentState.value) || _event.name === update || nextState.actions.length > 0 || context !== currentState.context;
+  nextState._internalQueue = resolved.internalQueue;
+  nextState.actions.forEach(function (action) {
+    if (action.type === invoke && action.params.ref) {
+      var ref = action.params.ref;
+
+      if (ref) {
+        children[ref.name] = ref;
+      }
+    }
+  });
+  return nextState;
+}
+
+function resolveActionsAndContext(actions, machine, _event, currentState, context) {
+  var resolvedActions = [];
+  var raiseActions = [];
+  var preservedContexts = [context];
+
+  function resolveAction(actionObject) {
+    var executableActionObject = resolveActionObject(actionObject, machine.options.actions);
+
+    if (isDynamicAction(executableActionObject)) {
+      if (executableActionObject.type === pure || executableActionObject.type === choose) {
+        var matchedActions = executableActionObject.resolve(executableActionObject, context, _event, {
+          machine: machine,
+          state: currentState,
+          action: actionObject
+        }).params.actions;
+
+        if (matchedActions) {
+          toActionObjects(toArray(matchedActions), machine.options.actions).forEach(resolveAction);
+        }
+      } else if (executableActionObject.type === assign) {
+        var resolvedActionObject = executableActionObject.resolve(executableActionObject, context, _event, {
+          machine: machine,
+          state: currentState,
+          action: actionObject
+        });
+
+        if (resolvedActionObject.type === raise) {
+          raiseActions.push(resolvedActionObject);
+          return;
+        }
+
+        context = resolvedActionObject.params.context;
+        preservedContexts.push(resolvedActionObject.params.context);
+        resolvedActions.push.apply(resolvedActions, [resolvedActionObject].concat(_toConsumableArray(resolvedActionObject.params.actions)));
+      } else {
+        var _resolvedActionObject = executableActionObject.resolve(executableActionObject, context, _event, {
+          machine: machine,
+          state: currentState,
+          action: actionObject
+        });
+
+        if (_resolvedActionObject.type === raise || _resolvedActionObject.type === send && _resolvedActionObject.params.to === exports.SpecialTargets.Internal) {
+          raiseActions.push(_resolvedActionObject);
+        } else {
+          resolvedActions.push(_resolvedActionObject);
+        }
+      }
+
+      return;
+    }
+
+    switch (executableActionObject.type) {
+      case raise:
+        raiseActions.push(executableActionObject);
+        break;
+
+      case choose:
+        {
+          var _chooseAction$params$;
+
+          var chooseAction = executableActionObject;
+
+          var _matchedActions = (_chooseAction$params$ = chooseAction.params.guards.find(function (condition) {
+            var guard = condition.guard && toGuardDefinition(condition.guard, function (guardType) {
+              return machine.options.guards[guardType];
+            });
+            return !guard || evaluateGuard(guard, context, _event, currentState, machine);
+          })) === null || _chooseAction$params$ === void 0 ? void 0 : _chooseAction$params$.actions;
+
+          if (_matchedActions) {
+            toActionObjects(toArray(_matchedActions), machine.options.actions).forEach(resolveAction);
+          }
+
+          break;
+        }
+
+      default:
+        var contextIndex = preservedContexts.length - 1;
+
+        if (isExecutableAction(executableActionObject)) {
+          executableActionObject.setContext(preservedContexts[contextIndex]);
+          resolvedActions.push(executableActionObject);
+        } else {
+          var _resolvedActionObject2 = toActionObject(executableActionObject, machine.options.actions);
+
+          var actionExec = new ExecutableAction(_resolvedActionObject2);
+          actionExec.setContext(preservedContexts[contextIndex]);
+          resolvedActions.push(actionExec);
+        }
+
+        break;
+    }
+  }
+
+  var _iterator31 = _createForOfIteratorHelper(actions),
+      _step31;
+
+  try {
+    for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {
+      var actionObject = _step31.value;
+      resolveAction(actionObject);
+    }
+  } catch (err) {
+    _iterator31.e(err);
+  } finally {
+    _iterator31.f();
+  }
+
+  return {
+    actions: resolvedActions,
+    raised: raiseActions,
+    context: context
+  };
+}
+
+function macrostep(state, event, machine) {
+  // Assume the state is at rest (no raised events)
+  // Determine the next state based on the next microstep
+  var nextState = event === null ? state : machine.microstep(state, event);
+  var _internalQueue = nextState._internalQueue;
+  var maybeNextState = nextState;
+
+  while (!maybeNextState.done) {
+    var eventlessTransitions = selectEventlessTransitions(maybeNextState, machine);
+
+    if (eventlessTransitions.length === 0) {
+      if (!_internalQueue.length) {
+        break;
+      } else {
+        var _maybeNextState$actio;
+
+        var internalEvent = _internalQueue.shift();
+
+        var currentActions = maybeNextState.actions;
+        maybeNextState = machine.microstep(maybeNextState, internalEvent);
+
+        _internalQueue.push.apply(_internalQueue, _toConsumableArray(maybeNextState._internalQueue)); // Since macrostep actions have not been executed yet,
+        // prioritize them in the action queue
+
+
+        (_maybeNextState$actio = maybeNextState.actions).unshift.apply(_maybeNextState$actio, _toConsumableArray(currentActions));
+      }
+    } else {
+      var _maybeNextState$actio2;
+
+      var _currentActions = maybeNextState.actions;
+      maybeNextState = resolveMicroTransition(machine, eventlessTransitions, maybeNextState, maybeNextState._event);
+
+      _internalQueue.push.apply(_internalQueue, _toConsumableArray(maybeNextState._internalQueue));
+
+      (_maybeNextState$actio2 = maybeNextState.actions).unshift.apply(_maybeNextState$actio2, _toConsumableArray(_currentActions));
+    }
+  } // Add tags
+
+
+  maybeNextState.tags = new Set(flatten(maybeNextState.configuration.map(function (sn) {
+    return sn.tags;
+  })));
+  maybeNextState.machine = machine;
+  return maybeNextState;
+}
+
+function resolveHistoryValue(currentState, exitSet) {
+  var historyValue = currentState ? currentState.historyValue : {};
+
+  if (currentState && currentState.configuration) {
+    // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
+    var _iterator32 = _createForOfIteratorHelper(exitSet),
+        _step32;
+
+    try {
+      var _loop3 = function _loop3() {
+        var exitStateNode = _step32.value;
+
+        var _iterator33 = _createForOfIteratorHelper(getHistoryNodes(exitStateNode)),
+            _step33;
+
+        try {
+          for (_iterator33.s(); !(_step33 = _iterator33.n()).done;) {
+            var historyNode = _step33.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] = currentState.configuration.filter(predicate);
+          }
+        } catch (err) {
+          _iterator33.e(err);
+        } finally {
+          _iterator33.f();
+        }
+      };
+
+      for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {
+        _loop3();
+      }
+    } catch (err) {
+      _iterator32.e(err);
+    } finally {
+      _iterator32.f();
+    }
+  }
+
+  return 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 toState(state, machine) {
+  if (state instanceof State) {
+    return state;
+  } else {
+    var resolvedStateValue = resolveStateValue(machine.root, state);
+    var resolvedContext = machine.context;
+    return machine.resolveState(State.from(resolvedStateValue, resolvedContext));
+  }
+}
+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 getMeta() {
+  var configuration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return configuration.reduce(function (acc, stateNode) {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+
+    return acc;
+  }, {});
+}
+function getTagsFromConfiguration(configuration) {
+  return new Set(flatten(configuration.map(function (sn) {
+    return sn.tags;
+  })));
+}
+
+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) {
+    _classCallCheck(this, State);
+
+    _defineProperty(this, "value", void 0);
+
+    _defineProperty(this, "context", void 0);
+
+    _defineProperty(this, "historyValue", {});
+
+    _defineProperty(this, "actions", []);
+
+    _defineProperty(this, "meta", {});
+
+    _defineProperty(this, "event", void 0);
+
+    _defineProperty(this, "_internalQueue", []);
+
+    _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);
+
+    _defineProperty(this, "tags", void 0);
+
+    _defineProperty(this, "machine", void 0);
+
+    this.value = config.value;
+    this.context = config.context;
+    this._event = config._event;
+    this._sessionid = config._sessionid;
+    this.event = this._event.data;
+    this.historyValue = config.historyValue || {};
+    this.actions = config.actions || [];
+    this.meta = getMeta(config.configuration);
+    this.matches = this.matches.bind(this);
+    this.toStrings = this.toStrings.bind(this);
+    this.configuration = config.configuration;
+    this.transitions = config.transitions;
+    this.children = config.children;
+    this.tags = config.configuration ? getTagsFromConfiguration(config.configuration) : config.tags ? new Set(config.tags) : new Set();
+    this.machine = config.machine;
+  }
+  /**
+   * 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)
+      });
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Indicates whether the state is a final state.
+     */
+
+  }, {
+    key: "done",
+    get: function get() {
+      return isInFinalState(this.configuration);
+    }
+    /**
+     * 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) {
+      var _this$machine;
+
+      {
+        warn(!!this.machine);
+      }
+
+      var transitionData = (_this$machine = this.machine) === null || _this$machine === void 0 ? void 0 : _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 nextEvents(_this2.configuration);
+      });
+    }
+  }], [{
+    key: "from",
+    value:
+    /**
+     * 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] : {};
+
+      if (stateValue instanceof State) {
+        if (stateValue.context !== context) {
+          return new State({
+            value: stateValue.value,
+            context: context,
+            _event: stateValue._event,
+            _sessionid: null,
+            actions: [],
+            meta: {},
+            configuration: [],
+            // TODO: fix,
+            transitions: [],
+            children: {}
+          });
+        }
+
+        return stateValue;
+      }
+
+      var _event = initEvent;
+      return new State({
+        value: stateValue,
+        context: context,
+        _event: _event,
+        _sessionid: null,
+        actions: [],
+        meta: undefined,
+        configuration: [],
+        transitions: [],
+        children: {}
+      });
+    }
+    /**
+     * Creates a new State instance for the given `config`.
+     * @param config The state config
+     */
+
+  }, {
+    key: "create",
+    value: function create(config) {
+      return new State(config);
+    }
+    /**
+     * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
+     * @param stateValue
+     * @param context
+     */
+
+  }, {
+    key: "inert",
+    value: function inert(stateValue, context) {
+      if (stateValue instanceof State) {
+        if (!stateValue.actions.length) {
+          return stateValue;
+        }
+
+        var _event = initEvent;
+        return new State({
+          value: stateValue.value,
+          context: stateValue.context,
+          _event: _event,
+          _sessionid: null,
+          configuration: stateValue.configuration,
+          transitions: [],
+          children: stateValue.children
+        });
+      }
+
+      return State.from(stateValue, context);
+    }
+  }]);
+
+  return State;
+}();
+
+(function (InterpreterStatus) {
+  InterpreterStatus[InterpreterStatus["NotStarted"] = 0] = "NotStarted";
+  InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
+  InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
+})(exports.InterpreterStatus || (exports.InterpreterStatus = {}));
+
+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 machine.
+   */
+
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+   */
+
+  /**
+   * Whether the service is started.
+   */
+  // Actor Ref
+
+  /**
+   * The globally unique process ID for this invocation.
+   */
+
+  /**
+   * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
+   *
+   * @param machine The machine to be interpreted
+   * @param options Interpreter options
+   */
+  function Interpreter(machine, options) {
+    var _this = this;
+
+    _classCallCheck(this, Interpreter);
+
+    this.machine = machine;
+
+    _defineProperty(this, "_state", void 0);
+
+    _defineProperty(this, "_initialState", 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, "listeners", new Set());
+
+    _defineProperty(this, "stopListeners", new Set());
+
+    _defineProperty(this, "errorListeners", new Set());
+
+    _defineProperty(this, "doneListeners", new Set());
+
+    _defineProperty(this, "logger", void 0);
+
+    _defineProperty(this, "status", exports.InterpreterStatus.NotStarted);
+
+    _defineProperty(this, "_parent", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "ref", void 0);
+
+    _defineProperty(this, "sessionId", void 0);
+
+    _defineProperty(this, "forwardTo", new Set());
+
+    _defineProperty(this, "send", function (event, payload) {
+      var eventObject = toEventObject(event, payload);
+
+      var _event = toSCXMLEvent(eventObject);
+
+      if (_this.status === exports.InterpreterStatus.Stopped) {
+
+        return;
+      }
+
+      if (_this.status !== exports.InterpreterStatus.Running && !_this.options.deferEvents) {
+        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized service \"").concat(_this.machine.key // tslint:disable-next-line:max-line-length
+        , "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: ").concat(JSON.stringify(_event.data)));
+      }
+
+      _this.mailbox.enqueue(_event);
+    });
+
+    var resolvedOptions = _objectSpread2(_objectSpread2({}, defaultOptions), options);
+
+    var clock = resolvedOptions.clock,
+        logger = resolvedOptions.logger,
+        parent = resolvedOptions.parent,
+        id = resolvedOptions.id;
+    var resolvedId = id !== undefined ? id : machine.key;
+    this.name = this.id = resolvedId;
+    this.logger = logger;
+    this.clock = clock;
+    this._parent = parent;
+    this.options = resolvedOptions;
+    this.ref = this;
+    this.sessionId = this.ref.name;
+  }
+
+  _createClass(Interpreter, [{
+    key: "initialized",
+    get: function get() {
+      return this.status === exports.InterpreterStatus.Running;
+    }
+  }, {
+    key: "initialState",
+    get: function get() {
+      var initialState = this._initialState || (this._initialState = this.machine.getInitialState(), this._initialState);
+      return initialState;
+    }
+  }, {
+    key: "state",
+    get: function get() {
+      return this._state;
+    }
+    /**
+     * Executes the actions of the given state, with that state's `context` and `event`.
+     *
+     * @param state The state whose actions will be executed
+     */
+
+  }, {
+    key: "execute",
+    value: function execute(state) {
+      var _iterator = _createForOfIteratorHelper(state.actions),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var action = _step.value;
+          this.exec(action, state);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "update",
+    value: function update(state) {
+      var _this2 = this;
+
+      // Attach session ID to state
+      state._sessionid = this.sessionId; // Update state
+
+      this._state = state; // Execute actions
+
+      this.execute(this.state);
+
+      var _iterator2 = _createForOfIteratorHelper(this.listeners),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _listener = _step2.value;
+
+          _listener(state, state.event);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      var isDone = isInFinalState(state.configuration || [], this.machine.root);
+
+      if (this.state.configuration && isDone) {
+        // get final child state node
+        var finalChildStateNode = state.configuration.find(function (stateNode) {
+          return stateNode.type === 'final' && stateNode.parent === _this2.machine.root;
+        });
+        var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, state.context, state._event) : undefined;
+
+        var _iterator3 = _createForOfIteratorHelper(this.doneListeners),
+            _step3;
+
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var listener = _step3.value;
+            listener(toSCXMLEvent(doneInvoke(this.name, doneData), {
+              invokeid: this.name
+            }));
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+
+        this.stop();
+      }
+    }
+    /*
+     * 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
+     */
+
+  }, {
+    key: "onTransition",
+    value: function onTransition(listener) {
+      this.listeners.add(listener); // Send current state to listener
+
+      if (this.status === exports.InterpreterStatus.Running) {
+        listener(this.state, this.state.event);
+      }
+
+      return this;
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(nextListenerOrObserver, errorListener, completeListener) {
+      var _this3 = this;
+
+      if (!nextListenerOrObserver) {
+        return {
+          unsubscribe: function unsubscribe() {
+            return void 0;
+          }
+        };
+      }
+
+      var listener;
+      var resolvedCompleteListener = completeListener;
+
+      if (typeof nextListenerOrObserver === 'function') {
+        listener = nextListenerOrObserver;
+      } else {
+        var _nextListenerOrObserv, _nextListenerOrObserv2;
+
+        listener = (_nextListenerOrObserv = nextListenerOrObserver.next) === null || _nextListenerOrObserv === void 0 ? void 0 : _nextListenerOrObserv.bind(nextListenerOrObserver);
+        resolvedCompleteListener = (_nextListenerOrObserv2 = nextListenerOrObserver.complete) === null || _nextListenerOrObserv2 === void 0 ? void 0 : _nextListenerOrObserv2.bind(nextListenerOrObserver);
+      }
+
+      if (listener) {
+        this.listeners.add(listener);
+      }
+
+      if (errorListener) {
+        this.onError(errorListener);
+      } // Send current state to listener
+
+
+      if (this.status !== exports.InterpreterStatus.NotStarted) {
+        listener(this.state);
+      }
+
+      if (resolvedCompleteListener) {
+        if (this.status === exports.InterpreterStatus.Stopped) {
+          resolvedCompleteListener();
+        } else {
+          this.onDone(resolvedCompleteListener);
+        }
+      }
+
+      return {
+        unsubscribe: function unsubscribe() {
+          listener && _this3.off(listener);
+          resolvedCompleteListener && _this3.off(resolvedCompleteListener);
+          errorListener && _this3.off(errorListener);
+        }
+      };
+    }
+    /**
+      * Adds a listener that is notified when the machine is stopped.
+     *
+     * @param listener The listener
+     */
+
+  }, {
+    key: "onStop",
+    value: function onStop(listener) {
+      this.stopListeners.add(listener);
+      return this;
+    }
+    /**
+     * Adds an error listener that is notified with an `Error` whenever an
+     * error occurs during execution.
+     *
+     * @param listener The error listener
+     */
+
+  }, {
+    key: "onError",
+    value: function onError(listener) {
+      this.errorListeners.add(listener);
+      return this;
+    }
+    /**
+     * 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) {
+      this.doneListeners.add(listener);
+      return this;
+    }
+    /**
+     * Removes a listener.
+     * @param listener The listener to remove
+     */
+
+  }, {
+    key: "off",
+    value: function off(listener) {
+      this.listeners["delete"](listener);
+      this.stopListeners["delete"](listener);
+      this.doneListeners["delete"](listener);
+      this.errorListeners["delete"](listener);
+      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(initialState) {
+      if (this.status === exports.InterpreterStatus.Running) {
+        // Do not restart the service if it is already started
+        return this;
+      }
+
+      registry.register(this.sessionId, this.ref);
+      this.status = exports.InterpreterStatus.Running;
+      var resolvedState = initialState === undefined ? this.initialState : isStateConfig(initialState) ? this.machine.resolveState(initialState) // TODO: fix this
+      : this.machine.resolveState(State.from(initialState, this.machine.context));
+      this._state = resolvedState; // 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) {
+      // TODO: handle errors
+      this.forward(event);
+      var errored = false;
+
+      if (isSCXMLErrorEvent(event) && !this.state.nextEvents.some(function (nextEvent) {
+        return nextEvent === event.name;
+      })) {
+        errored = true; // Error event unhandled by machine
+
+        if (this.errorListeners.size > 0) {
+          this.errorListeners.forEach(function (listener) {
+            listener(event.data.data);
+          });
+        } else {
+          this.stop();
+          throw event.data.data;
+        }
+      }
+
+      var nextState = this.nextState(event);
+      this.update(nextState);
+
+      if (errored) {
+        this.stop();
+      }
+    }
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     *
+     * This will also notify the `onStop` listeners.
+     */
+
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this4 = this;
+
+      this.listeners.clear();
+
+      var _iterator4 = _createForOfIteratorHelper(this.stopListeners),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var listener = _step4.value;
+          // call listener, then remove
+          listener();
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      this.stopListeners.clear();
+      this.doneListeners.clear();
+
+      if (!this.initialized) {
+        // Interpreter already stopped; do nothing
+        return this;
+      }
+
+      _toConsumableArray(this.state.configuration).sort(function (a, b) {
+        return b.order - a.order;
+      }).forEach(function (stateNode) {
+        var _iterator5 = _createForOfIteratorHelper(stateNode.definition.exit),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var action = _step5.value;
+
+            _this4.exec(action, _this4.state);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }); // Stop all children
+
+
+      Object.values(this.state.children).forEach(function (child) {
+        if (isFunction(child.stop)) {
+          child.stop();
+        }
+      }); // 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]);
+      }
+
+      this.mailbox.clear(); // TODO: after `stop` we must prepare ourselves for receiving events again
+      // events sent *after* stop signal must be queued
+      // it seems like this should be the common behavior for all of our consumers
+      // so perhaps this should be unified somehow for all of them
+
+      this.mailbox = new Mailbox(this._process.bind(this));
+      this.status = exports.InterpreterStatus.Stopped;
+      this._initialState = undefined;
+      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: "sendTo",
+    value: function sendTo(event, to) {
+      var isParent = this._parent && to === exports.SpecialTargets.Parent;
+      var target = isParent ? this._parent : isActorRef(to) ? to : this.state.children[to];
+
+      if (!target) {
+        if (!isParent) {
+          var executionError = new Error("Unable to send event to child '".concat(to, "' from service '").concat(this.name, "'."));
+          this.send(toSCXMLEvent(errorExecution, {
+            data: executionError // TODO: refine
+
+          }) // TODO: fix
+          );
+        } // tslint:disable-next-line:no-console
+
+        return;
+      }
+
+      target.send(_objectSpread2(_objectSpread2({}, event), {}, {
+        name: event.name === error ? "".concat(error$1(this.name)) : event.name,
+        origin: this
+      }));
+    }
+    /**
+     * Returns the next state given the interpreter's current state and the event.
+     *
+     * This is a pure method that does _not_ update the interpreter's state.
+     *
+     * @param event The event to determine the next state
+     */
+
+  }, {
+    key: "nextState",
+    value: function nextState(event) {
+      return this.machine.transition(this.state, event);
+    }
+  }, {
+    key: "forward",
+    value: function forward(event) {
+      var _iterator6 = _createForOfIteratorHelper(this.forwardTo),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _id = _step6.value;
+          var child = this.state.children[_id];
+
+          if (!child) {
+            throw new Error("Unable to forward event '".concat(event.name, "' from interpreter '").concat(this.name, "' to nonexistant child '").concat(_id, "'."));
+          }
+
+          child.send(event);
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    }
+  }, {
+    key: "defer",
+    value: function defer(sendAction) {
+      var _this5 = this;
+
+      this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(function () {
+        if (sendAction.params.to) {
+          _this5.sendTo(sendAction.params._event, sendAction.params.to);
+        } else {
+          _this5.send(sendAction.params._event);
+        }
+      }, sendAction.params.delay);
+    }
+  }, {
+    key: "cancel",
+    value: function cancel(sendId) {
+      this.clock.clearTimeout(this.delayedEventsMap[sendId]);
+      delete this.delayedEventsMap[sendId];
+    }
+  }, {
+    key: "getActionFunction",
+    value: function getActionFunction(actionType) {
+      var _this$machine$options,
+          _this6 = this,
+          _actionTypes$send$act;
+
+      return (_this$machine$options = this.machine.options.actions[actionType]) !== null && _this$machine$options !== void 0 ? _this$machine$options : (_actionTypes$send$act = {}, _defineProperty(_actionTypes$send$act, send, function (_ctx, _e, _ref) {
+        var action = _ref.action;
+        var sendAction = action;
+
+        if (typeof sendAction.params.delay === 'number') {
+          _this6.defer(sendAction);
+
+          return;
+        } else {
+          if (sendAction.params.to) {
+            _this6.sendTo(sendAction.params._event, sendAction.params.to);
+          } else {
+            _this6.send(sendAction.params._event);
+          }
+        }
+      }), _defineProperty(_actionTypes$send$act, cancel, function (_ctx, _e, _ref2) {
+        var action = _ref2.action;
+
+        _this6.cancel(action.params.sendId);
+      }), _defineProperty(_actionTypes$send$act, invoke, function (_ctx, _e, _ref3) {
+        var action = _ref3.action,
+            state = _ref3.state;
+        var _params = action.params,
+            id = _params.id,
+            autoForward = _params.autoForward,
+            ref = _params.ref;
+
+        if (!ref) {
+
+          return;
+        }
+
+        ref._parent = _this6; // TODO: fix
+        // If the actor will be stopped right after it's started
+        // (such as in transient states) don't bother starting the actor.
+
+        if (state.actions.find(function (otherAction) {
+          return otherAction.type === stop && otherAction.params.actor === id;
+        })) {
+          return;
+        }
+
+        try {
+          var _ref$start;
+
+          if (autoForward) {
+            _this6.forwardTo.add(id);
+          } // TODO: determine how this can be immutably updated
+
+
+          _this6.state.children[id] = ref;
+          (_ref$start = ref.start) === null || _ref$start === void 0 ? void 0 : _ref$start.call(ref);
+        } catch (err) {
+          _this6.send(error$1(id, err));
+
+          return;
+        }
+      }), _defineProperty(_actionTypes$send$act, stop, function (_ctx, _e, _ref4) {
+        var action = _ref4.action;
+        var actor = action.params.actor;
+        var actorRef = typeof actor === 'string' ? _this6.state.children[actor] : actor;
+
+        if (actorRef) {
+          _this6.stopChild(actorRef.name);
+        }
+      }), _defineProperty(_actionTypes$send$act, log, function (_ctx, _e, _ref5) {
+        var action = _ref5.action;
+        var _params2 = action.params,
+            label = _params2.label,
+            value = _params2.value;
+
+        if (label) {
+          _this6.logger(label, value);
+        } else {
+          _this6.logger(value);
+        }
+      }), _actionTypes$send$act)[actionType];
+    }
+  }, {
+    key: "exec",
+    value: function exec(action, state) {
+
+      var _event = state._event;
+
+      if (isExecutableAction(action)) {
+        try {
+          return action.execute(state);
+        } catch (err) {
+          var _this$_parent;
+
+          (_this$_parent = this._parent) === null || _this$_parent === void 0 ? void 0 : _this$_parent.send({
+            type: 'xstate.error',
+            data: err
+          });
+          throw err;
+        }
+      }
+
+      var actionOrExec = this.getActionFunction(action.type);
+      var exec = isFunction(actionOrExec) ? actionOrExec : undefined;
+
+      if (exec) {
+        try {
+          return exec(state.context, _event.data, {
+            action: action,
+            state: this.state,
+            _event: _event
+          });
+        } catch (err) {
+          if (this._parent) {
+            this._parent.send({
+              type: 'xstate.error',
+              data: err
+            });
+          }
+
+          throw err;
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "stopChild",
+    value: function stopChild(childId) {
+      var child = this.state.children[childId];
+
+      if (!child) {
+        return;
+      }
+
+      this.forwardTo["delete"](childId); // TODO: determine how this can be immutably updated
+
+      delete this.state.children[childId];
+
+      if (isFunction(child.stop)) {
+        child.stop();
+      }
+    }
+  }, {
+    key: "attachDevTools",
+    value: function attachDevTools() {
+      var devTools = this.options.devTools;
+
+      if (devTools) {
+        var resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
+        resolvedDevToolsAdapter(this);
+      }
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        id: this.name
+      };
+    }
+  }, {
+    key: symbolObservable,
+    value: function value() {
+      return this;
+    }
+  }, {
+    key: "getSnapshot",
+    value: function getSnapshot() {
+      if (this.status === exports.InterpreterStatus.NotStarted) {
+        return this.initialState;
+      }
+
+      return 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(machine, options) {
+  var interpreter = new Interpreter(machine, options);
+  return interpreter;
+}
+
+/**
+ * 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);
+    },
+    initialState: initialState
+  };
+}
+var startSignalType = Symbol["for"]('xstate.invoke');
+var stopSignalType = Symbol["for"]('xstate.stop');
+var startSignal = {
+  type: startSignalType
+};
+var stopSignal = {
+  type: stopSignalType
+};
+
+/**
+ * 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(event) {
+  return _typeof(event.type) === 'symbol';
+}
+
+function fromCallback(invokeCallback) {
+  var canceled = false;
+  var receivers = new Set();
+  var dispose;
+  var behavior = {
+    transition: function transition(_, event, _ref) {
+      var self = _ref.self,
+          name = _ref.name;
+      var parent = self._parent;
+
+      if (event.type === startSignalType) {
+        var sender = function sender(e) {
+          if (canceled) {
+            return;
+          }
+
+          parent === null || parent === void 0 ? void 0 : parent.send(toSCXMLEvent(e, {
+            origin: self
+          }));
+        };
+
+        var receiver = function receiver(newListener) {
+          receivers.add(newListener);
+        };
+
+        dispose = invokeCallback(sender, receiver);
+
+        if (isPromiseLike(dispose)) {
+          dispose.then(function (resolved) {
+            var _self$_parent;
+
+            (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(toSCXMLEvent(doneInvoke(name, resolved), {
+              origin: self
+            }));
+            canceled = true;
+          }, function (errorData) {
+            var _self$_parent2;
+
+            var errorEvent = error$1(name, errorData);
+            (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(toSCXMLEvent(errorEvent, {
+              origin: self
+            }));
+            canceled = true;
+          });
+        }
+
+        return undefined;
+      } else if (event.type === stopSignalType) {
+        canceled = true;
+
+        if (isFunction(dispose)) {
+          dispose();
+        }
+
+        return undefined;
+      }
+
+      if (isSignal(event)) {
+        // TODO: unrecognized signal
+        return undefined;
+      }
+
+      var plainEvent = isSCXMLEvent(event) ? event.data : event;
+      receivers.forEach(function (receiver) {
+        return receiver(plainEvent);
+      });
+      return undefined;
+    },
+    initialState: undefined
+  };
+  return behavior;
+}
+function fromPromise(lazyPromise) {
+  var canceled = false;
+  var resolveEventType = Symbol('resolve');
+  var rejectEventType = Symbol('reject'); // TODO: add event types
+
+  var behavior = {
+    transition: function transition(state, event, _ref2) {
+      var _self$_parent3, _self$_parent4;
+
+      var self = _ref2.self,
+          name = _ref2.name;
+
+      if (canceled) {
+        return state;
+      }
+
+      switch (event.type) {
+        case startSignalType:
+          var resolvedPromise = Promise.resolve(lazyPromise());
+          resolvedPromise.then(function (response) {
+            self.send({
+              type: resolveEventType,
+              data: response
+            });
+          }, function (errorData) {
+            self.send({
+              type: rejectEventType,
+              data: errorData
+            });
+          });
+          return undefined;
+
+        case resolveEventType:
+          (_self$_parent3 = self._parent) === null || _self$_parent3 === void 0 ? void 0 : _self$_parent3.send(toSCXMLEvent(doneInvoke(name, event.data), {
+            origin: self
+          }));
+          return event.data;
+
+        case rejectEventType:
+          var errorEvent = error$1(name, event.data);
+          (_self$_parent4 = self._parent) === null || _self$_parent4 === void 0 ? void 0 : _self$_parent4.send(toSCXMLEvent(errorEvent, {
+            origin: self
+          }));
+          return event.data;
+
+        case stopSignalType:
+          canceled = true;
+          return undefined;
+
+        default:
+          return undefined;
+      }
+    },
+    initialState: undefined
+  };
+  return behavior;
+}
+function fromObservable(lazyObservable) {
+  var subscription;
+  var observable;
+  var nextEventType = Symbol('next');
+  var errorEventType = Symbol('error');
+  var completeEventType = Symbol('complete');
+  var canceled = false; // TODO: add event types
+
+  var behavior = {
+    transition: function transition(state, event, _ref3) {
+      var _self$_parent5, _self$_parent6, _self$_parent7, _subscription;
+
+      var self = _ref3.self,
+          name = _ref3.name;
+
+      if (canceled) {
+        return state;
+      }
+
+      switch (event.type) {
+        case startSignalType:
+          observable = lazyObservable();
+          subscription = observable.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;
+
+        case nextEventType:
+          (_self$_parent5 = self._parent) === null || _self$_parent5 === void 0 ? void 0 : _self$_parent5.send(toSCXMLEvent({
+            type: "xstate.snapshot.".concat(name),
+            data: event.data
+          }, {
+            origin: self
+          }));
+          return event.data;
+
+        case errorEventType:
+          var errorEvent = error$1(name, event.data);
+          (_self$_parent6 = self._parent) === null || _self$_parent6 === void 0 ? void 0 : _self$_parent6.send(toSCXMLEvent(errorEvent, {
+            origin: self
+          }));
+          return state;
+
+        case completeEventType:
+          (_self$_parent7 = self._parent) === null || _self$_parent7 === void 0 ? void 0 : _self$_parent7.send(toSCXMLEvent(doneInvoke(name), {
+            origin: self
+          }));
+          return state;
+
+        case stopSignalType:
+          canceled = true;
+          (_subscription = subscription) === null || _subscription === void 0 ? void 0 : _subscription.unsubscribe();
+          return state;
+
+        default:
+          return state;
+      }
+    },
+    initialState: undefined
+  };
+  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 subscription;
+  var observable;
+  var nextEventType = Symbol('next');
+  var errorEventType = Symbol('error');
+  var completeEventType = Symbol('complete');
+  var canceled = false; // TODO: event types
+
+  var behavior = {
+    transition: function transition(state, event, _ref4) {
+      var _self$_parent9, _self$_parent10, _subscription2;
+
+      var self = _ref4.self,
+          name = _ref4.name;
+
+      if (canceled) {
+        return state;
+      }
+
+      switch (event.type) {
+        case startSignalType:
+          observable = lazyObservable();
+          subscription = observable.subscribe({
+            next: function next(value) {
+              var _self$_parent8;
+
+              (_self$_parent8 = self._parent) === null || _self$_parent8 === void 0 ? void 0 : _self$_parent8.send(toSCXMLEvent(value, {
+                origin: self
+              }));
+            },
+            error: function error(err) {
+              self.send({
+                type: errorEventType,
+                data: err
+              });
+            },
+            complete: function complete() {
+              self.send({
+                type: completeEventType
+              });
+            }
+          });
+          return state;
+
+        case nextEventType:
+          return event.data;
+
+        case errorEventType:
+          var errorEvent = error$1(name, event.data);
+          (_self$_parent9 = self._parent) === null || _self$_parent9 === void 0 ? void 0 : _self$_parent9.send(toSCXMLEvent(errorEvent, {
+            origin: self
+          }));
+          return state;
+
+        case completeEventType:
+          (_self$_parent10 = self._parent) === null || _self$_parent10 === void 0 ? void 0 : _self$_parent10.send(toSCXMLEvent(doneInvoke(name), {
+            origin: self
+          }));
+          return state;
+
+        case stopSignalType:
+          canceled = true;
+          (_subscription2 = subscription) === null || _subscription2 === void 0 ? void 0 : _subscription2.unsubscribe();
+          return state;
+
+        default:
+          return state;
+      }
+    },
+    initialState: undefined
+  };
+  return behavior;
+}
+function fromMachine(machine) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var snapshotEventType = Symbol('snapshot');
+  var castedMachine = machine;
+  var service;
+  var initialState; // TODO: use better type for `TEvent`
+
+  var behavior = {
+    transition: function transition(state, event, actorContext) {
+      var _service, _service2;
+
+      var parent = actorContext.self._parent;
+
+      switch (event.type) {
+        case startSignalType:
+          service = interpret(castedMachine, _objectSpread2(_objectSpread2({}, options), {}, {
+            parent: parent,
+            id: actorContext.name
+          }));
+          service.onDone(function (doneEvent) {
+            parent === null || parent === void 0 ? void 0 : parent.send(toSCXMLEvent(doneEvent, {
+              origin: actorContext.self
+            }));
+          });
+          service.subscribe(function (state) {
+            actorContext.self.send({
+              type: snapshotEventType,
+              snapshot: state
+            });
+          });
+          service.start();
+          return state;
+
+        case stopSignalType:
+          (_service = service) === null || _service === void 0 ? void 0 : _service.stop();
+          return state;
+
+        case snapshotEventType:
+          {
+            var snapshot = event.snapshot;
+
+            if (options.sync) {
+              parent === null || parent === void 0 ? void 0 : parent.send(toSCXMLEvent({
+                type: update,
+                state: snapshot
+              }, {
+                origin: actorContext.self
+              }));
+            }
+
+            return snapshot;
+          }
+
+        default:
+          var _event = actorContext._event;
+
+          if (isSignal(_event)) {
+            // TODO: unrecognized signal
+            return state;
+          }
+
+          (_service2 = service) === null || _service2 === void 0 ? void 0 : _service2.send(_event);
+          return state;
+      }
+    },
+
+    get initialState() {
+      // TODO: recheck if this caching is needed, write a test for its importance or remove the caching
+      if (initialState) {
+        return initialState;
+      }
+
+      initialState = castedMachine.getInitialState();
+      return initialState;
+    }
+
+  };
+  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
+
+function toActorRef(actorRefLike) {
+  return _objectSpread2(_defineProperty({
+    subscribe: function subscribe() {
+      return {
+        unsubscribe: function unsubscribe() {
+          return void 0;
+        }
+      };
+    },
+    name: 'anonymous',
+    getSnapshot: function getSnapshot() {
+      return undefined;
+    }
+  }, symbolObservable, function () {
+    return this;
+  }), actorRefLike);
+}
+
+var ObservableActorRef = /*#__PURE__*/function () {
+  function ObservableActorRef(behavior, name) {
+    _classCallCheck(this, ObservableActorRef);
+
+    this.behavior = behavior;
+    this.name = name;
+
+    _defineProperty(this, "current", void 0);
+
+    _defineProperty(this, "context", void 0);
+
+    _defineProperty(this, "mailbox", new Mailbox(this._process.bind(this)));
+
+    _defineProperty(this, "_observers", new Set());
+
+    this.context = {
+      self: this,
+      name: this.name,
+      _event: toSCXMLEvent({
+        type: 'xstate.init'
+      }) // TODO: fix
+
+    };
+    this.current = this.behavior.initialState;
+  }
+
+  _createClass(ObservableActorRef, [{
+    key: "start",
+    value: function start() {
+      this.mailbox.prepend(startSignal);
+      this.mailbox.start();
+      return this;
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this.mailbox.clear();
+      this.mailbox.enqueue(stopSignal);
+      return this;
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(observer) {
+      var _this = this;
+
+      var resolved = toObserver(observer);
+
+      this._observers.add(resolved);
+
+      return {
+        unsubscribe: function unsubscribe() {
+          _this._observers["delete"](resolved);
+        }
+      };
+    }
+  }, {
+    key: "send",
+    value: function send(event) {
+      this.receive(event);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        name: this.name,
+        current: this.current
+      };
+    }
+  }, {
+    key: "getSnapshot",
+    value: function getSnapshot() {
+      return this.current;
+    }
+  }, {
+    key: symbolObservable,
+    value: function value() {
+      return this;
+    }
+  }, {
+    key: "receive",
+    value: function receive(event) {
+      this.mailbox.enqueue(event);
+    }
+  }, {
+    key: "_process",
+    value: function _process(event) {
+      this.context._event = typeof event.type !== 'string' ? event : toSCXMLEvent(event);
+      var previous = this.current;
+      this.current = this.behavior.transition(this.current, typeof this.context._event.type !== 'string' ? this.context._event : this.context._event.data, this.context);
+
+      if (previous !== this.current) {
+        var current = this.current;
+
+        this._observers.forEach(function (observer) {
+          var _observer$next;
+
+          return (_observer$next = observer.next) === null || _observer$next === void 0 ? void 0 : _observer$next.call(observer, current);
+        });
+      }
+    }
+  }]);
+
+  return ObservableActorRef;
+}();
+
+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 = behaviorCreator(context, _event.data, {
+          id: name || 'anon',
+          src: {
+            type: behavior
+          },
+          _event: _event,
+          meta: undefined
+        });
+        var actorRef = new ObservableActorRef(createdBehavior, resolvedName);
+        mutCapturedActions.push({
+          type: exports.ActionTypes.Invoke,
+          params: {
+            src: actorRef,
+            ref: actorRef,
+            id: actorRef.name,
+            meta: undefined
+          }
+        });
+        return actorRef; // TODO: fix types
+      }
+
+      throw new Error("Behavior '".concat(behavior, "' not implemented in machine '").concat(machine.key, "'"));
+    } else {
+      var _actorRef = new ObservableActorRef(behavior, name || 'anonymous');
+
+      mutCapturedActions.push({
+        type: exports.ActionTypes.Invoke,
+        params: {
+          src: _actorRef,
+          ref: _actorRef,
+          id: _actorRef.name,
+          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(assign, {
+    assignment: assignment
+  }, function (_, context, _event, _ref) {
+    var machine = _ref.machine,
+        state = _ref.state,
+        action = _ref.action;
+    var capturedActions = [];
+
+    if (!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(machine, context, _event, capturedActions)
+    };
+    var partialUpdate = {};
+
+    if (isFunction(assignment)) {
+      partialUpdate = assignment(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(context, _event.data, meta) : propAssignment;
+      }
+    }
+
+    var updatedContext = Object.assign({}, context, partialUpdate);
+    return {
+      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(raise, {
+    _event: toSCXMLEvent(event)
+  }, function (_ref) {
+    var params = _ref.params;
+    return {
+      type: raise,
+      params: {
+        _event: params._event
+      }
+    };
+  });
+}
+
+function choose$1(guards) {
+  return createDynamicAction(choose, {
+    guards: guards
+  }, function (_ref, context, _event, _ref2) {
+    var _params$guards$find;
+
+    var params = _ref.params;
+    var machine = _ref2.machine,
+        state = _ref2.state;
+    var matchedActions = (_params$guards$find = params.guards.find(function (condition) {
+      var guard = condition.guard && toGuardDefinition(condition.guard, function (guardType) {
+        return machine.options.guards[guardType];
+      });
+      return !guard || evaluateGuard(guard, context, _event, state, machine);
+    })) === null || _params$guards$find === void 0 ? void 0 : _params$guards$find.actions;
+    return {
+      type: choose,
+      params: {
+        actions: toArray(matchedActions).map(function (chosenAction) {
+          return toActionObject(chosenAction);
+        })
+      }
+    };
+  });
+}
+
+var initEvent = toSCXMLEvent({
+  type: init
+});
+function getActionFunction(actionType, actionFunctionMap) {
+  return actionFunctionMap ? actionFunctionMap[actionType] || undefined : undefined;
+}
+function resolveActionObject(actionObject, actionFunctionMap) {
+  var exec = getActionFunction(actionObject.type, actionFunctionMap);
+
+  if (isFunction(exec)) {
+    return new ExecutableAction(actionObject, exec);
+  } else if (exec) {
+    return exec;
+  } else {
+    return actionObject;
+  }
+}
+function toActionObject(action, actionFunctionMap) {
+  if (isDynamicAction(action)) {
+    return action;
+  }
+
+  if (isString(action) || typeof action === 'number') {
+    return resolveActionObject({
+      type: action,
+      params: {}
+    }, actionFunctionMap);
+  } else if (isFunction(action)) {
+    var _action$name;
+
+    return new ExecutableAction({
+      type: (_action$name = action.name) !== null && _action$name !== void 0 ? _action$name : 'xstate:expr',
+      params: {}
+    }, action);
+  } else {
+    // action is already a BaseActionObject
+    return action;
+  }
+}
+var toActionObjects = function toActionObjects(action, actionFunctionMap) {
+  if (!action) {
+    return [];
+  }
+
+  var actions = isArray(action) ? action : [action];
+  return actions.map(function (subAction) {
+    return toActionObject(subAction, actionFunctionMap);
+  });
+};
+/**
+ * Returns an event type that represents an implicit event that
+ * is sent after the specified `delay`.
+ *
+ * @param delayRef The delay in milliseconds
+ * @param id The state node ID where this event is handled
+ */
+
+function after$1(delayRef, id) {
+  var idSuffix = id ? "#".concat(id) : '';
+  return "".concat(exports.ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
+}
+/**
+ * Returns an event that represents that a final state node
+ * has been reached in the parent state node.
+ *
+ * @param id The final state node's parent state node `id`
+ * @param data The data to pass into the event
+ */
+
+function done(id, data) {
+  var type = "".concat(exports.ActionTypes.DoneState, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+/**
+ * Returns an event that represents that an invoked service has terminated.
+ *
+ * An invoked service is terminated when it has reached a top-level final state node,
+ * but not when it is canceled.
+ *
+ * @param invokeId The invoked service ID
+ * @param data The data to pass into the event
+ */
+
+function doneInvoke(invokeId, data) {
+  var type = "".concat(exports.ActionTypes.DoneInvoke, ".").concat(invokeId);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+function error$1(id, data) {
+  var type = "".concat(exports.ActionTypes.ErrorPlatform, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+
+exports.Interpreter = Interpreter;
+exports.NULL_EVENT = NULL_EVENT;
+exports.ObservableActorRef = ObservableActorRef;
+exports.STATE_DELIMITER = STATE_DELIMITER;
+exports.State = State;
+exports._classCallCheck = _classCallCheck;
+exports._createClass = _createClass;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._defineProperty = _defineProperty;
+exports._objectSpread2 = _objectSpread2;
+exports._objectWithoutProperties = _objectWithoutProperties;
+exports._slicedToArray = _slicedToArray;
+exports._toConsumableArray = _toConsumableArray;
+exports.actionTypes = actionTypes;
+exports.after = after$1;
+exports.and = and;
+exports.assign = assign$1;
+exports.cancel = cancel$1;
+exports.choose = choose$1;
+exports.createDynamicAction = createDynamicAction;
+exports.createInvokeId = createInvokeId;
+exports.createSpawner = createSpawner;
+exports.done = done;
+exports.doneInvoke = doneInvoke;
+exports.error = error$1;
+exports.escalate = escalate;
+exports.evaluateGuard = evaluateGuard;
+exports.flatten = flatten;
+exports.formatInitialTransition = formatInitialTransition;
+exports.formatTransition = formatTransition;
+exports.formatTransitions = formatTransitions;
+exports.forwardTo = forwardTo;
+exports.fromCallback = fromCallback;
+exports.fromEventObservable = fromEventObservable;
+exports.fromMachine = fromMachine;
+exports.fromObservable = fromObservable;
+exports.fromPromise = fromPromise;
+exports.fromReducer = fromReducer;
+exports.getActionFunction = getActionFunction;
+exports.getCandidates = getCandidates;
+exports.getConfiguration = getConfiguration;
+exports.getDelayedTransitions = getDelayedTransitions;
+exports.getEventType = getEventType;
+exports.getStateNodes = getStateNodes;
+exports.getStateValue = getStateValue;
+exports.initEvent = initEvent;
+exports.interpret = interpret;
+exports.invoke = invoke;
+exports.isActorRef = isActorRef;
+exports.isBuiltInEvent = isBuiltInEvent;
+exports.isFunction = isFunction;
+exports.isStateId = isStateId;
+exports.isString = isString;
+exports.log = log$1;
+exports.macrostep = macrostep;
+exports.mapValues = mapValues;
+exports.matchesState = matchesState;
+exports.memo = memo;
+exports.not = not;
+exports.or = or;
+exports.pathToStateValue = pathToStateValue;
+exports.pure = pure;
+exports.raise = raise$1;
+exports.resolveActionObject = resolveActionObject;
+exports.resolveMicroTransition = resolveMicroTransition;
+exports.resolveStateValue = resolveStateValue;
+exports.respond = respond;
+exports.send = send$1;
+exports.sendParent = sendParent;
+exports.sendTo = sendTo;
+exports.sendUpdate = sendUpdate;
+exports.startSignal = startSignal;
+exports.startSignalType = startSignalType;
+exports.stateIn = stateIn;
+exports.stop = stop$1;
+exports.stopSignal = stopSignal;
+exports.stopSignalType = stopSignalType;
+exports.toActionObject = toActionObject;
+exports.toActionObjects = toActionObjects;
+exports.toActorRef = toActorRef;
+exports.toArray = toArray;
+exports.toEventObject = toEventObject;
+exports.toGuardDefinition = toGuardDefinition;
+exports.toInvokeConfig = toInvokeConfig;
+exports.toInvokeSource = toInvokeSource;
+exports.toObserver = toObserver;
+exports.toSCXMLEvent = toSCXMLEvent;
+exports.toState = toState;
+exports.toTransitionConfigArray = toTransitionConfigArray;
+exports.transitionNode = transitionNode;