Update lodash-amd to v4.17.21 + edadd45 (#6064)

* Fix prototype pollution in _.set and related functions

Prevents setting dangerous properties (__proto__, constructor, prototype)
that could lead to prototype pollution vulnerabilities.

* Fix command injection vulnerability in _.template

- Add validation for the variable option to prevent injection attacks
- Improve sourceURL whitespace normalization to prevent code injection

* Fix cyclic value comparison in _.isEqual

Properly checks both directions when comparing cyclic values to ensure
correct equality comparisons for circular references.

* Improve _.sortBy and _.orderBy performance and array handling

- Add early return for empty arrays in sorted index operations
- Improve array iteratee handling to support nested property paths
- Add missing keysIn import in baseClone

* Refactor _.trim, _.trimEnd, and _.trimStart implementations

Extract shared trim logic into reusable utilities (_baseTrim, _trimmedEndIndex)
for better code organization and consistency. Update related functions
(toNumber, parseInt) to use new utilities. Improve comment accuracy.

* Add documentation for predicate composition with _.overEvery and _.overSome

Enhance documentation to show how _.matches and _.matchesProperty can be
combined using _.overEvery and _.overSome for more powerful filtering.
Add examples demonstrating shorthand predicate syntax.

* Bump to v4.17.21

* Fix prototype pollution in _.unset and _.omit

Prevent prototype pollution on baseUnset function by:
- Blocking "__proto__" if not an own property
- Blocking "constructor.prototype" chains (except when starting at primitive root)
- Skipping non-string keys

See: https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg

* Update JSDoc documentation to align with main branch

- Fix sortBy example ages (40 -> 30) for correct sort order demonstration
- Fix _setCacheHas return type (number -> boolean)

LICENSE

@@ -1,4 +1,4 @@
-Copyright JS Foundation and other contributors <https://js.foundation/>
+Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 
 Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.16.5
+# lodash-amd v4.17.21
 
 The [Lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.16.5-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.17.21-amd) for more details.

_baseAssignIn.js

@@ -0,0 +1,17 @@
+define(['./_copyObject', './keysIn'], function(copyObject, keysIn) {
+
+  /**
+   * The base implementation of `_.assignIn` without support for multiple sources
+   * or `customizer` functions.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @returns {Object} Returns `object`.
+   */
+  function baseAssignIn(object, source) {
+    return object && copyObject(source, keysIn(source), object);
+  }
+
+  return baseAssignIn;
+});

_baseAt.js

@@ -8,7 +8,7 @@ define(['./get'], function(get) {
    *
    * @private
    * @param {Object} object The object to iterate over.
-   * @param {string[]} paths The property paths of elements to pick.
+   * @param {string[]} paths The property paths to pick.
    * @returns {Array} Returns the picked elements.
    */
   function baseAt(object, paths) {

_baseClone.js

@@ -1,8 +1,13 @@
-define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_cloneBuffer', './_copyArray', './_copySymbols', './_getAllKeys', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './isObject', './keys'], function(Stack, arrayEach, assignValue, baseAssign, cloneBuffer, copyArray, copySymbols, getAllKeys, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isObject, keys) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseAssignIn', './_cloneBuffer', './_copyArray', './_copySymbols', './_copySymbolsIn', './_getAllKeys', './_getAllKeysIn', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './isMap', './isObject', './isSet', './keys', './keysIn'], function(Stack, arrayEach, assignValue, baseAssign, baseAssignIn, cloneBuffer, copyArray, copySymbols, copySymbolsIn, getAllKeys, getAllKeysIn, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isMap, isObject, isSet, keys, keysIn) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_FLAT_FLAG = 2,
+      CLONE_SYMBOLS_FLAG = 4;
+
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
       arrayTag = '[object Array]',
@@ -54,16 +59,22 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
    *
    * @private
    * @param {*} value The value to clone.
-   * @param {boolean} [isDeep] Specify a deep clone.
-   * @param {boolean} [isFull] Specify a clone including symbols.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Deep clone
+   *  2 - Flatten inherited properties
+   *  4 - Clone symbols
    * @param {Function} [customizer] The function to customize cloning.
    * @param {string} [key] The key of `value`.
    * @param {Object} [object] The parent object of `value`.
    * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
    * @returns {*} Returns the cloned value.
    */
-  function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
-    var result;
+  function baseClone(value, bitmask, customizer, key, object, stack) {
+    var result,
+        isDeep = bitmask & CLONE_DEEP_FLAG,
+        isFlat = bitmask & CLONE_FLAT_FLAG,
+        isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
     }
@@ -87,15 +98,17 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
         return cloneBuffer(value, isDeep);
       }
       if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
-        result = initCloneObject(isFunc ? {} : value);
+        result = (isFlat || isFunc) ? {} : initCloneObject(value);
         if (!isDeep) {
-          return copySymbols(value, baseAssign(result, value));
+          return isFlat
+            ? copySymbolsIn(value, baseAssignIn(result, value))
+            : copySymbols(value, baseAssign(result, value));
         }
       } else {
         if (!cloneableTags[tag]) {
           return object ? value : {};
         }
-        result = initCloneByTag(value, tag, baseClone, isDeep);
+        result = initCloneByTag(value, tag, isDeep);
       }
     }
     // Check for circular references and return its corresponding clone.
@@ -106,14 +119,28 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
     }
     stack.set(value, result);
 
-    var props = isArr ? undefined : (isFull ? getAllKeys : keys)(value);
+    if (isSet(value)) {
+      value.forEach(function(subValue) {
+        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+      });
+    } else if (isMap(value)) {
+      value.forEach(function(subValue, key) {
+        result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+      });
+    }
+
+    var keysFunc = isFull
+      ? (isFlat ? getAllKeysIn : getAllKeys)
+      : (isFlat ? keysIn : keys);
+
+    var props = isArr ? undefined : keysFunc(value);
     arrayEach(props || value, function(subValue, key) {
       if (props) {
         key = subValue;
         subValue = value[key];
       }
       // Recursively populate clone (susceptible to call stack limits).
-      assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
     });
     return result;
   }

