text: import { Stylesheet } from '@uifabric/merge-styles';
  var stylesheet = Stylesheet.getInstance();
  if (stylesheet && stylesheet.onReset) {
      Stylesheet.getInstance().onReset(resetMemoizations);
  }
  var _resetCounter = 0;
  var _emptyObject = { empty: true };
  var _dictionary = {};
  var _weakMap = typeof WeakMap === 'undefined' ? null : WeakMap;
  /**
   *  Test utility for providing a custom weakmap.
   *
   * @internal
   * */
  export function setMemoizeWeakMap(weakMap) {
      _weakMap = weakMap;
  }
  /**
   * Reset memoizations.
   */
  export function resetMemoizations() {
      _resetCounter++;
  }
  /**
   * Memoize decorator to be used on class methods. WARNING: the `this` reference
   * will be inaccessible within a memoized method, given that a cached method's `this`
   * would not be instance-specific.
   *
   * @public
   */
  export function memoize(target, key, descriptor) {
      // We bind to "null" to prevent people from inadvertently pulling values from "this",
      // rather than passing them in as input values which can be memoized.
      var fn = memoizeFunction(descriptor.value && descriptor.value.bind(null));
      return {
          configurable: true,
          get: function () {
              return fn;
          }
      };
  }
  /**
   * Memoizes a function; when you pass in the same parameters multiple times, it returns a cached result.
   * Be careful when passing in objects, you need to pass in the same INSTANCE for caching to work. Otherwise
   * it will grow the cache unnecessarily. Also avoid using default values that evaluate functions; passing in
   * undefined for a value and relying on a default function will execute it the first time, but will not
   * re-evaluate subsequent times which may have been unexpected.
   *
   * By default, the cache will reset after 100 permutations, to avoid abuse cases where the function is
   * unintendedly called with unique objects. Without a reset, the cache could grow infinitely, so we safeguard
   * by resetting. To override this behavior, pass a value of 0 to the maxCacheSize parameter.
   *
   * @public
   * @param cb - The function to memoize.
   * @param maxCacheSize - Max results to cache. If the cache exceeds this value, it will reset on the next call.
   * @returns A memoized version of the function.
   */
  export function memoizeFunction(cb, maxCacheSize) {
      if (maxCacheSize === void 0) { maxCacheSize = 100; }
      // Avoid breaking scenarios which don't have weak map.
      if (!_weakMap) {
          return cb;
      }
      var rootNode;
      var cacheSize = 0;
      var localResetCounter = _resetCounter;
      // tslint:disable-next-line:no-function-expression
      return function memoizedFunction() {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          var currentNode = rootNode;
          if (rootNode === undefined || localResetCounter !== _resetCounter || (maxCacheSize > 0 && cacheSize > maxCacheSize)) {
              rootNode = _createNode();
              cacheSize = 0;
              localResetCounter = _resetCounter;
          }
          currentNode = rootNode;
          // Traverse the tree until we find the match.
          for (var i = 0; i < args.length; i++) {
              var arg = _normalizeArg(args[i]);
              if (!currentNode.map.has(arg)) {
                  currentNode.map.set(arg, _createNode());
              }
              currentNode = currentNode.map.get(arg);
          }
          if (!currentNode.hasOwnProperty('value')) {
              currentNode.value = cb.apply(void 0, args);
              cacheSize++;
          }
          return currentNode.value;
      };
  }
  function _normalizeArg(val) {
      if (!val) {
          return _emptyObject;
      }
      else if (typeof val === 'object' || typeof val === 'function') {
          return val;
      }
      else if (!_dictionary[val]) {
          _dictionary[val] = { val: val };
      }
      return _dictionary[val];
  }
  function _createNode() {
      return {
          map: _weakMap ? new _weakMap() : null
      };
  }
  //# sourceMappingURL=memoize.js.map