{"version":3,"file":"reselect-HBGHfvfV.js","sources":["../../node_modules/reselect/es/defaultMemoize.js","../../node_modules/reselect/es/index.js"],"sourcesContent":["// Cache implementation based on Erik Rasmussen's `lru-memoize`:\n// https://github.com/erikras/lru-memoize\nvar NOT_FOUND = 'NOT_FOUND';\n\nfunction createSingletonCache(equals) {\n  var entry;\n  return {\n    get: function get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n\n      return NOT_FOUND;\n    },\n    put: function put(key, value) {\n      entry = {\n        key: key,\n        value: value\n      };\n    },\n    getEntries: function getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear: function clear() {\n      entry = undefined;\n    }\n  };\n}\n\nfunction createLruCache(maxSize, equals) {\n  var entries = [];\n\n  function get(key) {\n    var cacheIndex = entries.findIndex(function (entry) {\n      return equals(key, entry.key);\n    }); // We found a cached entry\n\n    if (cacheIndex > -1) {\n      var entry = entries[cacheIndex]; // Cached entry not at top of cache, move it to the top\n\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n\n      return entry.value;\n    } // No entry found in cache, return sentinel\n\n\n    return NOT_FOUND;\n  }\n\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      // TODO Is unshift slow?\n      entries.unshift({\n        key: key,\n        value: value\n      });\n\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n\n  function getEntries() {\n    return entries;\n  }\n\n  function clear() {\n    entries = [];\n  }\n\n  return {\n    get: get,\n    put: put,\n    getEntries: getEntries,\n    clear: clear\n  };\n}\n\nexport var defaultEqualityCheck = function defaultEqualityCheck(a, b) {\n  return a === b;\n};\nexport function createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    } // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n\n\n    var length = prev.length;\n\n    for (var i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n// defaultMemoize now supports a configurable cache size with LRU behavior,\n// and optional comparison of the result value with existing values\nexport function defaultMemoize(func, equalityCheckOrOptions) {\n  var providedOptions = typeof equalityCheckOrOptions === 'object' ? equalityCheckOrOptions : {\n    equalityCheck: equalityCheckOrOptions\n  };\n  var _providedOptions$equa = providedOptions.equalityCheck,\n      equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa,\n      _providedOptions$maxS = providedOptions.maxSize,\n      maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS,\n      resultEqualityCheck = providedOptions.resultEqualityCheck;\n  var comparator = createCacheKeyComparator(equalityCheck);\n  var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator); // we reference arguments instead of spreading them for performance reasons\n\n  function memoized() {\n    var value = cache.get(arguments);\n\n    if (value === NOT_FOUND) {\n      // @ts-ignore\n      value = func.apply(null, arguments);\n\n      if (resultEqualityCheck) {\n        var entries = cache.getEntries();\n        var matchingEntry = entries.find(function (entry) {\n          return resultEqualityCheck(entry.value, value);\n        });\n\n        if (matchingEntry) {\n          value = matchingEntry.value;\n        }\n      }\n\n      cache.put(arguments, value);\n    }\n\n    return value;\n  }\n\n  memoized.clearCache = function () {\n    return cache.clear();\n  };\n\n  return memoized;\n}","import { defaultMemoize, defaultEqualityCheck } from './defaultMemoize';\nexport { defaultMemoize, defaultEqualityCheck };\n\nfunction getDependencies(funcs) {\n  var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;\n\n  if (!dependencies.every(function (dep) {\n    return typeof dep === 'function';\n  })) {\n    var dependencyTypes = dependencies.map(function (dep) {\n      return typeof dep === 'function' ? \"function \" + (dep.name || 'unnamed') + \"()\" : typeof dep;\n    }).join(', ');\n    throw new Error(\"createSelector expects all input-selectors to be functions, but received the following types: [\" + dependencyTypes + \"]\");\n  }\n\n  return dependencies;\n}\n\nexport function createSelectorCreator(memoize) {\n  for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    memoizeOptionsFromArgs[_key - 1] = arguments[_key];\n  }\n\n  var createSelector = function createSelector() {\n    for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      funcs[_key2] = arguments[_key2];\n    }\n\n    var _recomputations = 0;\n\n    var _lastResult; // Due to the intricacies of rest params, we can't do an optional arg after `...funcs`.\n    // So, start by declaring the default value here.\n    // (And yes, the words 'memoize' and 'options' appear too many times in this next sequence.)\n\n\n    var directlyPassedOptions = {\n      memoizeOptions: undefined\n    }; // Normally, the result func or \"output selector\" is the last arg\n\n    var resultFunc = funcs.pop(); // If the result func is actually an _object_, assume it's our options object\n\n    if (typeof resultFunc === 'object') {\n      directlyPassedOptions = resultFunc; // and pop the real result func off\n\n      resultFunc = funcs.pop();\n    }\n\n    if (typeof resultFunc !== 'function') {\n      throw new Error(\"createSelector expects an output function after the inputs, but received: [\" + typeof resultFunc + \"]\");\n    } // Determine which set of options we're using. Prefer options passed directly,\n    // but fall back to options given to createSelectorCreator.\n\n\n    var _directlyPassedOption = directlyPassedOptions,\n        _directlyPassedOption2 = _directlyPassedOption.memoizeOptions,\n        memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2; // Simplifying assumption: it's unlikely that the first options arg of the provided memoizer\n    // is an array. In most libs I've looked at, it's an equality function or options object.\n    // Based on that, if `memoizeOptions` _is_ an array, we assume it's a full\n    // user-provided array of options. Otherwise, it must be just the _first_ arg, and so\n    // we wrap it in an array so we can apply it.\n\n    var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];\n    var dependencies = getDependencies(funcs);\n    var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {\n      _recomputations++; // apply arguments instead of spreading for performance.\n\n      return resultFunc.apply(null, arguments);\n    }].concat(finalMemoizeOptions)); // If a selector is called with the exact same arguments we don't need to traverse our dependencies again.\n\n    var selector = memoize(function dependenciesChecker() {\n      var params = [];\n      var length = dependencies.length;\n\n      for (var i = 0; i < length; i++) {\n        // apply arguments instead of spreading and mutate a local list of params for performance.\n        // @ts-ignore\n        params.push(dependencies[i].apply(null, arguments));\n      } // apply arguments instead of spreading for performance.\n\n\n      _lastResult = memoizedResultFunc.apply(null, params);\n      return _lastResult;\n    });\n    Object.assign(selector, {\n      resultFunc: resultFunc,\n      memoizedResultFunc: memoizedResultFunc,\n      dependencies: dependencies,\n      lastResult: function lastResult() {\n        return _lastResult;\n      },\n      recomputations: function recomputations() {\n        return _recomputations;\n      },\n      resetRecomputations: function resetRecomputations() {\n        return _recomputations = 0;\n      }\n    });\n    return selector;\n  }; // @ts-ignore\n\n\n  return createSelector;\n}\nexport var createSelector = /* #__PURE__ */createSelectorCreator(defaultMemoize);\n// Manual definition of state and output arguments\nexport var createStructuredSelector = function createStructuredSelector(selectors, selectorCreator) {\n  if (selectorCreator === void 0) {\n    selectorCreator = createSelector;\n  }\n\n  if (typeof selectors !== 'object') {\n    throw new Error('createStructuredSelector expects first argument to be an object ' + (\"where each property is a selector, instead received a \" + typeof selectors));\n  }\n\n  var objectKeys = Object.keys(selectors);\n  var resultSelector = selectorCreator( // @ts-ignore\n  objectKeys.map(function (key) {\n    return selectors[key];\n  }), function () {\n    for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      values[_key3] = arguments[_key3];\n    }\n\n    return values.reduce(function (composition, value, index) {\n      composition[objectKeys[index]] = value;\n      return composition;\n    }, {});\n  });\n  return resultSelector;\n};"],"names":["NOT_FOUND","createSingletonCache","equals","entry","key","value","createLruCache","maxSize","entries","get","cacheIndex","put","getEntries","clear","defaultEqualityCheck","a","b","createCacheKeyComparator","equalityCheck","prev","next","length","defaultMemoize","func","equalityCheckOrOptions","providedOptions","_providedOptions$equa","_providedOptions$maxS","resultEqualityCheck","comparator","cache","memoized","matchingEntry","getDependencies","funcs","dependencies","dep","dependencyTypes","createSelectorCreator","memoize","_len","memoizeOptionsFromArgs","_key","createSelector","_len2","_key2","_recomputations","_lastResult","directlyPassedOptions","resultFunc","_directlyPassedOption","_directlyPassedOption2","memoizeOptions","finalMemoizeOptions","memoizedResultFunc","selector","params","i"],"mappings":"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","x_google_ignoreList":[0,1]}