{"version":3,"file":"reselect-cb7e52fa.js","sources":["../../../node_modules/reselect/dist/reselect.mjs"],"sourcesContent":["// src/devModeChecks/identityFunctionCheck.ts\nvar runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {\n  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {\n    let isInputSameAsOutput = false;\n    try {\n      const emptyObject = {};\n      if (resultFunc(emptyObject) === emptyObject)\n        isInputSameAsOutput = true;\n    } catch {\n    }\n    if (isInputSameAsOutput) {\n      let stack = void 0;\n      try {\n        throw new Error();\n      } catch (e) {\n        ;\n        ({ stack } = e);\n      }\n      console.warn(\n        \"The result function returned its own inputs without modification. e.g\\n`createSelector([state => state.todos], todos => todos)`\\nThis could lead to inefficient memoization and unnecessary re-renders.\\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.\",\n        { stack }\n      );\n    }\n  }\n};\n\n// src/devModeChecks/inputStabilityCheck.ts\nvar runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {\n  const { memoize, memoizeOptions } = options;\n  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;\n  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);\n  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);\n  if (!areInputSelectorResultsEqual) {\n    let stack = void 0;\n    try {\n      throw new Error();\n    } catch (e) {\n      ;\n      ({ stack } = e);\n    }\n    console.warn(\n      \"An input selector returned a different result when passed same arguments.\\nThis means your output selector will likely run more frequently than intended.\\nAvoid returning a new reference inside your input selector, e.g.\\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`\",\n      {\n        arguments: inputSelectorArgs,\n        firstInputs: inputSelectorResults,\n        secondInputs: inputSelectorResultsCopy,\n        stack\n      }\n    );\n  }\n};\n\n// src/devModeChecks/setGlobalDevModeChecks.ts\nvar globalDevModeChecks = {\n  inputStabilityCheck: \"once\",\n  identityFunctionCheck: \"once\"\n};\nvar setGlobalDevModeChecks = (devModeChecks) => {\n  Object.assign(globalDevModeChecks, devModeChecks);\n};\n\n// src/utils.ts\nvar NOT_FOUND = /* @__PURE__ */ Symbol(\"NOT_FOUND\");\nfunction assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {\n  if (typeof func !== \"function\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {\n  if (typeof object !== \"object\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {\n  if (!array.every((item) => typeof item === \"function\")) {\n    const itemTypes = array.map(\n      (item) => typeof item === \"function\" ? `function ${item.name || \"unnamed\"}()` : typeof item\n    ).join(\", \");\n    throw new TypeError(`${errorMessage}[${itemTypes}]`);\n  }\n}\nvar ensureIsArray = (item) => {\n  return Array.isArray(item) ? item : [item];\n};\nfunction getDependencies(createSelectorArgs) {\n  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;\n  assertIsArrayOfFunctions(\n    dependencies,\n    `createSelector expects all input-selectors to be functions, but received the following types: `\n  );\n  return dependencies;\n}\nfunction collectInputSelectorResults(dependencies, inputSelectorArgs) {\n  const inputSelectorResults = [];\n  const { length } = dependencies;\n  for (let i = 0; i < length; i++) {\n    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));\n  }\n  return inputSelectorResults;\n}\nvar getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {\n  const { identityFunctionCheck, inputStabilityCheck } = {\n    ...globalDevModeChecks,\n    ...devModeChecks\n  };\n  return {\n    identityFunctionCheck: {\n      shouldRun: identityFunctionCheck === \"always\" || identityFunctionCheck === \"once\" && firstRun,\n      run: runIdentityFunctionCheck\n    },\n    inputStabilityCheck: {\n      shouldRun: inputStabilityCheck === \"always\" || inputStabilityCheck === \"once\" && firstRun,\n      run: runInputStabilityCheck\n    }\n  };\n};\n\n// src/autotrackMemoize/autotracking.ts\nvar $REVISION = 0;\nvar CURRENT_TRACKER = null;\nvar Cell = class {\n  revision = $REVISION;\n  _value;\n  _lastValue;\n  _isEqual = tripleEq;\n  constructor(initialValue, isEqual = tripleEq) {\n    this._value = this._lastValue = initialValue;\n    this._isEqual = isEqual;\n  }\n  // Whenever a storage value is read, it'll add itself to the current tracker if\n  // one exists, entangling its state with that cache.\n  get value() {\n    CURRENT_TRACKER?.add(this);\n    return this._value;\n  }\n  // Whenever a storage value is updated, we bump the global revision clock,\n  // assign the revision for this storage to the new value, _and_ we schedule a\n  // rerender. This is important, and it's what makes autotracking  _pull_\n  // based. We don't actively tell the caches which depend on the storage that\n  // anything has happened. Instead, we recompute the caches when needed.\n  set value(newValue) {\n    if (this.value === newValue)\n      return;\n    this._value = newValue;\n    this.revision = ++$REVISION;\n  }\n};\nfunction tripleEq(a, b) {\n  return a === b;\n}\nvar TrackingCache = class {\n  _cachedValue;\n  _cachedRevision = -1;\n  _deps = [];\n  hits = 0;\n  fn;\n  constructor(fn) {\n    this.fn = fn;\n  }\n  clear() {\n    this._cachedValue = void 0;\n    this._cachedRevision = -1;\n    this._deps = [];\n    this.hits = 0;\n  }\n  get value() {\n    if (this.revision > this._cachedRevision) {\n      const { fn } = this;\n      const currentTracker = /* @__PURE__ */ new Set();\n      const prevTracker = CURRENT_TRACKER;\n      CURRENT_TRACKER = currentTracker;\n      this._cachedValue = fn();\n      CURRENT_TRACKER = prevTracker;\n      this.hits++;\n      this._deps = Array.from(currentTracker);\n      this._cachedRevision = this.revision;\n    }\n    CURRENT_TRACKER?.add(this);\n    return this._cachedValue;\n  }\n  get revision() {\n    return Math.max(...this._deps.map((d) => d.revision), 0);\n  }\n};\nfunction getValue(cell) {\n  if (!(cell instanceof Cell)) {\n    console.warn(\"Not a valid cell! \", cell);\n  }\n  return cell.value;\n}\nfunction setValue(storage, value) {\n  if (!(storage instanceof Cell)) {\n    throw new TypeError(\n      \"setValue must be passed a tracked store created with `createStorage`.\"\n    );\n  }\n  storage.value = storage._lastValue = value;\n}\nfunction createCell(initialValue, isEqual = tripleEq) {\n  return new Cell(initialValue, isEqual);\n}\nfunction createCache(fn) {\n  assertIsFunction(\n    fn,\n    \"the first parameter to `createCache` must be a function\"\n  );\n  return new TrackingCache(fn);\n}\n\n// src/autotrackMemoize/tracking.ts\nvar neverEq = (a, b) => false;\nfunction createTag() {\n  return createCell(null, neverEq);\n}\nfunction dirtyTag(tag, value) {\n  setValue(tag, value);\n}\nvar consumeCollection = (node) => {\n  let tag = node.collectionTag;\n  if (tag === null) {\n    tag = node.collectionTag = createTag();\n  }\n  getValue(tag);\n};\nvar dirtyCollection = (node) => {\n  const tag = node.collectionTag;\n  if (tag !== null) {\n    dirtyTag(tag, null);\n  }\n};\n\n// src/autotrackMemoize/proxy.ts\nvar REDUX_PROXY_LABEL = Symbol();\nvar nextId = 0;\nvar proto = Object.getPrototypeOf({});\nvar ObjectTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy(this, objectProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar objectProxyHandler = {\n  get(node, key) {\n    function calculateResult() {\n      const { value } = node;\n      const childValue = Reflect.get(value, key);\n      if (typeof key === \"symbol\") {\n        return childValue;\n      }\n      if (key in proto) {\n        return childValue;\n      }\n      if (typeof childValue === \"object\" && childValue !== null) {\n        let childNode = node.children[key];\n        if (childNode === void 0) {\n          childNode = node.children[key] = createNode(childValue);\n        }\n        if (childNode.tag) {\n          getValue(childNode.tag);\n        }\n        return childNode.proxy;\n      } else {\n        let tag = node.tags[key];\n        if (tag === void 0) {\n          tag = node.tags[key] = createTag();\n          tag.value = childValue;\n        }\n        getValue(tag);\n        return childValue;\n      }\n    }\n    const res = calculateResult();\n    return res;\n  },\n  ownKeys(node) {\n    consumeCollection(node);\n    return Reflect.ownKeys(node.value);\n  },\n  getOwnPropertyDescriptor(node, prop) {\n    return Reflect.getOwnPropertyDescriptor(node.value, prop);\n  },\n  has(node, prop) {\n    return Reflect.has(node.value, prop);\n  }\n};\nvar ArrayTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy([this], arrayProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar arrayProxyHandler = {\n  get([node], key) {\n    if (key === \"length\") {\n      consumeCollection(node);\n    }\n    return objectProxyHandler.get(node, key);\n  },\n  ownKeys([node]) {\n    return objectProxyHandler.ownKeys(node);\n  },\n  getOwnPropertyDescriptor([node], prop) {\n    return objectProxyHandler.getOwnPropertyDescriptor(node, prop);\n  },\n  has([node], prop) {\n    return objectProxyHandler.has(node, prop);\n  }\n};\nfunction createNode(value) {\n  if (Array.isArray(value)) {\n    return new ArrayTreeNode(value);\n  }\n  return new ObjectTreeNode(value);\n}\nfunction updateNode(node, newValue) {\n  const { value, tags, children } = node;\n  node.value = newValue;\n  if (Array.isArray(value) && Array.isArray(newValue) && value.length !== newValue.length) {\n    dirtyCollection(node);\n  } else {\n    if (value !== newValue) {\n      let oldKeysSize = 0;\n      let newKeysSize = 0;\n      let anyKeysAdded = false;\n      for (const _key in value) {\n        oldKeysSize++;\n      }\n      for (const key in newValue) {\n        newKeysSize++;\n        if (!(key in value)) {\n          anyKeysAdded = true;\n          break;\n        }\n      }\n      const isDifferent = anyKeysAdded || oldKeysSize !== newKeysSize;\n      if (isDifferent) {\n        dirtyCollection(node);\n      }\n    }\n  }\n  for (const key in tags) {\n    const childValue = value[key];\n    const newChildValue = newValue[key];\n    if (childValue !== newChildValue) {\n      dirtyCollection(node);\n      dirtyTag(tags[key], newChildValue);\n    }\n    if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      delete tags[key];\n    }\n  }\n  for (const key in children) {\n    const childNode = children[key];\n    const newChildValue = newValue[key];\n    const childValue = childNode.value;\n    if (childValue === newChildValue) {\n      continue;\n    } else if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      updateNode(childNode, newChildValue);\n    } else {\n      deleteNode(childNode);\n      delete children[key];\n    }\n  }\n}\nfunction deleteNode(node) {\n  if (node.tag) {\n    dirtyTag(node.tag, null);\n  }\n  dirtyCollection(node);\n  for (const key in node.tags) {\n    dirtyTag(node.tags[key], null);\n  }\n  for (const key in node.children) {\n    deleteNode(node.children[key]);\n  }\n}\n\n// src/lruMemoize.ts\nfunction createSingletonCache(equals) {\n  let entry;\n  return {\n    get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n      return NOT_FOUND;\n    },\n    put(key, value) {\n      entry = { key, value };\n    },\n    getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear() {\n      entry = void 0;\n    }\n  };\n}\nfunction createLruCache(maxSize, equals) {\n  let entries = [];\n  function get(key) {\n    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));\n    if (cacheIndex > -1) {\n      const entry = entries[cacheIndex];\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n      return entry.value;\n    }\n    return NOT_FOUND;\n  }\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      entries.unshift({ key, value });\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n  function getEntries() {\n    return entries;\n  }\n  function clear() {\n    entries = [];\n  }\n  return { get, put, getEntries, clear };\n}\nvar referenceEqualityCheck = (a, b) => a === b;\nfunction createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    }\n    const { length } = prev;\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}\nfunction lruMemoize(func, equalityCheckOrOptions) {\n  const providedOptions = typeof equalityCheckOrOptions === \"object\" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };\n  const {\n    equalityCheck = referenceEqualityCheck,\n    maxSize = 1,\n    resultEqualityCheck\n  } = providedOptions;\n  const comparator = createCacheKeyComparator(equalityCheck);\n  let resultsCount = 0;\n  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);\n  function memoized() {\n    let value = cache.get(arguments);\n    if (value === NOT_FOUND) {\n      value = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const entries = cache.getEntries();\n        const matchingEntry = entries.find(\n          (entry) => resultEqualityCheck(entry.value, value)\n        );\n        if (matchingEntry) {\n          value = matchingEntry.value;\n          resultsCount !== 0 && resultsCount--;\n        }\n      }\n      cache.put(arguments, value);\n    }\n    return value;\n  }\n  memoized.clearCache = () => {\n    cache.clear();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/autotrackMemoize/autotrackMemoize.ts\nfunction autotrackMemoize(func) {\n  const node = createNode(\n    []\n  );\n  let lastArgs = null;\n  const shallowEqual = createCacheKeyComparator(referenceEqualityCheck);\n  const cache = createCache(() => {\n    const res = func.apply(null, node.proxy);\n    return res;\n  });\n  function memoized() {\n    if (!shallowEqual(lastArgs, arguments)) {\n      updateNode(node, arguments);\n      lastArgs = arguments;\n    }\n    return cache.value;\n  }\n  memoized.clearCache = () => {\n    return cache.clear();\n  };\n  return memoized;\n}\n\n// src/weakMapMemoize.ts\nvar StrongRef = class {\n  constructor(value) {\n    this.value = value;\n  }\n  deref() {\n    return this.value;\n  }\n};\nvar Ref = typeof WeakRef !== \"undefined\" ? WeakRef : StrongRef;\nvar UNTERMINATED = 0;\nvar TERMINATED = 1;\nfunction createCacheNode() {\n  return {\n    s: UNTERMINATED,\n    v: void 0,\n    o: null,\n    p: null\n  };\n}\nfunction weakMapMemoize(func, options = {}) {\n  let fnNode = createCacheNode();\n  const { resultEqualityCheck } = options;\n  let lastResult;\n  let resultsCount = 0;\n  function memoized() {\n    let cacheNode = fnNode;\n    const { length } = arguments;\n    for (let i = 0, l = length; i < l; i++) {\n      const arg = arguments[i];\n      if (typeof arg === \"function\" || typeof arg === \"object\" && arg !== null) {\n        let objectCache = cacheNode.o;\n        if (objectCache === null) {\n          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();\n        }\n        const objectNode = objectCache.get(arg);\n        if (objectNode === void 0) {\n          cacheNode = createCacheNode();\n          objectCache.set(arg, cacheNode);\n        } else {\n          cacheNode = objectNode;\n        }\n      } else {\n        let primitiveCache = cacheNode.p;\n        if (primitiveCache === null) {\n          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();\n        }\n        const primitiveNode = primitiveCache.get(arg);\n        if (primitiveNode === void 0) {\n          cacheNode = createCacheNode();\n          primitiveCache.set(arg, cacheNode);\n        } else {\n          cacheNode = primitiveNode;\n        }\n      }\n    }\n    const terminatedNode = cacheNode;\n    let result;\n    if (cacheNode.s === TERMINATED) {\n      result = cacheNode.v;\n    } else {\n      result = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const lastResultValue = lastResult?.deref?.() ?? lastResult;\n        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {\n          result = lastResultValue;\n          resultsCount !== 0 && resultsCount--;\n        }\n        const needsWeakRef = typeof result === \"object\" && result !== null || typeof result === \"function\";\n        lastResult = needsWeakRef ? new Ref(result) : result;\n      }\n    }\n    terminatedNode.s = TERMINATED;\n    terminatedNode.v = result;\n    return result;\n  }\n  memoized.clearCache = () => {\n    fnNode = createCacheNode();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/createSelectorCreator.ts\nfunction createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {\n  const createSelectorCreatorOptions = typeof memoizeOrOptions === \"function\" ? {\n    memoize: memoizeOrOptions,\n    memoizeOptions: memoizeOptionsFromArgs\n  } : memoizeOrOptions;\n  const createSelector2 = (...createSelectorArgs) => {\n    let recomputations = 0;\n    let dependencyRecomputations = 0;\n    let lastResult;\n    let directlyPassedOptions = {};\n    let resultFunc = createSelectorArgs.pop();\n    if (typeof resultFunc === \"object\") {\n      directlyPassedOptions = resultFunc;\n      resultFunc = createSelectorArgs.pop();\n    }\n    assertIsFunction(\n      resultFunc,\n      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`\n    );\n    const combinedOptions = {\n      ...createSelectorCreatorOptions,\n      ...directlyPassedOptions\n    };\n    const {\n      memoize,\n      memoizeOptions = [],\n      argsMemoize = weakMapMemoize,\n      argsMemoizeOptions = [],\n      devModeChecks = {}\n    } = combinedOptions;\n    const finalMemoizeOptions = ensureIsArray(memoizeOptions);\n    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);\n    const dependencies = getDependencies(createSelectorArgs);\n    const memoizedResultFunc = memoize(function recomputationWrapper() {\n      recomputations++;\n      return resultFunc.apply(\n        null,\n        arguments\n      );\n    }, ...finalMemoizeOptions);\n    let firstRun = true;\n    const selector = argsMemoize(function dependenciesChecker() {\n      dependencyRecomputations++;\n      const inputSelectorResults = collectInputSelectorResults(\n        dependencies,\n        arguments\n      );\n      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);\n      if (process.env.NODE_ENV !== \"production\") {\n        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);\n        if (identityFunctionCheck.shouldRun) {\n          identityFunctionCheck.run(\n            resultFunc,\n            inputSelectorResults,\n            lastResult\n          );\n        }\n        if (inputStabilityCheck.shouldRun) {\n          const inputSelectorResultsCopy = collectInputSelectorResults(\n            dependencies,\n            arguments\n          );\n          inputStabilityCheck.run(\n            { inputSelectorResults, inputSelectorResultsCopy },\n            { memoize, memoizeOptions: finalMemoizeOptions },\n            arguments\n          );\n        }\n        if (firstRun)\n          firstRun = false;\n      }\n      return lastResult;\n    }, ...finalArgsMemoizeOptions);\n    return Object.assign(selector, {\n      resultFunc,\n      memoizedResultFunc,\n      dependencies,\n      dependencyRecomputations: () => dependencyRecomputations,\n      resetDependencyRecomputations: () => {\n        dependencyRecomputations = 0;\n      },\n      lastResult: () => lastResult,\n      recomputations: () => recomputations,\n      resetRecomputations: () => {\n        recomputations = 0;\n      },\n      memoize,\n      argsMemoize\n    });\n  };\n  Object.assign(createSelector2, {\n    withTypes: () => createSelector2\n  });\n  return createSelector2;\n}\nvar createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);\n\n// src/createStructuredSelector.ts\nvar createStructuredSelector = Object.assign(\n  (inputSelectorsObject, selectorCreator = createSelector) => {\n    assertIsObject(\n      inputSelectorsObject,\n      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`\n    );\n    const inputSelectorKeys = Object.keys(inputSelectorsObject);\n    const dependencies = inputSelectorKeys.map(\n      (key) => inputSelectorsObject[key]\n    );\n    const structuredSelector = selectorCreator(\n      dependencies,\n      (...inputSelectorResults) => {\n        return inputSelectorResults.reduce((composition, value, index) => {\n          composition[inputSelectorKeys[index]] = value;\n          return composition;\n        }, {});\n      }\n    );\n    return structuredSelector;\n  },\n  { withTypes: () => createStructuredSelector }\n);\nexport {\n  createSelector,\n  createSelectorCreator,\n  createStructuredSelector,\n  lruMemoize,\n  referenceEqualityCheck,\n  setGlobalDevModeChecks,\n  autotrackMemoize as unstable_autotrackMemoize,\n  weakMapMemoize\n};\n//# sourceMappingURL=reselect.mjs.map"],"names":["NOT_FOUND","assertIsFunction","func","errorMessage","assertIsObject","object","assertIsArrayOfFunctions","array","item","itemTypes","ensureIsArray","getDependencies","createSelectorArgs","dependencies","collectInputSelectorResults","inputSelectorArgs","inputSelectorResults","length","i","createSingletonCache","equals","entry","key","value","createLruCache","maxSize","entries","get","cacheIndex","put","getEntries","clear","referenceEqualityCheck","a","b","createCacheKeyComparator","equalityCheck","prev","next","lruMemoize","equalityCheckOrOptions","providedOptions","resultEqualityCheck","comparator","resultsCount","cache","memoized","matchingEntry","StrongRef","Ref","UNTERMINATED","TERMINATED","createCacheNode","weakMapMemoize","options","fnNode","lastResult","_a","cacheNode","l","arg","objectCache","objectNode","primitiveCache","primitiveNode","terminatedNode","result","lastResultValue","createSelectorCreator","memoizeOrOptions","memoizeOptionsFromArgs","createSelectorCreatorOptions","createSelector2","recomputations","dependencyRecomputations","directlyPassedOptions","resultFunc","combinedOptions","memoize","memoizeOptions","argsMemoize","argsMemoizeOptions","devModeChecks","finalMemoizeOptions","finalArgsMemoizeOptions","memoizedResultFunc","selector","createSelector","createStructuredSelector","inputSelectorsObject","selectorCreator","inputSelectorKeys","composition","index"],"mappings":"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","x_google_ignoreList":[0]}