@goatlab/fluent 0.9.9 → 0.9.11

package/dist/core/Loopback/mapValues.js

@@ -8,119 +8,141 @@
  */
 
 /** Used as the size to enable large array optimizations. */
-var LARGE_ARRAY_SIZE = 200;
+const LARGE_ARRAY_SIZE = 200
 
 /** Used as the `TypeError` message for "Functions" methods. */
-var FUNC_ERROR_TEXT = 'Expected a function';
+const FUNC_ERROR_TEXT = 'Expected a function'
 
 /** Used to stand-in for `undefined` hash values. */
-var HASH_UNDEFINED = '__lodash_hash_undefined__';
+const HASH_UNDEFINED = '__lodash_hash_undefined__'
 
 /** Used to compose bitmasks for comparison styles. */
-var UNORDERED_COMPARE_FLAG = 1,
-    PARTIAL_COMPARE_FLAG = 2;
+const UNORDERED_COMPARE_FLAG = 1
+const PARTIAL_COMPARE_FLAG = 2
 
 /** Used as references for various `Number` constants. */
-var INFINITY = 1 / 0,
-    MAX_SAFE_INTEGER = 9007199254740991;
+const INFINITY = 1 / 0
+const MAX_SAFE_INTEGER = 9007199254740991
 
 /** `Object#toString` result references. */
-var argsTag = '[object Arguments]',
-    arrayTag = '[object Array]',
-    boolTag = '[object Boolean]',
-    dateTag = '[object Date]',
-    errorTag = '[object Error]',
-    funcTag = '[object Function]',
-    genTag = '[object GeneratorFunction]',
-    mapTag = '[object Map]',
-    numberTag = '[object Number]',
-    objectTag = '[object Object]',
-    promiseTag = '[object Promise]',
-    regexpTag = '[object RegExp]',
-    setTag = '[object Set]',
-    stringTag = '[object String]',
-    symbolTag = '[object Symbol]',
-    weakMapTag = '[object WeakMap]';
-
-var arrayBufferTag = '[object ArrayBuffer]',
-    dataViewTag = '[object DataView]',
-    float32Tag = '[object Float32Array]',
-    float64Tag = '[object Float64Array]',
-    int8Tag = '[object Int8Array]',
-    int16Tag = '[object Int16Array]',
-    int32Tag = '[object Int32Array]',
-    uint8Tag = '[object Uint8Array]',
-    uint8ClampedTag = '[object Uint8ClampedArray]',
-    uint16Tag = '[object Uint16Array]',
-    uint32Tag = '[object Uint32Array]';
+const argsTag = '[object Arguments]'
+const arrayTag = '[object Array]'
+const boolTag = '[object Boolean]'
+const dateTag = '[object Date]'
+const errorTag = '[object Error]'
+const funcTag = '[object Function]'
+const genTag = '[object GeneratorFunction]'
+const mapTag = '[object Map]'
+const numberTag = '[object Number]'
+const objectTag = '[object Object]'
+const promiseTag = '[object Promise]'
+const regexpTag = '[object RegExp]'
+const setTag = '[object Set]'
+const stringTag = '[object String]'
+const symbolTag = '[object Symbol]'
+const weakMapTag = '[object WeakMap]'
+
+const arrayBufferTag = '[object ArrayBuffer]'
+const dataViewTag = '[object DataView]'
+const float32Tag = '[object Float32Array]'
+const float64Tag = '[object Float64Array]'
+const int8Tag = '[object Int8Array]'
+const int16Tag = '[object Int16Array]'
+const int32Tag = '[object Int32Array]'
+const uint8Tag = '[object Uint8Array]'
+const uint8ClampedTag = '[object Uint8ClampedArray]'
+const uint16Tag = '[object Uint16Array]'
+const uint32Tag = '[object Uint32Array]'
 
 /** Used to match property names within property paths. */
-var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
-    reIsPlainProp = /^\w*$/,
-    reLeadingDot = /^\./,
-    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+const reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/
+const reIsPlainProp = /^\w*$/
+const reLeadingDot = /^\./
+const rePropName =
+  /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g
 
 /**
  * Used to match `RegExp`
  * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
  */
-var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+const reRegExpChar = /[\\^$.*+?()[\]{}|]/g
 
 /** Used to match backslashes in property paths. */
-var reEscapeChar = /\\(\\)?/g;
+const reEscapeChar = /\\(\\)?/g
 
 /** Used to detect host constructors (Safari). */
-var reIsHostCtor = /^\[object .+?Constructor\]$/;
+const reIsHostCtor = /^\[object .+?Constructor\]$/
 
 /** Used to detect unsigned integer values. */
-var reIsUint = /^(?:0|[1-9]\d*)$/;
+const reIsUint = /^(?:0|[1-9]\d*)$/
 
 /** Used to identify `toStringTag` values of typed arrays. */
-var typedArrayTags = {};
-typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
-typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
-typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
-typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
-typedArrayTags[uint32Tag] = true;
-typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
-typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
-typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
-typedArrayTags[errorTag] = typedArrayTags[funcTag] =
-typedArrayTags[mapTag] = typedArrayTags[numberTag] =
-typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
-typedArrayTags[setTag] = typedArrayTags[stringTag] =
-typedArrayTags[weakMapTag] = false;
+const typedArrayTags = {}
+typedArrayTags[float32Tag] =
+  typedArrayTags[float64Tag] =
+  typedArrayTags[int8Tag] =
+  typedArrayTags[int16Tag] =
+  typedArrayTags[int32Tag] =
+  typedArrayTags[uint8Tag] =
+  typedArrayTags[uint8ClampedTag] =
+  typedArrayTags[uint16Tag] =
+  typedArrayTags[uint32Tag] =
+    true
+typedArrayTags[argsTag] =
+  typedArrayTags[arrayTag] =
+  typedArrayTags[arrayBufferTag] =
+  typedArrayTags[boolTag] =
+  typedArrayTags[dataViewTag] =
+  typedArrayTags[dateTag] =
+  typedArrayTags[errorTag] =
+  typedArrayTags[funcTag] =
+  typedArrayTags[mapTag] =
+  typedArrayTags[numberTag] =
+  typedArrayTags[objectTag] =
+  typedArrayTags[regexpTag] =
+  typedArrayTags[setTag] =
+  typedArrayTags[stringTag] =
+  typedArrayTags[weakMapTag] =
+    false
 
 /** Detect free variable `global` from Node.js. */
-var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+const freeGlobal =
+  typeof global === 'object' && global && global.Object === Object && global
 
 /** Detect free variable `self`. */
-var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+const freeSelf =
+  typeof self === 'object' && self && self.Object === Object && self
 
 /** Used as a reference to the global object. */
-var root = freeGlobal || freeSelf || Function('return this')();
+const root = freeGlobal || freeSelf || Function('return this')()
 
 /** Detect free variable `exports`. */
-var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+const freeExports =
+  typeof exports === 'object' && exports && !exports.nodeType && exports
 
 /** Detect free variable `module`. */
-var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+const freeModule =
+  freeExports &&
+  typeof module === 'object' &&
+  module &&
+  !module.nodeType &&
+  module
 
 /** Detect the popular CommonJS extension `module.exports`. */
-var moduleExports = freeModule && freeModule.exports === freeExports;
+const moduleExports = freeModule && freeModule.exports === freeExports
 
 /** Detect free variable `process` from Node.js. */
-var freeProcess = moduleExports && freeGlobal.process;
+const freeProcess = moduleExports && freeGlobal.process
 
 /** Used to access faster Node.js helpers. */
-var nodeUtil = (function() {
+const nodeUtil = (() => {
   try {
-    return freeProcess && freeProcess.binding('util');
-  } catch (e) {}
-}());
+    return freeProcess?.binding('util')
+  } catch (_e) {}
+})()
 
 /* Node.js helper references. */
