@ohif/app 3.7.0-beta.7 → 3.7.0-beta.71

package/dist/{531.bundle.2a82fb1d69e5b57cc72b.js → 677.bundle.ec5f2b4707db33bd4d8e.js}

@@ -1,11 +1,42 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[531],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[677],{
 
-/***/ 38531:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 59677:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  eO: () => (/* reexport */ useMachine)
+});
+
+// UNUSED EXPORTS: createActorContext, shallowEqual, useActor, useInterpret, useSelector, useSpawn
+
+// EXTERNAL MODULE: ../../../node_modules/react/index.js
+var react = __webpack_require__(43001);
+// EXTERNAL MODULE: ../../../node_modules/use-sync-external-store/shim/with-selector.js
+var with_selector = __webpack_require__(56901);
+// EXTERNAL MODULE: ../../../node_modules/xstate/es/index.js + 22 modules
+var es = __webpack_require__(261);
+;// CONCATENATED MODULE: ../../../node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js
+
+
+var index =  react.useLayoutEffect ;
+
+/* harmony default export */ const use_isomorphic_layout_effect_browser_esm = (index);
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useConstant.js
 
+function useConstant_useConstant(fn) {
+    var ref = react.useRef();
+    if (!ref.current) {
+        ref.current = { v: fn() };
+    }
+    return ref.current.v;
+}
 
