xstate 4.31.0 → 5.0.0-alpha.0

package/dist/actions-ff512f16.esm.js

@@ -0,0 +1,4757 @@
+import { I as IS_PRODUCTION, d as devToolsAdapter } from './index-20b364c4.esm.js';
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+// TODO: replace in v5 with:
+// export type IndexByType<T extends { type: string }> = { [E in T as E['type']]: E; };
+
+/**
+ * The full definition of an event, with a string `type`.
+ */
+
+/**
+ * The specified string event types or the specified event objects.
+ */
+// TODO: do not accept machines without all implementations
+// we should also accept a raw machine as a behavior here
+// or just make machine a behavior
+// TODO: narrow this to behaviors from machine
+// TODO: fix last param
+
+/**
+ * Extracts action objects that have no extra properties.
+ */
+
+/**
+ * The string or object representing the state value relative to the parent state node.
+ *
+ * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
+ */
+// TODO: remove once TS fixes this type-widening issue
+// TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
+var ActionTypes;
+
+(function (ActionTypes) {
+  ActionTypes["Stop"] = "xstate.stop";
+  ActionTypes["Raise"] = "xstate.raise";
+  ActionTypes["Send"] = "xstate.send";
+  ActionTypes["Cancel"] = "xstate.cancel";
+  ActionTypes["Assign"] = "xstate.assign";
+  ActionTypes["After"] = "xstate.after";
+  ActionTypes["DoneState"] = "done.state";
+  ActionTypes["DoneInvoke"] = "done.invoke";
+  ActionTypes["Log"] = "xstate.log";
+  ActionTypes["Init"] = "xstate.init";
+  ActionTypes["Invoke"] = "xstate.invoke";
+  ActionTypes["ErrorExecution"] = "error.execution";
+  ActionTypes["ErrorCommunication"] = "error.communication";
+  ActionTypes["ErrorPlatform"] = "error.platform";
+  ActionTypes["ErrorCustom"] = "xstate.error";
+  ActionTypes["Update"] = "xstate.update";
+  ActionTypes["Pure"] = "xstate.pure";
+  ActionTypes["Choose"] = "xstate.choose";
+})(ActionTypes || (ActionTypes = {}));
+
+var SpecialTargets;
+
+(function (SpecialTargets) {
+  SpecialTargets["Parent"] = "#_parent";
+  SpecialTargets["Internal"] = "#_internal";
+})(SpecialTargets || (SpecialTargets = {}));
+
+var stop = ActionTypes.Stop;
+var raise = ActionTypes.Raise;
+var send = ActionTypes.Send;
+var cancel = ActionTypes.Cancel;
+var assign = ActionTypes.Assign;
+var after = ActionTypes.After;
+var doneState = ActionTypes.DoneState;
+var log = ActionTypes.Log;
+var init = ActionTypes.Init;
+var invoke = ActionTypes.Invoke;
+var errorExecution = ActionTypes.ErrorExecution;
+var errorPlatform = ActionTypes.ErrorPlatform;
+var error = ActionTypes.ErrorCustom;
+var update = ActionTypes.Update;
+var choose = ActionTypes.Choose;
+var pure = ActionTypes.Pure;
+
+var actionTypes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  stop: stop,
+  raise: raise,
+  send: send,
+  cancel: cancel,
+  assign: assign,
+  after: after,
+  doneState: doneState,
+  log: log,
+  init: init,
+  invoke: invoke,
+  errorExecution: errorExecution,
+  errorPlatform: errorPlatform,
+  error: error,
+  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() {};
+
+if (!IS_PRODUCTION) {
+  warn = function warn(condition, message) {
+    var error = condition instanceof Error ? condition : undefined;
+
+    if (!error && condition) {
+      return;
+    }
+
+    if (console !== undefined) {
+      var args = ["Warning: ".concat(message)];
+
+      if (error) {
+        args.push(error);
+      } // tslint:disable-next-line:no-console
+
+
+      console.warn.apply(console, args);
+    }
+  };
+}
+
+function isArray(value) {
+  return Array.isArray(value);
+} // tslint:disable-next-line:ban-types
+
+function isFunction(value) {
+  return typeof value === 'function';
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+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 !== SpecialTargets.Parent && resolvedTarget !== 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: 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: 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;
+    }
+
+    if (!IS_PRODUCTION) {
+      warn(!/.*\*.+/.test(eventType), "Wildcards can only be the last token of an event descriptor (e.g., \"event.*\") or the entire event descriptor (\"*\"). Check the \"".concat(eventType, "\" event."));
+    }
+
+    var partialEventTokens = eventType.split('.');
+    var eventTokens = receivedEventType.split('.');
+
+    for (var tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+      var partialEventToken = partialEventTokens[tokenIndex];
+      var eventToken = eventTokens[tokenIndex];
+
+      if (partialEventToken === '*') {
+        var isLastToken = tokenIndex === partialEventTokens.length - 1;
+
+        if (!IS_PRODUCTION) {
+          warn(isLastToken, "Infix wildcards in transition events are not allowed. Check the \"".concat(eventType, "\" event."));
+        }
+
+        return isLastToken;
+      }
+
+      if (partialEventToken !== eventToken) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+  return candidates;
+}
+/**
+ * All delayed transitions from the config.
+ */
+
+function getDelayedTransitions(stateNode) {
+  var afterConfig = stateNode.config.after;
+
+  if (!afterConfig) {
+    return [];
+  }
+
+  var mutateEntryExit = function mutateEntryExit(delay, i) {
+    var delayRef = isFunction(delay) ? "".concat(stateNode.id, ":delay[").concat(i, "]") : delay;
+    var eventType = after$1(delayRef, stateNode.id);
+    stateNode.entry.push(send$1(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);
+
+  if (!IS_PRODUCTION && transitionConfig.cond) {
+    throw new Error("State \"".concat(stateNode.id, "\" has declared `cond` for one of its transitions. This property has been renamed to `guard`. Please update your code."));
+  }
+
+  var transition = _objectSpread2(_objectSpread2({}, transitionConfig), {}, {
+    actions: toActionObjects(toArray(transitionConfig.actions)),
+    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, function (guardType) {
+      return guards[guardType];
+    }) : undefined,
+    target: target,
+    source: stateNode,
+    internal: internal,
+    eventType: transitionConfig.event,
+    toJSON: function toJSON() {
+      return _objectSpread2(_objectSpread2({}, transition), {}, {
+        source: "#".concat(stateNode.id),
+        target: target ? target.map(function (t) {
+          return "#".concat(t.id);
+        }) : undefined
+      });
+    }
+  });
+
+  return transition;
+}
+function formatTransitions(stateNode) {
+  var transitionConfigs = [];
+
+  if (Array.isArray(stateNode.config.on)) {
+    transitionConfigs.push.apply(transitionConfigs, _toConsumableArray(stateNode.config.on));
+  } else if (stateNode.config.on) {
+    var _stateNode$config$on = stateNode.config.on,
+        _stateNode$config$on$ = _stateNode$config$on[WILDCARD],
+        wildcardConfigs = _stateNode$config$on$ === void 0 ? [] : _stateNode$config$on$,
+        namedTransitionConfigs = _objectWithoutProperties(_stateNode$config$on, [WILDCARD].map(_toPropertyKey));
+
+    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 === 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;
+
+      if (IS_PRODUCTION) {
+        warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
+      }
+
+      var transitionData = (_this$machine = 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;
+}();
+
+var InterpreterStatus;
+
+(function (InterpreterStatus) {
+  InterpreterStatus[InterpreterStatus["NotStarted"] = 0] = "NotStarted";
+  InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
+  InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
+})(InterpreterStatus || (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", 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 === InterpreterStatus.Stopped) {
+        // do nothing
+        if (!IS_PRODUCTION) {
+          warn(false, "Event \"".concat(_event.name, "\" was sent to stopped service \"").concat(_this.machine.key, "\". This service has already reached its final state, and will not transition.\nEvent: ").concat(JSON.stringify(_event.data)));
+        }
+
+        return;
+      }
+
+      if (_this.status !== 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 === 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 === 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 !== InterpreterStatus.NotStarted) {
+        listener(this.state);
+      }
+
+      if (resolvedCompleteListener) {
+        if (this.status === 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 === InterpreterStatus.Running) {
+        // Do not restart the service if it is already started
+        return this;
+      }
+
+      registry.register(this.sessionId, this.ref);
+      this.status = 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 = 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 === 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
+
+
+        if (!IS_PRODUCTION) {
+          warn(false, "Service '".concat(this.name, "' has no parent: unable to send event ").concat(event.type));
+        }
+
+        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) {
+          if (!IS_PRODUCTION) {
+            warn(false, "Actor type '".concat(action.params.src.type, "' not found in machine '").concat(_this6.machine.key, "'."));
+          }
+
+          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 _action$type;
+
+      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;
+        }
+      }
+
+      if (!IS_PRODUCTION && !((_action$type = action.type) !== null && _action$type !== void 0 && _action$type.startsWith('xstate.'))) {
+        warn(false, "No implementation found for action type '".concat(action.type, "'"));
+      }
+
+      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 : 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 === 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: 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: 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(ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
+}
+/**
+ * Returns an event that represents that a final state node
+ * has been reached in the parent state node.
+ *
+ * @param id The final state node's parent state node `id`
+ * @param data The data to pass into the event
+ */
+
+function done(id, data) {
+  var type = "".concat(ActionTypes.DoneState, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+/**
+ * Returns an event that represents that an invoked service has terminated.
+ *
+ * An invoked service is terminated when it has reached a top-level final state node,
+ * but not when it is canceled.
+ *
+ * @param invokeId The invoked service ID
+ * @param data The data to pass into the event
+ */
+
+function doneInvoke(invokeId, data) {
+  var type = "".concat(ActionTypes.DoneInvoke, ".").concat(invokeId);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+function error$1(id, data) {
+  var type = "".concat(ActionTypes.ErrorPlatform, ".").concat(id);
+  var eventObject = {
+    type: type,
+    data: data
+  };
+
+  eventObject.toString = function () {
+    return type;
+  };
+
+  return eventObject;
+}
+
+export { getDelayedTransitions as $, doneInvoke as A, getStateNodes as B, pathToStateValue as C, toEventObject as D, toObserver as E, toSCXMLEvent as F, ActionTypes as G, SpecialTargets as H, Interpreter as I, formatTransitions as J, toTransitionConfigArray as K, formatTransition as L, mapValues as M, NULL_EVENT as N, ObservableActorRef as O, memo as P, getEventType as Q, evaluateGuard as R, State as S, flatten as T, toActionObject as U, createInvokeId as V, toInvokeConfig as W, _objectSpread2 as X, invoke as Y, _objectWithoutProperties as Z, _createForOfIteratorHelper as _, _slicedToArray as a, formatInitialTransition as a0, getCandidates as a1, toInvokeSource as a2, isString as a3, createSpawner as a4, getConfiguration as a5, resolveStateValue as a6, toState as a7, macrostep as a8, isBuiltInEvent as a9, resolveActionObject as aA, toActionObjects as aB, error$1 as aC, resolveMicroTransition as aa, transitionNode as ab, getStateValue as ac, isStateId as ad, isFunction as ae, STATE_DELIMITER as af, stateIn as ag, not as ah, and as ai, or as aj, toGuardDefinition as ak, fromReducer as al, startSignalType as am, stopSignalType as an, startSignal as ao, stopSignal as ap, fromCallback as aq, fromPromise as ar, fromObservable as as, fromEventObservable as at, fromMachine as au, isActorRef as av, toActorRef as aw, actionTypes as ax, initEvent as ay, getActionFunction as az, _createClass as b, createDynamicAction as c, _toConsumableArray as d, _classCallCheck as e, _defineProperty as f, sendParent as g, sendTo as h, sendUpdate as i, cancel$1 as j, stop$1 as k, log$1 as l, matchesState as m, assign$1 as n, after$1 as o, pure as p, done as q, raise$1 as r, send$1 as s, toArray as t, respond as u, forwardTo as v, escalate as w, choose$1 as x, interpret as y, InterpreterStatus as z };