-var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+const nodeIsTypedArray = nodeUtil?.isTypedArray
 
 /**
  * A specialized version of `_.some` for arrays without support for iteratee
@@ -133,15 +155,15 @@ var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
  *  else `false`.
  */
 function arraySome(array, predicate) {
-  var index = -1,
-      length = array ? array.length : 0;
+  let index = -1
+  const length = array ? array.length : 0
 
   while (++index < length) {
     if (predicate(array[index], index, array)) {
-      return true;
+      return true
     }
   }
-  return false;
+  return false
 }
 
 /**
@@ -152,9 +174,7 @@ function arraySome(array, predicate) {
  * @returns {Function} Returns the new accessor function.
  */
 function baseProperty(key) {
-  return function(object) {
-    return object == null ? undefined : object[key];
-  };
+  return object => (object == null ? undefined : object[key])
 }
 
 /**
@@ -167,13 +187,13 @@ function baseProperty(key) {
  * @returns {Array} Returns the array of results.
  */
 function baseTimes(n, iteratee) {
-  var index = -1,
-      result = Array(n);
+  let index = -1
+  const result = Array(n)
 
   while (++index < n) {
-    result[index] = iteratee(index);
+    result[index] = iteratee(index)
   }
-  return result;
+  return result
 }
 
 /**
@@ -184,9 +204,7 @@ function baseTimes(n, iteratee) {
  * @returns {Function} Returns the new capped function.
  */
 function baseUnary(func) {
-  return function(value) {
-    return func(value);
-  };
+  return value => func(value)
 }
 
 /**
@@ -198,7 +216,7 @@ function baseUnary(func) {
  * @returns {*} Returns the property value.
  */
 function getValue(object, key) {
-  return object == null ? undefined : object[key];
+  return object == null ? undefined : object[key]
 }
 
 /**
@@ -211,13 +229,13 @@ function getValue(object, key) {
 function isHostObject(value) {
   // Many host objects are `Object` objects that can coerce to strings
   // despite having improperly defined `toString` methods.
-  var result = false;
-  if (value != null && typeof value.toString != 'function') {
+  let result = false
+  if (value != null && typeof value.toString !== 'function') {
     try {
-      result = !!(value + '');
-    } catch (e) {}
+      result = !!`${value}`
+    } catch (_e) {}
   }
-  return result;
+  return result
 }
 
 /**
@@ -228,13 +246,13 @@ function isHostObject(value) {
  * @returns {Array} Returns the key-value pairs.
  */
 function mapToArray(map) {
-  var index = -1,
-      result = Array(map.size);
+  let index = -1
+  const result = Array(map.size)
 
-  map.forEach(function(value, key) {
-    result[++index] = [key, value];
-  });
-  return result;
+  map.forEach((value, key) => {
+    result[++index] = [key, value]
+  })
+  return result
 }
 
 /**
@@ -246,9 +264,7 @@ function mapToArray(map) {
  * @returns {Function} Returns the new function.
  */
 function overArg(func, transform) {
-  return function(arg) {
-    return func(transform(arg));
-  };
+  return arg => func(transform(arg))
 }
 
 /**
@@ -259,76 +275,83 @@ function overArg(func, transform) {
  * @returns {Array} Returns the values.
  */
 function setToArray(set) {
-  var index = -1,
-      result = Array(set.size);
+  let index = -1
+  const result = Array(set.size)
 
-  set.forEach(function(value) {
-    result[++index] = value;
-  });
-  return result;
+  set.forEach(value => {
+    result[++index] = value
+  })
+  return result
 }
 
 /** Used for built-in method references. */
-var arrayProto = Array.prototype,
-    funcProto = Function.prototype,
-    objectProto = Object.prototype;
+const arrayProto = Array.prototype
+const funcProto = Function.prototype
+const objectProto = Object.prototype
 
 /** Used to detect overreaching core-js shims. */
-var coreJsData = root['__core-js_shared__'];
+const coreJsData = root['__core-js_shared__']
 
 /** Used to detect methods masquerading as native. */
-var maskSrcKey = (function() {
-  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
-  return uid ? ('Symbol(src)_1.' + uid) : '';
-}());
+const maskSrcKey = (() => {
+  const uid = /[^.]+$/.exec(coreJsData?.keys?.IE_PROTO || '')
+  return uid ? `Symbol(src)_1.${uid}` : ''
+})()
 
 /** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+const funcToString = funcProto.toString
 
 /** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+const hasOwnProperty = objectProto.hasOwnProperty
 
 /**
  * Used to resolve the
  * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  * of values.
  */
-var objectToString = objectProto.toString;
+const objectToString = objectProto.toString
 
 /** Used to detect if a method is native. */
-var reIsNative = RegExp('^' +
-  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
-  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
-);
+const reIsNative = RegExp(
+  '^' +
+    funcToString
+      .call(hasOwnProperty)
+      .replace(reRegExpChar, '\\$&')
+      .replace(
+        /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
+        '$1.*?'
+      ) +
+    '$'
+)
 
 /** Built-in value references. */
-var Symbol = root.Symbol,
-    Uint8Array = root.Uint8Array,
-    propertyIsEnumerable = objectProto.propertyIsEnumerable,
-    splice = arrayProto.splice;
+const Symbol = root.Symbol
+const Uint8Array = root.Uint8Array
+const propertyIsEnumerable = objectProto.propertyIsEnumerable
+const splice = arrayProto.splice
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeKeys = overArg(Object.keys, Object);
+const nativeKeys = overArg(Object.keys, Object)
 
 /* Built-in method references that are verified to be native. */
-var DataView = getNative(root, 'DataView'),
-    Map = getNative(root, 'Map'),
-    Promise = getNative(root, 'Promise'),
-    Set = getNative(root, 'Set'),
-    WeakMap = getNative(root, 'WeakMap'),
-    nativeCreate = getNative(Object, 'create');
+const DataView = getNative(root, 'DataView')
+const Map = getNative(root, 'Map')
+const Promise = getNative(root, 'Promise')
+const Set = getNative(root, 'Set')
+const WeakMap = getNative(root, 'WeakMap')
+const nativeCreate = getNative(Object, 'create')
 
 /** Used to detect maps, sets, and weakmaps. */
-var dataViewCtorString = toSource(DataView),
-    mapCtorString = toSource(Map),
-    promiseCtorString = toSource(Promise),
-    setCtorString = toSource(Set),
-    weakMapCtorString = toSource(WeakMap);
+const dataViewCtorString = toSource(DataView)
+const mapCtorString = toSource(Map)
+const promiseCtorString = toSource(Promise)
+const setCtorString = toSource(Set)
+const weakMapCtorString = toSource(WeakMap)
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto = Symbol ? Symbol.prototype : undefined,
-    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
-    symbolToString = symbolProto ? symbolProto.toString : undefined;
+const symbolProto = Symbol ? Symbol.prototype : undefined
+const symbolValueOf = symbolProto ? symbolProto.valueOf : undefined
+const symbolToString = symbolProto ? symbolProto.toString : undefined
 
 /**
  * Creates a hash object.
@@ -338,13 +361,13 @@ var symbolProto = Symbol ? Symbol.prototype : undefined,
  * @param {Array} [entries] The key-value pairs to cache.
  */
 function Hash(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
+  let index = -1
+  const length = entries ? entries.length : 0
 
-  this.clear();
+  this.clear()
   while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+    const entry = entries[index]
+    this.set(entry[0], entry[1])
   }
 }
 