-var __assign = (this && this.__assign) || function () {
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useInterpret.js
+var __assign = (undefined && undefined.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
             s = arguments[i];
@@ -16,7 +47,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __rest = (this && this.__rest) || function (s, e) {
+var __rest = (undefined && undefined.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
         t[p] = s[p];
@@ -27,7 +58,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __read = (this && this.__read) || function (o, n) {
+var __read = (undefined && undefined.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
     var i = m.call(o), r, ar = [], e;
@@ -43,105 +74,174 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-var react_1 = __webpack_require__(32735);
-var xstate_1 = __webpack_require__(87519);
-var defaultOptions = {
-    immediate: false
-};
-function useMachine(machine, options) {
-    if (options === void 0) { options = defaultOptions; }
-    var context = options.context, guards = options.guards, actions = options.actions, activities = options.activities, services = options.services, delays = options.delays, immediate = options.immediate, rehydratedState = options.state, interpreterOptions = __rest(options, ["context", "guards", "actions", "activities", "services", "delays", "immediate", "state"]);
-    var machineConfig = {
-        context: context,
-        guards: guards,
-        actions: actions,
-        activities: activities,
-        services: services,
-        delays: delays
-    };
-    // Reference the machine
-    var machineRef = react_1.useRef(null);
-    // Create the machine only once
-    // See https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily
-    if (machineRef.current === null) {
-        machineRef.current = machine.withConfig(machineConfig, __assign(__assign({}, machine.context), context));
-    }
-    // Reference the service
-    var serviceRef = react_1.useRef(null);
-    // Create the service only once
-    if (serviceRef.current === null) {
-        serviceRef.current = xstate_1.interpret(machineRef.current, interpreterOptions).onTransition(function (state) {
-            // Update the current machine state when a transition occurs
-            if (state.changed) {
-                setCurrent(state);
-            }
-        });
-    }
-    var service = serviceRef.current;
-    // Make sure actions and services are kept updated when they change.
+
+
+
+
+function useIdleInterpreter(getMachine, options) {
+    var machine = useConstant_useConstant(function () {
+        return typeof getMachine === 'function' ? getMachine() : getMachine;
+    });
+    if (false) { var _a, initialMachine; }
+    var context = options.context, guards = options.guards, actions = options.actions, activities = options.activities, services = options.services, delays = options.delays, rehydratedState = options.state, interpreterOptions = __rest(options, ["context", "guards", "actions", "activities", "services", "delays", "state"]);
+    var service = useConstant_useConstant(function () {
+        var machineConfig = {
+            context: context,
+            guards: guards,
+            actions: actions,
+            activities: activities,
+            services: services,
+            delays: delays
+        };
+        var machineWithConfig = machine.withConfig(machineConfig, function () { return (__assign(__assign({}, machine.context), context)); });
+        return (0,es/* interpret */.kJ)(machineWithConfig, interpreterOptions);
+    });
+    // Make sure options are kept updated when they change.
     // This mutation assignment is safe because the service instance is only used
     // in one place -- this hook's caller.
-    react_1.useEffect(function () {
+    use_isomorphic_layout_effect_browser_esm(function () {
         Object.assign(service.machine.options.actions, actions);
-    }, [actions]);
-    react_1.useEffect(function () {
+        Object.assign(service.machine.options.guards, guards);
+        Object.assign(service.machine.options.activities, activities);
         Object.assign(service.machine.options.services, services);
-    }, [services]);
-    // Keep track of the current machine state
-    var initialState = rehydratedState
-        ? xstate_1.State.create(rehydratedState)
-        : service.initialState;
-    var _a = __read(react_1.useState(function () { return initialState; }), 2), current = _a[0], setCurrent = _a[1];
-    // Start service immediately (before mount) if specified in options
-    if (immediate) {
-        service.start();
-    }
-    react_1.useEffect(function () {
-        // Start the service when the component mounts.
-        // Note: the service will start only if it hasn't started already.
-        //
-        // If a rehydrated state was provided, use the resolved `initialState`.
-        service.start(rehydratedState ? initialState : undefined);
-        return function () {
-            // Stop the service when the component unmounts
-            service.stop();
-        };
-    }, []);
-    return [current, service.send, service];
+        Object.assign(service.machine.options.delays, delays);
+    }, [actions, guards, activities, services, delays]);
+    return service;
 }
-exports.useMachine = useMachine;
-function useService(service) {
-    var _a = __read(react_1.useState(service.state), 2), current = _a[0], setCurrent = _a[1];
-    react_1.useEffect(function () {
-        // Set to current service state as there is a possibility
-        // of a transition occurring between the initial useState()
-        // initialization and useEffect() commit.
-        setCurrent(service.state);
-        var listener = function (state) {
-            if (state.changed) {
-                setCurrent(state);
-            }
-        };
-        var sub = service.subscribe(listener);
+function useInterpret_useInterpret(getMachine) {
+    var _a = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        _a[_i - 1] = arguments[_i];
+    }
+    var _b = __read(_a, 2), _c = _b[0], options = _c === void 0 ? {} : _c, observerOrListener = _b[1];
+    var service = useIdleInterpreter(getMachine, options);
+    useEffect(function () {
+        if (!observerOrListener) {
+            return;
+        }
+        var sub = service.subscribe(toObserver(observerOrListener));
         return function () {
             sub.unsubscribe();
         };
-    }, [service]);
-    return [current, service.send, service];
+    }, [observerOrListener]);
+    useEffect(function () {
+        var rehydratedState = options.state;
+        service.start(rehydratedState ? State.create(rehydratedState) : undefined);
+        return function () {
+            service.stop();
+            service.status = InterpreterStatus.NotStarted;
+        };
+    }, []);
+    return service;
 }
-exports.useService = useService;
-var useActor_1 = __webpack_require__(7283);
-exports.useActor = useActor_1.useActor;
-//# sourceMappingURL=index.js.map
-
-/***/ }),
 
-/***/ 7283:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/utils.js
+var utils_read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (undefined && undefined.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 
+function partition(items, predicate) {
+    var e_1, _a;
+    var _b = utils_read([[], []], 2), truthy = _b[0], falsy = _b[1];
+    try {
+        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+            var item = items_1_1.value;
+            if (predicate(item)) {
+                truthy.push(item);
+            }
+            else {
+                falsy.push(item);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [truthy, falsy];
+}
+function utils_getServiceSnapshot(service) {
+    return service.status !== 0
+        ? service.getSnapshot()
+        : service.machine.initialState;
+}
+// From https://github.com/reduxjs/react-redux/blob/master/src/utils/shallowEqual.ts
+function is(x, y) {
+    if (x === y) {
+        return x !== 0 || y !== 0 || 1 / x === 1 / y;
+    }
+    else {
+        return x !== x && y !== y;
+    }
+}
+function shallowEqual(objA, objB) {
+    if (is(objA, objB))
+        return true;
+    if (typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null) {
+        return false;
+    }
+    var keysA = Object.keys(objA);
+    var keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (var i = 0; i < keysA.length; i++) {
+        if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
+            !is(objA[keysA[i]], objB[keysA[i]])) {
+            return false;
+        }
+    }
+    return true;
+}
+function utils_isService(actor) {
+    return 'state' in actor && 'machine' in actor;
+}
+function utils_isInterpreterStateEqual(service, prevState, nextState) {
+    if (service.status === es/* InterpreterStatus */.TM.NotStarted) {
+        return true;
+    }
+    // Only change the current state if:
+    // - the incoming state is the "live" initial state (since it might have new actors)
+    // - OR the incoming state actually changed.
+    //
+    // The "live" initial state will have .changed === undefined.
+    var initialStateChanged = nextState.changed === undefined &&
+        (Object.keys(nextState.children).length > 0 ||
+            typeof prevState.changed === 'boolean');
+    return !(nextState.changed || initialStateChanged);
+}
 
-var __read = (this && this.__read) || function (o, n) {
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useMachine.js
+var useMachine_read = (undefined && undefined.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
     var i = m.call(o), r, ar = [], e;
@@ -157,126 +257,306 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-var react_1 = __webpack_require__(32735);
-function useActor(actor) {
-    var _a = __read(react_1.useState(undefined), 2), current = _a[0], setCurrent = _a[1];
-    var actorRef = react_1.useRef(actor);
-    react_1.useEffect(function () {
-        if (actor) {
-            actorRef.current = actor;
-            var sub_1 = actor.subscribe(setCurrent);
-            return function () {
-                sub_1.unsubscribe();
-            };
+
+
+
+
+
+function identity(a) {
+    return a;
+}
+function useMachine(getMachine) {
+    var _a = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        _a[_i - 1] = arguments[_i];
+    }
+    var _b = useMachine_read(_a, 1), _c = _b[0], options = _c === void 0 ? {} : _c;
+    // using `useIdleInterpreter` allows us to subscribe to the service *before* we start it
+    // so we don't miss any notifications
+    var service = useIdleInterpreter(getMachine, options);
+    var getSnapshot = (0,react.useCallback)(function () {
+        if (service.status === es/* InterpreterStatus */.TM.NotStarted) {
+            return (options.state
+                ? es/* State */.ZM.create(options.state)
+                : service.machine.initialState);
+        }
+        return service.getSnapshot();
+    }, [service]);
+    var isEqual = (0,react.useCallback)(function (prevState, nextState) {
+        return utils_isInterpreterStateEqual(service, prevState, nextState);
+    }, [service]);
+    var subscribe = (0,react.useCallback)(function (handleStoreChange) {
+        var unsubscribe = service.subscribe(handleStoreChange).unsubscribe;
+        return unsubscribe;
+    }, [service]);
+    var storeSnapshot = (0,with_selector.useSyncExternalStoreWithSelector)(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+    (0,react.useEffect)(function () {
+        var rehydratedState = options.state;
+        service.start(rehydratedState ? es/* State */.ZM.create(rehydratedState) : undefined);
+        return function () {
+            service.stop();
+            service.status = es/* InterpreterStatus */.TM.NotStarted;
+        };
+    }, []);
+    return [storeSnapshot, service.send, service];
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useActor.js
+
+
+
+
+
+function useActor_identity(a) {
+    return a;
+}
+function useActor_isActorWithState(actorRef) {
+    return 'state' in actorRef;
+}
+function isDeferredActor(actorRef) {
+    return 'deferred' in actorRef;
+}
+function defaultGetSnapshot(actorRef) {
+    return 'getSnapshot' in actorRef
+        ? isService(actorRef)
+            ? getServiceSnapshot(actorRef)
+            : actorRef.getSnapshot()
+        : useActor_isActorWithState(actorRef)
+            ? actorRef.state
+            : undefined;
+}
+function useActor(actorRef, getSnapshot) {
+    if (getSnapshot === void 0) { getSnapshot = defaultGetSnapshot; }
+    var actorRefRef = useRef(actorRef);
+    var deferredEventsRef = useRef([]);
+    var subscribe = useCallback(function (handleStoreChange) {
+        var unsubscribe = actorRef.subscribe(handleStoreChange).unsubscribe;
+        return unsubscribe;
+    }, [actorRef]);
+    var boundGetSnapshot = useCallback(function () { return getSnapshot(actorRef); }, [actorRef, getSnapshot]);
+    var isEqual = useCallback(function (prevState, nextState) {
+        if (isService(actorRef)) {
+            return isInterpreterStateEqual(actorRef, prevState, nextState);
+        }
+        return prevState === nextState;
+    }, [actorRef]);
+    var storeSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, useActor_identity, isEqual);
+    var send = useConstant(function () { return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var event = args[0];
+        if (false) {}
+        var currentActorRef = actorRefRef.current;
+        // If the previous actor is a deferred actor,
+        // queue the events so that they can be replayed
+        // on the non-deferred actor.
+        if (isDeferredActor(currentActorRef) && currentActorRef.deferred) {
+            deferredEventsRef.current.push(event);
+        }
+        else {
+            currentActorRef.send(event);
+        }
+    }; });
+    useIsomorphicLayoutEffect(function () {
+        actorRefRef.current = actorRef;
+        // Dequeue deferred events from the previous deferred actorRef
+        while (deferredEventsRef.current.length > 0) {
+            var deferredEvent = deferredEventsRef.current.shift();
+            actorRef.send(deferredEvent);
+        }
+    }, [actorRef]);
+    return [storeSnapshot, send];
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useSelector.js
+
+
+
+
+var defaultCompare = function (a, b) { return a === b; };
+var useSelector_defaultGetSnapshot = function (a, initialStateCacheRef) {
+    if (isService(a)) {
+        // A status of 0 = interpreter not started
+        if (a.status === 0 && initialStateCacheRef.current) {
+            return initialStateCacheRef.current;
         }
+        var snapshot = getServiceSnapshot(a);
+        initialStateCacheRef.current = a.status === 0 ? snapshot : null;
+        return snapshot;
+    }
+    return isActorWithState(a) ? a.state : undefined;
+};
+function useSelector(actor, selector, compare, getSnapshot) {
+    if (compare === void 0) { compare = defaultCompare; }
+    var initialStateCacheRef = useRef(null);
+    var subscribe = useCallback(function (handleStoreChange) {
+        var unsubscribe = actor.subscribe(handleStoreChange).unsubscribe;
+        return unsubscribe;
     }, [actor]);
-    return [current, actorRef.current ? actorRef.current.send : function () { return void 0; }];
+    var boundGetSnapshot = useCallback(function () {
+        if (getSnapshot) {
+            return getSnapshot(actor);
+        }
+        return useSelector_defaultGetSnapshot(actor, initialStateCacheRef);
+    }, [actor, getSnapshot]);
+    var selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
+    return selectedSnapshot;
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/useSpawn.js
+
+
+/**
+ * React hook that spawns an `ActorRef` with the specified `behavior`.
+ * The returned `ActorRef` can be used with the `useActor(actorRef)` hook.
+ *
+ * @param behavior The actor behavior to spawn
+ * @returns An ActorRef with the specified `behavior`
+ */
+function useSpawn(behavior) {
+    var actorRef = useConstant(function () {
+        return spawnBehavior(behavior);
+    });
+    return actorRef;
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/createActorContext.js
+var createActorContext_assign = (undefined && undefined.__assign) || function () {
+    createActorContext_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return createActorContext_assign.apply(this, arguments);
+};
+
+
+
+
+function createActorContext(machine, interpreterOptions, observerOrListener) {
+    var ReactContext = React.createContext(null);
+    var OriginalProvider = ReactContext.Provider;
+    function Provider(_a) {
+        var children = _a.children, _b = _a.machine, providedMachine = _b === void 0 ? machine : _b, options = _a.options;
+        var actor = useInterpret(providedMachine, createActorContext_assign(createActorContext_assign({}, interpreterOptions), options), observerOrListener);
+        return React.createElement(OriginalProvider, { value: actor }, children);
+    }
+    Provider.displayName = "ActorProvider(".concat(machine.id, ")");
+    function useContext() {
+        var actor = React.useContext(ReactContext);
+        if (!actor) {
+            throw new Error("You used a hook from \"".concat(Provider.displayName, "\" but it's not inside a <").concat(Provider.displayName, "> component."));
+        }
+        return actor;
+    }
+    function useActor() {
+        var actor = useContext();
+        return useActorUnbound(actor);
+    }
+    function useSelector(selector, compare) {
+        var actor = useContext();
+        return useSelectorUnbound(actor, selector, compare);
+    }
+    return {
+        Provider: Provider,
+        useActorRef: useContext,
+        useActor: useActor,
+        useSelector: useSelector
+    };
 }
-exports.useActor = useActor;
-//# sourceMappingURL=useActor.js.map
+
+;// CONCATENATED MODULE: ../../../node_modules/@xstate/react/es/index.js
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 17145:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var e=__webpack_require__(43001);function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}
+function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;
+
+
+/***/ }),
+
+/***/ 1594:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h=__webpack_require__(43001),n=__webpack_require__(75011);function p(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q="function"===typeof Object.is?Object.is:p,r=n.useSyncExternalStore,t=h.useRef,u=h.useEffect,v=h.useMemo,w=h.useDebugValue;
+exports.useSyncExternalStoreWithSelector=function(a,b,e,l,g){var c=t(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=v(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q(d,a))return b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,g]);var d=r(a,c[0],c[1]);
+u(function(){f.hasValue=!0;f.value=d},[d]);w(d);return d};
+
+
+/***/ }),
+
+/***/ 75011:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+
+if (true) {
+  module.exports = __webpack_require__(17145);
+} else {}
+
+
+/***/ }),
+
+/***/ 56901:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+
+if (true) {
+  module.exports = __webpack_require__(1594);
+} else {}
+
 
 /***/ }),
 
-/***/ 87519:
+/***/ 261:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  ActionTypes: () => (/* reexport */ ActionTypes),
-  Interpreter: () => (/* reexport */ Interpreter),
-  InterpreterStatus: () => (/* reexport */ InterpreterStatus),
-  Machine: () => (/* reexport */ Machine),
-  SpecialTargets: () => (/* reexport */ SpecialTargets),
-  State: () => (/* reexport */ State),
-  StateNode: () => (/* reexport */ StateNode),
-  actions: () => (/* reexport */ actions_namespaceObject),
-  assign: () => (/* binding */ es_assign),
-  createMachine: () => (/* reexport */ createMachine),
-  createSchema: () => (/* reexport */ createSchema),
-  doneInvoke: () => (/* binding */ es_doneInvoke),
-  forwardTo: () => (/* binding */ es_forwardTo),
-  interpret: () => (/* reexport */ interpret),
-  mapState: () => (/* reexport */ mapState),
-  matchState: () => (/* reexport */ matchState),
-  matchesState: () => (/* reexport */ matchesState),
-  raise: () => (/* binding */ es_raise),
-  send: () => (/* binding */ es_send),
-  sendParent: () => (/* binding */ es_sendParent),
-  sendTo: () => (/* binding */ es_sendTo),
-  sendUpdate: () => (/* binding */ es_sendUpdate),
-  spawn: () => (/* reexport */ spawn),
-  spawnBehavior: () => (/* reexport */ spawnBehavior),
-  t: () => (/* reexport */ t),
-  toActorRef: () => (/* reexport */ toActorRef),
-  toEventObject: () => (/* reexport */ toEventObject),
-  toObserver: () => (/* reexport */ toObserver),
-  toSCXMLEvent: () => (/* reexport */ toSCXMLEvent)
+  TM: () => (/* reexport */ InterpreterStatus),
+  J: () => (/* reexport */ Machine),
+  ZM: () => (/* reexport */ State_State),
+  f0: () => (/* binding */ es_assign),
+  kJ: () => (/* reexport */ interpret)
 });
 
-// NAMESPACE OBJECT: ../../../node_modules/xstate/es/actionTypes.js
-var actionTypes_namespaceObject = {};
-__webpack_require__.r(actionTypes_namespaceObject);
-__webpack_require__.d(actionTypes_namespaceObject, {
-  after: () => (after),
-  assign: () => (actionTypes_assign),
-  cancel: () => (cancel),
-  choose: () => (choose),
-  doneState: () => (doneState),
-  error: () => (actionTypes_error),
-  errorExecution: () => (errorExecution),
-  errorPlatform: () => (errorPlatform),
-  init: () => (init),
-  invoke: () => (invoke),
-  log: () => (log),
-  nullEvent: () => (nullEvent),
-  pure: () => (pure),
-  raise: () => (raise),
-  send: () => (send),
-  start: () => (start),
-  stop: () => (stop),
-  update: () => (update)
-});
-
-// NAMESPACE OBJECT: ../../../node_modules/xstate/es/actions.js
-var actions_namespaceObject = {};
-__webpack_require__.r(actions_namespaceObject);
-__webpack_require__.d(actions_namespaceObject, {
-  actionTypes: () => (actionTypes_namespaceObject),
-  after: () => (actions_after),
-  assign: () => (actions_assign),
-  cancel: () => (actions_cancel),
-  choose: () => (actions_choose),
-  done: () => (done),
-  doneInvoke: () => (actions_doneInvoke),
-  error: () => (actions_error),
-  escalate: () => (escalate),
-  forwardTo: () => (forwardTo),
-  getActionFunction: () => (getActionFunction),
-  initEvent: () => (initEvent),
-  isActionObject: () => (isActionObject),
-  log: () => (actions_log),
-  pure: () => (actions_pure),
-  raise: () => (actions_raise),
-  resolveActions: () => (resolveActions),
-  resolveLog: () => (resolveLog),
-  resolveRaise: () => (resolveRaise),
-  resolveSend: () => (resolveSend),
-  resolveStop: () => (resolveStop),
-  respond: () => (respond),
-  send: () => (actions_send),
-  sendParent: () => (sendParent),
-  sendTo: () => (sendTo),
-  sendUpdate: () => (sendUpdate),
-  start: () => (actions_start),
-  stop: () => (actions_stop),
-  toActionObject: () => (toActionObject),
-  toActionObjects: () => (toActionObjects),
-  toActivityDefinition: () => (toActivityDefinition)
-});
+// UNUSED EXPORTS: ActionTypes, Interpreter, SpecialTargets, StateNode, actions, choose, createMachine, createSchema, doneInvoke, forwardTo, log, mapState, matchState, matchesState, pure, raise, send, sendParent, sendTo, sendUpdate, spawn, spawnBehavior, stop, t, toActorRef, toEventObject, toObserver, toSCXMLEvent
 
 ;// CONCATENATED MODULE: ../../../node_modules/xstate/es/_virtual/_tslib.js
 /*! *****************************************************************************
@@ -294,15 +574,15 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
+var _tslib_assign = function() {
+    _tslib_assign = Object.assign || function __assign(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
             s = arguments[i];
             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
         }
         return t;
     };
-    return __assign.apply(this, arguments);
+    return _tslib_assign.apply(this, arguments);
 };
 
 function __rest(s, e) {
@@ -329,7 +609,7 @@ function _tslib_values(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 
-function __read(o, n) {
+function _tslib_read(o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
     var i = m.call(o), r, ar = [], e;
@@ -346,7 +626,7 @@ function __read(o, n) {
     return ar;
 }
 
-function __spreadArray(to, from, pack) {
+function _tslib_spreadArray(to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
             if (!ar) ar = Array.prototype.slice.call(from, 0, i);
@@ -359,7 +639,7 @@ function __spreadArray(to, from, pack) {
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/xstate/es/types.js
-var ActionTypes;
+var types_ActionTypes;
 
 (function (ActionTypes) {
   ActionTypes["Start"] = "xstate.start";
@@ -382,38 +662,38 @@ var ActionTypes;
   ActionTypes["Update"] = "xstate.update";
   ActionTypes["Pure"] = "xstate.pure";
   ActionTypes["Choose"] = "xstate.choose";
-})(ActionTypes || (ActionTypes = {}));
+})(types_ActionTypes || (types_ActionTypes = {}));
 
-var SpecialTargets;
+var types_SpecialTargets;
 
 (function (SpecialTargets) {
   SpecialTargets["Parent"] = "#_parent";
   SpecialTargets["Internal"] = "#_internal";
-})(SpecialTargets || (SpecialTargets = {}));
+})(types_SpecialTargets || (types_SpecialTargets = {}));
 
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/xstate/es/actionTypes.js
 
 
-var start = ActionTypes.Start;
-var stop = ActionTypes.Stop;
-var raise = ActionTypes.Raise;
-var send = ActionTypes.Send;
-var cancel = ActionTypes.Cancel;
-var nullEvent = ActionTypes.NullEvent;
-var actionTypes_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 actionTypes_error = ActionTypes.ErrorCustom;
-var update = ActionTypes.Update;
-var choose = ActionTypes.Choose;
-var pure = ActionTypes.Pure;
+var start = types_ActionTypes.Start;
+var stop = types_ActionTypes.Stop;
+var raise = types_ActionTypes.Raise;
+var send = types_ActionTypes.Send;
+var cancel = types_ActionTypes.Cancel;
+var nullEvent = types_ActionTypes.NullEvent;
+var actionTypes_assign = types_ActionTypes.Assign;
+var after = types_ActionTypes.After;
+var doneState = types_ActionTypes.DoneState;
+var log = types_ActionTypes.Log;
+var init = types_ActionTypes.Init;
+var invoke = types_ActionTypes.Invoke;
+var errorExecution = types_ActionTypes.ErrorExecution;
+var errorPlatform = types_ActionTypes.ErrorPlatform;
+var actionTypes_error = types_ActionTypes.ErrorCustom;
+var actionTypes_update = types_ActionTypes.Update;
+var choose = types_ActionTypes.Choose;
+var pure = types_ActionTypes.Pure;
 
 
 
@@ -426,7 +706,7 @@ var TARGETLESS_KEY = '';
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/xstate/es/environment.js
-var IS_PRODUCTION = "production" === 'production';
+var environment_IS_PRODUCTION = "production" === 'production';
 
 
 
@@ -441,7 +721,7 @@ var _a;
 function keys(value) {
   return Object.keys(value);
 }
-function matchesState(parentStateId, childStateId, delimiter) {
+function utils_matchesState(parentStateId, childStateId, delimiter) {
   if (delimiter === void 0) {
     delimiter = STATE_DELIMITER;
   }
@@ -449,8 +729,8 @@ function matchesState(parentStateId, childStateId, delimiter) {
   var parentStateValue = toStateValue(parentStateId, delimiter);
   var childStateValue = toStateValue(childStateId, delimiter);
 
-  if (isString(childStateValue)) {
-    if (isString(parentStateValue)) {
+  if (utils_isString(childStateValue)) {
+    if (utils_isString(parentStateValue)) {
       return childStateValue === parentStateValue;
     } // Parent more specific than child
 
@@ -458,7 +738,7 @@ function matchesState(parentStateId, childStateId, delimiter) {
     return false;
   }
 
-  if (isString(parentStateValue)) {
+  if (utils_isString(parentStateValue)) {
     return parentStateValue in childStateValue;
   }
 
@@ -467,19 +747,19 @@ function matchesState(parentStateId, childStateId, delimiter) {
       return false;
     }
 
-    return matchesState(parentStateValue[key], childStateValue[key]);
+    return utils_matchesState(parentStateValue[key], childStateValue[key]);
   });
 }
 function getEventType(event) {
   try {
-    return isString(event) || typeof event === 'number' ? "".concat(event) : event.type;
+    return utils_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 getActionType(action) {
   try {
-    return isString(action) || typeof action === 'number' ? "".concat(action) : isFunction(action) ? action.name : action.type;
+    return utils_isString(action) || typeof action === 'number' ? "".concat(action) : utils_isFunction(action) ? action.name : action.type;
   } catch (e) {
     throw new Error('Actions must be strings or objects with a string action.type property.');
   }
@@ -641,7 +921,7 @@ function toStatePaths(stateValue) {
     return [[]];
   }
 
-  if (isString(stateValue)) {
+  if (utils_isString(stateValue)) {
     return [[stateValue]];
   }
 
@@ -701,7 +981,7 @@ function pathsToStateValue(paths) {
 function flatten(array) {
   var _a;
 
-  return (_a = []).concat.apply(_a, __spreadArray([], __read(array), false));
+  return (_a = []).concat.apply(_a, _tslib_spreadArray([], _tslib_read(array), false));
 }
 function toArrayStrict(value) {
   if (isArray(value)) {
@@ -720,7 +1000,7 @@ function toArray(value) {
 function mapContext(mapper, context, _event) {
   var e_5, _a;
 
-  if (isFunction(mapper)) {
+  if (utils_isFunction(mapper)) {
     return mapper(context, _event.data);
   }
 
@@ -731,7 +1011,7 @@ function mapContext(mapper, context, _event) {
       var key = _c.value;
       var subMapper = mapper[key];
 
-      if (isFunction(subMapper)) {
+      if (utils_isFunction(subMapper)) {
         result[key] = subMapper(context, _event.data);
       } else {
         result[key] = subMapper;
@@ -760,7 +1040,7 @@ function isPromiseLike(value) {
   } // Check if shape matches the Promise/A+ specification for a "thenable".
 
 
-  if (value !== null && (isFunction(value) || typeof value === 'object') && isFunction(value.then)) {
+  if (value !== null && (utils_isFunction(value) || typeof value === 'object') && utils_isFunction(value.then)) {
     return true;
   }
 
@@ -772,7 +1052,7 @@ function isBehavior(value) {
 function partition(items, predicate) {
   var e_6, _a;
 
-  var _b = __read([[], []], 2),
+  var _b = _tslib_read([[], []], 2),
       truthy = _b[0],
       falsy = _b[1];
 
@@ -806,7 +1086,7 @@ function updateHistoryStates(hist, stateValue) {
       return undefined;
     }
 
-    var subStateValue = (isString(stateValue) ? undefined : stateValue[key]) || (subHist ? subHist.current : undefined);
+    var subStateValue = (utils_isString(stateValue) ? undefined : stateValue[key]) || (subHist ? subHist.current : undefined);
 
     if (!subStateValue) {
       return undefined;
@@ -825,8 +1105,8 @@ function updateHistoryValue(hist, stateValue) {
   };
 }
 function updateContext(context, _event, assignActions, state) {
-  if (!IS_PRODUCTION) {
-    warn(!!context, 'Attempting to update undefined context');
+  if (!environment_IS_PRODUCTION) {
+    utils_warn(!!context, 'Attempting to update undefined context');
   }
 
   var updatedContext = context ? assignActions.reduce(function (acc, assignAction) {
@@ -840,14 +1120,14 @@ function updateContext(context, _event, assignActions, state) {
     };
     var partialUpdate = {};
 
-    if (isFunction(assignment)) {
+    if (utils_isFunction(assignment)) {
       partialUpdate = assignment(acc, _event.data, meta);
     } else {
       try {
         for (var _b = _tslib_values(Object.keys(assignment)), _c = _b.next(); !_c.done; _c = _b.next()) {
           var key = _c.value;
           var propAssignment = assignment[key];
-          partialUpdate[key] = isFunction(propAssignment) ? propAssignment(acc, _event.data, meta) : propAssignment;
+          partialUpdate[key] = utils_isFunction(propAssignment) ? propAssignment(acc, _event.data, meta) : propAssignment;
         }
       } catch (e_7_1) {
         e_7 = {
@@ -867,10 +1147,10 @@ function updateContext(context, _event, assignActions, state) {
   return updatedContext;
 } // tslint:disable-next-line:no-empty
 
-var warn = function () {};
+var utils_warn = function () {};
 
-if (!IS_PRODUCTION) {
-  warn = function (condition, message) {
+if (!environment_IS_PRODUCTION) {
+  utils_warn = function (condition, message) {
     var error = condition instanceof Error ? condition : undefined;
 
     if (!error && condition) {
@@ -893,10 +1173,10 @@ function isArray(value) {
   return Array.isArray(value);
 } // tslint:disable-next-line:ban-types
 
-function isFunction(value) {
+function utils_isFunction(value) {
   return typeof value === 'function';
 }
-function isString(value) {
+function utils_isString(value) {
   return typeof value === 'string';
 }
 function toGuard(condition, guardMap) {
@@ -904,7 +1184,7 @@ function toGuard(condition, guardMap) {
     return undefined;
   }
 
-  if (isString(condition)) {
+  if (utils_isString(condition)) {
     return {
       type: DEFAULT_GUARD_TYPE,
       name: condition,
@@ -912,7 +1192,7 @@ function toGuard(condition, guardMap) {
     };
   }
 
-  if (isFunction(condition)) {
+  if (utils_isFunction(condition)) {
     return {
       type: DEFAULT_GUARD_TYPE,
       name: condition.name,
@@ -924,7 +1204,7 @@ function toGuard(condition, guardMap) {
 }
 function isObservable(value) {
   try {
-    return 'subscribe' in value && isFunction(value.subscribe);
+    return 'subscribe' in value && utils_isFunction(value.subscribe);
   } catch (e) {
     return false;
   }
@@ -938,23 +1218,23 @@ var interopSymbols = (_a = {}, _a[symbolObservable] = function () {
 }, _a[Symbol.observable] = function () {
   return this;
 }, _a);
-function isMachine(value) {
+function utils_isMachine(value) {
   return !!value && '__xstatenode' in value;
 }
 function isActor(value) {
   return !!value && typeof value.send === 'function';
 }
-var uniqueId = /*#__PURE__*/function () {
+var utils_uniqueId = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
   var currentId = 0;
   return function () {
     currentId++;
     return currentId.toString(16);
   };
-}();
+}()));
 function toEventObject(event, payload // id?: TEvent['type']
 ) {
-  if (isString(event) || typeof event === 'number') {
-    return __assign({
+  if (utils_isString(event) || typeof event === 'number') {
+    return _tslib_assign({
       type: event
     }, payload);
   }
@@ -962,12 +1242,12 @@ function toEventObject(event, payload // id?: TEvent['type']
   return event;
 }
 function toSCXMLEvent(event, scxmlEvent) {
-  if (!isString(event) && '$$type' in event && event.$$type === 'scxml') {
+  if (!utils_isString(event) && '$$type' in event && event.$$type === 'scxml') {
     return event;
   }
 
   var eventObject = toEventObject(event);
-  return __assign({
+  return _tslib_assign({
     name: eventObject.type,
     data: eventObject,
     $$type: 'scxml',
@@ -976,14 +1256,14 @@ function toSCXMLEvent(event, scxmlEvent) {
 }
 function toTransitionConfigArray(event, configLike) {
   var transitions = toArrayStrict(configLike).map(function (transitionLike) {
-    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string' || isMachine(transitionLike)) {
+    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string' || utils_isMachine(transitionLike)) {
       return {
         target: transitionLike,
         event: event
       };
     }
 
-    return __assign(__assign({}, transitionLike), {
+    return _tslib_assign(_tslib_assign({}, transitionLike), {
       event: event
     });
   });
@@ -997,7 +1277,7 @@ function normalizeTarget(target) {
   return toArray(target);
 }
 function reportUnhandledExceptionOnInvocation(originalError, currentError, id) {
-  if (!IS_PRODUCTION) {
+  if (!environment_IS_PRODUCTION) {
     var originalStackTrace = originalError.stack ? " Stacktrace was '".concat(originalError.stack, "'") : '';
 
     if (originalError === currentError) {
@@ -1054,7 +1334,7 @@ function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
 function isRaisableAction(action) {
-  return (action.type === raise || action.type === send && action.to === SpecialTargets.Internal) && typeof action.delay !== 'number';
+  return (action.type === raise || action.type === send && action.to === types_SpecialTargets.Internal) && typeof action.delay !== 'number';
 }
 
 
@@ -1077,10 +1357,10 @@ function getActionFunction(actionType, actionFunctionMap) {
 function toActionObject(action, actionFunctionMap) {
   var actionObject;
 
-  if (isString(action) || typeof action === 'number') {
+  if (utils_isString(action) || typeof action === 'number') {
     var exec = getActionFunction(action, actionFunctionMap);
 
-    if (isFunction(exec)) {
+    if (utils_isFunction(exec)) {
       actionObject = {
         type: action,
         exec: exec
@@ -1093,7 +1373,7 @@ function toActionObject(action, actionFunctionMap) {
         exec: undefined
       };
     }
-  } else if (isFunction(action)) {
+  } else if (utils_isFunction(action)) {
     actionObject = {
       // Convert action to string if unnamed
       type: action.name || action.toString(),
@@ -1102,13 +1382,13 @@ function toActionObject(action, actionFunctionMap) {
   } else {
     var exec = getActionFunction(action.type, actionFunctionMap);
 
-    if (isFunction(exec)) {
-      actionObject = __assign(__assign({}, action), {
+    if (utils_isFunction(exec)) {
+      actionObject = _tslib_assign(_tslib_assign({}, action), {
         exec: exec
       });
     } else if (exec) {
       var actionType = exec.type || action.type;
-      actionObject = __assign(__assign(__assign({}, exec), action), {
+      actionObject = _tslib_assign(_tslib_assign(_tslib_assign({}, exec), action), {
         type: actionType
       });
     } else {
@@ -1130,8 +1410,8 @@ var toActionObjects = function (action, actionFunctionMap) {
 };
 function toActivityDefinition(action) {
   var actionObject = toActionObject(action);
-  return __assign(__assign({
-    id: isString(action) ? action : actionObject.id
+  return _tslib_assign(_tslib_assign({
+    id: utils_isString(action) ? action : actionObject.id
   }, actionObject), {
     type: actionObject.type
   });
@@ -1155,17 +1435,17 @@ function resolveRaise(action, ctx, _event, delaysMap) {
   var meta = {
     _event: _event
   };
-  var resolvedEvent = toSCXMLEvent(isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
+  var resolvedEvent = toSCXMLEvent(utils_isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
   var resolvedDelay;
 
-  if (isString(action.delay)) {
+  if (utils_isString(action.delay)) {
     var configDelay = delaysMap && delaysMap[action.delay];
-    resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+    resolvedDelay = utils_isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
   } else {
-    resolvedDelay = isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
+    resolvedDelay = utils_isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
   }
 
-  return __assign(__assign({}, action), {
+  return _tslib_assign(_tslib_assign({}, action), {
     type: raise,
     _event: resolvedEvent,
     delay: resolvedDelay
@@ -1188,11 +1468,11 @@ function actions_send(event, options) {
   return {
     to: options ? options.to : undefined,
     type: send,
-    event: isFunction(event) ? event : toEventObject(event),
+    event: utils_isFunction(event) ? event : toEventObject(event),
     delay: options ? options.delay : undefined,
     // TODO: don't auto-generate IDs here like that
     // there is too big chance of the ID collision
-    id: options && options.id !== undefined ? options.id : isFunction(event) ? event.name : getEventType(event)
+    id: options && options.id !== undefined ? options.id : utils_isFunction(event) ? event.name : getEventType(event)
   };
 }
 function resolveSend(action, ctx, _event, delaysMap) {
@@ -1200,18 +1480,18 @@ function resolveSend(action, ctx, _event, delaysMap) {
     _event: _event
   }; // TODO: helper function for resolving Expr
 
-  var resolvedEvent = toSCXMLEvent(isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
+  var resolvedEvent = toSCXMLEvent(utils_isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
   var resolvedDelay;
 
-  if (isString(action.delay)) {
+  if (utils_isString(action.delay)) {
     var configDelay = delaysMap && delaysMap[action.delay];
-    resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+    resolvedDelay = utils_isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
   } else {
-    resolvedDelay = isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
+    resolvedDelay = utils_isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
   }
 
-  var resolvedTarget = isFunction(action.to) ? action.to(ctx, _event.data, meta) : action.to;
-  return __assign(__assign({}, action), {
+  var resolvedTarget = utils_isFunction(action.to) ? action.to(ctx, _event.data, meta) : action.to;
+  return _tslib_assign(_tslib_assign({}, action), {
     to: resolvedTarget,
     _event: resolvedEvent,
     event: resolvedEvent.data,
@@ -1289,14 +1569,14 @@ function actions_log(expr, label) {
   }
 
   return {
-    type: log,
+    type: log$1,
     label: label,
     expr: expr
   };
 }
 var resolveLog = function (action, ctx, _event) {
-  return __assign(__assign({}, action), {
-    value: isString(action.expr) ? action.expr : action.expr(ctx, _event.data, {
+  return _tslib_assign(_tslib_assign({}, action), {
+    value: utils_isString(action.expr) ? action.expr : action.expr(ctx, _event.data, {
       _event: _event
     })
   });
@@ -1324,7 +1604,7 @@ var actions_cancel = function (sendId) {
 function actions_start(activity) {
   var activityDef = toActivityDefinition(activity);
   return {
-    type: ActionTypes.Start,
+    type: types_ActionTypes.Start,
     activity: activityDef,
     exec: undefined
   };
@@ -1336,20 +1616,20 @@ function actions_start(activity) {
  */
 
 function actions_stop(actorRef) {
-  var activity = isFunction(actorRef) ? actorRef : toActivityDefinition(actorRef);
+  var activity = utils_isFunction(actorRef) ? actorRef : toActivityDefinition(actorRef);
   return {
-    type: ActionTypes.Stop,
+    type: types_ActionTypes.Stop,
     activity: activity,
     exec: undefined
   };
 }
 function resolveStop(action, context, _event) {
-  var actorRefOrString = isFunction(action.activity) ? action.activity(context, _event.data) : action.activity;
+  var actorRefOrString = utils_isFunction(action.activity) ? action.activity(context, _event.data) : action.activity;
   var resolvedActorRef = typeof actorRefOrString === 'string' ? {
     id: actorRefOrString
   } : actorRefOrString;
   var actionObject = {
-    type: ActionTypes.Stop,
+    type: types_ActionTypes.Stop,
     activity: resolvedActorRef
   };
   return actionObject;
@@ -1379,7 +1659,7 @@ function isActionObject(action) {
 
 function actions_after(delayRef, id) {
   var idSuffix = id ? "#".concat(id) : '';
-  return "".concat(ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
+  return "".concat(types_ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
 }
 /**
  * Returns an event that represents that a final state node
@@ -1390,7 +1670,7 @@ function actions_after(delayRef, id) {
  */
 
 function done(id, data) {
-  var type = "".concat(ActionTypes.DoneState, ".").concat(id);
+  var type = "".concat(types_ActionTypes.DoneState, ".").concat(id);
   var eventObject = {
     type: type,
     data: data
@@ -1413,7 +1693,7 @@ function done(id, data) {
  */
 
 function actions_doneInvoke(id, data) {
-  var type = "".concat(ActionTypes.DoneInvoke, ".").concat(id);
+  var type = "".concat(types_ActionTypes.DoneInvoke, ".").concat(id);
   var eventObject = {
     type: type,
     data: data
@@ -1426,7 +1706,7 @@ function actions_doneInvoke(id, data) {
   return eventObject;
 }
 function actions_error(id, data) {
-  var type = "".concat(ActionTypes.ErrorPlatform, ".").concat(id);
+  var type = "".concat(types_ActionTypes.ErrorPlatform, ".").concat(id);
   var eventObject = {
     type: type,
     data: data
@@ -1489,7 +1769,7 @@ function forwardTo(target, options) {
 function escalate(errorData, options) {
   return sendParent(function (context, event, meta) {
     return {
-      type: actionTypes_error,
+      type: error$1,
       data: isFunction(errorData) ? errorData(context, event, meta) : errorData
     };
   }, __assign(__assign({}, options), {
@@ -1566,14 +1846,14 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
       case send:
         var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
 
-        if (!IS_PRODUCTION) {
+        if (!environment_IS_PRODUCTION) {
           var configuredDelay = actionObject.delay; // warn after resolving as we can create better contextual message here
 
-          warn(!isString(configuredDelay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
+          utils_warn(!utils_isString(configuredDelay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
           "No delay reference for delay expression '".concat(configuredDelay, "' was found on machine '").concat(machine.id, "'"));
         }
 
-        if (predictableExec && sendAction.to !== SpecialTargets.Internal) {
+        if (predictableExec && sendAction.to !== types_SpecialTargets.Internal) {
           if (blockType === 'entry') {
             deferredToBlockEnd.push(sendAction);
           } else {
@@ -1602,7 +1882,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
             return [];
           }
 
-          var _b = __read(resolveActions(machine, currentState, updatedContext, _event, [{
+          var _b = _tslib_read(resolveActions(machine, currentState, updatedContext, _event, [{
             type: blockType,
             actions: toActionObjects(toArray(matchedActions), machine.options.actions)
           }], predictableExec, preserveActionOrder), 2),
@@ -1622,7 +1902,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
             return [];
           }
 
-          var _c = __read(resolveActions(machine, currentState, updatedContext, _event, [{
+          var _c = _tslib_read(resolveActions(machine, currentState, updatedContext, _event, [{
             type: blockType,
             actions: toActionObjects(toArray(matchedActions), machine.options.actions)
           }], predictableExec, preserveActionOrder), 2),
@@ -1657,7 +1937,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
         } else if (exec_1 && preservedContexts) {
           var contextIndex_1 = preservedContexts.length - 1;
 
-          var wrapped = __assign(__assign({}, resolvedActionObject), {
+          var wrapped = _tslib_assign(_tslib_assign({}, resolvedActionObject), {
             exec: function (_ctx) {
               var args = [];
 
@@ -1665,7 +1945,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
                 args[_i - 1] = arguments[_i];
               }
 
-              exec_1.apply(void 0, __spreadArray([preservedContexts[contextIndex_1]], __read(args), false));
+              exec_1.apply(void 0, _tslib_spreadArray([preservedContexts[contextIndex_1]], _tslib_read(args), false));
             }
           });
 
@@ -1727,7 +2007,7 @@ var provide = function (service, fn) {
   serviceStack.pop();
   return result;
 };
-var consume = function (fn) {
+var serviceScope_consume = function (fn) {
   return fn(serviceStack[serviceStack.length - 1]);
 };
 
@@ -1778,17 +2058,17 @@ function createInvocableActor(invokeDefinition, machine, context, _event) {
   var invokeSrc = toInvokeSource(invokeDefinition.src);
   var serviceCreator = (_a = machine === null || machine === void 0 ? void 0 : machine.options.services) === null || _a === void 0 ? void 0 : _a[invokeSrc.type];
   var resolvedData = invokeDefinition.data ? mapContext(invokeDefinition.data, context, _event) : undefined;
-  var tempActor = serviceCreator ? createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData) : createNullActor(invokeDefinition.id); // @ts-ignore
+  var tempActor = serviceCreator ? Actor_createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData) : createNullActor(invokeDefinition.id); // @ts-ignore
 
   tempActor.meta = invokeDefinition;
   return tempActor;
 }
-function createDeferredActor(entity, id, data) {
+function Actor_createDeferredActor(entity, id, data) {
   var tempActor = createNullActor(id); // @ts-ignore
 
   tempActor.deferred = true;
 
-  if (isMachine(entity)) {
+  if (utils_isMachine(entity)) {
     // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
     var initialState_1 = tempActor.state = provide(undefined, function () {
       return (data ? entity.withContext(data) : entity).initialState;
@@ -1815,7 +2095,7 @@ function isSpawnedActor(item) {
 function toActorRef(actorRefLike) {
   var _a;
 
-  return __assign((_a = {
+  return _tslib_assign((_a = {
     subscribe: function () {
       return {
         unsubscribe: function () {
@@ -2058,7 +2338,7 @@ function has(iterable, item) {
   return false; // TODO: fix
 }
 function nextEvents(configuration) {
-  return __spreadArray([], __read(new Set(flatten(__spreadArray([], __read(configuration.map(function (sn) {
+  return _tslib_spreadArray([], _tslib_read(new Set(flatten(_tslib_spreadArray([], _tslib_read(configuration.map(function (sn) {
     return sn.ownEvents;
   })), false)))), false);
 }
@@ -2115,7 +2395,7 @@ function stateValuesEqual(a, b) {
     return false;
   }
 
-  if (isString(a) || isString(b)) {
+  if (utils_isString(a) || utils_isString(b)) {
     return a === b;
   }
 
@@ -2140,7 +2420,7 @@ var isState = (/* unused pure expression or super */ null && (isStateConfig));
 function bindActionToState(action, state) {
   var exec = action.exec;
 
-  var boundAction = __assign(__assign({}, action), {
+  var boundAction = _tslib_assign(_tslib_assign({}, action), {
     exec: exec !== undefined ? function () {
       return exec(state.context, state.event, {
         action: action,
@@ -2153,7 +2433,7 @@ function bindActionToState(action, state) {
   return boundAction;
 }
 
-var State =
+var State_State =
 /*#__PURE__*/
 
 /** @class */
@@ -2308,12 +2588,12 @@ function () {
       delimiter = '.';
     }
 
-    if (isString(stateValue)) {
+    if (utils_isString(stateValue)) {
       return [stateValue];
     }
 
     var valueKeys = Object.keys(stateValue);
-    return valueKeys.concat.apply(valueKeys, __spreadArray([], __read(valueKeys.map(function (key) {
+    return valueKeys.concat.apply(valueKeys, _tslib_spreadArray([], _tslib_read(valueKeys.map(function (key) {
       return _this.toStrings(stateValue[key], delimiter).map(function (s) {
         return key + delimiter + s;
       });
@@ -2328,13 +2608,13 @@ function () {
         _a.machine;
         var jsonValues = __rest(_a, ["configuration", "transitions", "tags", "machine"]);
 
-    return __assign(__assign({}, jsonValues), {
+    return _tslib_assign(_tslib_assign({}, jsonValues), {
       tags: Array.from(tags)
     });
   };
 
   State.prototype.matches = function (parentStateValue) {
-    return matchesState(parentStateValue, this.value);
+    return utils_matchesState(parentStateValue, this.value);
   };
   /**
    * Whether the current state configuration has a state node with the specified `tag`.
@@ -2358,8 +2638,8 @@ function () {
   State.prototype.can = function (event) {
     var _a;
 
-    if (IS_PRODUCTION) {
-      warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
+    if (environment_IS_PRODUCTION) {
+      utils_warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
     }
 
     var transitionData = (_a = this.machine) === null || _a === void 0 ? void 0 : _a.getTransitionData(this, event);
@@ -2390,7 +2670,7 @@ function () {
     this.processingEvent = false;
     this.queue = [];
     this.initialized = false;
-    this.options = __assign(__assign({}, defaultOptions), options);
+    this.options = _tslib_assign(_tslib_assign({}, defaultOptions), options);
   }
 
   Scheduler.prototype.initialize = function (callback) {
@@ -2496,7 +2776,7 @@ function getGlobal() {
     return __webpack_require__.g;
   }
 
-  if (!IS_PRODUCTION) {
+  if (!environment_IS_PRODUCTION) {
     console.warn('XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues');
   }
 }
@@ -2746,8 +3026,8 @@ function () {
 
       if (_this.status === InterpreterStatus.Stopped) {
         // do nothing
-        if (!IS_PRODUCTION) {
-          warn(false, "Event \"".concat(_event.name, "\" was sent to stopped service \"").concat(_this.machine.id, "\". This service has already reached its final state, and will not transition.\nEvent: ").concat(JSON.stringify(_event.data)));
+        if (!environment_IS_PRODUCTION) {
+          utils_warn(false, "Event \"".concat(_event.name, "\" was sent to stopped service \"").concat(_this.machine.id, "\". This service has already reached its final state, and will not transition.\nEvent: ").concat(JSON.stringify(_event.data)));
         }
 
         return _this.state;
@@ -2772,8 +3052,8 @@ function () {
     };
 
     this.sendTo = function (event, to, immediate) {
-      var isParent = _this.parent && (to === SpecialTargets.Parent || _this.parent.id === to);
-      var target = isParent ? _this.parent : isString(to) ? to === SpecialTargets.Internal ? _this : _this.children.get(to) || registry.get(to) : isActor(to) ? to : undefined;
+      var isParent = _this.parent && (to === types_SpecialTargets.Parent || _this.parent.id === to);
+      var target = isParent ? _this.parent : utils_isString(to) ? to === types_SpecialTargets.Internal ? _this : _this.children.get(to) || registry.get(to) : isActor(to) ? to : undefined;
 
       if (!target) {
         if (!isParent) {
@@ -2781,8 +3061,8 @@ function () {
         } // tslint:disable-next-line:no-console
 
 
-        if (!IS_PRODUCTION) {
-          warn(false, "Service '".concat(_this.id, "' has no parent: unable to send event ").concat(event.type));
+        if (!environment_IS_PRODUCTION) {
+          utils_warn(false, "Service '".concat(_this.id, "' has no parent: unable to send event ").concat(event.type));
         }
 
         return;
@@ -2794,7 +3074,7 @@ function () {
         if (_this.status !== InterpreterStatus.Stopped || _this.parent !== target || // we need to send events to the parent from exit handlers of a machine that reached its final state
         _this.state.done) {
           // Send SCXML events to machines
-          var scxmlEvent = __assign(__assign({}, event), {
+          var scxmlEvent = _tslib_assign(_tslib_assign({}, event), {
             name: event.name === actionTypes_error ? "".concat(actions_error(_this.id)) : event.name,
             origin: _this.sessionId
           });
@@ -2821,7 +3101,7 @@ function () {
       }
 
       var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
-      var exec = isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
+      var exec = utils_isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
 
       if (exec) {
         try {
@@ -2894,14 +3174,14 @@ function () {
             } // Invoked services
 
 
-            if (activity.type === ActionTypes.Invoke) {
+            if (activity.type === types_ActionTypes.Invoke) {
               var invokeSource = toInvokeSource(activity.src);
               var serviceCreator = _this.machine.options.services ? _this.machine.options.services[invokeSource.type] : undefined;
               var id = activity.id,
                   data = activity.data;
 
-              if (!IS_PRODUCTION) {
-                warn(!('forward' in activity), // tslint:disable-next-line:max-line-length
+              if (!environment_IS_PRODUCTION) {
+                utils_warn(!('forward' in activity), // tslint:disable-next-line:max-line-length
                 "`forward` property is deprecated (found in invocation of '".concat(activity.src, "' in in machine '").concat(_this.machine.id, "'). ") + "Please use `autoForward` instead.");
               }
 
@@ -2909,8 +3189,8 @@ function () {
 
               if (!serviceCreator) {
                 // tslint:disable-next-line:no-console
-                if (!IS_PRODUCTION) {
-                  warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(_this.machine.id, "'."));
+                if (!environment_IS_PRODUCTION) {
+                  utils_warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(_this.machine.id, "'."));
                 }
 
                 return;
@@ -2923,7 +3203,7 @@ function () {
                 return;
               }
 
-              var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
+              var source = utils_isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
                 data: resolvedData,
                 src: invokeSource,
                 meta: activity.meta
@@ -2936,7 +3216,7 @@ function () {
 
               var options = void 0;
 
-              if (isMachine(source)) {
+              if (utils_isMachine(source)) {
                 source = resolvedData ? source.withContext(resolvedData) : source;
                 options = {
                   autoForward: autoForward
@@ -2972,15 +3252,15 @@ function () {
           break;
 
         default:
-          if (!IS_PRODUCTION) {
-            warn(false, "No implementation found for action type '".concat(action.type, "'"));
+          if (!environment_IS_PRODUCTION) {
+            utils_warn(false, "No implementation found for action type '".concat(action.type, "'"));
           }
 
           break;
       }
     };
 
-    var resolvedOptions = __assign(__assign({}, Interpreter.defaultOptions), options);
+    var resolvedOptions = _tslib_assign(_tslib_assign({}, Interpreter.defaultOptions), options);
 
     var clock = resolvedOptions.clock,
         logger = resolvedOptions.logger,
@@ -3019,8 +3299,8 @@ function () {
      * @deprecated Use `.getSnapshot()` instead.
      */
     get: function () {
-      if (!IS_PRODUCTION) {
-        warn(this.status !== InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
+      if (!environment_IS_PRODUCTION) {
+        utils_warn(this.status !== InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
       }
 
       return this._state;
@@ -3321,7 +3601,7 @@ function () {
     this.initialized = true;
     this.status = InterpreterStatus.Running;
     var resolvedState = initialState === undefined ? this.initialState : provide(this, function () {
-      return isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.from(initialState, _this.machine.context));
+      return isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State_State.from(initialState, _this.machine.context));
     });
 
     if (this.options.devTools) {
@@ -3337,7 +3617,7 @@ function () {
   Interpreter.prototype._stopChildren = function () {
     // TODO: think about converting those to actions
     this.children.forEach(function (child) {
-      if (isFunction(child.stop)) {
+      if (utils_isFunction(child.stop)) {
         child.stop();
       }
     });
@@ -3475,20 +3755,20 @@ function () {
       });
 
       var nextState = provide(_this, function () {
-        var exitActions = flatten(__spreadArray([], __read(_this.state.configuration), false).sort(function (a, b) {
+        var exitActions = flatten(_tslib_spreadArray([], _tslib_read(_this.state.configuration), false).sort(function (a, b) {
           return b.order - a.order;
         }).map(function (stateNode) {
           return toActionObjects(stateNode.onExit, _this.machine.options.actions);
         }));
 
-        var _a = __read(resolveActions(_this.machine, _this.state, _this.state.context, _event, [{
+        var _a = _tslib_read(resolveActions(_this.machine, _this.state, _this.state.context, _event, [{
           type: 'exit',
           actions: exitActions
         }], _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
             resolvedActions = _a[0],
             updatedContext = _a[1];
 
-        var newState = new State({
+        var newState = new State_State({
           value: _this.state.value,
           context: updatedContext,
           _event: _event,
@@ -3525,8 +3805,8 @@ function () {
 
     if (this.status === InterpreterStatus.NotStarted && this.options.deferEvents) {
       // tslint:disable-next-line:no-console
-      if (!IS_PRODUCTION) {
-        warn(false, "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\" and are deferred. Make sure .start() is called for this service.\nEvent: ").concat(JSON.stringify(event)));
+      if (!environment_IS_PRODUCTION) {
+        utils_warn(false, "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\" and are deferred. Make sure .start() is called for this service.\nEvent: ").concat(JSON.stringify(event)));
       }
     } else if (this.status !== InterpreterStatus.Running) {
       throw new Error( // tslint:disable-next-line:max-line-length
@@ -3553,7 +3833,7 @@ function () {
         nextState = provide(_this, function () {
           return _this.machine.transition(nextState, _event, undefined, exec || undefined);
         });
-        batchedActions.push.apply(batchedActions, __spreadArray([], __read(_this.machine.config.predictableActionArguments ? nextState.actions : nextState.actions.map(function (a) {
+        batchedActions.push.apply(batchedActions, _tslib_spreadArray([], _tslib_read(_this.machine.config.predictableActionArguments ? nextState.actions : nextState.actions.map(function (a) {
           return bindActionToState(a, nextState);
         })), false));
         batchChanged = batchChanged || !!nextState.changed;
@@ -3702,26 +3982,26 @@ function () {
 
     this.removeChild(childId);
 
-    if (isFunction(child.stop)) {
+    if (utils_isFunction(child.stop)) {
       child.stop();
     }
   };
 
   Interpreter.prototype.spawn = function (entity, name, options) {
     if (this.status !== InterpreterStatus.Running) {
-      return createDeferredActor(entity, name);
+      return Actor_createDeferredActor(entity, name);
     }
 
     if (isPromiseLike(entity)) {
       return this.spawnPromise(Promise.resolve(entity), name);
-    } else if (isFunction(entity)) {
+    } else if (utils_isFunction(entity)) {
       return this.spawnCallback(entity, name);
     } else if (isSpawnedActor(entity)) {
       return this.spawnActor(entity, name);
     } else if (isObservable(entity)) {
       return this.spawnObservable(entity, name);
-    } else if (isMachine(entity)) {
-      return this.spawnMachine(entity, __assign(__assign({}, options), {
+    } else if (utils_isMachine(entity)) {
+      return this.spawnMachine(entity, _tslib_assign(_tslib_assign({}, options), {
         id: name
       }));
     } else if (isBehavior(entity)) {
@@ -3738,16 +4018,16 @@ function () {
       options = {};
     }
 
-    var childService = new Interpreter(machine, __assign(__assign({}, this.options), {
+    var childService = new Interpreter(machine, _tslib_assign(_tslib_assign({}, this.options), {
       parent: this,
       id: options.id || machine.id
     }));
 
-    var resolvedOptions = __assign(__assign({}, DEFAULT_SPAWN_OPTIONS), options);
+    var resolvedOptions = _tslib_assign(_tslib_assign({}, DEFAULT_SPAWN_OPTIONS), options);
 
     if (resolvedOptions.sync) {
       childService.onTransition(function (state) {
-        _this.send(update, {
+        _this.send(actionTypes_update, {
           state: state,
           id: childService.id
         });
@@ -3936,7 +4216,7 @@ function () {
       stop: function () {
         canceled = true;
 
-        if (isFunction(callbackStop)) {
+        if (utils_isFunction(callbackStop)) {
           callbackStop();
         }
       },
@@ -4015,8 +4295,8 @@ function () {
     var implementation = this.machine.options && this.machine.options.activities ? this.machine.options.activities[activity.type] : undefined;
 
     if (!implementation) {
-      if (!IS_PRODUCTION) {
-        warn(false, "No implementation found for activity '".concat(activity.type, "'"));
+      if (!environment_IS_PRODUCTION) {
+        utils_warn(false, "No implementation found for activity '".concat(activity.type, "'"));
       } // tslint:disable-next-line:no-console
 
 
@@ -4063,7 +4343,7 @@ function () {
     if (this.options.devTools && global) {
       if (global.__REDUX_DEVTOOLS_EXTENSION__) {
         var devToolsOptions = typeof this.options.devTools === 'object' ? this.options.devTools : undefined;
-        this.devTools = global.__REDUX_DEVTOOLS_EXTENSION__.connect(__assign(__assign({
+        this.devTools = global.__REDUX_DEVTOOLS_EXTENSION__.connect(_tslib_assign(_tslib_assign({
           name: this.id,
           autoPause: true,
           stateSanitizer: function (state) {
@@ -4074,7 +4354,7 @@ function () {
             };
           }
         }, devToolsOptions), {
-          features: __assign({
+          features: _tslib_assign({
             jump: false,
             skip: false
           }, devToolsOptions ? devToolsOptions.features : undefined)
@@ -4195,7 +4475,7 @@ function invokeUtils_toInvokeSource(src) {
   return src;
 }
 function toInvokeDefinition(invokeConfig) {
-  return __assign(__assign({
+  return _tslib_assign(_tslib_assign({
     type: invoke
   }, invokeConfig), {
     toJSON: function () {
@@ -4203,7 +4483,7 @@ function toInvokeDefinition(invokeConfig) {
           invokeConfig.onError;
           var invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
 
-      return __assign(__assign({}, invokeDef), {
+      return _tslib_assign(_tslib_assign({}, invokeDef), {
         type: invoke,
         src: invokeUtils_toInvokeSource(invokeConfig.src)
       });
@@ -4246,13 +4526,13 @@ var createDefaultOptions = function () {
 
 var validateArrayifiedTransitions = function (stateNode, event, transitions) {
   var hasNonLastUnguardedTarget = transitions.slice(0, -1).some(function (transition) {
-    return !('cond' in transition) && !('in' in transition) && (isString(transition.target) || isMachine(transition.target));
+    return !('cond' in transition) && !('in' in transition) && (utils_isString(transition.target) || utils_isMachine(transition.target));
   });
   var eventText = event === NULL_EVENT ? 'the transient event' : "event '".concat(event, "'");
-  warn(!hasNonLastUnguardedTarget, "One or more transitions for ".concat(eventText, " on state '").concat(stateNode.id, "' are unreachable. ") + "Make sure that the default transition is the last one defined.");
+  utils_warn(!hasNonLastUnguardedTarget, "One or more transitions for ".concat(eventText, " on state '").concat(stateNode.id, "' are unreachable. ") + "Make sure that the default transition is the last one defined.");
 };
 
-var StateNode =
+var StateNode_StateNode =
 /*#__PURE__*/
 
 /** @class */
@@ -4301,14 +4581,14 @@ function () {
     this.machine = this.parent ? this.parent.machine : this;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
     this.delimiter = this.config.delimiter || (this.parent ? this.parent.delimiter : STATE_DELIMITER);
-    this.id = this.config.id || __spreadArray([this.machine.key], __read(this.path), false).join(this.delimiter);
+    this.id = this.config.id || _tslib_spreadArray([this.machine.key], _tslib_read(this.path), false).join(this.delimiter);
     this.version = this.parent ? this.parent.version : this.config.version;
     this.type = this.config.type || (this.config.parallel ? 'parallel' : this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.schema = this.parent ? this.machine.schema : (_a = this.config.schema) !== null && _a !== void 0 ? _a : {};
     this.description = this.config.description;
 
-    if (!IS_PRODUCTION) {
-      warn(!('parallel' in this.config), "The \"parallel\" property is deprecated and will be removed in version 4.1. ".concat(this.config.parallel ? "Replace with `type: 'parallel'`" : "Use `type: '".concat(this.type, "'`"), " in the config for state node '").concat(this.id, "' instead."));
+    if (!environment_IS_PRODUCTION) {
+      utils_warn(!('parallel' in this.config), "The \"parallel\" property is deprecated and will be removed in version 4.1. ".concat(this.config.parallel ? "Replace with `type: 'parallel'`" : "Use `type: '".concat(this.type, "'`"), " in the config for state node '").concat(this.id, "' instead."));
     }
 
     this.initial = this.config.initial;
@@ -4319,7 +4599,7 @@ function () {
         parent: _this,
         key: key
       });
-      Object.assign(_this.idMap, __assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
+      Object.assign(_this.idMap, _tslib_assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
       return stateNode;
     }) : EMPTY_OBJECT; // Document order
 
@@ -4369,30 +4649,30 @@ function () {
     this.invoke = toArray(this.config.invoke).map(function (invokeConfig, i) {
       var _a, _b;
 
-      if (isMachine(invokeConfig)) {
+      if (utils_isMachine(invokeConfig)) {
         var invokeId = createInvokeId(_this.id, i);
-        _this.machine.options.services = __assign((_a = {}, _a[invokeId] = invokeConfig, _a), _this.machine.options.services);
+        _this.machine.options.services = _tslib_assign((_a = {}, _a[invokeId] = invokeConfig, _a), _this.machine.options.services);
         return toInvokeDefinition({
           src: invokeId,
           id: invokeId
         });
-      } else if (isString(invokeConfig.src)) {
+      } else if (utils_isString(invokeConfig.src)) {
         var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
-        return toInvokeDefinition(__assign(__assign({}, invokeConfig), {
+        return toInvokeDefinition(_tslib_assign(_tslib_assign({}, invokeConfig), {
           id: invokeId,
           src: invokeConfig.src
         }));
-      } else if (isMachine(invokeConfig.src) || isFunction(invokeConfig.src)) {
+      } else if (utils_isMachine(invokeConfig.src) || utils_isFunction(invokeConfig.src)) {
         var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
-        _this.machine.options.services = __assign((_b = {}, _b[invokeId] = invokeConfig.src, _b), _this.machine.options.services);
-        return toInvokeDefinition(__assign(__assign({
+        _this.machine.options.services = _tslib_assign((_b = {}, _b[invokeId] = invokeConfig.src, _b), _this.machine.options.services);
+        return toInvokeDefinition(_tslib_assign(_tslib_assign({
           id: invokeId
         }, invokeConfig), {
           src: invokeId
         }));
       } else {
         var invokeSource = invokeConfig.src;
-        return toInvokeDefinition(__assign(__assign({
+        return toInvokeDefinition(_tslib_assign(_tslib_assign({
           id: createInvokeId(_this.id, i)
         }, invokeConfig), {
           src: invokeSource
@@ -4435,11 +4715,11 @@ function () {
         services = _a.services,
         delays = _a.delays;
     return new StateNode(this.config, {
-      actions: __assign(__assign({}, actions), options.actions),
-      activities: __assign(__assign({}, activities), options.activities),
-      guards: __assign(__assign({}, guards), options.guards),
-      services: __assign(__assign({}, services), options.services),
-      delays: __assign(__assign({}, delays), options.delays)
+      actions: _tslib_assign(_tslib_assign({}, actions), options.actions),
+      activities: _tslib_assign(_tslib_assign({}, activities), options.activities),
+      guards: _tslib_assign(_tslib_assign({}, guards), options.guards),
+      services: _tslib_assign(_tslib_assign({}, services), options.services),
+      delays: _tslib_assign(_tslib_assign({}, delays), options.delays)
     }, context !== null && context !== void 0 ? context : this.context);
   };
   /**
@@ -4455,7 +4735,7 @@ function () {
 
   Object.defineProperty(StateNode.prototype, "context", {
     get: function () {
-      return isFunction(this._context) ? this._context() : this._context;
+      return utils_isFunction(this._context) ? this._context() : this._context;
     },
     enumerable: false,
     configurable: true
@@ -4563,7 +4843,7 @@ function () {
     }
 
     var mutateEntryExit = function (delay, i) {
-      var delayRef = isFunction(delay) ? "".concat(_this.id, ":delay[").concat(i, "]") : delay;
+      var delayRef = utils_isFunction(delay) ? "".concat(_this.id, ":delay[").concat(i, "]") : delay;
       var eventType = actions_after(delayRef, _this.id);
 
       _this.onEntry.push(actions_send(eventType, {
@@ -4577,18 +4857,18 @@ function () {
 
     var delayedTransitions = isArray(afterConfig) ? afterConfig.map(function (transition, i) {
       var eventType = mutateEntryExit(transition.delay, i);
-      return __assign(__assign({}, transition), {
+      return _tslib_assign(_tslib_assign({}, transition), {
         event: eventType
       });
     }) : flatten(Object.keys(afterConfig).map(function (delay, i) {
       var configTransition = afterConfig[delay];
-      var resolvedTransition = isString(configTransition) ? {
+      var resolvedTransition = utils_isString(configTransition) ? {
         target: configTransition
       } : configTransition;
       var resolvedDelay = !isNaN(+delay) ? +delay : delay;
       var eventType = mutateEntryExit(resolvedDelay, i);
       return toArray(resolvedTransition).map(function (transition) {
-        return __assign(__assign({}, transition), {
+        return _tslib_assign(_tslib_assign({}, transition), {
           event: eventType,
           delay: resolvedDelay
         });
@@ -4596,7 +4876,7 @@ function () {
     }));
     return delayedTransitions.map(function (delayedTransition) {
       var delay = delayedTransition.delay;
-      return __assign(__assign({}, _this.formatTransition(delayedTransition)), {
+      return _tslib_assign(_tslib_assign({}, _this.formatTransition(delayedTransition)), {
         delay: delay
       });
     });
@@ -4617,16 +4897,16 @@ function () {
       return [];
     }
 
-    var stateValue = state instanceof State ? state.value : toStateValue(state, this.delimiter);
+    var stateValue = state instanceof State_State ? state.value : toStateValue(state, this.delimiter);
 
-    if (isString(stateValue)) {
+    if (utils_isString(stateValue)) {
       var initialStateValue = this.getStateNode(stateValue).initial;
       return initialStateValue !== undefined ? this.getStateNodes((_a = {}, _a[stateValue] = initialStateValue, _a)) : [this, this.states[stateValue]];
     }
 
     var subStateKeys = Object.keys(stateValue);
     var subStateNodes = [this];
-    subStateNodes.push.apply(subStateNodes, __spreadArray([], __read(flatten(subStateKeys.map(function (subStateKey) {
+    subStateNodes.push.apply(subStateNodes, _tslib_spreadArray([], _tslib_read(flatten(subStateKeys.map(function (subStateKey) {
       return _this.getStateNode(subStateKey).getStateNodes(stateValue[subStateKey]);
     }))), false));
     return subStateNodes;
@@ -4652,9 +4932,9 @@ function () {
 
 
   StateNode.prototype.resolveState = function (state) {
-    var stateFromConfig = state instanceof State ? state : State.create(state);
+    var stateFromConfig = state instanceof State_State ? state : State_State.create(state);
     var configuration = Array.from(getConfiguration([], this.getStateNodes(stateFromConfig.value)));
-    return new State(__assign(__assign({}, stateFromConfig), {
+    return new State_State(_tslib_assign(_tslib_assign({}, stateFromConfig), {
       value: this.resolve(stateFromConfig.value),
       configuration: configuration,
       done: isInFinalState(configuration, this),
@@ -4753,7 +5033,7 @@ function () {
 
   StateNode.prototype._transition = function (stateValue, state, _event) {
     // leaf node
-    if (isString(stateValue)) {
+    if (utils_isString(stateValue)) {
       return this.transitionLeafNode(stateValue, state, _event);
     } // hierarchical node
 
@@ -4786,9 +5066,9 @@ function () {
         var cond = candidate.cond,
             stateIn = candidate.in;
         var resolvedContext = state.context;
-        var isInState = stateIn ? isString(stateIn) && isStateId(stateIn) ? // Check if in state by ID
+        var isInState = stateIn ? utils_isString(stateIn) && isStateId(stateIn) ? // Check if in state by ID
         state.matches(toStateValue(this.getStateNodeById(stateIn).path, this.delimiter)) : // Check if in state by relative grandparent
-        matchesState(toStateValue(stateIn, this.delimiter), path(this.path.slice(0, -2))(state.value)) : true;
+        utils_matchesState(toStateValue(stateIn, this.delimiter), path(this.path.slice(0, -2))(state.value)) : true;
         var guardPassed = false;
 
         try {
@@ -4802,7 +5082,7 @@ function () {
             nextStateNodes = candidate.target;
           }
 
-          actions.push.apply(actions, __spreadArray([], __read(candidate.actions), false));
+          actions.push.apply(actions, _tslib_spreadArray([], _tslib_read(candidate.actions), false));
           selectedTransition = candidate;
           break;
         }
@@ -4966,7 +5246,7 @@ function () {
       });
       return {
         type: 'entry',
-        actions: toActionObjects(predictableExec ? __spreadArray(__spreadArray([], __read(entryActions), false), __read(invokeActions), false) : __spreadArray(__spreadArray([], __read(invokeActions), false), __read(entryActions), false), _this.machine.options.actions)
+        actions: toActionObjects(predictableExec ? _tslib_spreadArray(_tslib_spreadArray([], _tslib_read(entryActions), false), _tslib_read(invokeActions), false) : _tslib_spreadArray(_tslib_spreadArray([], _tslib_read(invokeActions), false), _tslib_read(entryActions), false), _this.machine.options.actions)
       };
     }).concat({
       type: 'state_done',
@@ -4977,7 +5257,7 @@ function () {
     var exitActions = Array.from(exitStates).map(function (stateNode) {
       return {
         type: 'exit',
-        actions: toActionObjects(__spreadArray(__spreadArray([], __read(stateNode.onExit), false), __read(stateNode.activities.map(function (activity) {
+        actions: toActionObjects(_tslib_spreadArray(_tslib_spreadArray([], _tslib_read(stateNode.onExit), false), _tslib_read(stateNode.activities.map(function (activity) {
           return actions_stop(activity);
         })), false), _this.machine.options.actions)
       };
@@ -4988,7 +5268,7 @@ function () {
     }).concat(entryActions);
 
     if (isDone) {
-      var stopActions = toActionObjects(flatten(__spreadArray([], __read(resolvedConfig), false).sort(function (a, b) {
+      var stopActions = toActionObjects(flatten(_tslib_spreadArray([], _tslib_read(resolvedConfig), false).sort(function (a, b) {
         return b.order - a.order;
       }).map(function (stateNode) {
         return stateNode.onExit;
@@ -5021,15 +5301,15 @@ function () {
 
     var currentState;
 
-    if (state instanceof State) {
-      currentState = context === undefined ? state : this.resolveState(State.from(state, context));
+    if (state instanceof State_State) {
+      currentState = context === undefined ? state : this.resolveState(State_State.from(state, context));
     } else {
-      var resolvedStateValue = isString(state) ? this.resolve(pathToStateValue(this.getResolvedPath(state))) : this.resolve(state);
+      var resolvedStateValue = utils_isString(state) ? this.resolve(pathToStateValue(this.getResolvedPath(state))) : this.resolve(state);
       var resolvedContext = context !== null && context !== void 0 ? context : this.machine.context;
-      currentState = this.resolveState(State.from(resolvedStateValue, resolvedContext));
+      currentState = this.resolveState(State_State.from(resolvedStateValue, resolvedContext));
     }
 
-    if (!IS_PRODUCTION && _event.name === WILDCARD) {
+    if (!environment_IS_PRODUCTION && _event.name === WILDCARD) {
       throw new Error("An event cannot have the wildcard type ('".concat(WILDCARD, "')"));
     }
 
@@ -5048,7 +5328,7 @@ function () {
     };
     var prevConfig = getConfiguration([], this.getStateNodes(currentState.value));
     var resolvedConfig = stateTransition.configuration.length ? getConfiguration(prevConfig, stateTransition.configuration) : prevConfig;
-    stateTransition.configuration = __spreadArray([], __read(resolvedConfig), false);
+    stateTransition.configuration = _tslib_spreadArray([], _tslib_read(resolvedConfig), false);
     return this.resolveTransition(stateTransition, currentState, currentState.context, exec, _event);
   };
 
@@ -5062,7 +5342,7 @@ function () {
     state._event = originalEvent;
     state.event = originalEvent.data;
 
-    (_a = state.actions).unshift.apply(_a, __spreadArray([], __read(currentActions), false));
+    (_a = state.actions).unshift.apply(_a, _tslib_spreadArray([], _tslib_read(currentActions), false));
 
     return state;
   };
@@ -5086,7 +5366,7 @@ function () {
     var resolvedStateValue = willTransition ? getValue(this.machine, configuration) : undefined;
     var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : undefined : undefined;
     var actionBlocks = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState, predictableExec);
-    var activities = currentState ? __assign({}, currentState.activities) : {};
+    var activities = currentState ? _tslib_assign({}, currentState.activities) : {};
 
     try {
       for (var actionBlocks_1 = _tslib_values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
@@ -5126,11 +5406,11 @@ function () {
       }
     }
 
-    var _e = __read(resolveActions(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
+    var _e = _tslib_read(resolveActions(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
         resolvedActions = _e[0],
         updatedContext = _e[1];
 
-    var _f = __read(partition(resolvedActions, isRaisableAction), 2),
+    var _f = _tslib_read(partition(resolvedActions, isRaisableAction), 2),
         raisedEvents = _f[0],
         nonRaisedActions = _f[1];
 
@@ -5142,8 +5422,8 @@ function () {
     var children = invokeActions.reduce(function (acc, action) {
       acc[action.activity.id] = createInvocableActor(action.activity, _this.machine, updatedContext, _event);
       return acc;
-    }, currentState ? __assign({}, currentState.children) : {});
-    var nextState = new State({
+    }, currentState ? _tslib_assign({}, currentState.children) : {});
+    var nextState = new State_State({
       value: resolvedStateValue || currentState.value,
       context: updatedContext,
       _event: _event,
@@ -5162,7 +5442,7 @@ function () {
       machine: this
     });
     var didUpdateContext = context !== updatedContext;
-    nextState.changed = _event.name === update || didUpdateContext; // Dispose of penultimate histories to prevent memory leaks
+    nextState.changed = _event.name === actionTypes_update || didUpdateContext; // Dispose of penultimate histories to prevent memory leaks
 
     var history = nextState.history;
 
@@ -5307,7 +5587,7 @@ function () {
         });
 
       case 'compound':
-        if (isString(stateValue)) {
+        if (utils_isString(stateValue)) {
           var subStateNode = this.getStateNode(stateValue);
 
           if (subStateNode.type === 'parallel' || subStateNode.type === 'compound') {
@@ -5420,7 +5700,7 @@ function () {
       if (this.type === 'history') {
         var historyConfig = this.config;
 
-        if (isString(historyConfig.target)) {
+        if (utils_isString(historyConfig.target)) {
           target = isStateId(historyConfig.target) ? pathToStateValue(this.machine.getStateNodeById(historyConfig.target).path.slice(this.path.length - 1)) : historyConfig.target;
         } else {
           target = historyConfig.target;
@@ -5458,8 +5738,8 @@ function () {
 
 
       if (this.type === 'compound' && !this.initial) {
-        if (!IS_PRODUCTION) {
-          warn(false, "Compound state node '".concat(this.id, "' has no initial state."));
+        if (!environment_IS_PRODUCTION) {
+          utils_warn(false, "Compound state node '".concat(this.id, "' has no initial state."));
         }
 
         return [this];
@@ -5485,7 +5765,7 @@ function () {
       return [this];
     }
 
-    var _a = __read(relativePath),
+    var _a = _tslib_read(relativePath),
         stateKey = _a[0],
         childStatePath = _a.slice(1);
 
@@ -5518,7 +5798,7 @@ function () {
           return stateNode.historyValue();
         }
 
-        var subStateValue = isString(relativeStateValue) ? undefined : relativeStateValue[key];
+        var subStateValue = utils_isString(relativeStateValue) ? undefined : relativeStateValue[key];
         return stateNode.historyValue(subStateValue || stateNode.initialStateValue);
       }, function (stateNode) {
         return !stateNode.history;
@@ -5551,7 +5831,7 @@ function () {
 
     var subHistoryValue = nestedPath(parent.path, 'states')(historyValue).current;
 
-    if (isString(subHistoryValue)) {
+    if (utils_isString(subHistoryValue)) {
       return [parent.getStateNode(subHistoryValue)];
     }
 
@@ -5659,7 +5939,7 @@ function () {
     }
 
     return _target.map(function (target) {
-      if (!isString(target)) {
+      if (!utils_isString(target)) {
         return target;
       }
 
@@ -5691,12 +5971,12 @@ function () {
 
     var normalizedTarget = normalizeTarget(transitionConfig.target);
     var internal = 'internal' in transitionConfig ? transitionConfig.internal : normalizedTarget ? normalizedTarget.some(function (_target) {
-      return isString(_target) && _target[0] === _this.delimiter;
+      return utils_isString(_target) && _target[0] === _this.delimiter;
     }) : true;
     var guards = this.machine.options.guards;
     var target = this.resolveTarget(normalizedTarget);
 
-    var transition = __assign(__assign({}, transitionConfig), {
+    var transition = _tslib_assign(_tslib_assign({}, transitionConfig), {
       actions: toActionObjects(toArray(transitionConfig.actions)),
       cond: toGuard(transitionConfig.cond, guards),
       target: target,
@@ -5704,7 +5984,7 @@ function () {
       internal: internal,
       eventType: transitionConfig.event,
       toJSON: function () {
-        return __assign(__assign({}, transition), {
+        return _tslib_assign(_tslib_assign({}, transition), {
           target: transition.target ? transition.target.map(function (t) {
             return "#".concat(t.id);
           }) : undefined,
@@ -5735,13 +6015,13 @@ function () {
           strictTransitionConfigs_1 = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
 
       onConfig = flatten(Object.keys(strictTransitionConfigs_1).map(function (key) {
-        if (!IS_PRODUCTION && key === NULL_EVENT) {
-          warn(false, "Empty string transition configs (e.g., `{ on: { '': ... }}`) for transient transitions are deprecated. Specify the transition in the `{ always: ... }` property instead. " + "Please check the `on` configuration for \"#".concat(_this.id, "\"."));
+        if (!environment_IS_PRODUCTION && key === NULL_EVENT) {
+          utils_warn(false, "Empty string transition configs (e.g., `{ on: { '': ... }}`) for transient transitions are deprecated. Specify the transition in the `{ always: ... }` property instead. " + "Please check the `on` configuration for \"#".concat(_this.id, "\"."));
         }
 
         var transitionConfigArray = toTransitionConfigArray(key, strictTransitionConfigs_1[key]);
 
-        if (!IS_PRODUCTION) {
+        if (!environment_IS_PRODUCTION) {
           validateArrayifiedTransitions(_this, key, transitionConfigArray);
         }
 
@@ -5752,25 +6032,25 @@ function () {
     var eventlessConfig = this.config.always ? toTransitionConfigArray('', this.config.always) : [];
     var doneConfig = this.config.onDone ? toTransitionConfigArray(String(done(this.id)), this.config.onDone) : [];
 
-    if (!IS_PRODUCTION) {
-      warn(!(this.config.onDone && !this.parent), "Root nodes cannot have an \".onDone\" transition. Please check the config of \"".concat(this.id, "\"."));
+    if (!environment_IS_PRODUCTION) {
+      utils_warn(!(this.config.onDone && !this.parent), "Root nodes cannot have an \".onDone\" transition. Please check the config of \"".concat(this.id, "\"."));
     }
 
     var invokeConfig = flatten(this.invoke.map(function (invokeDef) {
       var settleTransitions = [];
 
       if (invokeDef.onDone) {
-        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(actions_doneInvoke(invokeDef.id)), invokeDef.onDone)), false));
+        settleTransitions.push.apply(settleTransitions, _tslib_spreadArray([], _tslib_read(toTransitionConfigArray(String(actions_doneInvoke(invokeDef.id)), invokeDef.onDone)), false));
       }
 
       if (invokeDef.onError) {
-        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(actions_error(invokeDef.id)), invokeDef.onError)), false));
+        settleTransitions.push.apply(settleTransitions, _tslib_spreadArray([], _tslib_read(toTransitionConfigArray(String(actions_error(invokeDef.id)), invokeDef.onError)), false));
       }
 
       return settleTransitions;
     }));
     var delayedTransitions = this.after;
-    var formattedTransitions = flatten(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(doneConfig), false), __read(invokeConfig), false), __read(onConfig), false), __read(eventlessConfig), false).map(function (transitionConfig) {
+    var formattedTransitions = flatten(_tslib_spreadArray(_tslib_spreadArray(_tslib_spreadArray(_tslib_spreadArray([], _tslib_read(doneConfig), false), _tslib_read(invokeConfig), false), _tslib_read(onConfig), false), _tslib_read(eventlessConfig), false).map(function (transitionConfig) {
       return toArray(transitionConfig).map(function (transition) {
         return _this.formatTransition(transition);
       });
@@ -5811,7 +6091,7 @@ function Machine(config, options, initialContext) {
     initialContext = config.context;
   }
 
-  return new StateNode(config, options, initialContext);
+  return new StateNode_StateNode(config, options, initialContext);
 }
 function createMachine(config, options) {
   if (!IS_PRODUCTION && !('predictableActionArguments' in config) && !warned) {
@@ -5834,7 +6114,7 @@ function mapState(stateMap, stateId) {
   var foundStateId;
 
   try {
-    for (var _b = _tslib_values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+    for (var _b = __values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
       var mappedStateId = _c.value;
 
       if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
@@ -5868,7 +6148,7 @@ function matchState(state, patterns, defaultValue) {
   var resolvedState = State.from(state, state instanceof State ? state.context : undefined);
 
   try {
-    for (var patterns_1 = _tslib_values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
+    for (var patterns_1 = __values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
       var _b = __read(patterns_1_1.value, 2),
           stateValue = _b[0],
           getValue = _b[1];
@@ -5898,7 +6178,7 @@ function matchState(state, patterns, defaultValue) {
 function createSchema(schema) {
   return schema;
 }
-var t = createSchema;
+var t = (/* unused pure expression or super */ null && (createSchema));
 
 
 
@@ -5919,13 +6199,17 @@ var t = createSchema;
 
 
 var es_assign = actions_assign,
-    es_send = actions_send,
-    es_sendTo = sendTo,
-    es_sendParent = sendParent,
-    es_sendUpdate = sendUpdate,
-    es_forwardTo = forwardTo,
-    es_doneInvoke = actions_doneInvoke,
-    es_raise = actions_raise;
+    es_send = (/* unused pure expression or super */ null && (send$1)),
+    es_sendTo = (/* unused pure expression or super */ null && (sendTo$1)),
+    es_sendParent = (/* unused pure expression or super */ null && (sendParent$1)),
+    es_sendUpdate = (/* unused pure expression or super */ null && (sendUpdate$1)),
+    es_forwardTo = (/* unused pure expression or super */ null && (forwardTo$1)),
+    es_doneInvoke = (/* unused pure expression or super */ null && (doneInvoke$1)),
+    es_raise = (/* unused pure expression or super */ null && (raise$1)),
+    es_log = (/* unused pure expression or super */ null && (log$1)),
+    es_pure = (/* unused pure expression or super */ null && (pure$1)),
+    es_choose = (/* unused pure expression or super */ null && (choose$1)),
+    es_stop = (/* unused pure expression or super */ null && (stop$1));