_baseGet.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isKey', './_toKey'], function(castPath, isKey, toKey) {
+define(['./_castPath', './_toKey'], function(castPath, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,7 +12,7 @@ define(['./_castPath', './_isKey', './_toKey'], function(castPath, isKey, toKey)
    * @returns {*} Returns the resolved value.
    */
   function baseGet(object, path) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
     var index = 0,
         length = path.length;

_baseGetTag.js

@@ -21,8 +21,7 @@ define(['./_Symbol', './_getRawTag', './_objectToString'], function(Symbol, getR
     if (value == null) {
       return value === undefined ? undefinedTag : nullTag;
     }
-    value = Object(value);
-    return (symToStringTag && symToStringTag in value)
+    return (symToStringTag && symToStringTag in Object(value))
       ? getRawTag(value)
       : objectToString(value);
   }

_baseInvoke.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_castPath', './_isKey', './last', './_parent', './_toKey'], function(apply, castPath, isKey, last, parent, toKey) {
+define(['./_apply', './_castPath', './last', './_parent', './_toKey'], function(apply, castPath, last, parent, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,12 +14,9 @@ define(['./_apply', './_castPath', './_isKey', './last', './_parent', './_toKey'
    * @returns {*} Returns the result of the invoked method.
    */
   function baseInvoke(object, path, args) {
-    if (!isKey(path, object)) {
-      path = castPath(path);
-      object = parent(object, path);
-      path = last(path);
-    }
-    var func = object == null ? object : object[toKey(path)];
+    path = castPath(path, object);
+    object = parent(object, path);
+    var func = object == null ? object : object[toKey(last(path))];
     return func == null ? undefined : apply(func, object, args);
   }
 

_baseIsEqual.js

@@ -1,4 +1,4 @@
-define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEqualDeep, isObject, isObjectLike) {
+define(['./_baseIsEqualDeep', './isObjectLike'], function(baseIsEqualDeep, isObjectLike) {
 
   /**
    * The base implementation of `_.isEqual` which supports partial comparisons
@@ -7,22 +7,21 @@ define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEq
    * @private
    * @param {*} value The value to compare.
    * @param {*} other The other value to compare.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Unordered comparison
+   *  2 - Partial comparison
    * @param {Function} [customizer] The function to customize comparisons.
-   * @param {boolean} [bitmask] The bitmask of comparison flags.
-   *  The bitmask may be composed of the following flags:
-   *     1 - Unordered comparison
-   *     2 - Partial comparison
    * @param {Object} [stack] Tracks traversed `value` and `other` objects.
    * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
    */
-  function baseIsEqual(value, other, customizer, bitmask, stack) {
+  function baseIsEqual(value, other, bitmask, customizer, stack) {
     if (value === other) {
       return true;
     }
-    if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
       return value !== value && other !== other;
     }
-    return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
   }
 
   return baseIsEqual;

_baseIsEqualDeep.js

@@ -1,7 +1,7 @@
 define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_getTag', './isArray', './isBuffer', './isTypedArray'], function(Stack, equalArrays, equalByTag, equalObjects, getTag, isArray, isBuffer, isTypedArray) {
 
-  /** Used to compose bitmasks for comparison styles. */
-  var PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1;
 
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
@@ -22,27 +22,21 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
    * @private
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
    * @param {Function} equalFunc The function to determine equivalents of values.
-   * @param {Function} [customizer] The function to customize comparisons.
-   * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
    * @param {Object} [stack] Tracks traversed `object` and `other` objects.
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
-  function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
     var objIsArr = isArray(object),
         othIsArr = isArray(other),
-        objTag = arrayTag,
-        othTag = arrayTag;
+        objTag = objIsArr ? arrayTag : getTag(object),
+        othTag = othIsArr ? arrayTag : getTag(other);
+
+    objTag = objTag == argsTag ? objectTag : objTag;
+    othTag = othTag == argsTag ? objectTag : othTag;
 
-    if (!objIsArr) {
-      objTag = getTag(object);
-      objTag = objTag == argsTag ? objectTag : objTag;
-    }
-    if (!othIsArr) {
-      othTag = getTag(other);
-      othTag = othTag == argsTag ? objectTag : othTag;
-    }
     var objIsObj = objTag == objectTag,
         othIsObj = othTag == objectTag,
         isSameTag = objTag == othTag;
@@ -57,10 +51,10 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
     if (isSameTag && !objIsObj) {
       stack || (stack = new Stack);
       return (objIsArr || isTypedArray(object))
-        ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
-        : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+        ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+        : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
     }
-    if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
+    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
       var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
           othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
 
@@ -69,14 +63,14 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
             othUnwrapped = othIsWrapped ? other.value() : other;
 
         stack || (stack = new Stack);
-        return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
       }
     }
     if (!isSameTag) {
       return false;
     }
     stack || (stack = new Stack);
-    return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
   }
 
   return baseIsEqualDeep;

_baseIsMatch.js

@@ -3,9 +3,9 @@ define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * The base implementation of `_.isMatch` without support for iteratee shorthands.
@@ -51,7 +51,7 @@ define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
           var result = customizer(objValue, srcValue, key, object, source, stack);
         }
         if (!(result === undefined
-              ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+              ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
               : result
             )) {
           return false;

_baseMatchesProperty.js

@@ -3,9 +3,9 @@ define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
@@ -23,7 +23,7 @@ define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable
       var 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, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
     };
   }
 

_baseMerge.js

@@ -1,4 +1,4 @@
-define(['./_Stack', './_assignMergeValue', './_baseFor', './_baseMergeDeep', './isObject', './keysIn'], function(Stack, assignMergeValue, baseFor, baseMergeDeep, isObject, keysIn) {
+define(['./_Stack', './_assignMergeValue', './_baseFor', './_baseMergeDeep', './isObject', './keysIn', './_safeGet'], function(Stack, assignMergeValue, baseFor, baseMergeDeep, isObject, keysIn, safeGet) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -19,13 +19,13 @@ define(['./_Stack', './_assignMergeValue', './_baseFor', './_baseMergeDeep', './
       return;
     }
     baseFor(source, function(srcValue, key) {
+      stack || (stack = new Stack);
       if (isObject(srcValue)) {
-        stack || (stack = new Stack);
         baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
       }
       else {
         var newValue = customizer
-          ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+          ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
           : undefined;
 
         if (newValue === undefined) {

_baseMergeDeep.js

@@ -1,4 +1,4 @@
-define(['./_assignMergeValue', './_cloneBuffer', './_cloneTypedArray', './_copyArray', './_initCloneObject', './isArguments', './isArray', './isArrayLikeObject', './isBuffer', './isFunction', './isObject', './isPlainObject', './isTypedArray', './toPlainObject'], function(assignMergeValue, cloneBuffer, cloneTypedArray, copyArray, initCloneObject, isArguments, isArray, isArrayLikeObject, isBuffer, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
+define(['./_assignMergeValue', './_cloneBuffer', './_cloneTypedArray', './_copyArray', './_initCloneObject', './isArguments', './isArray', './isArrayLikeObject', './isBuffer', './isFunction', './isObject', './isPlainObject', './isTypedArray', './_safeGet', './toPlainObject'], function(assignMergeValue, cloneBuffer, cloneTypedArray, copyArray, initCloneObject, isArguments, isArray, isArrayLikeObject, isBuffer, isFunction, isObject, isPlainObject, isTypedArray, safeGet, toPlainObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -19,8 +19,8 @@ define(['./_assignMergeValue', './_cloneBuffer', './_cloneTypedArray', './_copyA
    *  counterparts.
    */
   function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
-    var objValue = object[key],
-        srcValue = source[key],
+    var objValue = safeGet(object, key),
+        srcValue = safeGet(source, key),
         stacked = stack.get(srcValue);
 
     if (stacked) {
@@ -63,7 +63,7 @@ define(['./_assignMergeValue', './_cloneBuffer', './_cloneTypedArray', './_copyA
         if (isArguments(objValue)) {
           newValue = toPlainObject(objValue);
         }
-        else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+        else if (!isObject(objValue) || isFunction(objValue)) {
           newValue = initCloneObject(srcValue);
         }
       }

_baseOrderBy.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_baseUnary', './_compareMultiple', './identity'], function(arrayMap, baseIteratee, baseMap, baseSortBy, baseUnary, compareMultiple, identity) {
+define(['./_arrayMap', './_baseGet', './_baseIteratee', './_baseMap', './_baseSortBy', './_baseUnary', './_compareMultiple', './identity', './isArray'], function(arrayMap, baseGet, baseIteratee, baseMap, baseSortBy, baseUnary, compareMultiple, identity, isArray) {
 
   /**
    * The base implementation of `_.orderBy` without param guards.
@@ -10,8 +10,21 @@ define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_bas
    * @returns {Array} Returns the new sorted array.
    */
   function baseOrderBy(collection, iteratees, orders) {
+    if (iteratees.length) {
+      iteratees = arrayMap(iteratees, function(iteratee) {
+        if (isArray(iteratee)) {
+          return function(value) {
+            return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+          }
+        }
+        return iteratee;
+      });
+    } else {
+      iteratees = [identity];
+    }
+
     var index = -1;
-    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
+    iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

_basePick.js

@@ -1,4 +1,4 @@
-define(['./_basePickBy'], function(basePickBy) {
+define(['./_basePickBy', './hasIn'], function(basePickBy, hasIn) {
 
   /**
    * The base implementation of `_.pick` without support for individual
@@ -6,13 +6,12 @@ define(['./_basePickBy'], function(basePickBy) {
    *
    * @private
    * @param {Object} object The source object.
-   * @param {string[]} props The property identifiers to pick.
+   * @param {string[]} paths The property paths to pick.
    * @returns {Object} Returns the new object.
    */
-  function basePick(object, props) {
-    object = Object(object);
-    return basePickBy(object, props, function(value, key) {
-      return key in object;
+  function basePick(object, paths) {
+    return basePickBy(object, paths, function(value, path) {
+      return hasIn(object, path);
     });
   }
 

_basePickBy.js

@@ -1,25 +1,25 @@
-define(['./_baseAssignValue'], function(baseAssignValue) {
+define(['./_baseGet', './_baseSet', './_castPath'], function(baseGet, baseSet, castPath) {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
    *
    * @private
    * @param {Object} object The source object.
-   * @param {string[]} props The property identifiers to pick from.
+   * @param {string[]} paths The property paths to pick.
    * @param {Function} predicate The function invoked per property.
    * @returns {Object} Returns the new object.
    */
-  function basePickBy(object, props, predicate) {
+  function basePickBy(object, paths, predicate) {
     var index = -1,
-        length = props.length,
+        length = paths.length,
         result = {};
 
     while (++index < length) {
-      var key = props[index],
-          value = object[key];
+      var path = paths[index],
+          value = baseGet(object, path);
 
-      if (predicate(value, key)) {
-        baseAssignValue(result, key, value);
+      if (predicate(value, path)) {
+        baseSet(result, castPath(path, object), value);
       }
     }
     return result;

_basePullAt.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isIndex', './_isKey', './last', './_parent', './_toKey'], function(castPath, isIndex, isKey, last, parent, toKey) {
+define(['./_baseUnset', './_isIndex'], function(baseUnset, isIndex) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -25,17 +25,8 @@ define(['./_castPath', './_isIndex', './_isKey', './last', './_parent', './_toKe
         var previous = index;
         if (isIndex(index)) {
           splice.call(array, index, 1);
-        }
-        else if (!isKey(index, array)) {
-          var path = castPath(index),
-              object = parent(array, path);
-
-          if (object != null) {
-            delete object[toKey(last(path))];
-          }
-        }
-        else {
-          delete array[toKey(index)];
+        } else {
+          baseUnset(array, index);
         }
       }
     }

_baseSet.js

@@ -1,4 +1,4 @@
-define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject', './_toKey'], function(assignValue, castPath, isIndex, isKey, isObject, toKey) {
+define(['./_assignValue', './_castPath', './_isIndex', './isObject', './_toKey'], function(assignValue, castPath, isIndex, isObject, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -17,7 +17,7 @@ define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject',
     if (!isObject(object)) {
       return object;
     }
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
     var index = -1,
         length = path.length,
@@ -28,6 +28,10 @@ define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject',
       var key = toKey(path[index]),
           newValue = value;
 
+      if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        return object;
+      }
+
       if (index != lastIndex) {
         var objValue = nested[key];
         newValue = customizer ? customizer(objValue, key, nested) : undefined;

_baseSortedIndexBy.js

@@ -25,11 +25,14 @@ define(['./isSymbol'], function(isSymbol) {
    *  into `array`.
    */
   function baseSortedIndexBy(array, value, iteratee, retHighest) {
-    value = iteratee(value);
-
     var low = 0,
-        high = array == null ? 0 : array.length,
-        valIsNaN = value !== value,
+        high = array == null ? 0 : array.length;
+    if (high === 0) {
+      return 0;
+    }
+
+    value = iteratee(value);
+    var valIsNaN = value !== value,
         valIsNull = value === null,
         valIsSymbol = isSymbol(value),
         valIsUndefined = value === undefined;

_baseTrim.js

@@ -0,0 +1,20 @@
+define(['./_trimmedEndIndex'], function(trimmedEndIndex) {
+
+  /** Used to match leading whitespace. */
+  var reTrimStart = /^\s+/;
+
+  /**
+   * The base implementation of `_.trim`.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} Returns the trimmed string.
+   */
+  function baseTrim(string) {
+    return string
+      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+      : string;
+  }
+
+  return baseTrim;
+});

_baseUnset.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isKey', './last', './_parent', './_toKey'], function(castPath, isKey, last, parent, toKey) {
+define(['./_castPath', './last', './_parent', './_toKey'], function(castPath, last, parent, toKey) {
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -11,15 +11,52 @@ define(['./_castPath', './_isKey', './last', './_parent', './_toKey'], function(
    *
    * @private
    * @param {Object} object The object to modify.
-   * @param {Array|string} path The path of the property to unset.
+   * @param {Array|string} path The property path to unset.
    * @returns {boolean} Returns `true` if the property is deleted, else `false`.
    */
   function baseUnset(object, path) {
-    path = isKey(path, object) ? [path] : castPath(path);
-    object = parent(object, path);
+    path = castPath(path, object);
 
-    var key = toKey(last(path));
-    return !(object != null && hasOwnProperty.call(object, key)) || delete object[key];
+    // Prevent prototype pollution, see: https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+    var index = -1,
+        length = path.length;
+
+    if (!length) {
+      return true;
+    }
+
+    var isRootPrimitive = object == null || (typeof object !== 'object' && typeof object !== 'function');
+
+    while (++index < length) {
+      var key = path[index];
+
+      // skip non-string keys (e.g., Symbols, numbers)
+      if (typeof key !== 'string') {
+        continue;
+      }
+
+      // Always block "__proto__" anywhere in the path if it's not expected
+      if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
+        return false;
+      }
+
+      // Block "constructor.prototype" chains
+      if (key === 'constructor' &&
+          (index + 1) < length &&
+          typeof path[index + 1] === 'string' &&
+          path[index + 1] === 'prototype') {
+
+        // Allow ONLY when the path starts at a primitive root, e.g., _.unset(0, 'constructor.prototype.a')
+        if (isRootPrimitive && index === 0) {
+          continue;
+        }
+
+        return false;
+      }
+    }
+
+    var obj = parent(object, path);
+    return obj == null || delete obj[toKey(last(path))];
   }
 
   return baseUnset;

_baseXor.js

@@ -23,9 +23,8 @@ define(['./_baseDifference', './_baseFlatten', './_baseUniq'], function(baseDiff
           othIndex = -1;
 
       while (++othIndex < length) {
-        var othArray = arrays[othIndex];
-        if (othArray !== array) {
-          result[index] = baseDifference(result[index] || array, othArray, iteratee, comparator);
+        if (othIndex != index) {
+          result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
         }
       }
     }

_castPath.js

@@ -1,14 +1,18 @@
-define(['./isArray', './_stringToPath'], function(isArray, stringToPath) {
+define(['./isArray', './_isKey', './_stringToPath', './toString'], function(isArray, isKey, stringToPath, toString) {
 
   /**
    * Casts `value` to a path array if it's not one.
    *
    * @private
    * @param {*} value The value to inspect.
+   * @param {Object} [object] The object to query keys on.
    * @returns {Array} Returns the cast property path array.
    */
-  function castPath(value) {
-    return isArray(value) ? value : stringToPath(value);
+  function castPath(value, object) {
+    if (isArray(value)) {
+      return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toString(value));
   }
 
   return castPath;

_cloneMap.js

@@ -1,5 +1,8 @@
 define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEntry, arrayReduce, mapToArray) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a clone of `map`.
    *
@@ -10,7 +13,7 @@ define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEnt
    * @returns {Object} Returns the cloned map.
    */
   function cloneMap(map, isDeep, cloneFunc) {
-    var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+    var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
     return arrayReduce(array, addMapEntry, new map.constructor);
   }
 

_cloneSet.js

@@ -1,5 +1,8 @@
 define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEntry, arrayReduce, setToArray) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a clone of `set`.
    *
@@ -10,7 +13,7 @@ define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEnt
    * @returns {Object} Returns the cloned set.
    */
   function cloneSet(set, isDeep, cloneFunc) {
-    var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+    var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
     return arrayReduce(array, addSetEntry, new set.constructor);
   }
 

_copySymbols.js

@@ -1,7 +1,7 @@
 define(['./_copyObject', './_getSymbols'], function(copyObject, getSymbols) {
 
   /**
-   * Copies own symbol properties of `source` to `object`.
+   * Copies own symbols of `source` to `object`.
    *
    * @private
    * @param {Object} source The object to copy symbols from.

_copySymbolsIn.js

@@ -0,0 +1,16 @@
+define(['./_copyObject', './_getSymbolsIn'], function(copyObject, getSymbolsIn) {
+
+  /**
+   * Copies own and inherited symbols of `source` to `object`.
+   *
+   * @private
+   * @param {Object} source The object to copy symbols from.
+   * @param {Object} [object={}] The object to copy symbols to.
+   * @returns {Object} Returns `object`.
+   */
+  function copySymbolsIn(source, object) {
+    return copyObject(source, getSymbolsIn(source), object);
+  }
+
+  return copySymbolsIn;
+});

_createBind.js

@@ -1,7 +1,7 @@
 define(['./_createCtor', './_root'], function(createCtor, root) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1;
+  var WRAP_BIND_FLAG = 1;
 
   /**
    * Creates a function that wraps `func` to invoke it with the optional `this`
@@ -14,7 +14,7 @@ define(['./_createCtor', './_root'], function(createCtor, root) {
    * @returns {Function} Returns the new wrapped function.
    */
   function createBind(func, bitmask, thisArg) {
-    var isBind = bitmask & BIND_FLAG,
+    var isBind = bitmask & WRAP_BIND_FLAG,
         Ctor = createCtor(func);
 
     function wrapper() {

_createFlow.js

@@ -3,17 +3,14 @@ define(['./_LodashWrapper', './_flatRest', './_getData', './_getFuncName', './is
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used as the size to enable large array optimizations. */
-  var LARGE_ARRAY_SIZE = 200;
-
   /** Error message constants. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /** Used to compose bitmasks for function metadata. */
-  var CURRY_FLAG = 8,
-      PARTIAL_FLAG = 32,
-      ARY_FLAG = 128,
-      REARG_FLAG = 256;
+  var WRAP_CURRY_FLAG = 8,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_ARY_FLAG = 128,
+      WRAP_REARG_FLAG = 256;
 
   /**
    * Creates a `_.flow` or `_.flowRight` function.
@@ -48,7 +45,7 @@ define(['./_LodashWrapper', './_flatRest', './_getData', './_getFuncName', './is
             data = funcName == 'wrapper' ? getData(func) : undefined;
 
         if (data && isLaziable(data[0]) &&
-              data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) &&
+              data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
               !data[4].length && data[9] == 1
             ) {
           wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
@@ -62,8 +59,7 @@ define(['./_LodashWrapper', './_flatRest', './_getData', './_getFuncName', './is
         var args = arguments,
             value = args[0];
 
-        if (wrapper && args.length == 1 &&
-            isArray(value) && value.length >= LARGE_ARRAY_SIZE) {
+        if (wrapper && args.length == 1 && isArray(value)) {
           return wrapper.plant(value).value();
         }
         var index = 0,

_createHybrid.js

@@ -4,12 +4,12 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_FLAG = 8,
-      CURRY_RIGHT_FLAG = 16,
-      ARY_FLAG = 128,
-      FLIP_FLAG = 512;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_CURRY_RIGHT_FLAG = 16,
+      WRAP_ARY_FLAG = 128,
+      WRAP_FLIP_FLAG = 512;
 
   /**
    * Creates a function that wraps `func` to invoke it with optional `this`
@@ -31,11 +31,11 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    * @returns {Function} Returns the new wrapped function.
    */
   function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
-    var isAry = bitmask & ARY_FLAG,
-        isBind = bitmask & BIND_FLAG,
-        isBindKey = bitmask & BIND_KEY_FLAG,
-        isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
-        isFlip = bitmask & FLIP_FLAG,
+    var isAry = bitmask & WRAP_ARY_FLAG,
+        isBind = bitmask & WRAP_BIND_FLAG,
+        isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
+        isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
+        isFlip = bitmask & WRAP_FLIP_FLAG,
         Ctor = isBindKey ? undefined : createCtor(func);
 
     function wrapper() {

_createPartial.js

@@ -1,7 +1,7 @@
 define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, root) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1;
+  var WRAP_BIND_FLAG = 1;
 
   /**
    * Creates a function that wraps `func` to invoke it with the `this` binding
@@ -16,7 +16,7 @@ define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, roo
    * @returns {Function} Returns the new wrapped function.
    */
   function createPartial(func, bitmask, thisArg, partials) {
-    var isBind = bitmask & BIND_FLAG,
+    var isBind = bitmask & WRAP_BIND_FLAG,
         Ctor = createCtor(func);
 
     function wrapper() {

_createRecurry.js

@@ -4,12 +4,12 @@ define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziabl
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_BOUND_FLAG = 4,
-      CURRY_FLAG = 8,
-      PARTIAL_FLAG = 32,
-      PARTIAL_RIGHT_FLAG = 64;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_BOUND_FLAG = 4,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_PARTIAL_RIGHT_FLAG = 64;
 
   /**
    * Creates a function that wraps `func` to continue currying.
@@ -29,17 +29,17 @@ define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziabl
    * @returns {Function} Returns the new wrapped function.
    */
   function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
-    var isCurry = bitmask & CURRY_FLAG,
+    var isCurry = bitmask & WRAP_CURRY_FLAG,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
         newPartials = isCurry ? partials : undefined,
         newPartialsRight = isCurry ? undefined : partials;
 
-    bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
-    bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
+    bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
+    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
 
-    if (!(bitmask & CURRY_BOUND_FLAG)) {
-      bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
+    if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
+      bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
     }
     var newData = [
       func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,

_createRound.js

@@ -1,7 +1,8 @@
-define(['./toInteger', './toNumber', './toString'], function(toInteger, toNumber, toString) {
+define(['./_root', './toInteger', './toNumber', './toString'], function(root, toInteger, toNumber, toString) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
-  var nativeMin = Math.min;
+  var nativeIsFinite = root.isFinite,
+      nativeMin = Math.min;
 
   /**
    * Creates a function like `_.round`.
@@ -14,8 +15,8 @@ define(['./toInteger', './toNumber', './toString'], function(toInteger, toNumber
     var func = Math[methodName];
     return function(number, precision) {
       number = toNumber(number);
-      precision = nativeMin(toInteger(precision), 292);
-      if (precision) {
+      precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
+      if (precision && nativeIsFinite(number)) {
         // Shift with exponential notation to avoid floating-point issues.
         // See [MDN](https://mdn.io/round#Examples) for more details.
         var pair = (toString(number) + 'e').split('e'),

_createWrap.js

@@ -7,12 +7,12 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_FLAG = 8,
-      CURRY_RIGHT_FLAG = 16,
-      PARTIAL_FLAG = 32,
-      PARTIAL_RIGHT_FLAG = 64;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_CURRY_RIGHT_FLAG = 16,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_PARTIAL_RIGHT_FLAG = 64;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeMax = Math.max;
@@ -24,17 +24,16 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
    * @private
    * @param {Function|string} func The function or method name to wrap.
    * @param {number} bitmask The bitmask flags.
-   *  The bitmask may be composed of the following flags:
-   *     1 - `_.bind`
-   *     2 - `_.bindKey`
-   *     4 - `_.curry` or `_.curryRight` of a bound function
-   *     8 - `_.curry`
-   *    16 - `_.curryRight`
-   *    32 - `_.partial`
-   *    64 - `_.partialRight`
-   *   128 - `_.rearg`
-   *   256 - `_.ary`
-   *   512 - `_.flip`
+   *    1 - `_.bind`
+   *    2 - `_.bindKey`
+   *    4 - `_.curry` or `_.curryRight` of a bound function
+   *    8 - `_.curry`
+   *   16 - `_.curryRight`
+   *   32 - `_.partial`
+   *   64 - `_.partialRight`
+   *  128 - `_.rearg`
+   *  256 - `_.ary`
+   *  512 - `_.flip`
    * @param {*} [thisArg] The `this` binding of `func`.
    * @param {Array} [partials] The arguments to be partially applied.
    * @param {Array} [holders] The `partials` placeholder indexes.
@@ -44,20 +43,20 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
    * @returns {Function} Returns the new wrapped function.
    */
   function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
-    var isBindKey = bitmask & BIND_KEY_FLAG;
+    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
     if (!isBindKey && typeof func != 'function') {
       throw new TypeError(FUNC_ERROR_TEXT);
     }
     var length = partials ? partials.length : 0;
     if (!length) {
-      bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
+      bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
       partials = holders = undefined;
     }
     ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
     arity = arity === undefined ? arity : toInteger(arity);
     length -= holders ? holders.length : 0;
 
-    if (bitmask & PARTIAL_RIGHT_FLAG) {
+    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
       var partialsRight = partials,
           holdersRight = holders;
 
@@ -78,18 +77,18 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
     thisArg = newData[2];
     partials = newData[3];
     holders = newData[4];
-    arity = newData[9] = newData[9] == null
+    arity = newData[9] = newData[9] === undefined
       ? (isBindKey ? 0 : func.length)
       : nativeMax(newData[9] - length, 0);
 
-    if (!arity && bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG)) {
-      bitmask &= ~(CURRY_FLAG | CURRY_RIGHT_FLAG);
+    if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
+      bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
     }
-    if (!bitmask || bitmask == BIND_FLAG) {
+    if (!bitmask || bitmask == WRAP_BIND_FLAG) {
       var result = createBind(func, bitmask, thisArg);
-    } else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
+    } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
       result = createCurry(func, bitmask, arity);
-    } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
+    } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
       result = createPartial(func, bitmask, thisArg, partials);
     } else {
       result = createHybrid.apply(undefined, newData);

_customDefaultsAssignIn.js

@@ -10,7 +10,9 @@ define(['./eq'], function(eq) {
   var hasOwnProperty = objectProto.hasOwnProperty;
 
   /**
-   * Used by `_.defaults` to customize its `_.assignIn` use.
+   * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
+   * of source objects to the destination object for all destination properties
+   * that resolve to `undefined`.
    *
    * @private
    * @param {*} objValue The destination value.
@@ -19,7 +21,7 @@ define(['./eq'], function(eq) {
    * @param {Object} object The parent object of `objValue`.
    * @returns {*} Returns the value to assign.
    */
-  function assignInDefaults(objValue, srcValue, key, object) {
+  function customDefaultsAssignIn(objValue, srcValue, key, object) {
     if (objValue === undefined ||
         (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
       return srcValue;
@@ -27,5 +29,5 @@ define(['./eq'], function(eq) {
     return objValue;
   }
 
-  return assignInDefaults;
+  return customDefaultsAssignIn;
 });

_customDefaultsMerge.js

@@ -4,7 +4,8 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
   var undefined;
 
   /**
-   * Used by `_.defaultsDeep` to customize its `_.merge` use.
+   * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
+   * objects into destination objects that are passed thru.
    *
    * @private
    * @param {*} objValue The destination value.
@@ -16,15 +17,15 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
    *  counterparts.
    * @returns {*} Returns the value to assign.
    */
-  function mergeDefaults(objValue, srcValue, key, object, source, stack) {
+  function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
     if (isObject(objValue) && isObject(srcValue)) {
       // Recursively merge objects and arrays (susceptible to call stack limits).
       stack.set(srcValue, objValue);
-      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack);
+      baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
       stack['delete'](srcValue);
     }
     return objValue;
   }
 
-  return mergeDefaults;
+  return customDefaultsMerge;
 });

_customOmitClone.js

@@ -0,0 +1,20 @@
+define(['./isPlainObject'], function(isPlainObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
+   * objects.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @param {string} key The key of the property to inspect.
+   * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
+   */
+  function customOmitClone(value) {
+    return isPlainObject(value) ? undefined : value;
+  }
+
+  return customOmitClone;
+});

_equalArrays.js

@@ -3,9 +3,9 @@ define(['./_SetCache', './_arraySome', './_cacheHas'], function(SetCache, arrayS
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * A specialized version of `baseIsEqualDeep` for arrays with support for
@@ -14,29 +14,29 @@ define(['./_SetCache', './_arraySome', './_cacheHas'], function(SetCache, arrayS
    * @private
    * @param {Array} array The array to compare.
    * @param {Array} other The other array to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `array` and `other` objects.
    * @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,
+  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
         arrLength = array.length,
         othLength = other.length;
 
     if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
       return false;
     }
-    // Assume cyclic values are equal.
-    var stacked = stack.get(array);
-    if (stacked && stack.get(other)) {
-      return stacked == other;
+    // Check that cyclic values are equal.
+    var arrStacked = stack.get(array);
+    var othStacked = stack.get(other);
+    if (arrStacked && othStacked) {
+      return arrStacked == other && othStacked == array;
     }
     var index = -1,
         result = true,
-        seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+        seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
 
     stack.set(array, other);
     stack.set(other, array);
@@ -62,7 +62,7 @@ define(['./_SetCache', './_arraySome', './_cacheHas'], function(SetCache, arrayS
       if (seen) {
         if (!arraySome(other, function(othValue, othIndex) {
               if (!cacheHas(seen, othIndex) &&
-                  (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+                  (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                 return seen.push(othIndex);
               }
             })) {
@@ -71,7 +71,7 @@ define(['./_SetCache', './_arraySome', './_cacheHas'], function(SetCache, arrayS
         }
       } else if (!(
             arrValue === othValue ||
-              equalFunc(arrValue, othValue, customizer, bitmask, stack)
+              equalFunc(arrValue, othValue, bitmask, customizer, stack)
           )) {
         result = false;
         break;

_equalByTag.js

@@ -3,9 +3,9 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /** `Object#toString` result references. */
   var boolTag = '[object Boolean]',
@@ -36,14 +36,13 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
    * @param {string} tag The `toStringTag` of the objects to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `object` and `other` objects.
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
-  function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
     switch (tag) {
       case dataViewTag:
         if ((object.byteLength != other.byteLength) ||
@@ -81,7 +80,7 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
         var convert = mapToArray;
 
       case setTag:
-        var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
         convert || (convert = setToArray);
 
         if (object.size != other.size && !isPartial) {
@@ -92,11 +91,11 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
         if (stacked) {
           return stacked == other;
         }
-        bitmask |= UNORDERED_COMPARE_FLAG;
+        bitmask |= COMPARE_UNORDERED_FLAG;
 
         // Recursively compare objects (susceptible to call stack limits).
         stack.set(object, other);
-        var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
         stack['delete'](object);
         return result;
 

_equalObjects.js

@@ -1,10 +1,10 @@
-define(['./keys'], function(keys) {
+define(['./_getAllKeys'], function(getAllKeys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1;
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -19,18 +19,17 @@ define(['./keys'], function(keys) {
    * @private
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `object` and `other` objects.
    * @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),
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+        objProps = getAllKeys(object),
         objLength = objProps.length,
-        othProps = keys(other),
+        othProps = getAllKeys(other),
         othLength = othProps.length;
 
     if (objLength != othLength && !isPartial) {
@@ -43,10 +42,11 @@ define(['./keys'], function(keys) {
         return false;
       }
     }
-    // Assume cyclic values are equal.
-    var stacked = stack.get(object);
-    if (stacked && stack.get(other)) {
-      return stacked == other;
+    // Check that cyclic values are equal.
+    var objStacked = stack.get(object);
+    var othStacked = stack.get(other);
+    if (objStacked && othStacked) {
+      return objStacked == other && othStacked == object;
     }
     var result = true;
     stack.set(object, other);
@@ -65,7 +65,7 @@ define(['./keys'], function(keys) {
       }
       // Recursively compare objects (susceptible to call stack limits).
       if (!(compared === undefined
-            ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
+            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
             : compared
           )) {
         result = false;

_getSymbols.js

@@ -1,16 +1,30 @@
-define(['./_overArg', './stubArray'], function(overArg, stubArray) {
+define(['./_arrayFilter', './stubArray'], function(arrayFilter, stubArray) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
-   * Creates an array of the own enumerable symbol properties of `object`.
+   * Creates an array of the own enumerable symbols of `object`.
    *
    * @private
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of symbols.
    */
-  var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
 
   return getSymbols;
 });

_getSymbolsIn.js

@@ -4,8 +4,7 @@ define(['./_arrayPush', './_getPrototype', './_getSymbols', './stubArray'], func
   var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
-   * Creates an array of the own and inherited enumerable symbol properties
-   * of `object`.
+   * Creates an array of the own and inherited enumerable symbols of `object`.
    *
    * @private
    * @param {Object} object The object to query.

_hasPath.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './_toKey'], function(castPath, isArguments, isArray, isIndex, isKey, isLength, toKey) {
+define(['./_castPath', './isArguments', './isArray', './_isIndex', './isLength', './_toKey'], function(castPath, isArguments, isArray, isIndex, isLength, toKey) {
 
   /**
    * Checks if `path` exists on `object`.
@@ -10,7 +10,7 @@ define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', '
    * @returns {boolean} Returns `true` if `path` exists, else `false`.
    */
   function hasPath(object, path, hasFunc) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
     var index = -1,
         length = path.length,

_hasUnicode.js

@@ -2,15 +2,17 @@ define([], function() {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
+      rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
       rsVarRange = '\\ufe0e\\ufe0f';
 
   /** Used to compose unicode capture groups. */
   var rsZWJ = '\\u200d';
 
   /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
-  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
+  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
 
   /**
    * Checks if `string` contains Unicode symbols.

_hasUnicodeWord.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /** Used to detect strings that need a more robust regexp to match words. */
-  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
 
   /**
    * Checks if `string` contains a word composed of Unicode symbols.

_hashHas.js

@@ -20,7 +20,7 @@ define(['./_nativeCreate'], function(nativeCreate) {
    */
   function hashHas(key) {
     var data = this.__data__;
-    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
   }
 
   return hashHas;

_initCloneArray.js

@@ -15,7 +15,7 @@ define([], function() {
    */
   function initCloneArray(array) {
     var length = array.length,
-        result = array.constructor(length);
+        result = new array.constructor(length);
 
     // Add properties assigned by `RegExp#exec`.
     if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {

_initCloneByTag.js

@@ -1,4 +1,4 @@
-define(['./_cloneArrayBuffer', './_cloneDataView', './_cloneMap', './_cloneRegExp', './_cloneSet', './_cloneSymbol', './_cloneTypedArray'], function(cloneArrayBuffer, cloneDataView, cloneMap, cloneRegExp, cloneSet, cloneSymbol, cloneTypedArray) {
+define(['./_cloneArrayBuffer', './_cloneDataView', './_cloneRegExp', './_cloneSymbol', './_cloneTypedArray'], function(cloneArrayBuffer, cloneDataView, cloneRegExp, cloneSymbol, cloneTypedArray) {
 
   /** `Object#toString` result references. */
   var boolTag = '[object Boolean]',
@@ -26,16 +26,15 @@ define(['./_cloneArrayBuffer', './_cloneDataView', './_cloneMap', './_cloneRegEx
    * Initializes an object clone based on its `toStringTag`.
    *
    * **Note:** This function only supports cloning values with tags of
-   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+   * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
    *
    * @private
    * @param {Object} object The object to clone.
    * @param {string} tag The `toStringTag` of the object to clone.
-   * @param {Function} cloneFunc The function to clone values.
    * @param {boolean} [isDeep] Specify a deep clone.
    * @returns {Object} Returns the initialized clone.
    */
-  function initCloneByTag(object, tag, cloneFunc, isDeep) {
+  function initCloneByTag(object, tag, isDeep) {
     var Ctor = object.constructor;
     switch (tag) {
       case arrayBufferTag:
@@ -54,7 +53,7 @@ define(['./_cloneArrayBuffer', './_cloneDataView', './_cloneMap', './_cloneRegEx
         return cloneTypedArray(object, isDeep);
 
       case mapTag:
-        return cloneMap(object, isDeep, cloneFunc);
+        return new Ctor;
 
       case numberTag:
       case stringTag:
@@ -64,7 +63,7 @@ define(['./_cloneArrayBuffer', './_cloneDataView', './_cloneMap', './_cloneRegEx
         return cloneRegExp(object);
 
       case setTag:
-        return cloneSet(object, isDeep, cloneFunc);
+        return new Ctor;
 
       case symbolTag:
         return cloneSymbol(object);

_isIndex.js

@@ -15,10 +15,13 @@ define([], function() {
    * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
    */
   function isIndex(value, length) {
+    var type = typeof value;
     length = length == null ? MAX_SAFE_INTEGER : length;
+
     return !!length &&
-      (typeof value == 'number' || reIsUint.test(value)) &&
-      (value > -1 && value % 1 == 0 && value < length);
+      (type == 'number' ||
+        (type != 'symbol' && reIsUint.test(value))) &&
+          (value > -1 && value % 1 == 0 && value < length);
   }
 
   return isIndex;

_lazyValue.js

@@ -1,8 +1,5 @@
 define(['./_baseWrapperValue', './_getView', './isArray'], function(baseWrapperValue, getView, isArray) {
 
-  /** Used as the size to enable large array optimizations. */
-  var LARGE_ARRAY_SIZE = 200;
-
   /** Used to indicate the type of lazy iteratees. */
   var LAZY_FILTER_FLAG = 1,
       LAZY_MAP_FLAG = 2;
@@ -34,8 +31,7 @@ define(['./_baseWrapperValue', './_getView', './isArray'], function(baseWrapperV
         resIndex = 0,
         takeCount = nativeMin(length, this.__takeCount__);
 
-    if (!isArr || arrLength < LARGE_ARRAY_SIZE ||
-        (arrLength == length && takeCount == length)) {
+    if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
       return baseWrapperValue(array, this.__actions__);
     }
     var result = [];

_mergeData.js

@@ -4,12 +4,12 @@ define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(
   var PLACEHOLDER = '__lodash_placeholder__';
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_BOUND_FLAG = 4,
-      CURRY_FLAG = 8,
-      ARY_FLAG = 128,
-      REARG_FLAG = 256;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_BOUND_FLAG = 4,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_ARY_FLAG = 128,
+      WRAP_REARG_FLAG = 256;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeMin = Math.min;
@@ -34,22 +34,22 @@ define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(
     var bitmask = data[1],
         srcBitmask = source[1],
         newBitmask = bitmask | srcBitmask,
-        isCommon = newBitmask < (BIND_FLAG | BIND_KEY_FLAG | ARY_FLAG);
+        isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
 
     var isCombo =
-      ((srcBitmask == ARY_FLAG) && (bitmask == CURRY_FLAG)) ||
-      ((srcBitmask == ARY_FLAG) && (bitmask == REARG_FLAG) && (data[7].length <= source[8])) ||
-      ((srcBitmask == (ARY_FLAG | REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == CURRY_FLAG));
+      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
+      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
+      ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
 
     // Exit early if metadata can't be merged.
     if (!(isCommon || isCombo)) {
       return data;
     }
     // Use source `thisArg` if available.
-    if (srcBitmask & BIND_FLAG) {
+    if (srcBitmask & WRAP_BIND_FLAG) {
       data[2] = source[2];
       // Set when currying a bound function.
-      newBitmask |= bitmask & BIND_FLAG ? 0 : CURRY_BOUND_FLAG;
+      newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
     }
     // Compose partial arguments.
     var value = source[3];
@@ -71,7 +71,7 @@ define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(
       data[7] = value;
     }
     // Use source `ary` if it's smaller.
-    if (srcBitmask & ARY_FLAG) {
+    if (srcBitmask & WRAP_ARY_FLAG) {
       data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
     }
     // Use source `arity` if one is not provided.

_nodeUtil.js

@@ -15,7 +15,15 @@ define(['./_freeGlobal'], function(freeGlobal) {
   /** Used to access faster Node.js helpers. */
   var nodeUtil = (function() {
     try {
-      return freeProcess && freeProcess.binding('util');
+      // Use `util.types` for Node.js 10+.
+      var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+      if (types) {
+        return types;
+      }
+
+      // Legacy `process.binding('util')` for Node.js < 10.
+      return freeProcess && freeProcess.binding && freeProcess.binding('util');
     } catch (e) {}
   }());
 

_parent.js

@@ -9,7 +9,7 @@ define(['./_baseGet', './_baseSlice'], function(baseGet, baseSlice) {
    * @returns {*} Returns the parent value.
    */
   function parent(object, path) {
-    return path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
+    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
   }
 
   return parent;

_safeGet.js

@@ -0,0 +1,24 @@
+define([], function() {
+
+  /**
+   * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {string} key The key of the property to get.
+   * @returns {*} Returns the property value.
+   */
+  function safeGet(object, key) {
+    if (key === 'constructor' && typeof object[key] === 'function') {
+      return;
+    }
+
+    if (key == '__proto__') {
+      return;
+    }
+
+    return object[key];
+  }
+
+  return safeGet;
+});

_setCacheHas.js

@@ -7,7 +7,7 @@ define([], function() {
    * @name has
    * @memberOf SetCache
    * @param {*} value The value to search for.
-   * @returns {number} Returns `true` if `value` is found, else `false`.
+   * @returns {boolean} Returns `true` if `value` is found, else `false`.
    */
   function setCacheHas(value) {
     return this.__data__.has(value);

_stringToPath.js

@@ -1,8 +1,7 @@
-define(['./_memoizeCapped', './toString'], function(memoizeCapped, toString) {
+define(['./_memoizeCapped'], function(memoizeCapped) {
 
   /** Used to match property names within property paths. */
-  var reLeadingDot = /^\./,
-      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
 
   /** Used to match backslashes in property paths. */
   var reEscapeChar = /\\(\\)?/g;
@@ -15,14 +14,12 @@ define(['./_memoizeCapped', './toString'], function(memoizeCapped, toString) {
    * @returns {Array} Returns the property path array.
    */
   var stringToPath = memoizeCapped(function(string) {
-    string = toString(string);
-
     var result = [];
-    if (reLeadingDot.test(string)) {
+    if (string.charCodeAt(0) === 46 /* . */) {
       result.push('');
     }
-    string.replace(rePropName, function(match, number, quote, string) {
-      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
+    string.replace(rePropName, function(match, number, quote, subString) {
+      result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
     });
     return result;
   });

_trimmedEndIndex.js

@@ -0,0 +1,22 @@
+define([], function() {
+
+  /** Used to match a single whitespace character. */
+  var reWhitespace = /\s/;
+
+  /**
+   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+   * character of `string`.
+   *
+   * @private
+   * @param {string} string The string to inspect.
+   * @returns {number} Returns the index of the last non-whitespace character.
+   */
+  function trimmedEndIndex(string) {
+    var index = string.length;
+
+    while (index-- && reWhitespace.test(string.charAt(index))) {}
+    return index;
+  }
+
+  return trimmedEndIndex;
+});

_unicodeSize.js

@@ -2,13 +2,15 @@ define([], function() {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
+      rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
       rsVarRange = '\\ufe0e\\ufe0f';
 
   /** Used to compose unicode capture groups. */
   var rsAstral = '[' + rsAstralRange + ']',
-      rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+      rsCombo = '[' + rsComboRange + ']',
       rsFitz = '\\ud83c[\\udffb-\\udfff]',
       rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
       rsNonAstral = '[^' + rsAstralRange + ']',

_unicodeToArray.js

@@ -2,13 +2,15 @@ define([], function() {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
+      rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
       rsVarRange = '\\ufe0e\\ufe0f';
 
   /** Used to compose unicode capture groups. */
   var rsAstral = '[' + rsAstralRange + ']',
-      rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+      rsCombo = '[' + rsComboRange + ']',
       rsFitz = '\\ud83c[\\udffb-\\udfff]',
       rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
       rsNonAstral = '[^' + rsAstralRange + ']',

_unicodeWords.js

@@ -2,8 +2,10 @@ define([], function() {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
+      rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
       rsDingbatRange = '\\u2700-\\u27bf',
       rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
       rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
@@ -17,7 +19,7 @@ define([], function() {
   /** Used to compose unicode capture groups. */
   var rsApos = "['\u2019]",
       rsBreak = '[' + rsBreakRange + ']',
-      rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+      rsCombo = '[' + rsComboRange + ']',
       rsDigits = '\\d+',
       rsDingbat = '[' + rsDingbatRange + ']',
       rsLower = '[' + rsLowerRange + ']',
@@ -38,8 +40,8 @@ define([], function() {
       reOptMod = rsModifier + '?',
       rsOptVar = '[' + rsVarRange + ']?',
       rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
-      rsOrdLower = '\\d*(?:(?:1st|2nd|3rd|(?![123])\\dth)\\b)',
-      rsOrdUpper = '\\d*(?:(?:1ST|2ND|3RD|(?![123])\\dTH)\\b)',
+      rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
+      rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
       rsSeq = rsOptVar + reOptMod + rsOptJoin,
       rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;
 

_updateWrapDetails.js

@@ -1,27 +1,27 @@
 define(['./_arrayEach', './_arrayIncludes'], function(arrayEach, arrayIncludes) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_FLAG = 8,
-      CURRY_RIGHT_FLAG = 16,
-      PARTIAL_FLAG = 32,
-      PARTIAL_RIGHT_FLAG = 64,
-      ARY_FLAG = 128,
-      REARG_FLAG = 256,
-      FLIP_FLAG = 512;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_CURRY_RIGHT_FLAG = 16,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_PARTIAL_RIGHT_FLAG = 64,
+      WRAP_ARY_FLAG = 128,
+      WRAP_REARG_FLAG = 256,
+      WRAP_FLIP_FLAG = 512;
 
   /** Used to associate wrap methods with their bit flags. */
   var wrapFlags = [
-    ['ary', ARY_FLAG],
-    ['bind', BIND_FLAG],
-    ['bindKey', BIND_KEY_FLAG],
-    ['curry', CURRY_FLAG],
-    ['curryRight', CURRY_RIGHT_FLAG],
-    ['flip', FLIP_FLAG],
-    ['partial', PARTIAL_FLAG],
-    ['partialRight', PARTIAL_RIGHT_FLAG],
-    ['rearg', REARG_FLAG]
+    ['ary', WRAP_ARY_FLAG],
+    ['bind', WRAP_BIND_FLAG],
+    ['bindKey', WRAP_BIND_KEY_FLAG],
+    ['curry', WRAP_CURRY_FLAG],
+    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
+    ['flip', WRAP_FLIP_FLAG],
+    ['partial', WRAP_PARTIAL_FLAG],
+    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
+    ['rearg', WRAP_REARG_FLAG]
   ];
 
   /**

ary.js

@@ -4,7 +4,7 @@ define(['./_createWrap'], function(createWrap) {
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var ARY_FLAG = 128;
+  var WRAP_ARY_FLAG = 128;
 
   /**
    * Creates a function that invokes `func`, with up to `n` arguments,
@@ -26,7 +26,7 @@ define(['./_createWrap'], function(createWrap) {
   function ary(func, n, guard) {
     n = guard ? undefined : n;
     n = (func && n == null) ? func.length : n;
-    return createWrap(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);
+    return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
   }
 
   return ary;

at.js

@@ -8,7 +8,7 @@ define(['./_baseAt', './_flatRest'], function(baseAt, flatRest) {
    * @since 1.0.0
    * @category Object
    * @param {Object} object The object to iterate over.
-   * @param {...(string|string[])} [paths] The property paths of elements to pick.
+   * @param {...(string|string[])} [paths] The property paths to pick.
    * @returns {Array} Returns the picked values.
    * @example
    *

bind.js

@@ -1,8 +1,8 @@
 define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], function(baseRest, createWrap, getHolder, replaceHolders) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      PARTIAL_FLAG = 32;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_PARTIAL_FLAG = 32;
 
   /**
    * Creates a function that invokes `func` with the `this` binding of `thisArg`
@@ -40,10 +40,10 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
    * // => 'hi fred!'
    */
   var bind = baseRest(function(func, thisArg, partials) {
-    var bitmask = BIND_FLAG;
+    var bitmask = WRAP_BIND_FLAG;
     if (partials.length) {
       var holders = replaceHolders(partials, getHolder(bind));
-      bitmask |= PARTIAL_FLAG;
+      bitmask |= WRAP_PARTIAL_FLAG;
     }
     return createWrap(func, bitmask, thisArg, partials, holders);
   });

bindKey.js

@@ -1,9 +1,9 @@
 define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], function(baseRest, createWrap, getHolder, replaceHolders) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      PARTIAL_FLAG = 32;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_PARTIAL_FLAG = 32;
 
   /**
    * Creates a function that invokes the method at `object[key]` with `partials`
@@ -51,10 +51,10 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
    * // => 'hiya fred!'
    */
   var bindKey = baseRest(function(object, key, partials) {
-    var bitmask = BIND_FLAG | BIND_KEY_FLAG;
+    var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
     if (partials.length) {
       var holders = replaceHolders(partials, getHolder(bindKey));
-      bitmask |= PARTIAL_FLAG;
+      bitmask |= WRAP_PARTIAL_FLAG;
     }
     return createWrap(key, bitmask, object, partials, holders);
   });

clone.js

@@ -1,5 +1,8 @@
 define(['./_baseClone'], function(baseClone) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_SYMBOLS_FLAG = 4;
+
   /**
    * Creates a shallow clone of `value`.
    *
@@ -27,7 +30,7 @@ define(['./_baseClone'], function(baseClone) {
    * // => true
    */
   function clone(value) {
-    return baseClone(value, false, true);
+    return baseClone(value, CLONE_SYMBOLS_FLAG);
   }
 
   return clone;

cloneDeep.js

@@ -1,5 +1,9 @@
 define(['./_baseClone'], function(baseClone) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_SYMBOLS_FLAG = 4;
+
   /**
    * This method is like `_.clone` except that it recursively clones `value`.
    *
@@ -19,7 +23,7 @@ define(['./_baseClone'], function(baseClone) {
    * // => false
    */
   function cloneDeep(value) {
-    return baseClone(value, true, true);
+    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
   }
 
   return cloneDeep;

cloneDeepWith.js

@@ -3,6 +3,10 @@ define(['./_baseClone'], function(baseClone) {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_SYMBOLS_FLAG = 4;
+
   /**
    * This method is like `_.cloneWith` except that it recursively clones `value`.
    *
@@ -33,7 +37,7 @@ define(['./_baseClone'], function(baseClone) {
    */
   function cloneDeepWith(value, customizer) {
     customizer = typeof customizer == 'function' ? customizer : undefined;
-    return baseClone(value, true, true, customizer);
+    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
   }
 
   return cloneDeepWith;

cloneWith.js

@@ -3,6 +3,9 @@ define(['./_baseClone'], function(baseClone) {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_SYMBOLS_FLAG = 4;
+
   /**
    * This method is like `_.clone` except that it accepts `customizer` which
    * is invoked to produce the cloned value. If `customizer` returns `undefined`,
@@ -36,7 +39,7 @@ define(['./_baseClone'], function(baseClone) {
    */
   function cloneWith(value, customizer) {
     customizer = typeof customizer == 'function' ? customizer : undefined;
-    return baseClone(value, false, true, customizer);
+    return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
   }
 
   return cloneWith;

conforms.js

@@ -1,5 +1,8 @@
 define(['./_baseClone', './_baseConforms'], function(baseClone, baseConforms) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a function that invokes the predicate properties of `source` with
    * the corresponding property values of a given object, returning `true` if
@@ -25,7 +28,7 @@ define(['./_baseClone', './_baseConforms'], function(baseClone, baseConforms) {
    * // => [{ 'a': 1, 'b': 2 }]
    */
   function conforms(source) {
-    return baseConforms(baseClone(source, true));
+    return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
   }
 
   return conforms;

curry.js

@@ -4,7 +4,7 @@ define(['./_createWrap'], function(createWrap) {
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var CURRY_FLAG = 8;
+  var WRAP_CURRY_FLAG = 8;
 
   /**
    * Creates a function that accepts arguments of `func` and either invokes
@@ -49,7 +49,7 @@ define(['./_createWrap'], function(createWrap) {
    */
   function curry(func, arity, guard) {
     arity = guard ? undefined : arity;
-    var result = createWrap(func, CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+    var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
     result.placeholder = curry.placeholder;
     return result;
   }

curryRight.js

@@ -4,7 +4,7 @@ define(['./_createWrap'], function(createWrap) {
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var CURRY_RIGHT_FLAG = 16;
+  var WRAP_CURRY_RIGHT_FLAG = 16;
 
   /**
    * This method is like `_.curry` except that arguments are applied to `func`
@@ -46,7 +46,7 @@ define(['./_createWrap'], function(createWrap) {
    */
   function curryRight(func, arity, guard) {
     arity = guard ? undefined : arity;
-    var result = createWrap(func, CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+    var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
     result.placeholder = curryRight.placeholder;
     return result;
   }

debounce.js

@@ -109,9 +109,11 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
     function remainingWait(time) {
       var timeSinceLastCall = time - lastCallTime,
           timeSinceLastInvoke = time - lastInvokeTime,
-          result = wait - timeSinceLastCall;
+          timeWaiting = wait - timeSinceLastCall;
 
-      return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+      return maxing
+        ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+        : timeWaiting;
     }
 
     function shouldInvoke(time) {
@@ -172,6 +174,7 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
         }
         if (maxing) {
           // Handle invocations in a tight loop.
+          clearTimeout(timerId);
           timerId = setTimeout(timerExpired, wait);
           return invokeFunc(lastCallTime);
         }

deburr.js

@@ -4,11 +4,13 @@ define(['./_deburrLetter', './toString'], function(deburrLetter, toString) {
   var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
 
   /** Used to compose unicode character classes. */
-  var rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0';
+  var rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
 
   /** Used to compose unicode capture groups. */
-  var rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']';
+  var rsCombo = '[' + rsComboRange + ']';
 
   /**
    * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

defaults.js

@@ -1,8 +1,14 @@
-define(['./_apply', './_assignInDefaults', './assignInWith', './_baseRest'], function(apply, assignInDefaults, assignInWith, baseRest) {
+define(['./_baseRest', './eq', './_isIterateeCall', './keysIn'], function(baseRest, eq, isIterateeCall, keysIn) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
   /**
    * Assigns own and inherited enumerable string keyed properties of source
    * objects to the destination object for all destination properties that
@@ -24,9 +30,35 @@ define(['./_apply', './_assignInDefaults', './assignInWith', './_baseRest'], fun
    * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
    * // => { 'a': 1, 'b': 2 }
    */
-  var defaults = baseRest(function(args) {
-    args.push(undefined, assignInDefaults);
-    return apply(assignInWith, undefined, args);
+  var defaults = baseRest(function(object, sources) {
+    object = Object(object);
+
+    var index = -1;
+    var length = sources.length;
+    var guard = length > 2 ? sources[2] : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      length = 1;
+    }
+
+    while (++index < length) {
+      var source = sources[index];
+      var props = keysIn(source);
+      var propsIndex = -1;
+      var propsLength = props.length;
+
+      while (++propsIndex < propsLength) {
+        var key = props[propsIndex];
+        var value = object[key];
+
+        if (value === undefined ||
+            (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+          object[key] = source[key];
+        }
+      }
+    }
+
+    return object;
   });
 
   return defaults;

defaultsDeep.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_baseRest', './_mergeDefaults', './mergeWith'], function(apply, baseRest, mergeDefaults, mergeWith) {
+define(['./_apply', './_baseRest', './_customDefaultsMerge', './mergeWith'], function(apply, baseRest, customDefaultsMerge, mergeWith) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -23,7 +23,7 @@ define(['./_apply', './_baseRest', './_mergeDefaults', './mergeWith'], function(
    * // => { 'a': { 'b': 2, 'c': 3 } }
    */
   var defaultsDeep = baseRest(function(args) {
-    args.push(undefined, mergeDefaults);
+    args.push(undefined, customDefaultsMerge);
     return apply(mergeWith, undefined, args);
   });
 

filter.js

@@ -36,6 +36,10 @@ define(['./_arrayFilter', './_baseFilter', './_baseIteratee', './isArray'], func
    * // The `_.property` iteratee shorthand.
    * _.filter(users, 'active');
    * // => objects for ['barney']
+   *
+   * // Combining several predicates using `_.overEvery` or `_.overSome`.
+   * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
+   * // => objects for ['fred', 'barney']
    */
   function filter(collection, predicate) {
     var func = isArray(collection) ? arrayFilter : baseFilter;

flip.js

@@ -1,7 +1,7 @@
 define(['./_createWrap'], function(createWrap) {
 
   /** Used to compose bitmasks for function metadata. */
-  var FLIP_FLAG = 512;
+  var WRAP_FLIP_FLAG = 512;
 
   /**
    * Creates a function that invokes `func` with arguments reversed.
@@ -22,7 +22,7 @@ define(['./_createWrap'], function(createWrap) {
    * // => ['d', 'c', 'b', 'a']
    */
   function flip(func) {
-    return createWrap(func, FLIP_FLAG);
+    return createWrap(func, WRAP_FLIP_FLAG);
   }
 
   return flip;

invert.js

@@ -1,5 +1,15 @@
 define(['./constant', './_createInverter', './identity'], function(constant, createInverter, identity) {
 
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
   /**
    * Creates an object composed of the inverted keys and values of `object`.
    * If `object` contains duplicate values, subsequent values overwrite
@@ -19,6 +29,11 @@ define(['./constant', './_createInverter', './identity'], function(constant, cre
    * // => { '1': 'c', '2': 'b' }
    */
   var invert = createInverter(function(result, value, key) {
+    if (value != null &&
+        typeof value.toString != 'function') {
+      value = nativeObjectToString.call(value);
+    }
+
     result[value] = key;
   }, constant(identity));
 

invertBy.js

@@ -6,6 +6,13 @@ define(['./_baseIteratee', './_createInverter'], function(baseIteratee, createIn
   /** Used to check objects for own properties. */
   var hasOwnProperty = objectProto.hasOwnProperty;
 
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
   /**
    * This method is like `_.invert` except that the inverted object is generated
    * from the results of running each element of `object` thru `iteratee`. The
@@ -33,6 +40,11 @@ define(['./_baseIteratee', './_createInverter'], function(baseIteratee, createIn
    * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
    */
   var invertBy = createInverter(function(result, value, key) {
+    if (value != null &&
+        typeof value.toString != 'function') {
+      value = nativeObjectToString.call(value);
+    }
+
     if (hasOwnProperty.call(result, value)) {
       result[value].push(key);
     } else {

invokeMap.js

@@ -1,7 +1,4 @@
-define(['./_apply', './_baseEach', './_baseInvoke', './_baseRest', './isArrayLike', './_isKey'], function(apply, baseEach, baseInvoke, baseRest, isArrayLike, isKey) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+define(['./_apply', './_baseEach', './_baseInvoke', './_baseRest', './isArrayLike'], function(apply, baseEach, baseInvoke, baseRest, isArrayLike) {
 
   /**
    * Invokes the method at `path` of each element in `collection`, returning
@@ -29,12 +26,10 @@ define(['./_apply', './_baseEach', './_baseInvoke', './_baseRest', './isArrayLik
   var invokeMap = baseRest(function(collection, path, args) {
     var index = -1,
         isFunc = typeof path == 'function',
-        isProp = isKey(path),
         result = isArrayLike(collection) ? Array(collection.length) : [];
 
     baseEach(collection, function(value) {
-      var func = isFunc ? path : ((isProp && value != null) ? value[path] : undefined);
-      result[++index] = func ? apply(func, value, args) : baseInvoke(value, path, args);
+      result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
     });
     return result;
   });

isEqual.js

@@ -8,7 +8,7 @@ define(['./_baseIsEqual'], function(baseIsEqual) {
    * date objects, error objects, maps, numbers, `Object` objects, regexes,
    * sets, strings, symbols, and typed arrays. `Object` objects are compared
    * by their own, not inherited, enumerable properties. Functions and DOM
-   * nodes are **not** supported.
+   * nodes are compared by strict equality, i.e. `===`.
    *
    * @static
    * @memberOf _

isEqualWith.js

@@ -38,7 +38,7 @@ define(['./_baseIsEqual'], function(baseIsEqual) {
   function isEqualWith(value, other, customizer) {
     customizer = typeof customizer == 'function' ? customizer : undefined;
     var result = customizer ? customizer(value, other) : undefined;
-    return result === undefined ? baseIsEqual(value, other, customizer) : !!result;
+    return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
   }
 
   return isEqualWith;

isNative.js

@@ -1,7 +1,7 @@
 define(['./_baseIsNative', './_isMaskable'], function(baseIsNative, isMaskable) {
 
   /** Error message constants. */
-  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://github.com/es-shims.';
+  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.';
 
   /**
    * Checks if `value` is a pristine native function.

iteratee.js

@@ -1,5 +1,8 @@
 define(['./_baseClone', './_baseIteratee'], function(baseClone, baseIteratee) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a function that invokes `func` with the arguments of the created
    * function. If `func` is a property name, the created function returns the
@@ -43,7 +46,7 @@ define(['./_baseClone', './_baseIteratee'], function(baseClone, baseIteratee) {
    * // => ['def']
    */
   function iteratee(func) {
-    return baseIteratee(typeof func == 'function' ? func : baseClone(func, true));
+    return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
   }
 
   return iteratee;

matches.js

@@ -1,5 +1,8 @@
 define(['./_baseClone', './_baseMatches'], function(baseClone, baseMatches) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a function that performs a partial deep comparison between a given
    * object and `source`, returning `true` if the given object has equivalent
@@ -12,6 +15,9 @@ define(['./_baseClone', './_baseMatches'], function(baseClone, baseMatches) {
    * values against any array or object value, respectively. See `_.isEqual`
    * for a list of supported value comparisons.
    *
+   * **Note:** Multiple values can be checked by combining several matchers
+   * using `_.overSome`
+   *
    * @static
    * @memberOf _
    * @since 3.0.0
@@ -27,9 +33,13 @@ define(['./_baseClone', './_baseMatches'], function(baseClone, baseMatches) {
    *
    * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
    * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
+   *
+   * // Checking for several possible values
+   * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
+   * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
    */
   function matches(source) {
-    return baseMatches(baseClone(source, true));
+    return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
   }
 
   return matches;

matchesProperty.js

@@ -1,5 +1,8 @@
 define(['./_baseClone', './_baseMatchesProperty'], function(baseClone, baseMatchesProperty) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a function that performs a partial deep comparison between the
    * value at `path` of a given object to `srcValue`, returning `true` if the
@@ -9,6 +12,9 @@ define(['./_baseClone', './_baseMatchesProperty'], function(baseClone, baseMatch
    * `srcValue` values against any array or object value, respectively. See
    * `_.isEqual` for a list of supported value comparisons.
    *
+   * **Note:** Multiple values can be checked by combining several matchers
+   * using `_.overSome`
+   *
    * @static
    * @memberOf _
    * @since 3.2.0
@@ -25,9 +31,13 @@ define(['./_baseClone', './_baseMatchesProperty'], function(baseClone, baseMatch
    *
    * _.find(objects, _.matchesProperty('a', 4));
    * // => { 'a': 4, 'b': 5, 'c': 6 }
+   *
+   * // Checking for several possible values
+   * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
+   * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
    */
   function matchesProperty(path, srcValue) {
-    return baseMatchesProperty(path, baseClone(srcValue, true));
+    return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
   }
 
   return matchesProperty;

omit.js

@@ -1,16 +1,22 @@
-define(['./_arrayMap', './_baseDifference', './_basePick', './_flatRest', './_getAllKeysIn', './_toKey'], function(arrayMap, baseDifference, basePick, flatRest, getAllKeysIn, toKey) {
+define(['./_arrayMap', './_baseClone', './_baseUnset', './_castPath', './_copyObject', './_customOmitClone', './_flatRest', './_getAllKeysIn'], function(arrayMap, baseClone, baseUnset, castPath, copyObject, customOmitClone, flatRest, getAllKeysIn) {
+
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_FLAT_FLAG = 2,
+      CLONE_SYMBOLS_FLAG = 4;
 
   /**
    * The opposite of `_.pick`; this method creates an object composed of the
-   * own and inherited enumerable string keyed properties of `object` that are
-   * not omitted.
+   * own and inherited enumerable property paths of `object` that are not omitted.
+   *
+   * **Note:** This method is considerably slower than `_.pick`.
    *
    * @static
    * @since 0.1.0
    * @memberOf _
    * @category Object
    * @param {Object} object The source object.
-   * @param {...(string|string[])} [props] The property identifiers to omit.
+   * @param {...(string|string[])} [paths] The property paths to omit.
    * @returns {Object} Returns the new object.
    * @example
    *
@@ -19,12 +25,26 @@ define(['./_arrayMap', './_baseDifference', './_basePick', './_flatRest', './_ge
    * _.omit(object, ['a', 'c']);
    * // => { 'b': '2' }
    */
-  var omit = flatRest(function(object, props) {
+  var omit = flatRest(function(object, paths) {
+    var result = {};
     if (object == null) {
-      return {};
+      return result;
     }
-    props = arrayMap(props, toKey);
-    return basePick(object, baseDifference(getAllKeysIn(object), props));
+    var isDeep = false;
+    paths = arrayMap(paths, function(path) {
+      path = castPath(path, object);
+      isDeep || (isDeep = path.length > 1);
+      return path;
+    });
+    copyObject(object, getAllKeysIn(object), result);
+    if (isDeep) {
+      result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+    }
+    var length = paths.length;
+    while (length--) {
+      baseUnset(result, paths[length]);
+    }
+    return result;
   });
 
   return omit;

overEvery.js

@@ -4,6 +4,10 @@ define(['./_arrayEvery', './_createOver'], function(arrayEvery, createOver) {
    * Creates a function that checks if **all** of the `predicates` return
    * truthy when invoked with the arguments it receives.
    *
+   * Following shorthands are possible for providing predicates.
+   * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
+   * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
+   *
    * @static
    * @memberOf _
    * @since 4.0.0

overSome.js

@@ -4,6 +4,10 @@ define(['./_arraySome', './_createOver'], function(arraySome, createOver) {
    * Creates a function that checks if **any** of the `predicates` return
    * truthy when invoked with the arguments it receives.
    *
+   * Following shorthands are possible for providing predicates.
+   * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
+   * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
+   *
    * @static
    * @memberOf _
    * @since 4.0.0
@@ -23,6 +27,9 @@ define(['./_arraySome', './_createOver'], function(arraySome, createOver) {
    *
    * func(NaN);
    * // => false
+   *
+   * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
+   * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
    */
   var overSome = createOver(arraySome);
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lodash-amd",
-  "version": "4.16.5",
+  "version": "4.17.21",
   "description": "Lodash exported as AMD modules.",
   "keywords": "amd, modules, stdlib, util",
   "homepage": "https://lodash.com/custom-builds",
@@ -8,11 +8,10 @@
   "repository": "lodash/lodash",
   "license": "MIT",
   "main": "main.js",
-  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "author": "John-David Dalton <john.david.dalton@gmail.com>",
   "contributors": [
-    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
-    "Blaine Bublitz <blaine.bublitz@gmail.com> (https://github.com/phated)",
-    "Mathias Bynens <mathias@qiwi.be> (https://mathiasbynens.be/)"
+    "John-David Dalton <john.david.dalton@gmail.com>",
+    "Mathias Bynens <mathias@qiwi.be>"
   ],
-  "scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" }
+  "scripts": { "test": "echo \"See https://travis-ci.org/lodash-archive/lodash-cli for testing details.\"" }
 }

parseInt.js

@@ -1,6 +1,6 @@
 define(['./_root', './toString'], function(root, toString) {
 
-  /** Used to match leading and trailing whitespace. */
+  /** Used to match leading whitespace. */
   var reTrimStart = /^\s+/;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */

partial.js

@@ -4,7 +4,7 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var PARTIAL_FLAG = 32;
+  var WRAP_PARTIAL_FLAG = 32;
 
   /**
    * Creates a function that invokes `func` with `partials` prepended to the
@@ -41,7 +41,7 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
    */
   var partial = baseRest(function(func, partials) {
     var holders = replaceHolders(partials, getHolder(partial));
-    return createWrap(func, PARTIAL_FLAG, undefined, partials, holders);
+    return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
   });
 
   // Assign default placeholders.

partialRight.js

@@ -4,7 +4,7 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var PARTIAL_RIGHT_FLAG = 64;
+  var WRAP_PARTIAL_RIGHT_FLAG = 64;
 
   /**
    * This method is like `_.partial` except that partially applied arguments
@@ -40,7 +40,7 @@ define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], fu
    */
   var partialRight = baseRest(function(func, partials) {
     var holders = replaceHolders(partials, getHolder(partialRight));
-    return createWrap(func, PARTIAL_RIGHT_FLAG, undefined, partials, holders);
+    return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
   });
 
   // Assign default placeholders.

pick.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_basePick', './_flatRest', './_toKey'], function(arrayMap, basePick, flatRest, toKey) {
+define(['./_basePick', './_flatRest'], function(basePick, flatRest) {
 
   /**
    * Creates an object composed of the picked `object` properties.
@@ -8,7 +8,7 @@ define(['./_arrayMap', './_basePick', './_flatRest', './_toKey'], function(array
    * @memberOf _
    * @category Object
    * @param {Object} object The source object.
-   * @param {...(string|string[])} [props] The property identifiers to pick.
+   * @param {...(string|string[])} [paths] The property paths to pick.
    * @returns {Object} Returns the new object.
    * @example
    *
@@ -17,8 +17,8 @@ define(['./_arrayMap', './_basePick', './_flatRest', './_toKey'], function(array
    * _.pick(object, ['a', 'c']);
    * // => { 'a': 1, 'c': 3 }
    */
-  var pick = flatRest(function(object, props) {
-    return object == null ? {} : basePick(object, arrayMap(props, toKey));
+  var pick = flatRest(function(object, paths) {
+    return object == null ? {} : basePick(object, paths);
   });
 
   return pick;

pickBy.js

@@ -1,4 +1,4 @@
-define(['./_baseIteratee', './_basePickBy', './_getAllKeysIn'], function(baseIteratee, basePickBy, getAllKeysIn) {
+define(['./_arrayMap', './_baseIteratee', './_basePickBy', './_getAllKeysIn'], function(arrayMap, baseIteratee, basePickBy, getAllKeysIn) {
 
   /**
    * Creates an object composed of the `object` properties `predicate` returns
@@ -19,7 +19,16 @@ define(['./_baseIteratee', './_basePickBy', './_getAllKeysIn'], function(baseIte
    * // => { 'a': 1, 'c': 3 }
    */
   function pickBy(object, predicate) {
-    return object == null ? {} : basePickBy(object, getAllKeysIn(object), baseIteratee(predicate));
+    if (object == null) {
+      return {};
+    }
+    var props = arrayMap(getAllKeysIn(object), function(prop) {
+      return [prop];
+    });
+    predicate = baseIteratee(predicate);
+    return basePickBy(object, props, function(value, path) {
+      return predicate(value, path[0]);
+    });
   }
 
   return pickBy;

rearg.js

@@ -4,7 +4,7 @@ define(['./_createWrap', './_flatRest'], function(createWrap, flatRest) {
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var REARG_FLAG = 256;
+  var WRAP_REARG_FLAG = 256;
 
   /**
    * Creates a function that invokes `func` with arguments arranged according
@@ -29,7 +29,7 @@ define(['./_createWrap', './_flatRest'], function(createWrap, flatRest) {
    * // => ['a', 'b', 'c']
    */
   var rearg = flatRest(function(func, indexes) {
-    return createWrap(func, REARG_FLAG, undefined, undefined, undefined, indexes);
+    return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
   });
 
   return rearg;

result.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './isFunction', './_isKey', './_toKey'], function(castPath, isFunction, isKey, toKey) {
+define(['./_castPath', './isFunction', './_toKey'], function(castPath, isFunction, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -33,15 +33,15 @@ define(['./_castPath', './isFunction', './_isKey', './_toKey'], function(castPat
    * // => 'default'
    */
   function result(object, path, defaultValue) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
     var index = -1,
         length = path.length;
 
     // Ensure the loop is entered when path is empty.
     if (!length) {
-      object = undefined;
       length = 1;
+      object = undefined;
     }
     while (++index < length) {
       var value = object == null ? undefined : object[toKey(path[index])];