@@ -356,7 +379,7 @@ function Hash(entries) {
  * @memberOf Hash
  */
 function hashClear() {
-  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.__data__ = nativeCreate ? nativeCreate(null) : {}
 }
 
 /**
@@ -370,7 +393,7 @@ function hashClear() {
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function hashDelete(key) {
-  return this.has(key) && delete this.__data__[key];
+  return this.has(key) && delete this.__data__[key]
 }
 
 /**
@@ -383,12 +406,12 @@ function hashDelete(key) {
  * @returns {*} Returns the entry value.
  */
 function hashGet(key) {
-  var data = this.__data__;
+  const data = this.__data__
   if (nativeCreate) {
-    var result = data[key];
-    return result === HASH_UNDEFINED ? undefined : result;
+    const result = data[key]
+    return result === HASH_UNDEFINED ? undefined : result
   }
-  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+  return hasOwnProperty.call(data, key) ? data[key] : undefined
 }
 
 /**
@@ -401,8 +424,8 @@ function hashGet(key) {
  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  */
 function hashHas(key) {
-  var data = this.__data__;
-  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+  const data = this.__data__
+  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key)
 }
 
 /**
@@ -416,17 +439,17 @@ function hashHas(key) {
  * @returns {Object} Returns the hash instance.
  */
 function hashSet(key, value) {
-  var data = this.__data__;
-  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
-  return this;
+  const data = this.__data__
+  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value
+  return this
 }
 
 // Add methods to `Hash`.
-Hash.prototype.clear = hashClear;
-Hash.prototype['delete'] = hashDelete;
-Hash.prototype.get = hashGet;
-Hash.prototype.has = hashHas;
-Hash.prototype.set = hashSet;
+Hash.prototype.clear = hashClear
+Hash.prototype.delete = hashDelete
+Hash.prototype.get = hashGet
+Hash.prototype.has = hashHas
+Hash.prototype.set = hashSet
 
 /**
  * Creates an list cache object.
@@ -436,13 +459,13 @@ Hash.prototype.set = hashSet;
  * @param {Array} [entries] The key-value pairs to cache.
  */
 function ListCache(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
+  let index = -1
+  const length = entries ? entries.length : 0
 
-  this.clear();
+  this.clear()
   while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+    const entry = entries[index]
+    this.set(entry[0], entry[1])
   }
 }
 
@@ -454,7 +477,7 @@ function ListCache(entries) {
  * @memberOf ListCache
  */
 function listCacheClear() {
-  this.__data__ = [];
+  this.__data__ = []
 }
 
 /**
@@ -467,19 +490,19 @@ function listCacheClear() {
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function listCacheDelete(key) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
+  const data = this.__data__
+  const index = assocIndexOf(data, key)
 
   if (index < 0) {
-    return false;
+    return false
   }
-  var lastIndex = data.length - 1;
-  if (index == lastIndex) {
-    data.pop();
+  const lastIndex = data.length - 1
+  if (index === lastIndex) {
+    data.pop()
   } else {
-    splice.call(data, index, 1);
+    splice.call(data, index, 1)
   }
-  return true;
+  return true
 }
 
 /**
@@ -492,10 +515,10 @@ function listCacheDelete(key) {
  * @returns {*} Returns the entry value.
  */
 function listCacheGet(key) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
+  const data = this.__data__
+  const index = assocIndexOf(data, key)
 
-  return index < 0 ? undefined : data[index][1];
+  return index < 0 ? undefined : data[index][1]
 }
 
 /**
@@ -508,7 +531,7 @@ function listCacheGet(key) {
  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  */
 function listCacheHas(key) {
-  return assocIndexOf(this.__data__, key) > -1;
+  return assocIndexOf(this.__data__, key) > -1
 }
 
 /**
@@ -522,23 +545,23 @@ function listCacheHas(key) {
  * @returns {Object} Returns the list cache instance.
  */
 function listCacheSet(key, value) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
+  const data = this.__data__
+  const index = assocIndexOf(data, key)
 
   if (index < 0) {
-    data.push([key, value]);
+    data.push([key, value])
   } else {
-    data[index][1] = value;
+    data[index][1] = value
   }
-  return this;
+  return this
 }
 
 // Add methods to `ListCache`.
-ListCache.prototype.clear = listCacheClear;
-ListCache.prototype['delete'] = listCacheDelete;
-ListCache.prototype.get = listCacheGet;
-ListCache.prototype.has = listCacheHas;
-ListCache.prototype.set = listCacheSet;
+ListCache.prototype.clear = listCacheClear
+ListCache.prototype.delete = listCacheDelete
+ListCache.prototype.get = listCacheGet
+ListCache.prototype.has = listCacheHas
+ListCache.prototype.set = listCacheSet
 
 /**
  * Creates a map cache object to store key-value pairs.
@@ -548,13 +571,13 @@ ListCache.prototype.set = listCacheSet;
  * @param {Array} [entries] The key-value pairs to cache.
  */
 function MapCache(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
+  let index = -1
+  const length = entries ? entries.length : 0
 
-  this.clear();
+  this.clear()
   while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+    const entry = entries[index]
+    this.set(entry[0], entry[1])
   }
 }
 
@@ -567,10 +590,10 @@ function MapCache(entries) {
  */
 function mapCacheClear() {
   this.__data__ = {
-    'hash': new Hash,
-    'map': new (Map || ListCache),
-    'string': new Hash
-  };
+    hash: new Hash(),
+    map: new (Map || ListCache)(),
+    string: new Hash()
+  }
 }
 
 /**
@@ -583,7 +606,7 @@ function mapCacheClear() {
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function mapCacheDelete(key) {
-  return getMapData(this, key)['delete'](key);
+  return getMapData(this, key).delete(key)
 }
 
 /**
@@ -596,7 +619,7 @@ function mapCacheDelete(key) {
  * @returns {*} Returns the entry value.
  */
 function mapCacheGet(key) {
-  return getMapData(this, key).get(key);
+  return getMapData(this, key).get(key)
 }
 
 /**
@@ -609,7 +632,7 @@ function mapCacheGet(key) {
  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  */
 function mapCacheHas(key) {
-  return getMapData(this, key).has(key);
+  return getMapData(this, key).has(key)
 }
 
 /**
@@ -623,16 +646,16 @@ function mapCacheHas(key) {
  * @returns {Object} Returns the map cache instance.
  */
 function mapCacheSet(key, value) {
-  getMapData(this, key).set(key, value);
-  return this;
+  getMapData(this, key).set(key, value)
+  return this
 }
 
 // Add methods to `MapCache`.
-MapCache.prototype.clear = mapCacheClear;
-MapCache.prototype['delete'] = mapCacheDelete;
-MapCache.prototype.get = mapCacheGet;
-MapCache.prototype.has = mapCacheHas;
-MapCache.prototype.set = mapCacheSet;
+MapCache.prototype.clear = mapCacheClear
+MapCache.prototype.delete = mapCacheDelete
+MapCache.prototype.get = mapCacheGet
+MapCache.prototype.has = mapCacheHas
+MapCache.prototype.set = mapCacheSet
 
 /**
  *
@@ -643,12 +666,12 @@ MapCache.prototype.set = mapCacheSet;
  * @param {Array} [values] The values to cache.
  */
 function SetCache(values) {
-  var index = -1,
-      length = values ? values.length : 0;
+  let index = -1
+  const length = values ? values.length : 0
 
-  this.__data__ = new MapCache;
+  this.__data__ = new MapCache()
   while (++index < length) {
-    this.add(values[index]);
+    this.add(values[index])
   }
 }
 
