@ngxs/store 3.7.6-dev.master-1bdb8c0 → 3.7.6-dev.master-dcdd391

package/fesm5/ngxs-store.js

@@ -1,4783 +0,0 @@
-import { __assign, __spread, __extends, __values, __read } from 'tslib';
-import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, ErrorHandler, Injector, Optional, SkipSelf, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
-import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
-import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
-import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @param {?} name
- * @return {?}
- */
-function throwStateNameError(name) {
-    throw new Error(name + " is not a valid state name. It needs to be a valid object property name.");
-}
-/**
- * @return {?}
- */
-function throwStateNamePropertyError() {
-    throw new Error("States must register a 'name' property.");
-}
-/**
- * @param {?} current
- * @param {?} newName
- * @param {?} oldName
- * @return {?}
- */
-function throwStateUniqueError(current, newName, oldName) {
-    throw new Error("State name '" + current + "' from " + newName + " already exists in " + oldName + ".");
-}
-/**
- * @param {?} name
- * @return {?}
- */
-function throwStateDecoratorError(name) {
-    throw new Error("States must be decorated with @State() decorator, but \"" + name + "\" isn't.");
-}
-/**
- * @return {?}
- */
-function throwActionDecoratorError() {
-    throw new Error('@Action() decorator cannot be used with static methods.');
-}
-/**
- * @return {?}
- */
-function throwSelectorDecoratorError() {
-    throw new Error('Selectors only work on methods.');
-}
-/**
- * @return {?}
- */
-function getZoneWarningMessage() {
-    return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
-        'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
-        'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
-}
-/**
- * @param {?} name
- * @return {?}
- */
-function getUndecoratedStateInIvyWarningMessage(name) {
-    return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
-}
-/**
- * @return {?}
- */
-function throwSelectFactoryNotConnectedError() {
-    throw new Error('You have forgotten to import the NGXS module!');
-}
-/**
- * @return {?}
- */
-function throwPatchingArrayError() {
-    throw new Error('Patching arrays is not supported.');
-}
-/**
- * @return {?}
- */
-function throwPatchingPrimitiveError() {
-    throw new Error('Patching primitives is not supported.');
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var DispatchOutsideZoneNgxsExecutionStrategy = /** @class */ (function () {
-    function DispatchOutsideZoneNgxsExecutionStrategy(_ngZone, _platformId) {
-        this._ngZone = _ngZone;
-        this._platformId = _platformId;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            verifyZoneIsNotNooped(_ngZone);
-        }
-    }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype.enter = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        if (isPlatformServer(this._platformId)) {
-            return this.runInsideAngular(func);
-        }
-        return this.runOutsideAngular(func);
-    };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype.leave = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return this.runInsideAngular(func);
-    };
-    /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype.runInsideAngular = /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        if (NgZone.isInAngularZone()) {
-            return func();
-        }
-        return this._ngZone.run(func);
-    };
-    /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype.runOutsideAngular = /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        if (NgZone.isInAngularZone()) {
-            return this._ngZone.runOutsideAngular(func);
-        }
-        return func();
-    };
-    DispatchOutsideZoneNgxsExecutionStrategy.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    /** @nocollapse */
-    DispatchOutsideZoneNgxsExecutionStrategy.ctorParameters = function () { return [
-        { type: NgZone },
-        { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
-    ]; };
-    /** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function DispatchOutsideZoneNgxsExecutionStrategy_Factory() { return new DispatchOutsideZoneNgxsExecutionStrategy(inject(NgZone), inject(PLATFORM_ID)); }, token: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: "root" });
-    return DispatchOutsideZoneNgxsExecutionStrategy;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype._ngZone;
-    /**
-     * @type {?}
-     * @private
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype._platformId;
-}
-// Caretaker note: this should exist as a separate function and not a class method,
-// since class methods are not tree-shakable.
-/**
- * @param {?} ngZone
- * @return {?}
- */
-function verifyZoneIsNotNooped(ngZone) {
-    // `NoopNgZone` is not exposed publicly as it doesn't expect
-    // to be used outside of the core Angular code, thus we just have
-    // to check if the zone doesn't extend or instanceof `NgZone`.
-    if (ngZone instanceof NgZone) {
-        return;
-    }
-    console.warn(getZoneWarningMessage());
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-var ROOT_STATE_TOKEN = new InjectionToken('ROOT_STATE_TOKEN');
-/** @type {?} */
-var FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');
-/** @type {?} */
-var NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');
-/** @type {?} */
-var META_KEY = 'NGXS_META';
-/** @type {?} */
-var META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
-/** @type {?} */
-var SELECTOR_META_KEY = 'NGXS_SELECTOR_META';
-/**
- * The NGXS config settings.
- */
-var NgxsConfig = /** @class */ (function () {
-    function NgxsConfig() {
-        /**
-         * Defining the default state before module initialization
-         * This is convenient if we need to create a define our own set of states.
-         * @deprecated will be removed after v4
-         * (default: {})
-         */
-        this.defaultsState = {};
-        /**
-         * Defining shared selector options
-         */
-        this.selectorOptions = {
-            injectContainerState: true,
-            // TODO: default is true in v3, will change in v4
-            suppressErrors: true // TODO: default is true in v3, will change in v4
-        };
-        this.compatibility = {
-            strictContentSecurityPolicy: false
-        };
-        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
-    }
-    NgxsConfig.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    NgxsConfig.ctorParameters = function () { return []; };
-    return NgxsConfig;
-}());
-if (false) {
-    /**
-     * Run in development mode. This will add additional debugging features:
-     * - Object.freeze on the state and actions to guarantee immutability
-     * (default: false)
-     *
-     * Note: this property will be accounted only in development mode when using the Ivy compiler.
-     * It makes sense to use it only during development to ensure there're no state mutations.
-     * When building for production, the Object.freeze will be tree-shaken away.
-     * @type {?}
-     */
-    NgxsConfig.prototype.developmentMode;
-    /** @type {?} */
-    NgxsConfig.prototype.compatibility;
-    /**
-     * Determines the execution context to perform async operations inside. An implementation can be
-     * provided to override the default behaviour where the async operations are run
-     * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
-     * These observable behaviours are from:
-     *   `\@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
-     * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
-     * application doesn't rely on zone.js running change detection then you can switch to the
-     * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
-     * (default: null)
-     * @type {?}
-     */
-    NgxsConfig.prototype.executionStrategy;
-    /**
-     * Defining the default state before module initialization
-     * This is convenient if we need to create a define our own set of states.
-     * @deprecated will be removed after v4
-     * (default: {})
-     * @type {?}
-     */
-    NgxsConfig.prototype.defaultsState;
-    /**
-     * Defining shared selector options
-     * @type {?}
-     */
-    NgxsConfig.prototype.selectorOptions;
-}
-/**
- * State context provided to the actions in the state.
- * @record
- * @template T
- */
-function StateContext() { }
-if (false) {
-    /**
-     * Get the current state.
-     * @return {?}
-     */
-    StateContext.prototype.getState = function () { };
-    /**
-     * Reset the state to a new value.
-     * @param {?} val
-     * @return {?}
-     */
-    StateContext.prototype.setState = function (val) { };
-    /**
-     * Patch the existing state with the provided value.
-     * @param {?} val
-     * @return {?}
-     */
-    StateContext.prototype.patchState = function (val) { };
-    /**
-     * Dispatch a new action and return the dispatched observable.
-     * @param {?} actions
-     * @return {?}
-     */
-    StateContext.prototype.dispatch = function (actions) { };
-}
-/**
- * Plugin interface
- * @record
- */
-function NgxsPlugin() { }
-if (false) {
-    /**
-     * Handle the state/action before its submitted to the state handlers.
-     * @param {?} state
-     * @param {?} action
-     * @param {?} next
-     * @return {?}
-     */
-    NgxsPlugin.prototype.handle = function (state, action, next) { };
-}
-/**
- * Options that can be provided to the store.
- * @record
- * @template T
- */
-function StoreOptions() { }
-if (false) {
-    /**
-     * Name of the state. Required.
-     * @type {?}
-     */
-    StoreOptions.prototype.name;
-    /**
-     * Default values for the state. If not provided, uses empty object.
-     * @type {?|undefined}
-     */
-    StoreOptions.prototype.defaults;
-    /**
-     * Sub states for the given state.
-     * @type {?|undefined}
-     */
-    StoreOptions.prototype.children;
-}
-/**
- * Represents a basic change from a previous to a new value for a single state instance.
- * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
- * @template T
- */
-var  /**
- * Represents a basic change from a previous to a new value for a single state instance.
- * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
- * @template T
- */
-NgxsSimpleChange = /** @class */ (function () {
-    function NgxsSimpleChange(previousValue, currentValue, firstChange) {
-        this.previousValue = previousValue;
-        this.currentValue = currentValue;
-        this.firstChange = firstChange;
-    }
-    return NgxsSimpleChange;
-}());
-if (false) {
-    /** @type {?} */
-    NgxsSimpleChange.prototype.previousValue;
-    /** @type {?} */
-    NgxsSimpleChange.prototype.currentValue;
-    /** @type {?} */
-    NgxsSimpleChange.prototype.firstChange;
-}
-/**
- * On init interface
- * @record
- */
-function NgxsOnInit() { }
-if (false) {
-    /**
-     * @param {?} ctx
-     * @return {?}
-     */
-    NgxsOnInit.prototype.ngxsOnInit = function (ctx) { };
-}
-/**
- * On change interface
- * @record
- */
-function NgxsOnChanges() { }
-if (false) {
-    /**
-     * @param {?} change
-     * @return {?}
-     */
-    NgxsOnChanges.prototype.ngxsOnChanges = function (change) { };
-}
-/**
- * After bootstrap interface
- * @record
- */
-function NgxsAfterBootstrap() { }
-if (false) {
-    /**
-     * @param {?} ctx
-     * @return {?}
-     */
-    NgxsAfterBootstrap.prototype.ngxsAfterBootstrap = function (ctx) { };
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var NoopNgxsExecutionStrategy = /** @class */ (function () {
-    function NoopNgxsExecutionStrategy() {
-    }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NoopNgxsExecutionStrategy.prototype.enter = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return func();
-    };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NoopNgxsExecutionStrategy.prototype.leave = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return func();
-    };
-    NoopNgxsExecutionStrategy.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    /** @nocollapse */ NoopNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function NoopNgxsExecutionStrategy_Factory() { return new NoopNgxsExecutionStrategy(); }, token: NoopNgxsExecutionStrategy, providedIn: "root" });
-    return NoopNgxsExecutionStrategy;
-}());
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * The strategy that might be provided by users through `options.executionStrategy`.
- * @type {?}
- */
-var USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
-/*
- * Internal execution strategy injection token
- */
-/** @type {?} */
-var NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY', {
-    providedIn: 'root',
-    factory: (/**
-     * @return {?}
-     */
-    function () {
-        /** @type {?} */
-        var injector = inject(INJECTOR);
-        /** @type {?} */
-        var executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
-        return executionStrategy
-            ? injector.get(executionStrategy)
-            : injector.get(typeof ɵglobal.Zone !== 'undefined'
-                ? DispatchOutsideZoneNgxsExecutionStrategy
-                : NoopNgxsExecutionStrategy);
-    })
-});
-/**
- * @record
- */
-function NgxsExecutionStrategy() { }
-if (false) {
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NgxsExecutionStrategy.prototype.enter = function (func) { };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NgxsExecutionStrategy.prototype.leave = function (func) { };
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T, U
- */
-function StateClassInternal() { }
-if (false) {
-    /* Skipping unnamed member:
-    [META_KEY]?: MetaDataModel;*/
-    /* Skipping unnamed member:
-    [META_OPTIONS_KEY]?: StoreOptions<U>;*/
-}
-/**
- * @record
- * @template T
- */
-function StateOperations() { }
-if (false) {
-    /**
-     * @return {?}
-     */
-    StateOperations.prototype.getState = function () { };
-    /**
-     * @param {?} val
-     * @return {?}
-     */
-    StateOperations.prototype.setState = function (val) { };
-    /**
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    StateOperations.prototype.dispatch = function (actionOrActions) { };
-}
-/**
- * @record
- */
-function MetaDataModel() { }
-if (false) {
-    /** @type {?} */
-    MetaDataModel.prototype.name;
-    /** @type {?} */
-    MetaDataModel.prototype.actions;
-    /** @type {?} */
-    MetaDataModel.prototype.defaults;
-    /** @type {?} */
-    MetaDataModel.prototype.path;
-    /** @type {?} */
-    MetaDataModel.prototype.makeRootSelector;
-    /** @type {?|undefined} */
-    MetaDataModel.prototype.children;
-}
-/**
- * @record
- */
-function RuntimeSelectorContext() { }
-if (false) {
-    /**
-     * @param {?} key
-     * @return {?}
-     */
-    RuntimeSelectorContext.prototype.getStateGetter = function (key) { };
-    /**
-     * @param {?=} localOptions
-     * @return {?}
-     */
-    RuntimeSelectorContext.prototype.getSelectorOptions = function (localOptions) { };
-}
-/**
- * @record
- */
-function SharedSelectorOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    SharedSelectorOptions.prototype.injectContainerState;
-    /** @type {?|undefined} */
-    SharedSelectorOptions.prototype.suppressErrors;
-}
-/**
- * @record
- */
-function SelectorMetaDataModel() { }
-if (false) {
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.makeRootSelector;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.originalFn;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.containerClass;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.selectorName;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.getSelectorOptions;
-}
-/**
- * @record
- */
-function MappedStore() { }
-if (false) {
-    /** @type {?} */
-    MappedStore.prototype.name;
-    /** @type {?} */
-    MappedStore.prototype.isInitialised;
-    /** @type {?} */
-    MappedStore.prototype.actions;
-    /** @type {?} */
-    MappedStore.prototype.defaults;
-    /** @type {?} */
-    MappedStore.prototype.instance;
-    /** @type {?} */
-    MappedStore.prototype.path;
-}
-/**
- * @record
- */
-function StatesAndDefaults() { }
-if (false) {
-    /** @type {?} */
-    StatesAndDefaults.prototype.defaults;
-    /** @type {?} */
-    StatesAndDefaults.prototype.states;
-}
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- * @param {?} target
- * @return {?}
- */
-function ensureStoreMetadata(target) {
-    if (!target.hasOwnProperty(META_KEY)) {
-        /** @type {?} */
-        var defaultMetadata_1 = {
-            name: null,
-            actions: {},
-            defaults: {},
-            path: null,
-            makeRootSelector: /**
-             * @param {?} context
-             * @return {?}
-             */
-            function (context) {
-                return context.getStateGetter(defaultMetadata_1.name);
-            },
-            children: []
-        };
-        Object.defineProperty(target, META_KEY, { value: defaultMetadata_1 });
-    }
-    return getStoreMetadata(target);
-}
-/**
- * Get the metadata attached to the state class if it exists.
- *
- * @ignore
- * @param {?} target
- * @return {?}
- */
-function getStoreMetadata(target) {
-    return (/** @type {?} */ (target[META_KEY]));
-}
-/**
- * Ensures metadata is attached to the selector and returns it.
- *
- * @ignore
- * @param {?} target
- * @return {?}
- */
-function ensureSelectorMetadata(target) {
-    if (!target.hasOwnProperty(SELECTOR_META_KEY)) {
-        /** @type {?} */
-        var defaultMetadata = {
-            makeRootSelector: null,
-            originalFn: null,
-            containerClass: null,
-            selectorName: null,
-            getSelectorOptions: (/**
-             * @return {?}
-             */
-            function () { return ({}); })
-        };
-        Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });
-    }
-    return getSelectorMetadata(target);
-}
-/**
- * Get the metadata attached to the selector if it exists.
- *
- * @ignore
- * @param {?} target
- * @return {?}
- */
-function getSelectorMetadata(target) {
-    return target[SELECTOR_META_KEY];
-}
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.
- * See perf hit: https://jsperf.com/fast-value-getter-given-path/1
- *
- * @ignore
- * @param {?} paths
- * @return {?}
- */
-function compliantPropGetter(paths) {
-    /** @type {?} */
-    var copyOfPaths = paths.slice();
-    return (/**
-     * @param {?} obj
-     * @return {?}
-     */
-    function (obj) { return copyOfPaths.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @return {?}
-     */
-    function (acc, part) { return acc && acc[part]; }), obj); });
-}
-/**
- * The generated function is faster than:
- * - pluck (Observable operator)
- * - memoize
- *
- * @ignore
- * @param {?} paths
- * @return {?}
- */
-function fastPropGetter(paths) {
-    /** @type {?} */
-    var segments = paths;
-    /** @type {?} */
-    var seg = 'store.' + segments[0];
-    /** @type {?} */
-    var i = 0;
-    /** @type {?} */
-    var l = segments.length;
-    /** @type {?} */
-    var expr = seg;
-    while (++i < l) {
-        expr = expr + ' && ' + (seg = seg + '.' + segments[i]);
-    }
-    /** @type {?} */
-    var fn = new Function('store', 'return ' + expr + ';');
-    return (/** @type {?} */ (fn));
-}
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- * @param {?} paths
- * @param {?} config
- * @return {?}
- */
-function propGetter(paths, config) {
-    if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {
-        return compliantPropGetter(paths);
-    }
-    else {
-        return fastPropGetter(paths);
-    }
-}
-/**
- * Given an array of states, it will return a object graph. Example:
- *    const states = [
- *      Cart,
- *      CartSaved,
- *      CartSavedItems
- *    ]
- *
- * would return:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * @ignore
- * @param {?} stateClasses
- * @return {?}
- */
-function buildGraph(stateClasses) {
-    /** @type {?} */
-    var findName = (/**
-     * @param {?} stateClass
-     * @return {?}
-     */
-    function (stateClass) {
-        /** @type {?} */
-        var meta = stateClasses.find((/**
-         * @param {?} g
-         * @return {?}
-         */
-        function (g) { return g === stateClass; }));
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {
-            throw new Error("Child state not found: " + stateClass + ". \r\nYou may have forgotten to add states to module");
-        }
-        return (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (meta))[META_KEY])).name));
-    });
-    return stateClasses.reduce((/**
-     * @param {?} result
-     * @param {?} stateClass
-     * @return {?}
-     */
-    function (result, stateClass) {
-        var _a = (/** @type {?} */ (stateClass[META_KEY])), name = _a.name, children = _a.children;
-        result[(/** @type {?} */ (name))] = (children || []).map(findName);
-        return result;
-    }), {});
-}
-/**
- * Given a states array, returns object graph
- * returning the name and state metadata. Example:
- *
- *  const graph = {
- *    cart: { metadata }
- *  };
- *
- * @ignore
- * @param {?} states
- * @return {?}
- */
-function nameToState(states) {
-    return states.reduce((/**
-     * @param {?} result
-     * @param {?} stateClass
-     * @return {?}
-     */
-    function (result, stateClass) {
-        /** @type {?} */
-        var meta = (/** @type {?} */ (stateClass[META_KEY]));
-        result[(/** @type {?} */ (meta.name))] = stateClass;
-        return result;
-    }), {});
-}
-/**
- * Given a object relationship graph will return the full path
- * for the child items. Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const r = {
- *    cart: 'cart',
- *    saved: 'cart.saved',
- *    items: 'cart.saved.items'
- *  };
- *
- * @ignore
- * @param {?} obj
- * @param {?=} newObj
- * @return {?}
- */
-function findFullParentPath(obj, newObj) {
-    if (newObj === void 0) { newObj = {}; }
-    /** @type {?} */
-    var visit = (/**
-     * @param {?} child
-     * @param {?} keyToFind
-     * @return {?}
-     */
-    function (child, keyToFind) {
-        for (var key in child) {
-            if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {
-                /** @type {?} */
-                var parent_1 = visit(child, key);
-                return parent_1 !== null ? parent_1 + "." + key : key;
-            }
-        }
-        return null;
-    });
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            /** @type {?} */
-            var parent_2 = visit(obj, key);
-            newObj[key] = parent_2 ? parent_2 + "." + key : key;
-        }
-    }
-    return newObj;
-}
-/**
- * Given a object graph, it will return the items topologically sorted Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const results = [
- *    'items',
- *    'saved',
- *    'cart'
- *  ];
- *
- * @ignore
- * @param {?} graph
- * @return {?}
- */
-function topologicalSort(graph) {
-    /** @type {?} */
-    var sorted = [];
-    /** @type {?} */
-    var visited = {};
-    /** @type {?} */
-    var visit = (/**
-     * @param {?} name
-     * @param {?=} ancestors
-     * @return {?}
-     */
-    function (name, ancestors) {
-        if (ancestors === void 0) { ancestors = []; }
-        if (!Array.isArray(ancestors)) {
-            ancestors = [];
-        }
-        ancestors.push(name);
-        visited[name] = true;
-        graph[name].forEach((/**
-         * @param {?} dep
-         * @return {?}
-         */
-        function (dep) {
-            // Caretaker note: we have still left the `typeof` condition in order to avoid
-            // creating a breaking change for projects that still use the View Engine.
-            if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {
-                throw new Error("Circular dependency '" + dep + "' is required by '" + name + "': " + ancestors.join(' -> '));
-            }
-            if (visited[dep]) {
-                return;
-            }
-            visit(dep, ancestors.slice(0));
-        }));
-        if (sorted.indexOf(name) < 0) {
-            sorted.push(name);
-        }
-    });
-    Object.keys(graph).forEach((/**
-     * @param {?} k
-     * @return {?}
-     */
-    function (k) { return visit(k); }));
-    return sorted.reverse();
-}
-/**
- * Returns if the parameter is a object or not.
- *
- * @ignore
- * @param {?} obj
- * @return {?}
- */
-function isObject(obj) {
-    return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Returns the type from an action instance/class.
- * @ignore
- * @param {?} action
- * @return {?}
- */
-function getActionTypeFromInstance(action) {
-    if (action.constructor && action.constructor.type) {
-        return action.constructor.type;
-    }
-    else {
-        return action.type;
-    }
-}
-/**
- * Matches a action
- * @ignore
- * @param {?} action1
- * @return {?}
- */
-function actionMatcher(action1) {
-    /** @type {?} */
-    var type1 = getActionTypeFromInstance(action1);
-    return (/**
-     * @param {?} action2
-     * @return {?}
-     */
-    function (action2) {
-        return type1 === getActionTypeFromInstance(action2);
-    });
-}
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- * @type {?}
- */
-var setValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @param {?} val
- * @return {?}
- */
-function (obj, prop, val) {
-    obj = __assign({}, obj);
-    /** @type {?} */
-    var split = prop.split('.');
-    /** @type {?} */
-    var lastIndex = split.length - 1;
-    split.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @param {?} index
-     * @return {?}
-     */
-    function (acc, part, index) {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : __assign({}, acc[part]);
-        }
-        return acc && acc[part];
-    }), obj);
-    return obj;
-});
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- * @type {?}
- */
-var getValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @return {?}
- */
-function (obj, prop) {
-    return prop.split('.').reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @return {?}
-     */
-    function (acc, part) { return acc && acc[part]; }), obj);
-});
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- * @type {?}
- */
-var isObject$1 = (/**
- * @param {?} item
- * @return {?}
- */
-function (item) {
-    return item && typeof item === 'object' && !Array.isArray(item);
-});
-/**
- * Deep merge two objects.
- *
- *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
- *
- * \@param base base object onto which `sources` will be applied
- * @type {?}
- */
-var mergeDeep = (/**
- * @param {?} base
- * @param {...?} sources
- * @return {?}
- */
-function (base) {
-    var sources = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        sources[_i - 1] = arguments[_i];
-    }
-    var _a, _b;
-    if (!sources.length)
-        return base;
-    /** @type {?} */
-    var source = sources.shift();
-    if (isObject$1(base) && isObject$1(source)) {
-        for (var key in source) {
-            if (isObject$1(source[key])) {
-                if (!base[key])
-                    Object.assign(base, (_a = {}, _a[key] = {}, _a));
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, (_b = {}, _b[key] = source[key], _b));
-            }
-        }
-    }
-    return mergeDeep.apply(void 0, __spread([base], sources));
-});
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T, E
- */
-function ActionCompletion() { }
-if (false) {
-    /** @type {?} */
-    ActionCompletion.prototype.action;
-    /** @type {?} */
-    ActionCompletion.prototype.result;
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will grab actions that have just been dispatched as well as actions that have completed
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofAction() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    return ofActionOperator(allowedTypes);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been dispatched
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofActionDispatched() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    return ofActionOperator(allowedTypes, ["DISPATCHED" /* Dispatched */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been successfully completed
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofActionSuccessful() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* Successful */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been canceled
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofActionCanceled() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    return ofActionOperator(allowedTypes, ["CANCELED" /* Canceled */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been completed
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofActionCompleted() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    /** @type {?} */
-    var allowedStatuses = [
-        "SUCCESSFUL" /* Successful */,
-        "CANCELED" /* Canceled */,
-        "ERRORED" /* Errored */
-    ];
-    return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just thrown an error
- * @template T
- * @param {...?} allowedTypes
- * @return {?}
- */
-function ofActionErrored() {
-    var allowedTypes = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        allowedTypes[_i] = arguments[_i];
-    }
-    return ofActionOperator(allowedTypes, ["ERRORED" /* Errored */]);
-}
-/**
- * @param {?} allowedTypes
- * @param {?=} statuses
- * @param {?=} mapOperator
- * @return {?}
- */
-function ofActionOperator(allowedTypes, statuses, 
-// This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,
-// since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`
-// defaults to `any`, thus there is no sense from union type.
-mapOperator) {
-    if (mapOperator === void 0) { mapOperator = mapAction; }
-    /** @type {?} */
-    var allowedMap = createAllowedActionTypesMap(allowedTypes);
-    /** @type {?} */
-    var allowedStatusMap = statuses && createAllowedStatusesMap(statuses);
-    return (/**
-     * @param {?} o
-     * @return {?}
-     */
-    function (o) {
-        return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());
-    });
-}
-/**
- * @param {?} allowedTypes
- * @param {?=} allowedStatuses
- * @return {?}
- */
-function filterStatus(allowedTypes, allowedStatuses) {
-    return filter((/**
-     * @param {?} ctx
-     * @return {?}
-     */
-    function (ctx) {
-        /** @type {?} */
-        var actionType = (/** @type {?} */ (getActionTypeFromInstance(ctx.action)));
-        /** @type {?} */
-        var typeMatch = allowedTypes[actionType];
-        /** @type {?} */
-        var statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;
-        return typeMatch && statusMatch;
-    }));
-}
-/**
- * @return {?}
- */
-function mapActionResult() {
-    return map((/**
-     * @param {?} __0
-     * @return {?}
-     */
-    function (_a) {
-        var action = _a.action, status = _a.status, error = _a.error;
-        return (/** @type {?} */ ({
-            action: action,
-            result: {
-                successful: "SUCCESSFUL" /* Successful */ === status,
-                canceled: "CANCELED" /* Canceled */ === status,
-                error: error
-            }
-        }));
-    }));
-}
-/**
- * @template T
- * @return {?}
- */
-function mapAction() {
-    return map((/**
-     * @param {?} ctx
-     * @return {?}
-     */
-    function (ctx) { return (/** @type {?} */ (ctx.action)); }));
-}
-/**
- * @record
- */
-function FilterMap() { }
-/**
- * @param {?} types
- * @return {?}
- */
-function createAllowedActionTypesMap(types) {
-    return types.reduce((/**
-     * @param {?} filterMap
-     * @param {?} klass
-     * @return {?}
-     */
-    function (filterMap, klass) {
-        filterMap[(/** @type {?} */ (getActionTypeFromInstance(klass)))] = true;
-        return filterMap;
-    }), (/** @type {?} */ ({})));
-}
-/**
- * @param {?} statuses
- * @return {?}
- */
-function createAllowedStatusesMap(statuses) {
-    return statuses.reduce((/**
-     * @param {?} filterMap
-     * @param {?} status
-     * @return {?}
-     */
-    function (filterMap, status) {
-        filterMap[status] = true;
-        return filterMap;
-    }), (/** @type {?} */ ({})));
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Returns operator that will run
- * `subscribe` outside of the ngxs execution context
- * @template T
- * @param {?} ngxsExecutionStrategy
- * @return {?}
- */
-function leaveNgxs(ngxsExecutionStrategy) {
-    return (/**
-     * @param {?} source
-     * @return {?}
-     */
-    function (source) {
-        return new Observable((/**
-         * @param {?} sink
-         * @return {?}
-         */
-        function (sink) {
-            return source.subscribe({
-                next: /**
-                 * @param {?} value
-                 * @return {?}
-                 */
-                function (value) {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    function () { return sink.next(value); }));
-                },
-                error: /**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (error) {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    function () { return sink.error(error); }));
-                },
-                complete: /**
-                 * @return {?}
-                 */
-                function () {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    function () { return sink.complete(); }));
-                }
-            });
-        }));
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var InternalNgxsExecutionStrategy = /** @class */ (function () {
-    function InternalNgxsExecutionStrategy(_executionStrategy) {
-        this._executionStrategy = _executionStrategy;
-    }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    InternalNgxsExecutionStrategy.prototype.enter = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return this._executionStrategy.enter(func);
-    };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    InternalNgxsExecutionStrategy.prototype.leave = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return this._executionStrategy.leave(func);
-    };
-    InternalNgxsExecutionStrategy.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    InternalNgxsExecutionStrategy.ctorParameters = function () { return [
-        { type: undefined, decorators: [{ type: Inject, args: [NGXS_EXECUTION_STRATEGY,] }] }
-    ]; };
-    return InternalNgxsExecutionStrategy;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalNgxsExecutionStrategy.prototype._executionStrategy;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {string} */
-var ActionStatus = {
-    Dispatched: 'DISPATCHED',
-    Successful: 'SUCCESSFUL',
-    Canceled: 'CANCELED',
-    Errored: 'ERRORED',
-};
-/**
- * @record
- * @template T
- */
-function ActionContext() { }
-if (false) {
-    /** @type {?} */
-    ActionContext.prototype.status;
-    /** @type {?} */
-    ActionContext.prototype.action;
-    /** @type {?|undefined} */
-    ActionContext.prototype.error;
-}
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
- */
-var  /**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
- */
-OrderedSubject = /** @class */ (function (_super) {
-    __extends(OrderedSubject, _super);
-    function OrderedSubject() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._itemQueue = [];
-        _this._busyPushingNext = false;
-        return _this;
-    }
-    /**
-     * @param {?=} value
-     * @return {?}
-     */
-    OrderedSubject.prototype.next = /**
-     * @param {?=} value
-     * @return {?}
-     */
-    function (value) {
-        if (this._busyPushingNext) {
-            this._itemQueue.unshift((/** @type {?} */ (value)));
-            return;
-        }
-        this._busyPushingNext = true;
-        _super.prototype.next.call(this, value);
-        while (this._itemQueue.length > 0) {
-            /** @type {?} */
-            var nextValue = this._itemQueue.pop();
-            _super.prototype.next.call(this, nextValue);
-        }
-        this._busyPushingNext = false;
-    };
-    return OrderedSubject;
-}(Subject));
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._itemQueue;
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._busyPushingNext;
-}
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-var InternalActions = /** @class */ (function (_super) {
-    __extends(InternalActions, _super);
-    function InternalActions() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    /**
-     * @return {?}
-     */
-    InternalActions.prototype.ngOnDestroy = /**
-     * @return {?}
-     */
-    function () {
-        this.complete();
-    };
-    InternalActions.decorators = [
-        { type: Injectable }
-    ];
-    return InternalActions;
-}(OrderedSubject));
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-var Actions = /** @class */ (function (_super) {
-    __extends(Actions, _super);
-    function Actions(internalActions$, internalExecutionStrategy) {
-        var _this = this;
-        /** @type {?} */
-        var sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
-        // The `InternalActions` subject emits outside of the Angular zone.
-        // We have to re-enter the Angular zone for any incoming consumer.
-        // The `share()` operator reduces the number of change detections.
-        // This would call leave only once for any stream emission across all active subscribers.
-        share());
-        _this = _super.call(this, (/**
-         * @param {?} observer
-         * @return {?}
-         */
-        function (observer) {
-            /** @type {?} */
-            var childSubscription = sharedInternalActions$.subscribe({
-                next: (/**
-                 * @param {?} ctx
-                 * @return {?}
-                 */
-                function (ctx) { return observer.next(ctx); }),
-                error: (/**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (error) { return observer.error(error); }),
-                complete: (/**
-                 * @return {?}
-                 */
-                function () { return observer.complete(); })
-            });
-            observer.add(childSubscription);
-        })) || this;
-        return _this;
-    }
-    Actions.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    Actions.ctorParameters = function () { return [
-        { type: InternalActions },
-        { type: InternalNgxsExecutionStrategy }
-    ]; };
-    return Actions;
-}(Observable));
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Composes a array of functions from left to right. Example:
- *
- *      compose([fn, final])(state, action);
- *
- * then the funcs have a signature like:
- *
- *      function fn (state, action, next) {
- *          console.log('here', state, action, next);
- *          return next(state, action);
- *      }
- *
- *      function final (state, action) {
- *          console.log('here', state, action);
- *          return state;
- *      }
- *
- * the last function should not call `next`.
- *
- * @ignore
- * @type {?}
- */
-var compose = (/**
- * @param {?} funcs
- * @return {?}
- */
-function (funcs) { return (/**
- * @param {...?} args
- * @return {?}
- */
-function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    /** @type {?} */
-    var curr = (/** @type {?} */ (funcs.shift()));
-    return curr.apply(void 0, __spread(args, [(/**
-         * @param {...?} nextArgs
-         * @return {?}
-         */
-        function () {
-            var nextArgs = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                nextArgs[_i] = arguments[_i];
-            }
-            return compose(funcs).apply(void 0, __spread(nextArgs));
-        })]));
-}); });
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * This operator is used for piping the observable result
- * from the `dispatch()`. It has a "smart" error handling
- * strategy that allows us to decide whether we propagate
- * errors to Angular's `ErrorHandler` or enable users to
- * handle them manually. We consider following cases:
- * 1) `store.dispatch()` (no subscribe) -> call `handleError()`
- * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`
- * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
- * 4) `toPromise()` without `catch` -> do `handleError()`
- * 5) `toPromise()` with `catch` -> don't `handleError()`
- * @template T
- * @param {?} internalErrorReporter
- * @param {?} ngxsExecutionStrategy
- * @return {?}
- */
-function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
-    return (/**
-     * @param {?} source
-     * @return {?}
-     */
-    function (source) {
-        /** @type {?} */
-        var subscribed = false;
-        source.subscribe({
-            error: (/**
-             * @param {?} error
-             * @return {?}
-             */
-            function (error) {
-                // Do not trigger change detection for a microtask. This depends on the execution
-                // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
-                // leaves the Angular zone.
-                ngxsExecutionStrategy.enter((/**
-                 * @return {?}
-                 */
-                function () {
-                    return Promise.resolve().then((/**
-                     * @return {?}
-                     */
-                    function () {
-                        if (!subscribed) {
-                            ngxsExecutionStrategy.leave((/**
-                             * @return {?}
-                             */
-                            function () {
-                                return internalErrorReporter.reportErrorSafely(error);
-                            }));
-                        }
-                    }));
-                }));
-            })
-        });
-        return new Observable((/**
-         * @param {?} subscriber
-         * @return {?}
-         */
-        function (subscriber) {
-            subscribed = true;
-            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
-        }));
-    });
-}
-var InternalErrorReporter = /** @class */ (function () {
-    function InternalErrorReporter(_injector) {
-        this._injector = _injector;
-        /**
-         * Will be set lazily to be backward compatible.
-         */
-        this._errorHandler = (/** @type {?} */ (null));
-    }
-    /**
-     * @param {?} error
-     * @return {?}
-     */
-    InternalErrorReporter.prototype.reportErrorSafely = /**
-     * @param {?} error
-     * @return {?}
-     */
-    function (error) {
-        if (this._errorHandler === null) {
-            this._errorHandler = this._injector.get(ErrorHandler);
-        }
-        // The `try-catch` is used to avoid handling the error twice. Suppose we call
-        // `handleError` which re-throws the error internally. The re-thrown error will
-        // be caught by zone.js which will then get to the `zone.onError.emit()` and the
-        // `onError` subscriber will call `handleError` again.
-        try {
-            this._errorHandler.handleError(error);
-        }
-        catch (_a) { }
-    };
-    InternalErrorReporter.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    /** @nocollapse */
-    InternalErrorReporter.ctorParameters = function () { return [
-        { type: Injector }
-    ]; };
-    /** @nocollapse */ InternalErrorReporter.ngInjectableDef = defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(inject(INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
-    return InternalErrorReporter;
-}());
-if (false) {
-    /**
-     * Will be set lazily to be backward compatible.
-     * @type {?}
-     * @private
-     */
-    InternalErrorReporter.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalErrorReporter.prototype._injector;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * BehaviorSubject of the entire state.
- * @ignore
- */
-var StateStream = /** @class */ (function (_super) {
-    __extends(StateStream, _super);
-    function StateStream() {
-        return _super.call(this, {}) || this;
-    }
-    /**
-     * @return {?}
-     */
-    StateStream.prototype.ngOnDestroy = /**
-     * @return {?}
-     */
-    function () {
-        // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.
-        // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users
-        // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.
-        this.complete();
-    };
-    StateStream.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    StateStream.ctorParameters = function () { return []; };
-    return StateStream;
-}(BehaviorSubject));
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var PluginManager = /** @class */ (function () {
-    function PluginManager(_parentManager, _pluginHandlers) {
-        this._parentManager = _parentManager;
-        this._pluginHandlers = _pluginHandlers;
-        this.plugins = [];
-        this.registerHandlers();
-    }
-    Object.defineProperty(PluginManager.prototype, "rootPlugins", {
-        get: /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            return (this._parentManager && this._parentManager.plugins) || this.plugins;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * @private
-     * @return {?}
-     */
-    PluginManager.prototype.registerHandlers = /**
-     * @private
-     * @return {?}
-     */
-    function () {
-        var _a;
-        /** @type {?} */
-        var pluginHandlers = this.getPluginHandlers();
-        (_a = this.rootPlugins).push.apply(_a, __spread(pluginHandlers));
-    };
-    /**
-     * @private
-     * @return {?}
-     */
-    PluginManager.prototype.getPluginHandlers = /**
-     * @private
-     * @return {?}
-     */
-    function () {
-        /** @type {?} */
-        var handlers = this._pluginHandlers || [];
-        return handlers.map((/**
-         * @param {?} plugin
-         * @return {?}
-         */
-        function (plugin) { return (/** @type {?} */ ((plugin.handle ? plugin.handle.bind(plugin) : plugin))); }));
-    };
-    PluginManager.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    PluginManager.ctorParameters = function () { return [
-        { type: PluginManager, decorators: [{ type: Optional }, { type: SkipSelf }] },
-        { type: Array, decorators: [{ type: Inject, args: [NGXS_PLUGINS,] }, { type: Optional }] }
-    ]; };
-    return PluginManager;
-}());
-if (false) {
-    /** @type {?} */
-    PluginManager.prototype.plugins;
-    /**
-     * @type {?}
-     * @private
-     */
-    PluginManager.prototype._parentManager;
-    /**
-     * @type {?}
-     * @private
-     */
-    PluginManager.prototype._pluginHandlers;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Internal Action result stream that is emitted when an action is completed.
- * This is used as a method of returning the action result to the dispatcher
- * for the observable returned by the dispatch(...) call.
- * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
- */
-var InternalDispatchedActionResults = /** @class */ (function (_super) {
-    __extends(InternalDispatchedActionResults, _super);
-    function InternalDispatchedActionResults() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    InternalDispatchedActionResults.decorators = [
-        { type: Injectable }
-    ];
-    return InternalDispatchedActionResults;
-}(Subject));
-var InternalDispatcher = /** @class */ (function () {
-    function InternalDispatcher(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
-        this._actions = _actions;
-        this._actionResults = _actionResults;
-        this._pluginManager = _pluginManager;
-        this._stateStream = _stateStream;
-        this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
-        this._internalErrorReporter = _internalErrorReporter;
-    }
-    /**
-     * Dispatches event(s).
-     */
-    /**
-     * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    InternalDispatcher.prototype.dispatch = /**
-     * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    function (actionOrActions) {
-        var _this = this;
-        /** @type {?} */
-        var result = this._ngxsExecutionStrategy.enter((/**
-         * @return {?}
-         */
-        function () {
-            return _this.dispatchByEvents(actionOrActions);
-        }));
-        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
-    };
-    /**
-     * @private
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    InternalDispatcher.prototype.dispatchByEvents = /**
-     * @private
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    function (actionOrActions) {
-        var _this = this;
-        if (Array.isArray(actionOrActions)) {
-            if (actionOrActions.length === 0)
-                return of(this._stateStream.getValue());
-            return forkJoin(actionOrActions.map((/**
-             * @param {?} action
-             * @return {?}
-             */
-            function (action) { return _this.dispatchSingle(action); })));
-        }
-        else {
-            return this.dispatchSingle(actionOrActions);
-        }
-    };
-    /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
-    InternalDispatcher.prototype.dispatchSingle = /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
-    function (action) {
-        var _this = this;
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
-            var type = getActionTypeFromInstance(action);
-            if (!type) {
-                /** @type {?} */
-                var error = new Error("This action doesn't have a type property: " + action.constructor.name);
-                return throwError(error);
-            }
-        }
-        /** @type {?} */
-        var prevState = this._stateStream.getValue();
-        /** @type {?} */
-        var plugins = this._pluginManager.plugins;
-        return ((/** @type {?} */ (compose(__spread(plugins, [
-            (/**
-             * @param {?} nextState
-             * @param {?} nextAction
-             * @return {?}
-             */
-            function (nextState, nextAction) {
-                if (nextState !== prevState) {
-                    _this._stateStream.next(nextState);
-                }
-                /** @type {?} */
-                var actionResult$ = _this.getActionResultStream(nextAction);
-                actionResult$.subscribe((/**
-                 * @param {?} ctx
-                 * @return {?}
-                 */
-                function (ctx) { return _this._actions.next(ctx); }));
-                _this._actions.next({ action: nextAction, status: "DISPATCHED" /* Dispatched */ });
-                return _this.createDispatchObservable(actionResult$);
-            })
-        ]))(prevState, action)))).pipe(shareReplay());
-    };
-    /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
-    InternalDispatcher.prototype.getActionResultStream = /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
-    function (action) {
-        return this._actionResults.pipe(filter((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        function (ctx) { return ctx.action === action && ctx.status !== "DISPATCHED" /* Dispatched */; })), take(1), shareReplay());
-    };
-    /**
-     * @private
-     * @param {?} actionResult$
-     * @return {?}
-     */
-    InternalDispatcher.prototype.createDispatchObservable = /**
-     * @private
-     * @param {?} actionResult$
-     * @return {?}
-     */
-    function (actionResult$) {
-        var _this = this;
-        return actionResult$
-            .pipe(exhaustMap((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        function (ctx) {
-            switch (ctx.status) {
-                case "SUCCESSFUL" /* Successful */:
-                    return of(_this._stateStream.getValue());
-                case "ERRORED" /* Errored */:
-                    return throwError(ctx.error);
-                default:
-                    return EMPTY;
-            }
-        })))
-            .pipe(shareReplay());
-    };
-    InternalDispatcher.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    InternalDispatcher.ctorParameters = function () { return [
-        { type: InternalActions },
-        { type: InternalDispatchedActionResults },
-        { type: PluginManager },
-        { type: StateStream },
-        { type: InternalNgxsExecutionStrategy },
-        { type: InternalErrorReporter }
-    ]; };
-    return InternalDispatcher;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._actions;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._actionResults;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._pluginManager;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._ngxsExecutionStrategy;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._internalErrorReporter;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Object freeze code
- * https://github.com/jsdf/deep-freeze
- * @type {?}
- */
-var deepFreeze = (/**
- * @param {?} o
- * @return {?}
- */
-function (o) {
-    Object.freeze(o);
-    /** @type {?} */
-    var oIsFunction = typeof o === 'function';
-    /** @type {?} */
-    var hasOwnProp = Object.prototype.hasOwnProperty;
-    Object.getOwnPropertyNames(o).forEach((/**
-     * @param {?} prop
-     * @return {?}
-     */
-    function (prop) {
-        if (hasOwnProp.call(o, prop) &&
-            (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
-            o[prop] !== null &&
-            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
-            !Object.isFrozen(o[prop])) {
-            deepFreeze(o[prop]);
-        }
-    }));
-    return o;
-});
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * State Context factory class
- * @ignore
- */
-var InternalStateOperations = /** @class */ (function () {
-    function InternalStateOperations(_stateStream, _dispatcher, _config) {
-        this._stateStream = _stateStream;
-        this._dispatcher = _dispatcher;
-        this._config = _config;
-    }
-    /**
-     * Returns the root state operators.
-     */
-    /**
-     * Returns the root state operators.
-     * @return {?}
-     */
-    InternalStateOperations.prototype.getRootStateOperations = /**
-     * Returns the root state operators.
-     * @return {?}
-     */
-    function () {
-        var _this = this;
-        /** @type {?} */
-        var rootStateOperations = {
-            getState: (/**
-             * @return {?}
-             */
-            function () { return _this._stateStream.getValue(); }),
-            setState: (/**
-             * @param {?} newState
-             * @return {?}
-             */
-            function (newState) { return _this._stateStream.next(newState); }),
-            dispatch: (/**
-             * @param {?} actionOrActions
-             * @return {?}
-             */
-            function (actionOrActions) { return _this._dispatcher.dispatch(actionOrActions); })
-        };
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            return this._config.developmentMode
-                ? ensureStateAndActionsAreImmutable(rootStateOperations)
-                : rootStateOperations;
-        }
-        else {
-            return rootStateOperations;
-        }
-    };
-    /**
-     * @param {?} results
-     * @return {?}
-     */
-    InternalStateOperations.prototype.setStateToTheCurrentWithNew = /**
-     * @param {?} results
-     * @return {?}
-     */
-    function (results) {
-        /** @type {?} */
-        var stateOperations = this.getRootStateOperations();
-        // Get our current stream
-        /** @type {?} */
-        var currentState = stateOperations.getState();
-        // Set the state to the current + new
-        stateOperations.setState(__assign({}, currentState, results.defaults));
-    };
-    InternalStateOperations.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    InternalStateOperations.ctorParameters = function () { return [
-        { type: StateStream },
-        { type: InternalDispatcher },
-        { type: NgxsConfig }
-    ]; };
-    return InternalStateOperations;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._dispatcher;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._config;
-}
-/**
- * @param {?} root
- * @return {?}
- */
-function ensureStateAndActionsAreImmutable(root) {
-    return {
-        getState: (/**
-         * @return {?}
-         */
-        function () { return root.getState(); }),
-        setState: (/**
-         * @param {?} value
-         * @return {?}
-         */
-        function (value) {
-            /** @type {?} */
-            var frozenValue = deepFreeze(value);
-            return root.setState(frozenValue);
-        }),
-        dispatch: (/**
-         * @param {?} actions
-         * @return {?}
-         */
-        function (actions) {
-            return root.dispatch(actions);
-        })
-    };
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?} val
- * @return {?}
- */
-function simplePatch(val) {
-    return (/**
-     * @param {?} existingState
-     * @return {?}
-     */
-    function (existingState) {
-        if (Array.isArray(val)) {
-            throwPatchingArrayError();
-        }
-        else if (typeof val !== 'object') {
-            throwPatchingPrimitiveError();
-        }
-        /** @type {?} */
-        var newState = __assign({}, ((/** @type {?} */ (existingState))));
-        for (var key in val) {
-            // deep clone for patch compatibility
-            // noinspection JSUnfilteredForInLoop (IDE)
-            newState[key] = ((/** @type {?} */ (val)))[key];
-        }
-        return (/** @type {?} */ (newState));
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * State Context factory class
- * @ignore
- */
-var StateContextFactory = /** @class */ (function () {
-    function StateContextFactory(_internalStateOperations) {
-        this._internalStateOperations = _internalStateOperations;
-    }
-    /**
-     * Create the state context
-     */
-    /**
-     * Create the state context
-     * @template T
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    StateContextFactory.prototype.createStateContext = /**
-     * Create the state context
-     * @template T
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    function (mappedStore) {
-        /** @type {?} */
-        var root = this._internalStateOperations.getRootStateOperations();
-        /**
-         * @param {?} currentAppState
-         * @return {?}
-         */
-        function getState(currentAppState) {
-            return getValue(currentAppState, mappedStore.path);
-        }
-        /**
-         * @param {?} currentAppState
-         * @param {?} newValue
-         * @return {?}
-         */
-        function setStateValue(currentAppState, newValue) {
-            /** @type {?} */
-            var newAppState = setValue(currentAppState, mappedStore.path, newValue);
-            root.setState(newAppState);
-            return newAppState;
-            // In doing this refactoring I noticed that there is a 'bug' where the
-            // application state is returned instead of this state slice.
-            // This has worked this way since the beginning see:
-            // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
-            // This needs to be fixed, but is a 'breaking' change.
-            // I will do this fix in a subsequent PR and we can decide how to handle it.
-        }
-        /**
-         * @param {?} currentAppState
-         * @param {?} stateOperator
-         * @return {?}
-         */
-        function setStateFromOperator(currentAppState, stateOperator) {
-            /** @type {?} */
-            var local = getState(currentAppState);
-            /** @type {?} */
-            var newValue = stateOperator((/** @type {?} */ (local)));
-            return setStateValue(currentAppState, newValue);
-        }
-        /**
-         * @param {?} value
-         * @return {?}
-         */
-        function isStateOperator(value) {
-            return typeof value === 'function';
-        }
-        return {
-            getState: /**
-             * @return {?}
-             */
-            function () {
-                /** @type {?} */
-                var currentAppState = root.getState();
-                return getState(currentAppState);
-            },
-            patchState: /**
-             * @param {?} val
-             * @return {?}
-             */
-            function (val) {
-                /** @type {?} */
-                var currentAppState = root.getState();
-                /** @type {?} */
-                var patchOperator = simplePatch(val);
-                return setStateFromOperator(currentAppState, patchOperator);
-            },
-            setState: /**
-             * @param {?} val
-             * @return {?}
-             */
-            function (val) {
-                /** @type {?} */
-                var currentAppState = root.getState();
-                return isStateOperator(val)
-                    ? setStateFromOperator(currentAppState, val)
-                    : setStateValue(currentAppState, val);
-            },
-            dispatch: /**
-             * @param {?} actions
-             * @return {?}
-             */
-            function (actions) {
-                return root.dispatch(actions);
-            }
-        };
-    };
-    StateContextFactory.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    StateContextFactory.ctorParameters = function () { return [
-        { type: InternalStateOperations }
-    ]; };
-    return StateContextFactory;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateContextFactory.prototype._internalStateOperations;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @abstract
- */
-var StoreValidators = /** @class */ (function () {
-    function StoreValidators() {
-    }
-    /**
-     * @param {?} name
-     * @return {?}
-     */
-    StoreValidators.checkThatStateIsNamedCorrectly = /**
-     * @param {?} name
-     * @return {?}
-     */
-    function (name) {
-        if (!name) {
-            throwStateNamePropertyError();
-        }
-        else if (!this.stateNameRegex.test(name)) {
-            throwStateNameError(name);
-        }
-    };
-    /**
-     * @param {?} stateName
-     * @param {?} state
-     * @param {?} statesByName
-     * @return {?}
-     */
-    StoreValidators.checkThatStateNameIsUnique = /**
-     * @param {?} stateName
-     * @param {?} state
-     * @param {?} statesByName
-     * @return {?}
-     */
-    function (stateName, state, statesByName) {
-        /** @type {?} */
-        var existingState = statesByName[stateName];
-        if (existingState && existingState !== state) {
-            throwStateUniqueError(stateName, state.name, existingState.name);
-        }
-    };
-    /**
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    StoreValidators.checkThatStateClassesHaveBeenDecorated = /**
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    function (stateClasses) {
-        stateClasses.forEach((/**
-         * @param {?} stateClass
-         * @return {?}
-         */
-        function (stateClass) {
-            if (!getStoreMetadata(stateClass)) {
-                throwStateDecoratorError(stateClass.name);
-            }
-        }));
-    };
-    StoreValidators.stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
-    return StoreValidators;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StoreValidators.stateNameRegex;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * All provided or injected tokens must have `\@Injectable` decorator
- * (previously, injected tokens without `\@Injectable` were allowed
- * if another decorator was used, e.g. pipes).
- * @param {?} stateClass
- * @return {?}
- */
-function ensureStateClassIsInjectable(stateClass) {
-    // `ɵprov` is a static property added by the NGCC compiler. It always exists in
-    // AOT mode because this property is added before runtime. If an application is running in
-    // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`
-    // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.
-    if (ɵivyEnabled) {
-        /** @type {?} */
-        /** @nocollapse */ var ngInjectableDef = stateClass.ɵprov;
-        if (!ngInjectableDef) {
-            // Don't warn if Ivy is disabled or `ɵprov` exists on the class
-            console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));
-        }
-    }
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Init action
- */
-var  /**
- * Init action
- */
-InitState = /** @class */ (function () {
-    function InitState() {
-    }
-    Object.defineProperty(InitState, "type", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-            return '@@INIT';
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return InitState;
-}());
-/**
- * Update action
- */
-var  /**
- * Update action
- */
-UpdateState = /** @class */ (function () {
-    function UpdateState(addedStates) {
-        this.addedStates = addedStates;
-    }
-    Object.defineProperty(UpdateState, "type", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-            return '@@UPDATE_STATE';
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return UpdateState;
-}());
-if (false) {
-    /** @type {?} */
-    UpdateState.prototype.addedStates;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- */
-function NgxsDevelopmentOptions() { }
-if (false) {
-    /** @type {?} */
-    NgxsDevelopmentOptions.prototype.warnOnUnhandledActions;
-}
-/** @type {?} */
-var NGXS_DEVELOPMENT_OPTIONS = new InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {
-    providedIn: 'root',
-    factory: (/**
-     * @return {?}
-     */
-    function () { return ({
-        warnOnUnhandledActions: { ignore: [] }
-    }); })
-});
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var NgxsUnhandledActionsLogger = /** @class */ (function () {
-    function NgxsUnhandledActionsLogger(options) {
-        /**
-         * These actions should be ignored by default; the user can increase this
-         * list in the future via the `ignoreActions` method.
-         */
-        this._ignoredActions = new Set([InitState.type, UpdateState.type]);
-        this.ignoreActions.apply(this, __spread(options.warnOnUnhandledActions.ignore));
-    }
-    /**
-     * Adds actions to the internal list of actions that should be ignored.
-     */
-    /**
-     * Adds actions to the internal list of actions that should be ignored.
-     * @param {...?} actions
-     * @return {?}
-     */
-    NgxsUnhandledActionsLogger.prototype.ignoreActions = /**
-     * Adds actions to the internal list of actions that should be ignored.
-     * @param {...?} actions
-     * @return {?}
-     */
-    function () {
-        var actions = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            actions[_i] = arguments[_i];
-        }
-        var e_1, _a;
-        try {
-            for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
-                var action = actions_1_1.value;
-                this._ignoredActions.add(action.type);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    /** @internal */
-    /**
-     * \@internal
-     * @param {?} action
-     * @return {?}
-     */
-    NgxsUnhandledActionsLogger.prototype.warn = /**
-     * \@internal
-     * @param {?} action
-     * @return {?}
-     */
-    function (action) {
-        /** @type {?} */
-        var actionShouldBeIgnored = Array.from(this._ignoredActions).some((/**
-         * @param {?} type
-         * @return {?}
-         */
-        function (type) { return type === getActionTypeFromInstance(action); }));
-        if (actionShouldBeIgnored) {
-            return;
-        }
-        action =
-            action.constructor && action.constructor.name !== 'Object'
-                ? action.constructor.name
-                : action.type;
-        console.warn("The " + action + " action has been dispatched but hasn't been handled. This may happen if the state with an action handler for this action is not registered.");
-    };
-    NgxsUnhandledActionsLogger.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    NgxsUnhandledActionsLogger.ctorParameters = function () { return [
-        { type: undefined, decorators: [{ type: Inject, args: [NGXS_DEVELOPMENT_OPTIONS,] }] }
-    ]; };
-    return NgxsUnhandledActionsLogger;
-}());
-if (false) {
-    /**
-     * These actions should be ignored by default; the user can increase this
-     * list in the future via the `ignoreActions` method.
-     * @type {?}
-     * @private
-     */
-    NgxsUnhandledActionsLogger.prototype._ignoredActions;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * State factory class
- * @ignore
- */
-var StateFactory = /** @class */ (function () {
-    function StateFactory(_injector, _config, _parentFactory, _actions, _actionResults, _stateContextFactory, _initialState) {
-        var _this = this;
-        this._injector = _injector;
-        this._config = _config;
-        this._parentFactory = _parentFactory;
-        this._actions = _actions;
-        this._actionResults = _actionResults;
-        this._stateContextFactory = _stateContextFactory;
-        this._initialState = _initialState;
-        this._actionsSubscription = null;
-        this._states = [];
-        this._statesByName = {};
-        this._statePaths = {};
-        this.getRuntimeSelectorContext = memoize((/**
-         * @return {?}
-         */
-        function () {
-            /** @type {?} */
-            var stateFactory = _this;
-            /**
-             * @param {?} key
-             * @return {?}
-             */
-            function resolveGetter(key) {
-                /** @type {?} */
-                var path = stateFactory.statePaths[key];
-                return path ? propGetter(path.split('.'), stateFactory._config) : null;
-            }
-            /** @type {?} */
-            var context = _this._parentFactory
-                ? _this._parentFactory.getRuntimeSelectorContext()
-                : {
-                    getStateGetter: /**
-                     * @param {?} key
-                     * @return {?}
-                     */
-                    function (key) {
-                        /** @type {?} */
-                        var getter = resolveGetter(key);
-                        if (getter) {
-                            return getter;
-                        }
-                        return (/**
-                         * @param {...?} args
-                         * @return {?}
-                         */
-                        function () {
-                            var args = [];
-                            for (var _i = 0; _i < arguments.length; _i++) {
-                                args[_i] = arguments[_i];
-                            }
-                            // Late loaded getter
-                            if (!getter) {
-                                getter = resolveGetter(key);
-                            }
-                            return getter ? getter.apply(void 0, __spread(args)) : undefined;
-                        });
-                    },
-                    getSelectorOptions: /**
-                     * @param {?=} localOptions
-                     * @return {?}
-                     */
-                    function (localOptions) {
-                        /** @type {?} */
-                        var globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return __assign({}, globalSelectorOptions, (localOptions || {}));
-                    }
-                };
-            return context;
-        }));
-    }
-    Object.defineProperty(StateFactory.prototype, "states", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            return this._parentFactory ? this._parentFactory.states : this._states;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(StateFactory.prototype, "statesByName", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(StateFactory.prototype, "statePaths", {
-        get: /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * @private
-     * @param {?} defaults
-     * @return {?}
-     */
-    StateFactory.cloneDefaults = /**
-     * @private
-     * @param {?} defaults
-     * @return {?}
-     */
-    function (defaults) {
-        /** @type {?} */
-        var value = {};
-        if (Array.isArray(defaults)) {
-            value = defaults.slice();
-        }
-        else if (isObject(defaults)) {
-            value = __assign({}, defaults);
-        }
-        else if (defaults === undefined) {
-            value = {};
-        }
-        else {
-            value = defaults;
-        }
-        return value;
-    };
-    /**
-     * @return {?}
-     */
-    StateFactory.prototype.ngOnDestroy = /**
-     * @return {?}
-     */
-    function () {
-        // This is being non-null asserted since `_actionsSubscrition` is
-        // initialized within the constructor.
-        (/** @type {?} */ (this._actionsSubscription)).unsubscribe();
-    };
-    /**
-     * Add a new state to the global defs.
-     */
-    /**
-     * Add a new state to the global defs.
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    StateFactory.prototype.add = /**
-     * Add a new state to the global defs.
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    function (stateClasses) {
-        var e_1, _a;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            StoreValidators.checkThatStateClassesHaveBeenDecorated(stateClasses);
-        }
-        var newStates = this.addToStatesMap(stateClasses).newStates;
-        if (!newStates.length)
-            return [];
-        /** @type {?} */
-        var stateGraph = buildGraph(newStates);
-        /** @type {?} */
-        var sortedStates = topologicalSort(stateGraph);
-        /** @type {?} */
-        var paths = findFullParentPath(stateGraph);
-        /** @type {?} */
-        var nameGraph = nameToState(newStates);
-        /** @type {?} */
-        var bootstrappedStores = [];
-        try {
-            for (var sortedStates_1 = __values(sortedStates), sortedStates_1_1 = sortedStates_1.next(); !sortedStates_1_1.done; sortedStates_1_1 = sortedStates_1.next()) {
-                var name_1 = sortedStates_1_1.value;
-                /** @type {?} */
-                var stateClass = nameGraph[name_1];
-                /** @type {?} */
-                var path = paths[name_1];
-                /** @type {?} */
-                var meta = (/** @type {?} */ (stateClass[META_KEY]));
-                this.addRuntimeInfoToMeta(meta, path);
-                // Note: previously we called `ensureStateClassIsInjectable` within the
-                // `State` decorator. This check is moved here because the `ɵprov` property
-                // will not exist on the class in JIT mode (because it's set asynchronously
-                // during JIT compilation through `Object.defineProperty`).
-                if (typeof ngDevMode === 'undefined' || ngDevMode) {
-                    ensureStateClassIsInjectable(stateClass);
-                }
-                /** @type {?} */
-                var stateMap = {
-                    name: name_1,
-                    path: path,
-                    isInitialised: false,
-                    actions: meta.actions,
-                    instance: this._injector.get(stateClass),
-                    defaults: StateFactory.cloneDefaults(meta.defaults)
-                };
-                // ensure our store hasn't already been added
-                // but don't throw since it could be lazy
-                // loaded from different paths
-                if (!this.hasBeenMountedAndBootstrapped(name_1, path)) {
-                    bootstrappedStores.push(stateMap);
-                }
-                this.states.push(stateMap);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (sortedStates_1_1 && !sortedStates_1_1.done && (_a = sortedStates_1.return)) _a.call(sortedStates_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return bootstrappedStores;
-    };
-    /**
-     * Add a set of states to the store and return the defaults
-     */
-    /**
-     * Add a set of states to the store and return the defaults
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    StateFactory.prototype.addAndReturnDefaults = /**
-     * Add a set of states to the store and return the defaults
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    function (stateClasses) {
-        /** @type {?} */
-        var classes = stateClasses || [];
-        /** @type {?} */
-        var mappedStores = this.add(classes);
-        /** @type {?} */
-        var defaults = mappedStores.reduce((/**
-         * @param {?} result
-         * @param {?} mappedStore
-         * @return {?}
-         */
-        function (result, mappedStore) {
-            return setValue(result, mappedStore.path, mappedStore.defaults);
-        }), {});
-        return { defaults: defaults, states: mappedStores };
-    };
-    /**
-     * Bind the actions to the handlers
-     */
-    /**
-     * Bind the actions to the handlers
-     * @return {?}
-     */
-    StateFactory.prototype.connectActionHandlers = /**
-     * Bind the actions to the handlers
-     * @return {?}
-     */
-    function () {
-        var _this = this;
-        if (this._actionsSubscription !== null)
-            return;
-        /** @type {?} */
-        var dispatched$ = new Subject();
-        this._actionsSubscription = this._actions
-            .pipe(filter((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        function (ctx) { return ctx.status === "DISPATCHED" /* Dispatched */; })), mergeMap((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        function (ctx) {
-            dispatched$.next(ctx);
-            /** @type {?} */
-            var action = ctx.action;
-            return _this.invokeActions(dispatched$, (/** @type {?} */ (action))).pipe(map((/**
-             * @return {?}
-             */
-            function () { return (/** @type {?} */ ({ action: action, status: "SUCCESSFUL" /* Successful */ })); })), defaultIfEmpty((/** @type {?} */ ({ action: action, status: "CANCELED" /* Canceled */ }))), catchError((/**
-             * @param {?} error
-             * @return {?}
-             */
-            function (error) {
-                return of((/** @type {?} */ ({ action: action, status: "ERRORED" /* Errored */, error: error })));
-            })));
-        })))
-            .subscribe((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        function (ctx) { return _this._actionResults.next(ctx); }));
-    };
-    /**
-     * Invoke actions on the states.
-     */
-    /**
-     * Invoke actions on the states.
-     * @param {?} dispatched$
-     * @param {?} action
-     * @return {?}
-     */
-    StateFactory.prototype.invokeActions = /**
-     * Invoke actions on the states.
-     * @param {?} dispatched$
-     * @param {?} action
-     * @return {?}
-     */
-    function (dispatched$, action) {
-        var e_2, _a, e_3, _b;
-        /** @type {?} */
-        var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
-        /** @type {?} */
-        var results = [];
-        // Determines whether the dispatched action has been handled, this is assigned
-        // to `true` within the below `for` loop if any `actionMetas` has been found.
-        /** @type {?} */
-        var actionHasBeenHandled = false;
-        try {
-            for (var _c = __values(this.states), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var metadata = _d.value;
-                /** @type {?} */
-                var actionMetas = metadata.actions[type];
-                if (actionMetas) {
-                    try {
-                        for (var actionMetas_1 = __values(actionMetas), actionMetas_1_1 = actionMetas_1.next(); !actionMetas_1_1.done; actionMetas_1_1 = actionMetas_1.next()) {
-                            var actionMeta = actionMetas_1_1.value;
-                            /** @type {?} */
-                            var stateContext = this._stateContextFactory.createStateContext(metadata);
-                            try {
-                                /** @type {?} */
-                                var result = metadata.instance[actionMeta.fn](stateContext, action);
-                                if (result instanceof Promise) {
-                                    result = from(result);
-                                }
-                                if (isObservable(result)) {
-                                    // If this observable has been completed w/o emitting
-                                    // any value then we wouldn't want to complete the whole chain
-                                    // of actions. Since if any observable completes then
-                                    // action will be canceled.
-                                    // For instance if any action handler would've had such statement:
-                                    // `handler(ctx) { return EMPTY; }`
-                                    // then the action will be canceled.
-                                    // See https://github.com/ngxs/store/issues/1568
-                                    result = result.pipe(mergeMap((/**
-                                     * @param {?} value
-                                     * @return {?}
-                                     */
-                                    function (value) {
-                                        if (value instanceof Promise) {
-                                            return from(value);
-                                        }
-                                        if (isObservable(value)) {
-                                            return value;
-                                        }
-                                        return of(value);
-                                    })), defaultIfEmpty({}));
-                                    if (actionMeta.options.cancelUncompleted) {
-                                        // todo: ofActionDispatched should be used with action class
-                                        result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
-                                    }
-                                }
-                                else {
-                                    result = of({}).pipe(shareReplay());
-                                }
-                                results.push(result);
-                            }
-                            catch (e) {
-                                results.push(throwError(e));
-                            }
-                            actionHasBeenHandled = true;
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (actionMetas_1_1 && !actionMetas_1_1.done && (_b = actionMetas_1.return)) _b.call(actionMetas_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
-        // only during development.
-        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !actionHasBeenHandled) {
-            /** @type {?} */
-            var unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);
-            // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
-            // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
-            // didn't return `null` so we may ensure the module has been imported.
-            if (unhandledActionsLogger) {
-                unhandledActionsLogger.warn(action);
-            }
-        }
-        if (!results.length) {
-            results.push(of({}));
-        }
-        return forkJoin(results);
-    };
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    StateFactory.prototype.addToStatesMap = /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    function (stateClasses) {
-        var e_4, _a;
-        /** @type {?} */
-        var newStates = [];
-        /** @type {?} */
-        var statesMap = this.statesByName;
-        try {
-            for (var stateClasses_1 = __values(stateClasses), stateClasses_1_1 = stateClasses_1.next(); !stateClasses_1_1.done; stateClasses_1_1 = stateClasses_1.next()) {
-                var stateClass = stateClasses_1_1.value;
-                /** @type {?} */
-                var stateName = (/** @type {?} */ (getStoreMetadata(stateClass).name));
-                // Caretaker note: we have still left the `typeof` condition in order to avoid
-                // creating a breaking change for projects that still use the View Engine.
-                if (typeof ngDevMode === 'undefined' || ngDevMode) {
-                    StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);
-                }
-                /** @type {?} */
-                var unmountedState = !statesMap[stateName];
-                if (unmountedState) {
-                    newStates.push(stateClass);
-                    statesMap[stateName] = stateClass;
-                }
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (stateClasses_1_1 && !stateClasses_1_1.done && (_a = stateClasses_1.return)) _a.call(stateClasses_1);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-        return { newStates: newStates };
-    };
-    /**
-     * @private
-     * @param {?} meta
-     * @param {?} path
-     * @return {?}
-     */
-    StateFactory.prototype.addRuntimeInfoToMeta = /**
-     * @private
-     * @param {?} meta
-     * @param {?} path
-     * @return {?}
-     */
-    function (meta, path) {
-        this.statePaths[(/** @type {?} */ (meta.name))] = path;
-        // TODO: v4 - we plan to get rid of the path property because it is non-deterministic
-        // we can do this when we get rid of the incorrectly exposed getStoreMetadata
-        // We will need to come up with an alternative in v4 because this is used by many plugins
-        meta.path = path;
-    };
-    /**
-     * @description
-     * the method checks if the state has already been added to the tree
-     * and completed the life cycle
-     * @param name
-     * @param path
-     */
-    /**
-     * \@description
-     * the method checks if the state has already been added to the tree
-     * and completed the life cycle
-     * @private
-     * @param {?} name
-     * @param {?} path
-     * @return {?}
-     */
-    StateFactory.prototype.hasBeenMountedAndBootstrapped = /**
-     * \@description
-     * the method checks if the state has already been added to the tree
-     * and completed the life cycle
-     * @private
-     * @param {?} name
-     * @param {?} path
-     * @return {?}
-     */
-    function (name, path) {
-        /** @type {?} */
-        var valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
-        return this.statesByName[name] && valueIsBootstrappedInInitialState;
-    };
-    StateFactory.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    StateFactory.ctorParameters = function () { return [
-        { type: Injector },
-        { type: NgxsConfig },
-        { type: StateFactory, decorators: [{ type: Optional }, { type: SkipSelf }] },
-        { type: InternalActions },
-        { type: InternalDispatchedActionResults },
-        { type: StateContextFactory },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-    ]; };
-    return StateFactory;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionsSubscription;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._states;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statesByName;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statePaths;
-    /** @type {?} */
-    StateFactory.prototype.getRuntimeSelectorContext;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._injector;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._parentFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actions;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionResults;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._initialState;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-var SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
-/** @type {?} */
-var selectorOptionsMetaAccessor = {
-    getOptions: (/**
-     * @param {?} target
-     * @return {?}
-     */
-    function (target) {
-        return (target && ((/** @type {?} */ (target)))[SELECTOR_OPTIONS_META_KEY]) || {};
-    }),
-    defineOptions: (/**
-     * @param {?} target
-     * @param {?} options
-     * @return {?}
-     */
-    function (target, options) {
-        if (!target)
-            return;
-        ((/** @type {?} */ (target)))[SELECTOR_OPTIONS_META_KEY] = options;
-    })
-};
-/**
- * @record
- */
-function CreationMetadata() { }
-if (false) {
-    /** @type {?} */
-    CreationMetadata.prototype.containerClass;
-    /** @type {?} */
-    CreationMetadata.prototype.selectorName;
-    /** @type {?|undefined} */
-    CreationMetadata.prototype.getSelectorOptions;
-}
-/**
- * @record
- */
-function RuntimeSelectorInfo() { }
-if (false) {
-    /** @type {?} */
-    RuntimeSelectorInfo.prototype.selectorOptions;
-    /** @type {?} */
-    RuntimeSelectorInfo.prototype.argumentSelectorFunctions;
-}
-/**
- * Function for creating a selector
- * @template T
- * @param {?} selectors The selectors to use to create the arguments of this function
- * @param {?} originalFn The original function being made into a selector
- * @param {?=} creationMetadata
- * @return {?}
- */
-function createSelector(selectors, originalFn, creationMetadata) {
-    /** @type {?} */
-    var containerClass = creationMetadata && creationMetadata.containerClass;
-    /** @type {?} */
-    var wrappedFn = (/** @type {?} */ ((/**
-     * @param {...?} args
-     * @return {?}
-     */
-    function wrappedSelectorFn() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        /** @type {?} */
-        var returnValue = originalFn.apply(containerClass, args);
-        if (returnValue instanceof Function) {
-            /** @type {?} */
-            var innerMemoizedFn = memoize.apply(null, [returnValue]);
-            return innerMemoizedFn;
-        }
-        return returnValue;
-    })));
-    /** @type {?} */
-    var memoizedFn = memoize(wrappedFn);
-    Object.setPrototypeOf(memoizedFn, originalFn);
-    /** @type {?} */
-    var selectorMetaData = setupSelectorMetadata(originalFn, creationMetadata);
-    /** @type {?} */
-    var makeRootSelector = (/**
-     * @param {?} context
-     * @return {?}
-     */
-    function (context) {
-        var _a = getRuntimeSelectorInfo(context, selectorMetaData, selectors), argumentSelectorFunctions = _a.argumentSelectorFunctions, selectorOptions = _a.selectorOptions;
-        return (/**
-         * @param {?} rootState
-         * @return {?}
-         */
-        function selectFromRoot(rootState) {
-            // Determine arguments from the app state using the selectors
-            /** @type {?} */
-            var results = argumentSelectorFunctions.map((/**
-             * @param {?} argFn
-             * @return {?}
-             */
-            function (argFn) { return argFn(rootState); }));
-            // if the lambda tries to access a something on the
-            // state that doesn't exist, it will throw a TypeError.
-            // since this is quite usual behaviour, we simply return undefined if so.
-            try {
-                return memoizedFn.apply(void 0, __spread(results));
-            }
-            catch (ex) {
-                if (ex instanceof TypeError && selectorOptions.suppressErrors) {
-                    return undefined;
-                }
-                throw ex;
-            }
-        });
-    });
-    selectorMetaData.makeRootSelector = makeRootSelector;
-    return memoizedFn;
-}
-/**
- * @template T
- * @param {?} originalFn
- * @param {?} creationMetadata
- * @return {?}
- */
-function setupSelectorMetadata(originalFn, creationMetadata) {
-    /** @type {?} */
-    var selectorMetaData = ensureSelectorMetadata(originalFn);
-    selectorMetaData.originalFn = originalFn;
-    /** @type {?} */
-    var getExplicitSelectorOptions = (/**
-     * @return {?}
-     */
-    function () { return ({}); });
-    if (creationMetadata) {
-        selectorMetaData.containerClass = creationMetadata.containerClass;
-        selectorMetaData.selectorName = creationMetadata.selectorName;
-        getExplicitSelectorOptions =
-            creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
-    }
-    /** @type {?} */
-    var selectorMetaDataClone = __assign({}, selectorMetaData);
-    selectorMetaData.getSelectorOptions = (/**
-     * @return {?}
-     */
-    function () {
-        return getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());
-    });
-    return selectorMetaData;
-}
-/**
- * @param {?} context
- * @param {?} selectorMetaData
- * @param {?=} selectors
- * @return {?}
- */
-function getRuntimeSelectorInfo(context, selectorMetaData, selectors) {
-    if (selectors === void 0) { selectors = []; }
-    /** @type {?} */
-    var localSelectorOptions = selectorMetaData.getSelectorOptions();
-    /** @type {?} */
-    var selectorOptions = context.getSelectorOptions(localSelectorOptions);
-    /** @type {?} */
-    var selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
-    /** @type {?} */
-    var argumentSelectorFunctions = selectorsToApply.map((/**
-     * @param {?} selector
-     * @return {?}
-     */
-    function (selector) {
-        /** @type {?} */
-        var factory = getRootSelectorFactory(selector);
-        return factory(context);
-    }));
-    return {
-        selectorOptions: selectorOptions,
-        argumentSelectorFunctions: argumentSelectorFunctions
-    };
-}
-/**
- * @param {?} selectorMetaData
- * @param {?} explicitOptions
- * @return {?}
- */
-function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
-    return __assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}), (selectorMetaData.getSelectorOptions() || {}), explicitOptions);
-}
-/**
- * @param {?=} selectors
- * @param {?=} selectorOptions
- * @param {?=} containerClass
- * @return {?}
- */
-function getSelectorsToApply(selectors, selectorOptions, containerClass) {
-    if (selectors === void 0) { selectors = []; }
-    /** @type {?} */
-    var selectorsToApply = [];
-    /** @type {?} */
-    var canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;
-    if (containerClass && canInjectContainerState) {
-        // If we are on a state class, add it as the first selector parameter
-        /** @type {?} */
-        var metadata = getStoreMetadata(containerClass);
-        if (metadata) {
-            selectorsToApply.push(containerClass);
-        }
-    }
-    if (selectors) {
-        selectorsToApply.push.apply(selectorsToApply, __spread(selectors));
-    }
-    return selectorsToApply;
-}
-/**
- * This function gets the factory function to create the selector to get the selected slice from the app state
- * @ignore
- * @param {?} selector
- * @return {?}
- */
-function getRootSelectorFactory(selector) {
-    /** @type {?} */
-    var metadata = getSelectorMetadata(selector) || getStoreMetadata(selector);
-    return (metadata && metadata.makeRootSelector) || ((/**
-     * @return {?}
-     */
-    function () { return selector; }));
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var Store = /** @class */ (function () {
-    function Store(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
-        this._stateStream = _stateStream;
-        this._internalStateOperations = _internalStateOperations;
-        this._config = _config;
-        this._internalExecutionStrategy = _internalExecutionStrategy;
-        this._stateFactory = _stateFactory;
-        /**
-         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-         */
-        this._selectableStateStream = this._stateStream.pipe(observeOn(queueScheduler), leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
-        this.initStateStream(initialStateValue);
-    }
-    /**
-     * Dispatches event(s).
-     */
-    /**
-     * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    Store.prototype.dispatch = /**
-     * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    function (actionOrActions) {
-        return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
-    };
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    Store.prototype.select = /**
-     * @param {?} selector
-     * @return {?}
-     */
-    function (selector) {
-        var _this = this;
-        /** @type {?} */
-        var selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
-         * @param {?} err
-         * @return {?}
-         */
-        function (err) {
-            // if error is TypeError we swallow it to prevent usual errors with property access
-            var suppressErrors = _this._config.selectorOptions.suppressErrors;
-            if (err instanceof TypeError && suppressErrors) {
-                return of(undefined);
-            }
-            // rethrow other errors
-            return throwError(err);
-        })), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
-    };
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    Store.prototype.selectOnce = /**
-     * @param {?} selector
-     * @return {?}
-     */
-    function (selector) {
-        return this.select(selector).pipe(take(1));
-    };
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    Store.prototype.selectSnapshot = /**
-     * @param {?} selector
-     * @return {?}
-     */
-    function (selector) {
-        /** @type {?} */
-        var selectorFn = this.getStoreBoundSelectorFn(selector);
-        return selectorFn(this._stateStream.getValue());
-    };
-    /**
-     * Allow the user to subscribe to the root of the state
-     */
-    /**
-     * Allow the user to subscribe to the root of the state
-     * @param {?=} fn
-     * @return {?}
-     */
-    Store.prototype.subscribe = /**
-     * Allow the user to subscribe to the root of the state
-     * @param {?=} fn
-     * @return {?}
-     */
-    function (fn) {
-        return this._selectableStateStream
-            .pipe(leaveNgxs(this._internalExecutionStrategy))
-            .subscribe(fn);
-    };
-    /**
-     * Return the raw value of the state.
-     */
-    /**
-     * Return the raw value of the state.
-     * @return {?}
-     */
-    Store.prototype.snapshot = /**
-     * Return the raw value of the state.
-     * @return {?}
-     */
-    function () {
-        return this._internalStateOperations.getRootStateOperations().getState();
-    };
-    /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     */
-    /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     * @param {?} state
-     * @return {?}
-     */
-    Store.prototype.reset = /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     * @param {?} state
-     * @return {?}
-     */
-    function (state) {
-        return this._internalStateOperations.getRootStateOperations().setState(state);
-    };
-    /**
-     * @private
-     * @param {?} selector
-     * @return {?}
-     */
-    Store.prototype.getStoreBoundSelectorFn = /**
-     * @private
-     * @param {?} selector
-     * @return {?}
-     */
-    function (selector) {
-        /** @type {?} */
-        var makeSelectorFn = getRootSelectorFactory(selector);
-        /** @type {?} */
-        var runtimeContext = this._stateFactory.getRuntimeSelectorContext();
-        return makeSelectorFn(runtimeContext);
-    };
-    /**
-     * @private
-     * @param {?} initialStateValue
-     * @return {?}
-     */
-    Store.prototype.initStateStream = /**
-     * @private
-     * @param {?} initialStateValue
-     * @return {?}
-     */
-    function (initialStateValue) {
-        /** @type {?} */
-        var value = this._stateStream.value;
-        /** @type {?} */
-        var storeIsEmpty = !value || Object.keys(value).length === 0;
-        if (storeIsEmpty) {
-            /** @type {?} */
-            var defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;
-            /** @type {?} */
-            var storeValues = defaultStateNotEmpty
-                ? __assign({}, this._config.defaultsState, initialStateValue) : initialStateValue;
-            this._stateStream.next(storeValues);
-        }
-    };
-    Store.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    Store.ctorParameters = function () { return [
-        { type: StateStream },
-        { type: InternalStateOperations },
-        { type: NgxsConfig },
-        { type: InternalNgxsExecutionStrategy },
-        { type: StateFactory },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-    ]; };
-    return Store;
-}());
-if (false) {
-    /**
-     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-     * @type {?}
-     * @private
-     */
-    Store.prototype._selectableStateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalExecutionStrategy;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateFactory;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var LifecycleStateManager = /** @class */ (function () {
-    function LifecycleStateManager(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
-        this._store = _store;
-        this._internalErrorReporter = _internalErrorReporter;
-        this._internalStateOperations = _internalStateOperations;
-        this._stateContextFactory = _stateContextFactory;
-        this._bootstrapper = _bootstrapper;
-        this._destroy$ = new Subject();
-    }
-    /**
-     * @return {?}
-     */
-    LifecycleStateManager.prototype.ngOnDestroy = /**
-     * @return {?}
-     */
-    function () {
-        this._destroy$.next();
-    };
-    /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    LifecycleStateManager.prototype.ngxsBootstrap = /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    function (action, results) {
-        var _this = this;
-        this._internalStateOperations
-            .getRootStateOperations()
-            .dispatch(action)
-            .pipe(filter((/**
-         * @return {?}
-         */
-        function () { return !!results; })), tap((/**
-         * @return {?}
-         */
-        function () { return _this._invokeInitOnStates((/** @type {?} */ (results)).states); })), mergeMap((/**
-         * @return {?}
-         */
-        function () { return _this._bootstrapper.appBootstrapped$; })), filter((/**
-         * @param {?} appBootstrapped
-         * @return {?}
-         */
-        function (appBootstrapped) { return !!appBootstrapped; })), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        function (error) {
-            // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
-            // errors asynchronously (`setTimeout(() => { throw error })`). This might
-            // break existing user's code or unit tests. We catch the error manually to
-            // be backward compatible with the old behavior.
-            _this._internalErrorReporter.reportErrorSafely(error);
-            return EMPTY;
-        })), takeUntil(this._destroy$))
-            .subscribe((/**
-         * @return {?}
-         */
-        function () { return _this._invokeBootstrapOnStates((/** @type {?} */ (results)).states); }));
-    };
-    /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    LifecycleStateManager.prototype._invokeInitOnStates = /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    function (mappedStores) {
-        var e_1, _a;
-        var _loop_1 = function (mappedStore) {
-            /** @type {?} */
-            var instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                this_1._store
-                    .select((/**
-                 * @param {?} state
-                 * @return {?}
-                 */
-                function (state) { return getValue(state, mappedStore.path); }))
-                    .pipe(startWith(undefined), pairwise(), takeUntil(this_1._destroy$))
-                    .subscribe((/**
-                 * @param {?} __0
-                 * @return {?}
-                 */
-                function (_a) {
-                    var _b = __read(_a, 2), previousValue = _b[0], currentValue = _b[1];
-                    /** @type {?} */
-                    var change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
-                    (/** @type {?} */ (instance.ngxsOnChanges))(change);
-                }));
-            }
-            if (instance.ngxsOnInit) {
-                instance.ngxsOnInit(this_1._getStateContext(mappedStore));
-            }
-            mappedStore.isInitialised = true;
-        };
-        var this_1 = this;
-        try {
-            for (var mappedStores_1 = __values(mappedStores), mappedStores_1_1 = mappedStores_1.next(); !mappedStores_1_1.done; mappedStores_1_1 = mappedStores_1.next()) {
-                var mappedStore = mappedStores_1_1.value;
-                _loop_1(mappedStore);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (mappedStores_1_1 && !mappedStores_1_1.done && (_a = mappedStores_1.return)) _a.call(mappedStores_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    LifecycleStateManager.prototype._invokeBootstrapOnStates = /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    function (mappedStores) {
-        var e_2, _a;
-        try {
-            for (var mappedStores_2 = __values(mappedStores), mappedStores_2_1 = mappedStores_2.next(); !mappedStores_2_1.done; mappedStores_2_1 = mappedStores_2.next()) {
-                var mappedStore = mappedStores_2_1.value;
-                /** @type {?} */
-                var instance = mappedStore.instance;
-                if (instance.ngxsAfterBootstrap) {
-                    instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (mappedStores_2_1 && !mappedStores_2_1.done && (_a = mappedStores_2.return)) _a.call(mappedStores_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    };
-    /**
-     * @private
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    LifecycleStateManager.prototype._getStateContext = /**
-     * @private
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    function (mappedStore) {
-        return this._stateContextFactory.createStateContext(mappedStore);
-    };
-    LifecycleStateManager.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    LifecycleStateManager.ctorParameters = function () { return [
-        { type: Store },
-        { type: InternalErrorReporter },
-        { type: InternalStateOperations },
-        { type: StateContextFactory },
-        { type: NgxsBootstrapper }
-    ]; };
-    return LifecycleStateManager;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._destroy$;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._store;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._internalErrorReporter;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._bootstrapper;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Allows the select decorator to get access to the DI store, this is used internally
- * in `\@Select` decorator.
- */
-var SelectFactory = /** @class */ (function () {
-    function SelectFactory(store, config) {
-        SelectFactory.store = store;
-        SelectFactory.config = config;
-    }
-    /**
-     * @return {?}
-     */
-    SelectFactory.prototype.ngOnDestroy = /**
-     * @return {?}
-     */
-    function () {
-        SelectFactory.store = null;
-        SelectFactory.config = null;
-    };
-    SelectFactory.store = null;
-    SelectFactory.config = null;
-    SelectFactory.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    SelectFactory.ctorParameters = function () { return [
-        { type: Store },
-        { type: NgxsConfig }
-    ]; };
-    return SelectFactory;
-}());
-if (false) {
-    /** @type {?} */
-    SelectFactory.store;
-    /** @type {?} */
-    SelectFactory.config;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Root module
- * @ignore
- */
-var NgxsRootModule = /** @class */ (function () {
-    function NgxsRootModule(factory, internalStateOperations, _store, _select, states, lifecycleStateManager) {
-        if (states === void 0) { states = []; }
-        // Add stores to the state graph and return their defaults
-        /** @type {?} */
-        var results = factory.addAndReturnDefaults(states);
-        internalStateOperations.setStateToTheCurrentWithNew(results);
-        // Connect our actions stream
-        factory.connectActionHandlers();
-        // Dispatch the init action and invoke init and bootstrap functions after
-        lifecycleStateManager.ngxsBootstrap(new InitState(), results);
-    }
-    NgxsRootModule.decorators = [
-        { type: NgModule }
-    ];
-    /** @nocollapse */
-    NgxsRootModule.ctorParameters = function () { return [
-        { type: StateFactory },
-        { type: InternalStateOperations },
-        { type: Store },
-        { type: SelectFactory },
-        { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [ROOT_STATE_TOKEN,] }] },
-        { type: LifecycleStateManager }
-    ]; };
-    return NgxsRootModule;
-}());
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Feature module
- * @ignore
- */
-var NgxsFeatureModule = /** @class */ (function () {
-    function NgxsFeatureModule(_store, internalStateOperations, factory, states, lifecycleStateManager) {
-        if (states === void 0) { states = []; }
-        // Since FEATURE_STATE_TOKEN is a multi token, we need to
-        // flatten it [[Feature1State, Feature2State], [Feature3State]]
-        /** @type {?} */
-        var flattenedStates = NgxsFeatureModule.flattenStates(states);
-        // add stores to the state graph and return their defaults
-        /** @type {?} */
-        var results = factory.addAndReturnDefaults(flattenedStates);
-        if (results.states.length) {
-            internalStateOperations.setStateToTheCurrentWithNew(results);
-            // dispatch the update action and invoke init and bootstrap functions after
-            lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);
-        }
-    }
-    /**
-     * @private
-     * @param {?=} states
-     * @return {?}
-     */
-    NgxsFeatureModule.flattenStates = /**
-     * @private
-     * @param {?=} states
-     * @return {?}
-     */
-    function (states) {
-        if (states === void 0) { states = []; }
-        return states.reduce((/**
-         * @param {?} total
-         * @param {?} values
-         * @return {?}
-         */
-        function (total, values) { return total.concat(values); }), []);
-    };
-    NgxsFeatureModule.decorators = [
-        { type: NgModule }
-    ];
-    /** @nocollapse */
-    NgxsFeatureModule.ctorParameters = function () { return [
-        { type: Store },
-        { type: InternalStateOperations },
-        { type: StateFactory },
-        { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [FEATURE_STATE_TOKEN,] }] },
-        { type: LifecycleStateManager }
-    ]; };
-    return NgxsFeatureModule;
-}());
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Ngxs Module
- */
-var NgxsModule = /** @class */ (function () {
-    function NgxsModule() {
-    }
-    /**
-     * Root module factory
-     */
-    /**
-     * Root module factory
-     * @param {?=} states
-     * @param {?=} options
-     * @return {?}
-     */
-    NgxsModule.forRoot = /**
-     * Root module factory
-     * @param {?=} states
-     * @param {?=} options
-     * @return {?}
-     */
-    function (states, options) {
-        if (states === void 0) { states = []; }
-        if (options === void 0) { options = {}; }
-        return {
-            ngModule: NgxsRootModule,
-            providers: __spread([
-                StateFactory,
-                StateContextFactory,
-                Actions,
-                InternalActions,
-                NgxsBootstrapper,
-                LifecycleStateManager,
-                InternalDispatcher,
-                InternalDispatchedActionResults,
-                InternalStateOperations,
-                InternalNgxsExecutionStrategy,
-                Store,
-                StateStream,
-                SelectFactory,
-                PluginManager
-            ], states, NgxsModule.ngxsTokenProviders(states, options))
-        };
-    };
-    /**
-     * Feature module factory
-     */
-    /**
-     * Feature module factory
-     * @param {?=} states
-     * @return {?}
-     */
-    NgxsModule.forFeature = /**
-     * Feature module factory
-     * @param {?=} states
-     * @return {?}
-     */
-    function (states) {
-        if (states === void 0) { states = []; }
-        return {
-            ngModule: NgxsFeatureModule,
-            providers: __spread([
-                StateFactory,
-                PluginManager
-            ], states, [
-                {
-                    provide: FEATURE_STATE_TOKEN,
-                    multi: true,
-                    useValue: states
-                }
-            ])
-        };
-    };
-    /**
-     * @private
-     * @param {?} states
-     * @param {?} options
-     * @return {?}
-     */
-    NgxsModule.ngxsTokenProviders = /**
-     * @private
-     * @param {?} states
-     * @param {?} options
-     * @return {?}
-     */
-    function (states, options) {
-        return [
-            {
-                provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
-                useValue: options.executionStrategy
-            },
-            {
-                provide: ROOT_STATE_TOKEN,
-                useValue: states
-            },
-            {
-                provide: NgxsModule.ROOT_OPTIONS,
-                useValue: options
-            },
-            {
-                provide: NgxsConfig,
-                useFactory: NgxsModule.ngxsConfigFactory,
-                deps: [NgxsModule.ROOT_OPTIONS]
-            },
-            {
-                provide: APP_BOOTSTRAP_LISTENER,
-                useFactory: NgxsModule.appBootstrapListenerFactory,
-                multi: true,
-                deps: [NgxsBootstrapper]
-            },
-            {
-                provide: INITIAL_STATE_TOKEN,
-                useFactory: NgxsModule.getInitialState
-            },
-            {
-                provide: NGXS_STATE_CONTEXT_FACTORY,
-                useExisting: StateContextFactory
-            },
-            {
-                provide: NGXS_STATE_FACTORY,
-                useExisting: StateFactory
-            }
-        ];
-    };
-    /**
-     * @private
-     * @param {?} options
-     * @return {?}
-     */
-    NgxsModule.ngxsConfigFactory = /**
-     * @private
-     * @param {?} options
-     * @return {?}
-     */
-    function (options) {
-        return mergeDeep(new NgxsConfig(), options);
-    };
-    /**
-     * @private
-     * @param {?} bootstrapper
-     * @return {?}
-     */
-    NgxsModule.appBootstrapListenerFactory = /**
-     * @private
-     * @param {?} bootstrapper
-     * @return {?}
-     */
-    function (bootstrapper) {
-        return (/**
-         * @return {?}
-         */
-        function () { return bootstrapper.bootstrap(); });
-    };
-    /**
-     * @private
-     * @return {?}
-     */
-    NgxsModule.getInitialState = /**
-     * @private
-     * @return {?}
-     */
-    function () {
-        return InitialState.pop();
-    };
-    NgxsModule.ROOT_OPTIONS = new InjectionToken('ROOT_OPTIONS');
-    NgxsModule.decorators = [
-        { type: NgModule }
-    ];
-    return NgxsModule;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    NgxsModule.ROOT_OPTIONS;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Decorates a method with a action information.
- * @param {?} actions
- * @param {?=} options
- * @return {?}
- */
-function Action(actions, options) {
-    return (/**
-     * @param {?} target
-     * @param {?} name
-     * @return {?}
-     */
-    function (target, name) {
-        var e_1, _a;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
-            var isStaticMethod = target.hasOwnProperty('prototype');
-            if (isStaticMethod) {
-                throwActionDecoratorError();
-            }
-        }
-        /** @type {?} */
-        var meta = ensureStoreMetadata(target.constructor);
-        if (!Array.isArray(actions)) {
-            actions = [actions];
-        }
-        try {
-            for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
-                var action = actions_1_1.value;
-                /** @type {?} */
-                var type = action.type;
-                if (!meta.actions[type]) {
-                    meta.actions[type] = [];
-                }
-                meta.actions[type].push({
-                    fn: name,
-                    options: options || {},
-                    type: type
-                });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T
- */
-function MutateMetaOptions() { }
-if (false) {
-    /** @type {?} */
-    MutateMetaOptions.prototype.meta;
-    /** @type {?} */
-    MutateMetaOptions.prototype.inheritedStateClass;
-    /** @type {?} */
-    MutateMetaOptions.prototype.optionsWithInheritance;
-}
-/**
- * Decorates a class with ngxs state information.
- * @template T
- * @param {?} options
- * @return {?}
- */
-function State(options) {
-    /**
-     * @param {?} inheritedStateClass
-     * @return {?}
-     */
-    function getStateOptions(inheritedStateClass) {
-        /** @type {?} */
-        var inheritanceOptions = inheritedStateClass[META_OPTIONS_KEY] || {};
-        return (/** @type {?} */ (__assign({}, inheritanceOptions, options)));
-    }
-    /**
-     * @param {?} params
-     * @return {?}
-     */
-    function mutateMetaData(params) {
-        var meta = params.meta, inheritedStateClass = params.inheritedStateClass, optionsWithInheritance = params.optionsWithInheritance;
-        var children = optionsWithInheritance.children, defaults = optionsWithInheritance.defaults, name = optionsWithInheritance.name;
-        /** @type {?} */
-        var stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            StoreValidators.checkThatStateIsNamedCorrectly(stateName);
-        }
-        if (inheritedStateClass.hasOwnProperty(META_KEY)) {
-            /** @type {?} */
-            var inheritedMeta = inheritedStateClass[META_KEY] || {};
-            meta.actions = __assign({}, meta.actions, inheritedMeta.actions);
-        }
-        meta.children = children;
-        meta.defaults = defaults;
-        meta.name = stateName;
-    }
-    return (/**
-     * @param {?} target
-     * @return {?}
-     */
-    function (target) {
-        /** @type {?} */
-        var stateClass = target;
-        /** @type {?} */
-        var meta = ensureStoreMetadata(stateClass);
-        /** @type {?} */
-        var inheritedStateClass = Object.getPrototypeOf(stateClass);
-        /** @type {?} */
-        var optionsWithInheritance = getStateOptions(inheritedStateClass);
-        mutateMetaData({ meta: meta, inheritedStateClass: inheritedStateClass, optionsWithInheritance: optionsWithInheritance });
-        stateClass[META_OPTIONS_KEY] = optionsWithInheritance;
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-var DOLLAR_CHAR_CODE = 36;
-/**
- * @template T
- * @param {?} selector
- * @return {?}
- */
-function createSelectObservable(selector) {
-    if (!SelectFactory.store) {
-        throwSelectFactoryNotConnectedError();
-    }
-    return (/** @type {?} */ (SelectFactory.store)).select(selector);
-}
-/**
- * @param {?} name
- * @param {?=} rawSelector
- * @param {?=} paths
- * @return {?}
- */
-function createSelectorFn(name, rawSelector, paths) {
-    if (paths === void 0) { paths = []; }
-    rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
-    if (typeof rawSelector === 'string') {
-        /** @type {?} */
-        var propsArray = paths.length
-            ? __spread([rawSelector], paths) : rawSelector.split('.');
-        return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
-    }
-    return rawSelector;
-}
-/**
- * \@example If `foo$` => make it just `foo`
- * @param {?} name
- * @return {?}
- */
-function removeDollarAtTheEnd(name) {
-    /** @type {?} */
-    var lastCharIndex = name.length - 1;
-    /** @type {?} */
-    var dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;
-    return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Decorator for selecting a slice of state from the store.
- * @template T
- * @param {?=} rawSelector
- * @param {...?} paths
- * @return {?}
- */
-function Select(rawSelector) {
-    var paths = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        paths[_i - 1] = arguments[_i];
-    }
-    return (/**
-     * @param {?} target
-     * @param {?} key
-     * @return {?}
-     */
-    function (target, key) {
-        var _a;
-        /** @type {?} */
-        var name = key.toString();
-        /** @type {?} */
-        var selectorId = "__" + name + "__selector";
-        /** @type {?} */
-        var selector = createSelectorFn(name, rawSelector, paths);
-        Object.defineProperties(target, (_a = {},
-            _a[selectorId] = {
-                writable: true,
-                enumerable: false,
-                configurable: true
-            },
-            _a[name] = {
-                enumerable: true,
-                configurable: true,
-                get: /**
-                 * @return {?}
-                 */
-                function () {
-                    return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
-                }
-            },
-            _a));
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Decorator for setting selector options at a method or class level.
- * @param {?} options
- * @return {?}
- */
-function SelectorOptions(options) {
-    return (/** @type {?} */ (((/**
-     * @template T
-     * @param {?} target
-     * @param {?} methodName
-     * @param {?} descriptor
-     * @return {?}
-     */
-    function decorate(target, methodName, descriptor) {
-        if (methodName) {
-            // Method Decorator
-            /** @type {?} */
-            var originalFn = descriptor.value || ((/** @type {?} */ (descriptor))).originalFn;
-            if (originalFn) {
-                selectorOptionsMetaAccessor.defineOptions(originalFn, options);
-            }
-        }
-        else {
-            // Class Decorator
-            selectorOptionsMetaAccessor.defineOptions(target, options);
-        }
-    }))));
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- */
-function MetaDataModel$1() { }
-if (false) {
-    /** @type {?} */
-    MetaDataModel$1.prototype.name;
-    /** @type {?} */
-    MetaDataModel$1.prototype.actions;
-    /** @type {?} */
-    MetaDataModel$1.prototype.defaults;
-    /** @type {?} */
-    MetaDataModel$1.prototype.path;
-    /** @type {?|undefined} */
-    MetaDataModel$1.prototype.children;
-}
-/**
- * @record
- */
-function SelectorMetaDataModel$1() { }
-if (false) {
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.originalFn;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.containerClass;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.selectorName;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.getSelectorOptions;
-}
-/**
- * @param {?} target
- * @return {?}
- */
-function ensureStoreMetadata$1(target) {
-    return ensureStoreMetadata(target);
-}
-/**
- * @param {?} target
- * @return {?}
- */
-function getStoreMetadata$1(target) {
-    return getStoreMetadata(target);
-}
-/**
- * @param {?} target
- * @return {?}
- */
-function ensureSelectorMetadata$1(target) {
-    return ensureSelectorMetadata(target);
-}
-/**
- * @param {?} target
- * @return {?}
- */
-function getSelectorMetadata$1(target) {
-    return getSelectorMetadata(target);
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Decorator for memoizing a state selector.
- * @template T
- * @param {?=} selectors
- * @return {?}
- */
-function Selector(selectors) {
-    return (/**
-     * @template U
-     * @param {?} target
-     * @param {?} key
-     * @param {?} descriptor
-     * @return {?}
-     */
-    function (target, key, descriptor) {
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
-            var isNotMethod = !(descriptor && descriptor.value !== null);
-            if (isNotMethod) {
-                throwSelectorDecoratorError();
-            }
-        }
-        /** @type {?} */
-        var originalFn = descriptor.value;
-        /** @type {?} */
-        var memoizedFn = createSelector(selectors, (/** @type {?} */ (originalFn)), {
-            containerClass: target,
-            selectorName: key.toString(),
-            getSelectorOptions: /**
-             * @return {?}
-             */
-            function () {
-                return {};
-            }
-        });
-        /** @type {?} */
-        var newDescriptor = {
-            configurable: true,
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return memoizedFn;
-            }
-        };
-        // Add hidden property to descriptor
-        ((/** @type {?} */ (newDescriptor)))['originalFn'] = originalFn;
-        return newDescriptor;
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
-var  /**
- * @template T
- */
-StateToken = /** @class */ (function () {
-    function StateToken(name) {
-        var _this = this;
-        this.name = name;
-        /** @type {?} */
-        var selectorMetadata = ensureSelectorMetadata((/** @type {?} */ (this)));
-        selectorMetadata.makeRootSelector = (/**
-         * @param {?} runtimeContext
-         * @return {?}
-         */
-        function (runtimeContext) {
-            return runtimeContext.getStateGetter(_this.name);
-        });
-    }
-    /**
-     * @return {?}
-     */
-    StateToken.prototype.getName = /**
-     * @return {?}
-     */
-    function () {
-        return this.name;
-    };
-    /**
-     * @return {?}
-     */
-    StateToken.prototype.toString = /**
-     * @return {?}
-     */
-    function () {
-        return "StateToken[" + this.name + "]";
-    };
-    return StateToken;
-}());
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateToken.prototype.name;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var NgxsDevelopmentModule = /** @class */ (function () {
-    function NgxsDevelopmentModule() {
-    }
-    /**
-     * @param {?} options
-     * @return {?}
-     */
-    NgxsDevelopmentModule.forRoot = /**
-     * @param {?} options
-     * @return {?}
-     */
-    function (options) {
-        return {
-            ngModule: NgxsDevelopmentModule,
-            providers: [
-                NgxsUnhandledActionsLogger,
-                { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
-            ]
-        };
-    };
-    NgxsDevelopmentModule.decorators = [
-        { type: NgModule }
-    ];
-    return NgxsDevelopmentModule;
-}());
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, NgxsFeatureModule as ɵba, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NGXS_DEVELOPMENT_OPTIONS as ɵj, NgxsRootModule as ɵk, StateFactory as ɵl, InternalDispatchedActionResults as ɵm, InternalDispatcher as ɵn, StateContextFactory as ɵo, InternalStateOperations as ɵp, PluginManager as ɵq, InternalNgxsExecutionStrategy as ɵr, InternalErrorReporter as ɵs, SelectFactory as ɵt, ensureStoreMetadata as ɵv, getStoreMetadata as ɵw, ensureSelectorMetadata as ɵx, getSelectorMetadata as ɵy, LifecycleStateManager as ɵz };
-//# sourceMappingURL=ngxs-store.js.map