xstate 5.0.0-beta.27 → 5.0.0-beta.29

package/dist/xstate.development.cjs.js

@@ -2,12 +2,63 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var guards_dist_xstateGuards = require('./actions-ca622922.development.cjs.js');
-var promise = require('./promise-3b7e3357.development.cjs.js');
+var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
+var interpreter = require('./interpreter-e2c6a579.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-f751dfac.development.cjs.js');
+var send = require('./send-f53778f6.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(([id, timeout]) => {
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    });
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
+
 const EMPTY_OBJECT = {};
-const toSerializableActon = action => {
+const toSerializableAction = action => {
   if (typeof action === 'string') {
     return {
       type: action
@@ -80,7 +131,7 @@ class StateNode {
    */
 
   /**
-   * The output data sent with the "done.state._id_" event if this is a final state node.
+   * The output data sent with the "xstate.done.state._id_" event if this is a final state node.
    */
 
   /**
@@ -114,12 +165,12 @@ class StateNode {
     this.key = options._key;
     this.machine = options._machine;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
-    this.id = this.config.id || [this.machine.id, ...this.path].join(guards_dist_xstateGuards.STATE_DELIMITER);
+    this.id = this.config.id || [this.machine.id, ...this.path].join(interpreter.STATE_DELIMITER);
     this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
-    this.states = this.config.states ? guards_dist_xstateGuards.mapValues(this.config.states, (stateConfig, key) => {
+    this.states = this.config.states ? interpreter.mapValues(this.config.states, (stateConfig, key) => {
       const stateNode = new StateNode(stateConfig, {
         _parent: this,
         _key: key,
@@ -133,16 +184,16 @@ class StateNode {
 
     // History config
     this.history = this.config.history === true ? 'shallow' : this.config.history || false;
-    this.entry = guards_dist_xstateGuards.toArray(this.config.entry).slice();
-    this.exit = guards_dist_xstateGuards.toArray(this.config.exit).slice();
+    this.entry = interpreter.toArray(this.config.entry).slice();
+    this.exit = interpreter.toArray(this.config.exit).slice();
     this.meta = this.config.meta;
     this.output = this.type === 'final' ? this.config.output : undefined;
-    this.tags = guards_dist_xstateGuards.toArray(config.tags).slice();
+    this.tags = interpreter.toArray(config.tags).slice();
   }
   _initialize() {
     this.transitions = guards_dist_xstateGuards.formatTransitions(this);
     if (this.config.always) {
-      this.always = guards_dist_xstateGuards.toTransitionConfigArray(this.config.always).map(t => guards_dist_xstateGuards.formatTransition(this, guards_dist_xstateGuards.NULL_EVENT, t));
+      this.always = interpreter.toTransitionConfigArray(this.config.always).map(t => guards_dist_xstateGuards.formatTransition(this, interpreter.NULL_EVENT, t));
     }
     Object.keys(this.states).forEach(key => {
       this.states[key]._initialize();
@@ -161,27 +212,27 @@ class StateNode {
       initial: this.initial ? {
         target: this.initial.target,
         source: this,
-        actions: this.initial.actions.map(toSerializableActon),
+        actions: this.initial.actions.map(toSerializableAction),
         eventType: null,
         reenter: false,
         toJSON: () => ({
           target: this.initial.target.map(t => `#${t.id}`),
           source: `#${this.id}`,
-          actions: this.initial.actions.map(toSerializableActon),
+          actions: this.initial.actions.map(toSerializableAction),
           eventType: null
         })
       } : undefined,
       history: this.history,
-      states: guards_dist_xstateGuards.mapValues(this.states, state => {
+      states: interpreter.mapValues(this.states, state => {
         return state.definition;
       }),
       on: this.on,
       transitions: [...this.transitions.values()].flat().map(t => ({
         ...t,
-        actions: t.actions.map(toSerializableActon)
+        actions: t.actions.map(toSerializableAction)
       })),
-      entry: this.entry.map(toSerializableActon),
-      exit: this.exit.map(toSerializableActon),
+      entry: this.entry.map(toSerializableAction),
+      exit: this.exit.map(toSerializableAction),
       meta: this.meta,
       order: this.order || -1,
       output: this.output,
@@ -198,12 +249,12 @@ class StateNode {
    * The logic invoked as actors by this state node.
    */
   get invoke() {
-    return guards_dist_xstateGuards.memo(this, 'invoke', () => guards_dist_xstateGuards.toArray(this.config.invoke).map((invokeConfig, i) => {
+    return guards_dist_xstateGuards.memo(this, 'invoke', () => interpreter.toArray(this.config.invoke).map((invokeConfig, i) => {
       const {
         src,
         systemId
       } = invokeConfig;
-      const resolvedId = invokeConfig.id || guards_dist_xstateGuards.createInvokeId(this.id, i);
+      const resolvedId = invokeConfig.id || interpreter.createInvokeId(this.id, i);
       // TODO: resolving should not happen here
       const resolvedSrc = typeof src === 'string' ? src : !('type' in src) ? resolvedId : src;
       if (!this.machine.implementations.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
@@ -433,7 +484,7 @@ class StateMachine {
    */
   transition(state, event, actorCtx) {
     // TODO: handle error events in a better way
-    if (guards_dist_xstateGuards.isErrorEvent(event) && !state.nextEvents.some(nextEvent => nextEvent === event.type)) {
+    if (interpreter.isErrorActorEvent(event) && !state.nextEvents.some(nextEvent => nextEvent === event.type)) {
       return guards_dist_xstateGuards.cloneState(state, {
         error: event.data
       });
@@ -482,7 +533,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext([guards_dist_xstateGuards.assign(assignment)], initEvent, preInitial, actorCtx);
+      return guards_dist_xstateGuards.resolveActionsAndContext([send.assign(assignment)], initEvent, preInitial, actorCtx);
     }
     return preInitial;
   }
@@ -491,7 +542,7 @@ class StateMachine {
    * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
    */
   getInitialState(actorCtx, input) {
-    const initEvent = guards_dist_xstateGuards.createInitEvent(input); // TODO: fix;
+    const initEvent = interpreter.createInitEvent(input); // TODO: fix;
 
     const preInitialState = this.getPreInitialState(actorCtx, initEvent);
     const nextState = guards_dist_xstateGuards.microstep([{
@@ -515,7 +566,7 @@ class StateMachine {
     });
   }
   getStateNodeById(stateId) {
-    const fullPath = stateId.split(guards_dist_xstateGuards.STATE_DELIMITER);
+    const fullPath = stateId.split(interpreter.STATE_DELIMITER);
     const relativePath = fullPath.slice(1);
     const resolvedStateId = guards_dist_xstateGuards.isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
     const stateNode = this.idMap.get(resolvedStateId);
@@ -553,12 +604,12 @@ class StateMachine {
       const actorData = state.children[actorId];
       const childState = actorData.state;
       const src = actorData.src;
-      const logic = src ? guards_dist_xstateGuards.resolveReferencedActor(this.implementations.actors[src])?.src : undefined;
+      const logic = src ? interpreter.resolveReferencedActor(this.implementations.actors[src])?.src : undefined;
       if (!logic) {
         return;
       }
       const actorState = logic.restoreState?.(childState, _actorCtx);
-      const actorRef = guards_dist_xstateGuards.createActor(logic, {
+      const actorRef = interpreter.createActor(logic, {
         id: actorId,
         state: actorState
       });
@@ -580,9 +631,9 @@ class StateMachine {
           if (children[id]) {
             return;
           }
-          const referenced = guards_dist_xstateGuards.resolveReferencedActor(this.implementations.actors[src]);
+          const referenced = interpreter.resolveReferencedActor(this.implementations.actors[src]);
           if (referenced) {
-            const actorRef = guards_dist_xstateGuards.createActor(referenced.src, {
+            const actorRef = interpreter.createActor(referenced.src, {
               id,
               parent: _actorCtx?.self,
               input: 'input' in invokeConfig ? invokeConfig.input : referenced.input
@@ -598,69 +649,6 @@ class StateMachine {
   /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
 }
 
-function createMachine(config, implementations) {
-  return new StateMachine(config, implementations);
-}
-
-function mapState(stateMap, stateId) {
-  let foundStateId;
-  for (const mappedStateId of Object.keys(stateMap)) {
-    if (guards_dist_xstateGuards.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
-      foundStateId = mappedStateId;
-    }
-  }
-  return stateMap[foundStateId];
-}
-
-class SimulatedClock {
-  constructor() {
-    this.timeouts = new Map();
-    this._now = 0;
-    this._id = 0;
-  }
-  now() {
-    return this._now;
-  }
-  getId() {
-    return this._id++;
-  }
-  setTimeout(fn, timeout) {
-    const id = this.getId();
-    this.timeouts.set(id, {
-      start: this.now(),
-      timeout,
-      fn
-    });
-    return id;
-  }
-  clearTimeout(id) {
-    this.timeouts.delete(id);
-  }
-  set(time) {
-    if (this._now > time) {
-      throw new Error('Unable to travel back in time');
-    }
-    this._now = time;
-    this.flushTimeouts();
-  }
-  flushTimeouts() {
-    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
-      const endA = timeoutA.start + timeoutA.timeout;
-      const endB = timeoutB.start + timeoutB.timeout;
-      return endB > endA ? -1 : 1;
-    }).forEach(([id, timeout]) => {
-      if (this.now() - timeout.start >= timeout.timeout) {
-        this.timeouts.delete(id);
-        timeout.fn.call(null);
-      }
-    });
-  }
-  increment(ms) {
-    this._now += ms;
-    this.flushTimeouts();
-  }
-}
-
 const defaultWaitForOptions = {
   timeout: 10_000 // 10 seconds
 };
@@ -735,38 +723,52 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
-exports.Actor = guards_dist_xstateGuards.Actor;
-exports.ActorStatus = guards_dist_xstateGuards.ActorStatus;
-exports.ConstantPrefix = guards_dist_xstateGuards.ConstantPrefix;
-exports.InterpreterStatus = guards_dist_xstateGuards.InterpreterStatus;
-exports.SpecialTargets = guards_dist_xstateGuards.SpecialTargets;
+function createMachine(config, implementations) {
+  return new StateMachine(config, implementations);
+}
+
+function mapState(stateMap, stateId) {
+  let foundStateId;
+  for (const mappedStateId of Object.keys(stateMap)) {
+    if (interpreter.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
+    }
+  }
+  return stateMap[foundStateId];
+}
+
+exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
+exports.fromCallback = actors_dist_xstateActors.fromCallback;
+exports.fromEventObservable = actors_dist_xstateActors.fromEventObservable;
+exports.fromObservable = actors_dist_xstateActors.fromObservable;
+exports.fromPromise = actors_dist_xstateActors.fromPromise;
+exports.fromTransition = actors_dist_xstateActors.fromTransition;
+exports.Actor = interpreter.Actor;
+exports.ActorStatus = interpreter.ActorStatus;
+exports.InterpreterStatus = interpreter.InterpreterStatus;
+exports.createActor = interpreter.createActor;
+exports.interpret = interpreter.interpret;
+exports.matchesState = interpreter.matchesState;
+exports.pathToStateValue = interpreter.pathToStateValue;
+exports.toObserver = interpreter.toObserver;
 exports.State = guards_dist_xstateGuards.State;
 exports.and = guards_dist_xstateGuards.and;
-exports.assign = guards_dist_xstateGuards.assign;
 exports.cancel = guards_dist_xstateGuards.cancel;
-exports.choose = guards_dist_xstateGuards.choose;
-exports.createActor = guards_dist_xstateGuards.createActor;
-exports.doneInvoke = guards_dist_xstateGuards.doneInvoke;
-exports.forwardTo = guards_dist_xstateGuards.forwardTo;
 exports.getStateNodes = guards_dist_xstateGuards.getStateNodes;
-exports.interpret = guards_dist_xstateGuards.interpret;
-exports.log = guards_dist_xstateGuards.log;
-exports.matchesState = guards_dist_xstateGuards.matchesState;
 exports.not = guards_dist_xstateGuards.not;
 exports.or = guards_dist_xstateGuards.or;
-exports.pathToStateValue = guards_dist_xstateGuards.pathToStateValue;
-exports.pure = guards_dist_xstateGuards.pure;
 exports.raise = guards_dist_xstateGuards.raise;
-exports.sendParent = guards_dist_xstateGuards.sendParent;
-exports.sendTo = guards_dist_xstateGuards.sendTo;
 exports.stateIn = guards_dist_xstateGuards.stateIn;
 exports.stop = guards_dist_xstateGuards.stop;
-exports.toObserver = guards_dist_xstateGuards.toObserver;
-exports.fromCallback = promise.fromCallback;
-exports.fromEventObservable = promise.fromEventObservable;
-exports.fromObservable = promise.fromObservable;
-exports.fromPromise = promise.fromPromise;
-exports.fromTransition = promise.fromTransition;
+exports.SpecialTargets = send.SpecialTargets;
+exports.assign = send.assign;
+exports.choose = send.choose;
+exports.escalate = send.escalate;
+exports.forwardTo = send.forwardTo;
+exports.log = send.log;
+exports.pure = send.pure;
+exports.sendParent = send.sendParent;
+exports.sendTo = send.sendTo;
 exports.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;

package/dist/xstate.development.cjs.mjs

@@ -1,7 +1,6 @@
 export {
   Actor,
   ActorStatus,
-  ConstantPrefix,
   InterpreterStatus,
   SimulatedClock,
   SpecialTargets,
@@ -13,8 +12,9 @@ export {
   cancel,
   choose,
   createActor,
+  createEmptyActor,
   createMachine,
-  doneInvoke,
+  escalate,
   forwardTo,
   fromCallback,
   fromEventObservable,

package/dist/xstate.development.esm.js

@@ -1,10 +1,63 @@
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, c as memo, e as evaluateGuard, d as createInvokeId, g as getDelayedTransitions, h as formatInitialTransition, i as getCandidates, j as getConfiguration, k as getStateNodes, r as resolveStateValue, l as isInFinalState, n as State, o as isErrorEvent, p as cloneState, q as macrostep, s as transitionNode, u as getInitialConfiguration, v as resolveActionsAndContext, w as assign, x as createInitEvent, y as microstep, z as isAtomicStateNode, A as isStateId, B as getStateNodeByPath, C as getPersistedState, D as resolveReferencedActor, E as createActor, F as matchesState } from './actions-9754d2ca.development.esm.js';
-export { G as Actor, H as ActorStatus, a0 as ConstantPrefix, K as InterpreterStatus, a1 as SpecialTargets, n as State, Y as and, w as assign, L as cancel, M as choose, E as createActor, I as doneInvoke, R as forwardTo, k as getStateNodes, J as interpret, O as log, F as matchesState, Z as not, _ as or, W as pathToStateValue, P as pure, Q as raise, T as sendParent, U as sendTo, $ as stateIn, V as stop, X as toObserver } from './actions-9754d2ca.development.esm.js';
-export { f as fromCallback, a as fromEventObservable, b as fromObservable, c as fromPromise, d as fromTransition } from './promise-2ad94e3b.development.esm.js';
+export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, a as toTransitionConfigArray, N as NULL_EVENT, c as createInvokeId, i as isErrorActorEvent, b as createInitEvent, r as resolveReferencedActor, d as createActor, e as matchesState } from './interpreter-6e7909c8.development.esm.js';
+export { A as Actor, f as ActorStatus, I as InterpreterStatus, d as createActor, g as interpret, e as matchesState, p as pathToStateValue, h as toObserver } from './interpreter-6e7909c8.development.esm.js';
+import { f as formatTransitions, a as formatTransition, m as memo, e as evaluateGuard, g as getDelayedTransitions, b as formatInitialTransition, c as getCandidates, d as getConfiguration, h as getStateNodes, r as resolveStateValue, i as isInFinalState, S as State, j as cloneState, k as macrostep, t as transitionNode, l as getInitialConfiguration, n as resolveActionsAndContext, o as microstep, p as isAtomicStateNode, q as isStateId, s as getStateNodeByPath, u as getPersistedState } from './raise-e778a828.development.esm.js';
+export { S as State, v as and, z as cancel, h as getStateNodes, w as not, x as or, A as raise, y as stateIn, B as stop } from './raise-e778a828.development.esm.js';
+import { a as assign } from './send-42c83fb2.development.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-42c83fb2.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(([id, timeout]) => {
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    });
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
+
 const EMPTY_OBJECT = {};
-const toSerializableActon = action => {
+const toSerializableAction = action => {
   if (typeof action === 'string') {
     return {
       type: action
@@ -77,7 +130,7 @@ class StateNode {
    */
 
   /**
-   * The output data sent with the "done.state._id_" event if this is a final state node.
+   * The output data sent with the "xstate.done.state._id_" event if this is a final state node.
    */
 
   /**
@@ -158,13 +211,13 @@ class StateNode {
       initial: this.initial ? {
         target: this.initial.target,
         source: this,
-        actions: this.initial.actions.map(toSerializableActon),
+        actions: this.initial.actions.map(toSerializableAction),
         eventType: null,
         reenter: false,
         toJSON: () => ({
           target: this.initial.target.map(t => `#${t.id}`),
           source: `#${this.id}`,
-          actions: this.initial.actions.map(toSerializableActon),
+          actions: this.initial.actions.map(toSerializableAction),
           eventType: null
         })
       } : undefined,
@@ -175,10 +228,10 @@ class StateNode {
       on: this.on,
       transitions: [...this.transitions.values()].flat().map(t => ({
         ...t,
-        actions: t.actions.map(toSerializableActon)
+        actions: t.actions.map(toSerializableAction)
       })),
-      entry: this.entry.map(toSerializableActon),
-      exit: this.exit.map(toSerializableActon),
+      entry: this.entry.map(toSerializableAction),
+      exit: this.exit.map(toSerializableAction),
       meta: this.meta,
       order: this.order || -1,
       output: this.output,
@@ -430,7 +483,7 @@ class StateMachine {
    */
   transition(state, event, actorCtx) {
     // TODO: handle error events in a better way
-    if (isErrorEvent(event) && !state.nextEvents.some(nextEvent => nextEvent === event.type)) {
+    if (isErrorActorEvent(event) && !state.nextEvents.some(nextEvent => nextEvent === event.type)) {
       return cloneState(state, {
         error: event.data
       });
@@ -595,69 +648,6 @@ class StateMachine {
   /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
 }
 
-function createMachine(config, implementations) {
-  return new StateMachine(config, implementations);
-}
-
-function mapState(stateMap, stateId) {
-  let foundStateId;
-  for (const mappedStateId of Object.keys(stateMap)) {
-    if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
-      foundStateId = mappedStateId;
-    }
-  }
-  return stateMap[foundStateId];
-}
-
-class SimulatedClock {
-  constructor() {
-    this.timeouts = new Map();
-    this._now = 0;
-    this._id = 0;
-  }
-  now() {
-    return this._now;
-  }
-  getId() {
-    return this._id++;
-  }
-  setTimeout(fn, timeout) {
-    const id = this.getId();
-    this.timeouts.set(id, {
-      start: this.now(),
-      timeout,
-      fn
-    });
-    return id;
-  }
-  clearTimeout(id) {
-    this.timeouts.delete(id);
-  }
-  set(time) {
-    if (this._now > time) {
-      throw new Error('Unable to travel back in time');
-    }
-    this._now = time;
-    this.flushTimeouts();
-  }
-  flushTimeouts() {
-    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
-      const endA = timeoutA.start + timeoutA.timeout;
-      const endB = timeoutB.start + timeoutB.timeout;
-      return endB > endA ? -1 : 1;
-    }).forEach(([id, timeout]) => {
-      if (this.now() - timeout.start >= timeout.timeout) {
-        this.timeouts.delete(id);
-        timeout.fn.call(null);
-      }
-    });
-  }
-  increment(ms) {
-    this._now += ms;
-    this.flushTimeouts();
-  }
-}
-
 const defaultWaitForOptions = {
   timeout: 10_000 // 10 seconds
 };
@@ -732,4 +722,18 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+function createMachine(config, implementations) {
+  return new StateMachine(config, implementations);
+}
+
+function mapState(stateMap, stateId) {
+  let foundStateId;
+  for (const mappedStateId of Object.keys(stateMap)) {
+    if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
+    }
+  }
+  return stateMap[foundStateId];
+}
+
 export { SimulatedClock, StateMachine, StateNode, createMachine, mapState, waitFor };