@@ -663,8 +686,8 @@ function SetCache(values) {
  * @returns {Object} Returns the cache instance.
  */
 function setCacheAdd(value) {
-  this.__data__.set(value, HASH_UNDEFINED);
-  return this;
+  this.__data__.set(value, HASH_UNDEFINED)
+  return this
 }
 
 /**
@@ -677,12 +700,12 @@ function setCacheAdd(value) {
  * @returns {number} Returns `true` if `value` is found, else `false`.
  */
 function setCacheHas(value) {
-  return this.__data__.has(value);
+  return this.__data__.has(value)
 }
 
 // Add methods to `SetCache`.
-SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
-SetCache.prototype.has = setCacheHas;
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd
+SetCache.prototype.has = setCacheHas
 
 /**
  * Creates a stack cache object to store key-value pairs.
@@ -692,7 +715,7 @@ SetCache.prototype.has = setCacheHas;
  * @param {Array} [entries] The key-value pairs to cache.
  */
 function Stack(entries) {
-  this.__data__ = new ListCache(entries);
+  this.__data__ = new ListCache(entries)
 }
 
 /**
@@ -703,7 +726,7 @@ function Stack(entries) {
  * @memberOf Stack
  */
 function stackClear() {
-  this.__data__ = new ListCache;
+  this.__data__ = new ListCache()
 }
 
 /**
@@ -716,7 +739,7 @@ function stackClear() {
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function stackDelete(key) {
-  return this.__data__['delete'](key);
+  return this.__data__.delete(key)
 }
 
 /**
@@ -729,7 +752,7 @@ function stackDelete(key) {
  * @returns {*} Returns the entry value.
  */
 function stackGet(key) {
-  return this.__data__.get(key);
+  return this.__data__.get(key)
 }
 
 /**
@@ -742,7 +765,7 @@ function stackGet(key) {
  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  */
 function stackHas(key) {
-  return this.__data__.has(key);
+  return this.__data__.has(key)
 }
 
 /**
@@ -756,25 +779,25 @@ function stackHas(key) {
  * @returns {Object} Returns the stack cache instance.
  */
 function stackSet(key, value) {
-  var cache = this.__data__;
+  let cache = this.__data__
   if (cache instanceof ListCache) {
-    var pairs = cache.__data__;
-    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
-      pairs.push([key, value]);
-      return this;
+    const pairs = cache.__data__
+    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value])
+      return this
     }
-    cache = this.__data__ = new MapCache(pairs);
+    cache = this.__data__ = new MapCache(pairs)
   }
-  cache.set(key, value);
-  return this;
+  cache.set(key, value)
+  return this
 }
 
 // Add methods to `Stack`.
-Stack.prototype.clear = stackClear;
-Stack.prototype['delete'] = stackDelete;
-Stack.prototype.get = stackGet;
-Stack.prototype.has = stackHas;
-Stack.prototype.set = stackSet;
+Stack.prototype.clear = stackClear
+Stack.prototype.delete = stackDelete
+Stack.prototype.get = stackGet
+Stack.prototype.has = stackHas
+Stack.prototype.set = stackSet
 
 /**
  * Creates an array of the enumerable property names of the array-like `value`.
@@ -787,20 +810,21 @@ Stack.prototype.set = stackSet;
 function arrayLikeKeys(value, inherited) {
   // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
   // Safari 9 makes `arguments.length` enumerable in strict mode.
-  var result = (isArray(value) || isArguments(value))
-    ? baseTimes(value.length, String)
-    : [];
-
-  var length = result.length,
-      skipIndexes = !!length;
-
-  for (var key in value) {
-    if ((inherited || hasOwnProperty.call(value, key)) &&
-        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
-      result.push(key);
+  const result =
+    isArray(value) || isArguments(value) ? baseTimes(value.length, String) : []
+
+  const length = result.length
+  const skipIndexes = !!length
+
+  for (const key in value) {
+    if (
+      (inherited || hasOwnProperty.call(value, key)) &&
+      !(skipIndexes && (key === 'length' || isIndex(key, length)))
+    ) {
+      result.push(key)
     }
   }
-  return result;
+  return result
 }
 
 /**
@@ -812,13 +836,13 @@ function arrayLikeKeys(value, inherited) {
  * @returns {number} Returns the index of the matched value, else `-1`.
  */
 function assocIndexOf(array, key) {
-  var length = array.length;
+  let length = array.length
   while (length--) {
     if (eq(array[length][0], key)) {
-      return length;
+      return length
     }
   }
-  return -1;
+  return -1
 }
 
 /**
@@ -832,7 +856,7 @@ function assocIndexOf(array, key) {
  * @param {Function} keysFunc The function to get the keys of `object`.
  * @returns {Object} Returns `object`.
  */
