{"version":3,"file":"static/js/2325.b4c47946.chunk.js","mappings":"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","sources":["webpack://power-app-fe/./node_modules/reselect/es/defaultMemoize.js","webpack://power-app-fe/./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","defaultEqualityCheck","a","b","defaultMemoize","func","equalityCheckOrOptions","providedOptions","equalityCheck","_providedOptions$equa","_providedOptions$maxS","maxSize","resultEqualityCheck","comparator","prev","next","length","i","createCacheKeyComparator","cache","equals","entry","get","key","value","put","getEntries","clear","undefined","createSingletonCache","entries","cacheIndex","findIndex","splice","unshift","pop","createLruCache","memoized","arguments","apply","matchingEntry","find","clearCache","createSelectorCreator","memoize","_len","memoizeOptionsFromArgs","Array","_key","_len2","funcs","_key2","_lastResult","_recomputations","directlyPassedOptions","memoizeOptions","resultFunc","Error","_directlyPassedOption2","finalMemoizeOptions","isArray","dependencies","every","dep","dependencyTypes","map","name","join","getDependencies","memoizedResultFunc","concat","selector","params","push","Object","assign","lastResult","recomputations","resetRecomputations","createSelector","createStructuredSelector","selectors","selectorCreator","objectKeys","keys","resultSelector","_len3","values","_key3","reduce","composition","index"],"sourceRoot":""}