{"version":3,"sources":["node_modules/@ngxs/store/fesm2015/ngxs-store-internals.js","node_modules/@ngxs/store/fesm2015/ngxs-store-operators.js","node_modules/@ngxs/store/fesm2015/ngxs-store.js","src/app/shared/helpers/error-handler.ts"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { Injectable, InjectionToken } from '@angular/core';\nimport { ReplaySubject } from 'rxjs';\nlet NgxsBootstrapper = /*#__PURE__*/(() => {\n  class NgxsBootstrapper {\n    constructor() {\n      /**\n       * Use `ReplaySubject`, thus we can get cached value even if the stream is completed\n       */\n      this.bootstrap$ = new ReplaySubject(1);\n    }\n    get appBootstrapped$() {\n      return this.bootstrap$.asObservable();\n    }\n    /**\n     * This event will be emitted after attaching `ComponentRef` of the root component\n     * to the tree of views, that's a signal that application has been fully rendered\n     */\n    bootstrap() {\n      this.bootstrap$.next(true);\n      this.bootstrap$.complete();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */NgxsBootstrapper.ɵfac = function NgxsBootstrapper_Factory(t) {\n    return new (t || NgxsBootstrapper)();\n  };\n  NgxsBootstrapper.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: NgxsBootstrapper,\n    factory: NgxsBootstrapper.ɵfac,\n    providedIn: 'root'\n  });\n  return NgxsBootstrapper;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction defaultEqualityCheck(a, b) {\n  return a === b;\n}\nfunction areArgumentsShallowlyEqual(equalityCheck, prev, next) {\n  if (prev === null || next === null || prev.length !== next.length) {\n    return false;\n  }\n  // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n  const length = prev.length;\n  for (let i = 0; i < length; i++) {\n    if (!equalityCheck(prev[i], next[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n/**\n * Memoize a function on its last inputs only.\n * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js\n *\n * @ignore\n */\nfunction memoize(func, equalityCheck = defaultEqualityCheck) {\n  let lastArgs = null;\n  let lastResult = null;\n  // we reference arguments instead of spreading them for performance reasons\n  function memoized() {\n    // eslint-disable-next-line prefer-rest-params\n    if (!areArgumentsShallowlyEqual(equalityCheck, lastArgs, arguments)) {\n      // apply arguments instead of spreading for performance.\n      // eslint-disable-next-line prefer-rest-params, prefer-spread\n      lastResult = func.apply(null, arguments);\n    }\n    // eslint-disable-next-line prefer-rest-params\n    lastArgs = arguments;\n    return lastResult;\n  }\n  memoized.reset = function () {\n    // The hidden (for now) ability to reset the memoization\n    lastArgs = null;\n    lastResult = null;\n  };\n  return memoized;\n}\nlet InitialState = /*#__PURE__*/(() => {\n  class InitialState {\n    static set(state) {\n      this._value = state;\n    }\n    static pop() {\n      const state = this._value;\n      this._value = {};\n      return state;\n    }\n  }\n  InitialState._value = {};\n  return InitialState;\n})();\nconst INITIAL_STATE_TOKEN = new InjectionToken('INITIAL_STATE_TOKEN', {\n  providedIn: 'root',\n  factory: () => InitialState.pop()\n});\n\n// These tokens are internal and can change at any point.\nconst ɵNGXS_STATE_FACTORY = new InjectionToken('ɵNGXS_STATE_FACTORY');\nconst ɵNGXS_STATE_CONTEXT_FACTORY = new InjectionToken('ɵNGXS_STATE_CONTEXT_FACTORY');\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { INITIAL_STATE_TOKEN, InitialState, NgxsBootstrapper, memoize, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY };\n","/**\n * @param items - Specific items to append to the end of an array\n */\nfunction append(items) {\n  return function appendOperator(existing) {\n    // If `items` is `undefined` or `null` or `[]` but `existing` is provided\n    // just return `existing`\n    const itemsNotProvidedButExistingIs = (!items || !items.length) && existing;\n    if (itemsNotProvidedButExistingIs) {\n      return existing;\n    }\n    if (Array.isArray(existing)) {\n      return existing.concat(items);\n    }\n    // For example if some property is added dynamically\n    // and didn't exist before thus it's not `ArrayLike`\n    return items;\n  };\n}\nfunction compose(...operators) {\n  return function composeOperator(existing) {\n    return operators.reduce((accumulator, operator) => operator(accumulator), existing);\n  };\n}\nfunction isStateOperator(value) {\n  return typeof value === 'function';\n}\nfunction isUndefined(value) {\n  return typeof value === 'undefined';\n}\nfunction isPredicate(value) {\n  return typeof value === 'function';\n}\nfunction isNumber(value) {\n  return typeof value === 'number';\n}\nfunction invalidIndex(index) {\n  return Number.isNaN(index) || index === -1;\n}\nfunction isNil(value) {\n  return value === null || isUndefined(value);\n}\nfunction retrieveValue(operatorOrValue, existing) {\n  // If state operator is a function\n  // then call it with an original value\n  if (isStateOperator(operatorOrValue)) {\n    const value = operatorOrValue(existing);\n    return value;\n  }\n  // If operator or value was not provided\n  // e.g. `elseOperatorOrValue` is `undefined`\n  // then we just return an original value\n  if (isUndefined(operatorOrValue)) {\n    return existing;\n  }\n  return operatorOrValue;\n}\n/**\n * @param condition - Condition can be a plain boolean value or a function,\n * that returns boolean, also this function can take a value as an argument\n * to which this state operator applies\n * @param trueOperatorOrValue - Any value or a state operator\n * @param elseOperatorOrValue - Any value or a state operator\n */\nfunction iif(condition, trueOperatorOrValue, elseOperatorOrValue) {\n  return function iifOperator(existing) {\n    // Convert the value to a boolean\n    let result = !!condition;\n    // but if it is a function then run it to get the result\n    if (isPredicate(condition)) {\n      result = condition(existing);\n    }\n    if (result) {\n      return retrieveValue(trueOperatorOrValue, existing);\n    }\n    return retrieveValue(elseOperatorOrValue, existing);\n  };\n}\n\n/**\n * @param value - Value to insert\n * @param [beforePosition] -  Specified index to insert value before, optional\n */\nfunction insertItem(value, beforePosition) {\n  return function insertItemOperator(existing) {\n    // Have to check explicitly for `null` and `undefined`\n    // because `value` can be `0`, thus `!value` will return `true`\n    if (isNil(value) && existing) {\n      return existing;\n    }\n    // Property may be dynamic and might not existed before\n    if (!Array.isArray(existing)) {\n      return [value];\n    }\n    const clone = existing.slice();\n    let index = 0;\n    // No need to call `isNumber`\n    // as we are checking `> 0` not `>= 0`\n    // everything except number will return false here\n    if (beforePosition > 0) {\n      index = beforePosition;\n    }\n    clone.splice(index, 0, value);\n    return clone;\n  };\n}\nfunction patch(patchObject) {\n  return function patchStateOperator(existing) {\n    let clone = null;\n    for (const k in patchObject) {\n      const newValue = patchObject[k];\n      const existingPropValue = existing === null || existing === void 0 ? void 0 : existing[k];\n      const newPropValue = isStateOperator(newValue) ? newValue(existingPropValue) : newValue;\n      if (newPropValue !== existingPropValue) {\n        if (!clone) {\n          clone = Object.assign({}, existing);\n        }\n        clone[k] = newPropValue;\n      }\n    }\n    return clone || existing;\n  };\n}\n\n/**\n * @param selector - Index of item in the array or a predicate function\n * that can be provided in `Array.prototype.findIndex`\n * @param operatorOrValue - New value under the `selector` index or a\n * function that can be applied to an existing value\n */\nfunction updateItem(selector, operatorOrValue) {\n  return function updateItemOperator(existing) {\n    let index = -1;\n    if (isPredicate(selector)) {\n      index = existing.findIndex(selector);\n    } else if (isNumber(selector)) {\n      index = selector;\n    }\n    if (invalidIndex(index)) {\n      return existing;\n    }\n    let value = null;\n    // Need to check if the new item value will change the existing item value\n    // then, only if it will change it then clone the array and set the item\n    const theOperatorOrValue = operatorOrValue;\n    if (isStateOperator(theOperatorOrValue)) {\n      value = theOperatorOrValue(existing[index]);\n    } else {\n      value = theOperatorOrValue;\n    }\n    // If the value hasn't been mutated\n    // then we just return `existing` array\n    if (value === existing[index]) {\n      return existing;\n    }\n    const clone = existing.slice();\n    clone[index] = value;\n    return clone;\n  };\n}\n\n/**\n * @param selector - index or predicate to remove an item from an array by\n */\nfunction removeItem(selector) {\n  return function removeItemOperator(existing) {\n    let index = -1;\n    if (isPredicate(selector)) {\n      index = existing.findIndex(selector);\n    } else if (isNumber(selector)) {\n      index = selector;\n    }\n    if (invalidIndex(index)) {\n      return existing;\n    }\n    const clone = existing.slice();\n    clone.splice(index, 1);\n    return clone;\n  };\n}\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of this package.\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { append, compose, iif, insertItem, isPredicate, isStateOperator, patch, removeItem, updateItem };\n","import * as i0 from '@angular/core';\nimport { NgZone, PLATFORM_ID, Injectable, Inject, InjectionToken, inject, INJECTOR, ɵglobal, ErrorHandler, Optional, SkipSelf, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';\nimport * as i5 from '@ngxs/store/internals';\nimport { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY } from '@ngxs/store/internals';\nimport { isPlatformServer } from '@angular/common';\nimport { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable } from 'rxjs';\nimport { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';\nimport { isStateOperator } from '@ngxs/store/operators';\n\n/**\n * Returns the type from an action instance/class.\n * @ignore\n */\nfunction getActionTypeFromInstance(action) {\n  if (action.constructor && action.constructor.type) {\n    return action.constructor.type;\n  } else {\n    return action.type;\n  }\n}\n/**\n * Matches a action\n * @ignore\n */\nfunction actionMatcher(action1) {\n  const type1 = getActionTypeFromInstance(action1);\n  return function (action2) {\n    return type1 === getActionTypeFromInstance(action2);\n  };\n}\n/**\n * Set a deeply nested value. Example:\n *\n *   setValue({ foo: { bar: { eat: false } } },\n *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }\n *\n * While it traverses it also creates new objects from top down.\n *\n * @ignore\n */\nconst setValue = (obj, prop, val) => {\n  obj = Object.assign({}, obj);\n  const split = prop.split('.');\n  const lastIndex = split.length - 1;\n  split.reduce((acc, part, index) => {\n    if (index === lastIndex) {\n      acc[part] = val;\n    } else {\n      acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);\n    }\n    return acc && acc[part];\n  }, obj);\n  return obj;\n};\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nconst getValue = (obj, prop) => prop.split('.').reduce((acc, part) => acc && acc[part], obj);\n/**\n * Simple object check.\n *\n *    isObject({a:1}) //=> true\n *    isObject(1) //=> false\n *\n * @ignore\n */\nconst isObject$1 = item => {\n  return item && typeof item === 'object' && !Array.isArray(item);\n};\n/**\n * Deep merge two objects.\n *\n *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}\n *\n * @param base base object onto which `sources` will be applied\n */\nconst mergeDeep = (base, ...sources) => {\n  if (!sources.length) return base;\n  const source = sources.shift();\n  if (isObject$1(base) && isObject$1(source)) {\n    for (const key in source) {\n      if (isObject$1(source[key])) {\n        if (!base[key]) Object.assign(base, {\n          [key]: {}\n        });\n        mergeDeep(base[key], source[key]);\n      } else {\n        Object.assign(base, {\n          [key]: source[key]\n        });\n      }\n    }\n  }\n  return mergeDeep(base, ...sources);\n};\nfunction throwStateNameError(name) {\n  throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);\n}\nfunction throwStateNamePropertyError() {\n  throw new Error(`States must register a 'name' property.`);\n}\nfunction throwStateUniqueError(current, newName, oldName) {\n  throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);\n}\nfunction throwStateDecoratorError(name) {\n  throw new Error(`States must be decorated with @State() decorator, but \"${name}\" isn't.`);\n}\nfunction throwActionDecoratorError() {\n  throw new Error('@Action() decorator cannot be used with static methods.');\n}\nfunction throwSelectorDecoratorError() {\n  throw new Error('Selectors only work on methods.');\n}\nfunction getZoneWarningMessage() {\n  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 })';\n}\nfunction getUndecoratedStateInIvyWarningMessage(name) {\n  return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;\n}\nfunction throwSelectFactoryNotConnectedError() {\n  throw new Error('You have forgotten to import the NGXS module!');\n}\nfunction throwPatchingArrayError() {\n  throw new Error('Patching arrays is not supported.');\n}\nfunction throwPatchingPrimitiveError() {\n  throw new Error('Patching primitives is not supported.');\n}\nlet DispatchOutsideZoneNgxsExecutionStrategy = /*#__PURE__*/(() => {\n  class DispatchOutsideZoneNgxsExecutionStrategy {\n    constructor(_ngZone, _platformId) {\n      this._ngZone = _ngZone;\n      this._platformId = _platformId;\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        verifyZoneIsNotNooped(_ngZone);\n      }\n    }\n    enter(func) {\n      if (isPlatformServer(this._platformId)) {\n        return this.runInsideAngular(func);\n      }\n      return this.runOutsideAngular(func);\n    }\n    leave(func) {\n      return this.runInsideAngular(func);\n    }\n    runInsideAngular(func) {\n      if (NgZone.isInAngularZone()) {\n        return func();\n      }\n      return this._ngZone.run(func);\n    }\n    runOutsideAngular(func) {\n      if (NgZone.isInAngularZone()) {\n        return this._ngZone.runOutsideAngular(func);\n      }\n      return func();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */DispatchOutsideZoneNgxsExecutionStrategy.ɵfac = function DispatchOutsideZoneNgxsExecutionStrategy_Factory(t) {\n    return new (t || DispatchOutsideZoneNgxsExecutionStrategy)(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(PLATFORM_ID));\n  };\n  DispatchOutsideZoneNgxsExecutionStrategy.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: DispatchOutsideZoneNgxsExecutionStrategy,\n    factory: DispatchOutsideZoneNgxsExecutionStrategy.ɵfac,\n    providedIn: 'root'\n  });\n  return DispatchOutsideZoneNgxsExecutionStrategy;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n// Caretaker note: this should exist as a separate function and not a class method,\n// since class methods are not tree-shakable.\nfunction verifyZoneIsNotNooped(ngZone) {\n  // `NoopNgZone` is not exposed publicly as it doesn't expect\n  // to be used outside of the core Angular code, thus we just have\n  // to check if the zone doesn't extend or instanceof `NgZone`.\n  if (ngZone instanceof NgZone) {\n    return;\n  }\n  console.warn(getZoneWarningMessage());\n}\nconst ROOT_OPTIONS = new InjectionToken('ROOT_OPTIONS');\nconst ROOT_STATE_TOKEN = new InjectionToken('ROOT_STATE_TOKEN');\nconst FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');\nconst NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');\nconst META_KEY = 'NGXS_META';\nconst META_OPTIONS_KEY = 'NGXS_OPTIONS_META';\nconst SELECTOR_META_KEY = 'NGXS_SELECTOR_META';\n/**\n * The NGXS config settings.\n */\nlet NgxsConfig = /*#__PURE__*/(() => {\n  class NgxsConfig {\n    constructor() {\n      /**\n       * Defining the default state before module initialization\n       * This is convenient if we need to create a define our own set of states.\n       * @deprecated will be removed after v4\n       * (default: {})\n       */\n      this.defaultsState = {};\n      /**\n       * Defining shared selector options\n       */\n      this.selectorOptions = {\n        injectContainerState: true,\n        suppressErrors: true // TODO: default is true in v3, will change in v4\n      };\n      this.compatibility = {\n        strictContentSecurityPolicy: false\n      };\n      this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */NgxsConfig.ɵfac = function NgxsConfig_Factory(t) {\n    return new (t || NgxsConfig)();\n  };\n  NgxsConfig.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: NgxsConfig,\n    factory: function NgxsConfig_Factory(t) {\n      let r = null;\n      if (t) {\n        r = new t();\n      } else {\n        r = (options => mergeDeep(new NgxsConfig(), options))(i0.ɵɵinject(ROOT_OPTIONS));\n      }\n      return r;\n    },\n    providedIn: 'root'\n  });\n  return NgxsConfig;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Represents a basic change from a previous to a new value for a single state instance.\n * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.\n */\nclass NgxsSimpleChange {\n  constructor(previousValue, currentValue, firstChange) {\n    this.previousValue = previousValue;\n    this.currentValue = currentValue;\n    this.firstChange = firstChange;\n  }\n}\nlet NoopNgxsExecutionStrategy = /*#__PURE__*/(() => {\n  class NoopNgxsExecutionStrategy {\n    enter(func) {\n      return func();\n    }\n    leave(func) {\n      return func();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */NoopNgxsExecutionStrategy.ɵfac = function NoopNgxsExecutionStrategy_Factory(t) {\n    return new (t || NoopNgxsExecutionStrategy)();\n  };\n  NoopNgxsExecutionStrategy.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: NoopNgxsExecutionStrategy,\n    factory: NoopNgxsExecutionStrategy.ɵfac,\n    providedIn: 'root'\n  });\n  return NoopNgxsExecutionStrategy;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * The strategy that might be provided by users through `options.executionStrategy`.\n */\nconst USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');\n/*\n * Internal execution strategy injection token\n */\nconst NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY', {\n  providedIn: 'root',\n  factory: () => {\n    const injector = inject(INJECTOR);\n    const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);\n    return executionStrategy ? injector.get(executionStrategy) : injector.get(typeof ɵglobal.Zone !== 'undefined' ? DispatchOutsideZoneNgxsExecutionStrategy : NoopNgxsExecutionStrategy);\n  }\n});\n\n/**\n * Ensures metadata is attached to the class and returns it.\n *\n * @ignore\n */\nfunction ensureStoreMetadata$1(target) {\n  if (!target.hasOwnProperty(META_KEY)) {\n    const defaultMetadata = {\n      name: null,\n      actions: {},\n      defaults: {},\n      path: null,\n      makeRootSelector(context) {\n        return context.getStateGetter(defaultMetadata.name);\n      },\n      children: []\n    };\n    Object.defineProperty(target, META_KEY, {\n      value: defaultMetadata\n    });\n  }\n  return getStoreMetadata$1(target);\n}\n/**\n * Get the metadata attached to the state class if it exists.\n *\n * @ignore\n */\nfunction getStoreMetadata$1(target) {\n  return target[META_KEY];\n}\n/**\n * Ensures metadata is attached to the selector and returns it.\n *\n * @ignore\n */\nfunction ensureSelectorMetadata$1(target) {\n  if (!target.hasOwnProperty(SELECTOR_META_KEY)) {\n    const defaultMetadata = {\n      makeRootSelector: null,\n      originalFn: null,\n      containerClass: null,\n      selectorName: null,\n      getSelectorOptions: () => ({})\n    };\n    Object.defineProperty(target, SELECTOR_META_KEY, {\n      value: defaultMetadata\n    });\n  }\n  return getSelectorMetadata$1(target);\n}\n/**\n * Get the metadata attached to the selector if it exists.\n *\n * @ignore\n */\nfunction getSelectorMetadata$1(target) {\n  return target[SELECTOR_META_KEY];\n}\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\n *\n * @ignore\n */\nfunction compliantPropGetter(paths) {\n  const copyOfPaths = paths.slice();\n  return obj => copyOfPaths.reduce((acc, part) => acc && acc[part], obj);\n}\n/**\n * The generated function is faster than:\n * - pluck (Observable operator)\n * - memoize\n *\n * @ignore\n */\nfunction fastPropGetter(paths) {\n  const segments = paths;\n  let seg = 'store.' + segments[0];\n  let i = 0;\n  const l = segments.length;\n  let expr = seg;\n  while (++i < l) {\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\n  }\n  const fn = new Function('store', 'return ' + expr + ';');\n  return fn;\n}\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nfunction propGetter(paths, config) {\n  if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {\n    return compliantPropGetter(paths);\n  } else {\n    return fastPropGetter(paths);\n  }\n}\n/**\n * Given an array of states, it will return a object graph. Example:\n *    const states = [\n *      Cart,\n *      CartSaved,\n *      CartSavedItems\n *    ]\n *\n * would return:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * @ignore\n */\nfunction buildGraph(stateClasses) {\n  const findName = stateClass => {\n    const meta = stateClasses.find(g => g === stateClass);\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {\n      throw new Error(`Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`);\n    }\n    return meta[META_KEY].name;\n  };\n  return stateClasses.reduce((result, stateClass) => {\n    const {\n      name,\n      children\n    } = stateClass[META_KEY];\n    result[name] = (children || []).map(findName);\n    return result;\n  }, {});\n}\n/**\n * Given a states array, returns object graph\n * returning the name and state metadata. Example:\n *\n *  const graph = {\n *    cart: { metadata }\n *  };\n *\n * @ignore\n */\nfunction nameToState(states) {\n  return states.reduce((result, stateClass) => {\n    const meta = stateClass[META_KEY];\n    result[meta.name] = stateClass;\n    return result;\n  }, {});\n}\n/**\n * Given a object relationship graph will return the full path\n * for the child items. Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const r = {\n *    cart: 'cart',\n *    saved: 'cart.saved',\n *    items: 'cart.saved.items'\n *  };\n *\n * @ignore\n */\nfunction findFullParentPath(obj, newObj = {}) {\n  const visit = (child, keyToFind) => {\n    for (const key in child) {\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\n        const parent = visit(child, key);\n        return parent !== null ? `${parent}.${key}` : key;\n      }\n    }\n    return null;\n  };\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key)) {\n      const parent = visit(obj, key);\n      newObj[key] = parent ? `${parent}.${key}` : key;\n    }\n  }\n  return newObj;\n}\n/**\n * Given a object graph, it will return the items topologically sorted Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const results = [\n *    'items',\n *    'saved',\n *    'cart'\n *  ];\n *\n * @ignore\n */\nfunction topologicalSort(graph) {\n  const sorted = [];\n  const visited = {};\n  const visit = (name, ancestors = []) => {\n    if (!Array.isArray(ancestors)) {\n      ancestors = [];\n    }\n    ancestors.push(name);\n    visited[name] = true;\n    graph[name].forEach(dep => {\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {\n        throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);\n      }\n      if (visited[dep]) {\n        return;\n      }\n      visit(dep, ancestors.slice(0));\n    });\n    if (sorted.indexOf(name) < 0) {\n      sorted.push(name);\n    }\n  };\n  Object.keys(graph).forEach(k => visit(k));\n  return sorted.reverse();\n}\n/**\n * Returns if the parameter is a object or not.\n *\n * @ignore\n */\nfunction isObject(obj) {\n  return typeof obj === 'object' && obj !== null || typeof obj === 'function';\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will grab actions that have just been dispatched as well as actions that have completed\n */\nfunction ofAction(...allowedTypes) {\n  return ofActionOperator(allowedTypes);\n}\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been dispatched\n */\nfunction ofActionDispatched(...allowedTypes) {\n  return ofActionOperator(allowedTypes, [\"DISPATCHED\" /* Dispatched */]);\n}\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been successfully completed\n */\nfunction ofActionSuccessful(...allowedTypes) {\n  return ofActionOperator(allowedTypes, [\"SUCCESSFUL\" /* Successful */]);\n}\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been canceled\n */\nfunction ofActionCanceled(...allowedTypes) {\n  return ofActionOperator(allowedTypes, [\"CANCELED\" /* Canceled */]);\n}\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been completed\n */\nfunction ofActionCompleted(...allowedTypes) {\n  const allowedStatuses = [\"SUCCESSFUL\" /* Successful */, \"CANCELED\" /* Canceled */, \"ERRORED\" /* Errored */];\n  return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);\n}\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just thrown an error\n */\nfunction ofActionErrored(...allowedTypes) {\n  return ofActionOperator(allowedTypes, [\"ERRORED\" /* Errored */]);\n}\nfunction ofActionOperator(allowedTypes, statuses,\n// This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,\n// since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`\n// defaults to `any`, thus there is no sense from union type.\nmapOperator = mapAction) {\n  const allowedMap = createAllowedActionTypesMap(allowedTypes);\n  const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);\n  return function (o) {\n    return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());\n  };\n}\nfunction filterStatus(allowedTypes, allowedStatuses) {\n  return filter(ctx => {\n    const actionType = getActionTypeFromInstance(ctx.action);\n    const typeMatch = allowedTypes[actionType];\n    const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;\n    return typeMatch && statusMatch;\n  });\n}\nfunction mapActionResult() {\n  return map(({\n    action,\n    status,\n    error\n  }) => {\n    return {\n      action,\n      result: {\n        successful: \"SUCCESSFUL\" /* Successful */ === status,\n        canceled: \"CANCELED\" /* Canceled */ === status,\n        error\n      }\n    };\n  });\n}\nfunction mapAction() {\n  return map(ctx => ctx.action);\n}\nfunction createAllowedActionTypesMap(types) {\n  return types.reduce((filterMap, klass) => {\n    filterMap[getActionTypeFromInstance(klass)] = true;\n    return filterMap;\n  }, {});\n}\nfunction createAllowedStatusesMap(statuses) {\n  return statuses.reduce((filterMap, status) => {\n    filterMap[status] = true;\n    return filterMap;\n  }, {});\n}\n\n/**\n * Returns operator that will run\n * `subscribe` outside of the ngxs execution context\n */\nfunction leaveNgxs(ngxsExecutionStrategy) {\n  return source => {\n    return new Observable(sink => {\n      return source.subscribe({\n        next(value) {\n          ngxsExecutionStrategy.leave(() => sink.next(value));\n        },\n        error(error) {\n          ngxsExecutionStrategy.leave(() => sink.error(error));\n        },\n        complete() {\n          ngxsExecutionStrategy.leave(() => sink.complete());\n        }\n      });\n    });\n  };\n}\nlet InternalNgxsExecutionStrategy = /*#__PURE__*/(() => {\n  class InternalNgxsExecutionStrategy {\n    constructor(_executionStrategy) {\n      this._executionStrategy = _executionStrategy;\n    }\n    enter(func) {\n      return this._executionStrategy.enter(func);\n    }\n    leave(func) {\n      return this._executionStrategy.leave(func);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */InternalNgxsExecutionStrategy.ɵfac = function InternalNgxsExecutionStrategy_Factory(t) {\n    return new (t || InternalNgxsExecutionStrategy)(i0.ɵɵinject(NGXS_EXECUTION_STRATEGY));\n  };\n  InternalNgxsExecutionStrategy.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalNgxsExecutionStrategy,\n    factory: InternalNgxsExecutionStrategy.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalNgxsExecutionStrategy;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * This wraps the provided function, and will enforce the following:\n * - The calls will execute in the order that they are made\n * - A call will only be initiated when the previous call has completed\n * - If there is a call currently executing then the new call will be added\n *   to the queue and the function will return immediately\n *\n * NOTE: The following assumptions about the operation must hold true:\n * - The operation is synchronous in nature\n * - If any asynchronous side effects of the call exist, it should not\n *   have any bearing on the correctness of the next call in the queue\n * - The operation has a void return\n * - The caller should not assume that the call has completed upon\n *   return of the function\n * - The caller can assume that all the queued calls will complete\n *   within the current microtask\n * - The only way that a call will encounter another call in the queue\n *   would be if the call at the front of the queue initiated this call\n *   as part of its synchronous execution\n */\nfunction orderedQueueOperation(operation) {\n  const callsQueue = [];\n  let busyPushingNext = false;\n  return function callOperation(...args) {\n    if (busyPushingNext) {\n      callsQueue.unshift(args);\n      return;\n    }\n    busyPushingNext = true;\n    operation(...args);\n    while (callsQueue.length > 0) {\n      const nextCallArgs = callsQueue.pop();\n      nextCallArgs && operation(...nextCallArgs);\n    }\n    busyPushingNext = false;\n  };\n}\n/**\n * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.\n * A standard Subject does not have this guarantee.\n * For example, given the following code:\n * ```typescript\n *   const subject = new Subject<string>();\n     subject.subscribe(value => {\n       if (value === 'start') subject.next('end');\n     });\n     subject.subscribe(value => { });\n     subject.next('start');\n * ```\n * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.\n * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.\n */\nclass OrderedSubject extends Subject {\n  constructor() {\n    super(...arguments);\n    this._orderedNext = orderedQueueOperation(value => super.next(value));\n  }\n  next(value) {\n    this._orderedNext(value);\n  }\n}\n/**\n * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.\n * A standard BehaviorSubject does not have this guarantee.\n * For example, given the following code:\n * ```typescript\n *   const subject = new BehaviorSubject<string>();\n     subject.subscribe(value => {\n       if (value === 'start') subject.next('end');\n     });\n     subject.subscribe(value => { });\n     subject.next('start');\n * ```\n * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.\n * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.\n */\nclass OrderedBehaviorSubject extends BehaviorSubject {\n  constructor(value) {\n    super(value);\n    this._orderedNext = orderedQueueOperation(value => super.next(value));\n    this._currentValue = value;\n  }\n  getValue() {\n    return this._currentValue;\n  }\n  next(value) {\n    this._currentValue = value;\n    this._orderedNext(value);\n  }\n}\n\n/**\n * Internal Action stream that is emitted anytime an action is dispatched.\n */\nlet InternalActions = /*#__PURE__*/(() => {\n  class InternalActions extends OrderedSubject {\n    ngOnDestroy() {\n      this.complete();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */InternalActions.ɵfac = /* @__PURE__ */(() => {\n    let ɵInternalActions_BaseFactory;\n    return function InternalActions_Factory(t) {\n      return (ɵInternalActions_BaseFactory || (ɵInternalActions_BaseFactory = i0.ɵɵgetInheritedFactory(InternalActions)))(t || InternalActions);\n    };\n  })();\n  InternalActions.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalActions,\n    factory: InternalActions.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalActions;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Action stream that is emitted anytime an action is dispatched.\n *\n * You can listen to this in services to react without stores.\n */\nlet Actions = /*#__PURE__*/(() => {\n  class Actions extends Observable {\n    constructor(internalActions$, internalExecutionStrategy) {\n      const sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy),\n      // The `InternalActions` subject emits outside of the Angular zone.\n      // We have to re-enter the Angular zone for any incoming consumer.\n      // The `share()` operator reduces the number of change detections.\n      // This would call leave only once for any stream emission across all active subscribers.\n      share());\n      super(observer => {\n        const childSubscription = sharedInternalActions$.subscribe({\n          next: ctx => observer.next(ctx),\n          error: error => observer.error(error),\n          complete: () => observer.complete()\n        });\n        observer.add(childSubscription);\n      });\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */Actions.ɵfac = function Actions_Factory(t) {\n    return new (t || Actions)(i0.ɵɵinject(InternalActions), i0.ɵɵinject(InternalNgxsExecutionStrategy));\n  };\n  Actions.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: Actions,\n    factory: Actions.ɵfac,\n    providedIn: 'root'\n  });\n  return Actions;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Composes a array of functions from left to right. Example:\n *\n *      compose([fn, final])(state, action);\n *\n * then the funcs have a signature like:\n *\n *      function fn (state, action, next) {\n *          console.log('here', state, action, next);\n *          return next(state, action);\n *      }\n *\n *      function final (state, action) {\n *          console.log('here', state, action);\n *          return state;\n *      }\n *\n * the last function should not call `next`.\n *\n * @ignore\n */\nconst compose = funcs => (...args) => {\n  const curr = funcs.shift();\n  return curr(...args, (...nextArgs) => compose(funcs)(...nextArgs));\n};\n\n/**\n * This operator is used for piping the observable result\n * from the `dispatch()`. It has a \"smart\" error handling\n * strategy that allows us to decide whether we propagate\n * errors to Angular's `ErrorHandler` or enable users to\n * handle them manually. We consider following cases:\n * 1) `store.dispatch()` (no subscribe) -> call `handleError()`\n * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`\n * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`\n * 4) `toPromise()` without `catch` -> do `handleError()`\n * 5) `toPromise()` with `catch` -> don't `handleError()`\n */\nfunction ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {\n  return source => {\n    let subscribed = false;\n    source.subscribe({\n      error: error => {\n        // Do not trigger change detection for a microtask. This depends on the execution\n        // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`\n        // leaves the Angular zone.\n        ngxsExecutionStrategy.enter(() => Promise.resolve().then(() => {\n          if (!subscribed) {\n            ngxsExecutionStrategy.leave(() => internalErrorReporter.reportErrorSafely(error));\n          }\n        }));\n      }\n    });\n    return new Observable(subscriber => {\n      subscribed = true;\n      return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);\n    });\n  };\n}\nlet InternalErrorReporter = /*#__PURE__*/(() => {\n  class InternalErrorReporter {\n    constructor(_injector) {\n      this._injector = _injector;\n      /** Will be set lazily to be backward compatible. */\n      this._errorHandler = null;\n    }\n    reportErrorSafely(error) {\n      if (this._errorHandler === null) {\n        this._errorHandler = this._injector.get(ErrorHandler);\n      }\n      // The `try-catch` is used to avoid handling the error twice. Suppose we call\n      // `handleError` which re-throws the error internally. The re-thrown error will\n      // be caught by zone.js which will then get to the `zone.onError.emit()` and the\n      // `onError` subscriber will call `handleError` again.\n      try {\n        this._errorHandler.handleError(error);\n      } catch (_a) {}\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */InternalErrorReporter.ɵfac = function InternalErrorReporter_Factory(t) {\n    return new (t || InternalErrorReporter)(i0.ɵɵinject(i0.Injector));\n  };\n  InternalErrorReporter.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalErrorReporter,\n    factory: InternalErrorReporter.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalErrorReporter;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * BehaviorSubject of the entire state.\n * @ignore\n */\nlet StateStream = /*#__PURE__*/(() => {\n  class StateStream extends OrderedBehaviorSubject {\n    constructor() {\n      super({});\n    }\n    ngOnDestroy() {\n      // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.\n      // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users\n      // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.\n      this.complete();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */StateStream.ɵfac = function StateStream_Factory(t) {\n    return new (t || StateStream)();\n  };\n  StateStream.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: StateStream,\n    factory: StateStream.ɵfac,\n    providedIn: 'root'\n  });\n  return StateStream;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet PluginManager = /*#__PURE__*/(() => {\n  class PluginManager {\n    constructor(_parentManager, _pluginHandlers) {\n      this._parentManager = _parentManager;\n      this._pluginHandlers = _pluginHandlers;\n      this.plugins = [];\n      this.registerHandlers();\n    }\n    get rootPlugins() {\n      return this._parentManager && this._parentManager.plugins || this.plugins;\n    }\n    registerHandlers() {\n      const pluginHandlers = this.getPluginHandlers();\n      this.rootPlugins.push(...pluginHandlers);\n    }\n    getPluginHandlers() {\n      const handlers = this._pluginHandlers || [];\n      return handlers.map(plugin => plugin.handle ? plugin.handle.bind(plugin) : plugin);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */PluginManager.ɵfac = function PluginManager_Factory(t) {\n    return new (t || PluginManager)(i0.ɵɵinject(PluginManager, 12), i0.ɵɵinject(NGXS_PLUGINS, 8));\n  };\n  PluginManager.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: PluginManager,\n    factory: PluginManager.ɵfac\n  });\n  return PluginManager;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Internal Action result stream that is emitted when an action is completed.\n * This is used as a method of returning the action result to the dispatcher\n * for the observable returned by the dispatch(...) call.\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\n */\nlet InternalDispatchedActionResults = /*#__PURE__*/(() => {\n  class InternalDispatchedActionResults extends Subject {}\n  /** @nocollapse */\n  /** @nocollapse */InternalDispatchedActionResults.ɵfac = /* @__PURE__ */(() => {\n    let ɵInternalDispatchedActionResults_BaseFactory;\n    return function InternalDispatchedActionResults_Factory(t) {\n      return (ɵInternalDispatchedActionResults_BaseFactory || (ɵInternalDispatchedActionResults_BaseFactory = i0.ɵɵgetInheritedFactory(InternalDispatchedActionResults)))(t || InternalDispatchedActionResults);\n    };\n  })();\n  InternalDispatchedActionResults.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalDispatchedActionResults,\n    factory: InternalDispatchedActionResults.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalDispatchedActionResults;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet InternalDispatcher = /*#__PURE__*/(() => {\n  class InternalDispatcher {\n    constructor(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {\n      this._actions = _actions;\n      this._actionResults = _actionResults;\n      this._pluginManager = _pluginManager;\n      this._stateStream = _stateStream;\n      this._ngxsExecutionStrategy = _ngxsExecutionStrategy;\n      this._internalErrorReporter = _internalErrorReporter;\n    }\n    /**\n     * Dispatches event(s).\n     */\n    dispatch(actionOrActions) {\n      const result = this._ngxsExecutionStrategy.enter(() => this.dispatchByEvents(actionOrActions));\n      return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));\n    }\n    dispatchByEvents(actionOrActions) {\n      if (Array.isArray(actionOrActions)) {\n        if (actionOrActions.length === 0) return of(this._stateStream.getValue());\n        return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\n      } else {\n        return this.dispatchSingle(actionOrActions);\n      }\n    }\n    dispatchSingle(action) {\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        const type = getActionTypeFromInstance(action);\n        if (!type) {\n          const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);\n          return throwError(error);\n        }\n      }\n      const prevState = this._stateStream.getValue();\n      const plugins = this._pluginManager.plugins;\n      return compose([...plugins, (nextState, nextAction) => {\n        if (nextState !== prevState) {\n          this._stateStream.next(nextState);\n        }\n        const actionResult$ = this.getActionResultStream(nextAction);\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\n        this._actions.next({\n          action: nextAction,\n          status: \"DISPATCHED\" /* Dispatched */\n        });\n        return this.createDispatchObservable(actionResult$);\n      }])(prevState, action).pipe(shareReplay());\n    }\n    getActionResultStream(action) {\n      return this._actionResults.pipe(filter(ctx => ctx.action === action && ctx.status !== \"DISPATCHED\" /* Dispatched */), take(1), shareReplay());\n    }\n    createDispatchObservable(actionResult$) {\n      return actionResult$.pipe(exhaustMap(ctx => {\n        switch (ctx.status) {\n          case \"SUCCESSFUL\" /* Successful */:\n            return of(this._stateStream.getValue());\n          case \"ERRORED\" /* Errored */:\n            return throwError(ctx.error);\n          default:\n            return EMPTY;\n        }\n      })).pipe(shareReplay());\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */InternalDispatcher.ɵfac = function InternalDispatcher_Factory(t) {\n    return new (t || InternalDispatcher)(i0.ɵɵinject(InternalActions), i0.ɵɵinject(InternalDispatchedActionResults), i0.ɵɵinject(PluginManager), i0.ɵɵinject(StateStream), i0.ɵɵinject(InternalNgxsExecutionStrategy), i0.ɵɵinject(InternalErrorReporter));\n  };\n  InternalDispatcher.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalDispatcher,\n    factory: InternalDispatcher.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalDispatcher;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Object freeze code\n * https://github.com/jsdf/deep-freeze\n */\nconst deepFreeze = o => {\n  Object.freeze(o);\n  const oIsFunction = typeof o === 'function';\n  const hasOwnProp = Object.prototype.hasOwnProperty;\n  Object.getOwnPropertyNames(o).forEach(function (prop) {\n    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])) {\n      deepFreeze(o[prop]);\n    }\n  });\n  return o;\n};\n\n/**\n * @ignore\n */\nlet InternalStateOperations = /*#__PURE__*/(() => {\n  class InternalStateOperations {\n    constructor(_stateStream, _dispatcher, _config) {\n      this._stateStream = _stateStream;\n      this._dispatcher = _dispatcher;\n      this._config = _config;\n    }\n    /**\n     * Returns the root state operators.\n     */\n    getRootStateOperations() {\n      const rootStateOperations = {\n        getState: () => this._stateStream.getValue(),\n        setState: newState => this._stateStream.next(newState),\n        dispatch: actionOrActions => this._dispatcher.dispatch(actionOrActions)\n      };\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        return this._config.developmentMode ? ensureStateAndActionsAreImmutable(rootStateOperations) : rootStateOperations;\n      } else {\n        return rootStateOperations;\n      }\n    }\n    setStateToTheCurrentWithNew(results) {\n      const stateOperations = this.getRootStateOperations();\n      // Get our current stream\n      const currentState = stateOperations.getState();\n      // Set the state to the current + new\n      stateOperations.setState(Object.assign(Object.assign({}, currentState), results.defaults));\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */InternalStateOperations.ɵfac = function InternalStateOperations_Factory(t) {\n    return new (t || InternalStateOperations)(i0.ɵɵinject(StateStream), i0.ɵɵinject(InternalDispatcher), i0.ɵɵinject(NgxsConfig));\n  };\n  InternalStateOperations.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: InternalStateOperations,\n    factory: InternalStateOperations.ɵfac,\n    providedIn: 'root'\n  });\n  return InternalStateOperations;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction ensureStateAndActionsAreImmutable(root) {\n  return {\n    getState: () => root.getState(),\n    setState: value => {\n      const frozenValue = deepFreeze(value);\n      return root.setState(frozenValue);\n    },\n    dispatch: actions => {\n      return root.dispatch(actions);\n    }\n  };\n}\nfunction simplePatch(value) {\n  return existingState => {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      if (Array.isArray(value)) {\n        throwPatchingArrayError();\n      } else if (typeof value !== 'object') {\n        throwPatchingPrimitiveError();\n      }\n    }\n    const newState = Object.assign({}, existingState);\n    for (const key in value) {\n      // deep clone for patch compatibility\n      newState[key] = value[key];\n    }\n    return newState;\n  };\n}\n\n/**\n * State Context factory class\n * @ignore\n */\nlet StateContextFactory = /*#__PURE__*/(() => {\n  class StateContextFactory {\n    constructor(_internalStateOperations) {\n      this._internalStateOperations = _internalStateOperations;\n    }\n    /**\n     * Create the state context\n     */\n    createStateContext(mappedStore) {\n      const root = this._internalStateOperations.getRootStateOperations();\n      return {\n        getState() {\n          const currentAppState = root.getState();\n          return getState(currentAppState, mappedStore.path);\n        },\n        patchState(val) {\n          const currentAppState = root.getState();\n          const patchOperator = simplePatch(val);\n          return setStateFromOperator(root, currentAppState, patchOperator, mappedStore.path);\n        },\n        setState(val) {\n          const currentAppState = root.getState();\n          return isStateOperator(val) ? setStateFromOperator(root, currentAppState, val, mappedStore.path) : setStateValue(root, currentAppState, val, mappedStore.path);\n        },\n        dispatch(actions) {\n          return root.dispatch(actions);\n        }\n      };\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */StateContextFactory.ɵfac = function StateContextFactory_Factory(t) {\n    return new (t || StateContextFactory)(i0.ɵɵinject(InternalStateOperations));\n  };\n  StateContextFactory.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: StateContextFactory,\n    factory: StateContextFactory.ɵfac,\n    providedIn: 'root'\n  });\n  return StateContextFactory;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction setStateValue(root, currentAppState, newValue, path) {\n  const newAppState = setValue(currentAppState, path, newValue);\n  root.setState(newAppState);\n  return newAppState;\n  // In doing this refactoring I noticed that there is a 'bug' where the\n  // application state is returned instead of this state slice.\n  // This has worked this way since the beginning see:\n  // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts\n  // This needs to be fixed, but is a 'breaking' change.\n  // I will do this fix in a subsequent PR and we can decide how to handle it.\n}\nfunction setStateFromOperator(root, currentAppState, stateOperator, path) {\n  const local = getState(currentAppState, path);\n  const newValue = stateOperator(local);\n  return setStateValue(root, currentAppState, newValue, path);\n}\nfunction getState(currentAppState, path) {\n  return getValue(currentAppState, path);\n}\nconst stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');\nfunction ensureStateNameIsValid(name) {\n  if (!name) {\n    throwStateNamePropertyError();\n  } else if (!stateNameRegex.test(name)) {\n    throwStateNameError(name);\n  }\n}\nfunction ensureStateNameIsUnique(stateName, state, statesByName) {\n  const existingState = statesByName[stateName];\n  if (existingState && existingState !== state) {\n    throwStateUniqueError(stateName, state.name, existingState.name);\n  }\n}\nfunction ensureStatesAreDecorated(stateClasses) {\n  stateClasses.forEach(stateClass => {\n    if (!getStoreMetadata$1(stateClass)) {\n      throwStateDecoratorError(stateClass.name);\n    }\n  });\n}\n\n/**\n * All provided or injected tokens must have `@Injectable` decorator\n * (previously, injected tokens without `@Injectable` were allowed\n * if another decorator was used, e.g. pipes).\n */\nfunction ensureStateClassIsInjectable(stateClass) {\n  if (jit_hasInjectableAnnotation(stateClass) || aot_hasNgInjectableDef(stateClass)) {\n    return;\n  }\n  console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));\n}\nfunction aot_hasNgInjectableDef(stateClass) {\n  // `ɵprov` is a static property added by the NGCC compiler. It always exists in\n  // AOT mode because this property is added before runtime. If an application is running in\n  // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`\n  // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.\n  return !!stateClass.ɵprov;\n}\nfunction jit_hasInjectableAnnotation(stateClass) {\n  // `ɵprov` doesn't exist in JIT mode (for instance when running unit tests with Jest).\n  const annotations = stateClass.__annotations__ || [];\n  return annotations.some(annotation => (annotation === null || annotation === void 0 ? void 0 : annotation.ngMetadataName) === 'Injectable');\n}\n\n/**\n * Init action\n */\nlet InitState = /*#__PURE__*/(() => {\n  class InitState {}\n  InitState.type = '@@INIT';\n  /**\n   * Update action\n   */\n  return InitState;\n})();\nlet UpdateState = /*#__PURE__*/(() => {\n  class UpdateState {\n    constructor(addedStates) {\n      this.addedStates = addedStates;\n    }\n  }\n  UpdateState.type = '@@UPDATE_STATE';\n  return UpdateState;\n})();\nconst NGXS_DEVELOPMENT_OPTIONS = new InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {\n  providedIn: 'root',\n  factory: () => ({\n    warnOnUnhandledActions: true\n  })\n});\nlet NgxsUnhandledActionsLogger = /*#__PURE__*/(() => {\n  class NgxsUnhandledActionsLogger {\n    constructor(options) {\n      /**\n       * These actions should be ignored by default; the user can increase this\n       * list in the future via the `ignoreActions` method.\n       */\n      this._ignoredActions = new Set([InitState.type, UpdateState.type]);\n      if (typeof options.warnOnUnhandledActions === 'object') {\n        this.ignoreActions(...options.warnOnUnhandledActions.ignore);\n      }\n    }\n    /**\n     * Adds actions to the internal list of actions that should be ignored.\n     */\n    ignoreActions(...actions) {\n      for (const action of actions) {\n        this._ignoredActions.add(action.type);\n      }\n    }\n    /** @internal */\n    warn(action) {\n      const actionShouldBeIgnored = Array.from(this._ignoredActions).some(type => type === getActionTypeFromInstance(action));\n      if (actionShouldBeIgnored) {\n        return;\n      }\n      action = action.constructor && action.constructor.name !== 'Object' ? action.constructor.name : action.type;\n      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.`);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */NgxsUnhandledActionsLogger.ɵfac = function NgxsUnhandledActionsLogger_Factory(t) {\n    return new (t || NgxsUnhandledActionsLogger)(i0.ɵɵinject(NGXS_DEVELOPMENT_OPTIONS));\n  };\n  NgxsUnhandledActionsLogger.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: NgxsUnhandledActionsLogger,\n    factory: NgxsUnhandledActionsLogger.ɵfac\n  });\n  return NgxsUnhandledActionsLogger;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;\n/**\n * The `StateFactory` class adds root and feature states to the graph.\n * This extracts state names from state classes, checks if they already\n * exist in the global graph, throws errors if their names are invalid, etc.\n * See its constructor, state factories inject state factories that are\n * parent-level providers. This is required to get feature states from the\n * injector on the same level.\n *\n * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.\n * The `StateFactory` is initialized on the feature level and goes through `...states`\n * to get them from the injector through `injector.get(state)`.\n * @ignore\n */\nlet StateFactory = /*#__PURE__*/(() => {\n  class StateFactory {\n    constructor(_injector, _config, _parentFactory, _actions, _actionResults, _stateContextFactory, _initialState) {\n      this._injector = _injector;\n      this._config = _config;\n      this._parentFactory = _parentFactory;\n      this._actions = _actions;\n      this._actionResults = _actionResults;\n      this._stateContextFactory = _stateContextFactory;\n      this._initialState = _initialState;\n      this._actionsSubscription = null;\n      this._states = [];\n      this._statesByName = {};\n      this._statePaths = {};\n      this.getRuntimeSelectorContext = memoize(() => {\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const stateFactory = this;\n        function resolveGetter(key) {\n          const path = stateFactory.statePaths[key];\n          return path ? propGetter(path.split('.'), stateFactory._config) : null;\n        }\n        const context = this._parentFactory ? this._parentFactory.getRuntimeSelectorContext() : {\n          getStateGetter(key) {\n            let getter = resolveGetter(key);\n            if (getter) {\n              return getter;\n            }\n            return (...args) => {\n              // Late loaded getter\n              if (!getter) {\n                getter = resolveGetter(key);\n              }\n              return getter ? getter(...args) : undefined;\n            };\n          },\n          getSelectorOptions(localOptions) {\n            const globalSelectorOptions = stateFactory._config.selectorOptions;\n            return Object.assign(Object.assign({}, globalSelectorOptions), localOptions || {});\n          }\n        };\n        return context;\n      });\n    }\n    get states() {\n      return this._parentFactory ? this._parentFactory.states : this._states;\n    }\n    get statesByName() {\n      return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;\n    }\n    get statePaths() {\n      return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;\n    }\n    static _cloneDefaults(defaults) {\n      let value = defaults;\n      if (Array.isArray(defaults)) {\n        value = defaults.slice();\n      } else if (isObject(defaults)) {\n        value = Object.assign({}, defaults);\n      } else if (defaults === undefined) {\n        value = {};\n      }\n      return value;\n    }\n    ngOnDestroy() {\n      var _a;\n      (_a = this._actionsSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();\n    }\n    /**\n     * Add a new state to the global defs.\n     */\n    add(stateClasses) {\n      if (NG_DEV_MODE) {\n        ensureStatesAreDecorated(stateClasses);\n      }\n      const {\n        newStates\n      } = this.addToStatesMap(stateClasses);\n      if (!newStates.length) return [];\n      const stateGraph = buildGraph(newStates);\n      const sortedStates = topologicalSort(stateGraph);\n      const paths = findFullParentPath(stateGraph);\n      const nameGraph = nameToState(newStates);\n      const bootstrappedStores = [];\n      for (const name of sortedStates) {\n        const stateClass = nameGraph[name];\n        const path = paths[name];\n        const meta = stateClass[META_KEY];\n        this.addRuntimeInfoToMeta(meta, path);\n        // Note: previously we called `ensureStateClassIsInjectable` within the\n        // `State` decorator. This check is moved here because the `ɵprov` property\n        // will not exist on the class in JIT mode (because it's set asynchronously\n        // during JIT compilation through `Object.defineProperty`).\n        if (NG_DEV_MODE) {\n          ensureStateClassIsInjectable(stateClass);\n        }\n        const stateMap = {\n          name,\n          path,\n          isInitialised: false,\n          actions: meta.actions,\n          instance: this._injector.get(stateClass),\n          defaults: StateFactory._cloneDefaults(meta.defaults)\n        };\n        // ensure our store hasn't already been added\n        // but don't throw since it could be lazy\n        // loaded from different paths\n        if (!this.hasBeenMountedAndBootstrapped(name, path)) {\n          bootstrappedStores.push(stateMap);\n        }\n        this.states.push(stateMap);\n      }\n      return bootstrappedStores;\n    }\n    /**\n     * Add a set of states to the store and return the defaults\n     */\n    addAndReturnDefaults(stateClasses) {\n      const classes = stateClasses || [];\n      const mappedStores = this.add(classes);\n      const defaults = mappedStores.reduce((result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults), {});\n      return {\n        defaults,\n        states: mappedStores\n      };\n    }\n    connectActionHandlers() {\n      // Note: We have to connect actions only once when the `StateFactory`\n      //       is being created for the first time. This checks if we're in\n      //       a child state factory and the parent state factory already exists.\n      if (this._parentFactory || this._actionsSubscription !== null) {\n        return;\n      }\n      const dispatched$ = new Subject();\n      this._actionsSubscription = this._actions.pipe(filter(ctx => ctx.status === \"DISPATCHED\" /* Dispatched */), mergeMap(ctx => {\n        dispatched$.next(ctx);\n        const action = ctx.action;\n        return this.invokeActions(dispatched$, action).pipe(map(() => ({\n          action,\n          status: \"SUCCESSFUL\" /* Successful */\n        })), defaultIfEmpty({\n          action,\n          status: \"CANCELED\" /* Canceled */\n        }), catchError(error => of({\n          action,\n          status: \"ERRORED\" /* Errored */,\n          error\n        })));\n      })).subscribe(ctx => this._actionResults.next(ctx));\n    }\n    /**\n     * Invoke actions on the states.\n     */\n    invokeActions(dispatched$, action) {\n      const type = getActionTypeFromInstance(action);\n      const results = [];\n      // Determines whether the dispatched action has been handled, this is assigned\n      // to `true` within the below `for` loop if any `actionMetas` has been found.\n      let actionHasBeenHandled = false;\n      for (const metadata of this.states) {\n        const actionMetas = metadata.actions[type];\n        if (actionMetas) {\n          for (const actionMeta of actionMetas) {\n            const stateContext = this._stateContextFactory.createStateContext(metadata);\n            try {\n              let result = metadata.instance[actionMeta.fn](stateContext, action);\n              if (result instanceof Promise) {\n                result = from(result);\n              }\n              if (isObservable(result)) {\n                // If this observable has been completed w/o emitting\n                // any value then we wouldn't want to complete the whole chain\n                // of actions. Since if any observable completes then\n                // action will be canceled.\n                // For instance if any action handler would've had such statement:\n                // `handler(ctx) { return EMPTY; }`\n                // then the action will be canceled.\n                // See https://github.com/ngxs/store/issues/1568\n                result = result.pipe(mergeMap(value => {\n                  if (value instanceof Promise) {\n                    return from(value);\n                  }\n                  if (isObservable(value)) {\n                    return value;\n                  }\n                  return of(value);\n                }), defaultIfEmpty({}));\n                if (actionMeta.options.cancelUncompleted) {\n                  // todo: ofActionDispatched should be used with action class\n                  result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));\n                }\n              } else {\n                result = of({}).pipe(shareReplay());\n              }\n              results.push(result);\n            } catch (e) {\n              results.push(throwError(e));\n            }\n            actionHasBeenHandled = true;\n          }\n        }\n      }\n      // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions\n      // only during development.\n      if (NG_DEV_MODE && !actionHasBeenHandled) {\n        const unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);\n        // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the\n        // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`\n        // didn't return `null` so we may ensure the module has been imported.\n        if (unhandledActionsLogger) {\n          unhandledActionsLogger.warn(action);\n        }\n      }\n      if (!results.length) {\n        results.push(of({}));\n      }\n      return forkJoin(results);\n    }\n    addToStatesMap(stateClasses) {\n      const newStates = [];\n      const statesMap = this.statesByName;\n      for (const stateClass of stateClasses) {\n        const stateName = getStoreMetadata$1(stateClass).name;\n        if (NG_DEV_MODE) {\n          ensureStateNameIsUnique(stateName, stateClass, statesMap);\n        }\n        const unmountedState = !statesMap[stateName];\n        if (unmountedState) {\n          newStates.push(stateClass);\n          statesMap[stateName] = stateClass;\n        }\n      }\n      return {\n        newStates\n      };\n    }\n    addRuntimeInfoToMeta(meta, path) {\n      this.statePaths[meta.name] = path;\n      // TODO: v4 - we plan to get rid of the path property because it is non-deterministic\n      // we can do this when we get rid of the incorrectly exposed getStoreMetadata\n      // We will need to come up with an alternative in v4 because this is used by many plugins\n      meta.path = path;\n    }\n    hasBeenMountedAndBootstrapped(name, path) {\n      const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;\n      // This checks whether a state has been already added to the global graph and\n      // its lifecycle is in 'bootstrapped' state.\n      return this.statesByName[name] && valueIsBootstrappedInInitialState;\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */StateFactory.ɵfac = function StateFactory_Factory(t) {\n    return new (t || StateFactory)(i0.ɵɵinject(i0.Injector), i0.ɵɵinject(NgxsConfig), i0.ɵɵinject(StateFactory, 12), i0.ɵɵinject(InternalActions), i0.ɵɵinject(InternalDispatchedActionResults), i0.ɵɵinject(StateContextFactory), i0.ɵɵinject(INITIAL_STATE_TOKEN, 8));\n  };\n  StateFactory.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: StateFactory,\n    factory: StateFactory.ɵfac\n  });\n  return StateFactory;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {\n  return context => {\n    const {\n      argumentSelectorFunctions,\n      selectorOptions\n    } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);\n    return function selectFromRoot(rootState) {\n      // Determine arguments from the app state using the selectors\n      const results = argumentSelectorFunctions.map(argFn => argFn(rootState));\n      // if the lambda tries to access a something on the\n      // state that doesn't exist, it will throw a TypeError.\n      // since this is quite usual behaviour, we simply return undefined if so.\n      try {\n        return memoizedSelectorFn(...results);\n      } catch (ex) {\n        if (ex instanceof TypeError && selectorOptions.suppressErrors) {\n          return undefined;\n        }\n        throw ex;\n      }\n    };\n  };\n}\nfunction createMemoizedSelectorFn(originalFn, creationMetadata) {\n  const containerClass = creationMetadata && creationMetadata.containerClass;\n  const wrappedFn = function wrappedSelectorFn(...args) {\n    const returnValue = originalFn.apply(containerClass, args);\n    if (returnValue instanceof Function) {\n      const innerMemoizedFn = memoize.apply(null, [returnValue]);\n      return innerMemoizedFn;\n    }\n    return returnValue;\n  };\n  const memoizedFn = memoize(wrappedFn);\n  Object.setPrototypeOf(memoizedFn, originalFn);\n  return memoizedFn;\n}\nfunction getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {\n  const localSelectorOptions = selectorMetaData.getSelectorOptions();\n  const selectorOptions = context.getSelectorOptions(localSelectorOptions);\n  const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);\n  const argumentSelectorFunctions = selectorsToApply.map(selector => {\n    const factory = getRootSelectorFactory(selector);\n    return factory(context);\n  });\n  return {\n    selectorOptions,\n    argumentSelectorFunctions\n  };\n}\nfunction getSelectorsToApply(selectors = [], selectorOptions, containerClass) {\n  const selectorsToApply = [];\n  const canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;\n  if (containerClass && canInjectContainerState) {\n    // If we are on a state class, add it as the first selector parameter\n    const metadata = getStoreMetadata$1(containerClass);\n    if (metadata) {\n      selectorsToApply.push(containerClass);\n    }\n  }\n  if (selectors) {\n    selectorsToApply.push(...selectors);\n  }\n  return selectorsToApply;\n}\n/**\n * This function gets the factory function to create the selector to get the selected slice from the app state\n * @ignore\n */\nfunction getRootSelectorFactory(selector) {\n  const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);\n  return metadata && metadata.makeRootSelector || (() => selector);\n}\n\n// tslint:disable:unified-signatures\nlet Store = /*#__PURE__*/(() => {\n  class Store {\n    constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {\n      this._stateStream = _stateStream;\n      this._internalStateOperations = _internalStateOperations;\n      this._config = _config;\n      this._internalExecutionStrategy = _internalExecutionStrategy;\n      this._stateFactory = _stateFactory;\n      /**\n       * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n       * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n       * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n       */\n      this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({\n        bufferSize: 1,\n        refCount: true\n      }));\n      this.initStateStream(initialStateValue);\n    }\n    /**\n     * Dispatches event(s).\n     */\n    dispatch(actionOrActions) {\n      return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n    }\n    select(selector) {\n      const selectorFn = this.getStoreBoundSelectorFn(selector);\n      return this._selectableStateStream.pipe(map(selectorFn), catchError(err => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const {\n          suppressErrors\n        } = this._config.selectorOptions;\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n        // rethrow other errors\n        return throwError(err);\n      }), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));\n    }\n    selectOnce(selector) {\n      return this.select(selector).pipe(take(1));\n    }\n    selectSnapshot(selector) {\n      const selectorFn = this.getStoreBoundSelectorFn(selector);\n      return selectorFn(this._stateStream.getValue());\n    }\n    /**\n     * Allow the user to subscribe to the root of the state\n     */\n    subscribe(fn) {\n      return this._selectableStateStream.pipe(leaveNgxs(this._internalExecutionStrategy)).subscribe(fn);\n    }\n    /**\n     * Return the raw value of the state.\n     */\n    snapshot() {\n      return this._internalStateOperations.getRootStateOperations().getState();\n    }\n    /**\n     * Reset the state to a specific point in time. This method is useful\n     * for plugin's who need to modify the state directly or unit testing.\n     */\n    reset(state) {\n      return this._internalStateOperations.getRootStateOperations().setState(state);\n    }\n    getStoreBoundSelectorFn(selector) {\n      const makeSelectorFn = getRootSelectorFactory(selector);\n      const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n      return makeSelectorFn(runtimeContext);\n    }\n    initStateStream(initialStateValue) {\n      const value = this._stateStream.value;\n      const storeIsEmpty = !value || Object.keys(value).length === 0;\n      if (storeIsEmpty) {\n        const defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;\n        const storeValues = defaultStateNotEmpty ? Object.assign(Object.assign({}, this._config.defaultsState), initialStateValue) : initialStateValue;\n        this._stateStream.next(storeValues);\n      }\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */Store.ɵfac = function Store_Factory(t) {\n    return new (t || Store)(i0.ɵɵinject(StateStream), i0.ɵɵinject(InternalStateOperations), i0.ɵɵinject(NgxsConfig), i0.ɵɵinject(InternalNgxsExecutionStrategy), i0.ɵɵinject(StateFactory), i0.ɵɵinject(INITIAL_STATE_TOKEN, 8));\n  };\n  Store.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: Store,\n    factory: Store.ɵfac,\n    providedIn: 'root'\n  });\n  return Store;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Allows the select decorator to get access to the DI store, this is used internally\n * in `@Select` decorator.\n */\nlet SelectFactory = /*#__PURE__*/(() => {\n  class SelectFactory {\n    constructor(store, config) {\n      SelectFactory.store = store;\n      SelectFactory.config = config;\n    }\n    ngOnDestroy() {\n      SelectFactory.store = null;\n      SelectFactory.config = null;\n    }\n  }\n  SelectFactory.store = null;\n  SelectFactory.config = null;\n  /** @nocollapse */\n  /** @nocollapse */\n  SelectFactory.ɵfac = function SelectFactory_Factory(t) {\n    return new (t || SelectFactory)(i0.ɵɵinject(Store), i0.ɵɵinject(NgxsConfig));\n  };\n  SelectFactory.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: SelectFactory,\n    factory: SelectFactory.ɵfac,\n    providedIn: 'root'\n  });\n  return SelectFactory;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet LifecycleStateManager = /*#__PURE__*/(() => {\n  class LifecycleStateManager {\n    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {\n      this._store = _store;\n      this._internalErrorReporter = _internalErrorReporter;\n      this._internalStateOperations = _internalStateOperations;\n      this._stateContextFactory = _stateContextFactory;\n      this._bootstrapper = _bootstrapper;\n      this._destroy$ = new Subject();\n    }\n    ngOnDestroy() {\n      this._destroy$.next();\n    }\n    ngxsBootstrap(action, results) {\n      this._internalStateOperations.getRootStateOperations().dispatch(action).pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._bootstrapper.appBootstrapped$), filter(appBootstrapped => !!appBootstrapped), catchError(error => {\n        // The `SafeSubscriber` (which is used by most RxJS operators) re-throws\n        // errors asynchronously (`setTimeout(() => { throw error })`). This might\n        // break existing user's code or unit tests. We catch the error manually to\n        // be backward compatible with the old behavior.\n        this._internalErrorReporter.reportErrorSafely(error);\n        return EMPTY;\n      }), takeUntil(this._destroy$)).subscribe(() => this._invokeBootstrapOnStates(results.states));\n    }\n    _invokeInitOnStates(mappedStores) {\n      for (const mappedStore of mappedStores) {\n        const instance = mappedStore.instance;\n        if (instance.ngxsOnChanges) {\n          this._store.select(state => getValue(state, mappedStore.path)).pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$)).subscribe(([previousValue, currentValue]) => {\n            const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);\n            instance.ngxsOnChanges(change);\n          });\n        }\n        if (instance.ngxsOnInit) {\n          instance.ngxsOnInit(this._getStateContext(mappedStore));\n        }\n        mappedStore.isInitialised = true;\n      }\n    }\n    _invokeBootstrapOnStates(mappedStores) {\n      for (const mappedStore of mappedStores) {\n        const instance = mappedStore.instance;\n        if (instance.ngxsAfterBootstrap) {\n          instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));\n        }\n      }\n    }\n    _getStateContext(mappedStore) {\n      return this._stateContextFactory.createStateContext(mappedStore);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */LifecycleStateManager.ɵfac = function LifecycleStateManager_Factory(t) {\n    return new (t || LifecycleStateManager)(i0.ɵɵinject(Store), i0.ɵɵinject(InternalErrorReporter), i0.ɵɵinject(InternalStateOperations), i0.ɵɵinject(StateContextFactory), i0.ɵɵinject(i5.NgxsBootstrapper));\n  };\n  LifecycleStateManager.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: LifecycleStateManager,\n    factory: LifecycleStateManager.ɵfac,\n    providedIn: 'root'\n  });\n  return LifecycleStateManager;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Root module\n * @ignore\n */\nlet NgxsRootModule = /*#__PURE__*/(() => {\n  class NgxsRootModule {\n    constructor(factory, internalStateOperations, _store, _select, states = [], lifecycleStateManager) {\n      // Add stores to the state graph and return their defaults\n      const results = factory.addAndReturnDefaults(states);\n      internalStateOperations.setStateToTheCurrentWithNew(results);\n      // Connect our actions stream\n      factory.connectActionHandlers();\n      // Dispatch the init action and invoke init and bootstrap functions after\n      lifecycleStateManager.ngxsBootstrap(new InitState(), results);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */\n  /** @nocollapse */NgxsRootModule.ɵfac = function NgxsRootModule_Factory(t) {\n    return new (t || NgxsRootModule)(i0.ɵɵinject(StateFactory), i0.ɵɵinject(InternalStateOperations), i0.ɵɵinject(Store), i0.ɵɵinject(SelectFactory), i0.ɵɵinject(ROOT_STATE_TOKEN, 8), i0.ɵɵinject(LifecycleStateManager));\n  };\n  NgxsRootModule.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n    type: NgxsRootModule\n  });\n  NgxsRootModule.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n  return NgxsRootModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Feature module\n * @ignore\n */\nlet NgxsFeatureModule = /*#__PURE__*/(() => {\n  class NgxsFeatureModule {\n    constructor(_store, internalStateOperations, factory, states = [], lifecycleStateManager) {\n      // Since FEATURE_STATE_TOKEN is a multi token, we need to\n      // flatten it [[Feature1State, Feature2State], [Feature3State]]\n      const flattenedStates = NgxsFeatureModule.flattenStates(states);\n      // add stores to the state graph and return their defaults\n      const results = factory.addAndReturnDefaults(flattenedStates);\n      if (results.states.length) {\n        internalStateOperations.setStateToTheCurrentWithNew(results);\n        // dispatch the update action and invoke init and bootstrap functions after\n        lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);\n      }\n    }\n    static flattenStates(states = []) {\n      return states.reduce((total, values) => total.concat(values), []);\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */\n  /** @nocollapse */NgxsFeatureModule.ɵfac = function NgxsFeatureModule_Factory(t) {\n    return new (t || NgxsFeatureModule)(i0.ɵɵinject(Store), i0.ɵɵinject(InternalStateOperations), i0.ɵɵinject(StateFactory), i0.ɵɵinject(FEATURE_STATE_TOKEN, 8), i0.ɵɵinject(LifecycleStateManager));\n  };\n  NgxsFeatureModule.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n    type: NgxsFeatureModule\n  });\n  NgxsFeatureModule.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n  return NgxsFeatureModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Ngxs Module\n */\nlet NgxsModule = /*#__PURE__*/(() => {\n  class NgxsModule {\n    /**\n     * Root module factory\n     */\n    static forRoot(states = [], options = {}) {\n      return {\n        ngModule: NgxsRootModule,\n        providers: [StateFactory, PluginManager, ...states, ...NgxsModule.ngxsTokenProviders(states, options)]\n      };\n    }\n    /**\n     * Feature module factory\n     */\n    static forFeature(states = []) {\n      return {\n        ngModule: NgxsFeatureModule,\n        providers: [\n        // This is required on the feature level, see comments in `state-factory.ts`.\n        StateFactory, PluginManager, ...states, {\n          provide: FEATURE_STATE_TOKEN,\n          multi: true,\n          useValue: states\n        }]\n      };\n    }\n    static ngxsTokenProviders(states, options) {\n      return [{\n        provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,\n        useValue: options.executionStrategy\n      }, {\n        provide: ROOT_STATE_TOKEN,\n        useValue: states\n      }, {\n        provide: ROOT_OPTIONS,\n        useValue: options\n      }, {\n        provide: APP_BOOTSTRAP_LISTENER,\n        useFactory: NgxsModule.appBootstrapListenerFactory,\n        multi: true,\n        deps: [NgxsBootstrapper]\n      }, {\n        provide: ɵNGXS_STATE_CONTEXT_FACTORY,\n        useExisting: StateContextFactory\n      }, {\n        provide: ɵNGXS_STATE_FACTORY,\n        useExisting: StateFactory\n      }];\n    }\n    static appBootstrapListenerFactory(bootstrapper) {\n      return () => bootstrapper.bootstrap();\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */\n  /** @nocollapse */NgxsModule.ɵfac = function NgxsModule_Factory(t) {\n    return new (t || NgxsModule)();\n  };\n  NgxsModule.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n    type: NgxsModule\n  });\n  NgxsModule.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n  return NgxsModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Decorates a method with a action information.\n */\nfunction Action(actions, options) {\n  return (target, name) => {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const isStaticMethod = target.hasOwnProperty('prototype');\n      if (isStaticMethod) {\n        throwActionDecoratorError();\n      }\n    }\n    const meta = ensureStoreMetadata$1(target.constructor);\n    if (!Array.isArray(actions)) {\n      actions = [actions];\n    }\n    for (const action of actions) {\n      const type = action.type;\n      if (!meta.actions[type]) {\n        meta.actions[type] = [];\n      }\n      meta.actions[type].push({\n        fn: name,\n        options: options || {},\n        type\n      });\n    }\n  };\n}\n\n/**\n * Decorates a class with ngxs state information.\n */\nfunction State(options) {\n  return target => {\n    const stateClass = target;\n    const meta = ensureStoreMetadata$1(stateClass);\n    const inheritedStateClass = Object.getPrototypeOf(stateClass);\n    const optionsWithInheritance = getStateOptions(inheritedStateClass, options);\n    mutateMetaData({\n      meta,\n      inheritedStateClass,\n      optionsWithInheritance\n    });\n    stateClass[META_OPTIONS_KEY] = optionsWithInheritance;\n  };\n}\nfunction getStateOptions(inheritedStateClass, options) {\n  const inheritanceOptions = inheritedStateClass[META_OPTIONS_KEY] || {};\n  return Object.assign(Object.assign({}, inheritanceOptions), options);\n}\nfunction mutateMetaData(params) {\n  const {\n    meta,\n    inheritedStateClass,\n    optionsWithInheritance\n  } = params;\n  const {\n    children,\n    defaults,\n    name\n  } = optionsWithInheritance;\n  const stateName = typeof name === 'string' ? name : name && name.getName() || null;\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    ensureStateNameIsValid(stateName);\n  }\n  if (inheritedStateClass.hasOwnProperty(META_KEY)) {\n    const inheritedMeta = inheritedStateClass[META_KEY] || {};\n    meta.actions = Object.assign(Object.assign({}, meta.actions), inheritedMeta.actions);\n  }\n  meta.children = children;\n  meta.defaults = defaults;\n  meta.name = stateName;\n}\nconst DOLLAR_CHAR_CODE = 36;\nfunction createSelectObservable(selector) {\n  if (!SelectFactory.store) {\n    throwSelectFactoryNotConnectedError();\n  }\n  return SelectFactory.store.select(selector);\n}\nfunction createSelectorFn(name, rawSelector, paths = []) {\n  rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;\n  if (typeof rawSelector === 'string') {\n    const propsArray = paths.length ? [rawSelector, ...paths] : rawSelector.split('.');\n    return propGetter(propsArray, SelectFactory.config);\n  }\n  return rawSelector;\n}\n/**\n * @example If `foo$` => make it just `foo`\n */\nfunction removeDollarAtTheEnd(name) {\n  const lastCharIndex = name.length - 1;\n  const dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;\n  return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;\n}\n\n/**\n * Decorator for selecting a slice of state from the store.\n */\nfunction Select(rawSelector, ...paths) {\n  return function (target, key) {\n    const name = key.toString();\n    const selectorId = `__${name}__selector`;\n    const selector = createSelectorFn(name, rawSelector, paths);\n    Object.defineProperties(target, {\n      [selectorId]: {\n        writable: true,\n        enumerable: false,\n        configurable: true\n      },\n      [name]: {\n        enumerable: true,\n        configurable: true,\n        get() {\n          return this[selectorId] || (this[selectorId] = createSelectObservable(selector));\n        }\n      }\n    });\n  };\n}\nconst SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';\nconst selectorOptionsMetaAccessor = {\n  getOptions: target => {\n    return target && target[SELECTOR_OPTIONS_META_KEY] || {};\n  },\n  defineOptions: (target, options) => {\n    if (!target) return;\n    target[SELECTOR_OPTIONS_META_KEY] = options;\n  }\n};\nfunction setupSelectorMetadata(originalFn, creationMetadata) {\n  const selectorMetaData = ensureSelectorMetadata$1(originalFn);\n  selectorMetaData.originalFn = originalFn;\n  let getExplicitSelectorOptions = () => ({});\n  if (creationMetadata) {\n    selectorMetaData.containerClass = creationMetadata.containerClass;\n    selectorMetaData.selectorName = creationMetadata.selectorName || null;\n    getExplicitSelectorOptions = creationMetadata.getSelectorOptions || getExplicitSelectorOptions;\n  }\n  const selectorMetaDataClone = Object.assign({}, selectorMetaData);\n  selectorMetaData.getSelectorOptions = () => getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());\n  return selectorMetaData;\n}\nfunction getLocalSelectorOptions(selectorMetaData, explicitOptions) {\n  return Object.assign(Object.assign(Object.assign(Object.assign({}, selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}), selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}), selectorMetaData.getSelectorOptions() || {}), explicitOptions);\n}\n\n/**\n * Decorator for setting selector options at a method or class level.\n */\nfunction SelectorOptions(options) {\n  return function decorate(target, methodName, descriptor) {\n    if (methodName) {\n      descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, methodName));\n      // Method Decorator\n      const originalFn = descriptor.value || descriptor.originalFn;\n      if (originalFn) {\n        selectorOptionsMetaAccessor.defineOptions(originalFn, options);\n      }\n    } else {\n      // Class Decorator\n      selectorOptionsMetaAccessor.defineOptions(target, options);\n    }\n  };\n}\nfunction ensureStoreMetadata(target) {\n  return ensureStoreMetadata$1(target);\n}\nfunction getStoreMetadata(target) {\n  return getStoreMetadata$1(target);\n}\nfunction ensureSelectorMetadata(target) {\n  return ensureSelectorMetadata$1(target);\n}\nfunction getSelectorMetadata(target) {\n  return getSelectorMetadata$1(target);\n}\nfunction createSelector(selectors, projector, creationMetadata) {\n  const memoizedFn = createMemoizedSelectorFn(projector, creationMetadata);\n  const selectorMetaData = setupSelectorMetadata(projector, creationMetadata);\n  selectorMetaData.makeRootSelector = createRootSelectorFactory(selectorMetaData, selectors, memoizedFn);\n  return memoizedFn;\n}\nfunction Selector(selectors) {\n  return (target, key, descriptor) => {\n    descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, key));\n    const originalFn = descriptor === null || descriptor === void 0 ? void 0 : descriptor.value;\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      if (originalFn && typeof originalFn !== 'function') {\n        throwSelectorDecoratorError();\n      }\n    }\n    const memoizedFn = createSelector(selectors, originalFn, {\n      containerClass: target,\n      selectorName: key.toString(),\n      getSelectorOptions() {\n        return {};\n      }\n    });\n    const newDescriptor = {\n      configurable: true,\n      get() {\n        return memoizedFn;\n      }\n    };\n    // Add hidden property to descriptor\n    newDescriptor['originalFn'] = originalFn;\n    return newDescriptor;\n  };\n}\nclass StateToken {\n  constructor(name) {\n    this.name = name;\n    const selectorMetadata = ensureSelectorMetadata$1(this);\n    selectorMetadata.makeRootSelector = runtimeContext => {\n      return runtimeContext.getStateGetter(this.name);\n    };\n  }\n  getName() {\n    return this.name;\n  }\n  toString() {\n    return `StateToken[${this.name}]`;\n  }\n}\nlet NgxsDevelopmentModule = /*#__PURE__*/(() => {\n  class NgxsDevelopmentModule {\n    static forRoot(options) {\n      return {\n        ngModule: NgxsDevelopmentModule,\n        providers: [NgxsUnhandledActionsLogger, {\n          provide: NGXS_DEVELOPMENT_OPTIONS,\n          useValue: options\n        }]\n      };\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */\n  /** @nocollapse */NgxsDevelopmentModule.ɵfac = function NgxsDevelopmentModule_Factory(t) {\n    return new (t || NgxsDevelopmentModule)();\n  };\n  NgxsDevelopmentModule.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n    type: NgxsDevelopmentModule\n  });\n  NgxsDevelopmentModule.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n  return NgxsDevelopmentModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction ensureValidSelector(selector, context = {}) {\n  const noun = context.noun || 'selector';\n  const prefix = context.prefix ? context.prefix + ': ' : '';\n  ensureValueProvided(selector, {\n    noun,\n    prefix: context.prefix\n  });\n  const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);\n  if (!metadata) {\n    throw new Error(`${prefix}The value provided as the ${noun} is not a valid selector.`);\n  }\n}\nfunction ensureValueProvided(value, context = {}) {\n  const noun = context.noun || 'value';\n  const prefix = context.prefix ? context.prefix + ': ' : '';\n  if (!value) {\n    throw new Error(`${prefix}A ${noun} must be provided.`);\n  }\n}\nfunction createModelSelector(selectorMap) {\n  const selectorKeys = Object.keys(selectorMap);\n  const selectors = Object.values(selectorMap);\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    ensureValidSelectorMap({\n      prefix: '[createModelSelector]',\n      selectorMap,\n      selectorKeys,\n      selectors\n    });\n  }\n  return createSelector(selectors, (...args) => {\n    return selectorKeys.reduce((obj, key, index) => {\n      obj[key] = args[index];\n      return obj;\n    }, {});\n  });\n}\nfunction ensureValidSelectorMap({\n  prefix,\n  selectorMap,\n  selectorKeys,\n  selectors\n}) {\n  ensureValueProvided(selectorMap, {\n    prefix,\n    noun: 'selector map'\n  });\n  ensureValueProvided(typeof selectorMap === 'object', {\n    prefix,\n    noun: 'valid selector map'\n  });\n  ensureValueProvided(selectorKeys.length, {\n    prefix,\n    noun: 'non-empty selector map'\n  });\n  selectors.forEach((selector, index) => ensureValidSelector(selector, {\n    prefix,\n    noun: `selector for the '${selectorKeys[index]}' property`\n  }));\n}\nfunction createPickSelector(selector, keys) {\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    ensureValidSelector(selector, {\n      prefix: '[createPickSelector]'\n    });\n  }\n  const validKeys = keys.filter(Boolean);\n  const selectors = validKeys.map(key => createSelector([selector], s => s[key]));\n  return createSelector([...selectors], (...props) => {\n    return validKeys.reduce((acc, key, index) => {\n      acc[key] = props[index];\n      return acc;\n    }, {});\n  });\n}\nfunction createPropertySelectors(parentSelector) {\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    ensureValidSelector(parentSelector, {\n      prefix: '[createPropertySelectors]',\n      noun: 'parent selector'\n    });\n  }\n  const cache = {};\n  return new Proxy({}, {\n    get(_target, prop) {\n      const selector = cache[prop] || createSelector([parentSelector], s => s === null || s === void 0 ? void 0 : s[prop]);\n      cache[prop] = selector;\n      return selector;\n    }\n  });\n}\n\n/**\n * The public api for consumers of @ngxs/store\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { Action, Actions, InitState, NGXS_PLUGINS, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ensureSelectorMetadata, ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata, getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };\n","import {HttpErrorResponse} from '@angular/common/http';\nimport {SeverityLevel} from '@microsoft/applicationinsights-web';\nimport {AppInsightsService} from 'src/app/core/app-insights/app-insights.service';\n\nexport interface IErrorHandlerArgs {\n    error: any;\n    appInsightsSrv: AppInsightsService;\n    fallbackMessage?: string;\n\n    /** Usually it is class SomeService.name, but this approach can't be used due to minification, need to place 'SomeService'*/\n    scope?: string;\n};\n\nexport const errorHandler = (arg: IErrorHandlerArgs): void => {\n    const {error, appInsightsSrv, fallbackMessage, scope} = arg;\n    console.error(error);\n    let trackEventMessage = '';\n    if (error instanceof HttpErrorResponse) {\n        trackEventMessage = JSON.stringify({...error, error: typeof error.error === 'object' ? JSON.stringify(error.error) : error.error});\n    } else {\n        trackEventMessage = `${fallbackMessage}${scope ? ('(scope ' + scope + ')'): ''}: ${error}`;\n    }\n    appInsightsSrv.trackTrace(\n        {\n            message: trackEventMessage,\n            severityLevel: SeverityLevel.Error,\n        });\n}\n\nexport const httpErrorToString = (error: HttpErrorResponse, fallbackMessage = 'Unknown error'): string => {\n    if (Array.isArray(error?.error) && error?.error?.[0]?.errorMessage) {\n        return error?.error?.map((e) => e.errorMessage).join('\\n');\n    }\n    return error?.error?.message ?? error?.error ?? error?.message ?? `${error.statusText} - ${fallbackMessage}`;\n};"],"mappings":"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","names":["NgxsBootstrapper","ReplaySubject","t","ɵɵdefineInjectable","defaultEqualityCheck","a","b","areArgumentsShallowlyEqual","equalityCheck","prev","next","length","i","memoize","func","lastArgs","lastResult","memoized","InitialState","state","INITIAL_STATE_TOKEN","InjectionToken","ɵNGXS_STATE_FACTORY","ɵNGXS_STATE_CONTEXT_FACTORY","isStateOperator","value","getActionTypeFromInstance","action","setValue","obj","prop","val","split","lastIndex","acc","part","index","getValue","isObject$1","item","mergeDeep","base","sources","source","key","throwStateUniqueError","current","newName","oldName","throwStateDecoratorError","name","getUndecoratedStateInIvyWarningMessage","name","throwSelectFactoryNotConnectedError","DispatchOutsideZoneNgxsExecutionStrategy","_ngZone","_platformId","func","isPlatformServer","NgZone","t","ɵɵinject","PLATFORM_ID","ɵɵdefineInjectable","ROOT_OPTIONS","InjectionToken","ROOT_STATE_TOKEN","FEATURE_STATE_TOKEN","NGXS_PLUGINS","META_KEY","META_OPTIONS_KEY","SELECTOR_META_KEY","NgxsConfig","DispatchOutsideZoneNgxsExecutionStrategy","t","ɵɵdefineInjectable","r","options","mergeDeep","ɵɵinject","NgxsSimpleChange","previousValue","currentValue","firstChange","NoopNgxsExecutionStrategy","func","USER_PROVIDED_NGXS_EXECUTION_STRATEGY","NGXS_EXECUTION_STRATEGY","injector","inject","INJECTOR$1","executionStrategy","_global","ensureStoreMetadata$1","target","defaultMetadata","context","getStoreMetadata$1","ensureSelectorMetadata$1","getSelectorMetadata$1","compliantPropGetter","paths","copyOfPaths","obj","acc","part","fastPropGetter","segments","seg","i","l","expr","propGetter","config","buildGraph","stateClasses","findName","stateClass","g","result","name","children","nameToState","states","meta","findFullParentPath","newObj","visit","child","keyToFind","key","parent","topologicalSort","graph","sorted","visited","ancestors","dep","k","isObject","ofActionDispatched","allowedTypes","ofActionOperator","ofActionOperator","allowedTypes","statuses","mapOperator","mapAction","allowedMap","createAllowedActionTypesMap","allowedStatusMap","createAllowedStatusesMap","o","filterStatus","allowedStatuses","filter","ctx","actionType","getActionTypeFromInstance","typeMatch","statusMatch","mapAction","map","ctx","createAllowedActionTypesMap","types","filterMap","klass","getActionTypeFromInstance","createAllowedStatusesMap","statuses","status","leaveNgxs","ngxsExecutionStrategy","source","Observable","sink","value","error","InternalNgxsExecutionStrategy","_executionStrategy","func","t","ɵɵinject","NGXS_EXECUTION_STRATEGY","ɵɵdefineInjectable","orderedQueueOperation","operation","callsQueue","busyPushingNext","args","nextCallArgs","OrderedSubject","Subject","OrderedBehaviorSubject","BehaviorSubject","InternalActions","ɵInternalActions_BaseFactory","ɵɵgetInheritedFactory","Actions","internalActions$","internalExecutionStrategy","sharedInternalActions$","share","observer","childSubscription","compose","funcs","nextArgs","ngxsErrorHandler","internalErrorReporter","subscribed","subscriber","InternalErrorReporter","_injector","ErrorHandler","Injector","StateStream","PluginManager","_parentManager","_pluginHandlers","pluginHandlers","plugin","NGXS_PLUGINS","InternalDispatchedActionResults","ɵInternalDispatchedActionResults_BaseFactory","InternalDispatcher","_actions","_actionResults","_pluginManager","_stateStream","_ngxsExecutionStrategy","_internalErrorReporter","actionOrActions","of","forkJoin","action","prevState","plugins","nextState","nextAction","actionResult$","shareReplay","filter","take","exhaustMap","throwError","EMPTY","InternalStateOperations","_stateStream","_dispatcher","_config","newState","actionOrActions","results","stateOperations","currentState","t","ɵɵinject","StateStream","InternalDispatcher","NgxsConfig","ɵɵdefineInjectable","simplePatch","value","existingState","newState","key","StateContextFactory","_internalStateOperations","mappedStore","root","currentAppState","getState","val","patchOperator","setStateFromOperator","isStateOperator","setStateValue","actions","t","ɵɵinject","InternalStateOperations","ɵɵdefineInjectable","newValue","path","newAppState","setValue","stateOperator","local","getValue","stateNameRegex","ensureStateNameIsUnique","stateName","state","statesByName","existingState","throwStateUniqueError","ensureStatesAreDecorated","stateClasses","stateClass","getStoreMetadata$1","throwStateDecoratorError","ensureStateClassIsInjectable","jit_hasInjectableAnnotation","aot_hasNgInjectableDef","getUndecoratedStateInIvyWarningMessage","annotation","InitState","UpdateState","addedStates","NGXS_DEVELOPMENT_OPTIONS","InjectionToken","NgxsUnhandledActionsLogger","options","actions","action","type","getActionTypeFromInstance","t","ɵɵinject","ɵɵdefineInjectable","NG_DEV_MODE","StateFactory","_injector","_config","_parentFactory","_actions","_actionResults","_stateContextFactory","_initialState","memoize","stateFactory","resolveGetter","key","path","propGetter","getter","args","localOptions","globalSelectorOptions","defaults","value","isObject","_a","newStates","stateGraph","buildGraph","sortedStates","topologicalSort","paths","findFullParentPath","nameGraph","nameToState","bootstrappedStores","name","meta","META_KEY","stateMap","classes","mappedStores","result","mappedStore","setValue","dispatched$","Subject","filter","ctx","mergeMap","map","defaultIfEmpty","catchError","error","of","results","actionHasBeenHandled","metadata","actionMetas","actionMeta","stateContext","from","isObservable","takeUntil","ofActionDispatched","shareReplay","e","throwError","unhandledActionsLogger","forkJoin","statesMap","valueIsBootstrappedInInitialState","getValue","Injector","NgxsConfig","InternalActions","InternalDispatchedActionResults","StateContextFactory","INITIAL_STATE_TOKEN","createRootSelectorFactory","selectorMetaData","selectors","memoizedSelectorFn","context","argumentSelectorFunctions","selectorOptions","getRuntimeSelectorInfo","rootState","argFn","ex","createMemoizedSelectorFn","originalFn","creationMetadata","containerClass","memoizedFn","returnValue","localSelectorOptions","getSelectorsToApply","selector","getRootSelectorFactory","selectorsToApply","canInjectContainerState","getSelectorMetadata$1","Store","_stateStream","_internalStateOperations","_internalExecutionStrategy","_stateFactory","initialStateValue","leaveNgxs","actionOrActions","selectorFn","err","suppressErrors","distinctUntilChanged","take","fn","makeSelectorFn","runtimeContext","storeValues","StateStream","InternalStateOperations","InternalNgxsExecutionStrategy","SelectFactory","store","config","LifecycleStateManager","_store","_internalErrorReporter","_bootstrapper","tap","appBootstrapped","EMPTY","instance","startWith","pairwise","previousValue","currentValue","change","NgxsSimpleChange","InternalErrorReporter","NgxsBootstrapper","NgxsRootModule","factory","internalStateOperations","_select","states","lifecycleStateManager","ROOT_STATE_TOKEN","ɵɵdefineNgModule","ɵɵdefineInjector","NgxsFeatureModule","flattenedStates","total","values","FEATURE_STATE_TOKEN","NgxsModule","PluginManager","USER_PROVIDED_NGXS_EXECUTION_STRATEGY","ROOT_OPTIONS","APP_BOOTSTRAP_LISTENER","ɵNGXS_STATE_CONTEXT_FACTORY","ɵNGXS_STATE_FACTORY","bootstrapper","Action","target","ensureStoreMetadata$1","State","inheritedStateClass","optionsWithInheritance","getStateOptions","mutateMetaData","META_OPTIONS_KEY","inheritanceOptions","params","children","inheritedMeta","DOLLAR_CHAR_CODE","createSelectObservable","throwSelectFactoryNotConnectedError","createSelectorFn","rawSelector","removeDollarAtTheEnd","propsArray","lastCharIndex","Select","selectorId","SELECTOR_OPTIONS_META_KEY","selectorOptionsMetaAccessor","setupSelectorMetadata","ensureSelectorMetadata$1","getExplicitSelectorOptions","selectorMetaDataClone","getLocalSelectorOptions","explicitOptions","createSelector","selectors","projector","creationMetadata","memoizedFn","createMemoizedSelectorFn","selectorMetaData","setupSelectorMetadata","createRootSelectorFactory","Selector","target","key","descriptor","originalFn","newDescriptor","errorHandler","arg","error","appInsightsSrv","fallbackMessage","scope","console","trackEventMessage","HttpErrorResponse","JSON","stringify","__spreadProps","__spreadValues","trackTrace","message","severityLevel","SeverityLevel","Error","httpErrorToString","Array","isArray","errorMessage","map","e","join","statusText"],"x_google_ignoreList":[0,1,2]}