-var baseFor = createBaseFor();
+const baseFor = createBaseFor()
 
 /**
  * The base implementation of `_.forOwn` without support for iteratee shorthands.
@@ -843,7 +867,7 @@ var baseFor = createBaseFor();
  * @returns {Object} Returns `object`.
  */
 function baseForOwn(object, iteratee) {
-  return object && baseFor(object, iteratee, keys);
+  return object && baseFor(object, iteratee, keys)
 }
 
 /**
@@ -855,15 +879,15 @@ function baseForOwn(object, iteratee) {
  * @returns {*} Returns the resolved value.
  */
 function baseGet(object, path) {
-  path = isKey(path, object) ? [path] : castPath(path);
+  path = isKey(path, object) ? [path] : castPath(path)
 
-  var index = 0,
-      length = path.length;
+  let index = 0
+  const length = path.length
 
   while (object != null && index < length) {
-    object = object[toKey(path[index++])];
+    object = object[toKey(path[index++])]
   }
-  return (index && index == length) ? object : undefined;
+  return index && index === length ? object : undefined
 }
 
 /**
@@ -874,7 +898,7 @@ function baseGet(object, path) {
  * @returns {string} Returns the `toStringTag`.
  */
 function baseGetTag(value) {
-  return objectToString.call(value);
+  return objectToString.call(value)
 }
 
 /**
@@ -886,7 +910,7 @@ function baseGetTag(value) {
  * @returns {boolean} Returns `true` if `key` exists, else `false`.
  */
 function baseHasIn(object, key) {
-  return object != null && key in Object(object);
+  return object != null && key in Object(object)
 }
 
 /**
@@ -906,12 +930,16 @@ function baseHasIn(object, key) {
  */
 function baseIsEqual(value, other, customizer, bitmask, stack) {
   if (value === other) {
-    return true;
+    return true
   }
-  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
-    return value !== value && other !== other;
+  if (
+    value == null ||
+    other == null ||
+    (!isObject(value) && !isObjectLike(other))
+  ) {
+    return value !== value && other !== other
   }
-  return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+  return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack)
 }
 
 /**
@@ -930,46 +958,46 @@ function baseIsEqual(value, other, customizer, bitmask, stack) {
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
 function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
-  var objIsArr = isArray(object),
-      othIsArr = isArray(other),
-      objTag = arrayTag,
-      othTag = arrayTag;
+  const objIsArr = isArray(object)
+  const othIsArr = isArray(other)
+  let objTag = arrayTag
+  let othTag = arrayTag
 
   if (!objIsArr) {
-    objTag = getTag(object);
-    objTag = objTag == argsTag ? objectTag : objTag;
+    objTag = getTag(object)
+    objTag = objTag === argsTag ? objectTag : objTag
   }
   if (!othIsArr) {
-    othTag = getTag(other);
-    othTag = othTag == argsTag ? objectTag : othTag;
+    othTag = getTag(other)
+    othTag = othTag === argsTag ? objectTag : othTag
   }
-  var objIsObj = objTag == objectTag && !isHostObject(object),
-      othIsObj = othTag == objectTag && !isHostObject(other),
-      isSameTag = objTag == othTag;
+  const objIsObj = objTag === objectTag && !isHostObject(object)
+  const othIsObj = othTag === objectTag && !isHostObject(other)
+  const isSameTag = objTag === othTag
 
   if (isSameTag && !objIsObj) {
-    stack || (stack = new Stack);
-    return (objIsArr || isTypedArray(object))
+    stack || (stack = new Stack())
+    return objIsArr || isTypedArray(object)
       ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
-      : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+      : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack)
   }
   if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
-    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
-        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+    const objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__')
+    const othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__')
 
     if (objIsWrapped || othIsWrapped) {
-      var objUnwrapped = objIsWrapped ? object.value() : object,
-          othUnwrapped = othIsWrapped ? other.value() : other;
+      const objUnwrapped = objIsWrapped ? object.value() : object
+      const othUnwrapped = othIsWrapped ? other.value() : other
 
-      stack || (stack = new Stack);
-      return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+      stack || (stack = new Stack())
+      return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack)
     }
   }
   if (!isSameTag) {
-    return false;
+    return false
   }
-  stack || (stack = new Stack);
-  return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+  stack || (stack = new Stack())
+  return equalObjects(object, other, equalFunc, customizer, bitmask, stack)
 }
 
 /**
@@ -983,47 +1011,62 @@ function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
  * @returns {boolean} Returns `true` if `object` is a match, else `false`.
  */
 function baseIsMatch(object, source, matchData, customizer) {
-  var index = matchData.length,
-      length = index,
-      noCustomizer = !customizer;
+  let index = matchData.length
+  const length = index
+  const noCustomizer = !customizer
 
   if (object == null) {
-    return !length;
+    return !length
   }
-  object = Object(object);
+  object = Object(object)
   while (index--) {
-    var data = matchData[index];
-    if ((noCustomizer && data[2])
-          ? data[1] !== object[data[0]]
-          : !(data[0] in object)
-        ) {
-      return false;
+    const data = matchData[index]
+    if (
+      noCustomizer && data[2]
+        ? data[1] !== object[data[0]]
+        : !(data[0] in object)
+    ) {
+      return false
     }
   }
   while (++index < length) {
-    data = matchData[index];
-    var key = data[0],
-        objValue = object[key],
-        srcValue = data[1];
+    data = matchData[index]
+    const key = data[0]
+    const objValue = object[key]
+    const srcValue = data[1]
 
     if (noCustomizer && data[2]) {
       if (objValue === undefined && !(key in object)) {
-        return false;
+        return false
       }
     } else {
-      var stack = new Stack;
+      const stack = new Stack()
       if (customizer) {
-        var result = customizer(objValue, srcValue, key, object, source, stack);
+        const _result = customizer(
+          objValue,
+          srcValue,
+          key,
+          object,
+          source,
+          stack
+        )
       }
-      if (!(result === undefined
-            ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
-            : result
-          )) {
-        return false;
+      if (
+        !(result === undefined
+          ? baseIsEqual(
+              srcValue,
+              objValue,
+              customizer,
+              UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG,
+              stack
+            )
+          : result)
+      ) {
+        return false
       }
     }
   }
-  return true;
+  return true
 }
 
 /**
@@ -1036,10 +1079,11 @@ function baseIsMatch(object, source, matchData, customizer) {
  */
 function baseIsNative(value) {
   if (!isObject(value) || isMasked(value)) {
-    return false;
+    return false
   }
-  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
-  return pattern.test(toSource(value));
+  const pattern =
+    isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor
+  return pattern.test(toSource(value))
 }
 
 /**
@@ -1050,8 +1094,11 @@ function baseIsNative(value) {
  * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
  */
 function baseIsTypedArray(value) {
-  return isObjectLike(value) &&
-    isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+  return (
+    isObjectLike(value) &&
+    isLength(value.length) &&
+    !!typedArrayTags[objectToString.call(value)]
+  )
 }
 
 /**
@@ -1064,18 +1111,18 @@ function baseIsTypedArray(value) {
 function baseIteratee(value) {
   // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
   // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
-  if (typeof value == 'function') {
-    return value;
+  if (typeof value === 'function') {
+    return value
   }
   if (value == null) {
-    return identity;
+    return identity
   }
-  if (typeof value == 'object') {
+  if (typeof value === 'object') {
     return isArray(value)
       ? baseMatchesProperty(value[0], value[1])
-      : baseMatches(value);
+      : baseMatches(value)
   }
-  return property(value);
+  return property(value)
 }
 
 /**
@@ -1087,15 +1134,15 @@ function baseIteratee(value) {
  */
 function baseKeys(object) {
   if (!isPrototype(object)) {
-    return nativeKeys(object);
+    return nativeKeys(object)
   }
-  var result = [];
-  for (var key in Object(object)) {
-    if (hasOwnProperty.call(object, key) && key != 'constructor') {
-      result.push(key);
+  const result = []
+  for (const key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key !== 'constructor') {
+      result.push(key)
     }
   }
-  return result;
+  return result
 }
 
 /**
@@ -1106,13 +1153,11 @@ function baseKeys(object) {
  * @returns {Function} Returns the new spec function.
  */
 function baseMatches(source) {
-  var matchData = getMatchData(source);
-  if (matchData.length == 1 && matchData[0][2]) {
-    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  const matchData = getMatchData(source)
+  if (matchData.length === 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1])
   }
-  return function(object) {
-    return object === source || baseIsMatch(object, source, matchData);
-  };
+  return object => object === source || baseIsMatch(object, source, matchData)
 }
 
 /**
@@ -1125,14 +1170,19 @@ function baseMatches(source) {
  */
 function baseMatchesProperty(path, srcValue) {
   if (isKey(path) && isStrictComparable(srcValue)) {
-    return matchesStrictComparable(toKey(path), srcValue);
+    return matchesStrictComparable(toKey(path), srcValue)
   }
-  return function(object) {
-    var objValue = get(object, path);
-    return (objValue === undefined && objValue === srcValue)
+  return object => {
+    const objValue = get(object, path)
+    return objValue === undefined && objValue === srcValue
       ? hasIn(object, path)
-      : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
-  };
+      : baseIsEqual(
+          srcValue,
+          objValue,
+          undefined,
+          UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG
+        )
+  }
 }
 
 /**
@@ -1143,9 +1193,7 @@ function baseMatchesProperty(path, srcValue) {
  * @returns {Function} Returns the new accessor function.
  */
 function basePropertyDeep(path) {
-  return function(object) {
-    return baseGet(object, path);
-  };
+  return object => baseGet(object, path)
 }
 
 /**
@@ -1158,14 +1206,14 @@ function basePropertyDeep(path) {
  */
 function baseToString(value) {
   // Exit early for strings to avoid a performance hit in some environments.
-  if (typeof value == 'string') {
-    return value;
+  if (typeof value === 'string') {
+    return value
   }
   if (isSymbol(value)) {
-    return symbolToString ? symbolToString.call(value) : '';
+    return symbolToString ? symbolToString.call(value) : ''
   }
-  var result = (value + '');
-  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+  const result = `${value}`
+  return result === '0' && 1 / value === -INFINITY ? '-0' : result
 }
 
 /**
@@ -1176,7 +1224,7 @@ function baseToString(value) {
  * @returns {Array} Returns the cast property path array.
  */
 function castPath(value) {
-  return isArray(value) ? value : stringToPath(value);
+  return isArray(value) ? value : stringToPath(value)
 }
 
 /**
@@ -1187,20 +1235,20 @@ function castPath(value) {
  * @returns {Function} Returns the new base function.
  */
 function createBaseFor(fromRight) {
-  return function(object, iteratee, keysFunc) {
-    var index = -1,
-        iterable = Object(object),
-        props = keysFunc(object),
-        length = props.length;
+  return (object, iteratee, keysFunc) => {
+    let index = -1
+    const iterable = Object(object)
+    const props = keysFunc(object)
+    let length = props.length
 
     while (length--) {
-      var key = props[fromRight ? length : ++index];
+      const key = props[fromRight ? length : ++index]
       if (iteratee(iterable[key], key, iterable) === false) {
-        break;
+        break
       }
     }
-    return object;
-  };
+    return object
+  }
 }
 
 /**
@@ -1218,64 +1266,71 @@ function createBaseFor(fromRight) {
  * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
  */
 function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
-  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
-      arrLength = array.length,
-      othLength = other.length;
+  const isPartial = bitmask & PARTIAL_COMPARE_FLAG
+  const arrLength = array.length
+  const othLength = other.length
 
-  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
-    return false;
+  if (arrLength !== othLength && !(isPartial && othLength > arrLength)) {
+    return false
   }
   // Assume cyclic values are equal.
-  var stacked = stack.get(array);
+  const stacked = stack.get(array)
   if (stacked && stack.get(other)) {
-    return stacked == other;
+    return stacked === other
   }
-  var index = -1,
-      result = true,
-      seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+  let index = -1
+  let result = true
+  const seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : undefined
 
-  stack.set(array, other);
-  stack.set(other, array);
+  stack.set(array, other)
+  stack.set(other, array)
 
   // Ignore non-index properties.
   while (++index < arrLength) {
-    var arrValue = array[index],
-        othValue = other[index];
+    const arrValue = array[index]
+    const othValue = other[index]
 
     if (customizer) {
-      var compared = isPartial
+      const _compared = isPartial
         ? customizer(othValue, arrValue, index, other, array, stack)
-        : customizer(arrValue, othValue, index, array, other, stack);
+        : customizer(arrValue, othValue, index, array, other, stack)
     }
     if (compared !== undefined) {
       if (compared) {
-        continue;
+        continue
       }
-      result = false;
-      break;
+      result = false
+      break
     }
     // Recursively compare arrays (susceptible to call stack limits).
     if (seen) {
-      if (!arraySome(other, function(othValue, othIndex) {
-            if (!seen.has(othIndex) &&
-                (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
-              return seen.add(othIndex);
-            }
-          })) {
-        result = false;
-        break;
+      if (
+        !arraySome(other, (othValue, othIndex) => {
+          if (
+            !seen.has(othIndex) &&
+            (arrValue === othValue ||
+              equalFunc(arrValue, othValue, customizer, bitmask, stack))
+          ) {
+            return seen.add(othIndex)
+          }
+        })
+      ) {
+        result = false
+        break
       }
-    } else if (!(
-          arrValue === othValue ||
-            equalFunc(arrValue, othValue, customizer, bitmask, stack)
-        )) {
-      result = false;
-      break;
+    } else if (
+      !(
+        arrValue === othValue ||
+        equalFunc(arrValue, othValue, customizer, bitmask, stack)
+      )
+    ) {
+      result = false
+      break
     }
   }
-  stack['delete'](array);
-  stack['delete'](other);
-  return result;
+  stack.delete(array)
+  stack.delete(other)
+  return result
 }
 
 /**
@@ -1299,66 +1354,79 @@ function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
 function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
   switch (tag) {
     case dataViewTag:
-      if ((object.byteLength != other.byteLength) ||
-          (object.byteOffset != other.byteOffset)) {
-        return false;
+      if (
+        object.byteLength !== other.byteLength ||
+        object.byteOffset !== other.byteOffset
+      ) {
+        return false
       }
-      object = object.buffer;
-      other = other.buffer;
+      object = object.buffer
+      other = other.buffer
 
     case arrayBufferTag:
-      if ((object.byteLength != other.byteLength) ||
-          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
-        return false;
+      if (
+        object.byteLength !== other.byteLength ||
+        !equalFunc(new Uint8Array(object), new Uint8Array(other))
+      ) {
+        return false
       }
-      return true;
+      return true
 
     case boolTag:
     case dateTag:
     case numberTag:
       // Coerce booleans to `1` or `0` and dates to milliseconds.
       // Invalid dates are coerced to `NaN`.
-      return eq(+object, +other);
+      return eq(+object, +other)
 
     case errorTag:
-      return object.name == other.name && object.message == other.message;
+      return object.name === other.name && object.message === other.message
 
     case regexpTag:
     case stringTag:
       // Coerce regexes to strings and treat strings, primitives and objects,
       // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
       // for more details.
-      return object == (other + '');
+      return object === `${other}`
 
-    case mapTag:
-      var convert = mapToArray;
+    case mapTag: {
+      const _convert = mapToArray
+    }
 
-    case setTag:
-      var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
-      convert || (convert = setToArray);
+    case setTag: {
+      const isPartial = bitmask & PARTIAL_COMPARE_FLAG
+      convert || (convert = setToArray)
 
-      if (object.size != other.size && !isPartial) {
-        return false;
+      if (object.size !== other.size && !isPartial) {
+        return false
       }
       // Assume cyclic values are equal.
-      var stacked = stack.get(object);
+      const stacked = stack.get(object)
       if (stacked) {
-        return stacked == other;
+        return stacked === other
       }
-      bitmask |= UNORDERED_COMPARE_FLAG;
+      bitmask |= UNORDERED_COMPARE_FLAG
 
       // Recursively compare objects (susceptible to call stack limits).
-      stack.set(object, other);
-      var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
-      stack['delete'](object);
-      return result;
+      stack.set(object, other)
+      const result = equalArrays(
+        convert(object),
+        convert(other),
+        equalFunc,
+        customizer,
+        bitmask,
+        stack
+      )
+      stack.delete(object)
+      return result
+    }
 
     case symbolTag:
       if (symbolValueOf) {
-        return symbolValueOf.call(object) == symbolValueOf.call(other);
+        return symbolValueOf.call(object) === symbolValueOf.call(other)
       }
   }
-  return false;
+  return false
 }
 
 /**
@@ -1376,67 +1444,76 @@ function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
 function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
-  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
-      objProps = keys(object),
-      objLength = objProps.length,
-      othProps = keys(other),
-      othLength = othProps.length;
-
-  if (objLength != othLength && !isPartial) {
-    return false;
+  const isPartial = bitmask & PARTIAL_COMPARE_FLAG
+  const objProps = keys(object)
+  const objLength = objProps.length
+  const othProps = keys(other)
+  const othLength = othProps.length
+
+  if (objLength !== othLength && !isPartial) {
+    return false
   }
-  var index = objLength;
+  let index = objLength
   while (index--) {
-    var key = objProps[index];
+    const key = objProps[index]
     if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
-      return false;
+      return false
     }
   }
   // Assume cyclic values are equal.
-  var stacked = stack.get(object);
+  const stacked = stack.get(object)
   if (stacked && stack.get(other)) {
-    return stacked == other;
+    return stacked === other
   }
-  var result = true;
-  stack.set(object, other);
-  stack.set(other, object);
+  let result = true
+  stack.set(object, other)
+  stack.set(other, object)
 
-  var skipCtor = isPartial;
+  let skipCtor = isPartial
   while (++index < objLength) {
-    key = objProps[index];
-    var objValue = object[key],
-        othValue = other[key];
+    key = objProps[index]
+    const objValue = object[key]
+    const othValue = other[key]
 
     if (customizer) {
-      var compared = isPartial
+      const _compared = isPartial
         ? customizer(othValue, objValue, key, other, object, stack)
-        : customizer(objValue, othValue, key, object, other, stack);
+        : customizer(objValue, othValue, key, object, other, stack)
     }
     // Recursively compare objects (susceptible to call stack limits).
-    if (!(compared === undefined
-          ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
-          : compared
-        )) {
-      result = false;
-      break;
+    if (
+      !(compared === undefined
+        ? objValue === othValue ||
+          equalFunc(objValue, othValue, customizer, bitmask, stack)
+        : compared)
+    ) {
+      result = false
+      break
     }
-    skipCtor || (skipCtor = key == 'constructor');
+    skipCtor || (skipCtor = key === 'constructor')
   }
   if (result && !skipCtor) {
-    var objCtor = object.constructor,
-        othCtor = other.constructor;
+    const objCtor = object.constructor
+    const othCtor = other.constructor
 
     // Non `Object` object instances with different constructors are not equal.
-    if (objCtor != othCtor &&
-        ('constructor' in object && 'constructor' in other) &&
-        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
-          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
-      result = false;
+    if (
+      objCtor !== othCtor &&
+      'constructor' in object &&
+      'constructor' in other &&
+      !(
+        typeof objCtor === 'function' &&
+        objCtor instanceof objCtor &&
+        typeof othCtor === 'function' &&
+        othCtor instanceof othCtor
+      )
+    ) {
+      result = false
     }
   }
-  stack['delete'](object);
-  stack['delete'](other);
-  return result;
+  stack.delete(object)
+  stack.delete(other)
+  return result
 }
 
 /**
@@ -1448,10 +1525,10 @@ function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
  * @returns {*} Returns the map data.
  */
 function getMapData(map, key) {
-  var data = map.__data__;
+  const data = map.__data__
   return isKeyable(key)
-    ? data[typeof key == 'string' ? 'string' : 'hash']
-    : data.map;
+    ? data[typeof key === 'string' ? 'string' : 'hash']
+    : data.map
 }
 
 /**
@@ -1462,16 +1539,16 @@ function getMapData(map, key) {
  * @returns {Array} Returns the match data of `object`.
  */
 function getMatchData(object) {
-  var result = keys(object),
-      length = result.length;
+  const result = keys(object)
+  let length = result.length
 
   while (length--) {
-    var key = result[length],
-        value = object[key];
+    const key = result[length]
+    const value = object[key]
 
-    result[length] = [key, value, isStrictComparable(value)];
+    result[length] = [key, value, isStrictComparable(value)]
   }
-  return result;
+  return result
 }
 
 /**
@@ -1483,8 +1560,8 @@ function getMatchData(object) {
  * @returns {*} Returns the function if it's native, else `undefined`.
  */
 function getNative(object, key) {
-  var value = getValue(object, key);
-  return baseIsNative(value) ? value : undefined;
+  const value = getValue(object, key)
+  return baseIsNative(value) ? value : undefined
 }
 
 /**
@@ -1494,31 +1571,38 @@ function getNative(object, key) {
  * @param {*} value The value to query.
  * @returns {string} Returns the `toStringTag`.
  */
-var getTag = baseGetTag;
+let getTag = baseGetTag
 
 // Fallback for data views, maps, sets, and weak maps in IE 11,
 // for data views in Edge < 14, and promises in Node.js.
-if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
-    (Map && getTag(new Map) != mapTag) ||
-    (Promise && getTag(Promise.resolve()) != promiseTag) ||
-    (Set && getTag(new Set) != setTag) ||
-    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
-  getTag = function(value) {
-    var result = objectToString.call(value),
-        Ctor = result == objectTag ? value.constructor : undefined,
-        ctorString = Ctor ? toSource(Ctor) : undefined;
+if (
+  (DataView && getTag(new DataView(new ArrayBuffer(1))) !== dataViewTag) ||
+  (Map && getTag(new Map()) !== mapTag) ||
+  (Promise && getTag(Promise.resolve()) !== promiseTag) ||
+  (Set && getTag(new Set()) !== setTag) ||
+  (WeakMap && getTag(new WeakMap()) !== weakMapTag)
+) {
+  getTag = value => {
+    const result = objectToString.call(value)
+    const Ctor = result === objectTag ? value.constructor : undefined
+    const ctorString = Ctor ? toSource(Ctor) : undefined
 
     if (ctorString) {
       switch (ctorString) {
-        case dataViewCtorString: return dataViewTag;
-        case mapCtorString: return mapTag;
-        case promiseCtorString: return promiseTag;
-        case setCtorString: return setTag;
-        case weakMapCtorString: return weakMapTag;
+        case dataViewCtorString:
+          return dataViewTag
+        case mapCtorString:
+          return mapTag
+        case promiseCtorString:
+          return promiseTag
+        case setCtorString:
+          return setTag
+        case weakMapCtorString:
+          return weakMapTag
       }
     }
-    return result;
-  };
+    return result
+  }
 }
 
 /**
@@ -1531,25 +1615,29 @@ if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
  * @returns {boolean} Returns `true` if `path` exists, else `false`.
  */
 function hasPath(object, path, hasFunc) {
-  path = isKey(path, object) ? [path] : castPath(path);
+  path = isKey(path, object) ? [path] : castPath(path)
 
-  var result,
-      index = -1,
-      length = path.length;
+  let result
+  let index = -1
+  const _length = path.length
 
   while (++index < length) {
-    var key = toKey(path[index]);
+    const key = toKey(path[index])
     if (!(result = object != null && hasFunc(object, key))) {
-      break;
+      break
     }
-    object = object[key];
+    object = object[key]
   }
   if (result) {
-    return result;
+    return result
   }
-  var length = object ? object.length : 0;
-  return !!length && isLength(length) && isIndex(key, length) &&
-    (isArray(object) || isArguments(object));
+  const length = object ? object.length : 0
+  return (
+    !!length &&
+    isLength(length) &&
+    isIndex(key, length) &&
+    (isArray(object) || isArguments(object))
+  )
 }
 
 /**
@@ -1561,10 +1649,14 @@ function hasPath(object, path, hasFunc) {
  * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
  */
 function isIndex(value, length) {
-  length = length == null ? MAX_SAFE_INTEGER : length;
-  return !!length &&
-    (typeof value == 'number' || reIsUint.test(value)) &&
-    (value > -1 && value % 1 == 0 && value < length);
+  length = length == null ? MAX_SAFE_INTEGER : length
+  return (
+    !!length &&
+    (typeof value === 'number' || reIsUint.test(value)) &&
+    value > -1 &&
+    value % 1 === 0 &&
+    value < length
+  )
 }
 
 /**
@@ -1577,15 +1669,23 @@ function isIndex(value, length) {
  */
 function isKey(value, object) {
   if (isArray(value)) {
-    return false;
+    return false
   }
-  var type = typeof value;
-  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
-      value == null || isSymbol(value)) {
-    return true;
+  const type = typeof value
+  if (
+    type === 'number' ||
+    type === 'symbol' ||
+    type === 'boolean' ||
+    value == null ||
+    isSymbol(value)
+  ) {
+    return true
   }
-  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
-    (object != null && value in Object(object));
+  return (
+    reIsPlainProp.test(value) ||
+    !reIsDeepProp.test(value) ||
+    (object != null && value in Object(object))
+  )
 }
 
 /**
@@ -1596,10 +1696,13 @@ function isKey(value, object) {
  * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
  */
 function isKeyable(value) {
-  var type = typeof value;
-  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
-    ? (value !== '__proto__')
-    : (value === null);
+  const type = typeof value
+  return type === 'string' ||
+    type === 'number' ||
+    type === 'symbol' ||
+    type === 'boolean'
+    ? value !== '__proto__'
+    : value === null
 }
 
 /**
@@ -1610,7 +1713,7 @@ function isKeyable(value) {
  * @returns {boolean} Returns `true` if `func` is masked, else `false`.
  */
 function isMasked(func) {
-  return !!maskSrcKey && (maskSrcKey in func);
+  return !!maskSrcKey && maskSrcKey in func
 }
 
 /**
@@ -1621,10 +1724,10 @@ function isMasked(func) {
  * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
  */
 function isPrototype(value) {
-  var Ctor = value && value.constructor,
-      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+  const Ctor = value?.constructor
+  const proto = (typeof Ctor === 'function' && Ctor.prototype) || objectProto
 
-  return value === proto;
+  return value === proto
 }
 
 /**
@@ -1636,7 +1739,7 @@ function isPrototype(value) {
  *  equality comparisons, else `false`.
  */
 function isStrictComparable(value) {
-  return value === value && !isObject(value);
+  return value === value && !isObject(value)
 }
 
 /**
@@ -1649,13 +1752,15 @@ function isStrictComparable(value) {
  * @returns {Function} Returns the new spec function.
  */
 function matchesStrictComparable(key, srcValue) {
-  return function(object) {
+  return object => {
     if (object == null) {
-      return false;
+      return false
     }
-    return object[key] === srcValue &&
-      (srcValue !== undefined || (key in Object(object)));
-  };
+    return (
+      object[key] === srcValue &&
+      (srcValue !== undefined || key in Object(object))
+    )
+  }
 }
 
 /**
@@ -1665,18 +1770,18 @@ function matchesStrictComparable(key, srcValue) {
  * @param {string} string The string to convert.
  * @returns {Array} Returns the property path array.
  */
-var stringToPath = memoize(function(string) {
-  string = toString(string);
+const stringToPath = memoize(string => {
+  string = toString(string)
 
-  var result = [];
+  const result = []
   if (reLeadingDot.test(string)) {
-    result.push('');
+    result.push('')
   }
-  string.replace(rePropName, function(match, number, quote, string) {
-    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
-  });
-  return result;
-});
+  string.replace(rePropName, (match, number, quote, string) => {
+    result.push(quote ? string.replace(reEscapeChar, '$1') : number || match)
+  })
+  return result
+})
 
 /**
  * Converts `value` to a string key if it's not a string or symbol.
@@ -1686,11 +1791,11 @@ var stringToPath = memoize(function(string) {
  * @returns {string|symbol} Returns the key.
  */
 function toKey(value) {
-  if (typeof value == 'string' || isSymbol(value)) {
-    return value;
+  if (typeof value === 'string' || isSymbol(value)) {
+    return value
   }
-  var result = (value + '');
-  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+  const result = `${value}`
+  return result === '0' && 1 / value === -INFINITY ? '-0' : result
 }
 
 /**
@@ -1703,13 +1808,13 @@ function toKey(value) {
 function toSource(func) {
   if (func != null) {
     try {
-      return funcToString.call(func);
-    } catch (e) {}
+      return funcToString.call(func)
+    } catch (_e) {}
     try {
-      return (func + '');
-    } catch (e) {}
+      return `${func}`
+    } catch (_e) {}
   }
-  return '';
+  return ''
 }
 
 /**
@@ -1757,27 +1862,30 @@ function toSource(func) {
  * _.memoize.Cache = WeakMap;
  */
 function memoize(func, resolver) {
-  if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
-    throw new TypeError(FUNC_ERROR_TEXT);
+  if (
+    typeof func !== 'function' ||
+    (resolver && typeof resolver !== 'function')
+  ) {
+    throw new TypeError(FUNC_ERROR_TEXT)
   }
-  var memoized = function() {
-    var args = arguments,
-        key = resolver ? resolver.apply(this, args) : args[0],
-        cache = memoized.cache;
+  const memoized = function () {
+    const args = arguments
+    const key = resolver ? resolver.apply(this, args) : args[0]
+    const cache = memoized.cache
 
     if (cache.has(key)) {
-      return cache.get(key);
+      return cache.get(key)
     }
-    var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result);
-    return result;
-  };
-  memoized.cache = new (memoize.Cache || MapCache);
-  return memoized;
+    const result = func.apply(this, args)
+    memoized.cache = cache.set(key, result)
+    return result
+  }
+  memoized.cache = new (memoize.Cache || MapCache)()
+  return memoized
 }
 
 // Assign cache to `_.memoize`.
-memoize.Cache = MapCache;
+memoize.Cache = MapCache
 
 /**
  * Performs a
@@ -1812,7 +1920,7 @@ memoize.Cache = MapCache;
  * // => true
  */
 function eq(value, other) {
-  return value === other || (value !== value && other !== other);
+  return value === other || (value !== value && other !== other)
 }
 
 /**
@@ -1835,8 +1943,12 @@ function eq(value, other) {
  */
 function isArguments(value) {
   // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
-  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
-    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+  return (
+    isArrayLikeObject(value) &&
+    hasOwnProperty.call(value, 'callee') &&
+    (!propertyIsEnumerable.call(value, 'callee') ||
+      objectToString.call(value) === argsTag)
+  )
 }
 
 /**
@@ -1862,7 +1974,7 @@ function isArguments(value) {
  * _.isArray(_.noop);
  * // => false
  */
-var isArray = Array.isArray;
+const isArray = Array.isArray
 
 /**
  * Checks if `value` is array-like. A value is considered array-like if it's
@@ -1890,7 +2002,7 @@ var isArray = Array.isArray;
  * // => false
  */
 function isArrayLike(value) {
-  return value != null && isLength(value.length) && !isFunction(value);
+  return value != null && isLength(value.length) && !isFunction(value)
 }
 
 /**
@@ -1919,7 +2031,7 @@ function isArrayLike(value) {
  * // => false
  */
 function isArrayLikeObject(value) {
-  return isObjectLike(value) && isArrayLike(value);
+  return isObjectLike(value) && isArrayLike(value)
 }
 
 /**
@@ -1942,8 +2054,8 @@ function isArrayLikeObject(value) {
 function isFunction(value) {
   // The use of `Object#toString` avoids issues with the `typeof` operator
   // in Safari 8-9 which returns 'object' for typed array and other constructors.
-  var tag = isObject(value) ? objectToString.call(value) : '';
-  return tag == funcTag || tag == genTag;
+  const tag = isObject(value) ? objectToString.call(value) : ''
+  return tag === funcTag || tag === genTag
 }
 
 /**
@@ -1973,8 +2085,12 @@ function isFunction(value) {
  * // => false
  */
 function isLength(value) {
-  return typeof value == 'number' &&
-    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  return (
+    typeof value === 'number' &&
+    value > -1 &&
+    value % 1 === 0 &&
+    value <= MAX_SAFE_INTEGER
+  )
 }
 
 /**
@@ -2003,8 +2119,8 @@ function isLength(value) {
  * // => false
  */
 function isObject(value) {
-  var type = typeof value;
-  return !!value && (type == 'object' || type == 'function');
+  const type = typeof value
+  return !!value && (type === 'object' || type === 'function')
 }
 
 /**
@@ -2032,7 +2148,7 @@ function isObject(value) {
  * // => false
  */
 function isObjectLike(value) {
-  return !!value && typeof value == 'object';
+  return !!value && typeof value === 'object'
 }
 
 /**
@@ -2053,8 +2169,10 @@ function isObjectLike(value) {
  * // => false
  */
 function isSymbol(value) {
-  return typeof value == 'symbol' ||
-    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+  return (
+    typeof value === 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) === symbolTag)
+  )
 }
 
 /**
@@ -2074,7 +2192,9 @@ function isSymbol(value) {
  * _.isTypedArray([]);
  * // => false
  */
-var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+const isTypedArray = nodeIsTypedArray
+  ? baseUnary(nodeIsTypedArray)
+  : baseIsTypedArray
 
 /**
  * Converts `value` to a string. An empty string is returned for `null`
@@ -2098,7 +2218,7 @@ var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedA
  * // => '1,2,3'
  */
 function toString(value) {
-  return value == null ? '' : baseToString(value);
+  return value == null ? '' : baseToString(value)
 }
 
 /**
@@ -2127,8 +2247,8 @@ function toString(value) {
  * // => 'default'
  */
 function get(object, path, defaultValue) {
-  var result = object == null ? undefined : baseGet(object, path);
-  return result === undefined ? defaultValue : result;
+  const result = object == null ? undefined : baseGet(object, path)
+  return result === undefined ? defaultValue : result
 }
 
 /**
@@ -2158,7 +2278,7 @@ function get(object, path, defaultValue) {
  * // => false
  */
 function hasIn(object, path) {
-  return object != null && hasPath(object, path, baseHasIn);
+  return object != null && hasPath(object, path, baseHasIn)
 }
 
 /**
@@ -2190,7 +2310,7 @@ function hasIn(object, path) {
  * // => ['0', '1']
  */
 function keys(object) {
-  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object)
 }
 
 /**
@@ -2222,13 +2342,13 @@ function keys(object) {
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  */
 function mapValues(object, iteratee) {
-  var result = {};
-  iteratee = baseIteratee(iteratee, 3);
+  const result = {}
+  iteratee = baseIteratee(iteratee, 3)
 
-  baseForOwn(object, function(value, key, object) {
-    result[key] = iteratee(value, key, object);
-  });
-  return result;
+  baseForOwn(object, (value, key, object) => {
+    result[key] = iteratee(value, key, object)
+  })
+  return result
 }
 
 /**
@@ -2248,7 +2368,7 @@ function mapValues(object, iteratee) {
  * // => true
  */
 function identity(value) {
-  return value;
+  return value
 }
 
 /**
@@ -2274,7 +2394,7 @@ function identity(value) {
  * // => [1, 2]
  */
 function property(path) {
-  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path)
 }
 
-module.exports = mapValues;
+module.exports = mapValues