Bump to v4.6.1.

README.md

@@ -1,4 +1,4 @@
-# lodash-es v4.3.0
+# lodash-es v4.6.1
 
 The [lodash](https://lodash.com/) library exported as [ES](http://www.ecma-international.org/ecma-262/6.0/) modules.
 
@@ -7,4 +7,4 @@ Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
 $ lodash modularize exports=es -o ./
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.3.0-es) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.6.1-es) for more details.

_Hash.js

@@ -7,6 +7,7 @@ var objectProto = Object.prototype;
  * Creates an hash object.
  *
  * @private
+ * @constructor
  * @returns {Object} Returns the new hash object.
  */
 function Hash() {}

_LazyWrapper.js

@@ -8,6 +8,7 @@ var MAX_ARRAY_LENGTH = 4294967295;
  * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
  *
  * @private
+ * @constructor
  * @param {*} value The value to wrap.
  */
 function LazyWrapper(value) {

_MapCache.js

@@ -8,6 +8,7 @@ import mapSet from './_mapSet';
  * Creates a map cache object to store key-value pairs.
  *
  * @private
+ * @constructor
  * @param {Array} [values] The values to cache.
  */
 function MapCache(values) {

_SetCache.js

@@ -6,6 +6,7 @@ import cachePush from './_cachePush';
  * Creates a set cache object to store unique values.
  *
  * @private
+ * @constructor
  * @param {Array} [values] The values to cache.
  */
 function SetCache(values) {

_Stack.js

@@ -8,6 +8,7 @@ import stackSet from './_stackSet';
  * Creates a stack cache object to store key-value pairs.
  *
  * @private
+ * @constructor
  * @param {Array} [values] The values to cache.
  */
 function Stack(values) {

_addMapEntry.js

@@ -7,6 +7,7 @@
  * @returns {Object} Returns `map`.
  */
 function addMapEntry(map, pair) {
+  // Don't return `Map#set` because it doesn't return the map instance in IE 11.
   map.set(pair[0], pair[1]);
   return map;
 }

_arrayFilter.js

@@ -10,13 +10,13 @@
 function arrayFilter(array, predicate) {
   var index = -1,
       length = array.length,
-      resIndex = -1,
+      resIndex = 0,
       result = [];
 
   while (++index < length) {
     var value = array[index];
     if (predicate(value, index, array)) {
-      result[++resIndex] = value;
+      result[resIndex++] = value;
     }
   }
   return result;

_arrayIncludesWith.js

@@ -1,6 +1,5 @@
 /**
- * A specialized version of `_.includesWith` for arrays without support for
+ * This function is like `arrayIncludes` except that it accepts a comparator.
- * specifying an index to search from.
  *
  * @private
  * @param {Array} array The array to search.

_assignMergeValue.js

@@ -1,7 +1,8 @@
 import eq from './eq';
 
 /**
- * This function is like `assignValue` except that it doesn't assign `undefined` values.
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
  *
  * @private
  * @param {Object} object The object to modify.

_assignValue.js

@@ -18,8 +18,7 @@ var hasOwnProperty = objectProto.hasOwnProperty;
  */
 function assignValue(object, key, value) {
   var objValue = object[key];
-  if ((!eq(objValue, value) ||
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
-        (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) ||
       (value === undefined && !(key in object))) {
     object[key] = value;
   }

_baseCastArrayLikeObject.js

@@ -0,0 +1,14 @@
+import isArrayLikeObject from './isArrayLikeObject';
+
+/**
+ * Casts `value` to an empty array if it's not an array like object.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the array-like object.
+ */
+function baseCastArrayLikeObject(value) {
+  return isArrayLikeObject(value) ? value : [];
+}
+
+export default baseCastArrayLikeObject;

_baseCastFunction.js

@@ -0,0 +1,14 @@
+import identity from './identity';
+
+/**
+ * Casts `value` to `identity` if it's not a function.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the array-like object.
+ */
+function baseCastFunction(value) {
+  return typeof value == 'function' ? value : identity;
+}
+
+export default baseCastFunction;

_baseCastPath.js

@@ -0,0 +1,15 @@
+import isArray from './isArray';
+import stringToPath from './_stringToPath';
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast property path array.
+ */
+function baseCastPath(value) {
+  return isArray(value) ? value : stringToPath(value);
+}
+
+export default baseCastPath;

_baseClone.js

@@ -66,13 +66,14 @@ cloneableTags[weakMapTag] = false;
  * @private
  * @param {*} value The value to clone.
  * @param {boolean} [isDeep] Specify a deep clone.
+ * @param {boolean} [isFull] Specify a clone including 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, customizer, key, object, stack) {
+function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
   var result;
   if (customizer) {
     result = object ? customizer(value, key, object, stack) : customizer(value);
@@ -102,12 +103,14 @@ function baseClone(value, isDeep, customizer, key, object, stack) {
       }
       result = initCloneObject(isFunc ? {} : value);
       if (!isDeep) {
-        return copySymbols(value, baseAssign(result, value));
+        result = baseAssign(result, value);
+        return isFull ? copySymbols(value, result) : result;
       }
     } else {
-      return cloneableTags[tag]
+      if (!cloneableTags[tag]) {
-        ? initCloneByTag(value, tag, isDeep)
+        return object ? value : {};
-        : (object ? value : {});
+      }
+      result = initCloneByTag(value, tag, isDeep);
     }
   }
   // Check for circular references and return its corresponding clone.
@@ -120,9 +123,9 @@ function baseClone(value, isDeep, customizer, key, object, stack) {
 
   // Recursively populate clone (susceptible to call stack limits).
   (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
-    assignValue(result, key, baseClone(subValue, isDeep, customizer, key, value, stack));
+    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
   });
-  return isArr ? result : copySymbols(value, result);
+  return (isFull && !isArr) ? copySymbols(value, result) : result;
 }
 
 export default baseClone;

_baseCreate.js

@@ -1,5 +1,8 @@
 import isObject from './isObject';
 
+/** Built-in value references. */
+var objectCreate = Object.create;
+
 /**
  * The base implementation of `_.create` without support for assigning
  * properties to the created object.
@@ -8,16 +11,8 @@ import isObject from './isObject';
  * @param {Object} prototype The object to inherit from.
  * @returns {Object} Returns the new object.
  */
-var baseCreate = (function() {
+function baseCreate(proto) {
-  function object() {}
+  return isObject(proto) ? objectCreate(proto) : {};
-  return function(prototype) {
+}
-    if (isObject(prototype)) {
-      object.prototype = prototype;
-      var result = new object;
-      object.prototype = undefined;
-    }
-    return result || {};
-  };
-}());
 
 export default baseCreate;

_baseFlatten.js

@@ -8,12 +8,12 @@ import isArrayLikeObject from './isArrayLikeObject';
  *
  * @private
  * @param {Array} array The array to flatten.
- * @param {boolean} [isDeep] Specify a deep flatten.
+ * @param {number} depth The maximum recursion depth.
  * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
  * @param {Array} [result=[]] The initial result value.
  * @returns {Array} Returns the new flattened array.
  */
-function baseFlatten(array, isDeep, isStrict, result) {
+function baseFlatten(array, depth, isStrict, result) {
   result || (result = []);
 
   var index = -1,
@@ -21,11 +21,11 @@ function baseFlatten(array, isDeep, isStrict, result) {
 
   while (++index < length) {
     var value = array[index];
-    if (isArrayLikeObject(value) &&
+    if (depth > 0 && isArrayLikeObject(value) &&
         (isStrict || isArray(value) || isArguments(value))) {
-      if (isDeep) {
+      if (depth > 1) {
         // Recursively flatten arrays (susceptible to call stack limits).
-        baseFlatten(value, isDeep, isStrict, result);
+        baseFlatten(value, depth - 1, isStrict, result);
       } else {
         arrayPush(result, value);
       }

_baseGet.js

@@ -1,4 +1,4 @@
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import isKey from './_isKey';
 
 /**
@@ -10,7 +10,7 @@ import isKey from './_isKey';
  * @returns {*} Returns the resolved value.
  */
 function baseGet(object, path) {
-  path = isKey(path, object) ? [path + ''] : baseToPath(path);
+  path = isKey(path, object) ? [path + ''] : baseCastPath(path);
 
   var index = 0,
       length = path.length;

_baseIndexOfWith.js

@@ -0,0 +1,23 @@
+/**
+ * This function is like `baseIndexOf` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOfWith(array, value, fromIndex, comparator) {
+  var index = fromIndex - 1,
+      length = array.length;
+
+  while (++index < length) {
+    if (comparator(array[index], value)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+export default baseIndexOfWith;

_baseIntersection.js

@@ -5,6 +5,9 @@ import arrayMap from './_arrayMap';
 import baseUnary from './_baseUnary';
 import cacheHas from './_cacheHas';
 
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMin = Math.min;
+
 /**
  * The base implementation of methods like `_.intersection`, without support
  * for iteratee shorthands, that accepts an array of arrays to inspect.
@@ -17,9 +20,11 @@ import cacheHas from './_cacheHas';
  */
 function baseIntersection(arrays, iteratee, comparator) {
   var includes = comparator ? arrayIncludesWith : arrayIncludes,
+      length = arrays[0].length,
       othLength = arrays.length,
       othIndex = othLength,
       caches = Array(othLength),
+      maxLength = Infinity,
       result = [];
 
   while (othIndex--) {
@@ -27,26 +32,32 @@ function baseIntersection(arrays, iteratee, comparator) {
     if (othIndex && iteratee) {
       array = arrayMap(array, baseUnary(iteratee));
     }
-    caches[othIndex] = !comparator && (iteratee || array.length >= 120)
+    maxLength = nativeMin(array.length, maxLength);
+    caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
       ? new SetCache(othIndex && array)
       : undefined;
   }
   array = arrays[0];
 
   var index = -1,
-      length = array.length,
       seen = caches[0];
 
   outer:
-  while (++index < length) {
+  while (++index < length && result.length < maxLength) {
     var value = array[index],
         computed = iteratee ? iteratee(value) : value;
 
-    if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
+    if (!(seen
-      var othIndex = othLength;
+          ? cacheHas(seen, computed)
+          : includes(result, computed, comparator)
+        )) {
+      othIndex = othLength;
       while (--othIndex) {
         var cache = caches[othIndex];
-        if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
+        if (!(cache
+              ? cacheHas(cache, computed)
+              : includes(arrays[othIndex], computed, comparator))
+            ) {
           continue outer;
         }
       }

_baseInvoke.js

@@ -1,5 +1,5 @@
 import apply from './_apply';
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import isKey from './_isKey';
 import last from './last';
 import parent from './_parent';
@@ -16,7 +16,7 @@ import parent from './_parent';
  */
 function baseInvoke(object, path, args) {
   if (!isKey(path, object)) {
-    path = baseToPath(path);
+    path = baseCastPath(path);
     object = parent(object, path);
     path = last(path);
   }

_baseIsEqualDeep.js

@@ -43,33 +43,28 @@ function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
 
   if (!objIsArr) {
     objTag = getTag(object);
-    if (objTag == argsTag) {
+    objTag = objTag == argsTag ? objectTag : objTag;
-      objTag = objectTag;
-    } else if (objTag != objectTag) {
-      objIsArr = isTypedArray(object);
-    }
   }
   if (!othIsArr) {
     othTag = getTag(other);
-    if (othTag == argsTag) {
+    othTag = othTag == argsTag ? objectTag : othTag;
-      othTag = objectTag;
-    } else if (othTag != objectTag) {
-      othIsArr = isTypedArray(other);
-    }
   }
   var objIsObj = objTag == objectTag && !isHostObject(object),
       othIsObj = othTag == objectTag && !isHostObject(other),
       isSameTag = objTag == othTag;
 
-  if (isSameTag && !(objIsArr || objIsObj)) {
+  if (isSameTag && !objIsObj) {
-    return equalByTag(object, other, objTag, equalFunc, customizer, bitmask);
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
+      : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
   }
-  var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+  if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
-  if (!isPartial) {
     var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
         othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
 
     if (objIsWrapped || othIsWrapped) {
+      stack || (stack = new Stack);
       return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, bitmask, stack);
     }
   }
@@ -77,7 +72,7 @@ function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
     return false;
   }
   stack || (stack = new Stack);
-  return (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, bitmask, stack);
+  return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
 }
 
 export default baseIsEqualDeep;

_baseKeys.js

@@ -6,7 +6,6 @@ var nativeKeys = Object.keys;
  * property of prototypes or treat sparse arrays as dense.
  *
  * @private
- * @type Function
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of property names.
  */

_baseMerge.js

@@ -21,7 +21,10 @@ function baseMerge(object, source, srcIndex, customizer, stack) {
   if (object === source) {
     return;
   }
-  var props = (isArray(source) || isTypedArray(source)) ? undefined : keysIn(source);
+  var props = (isArray(source) || isTypedArray(source))
+    ? undefined
+    : keysIn(source);
+
   arrayEach(props || source, function(srcValue, key) {
     if (props) {
       key = srcValue;
@@ -32,7 +35,10 @@ function baseMerge(object, source, srcIndex, customizer, stack) {
       baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
     }
     else {
-      var newValue = customizer ? customizer(object[key], srcValue, (key + ''), object, source, stack) : undefined;
+      var newValue = customizer
+        ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+        : undefined;
+
       if (newValue === undefined) {
         newValue = srcValue;
       }

_baseMergeDeep.js

@@ -33,21 +33,24 @@ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, sta
     assignMergeValue(object, key, stacked);
     return;
   }
-  var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined,
+  var newValue = customizer
-      isCommon = newValue === undefined;
+    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+    : undefined;
+
+  var isCommon = newValue === undefined;
 
   if (isCommon) {
     newValue = srcValue;
     if (isArray(srcValue) || isTypedArray(srcValue)) {
       if (isArray(objValue)) {
-        newValue = srcIndex ? copyArray(objValue) : objValue;
+        newValue = objValue;
       }
       else if (isArrayLikeObject(objValue)) {
         newValue = copyArray(objValue);
       }
       else {
         isCommon = false;
-        newValue = baseClone(srcValue);
+        newValue = baseClone(srcValue, !customizer);
       }
     }
     else if (isPlainObject(srcValue) || isArguments(srcValue)) {
@@ -56,10 +59,10 @@ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, sta
       }
       else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
         isCommon = false;
-        newValue = baseClone(srcValue);
+        newValue = baseClone(srcValue, !customizer);
       }
       else {
-        newValue = srcIndex ? baseClone(objValue) : objValue;
+        newValue = objValue;
       }
     }
     else {
@@ -72,6 +75,7 @@ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, sta
     // Recursively merge objects and arrays (susceptible to call stack limits).
     mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
   }
+  stack['delete'](srcValue);
   assignMergeValue(object, key, newValue);
 }
 

_baseOrderBy.js

@@ -14,12 +14,8 @@ import compareMultiple from './_compareMultiple';
  * @returns {Array} Returns the new sorted array.
  */
 function baseOrderBy(collection, iteratees, orders) {
-  var index = -1,
+  var index = -1;
-      toIteratee = baseIteratee;
+  iteratees = arrayMap(iteratees.length ? iteratees : Array(1), baseIteratee);
-
-  iteratees = arrayMap(iteratees.length ? iteratees : Array(1), function(iteratee) {
-    return toIteratee(iteratee);
-  });
 
   var result = baseMap(collection, function(value, key, collection) {
     var criteria = arrayMap(iteratees, function(iteratee) {

_basePullAll.js

@@ -1,15 +1,47 @@
-import basePullAllBy from './_basePullAllBy';
+import arrayMap from './_arrayMap';
+import baseIndexOf from './_baseIndexOf';
+import baseIndexOfWith from './_baseIndexOfWith';
+import baseUnary from './_baseUnary';
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
 
 /**
- * The base implementation of `_.pullAll`.
+ * The base implementation of `_.pullAllBy` without support for iteratee
+ * shorthands.
  *
  * @private
  * @param {Array} array The array to modify.
  * @param {Array} values The values to remove.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
  * @returns {Array} Returns `array`.
  */
-function basePullAll(array, values) {
+function basePullAll(array, values, iteratee, comparator) {
-  return basePullAllBy(array, values);
+  var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
+      index = -1,
+      length = values.length,
+      seen = array;
+
+  if (iteratee) {
+    seen = arrayMap(array, baseUnary(iteratee));
+  }
+  while (++index < length) {
+    var fromIndex = 0,
+        value = values[index],
+        computed = iteratee ? iteratee(value) : value;
+
+    while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
+      if (seen !== array) {
+        splice.call(seen, fromIndex, 1);
+      }
+      splice.call(array, fromIndex, 1);
+    }
+  }
+  return array;
 }
 
 export default basePullAll;

_basePullAllBy.js

@@ -1,43 +0,0 @@
-import arrayMap from './_arrayMap';
-import baseIndexOf from './_baseIndexOf';
-
-/** Used for built-in method references. */
-var arrayProto = Array.prototype;
-
-/** Built-in value references. */
-var splice = arrayProto.splice;
-
-/**
- * The base implementation of `_.pullAllBy` without support for iteratee
- * shorthands.
- *
- * @private
- * @param {Array} array The array to modify.
- * @param {Array} values The values to remove.
- * @param {Function} [iteratee] The iteratee invoked per element.
- * @returns {Array} Returns `array`.
- */
-function basePullAllBy(array, values, iteratee) {
-  var index = -1,
-      length = values.length,
-      seen = array;
-
-  if (iteratee) {
-    seen = arrayMap(array, function(value) { return iteratee(value); });
-  }
-  while (++index < length) {
-    var fromIndex = 0,
-        value = values[index],
-        computed = iteratee ? iteratee(value) : value;
-
-    while ((fromIndex = baseIndexOf(seen, computed, fromIndex)) > -1) {
-      if (seen !== array) {
-        splice.call(seen, fromIndex, 1);
-      }
-      splice.call(array, fromIndex, 1);
-    }
-  }
-  return array;
-}
-
-export default basePullAllBy;

_basePullAt.js

@@ -1,4 +1,4 @@
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import isIndex from './_isIndex';
 import isKey from './_isKey';
 import last from './last';
@@ -31,7 +31,7 @@ function basePullAt(array, indexes) {
         splice.call(array, index, 1);
       }
       else if (!isKey(index, array)) {
-        var path = baseToPath(index),
+        var path = baseCastPath(index),
             object = parent(array, path);
 
         if (object != null) {

_baseSet.js

@@ -1,5 +1,5 @@
 import assignValue from './_assignValue';
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import isIndex from './_isIndex';
 import isKey from './_isKey';
 import isObject from './isObject';
@@ -15,7 +15,7 @@ import isObject from './isObject';
  * @returns {Object} Returns `object`.
  */
 function baseSet(object, path, value, customizer) {
-  path = isKey(path, object) ? [path + ''] : baseToPath(path);
+  path = isKey(path, object) ? [path + ''] : baseCastPath(path);
 
   var index = -1,
       length = path.length,
@@ -30,7 +30,9 @@ function baseSet(object, path, value, customizer) {
         var objValue = nested[key];
         newValue = customizer ? customizer(objValue, key, nested) : undefined;
         if (newValue === undefined) {
-          newValue = objValue == null ? (isIndex(path[index + 1]) ? [] : {}) : objValue;
+          newValue = objValue == null
+            ? (isIndex(path[index + 1]) ? [] : {})
+            : objValue;
         }
       }
       assignValue(nested, key, newValue);

_baseSortBy.js

@@ -1,7 +1,7 @@
 /**
- * The base implementation of `_.sortBy` which uses `comparer` to define
+ * The base implementation of `_.sortBy` which uses `comparer` to define the
- * the sort order of `array` and replaces criteria objects with their
+ * sort order of `array` and replaces criteria objects with their corresponding
- * corresponding values.
+ * values.
  *
  * @private
  * @param {Array} array The array to sort.

_baseSortedUniqBy.js

@@ -15,7 +15,7 @@ function baseSortedUniqBy(array, iteratee) {
       value = array[0],
       computed = iteratee ? iteratee(value) : value,
       seen = computed,
-      resIndex = 0,
+      resIndex = 1,
       result = [value];
 
   while (++index < length) {
@@ -24,7 +24,7 @@ function baseSortedUniqBy(array, iteratee) {
 
     if (!eq(computed, seen)) {
       seen = computed;
-      result[++resIndex] = value;
+      result[resIndex++] = value;
     }
   }
   return result;

_baseToPath.js

@@ -1,16 +0,0 @@
-import isArray from './isArray';
-import stringToPath from './_stringToPath';
-
-/**
- * The base implementation of `_.toPath` which only converts `value` to a
- * path if it's not one.
- *
- * @private
- * @param {*} value The value to process.
- * @returns {Array} Returns the property path array.
- */
-function baseToPath(value) {
-  return isArray(value) ? value : stringToPath(value);
-}
-
-export default baseToPath;

_baseUnset.js

@@ -1,4 +1,4 @@
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import has from './has';
 import isKey from './_isKey';
 import last from './last';
@@ -13,7 +13,7 @@ import parent from './_parent';
  * @returns {boolean} Returns `true` if the property is deleted, else `false`.
  */
 function baseUnset(object, path) {
-  path = isKey(path, object) ? [path + ''] : baseToPath(path);
+  path = isKey(path, object) ? [path + ''] : baseCastPath(path);
   object = parent(object, path);
   var key = last(path);
   return (object != null && has(object, key)) ? delete object[key] : true;

_baseUpdate.js

@@ -0,0 +1,18 @@
+import baseGet from './_baseGet';
+import baseSet from './_baseSet';
+
+/**
+ * The base implementation of `_.update`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to update.
+ * @param {Function} updater The function to produce the updated value.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+function baseUpdate(object, path, updater, customizer) {
+  return baseSet(object, path, updater(baseGet(object, path)), customizer);
+}
+
+export default baseUpdate;

_cloneArrayBuffer.js

@@ -8,11 +8,8 @@ import Uint8Array from './_Uint8Array';
  * @returns {ArrayBuffer} Returns the cloned array buffer.
  */
 function cloneArrayBuffer(arrayBuffer) {
-  var Ctor = arrayBuffer.constructor,
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
-      result = new Ctor(arrayBuffer.byteLength),
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
-      view = new Uint8Array(result);
-
-  view.set(new Uint8Array(arrayBuffer));
   return result;
 }
 

_cloneBuffer.js

@@ -10,9 +10,7 @@ function cloneBuffer(buffer, isDeep) {
   if (isDeep) {
     return buffer.slice();
   }
-  var Ctor = buffer.constructor,
+  var result = new buffer.constructor(buffer.length);
-      result = new Ctor(buffer.length);
-
   buffer.copy(result);
   return result;
 }

_cloneMap.js

@@ -10,8 +10,7 @@ import mapToArray from './_mapToArray';
  * @returns {Object} Returns the cloned map.
  */
 function cloneMap(map) {
-  var Ctor = map.constructor;
+  return arrayReduce(mapToArray(map), addMapEntry, new map.constructor);
-  return arrayReduce(mapToArray(map), addMapEntry, new Ctor);
 }
 
 export default cloneMap;

_cloneRegExp.js

@@ -9,9 +9,7 @@ var reFlags = /\w*$/;
  * @returns {Object} Returns the cloned regexp.
  */
 function cloneRegExp(regexp) {
-  var Ctor = regexp.constructor,
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
-      result = new Ctor(regexp.source, reFlags.exec(regexp));
-
   result.lastIndex = regexp.lastIndex;
   return result;
 }

_cloneSet.js

@@ -10,8 +10,7 @@ import setToArray from './_setToArray';
  * @returns {Object} Returns the cloned set.
  */
 function cloneSet(set) {
-  var Ctor = set.constructor;
+  return arrayReduce(setToArray(set), addSetEntry, new set.constructor);
-  return arrayReduce(setToArray(set), addSetEntry, new Ctor);
 }
 
 export default cloneSet;

_cloneSymbol.js

@@ -2,7 +2,7 @@ import Symbol from './_Symbol';
 
 /** Used to convert symbols to primitives and strings. */
 var symbolProto = Symbol ? Symbol.prototype : undefined,
-    symbolValueOf = Symbol ? symbolProto.valueOf : undefined;
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
 
 /**
  * Creates a clone of the `symbol` object.
@@ -12,7 +12,7 @@ var symbolProto = Symbol ? Symbol.prototype : undefined,
  * @returns {Object} Returns the cloned symbol object.
  */
 function cloneSymbol(symbol) {
-  return Symbol ? Object(symbolValueOf.call(symbol)) : {};
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
 }
 
 export default cloneSymbol;

_cloneTypedArray.js

@@ -9,10 +9,8 @@ import cloneArrayBuffer from './_cloneArrayBuffer';
  * @returns {Object} Returns the cloned typed array.
  */
 function cloneTypedArray(typedArray, isDeep) {
-  var buffer = typedArray.buffer,
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
-      Ctor = typedArray.constructor;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
-
-  return new Ctor(isDeep ? cloneArrayBuffer(buffer) : buffer, typedArray.byteOffset, typedArray.length);
 }
 
 export default cloneTypedArray;

_composeArgs.js

@@ -9,23 +9,28 @@ var nativeMax = Math.max;
  * @param {Array|Object} args The provided arguments.
  * @param {Array} partials The arguments to prepend to those provided.
  * @param {Array} holders The `partials` placeholder indexes.
+ * @params {boolean} [isCurried] Specify composing for a curried function.
  * @returns {Array} Returns the new array of composed arguments.
  */
-function composeArgs(args, partials, holders) {
+function composeArgs(args, partials, holders, isCurried) {
-  var holdersLength = holders.length,
+  var argsIndex = -1,
-      argsIndex = -1,
+      argsLength = args.length,
-      argsLength = nativeMax(args.length - holdersLength, 0),
+      holdersLength = holders.length,
       leftIndex = -1,
       leftLength = partials.length,
-      result = Array(leftLength + argsLength);
+      rangeLength = nativeMax(argsLength - holdersLength, 0),
+      result = Array(leftLength + rangeLength),
+      isUncurried = !isCurried;
 
   while (++leftIndex < leftLength) {
     result[leftIndex] = partials[leftIndex];
   }
   while (++argsIndex < holdersLength) {
-    result[holders[argsIndex]] = args[argsIndex];
+    if (isUncurried || argsIndex < argsLength) {
+      result[holders[argsIndex]] = args[argsIndex];
+    }
   }
-  while (argsLength--) {
+  while (rangeLength--) {
     result[leftIndex++] = args[argsIndex++];
   }
   return result;

_composeArgsRight.js

@@ -9,18 +9,21 @@ var nativeMax = Math.max;
  * @param {Array|Object} args The provided arguments.
  * @param {Array} partials The arguments to append to those provided.
  * @param {Array} holders The `partials` placeholder indexes.
+ * @params {boolean} [isCurried] Specify composing for a curried function.
  * @returns {Array} Returns the new array of composed arguments.
  */
-function composeArgsRight(args, partials, holders) {
+function composeArgsRight(args, partials, holders, isCurried) {
-  var holdersIndex = -1,
+  var argsIndex = -1,
+      argsLength = args.length,
+      holdersIndex = -1,
       holdersLength = holders.length,
-      argsIndex = -1,
-      argsLength = nativeMax(args.length - holdersLength, 0),
       rightIndex = -1,
       rightLength = partials.length,
-      result = Array(argsLength + rightLength);
+      rangeLength = nativeMax(argsLength - holdersLength, 0),
+      result = Array(rangeLength + rightLength),
+      isUncurried = !isCurried;
 
-  while (++argsIndex < argsLength) {
+  while (++argsIndex < rangeLength) {
     result[argsIndex] = args[argsIndex];
   }
   var offset = argsIndex;
@@ -28,7 +31,9 @@ function composeArgsRight(args, partials, holders) {
     result[offset + rightIndex] = partials[rightIndex];
   }
   while (++holdersIndex < holdersLength) {
-    result[offset + holders[holdersIndex]] = args[argsIndex++];
+    if (isUncurried || argsIndex < argsLength) {
+      result[offset + holders[holdersIndex]] = args[argsIndex++];
+    }
   }
   return result;
 }

_copyObjectWith.js

@@ -18,8 +18,11 @@ function copyObjectWith(source, props, object, customizer) {
       length = props.length;
 
   while (++index < length) {
-    var key = props[index],
+    var key = props[index];
-        newValue = customizer ? customizer(object[key], source[key], key, object, source) : source[key];
+
+    var newValue = customizer
+      ? customizer(object[key], source[key], key, object, source)
+      : source[key];
 
     assignValue(object, key, newValue);
   }

_countHolders.js

@@ -0,0 +1,21 @@
+/**
+ * Gets the number of `placeholder` occurrences in `array`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} placeholder The placeholder to search for.
+ * @returns {number} Returns the placeholder count.
+ */
+function countHolders(array, placeholder) {
+  var length = array.length,
+      result = 0;
+
+  while (length--) {
+    if (array[length] === placeholder) {
+      result++;
+    }
+  }
+  return result;
+}
+
+export default countHolders;

_createAssigner.js

@@ -15,7 +15,10 @@ function createAssigner(assigner) {
         customizer = length > 1 ? sources[length - 1] : undefined,
         guard = length > 2 ? sources[2] : undefined;
 
-    customizer = typeof customizer == 'function' ? (length--, customizer) : undefined;
+    customizer = typeof customizer == 'function'
+      ? (length--, customizer)
+      : undefined;
+
     if (guard && isIterateeCall(sources[0], sources[1], guard)) {
       customizer = length < 3 ? undefined : customizer;
       length = 1;

_createCaseFirst.js

@@ -24,8 +24,11 @@ function createCaseFirst(methodName) {
   return function(string) {
     string = toString(string);
 
-    var strSymbols = reHasComplexSymbol.test(string) ? stringToArray(string) : undefined,
+    var strSymbols = reHasComplexSymbol.test(string)
-        chr = strSymbols ? strSymbols[0] : string.charAt(0),
+      ? stringToArray(string)
+      : undefined;
+
+    var chr = strSymbols ? strSymbols[0] : string.charAt(0),
         trailing = strSymbols ? strSymbols.slice(1).join('') : string.slice(1);
 
     return chr[methodName]() + trailing;

_createCurryWrapper.js

@@ -2,6 +2,7 @@ import apply from './_apply';
 import createCtorWrapper from './_createCtorWrapper';
 import createHybridWrapper from './_createHybridWrapper';
 import createRecurryWrapper from './_createRecurryWrapper';
+import getPlaceholder from './_getPlaceholder';
 import replaceHolders from './_replaceHolders';
 import root from './_root';
 
@@ -19,10 +20,9 @@ function createCurryWrapper(func, bitmask, arity) {
 
   function wrapper() {
     var length = arguments.length,
-        index = length,
         args = Array(length),
-        fn = (this && this !== root && this instanceof wrapper) ? Ctor : func,
+        index = length,
-        placeholder = wrapper.placeholder;
+        placeholder = getPlaceholder(wrapper);
 
     while (index--) {
       args[index] = arguments[index];
@@ -32,9 +32,13 @@ function createCurryWrapper(func, bitmask, arity) {
       : replaceHolders(args, placeholder);
 
     length -= holders.length;
-    return length < arity
+    if (length < arity) {
-      ? createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, undefined, args, holders, undefined, undefined, arity - length)
+      return createRecurryWrapper(
-      : apply(fn, this, args);
+        func, bitmask, createHybridWrapper, wrapper.placeholder, undefined,
+        args, holders, undefined, undefined, arity - length);
+    }
+    var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
+    return apply(fn, this, args);
   }
   return wrapper;
 }

_createFlow.js

@@ -6,18 +6,18 @@ import isArray from './isArray';
 import isLaziable from './_isLaziable';
 import rest from './rest';
 
-/** Used to compose bitmasks for wrapper metadata. */
-var CURRY_FLAG = 8,
-    PARTIAL_FLAG = 32,
-    ARY_FLAG = 128,
-    REARG_FLAG = 256;
-
 /** Used as the size to enable large array optimizations. */
 var LARGE_ARRAY_SIZE = 200;
 
 /** Used as the `TypeError` message for "Functions" methods. */
 var FUNC_ERROR_TEXT = 'Expected a function';
 
+/** Used to compose bitmasks for wrapper metadata. */
+var CURRY_FLAG = 8,
+    PARTIAL_FLAG = 32,
+    ARY_FLAG = 128,
+    REARG_FLAG = 256;
+
 /**
  * Creates a `_.flow` or `_.flowRight` function.
  *
@@ -27,7 +27,7 @@ var FUNC_ERROR_TEXT = 'Expected a function';
  */
 function createFlow(fromRight) {
   return rest(function(funcs) {
-    funcs = baseFlatten(funcs);
+    funcs = baseFlatten(funcs, 1);
 
     var length = funcs.length,
         index = length,
@@ -52,7 +52,10 @@ function createFlow(fromRight) {
       var funcName = getFuncName(func),
           data = funcName == 'wrapper' ? getData(func) : undefined;
 
-      if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {
+      if (data && isLaziable(data[0]) &&
+            data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) &&
+            !data[4].length && data[9] == 1
+          ) {
         wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
       } else {
         wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);
@@ -62,7 +65,8 @@ function createFlow(fromRight) {
       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) && value.length >= LARGE_ARRAY_SIZE) {
         return wrapper.plant(value).value();
       }
       var index = 0,

_createHybridWrapper.js

@@ -1,7 +1,9 @@
 import composeArgs from './_composeArgs';
 import composeArgsRight from './_composeArgsRight';
+import countHolders from './_countHolders';
 import createCtorWrapper from './_createCtorWrapper';
 import createRecurryWrapper from './_createRecurryWrapper';
+import getPlaceholder from './_getPlaceholder';
 import reorder from './_reorder';
 import replaceHolders from './_replaceHolders';
 import root from './_root';
@@ -35,8 +37,7 @@ function createHybridWrapper(func, bitmask, thisArg, partials, holders, partials
   var isAry = bitmask & ARY_FLAG,
       isBind = bitmask & BIND_FLAG,
       isBindKey = bitmask & BIND_KEY_FLAG,
-      isCurry = bitmask & CURRY_FLAG,
+      isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
-      isCurryRight = bitmask & CURRY_RIGHT_FLAG,
       isFlip = bitmask & FLIP_FLAG,
       Ctor = isBindKey ? undefined : createCtorWrapper(func);
 
@@ -48,30 +49,34 @@ function createHybridWrapper(func, bitmask, thisArg, partials, holders, partials
     while (index--) {
       args[index] = arguments[index];
     }
+    if (isCurried) {
+      var placeholder = getPlaceholder(wrapper),
+          holdersCount = countHolders(args, placeholder);
+    }
     if (partials) {
-      args = composeArgs(args, partials, holders);
+      args = composeArgs(args, partials, holders, isCurried);
     }
     if (partialsRight) {
-      args = composeArgsRight(args, partialsRight, holdersRight);
+      args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
     }
-    if (isCurry || isCurryRight) {
+    length -= holdersCount;
-      var placeholder = wrapper.placeholder,
+    if (isCurried && length < arity) {
-          argsHolders = replaceHolders(args, placeholder);
+      var newHolders = replaceHolders(args, placeholder);
-
+      return createRecurryWrapper(
-      length -= argsHolders.length;
+        func, bitmask, createHybridWrapper, wrapper.placeholder, thisArg,
-      if (length < arity) {
+        args, newHolders, argPos, ary, arity - length
-        return createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, thisArg, args, argsHolders, argPos, ary, arity - length);
+      );
-      }
     }
     var thisBinding = isBind ? thisArg : this,
         fn = isBindKey ? thisBinding[func] : func;
 
+    length = args.length;
     if (argPos) {
       args = reorder(args, argPos);
-    } else if (isFlip && args.length > 1) {
+    } else if (isFlip && length > 1) {
       args.reverse();
     }
-    if (isAry && ary < args.length) {
+    if (isAry && ary < length) {
       args.length = ary;
     }
     if (this && this !== root && this instanceof wrapper) {

_createOver.js

@@ -13,7 +13,7 @@ import rest from './rest';
  */
 function createOver(arrayFunc) {
   return rest(function(iteratees) {
-    iteratees = arrayMap(baseFlatten(iteratees), baseIteratee);
+    iteratees = arrayMap(baseFlatten(iteratees, 1), baseIteratee);
     return rest(function(args) {
       var thisArg = this;
       return arrayFunc(iteratees, function(iteratee) {

_createRecurryWrapper.js

@@ -17,7 +17,7 @@ var BIND_FLAG = 1,
  * @param {Function} func The function to wrap.
  * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
  * @param {Function} wrapFunc The function to create the `func` wrapper.
- * @param {*} placeholder The placeholder to replace.
+ * @param {*} placeholder The placeholder value.
  * @param {*} [thisArg] The `this` binding of `func`.
  * @param {Array} [partials] The arguments to prepend to those provided to the new function.
  * @param {Array} [holders] The `partials` placeholder indexes.
@@ -29,7 +29,7 @@ var BIND_FLAG = 1,
 function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
   var isCurry = bitmask & CURRY_FLAG,
       newArgPos = argPos ? copyArray(argPos) : undefined,
-      newsHolders = isCurry ? holders : undefined,
+      newHolders = isCurry ? holders : undefined,
       newHoldersRight = isCurry ? undefined : holders,
       newPartials = isCurry ? partials : undefined,
       newPartialsRight = isCurry ? undefined : partials;
@@ -40,9 +40,12 @@ function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, par
   if (!(bitmask & CURRY_BOUND_FLAG)) {
     bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
   }
-  var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, arity],
+  var newData = [
-      result = wrapFunc.apply(undefined, newData);
+    func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
+    newHoldersRight, newArgPos, ary, arity
+  ];
 
+  var result = wrapFunc.apply(undefined, newData);
   if (isLaziable(func)) {
     setData(result, newData);
   }

_createWrapper.js

@@ -8,6 +8,9 @@ import mergeData from './_mergeData';
 import setData from './_setData';
 import toInteger from './toInteger';
 
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
 /** Used to compose bitmasks for wrapper metadata. */
 var BIND_FLAG = 1,
     BIND_KEY_FLAG = 2,
@@ -16,9 +19,6 @@ var BIND_FLAG = 1,
     PARTIAL_FLAG = 32,
     PARTIAL_RIGHT_FLAG = 64;
 
-/** Used as the `TypeError` message for "Functions" methods. */
-var FUNC_ERROR_TEXT = 'Expected a function';
-
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMax = Math.max;
 
@@ -67,8 +67,12 @@ function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, a
 
     partials = holders = undefined;
   }
-  var data = isBindKey ? undefined : getData(func),
+  var data = isBindKey ? undefined : getData(func);
-      newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];
+
+  var newData = [
+    func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
+    argPos, ary, arity
+  ];
 
   if (data) {
     mergeData(newData, data);

_equalArrays.js

@@ -12,9 +12,9 @@ var UNORDERED_COMPARE_FLAG = 1,
  * @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 {Function} [customizer] The function to customize comparisons.
+ * @param {Function} customizer The function to customize comparisons.
- * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` for more details.
- * @param {Object} [stack] Tracks traversed `array` and `other` objects.
+ * @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) {

_equalByTag.js

@@ -1,5 +1,6 @@
 import Symbol from './_Symbol';
 import Uint8Array from './_Uint8Array';
+import equalArrays from './_equalArrays';
 import mapToArray from './_mapToArray';
 import setToArray from './_setToArray';
 
@@ -22,7 +23,7 @@ var arrayBufferTag = '[object ArrayBuffer]';
 
 /** Used to convert symbols to primitives and strings. */
 var symbolProto = Symbol ? Symbol.prototype : undefined,
-    symbolValueOf = Symbol ? symbolProto.valueOf : undefined;
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
 
 /**
  * A specialized version of `baseIsEqualDeep` for comparing objects of
@@ -36,11 +37,12 @@ var symbolProto = Symbol ? Symbol.prototype : undefined,
  * @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 {Function} [customizer] The function to customize comparisons.
+ * @param {Function} customizer The function to customize comparisons.
- * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
+ * @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 equalByTag(object, other, tag, equalFunc, customizer, bitmask) {
+function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
   switch (tag) {
     case arrayBufferTag:
       if ((object.byteLength != other.byteLength) ||
@@ -75,12 +77,21 @@ function equalByTag(object, other, tag, equalFunc, customizer, bitmask) {
       var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
       convert || (convert = setToArray);
 
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
       // Recursively compare objects (susceptible to call stack limits).
-      return (isPartial || object.size == other.size) &&
+      return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask | UNORDERED_COMPARE_FLAG, stack.set(object, other));
-        equalFunc(convert(object), convert(other), customizer, bitmask | UNORDERED_COMPARE_FLAG);
 
     case symbolTag:
-      return !!Symbol && (symbolValueOf.call(object) == symbolValueOf.call(other));
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
   }
   return false;
 }

_equalObjects.js

@@ -12,9 +12,9 @@ var PARTIAL_COMPARE_FLAG = 2;
  * @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 {Function} [customizer] The function to customize comparisons.
+ * @param {Function} customizer The function to customize comparisons.
- * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` for more details.
- * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @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) {

_getNative.js

@@ -9,7 +9,7 @@ import isNative from './isNative';
  * @returns {*} Returns the function if it's native, else `undefined`.
  */
 function getNative(object, key) {
-  var value = object == null ? undefined : object[key];
+  var value = object[key];
   return isNative(value) ? value : undefined;
 }
 

_getPlaceholder.js

@@ -0,0 +1,13 @@
+/**
+ * Gets the argument placeholder value for `func`.
+ *
+ * @private
+ * @param {Function} func The function to inspect.
+ * @returns {*} Returns the placeholder value.
+ */
+function getPlaceholder(func) {
+  var object = func;
+  return object.placeholder;
+}
+
+export default getPlaceholder;

_hasPath.js

@@ -1,4 +1,4 @@
-import baseToPath from './_baseToPath';
+import baseCastPath from './_baseCastPath';
 import isArguments from './isArguments';
 import isArray from './isArray';
 import isIndex from './_isIndex';
@@ -23,7 +23,7 @@ function hasPath(object, path, hasFunc) {
   }
   var result = hasFunc(object, path);
   if (!result && !isKey(path)) {
-    path = baseToPath(path);
+    path = baseCastPath(path);
     object = parent(object, path);
     if (object != null) {
       path = last(path);

_initCloneObject.js

@@ -1,7 +1,9 @@
 import baseCreate from './_baseCreate';
-import isFunction from './isFunction';
 import isPrototype from './_isPrototype';
 
+/** Built-in value references. */
+var getPrototypeOf = Object.getPrototypeOf;
+
 /**
  * Initializes an object clone.
  *
@@ -10,11 +12,9 @@ import isPrototype from './_isPrototype';
  * @returns {Object} Returns the initialized clone.
  */
 function initCloneObject(object) {
-  if (isPrototype(object)) {
+  return (typeof object.constructor == 'function' && !isPrototype(object))
-    return {};
+    ? baseCreate(getPrototypeOf(object))
-  }
+    : {};
-  var Ctor = object.constructor;
-  return baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);
 }
 
 export default initCloneObject;

_isKeyable.js

@@ -8,7 +8,7 @@
 function isKeyable(value) {
   var type = typeof value;
   return type == 'number' || type == 'boolean' ||
-    (type == 'string' && value !== '__proto__') || value == null;
+    (type == 'string' && value != '__proto__') || value == null;
 }
 
 export default isKeyable;

_lazyValue.js

@@ -36,7 +36,8 @@ function lazyValue() {
       resIndex = 0,
       takeCount = nativeMin(length, this.__takeCount__);
 
-  if (!isArr || arrLength < LARGE_ARRAY_SIZE || (arrLength == length && takeCount == length)) {
+  if (!isArr || arrLength < LARGE_ARRAY_SIZE ||
+      (arrLength == length && takeCount == length)) {
     return baseWrapperValue(array, this.__actions__);
   }
   var result = [];

_mapClear.js

@@ -9,7 +9,11 @@ import Map from './_Map';
  * @memberOf MapCache
  */
 function mapClear() {
-  this.__data__ = { 'hash': new Hash, 'map': Map ? new Map : [], 'string': new Hash };
+  this.__data__ = {
+    'hash': new Hash,
+    'map': Map ? new Map : [],
+    'string': new Hash
+  };
 }
 
 export default mapClear;

_mergeData.js

@@ -3,6 +3,9 @@ import composeArgsRight from './_composeArgsRight';
 import copyArray from './_copyArray';
 import replaceHolders from './_replaceHolders';
 
+/** Used as the internal argument placeholder. */
+var PLACEHOLDER = '__lodash_placeholder__';
+
 /** Used to compose bitmasks for wrapper metadata. */
 var BIND_FLAG = 1,
     BIND_KEY_FLAG = 2,
@@ -11,9 +14,6 @@ var BIND_FLAG = 1,
     ARY_FLAG = 128,
     REARG_FLAG = 256;
 
-/** Used as the internal argument placeholder. */
-var PLACEHOLDER = '__lodash_placeholder__';
-
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMin = Math.min;
 
@@ -39,9 +39,9 @@ function mergeData(data, source) {
       isCommon = newBitmask < (BIND_FLAG | BIND_KEY_FLAG | ARY_FLAG);
 
   var isCombo =
-    (srcBitmask == ARY_FLAG && (bitmask == CURRY_FLAG)) ||
+    ((srcBitmask == ARY_FLAG) && (bitmask == CURRY_FLAG)) ||
-    (srcBitmask == ARY_FLAG && (bitmask == REARG_FLAG) && (data[7].length <= source[8])) ||
+    ((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 == (ARY_FLAG | REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == CURRY_FLAG));
 
   // Exit early if metadata can't be merged.
   if (!(isCommon || isCombo)) {
@@ -51,7 +51,7 @@ function mergeData(data, source) {
   if (srcBitmask & BIND_FLAG) {
     data[2] = source[2];
     // Set when currying a bound function.
-    newBitmask |= (bitmask & BIND_FLAG) ? 0 : CURRY_BOUND_FLAG;
+    newBitmask |= bitmask & BIND_FLAG ? 0 : CURRY_BOUND_FLAG;
   }
   // Compose partial arguments.
   var value = source[3];

_mergeDefaults.js

@@ -15,8 +15,7 @@ import isObject from './isObject';
  */
 function mergeDefaults(objValue, srcValue, key, object, source, stack) {
   if (isObject(objValue) && isObject(srcValue)) {
-    stack.set(srcValue, objValue);
+    baseMerge(objValue, srcValue, undefined, mergeDefaults, stack.set(srcValue, objValue));
-    baseMerge(objValue, srcValue, undefined, mergeDefaults, stack);
   }
   return objValue;
 }

_replaceHolders.js

@@ -13,13 +13,14 @@ var PLACEHOLDER = '__lodash_placeholder__';
 function replaceHolders(array, placeholder) {
   var index = -1,
       length = array.length,
-      resIndex = -1,
+      resIndex = 0,
       result = [];
 
   while (++index < length) {
-    if (array[index] === placeholder) {
+    var value = array[index];
+    if (value === placeholder || value === PLACEHOLDER) {
       array[index] = PLACEHOLDER;
-      result[++resIndex] = index;
+      result[resIndex++] = index;
     }
   }
   return result;

_root.js

@@ -7,10 +7,14 @@ var objectTypes = {
 };
 
 /** Detect free variable `exports`. */
-var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType) ? exports : null;
+var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType)
+  ? exports
+  : undefined;
 
 /** Detect free variable `module`. */
-var freeModule = (objectTypes[typeof module] && module && !module.nodeType) ? module : null;
+var freeModule = (objectTypes[typeof module] && module && !module.nodeType)
+  ? module
+  : undefined;
 
 /** Detect free variable `global` from Node.js. */
 var freeGlobal = checkGlobal(freeExports && freeModule && typeof global == 'object' && global);
@@ -30,6 +34,8 @@ var thisGlobal = checkGlobal(objectTypes[typeof this] && this);
  * The `this` value is used if it's the global object to avoid Greasemonkey's
  * restricted `window` object, otherwise the `window` object is used.
  */
-var root = freeGlobal || ((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) || freeSelf || thisGlobal || Function('return this')();
+var root = freeGlobal ||
+  ((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) ||
+    freeSelf || thisGlobal || Function('return this')();
 
 export default root;

_toArrayLikeObject.js

@@ -1,14 +0,0 @@
-import isArrayLikeObject from './isArrayLikeObject';
-
-/**
- * Converts `value` to an array-like object if it's not one.
- *
- * @private
- * @param {*} value The value to process.
- * @returns {Array} Returns the array-like object.
- */
-function toArrayLikeObject(value) {
-  return isArrayLikeObject(value) ? value : [];
-}
-
-export default toArrayLikeObject;

_toFunction.js

@@ -1,14 +0,0 @@
-import identity from './identity';
-
-/**
- * Converts `value` to a function if it's not one.
- *
- * @private
- * @param {*} value The value to process.
- * @returns {Function} Returns the function.
- */
-function toFunction(value) {
-  return typeof value == 'function' ? value : identity;
-}
-
-export default toFunction;

array.default.js

@@ -13,6 +13,7 @@ import findIndex from './findIndex';
 import findLastIndex from './findLastIndex';
 import flatten from './flatten';
 import flattenDeep from './flattenDeep';
+import flattenDepth from './flattenDepth';
 import fromPairs from './fromPairs';
 import head from './head';
 import indexOf from './indexOf';
@@ -26,6 +27,7 @@ import lastIndexOf from './lastIndexOf';
 import pull from './pull';
 import pullAll from './pullAll';
 import pullAllBy from './pullAllBy';
+import pullAllWith from './pullAllWith';
 import pullAt from './pullAt';
 import remove from './remove';
 import reverse from './reverse';
@@ -64,14 +66,14 @@ export default {
   chunk, compact, concat, difference, differenceBy,
   differenceWith, drop, dropRight, dropRightWhile, dropWhile,
   fill, findIndex, findLastIndex, flatten, flattenDeep,
-  fromPairs, head, indexOf, initial, intersection,
+  flattenDepth, fromPairs, head, indexOf, initial,
-  intersectionBy, intersectionWith, join, last, lastIndexOf,
+  intersection, intersectionBy, intersectionWith, join, last,
-  pull, pullAll, pullAllBy, pullAt, remove,
+  lastIndexOf, pull, pullAll, pullAllBy, pullAllWith,
-  reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf,
+  pullAt, remove, reverse, slice, sortedIndex,
-  sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy,
+  sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf,
-  tail, take, takeRight, takeRightWhile, takeWhile,
+  sortedUniq, sortedUniqBy, tail, take, takeRight,
-  union, unionBy, unionWith, uniq, uniqBy,
+  takeRightWhile, takeWhile, union, unionBy, unionWith,
-  uniqWith, unzip, unzipWith, without, xor,
+  uniq, uniqBy, uniqWith, unzip, unzipWith,
-  xorBy, xorWith, zip, zipObject, zipObjectDeep,
+  without, xor, xorBy, xorWith, zip,
-  zipWith
+  zipObject, zipObjectDeep, zipWith
 };

array.js

@@ -13,6 +13,7 @@ export { default as findIndex } from './findIndex';
 export { default as findLastIndex } from './findLastIndex';
 export { default as flatten } from './flatten';
 export { default as flattenDeep } from './flattenDeep';
+export { default as flattenDepth } from './flattenDepth';
 export { default as fromPairs } from './fromPairs';
 export { default as head } from './head';
 export { default as indexOf } from './indexOf';
@@ -26,6 +27,7 @@ export { default as lastIndexOf } from './lastIndexOf';
 export { default as pull } from './pull';
 export { default as pullAll } from './pullAll';
 export { default as pullAllBy } from './pullAllBy';
+export { default as pullAllWith } from './pullAllWith';
 export { default as pullAt } from './pullAt';
 export { default as remove } from './remove';
 export { default as reverse } from './reverse';

assign.js

@@ -1,7 +1,22 @@
+import assignValue from './_assignValue';
 import copyObject from './_copyObject';
 import createAssigner from './_createAssigner';
+import isArrayLike from './isArrayLike';
+import isPrototype from './_isPrototype';
 import keys from './keys';
 
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');
+
 /**
  * Assigns own enumerable properties of source objects to the destination
  * object. Source objects are applied from left to right. Subsequent sources
@@ -33,7 +48,15 @@ import keys from './keys';
  * // => { 'a': 1, 'c': 3, 'e': 5 }
  */
 var assign = createAssigner(function(object, source) {
-  copyObject(source, keys(source), object);
+  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {
+    copyObject(source, keys(source), object);
+    return;
+  }
+  for (var key in source) {
+    if (hasOwnProperty.call(source, key)) {
+      assignValue(object, key, source[key]);
+    }
+  }
 });
 
 export default assign;

assignIn.js

@@ -1,7 +1,19 @@
+import assignValue from './_assignValue';
 import copyObject from './_copyObject';
 import createAssigner from './_createAssigner';
+import isArrayLike from './isArrayLike';
+import isPrototype from './_isPrototype';
 import keysIn from './keysIn';
 
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');
+
 /**
  * This method is like `_.assign` except that it iterates over own and
  * inherited source properties.
@@ -32,7 +44,13 @@ import keysIn from './keysIn';
  * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 }
  */
 var assignIn = createAssigner(function(object, source) {
-  copyObject(source, keysIn(source), object);
+  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {
+    copyObject(source, keysIn(source), object);
+    return;
+  }
+  for (var key in source) {
+    assignValue(object, key, source[key]);
+  }
 });
 
 export default assignIn;

at.js

@@ -23,7 +23,7 @@ import rest from './rest';
  * // => ['a', 'c']
  */
 var at = rest(function(object, paths) {
-  return baseAt(object, baseFlatten(paths));
+  return baseAt(object, baseFlatten(paths, 1));
 });
 
 export default at;

attempt.js

@@ -1,5 +1,5 @@
 import apply from './_apply';
-import isObject from './isObject';
+import isError from './isError';
 import rest from './rest';
 
 /**
@@ -26,7 +26,7 @@ var attempt = rest(function(func, args) {
   try {
     return apply(func, undefined, args);
   } catch (e) {
-    return isObject(e) ? e : new Error(e);
+    return isError(e) ? e : new Error(e);
   }
 });
 

bind.js

@@ -1,4 +1,5 @@
 import createWrapper from './_createWrapper';
+import getPlaceholder from './_getPlaceholder';
 import replaceHolders from './_replaceHolders';
 import rest from './rest';
 
@@ -44,9 +45,7 @@ var BIND_FLAG = 1,
 var bind = rest(function(func, thisArg, partials) {
   var bitmask = BIND_FLAG;
   if (partials.length) {
-    var placeholder = bind.placeholder,
+    var holders = replaceHolders(partials, getPlaceholder(bind));
-        holders = replaceHolders(partials, placeholder);
-
     bitmask |= PARTIAL_FLAG;
   }
   return createWrapper(func, bitmask, thisArg, partials, holders);

bindAll.js

@@ -30,7 +30,7 @@ import rest from './rest';
  * // => logs 'clicked docs' when clicked
  */
 var bindAll = rest(function(object, methodNames) {
-  arrayEach(baseFlatten(methodNames), function(key) {
+  arrayEach(baseFlatten(methodNames, 1), function(key) {
     object[key] = bind(object[key], object);
   });
   return object;

bindKey.js

@@ -1,4 +1,5 @@
 import createWrapper from './_createWrapper';
+import getPlaceholder from './_getPlaceholder';
 import replaceHolders from './_replaceHolders';
 import rest from './rest';
 
@@ -54,9 +55,7 @@ var BIND_FLAG = 1,
 var bindKey = rest(function(object, key, partials) {
   var bitmask = BIND_FLAG | BIND_KEY_FLAG;
   if (partials.length) {
-    var placeholder = bindKey.placeholder,
+    var holders = replaceHolders(partials, getPlaceholder(bindKey));
-        holders = replaceHolders(partials, placeholder);
-
     bitmask |= PARTIAL_FLAG;
   }
   return createWrapper(key, bitmask, object, partials, holders);

castArray.js

@@ -0,0 +1,43 @@
+import isArray from './isArray';
+
+/**
+ * Casts `value` as an array if it's not one.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast array.
+ * @example
+ *
+ * _.castArray(1);
+ * // => [1]
+ *
+ * _.castArray({ 'a': 1 });
+ * // => [{ 'a': 1 }]
+ *
+ * _.castArray('abc');
+ * // => ['abc']
+ *
+ * _.castArray(null);
+ * // => [null]
+ *
+ * _.castArray(undefined);
+ * // => [undefined]
+ *
+ * _.castArray();
+ * // => []
+ *
+ * var array = [1, 2, 3];
+ * console.log(_.castArray(array) === array);
+ * // => true
+ */
+function castArray() {
+  if (!arguments.length) {
+    return [];
+  }
+  var value = arguments[0];
+  return isArray(value) ? value : [value];
+}
+
+export default castArray;

chunk.js

@@ -32,11 +32,11 @@ function chunk(array, size) {
     return [];
   }
   var index = 0,
-      resIndex = -1,
+      resIndex = 0,
       result = Array(nativeCeil(length / size));
 
   while (index < length) {
-    result[++resIndex] = baseSlice(array, index, (index += size));
+    result[resIndex++] = baseSlice(array, index, (index += size));
   }
   return result;
 }

clone.js

@@ -25,7 +25,7 @@ import baseClone from './_baseClone';
  * // => true
  */
 function clone(value) {
-  return baseClone(value);
+  return baseClone(value, false, true);
 }
 
 export default clone;

cloneDeep.js

@@ -17,7 +17,7 @@ import baseClone from './_baseClone';
  * // => false
  */
 function cloneDeep(value) {
-  return baseClone(value, true);
+  return baseClone(value, true, true);
 }
 
 export default cloneDeep;

cloneDeepWith.js

@@ -27,7 +27,7 @@ import baseClone from './_baseClone';
  * // => 20
  */
 function cloneDeepWith(value, customizer) {
-  return baseClone(value, true, customizer);
+  return baseClone(value, true, true, customizer);
 }
 
 export default cloneDeepWith;

cloneWith.js

@@ -30,7 +30,7 @@ import baseClone from './_baseClone';
  * // => 0
  */
 function cloneWith(value, customizer) {
-  return baseClone(value, false, customizer);
+  return baseClone(value, false, true, customizer);
 }
 
 export default cloneWith;

compact.js

@@ -15,13 +15,13 @@
 function compact(array) {
   var index = -1,
       length = array ? array.length : 0,
-      resIndex = -1,
+      resIndex = 0,
       result = [];
 
   while (++index < length) {
     var value = array[index];
     if (value) {
-      result[++resIndex] = value;
+      result[resIndex++] = value;
     }
   }
   return result;

concat.js

@@ -28,7 +28,7 @@ var concat = rest(function(array, values) {
   if (!isArray(array)) {
     array = array == null ? [] : [Object(array)];
   }
-  values = baseFlatten(values);
+  values = baseFlatten(values, 1);
   return arrayConcat(array, values);
 });
 

debounce.js

@@ -138,8 +138,10 @@ function debounce(func, wait, options) {
       if (!lastCalled && !maxTimeoutId && !leading) {
         lastCalled = stamp;
       }
-      var remaining = maxWait - (stamp - lastCalled),
+      var remaining = maxWait - (stamp - lastCalled);
-          isCalled = remaining <= 0 || remaining > maxWait;
+
+      var isCalled = (remaining <= 0 || remaining > maxWait) &&
+        (leading || maxTimeoutId);
 
       if (isCalled) {
         if (maxTimeoutId) {

difference.js

@@ -6,7 +6,8 @@ import rest from './rest';
 /**
  * Creates an array of unique `array` values not included in the other
  * given arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
- * for equality comparisons.
+ * for equality comparisons. The order of result values is determined by the
+ * order they occur in the first array.
  *
  * @static
  * @memberOf _
@@ -21,7 +22,7 @@ import rest from './rest';
  */
 var difference = rest(function(array, values) {
   return isArrayLikeObject(array)
-    ? baseDifference(array, baseFlatten(values, false, true))
+    ? baseDifference(array, baseFlatten(values, 1, true))
     : [];
 });
 

differenceBy.js

@@ -8,7 +8,8 @@ import rest from './rest';
 /**
  * This method is like `_.difference` except that it accepts `iteratee` which
  * is invoked for each element of `array` and `values` to generate the criterion
- * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
+ * by which they're compared. Result values are chosen from the first array.
+ * The iteratee is invoked with one argument: (value).
  *
  * @static
  * @memberOf _
@@ -32,7 +33,7 @@ var differenceBy = rest(function(array, values) {
     iteratee = undefined;
   }
   return isArrayLikeObject(array)
-    ? baseDifference(array, baseFlatten(values, false, true), baseIteratee(iteratee))
+    ? baseDifference(array, baseFlatten(values, 1, true), baseIteratee(iteratee))
     : [];
 });
 

differenceWith.js

@@ -6,8 +6,9 @@ import rest from './rest';
 
 /**
  * This method is like `_.difference` except that it accepts `comparator`
- * which is invoked to compare elements of `array` to `values`. The comparator
+ * which is invoked to compare elements of `array` to `values`. Result values
- * is invoked with two arguments: (arrVal, othVal).
+ * are chosen from the first array. The comparator is invoked with two arguments:
+ * (arrVal, othVal).
  *
  * @static
  * @memberOf _
@@ -29,7 +30,7 @@ var differenceWith = rest(function(array, values) {
     comparator = undefined;
   }
   return isArrayLikeObject(array)
-    ? baseDifference(array, baseFlatten(values, false, true), undefined, comparator)
+    ? baseDifference(array, baseFlatten(values, 1, true), undefined, comparator)
     : [];
 });
 

flatMap.js

@@ -22,7 +22,7 @@ import map from './map';
  * // => [1, 1, 2, 2]
  */
 function flatMap(collection, iteratee) {
-  return baseFlatten(map(collection, iteratee));
+  return baseFlatten(map(collection, iteratee), 1);
 }
 
 export default flatMap;

flatten.js

@@ -1,7 +1,7 @@
 import baseFlatten from './_baseFlatten';
 
 /**
- * Flattens `array` a single level.
+ * Flattens `array` a single level deep.
  *
  * @static
  * @memberOf _
@@ -10,12 +10,12 @@ import baseFlatten from './_baseFlatten';
  * @returns {Array} Returns the new flattened array.
  * @example
  *
- * _.flatten([1, [2, 3, [4]]]);
+ * _.flatten([1, [2, [3, [4]], 5]]);
- * // => [1, 2, 3, [4]]
+ * // => [1, 2, [3, [4]], 5]
  */
 function flatten(array) {
   var length = array ? array.length : 0;
-  return length ? baseFlatten(array) : [];
+  return length ? baseFlatten(array, 1) : [];
 }
 
 export default flatten;

flattenDeep.js

@@ -1,21 +1,24 @@
 import baseFlatten from './_baseFlatten';
 
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
 /**
- * This method is like `_.flatten` except that it recursively flattens `array`.
+ * Recursively flattens `array`.
  *
  * @static
  * @memberOf _
  * @category Array
- * @param {Array} array The array to recursively flatten.
+ * @param {Array} array The array to flatten.
  * @returns {Array} Returns the new flattened array.
  * @example
  *
- * _.flattenDeep([1, [2, 3, [4]]]);
+ * _.flattenDeep([1, [2, [3, [4]], 5]]);
- * // => [1, 2, 3, 4]
+ * // => [1, 2, 3, 4, 5]
  */
 function flattenDeep(array) {
   var length = array ? array.length : 0;
-  return length ? baseFlatten(array, true) : [];
+  return length ? baseFlatten(array, INFINITY) : [];
 }
 
 export default flattenDeep;

flattenDepth.js

@@ -0,0 +1,32 @@
+import baseFlatten from './_baseFlatten';
+import toInteger from './toInteger';
+
+/**
+ * Recursively flatten `array` up to `depth` times.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @param {number} [depth=1] The maximum recursion depth.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * var array = [1, [2, [3, [4]], 5]];
+ *
+ * _.flattenDepth(array, 1);
+ * // => [1, 2, [3, [4]], 5]
+ *
+ * _.flattenDepth(array, 2);
+ * // => [1, 2, 3, [4], 5]
+ */
+function flattenDepth(array, depth) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  depth = depth === undefined ? 1 : toInteger(depth);
+  return baseFlatten(array, depth);
+}
+
+export default flattenDepth;

forEach.js

@@ -1,7 +1,7 @@
 import arrayEach from './_arrayEach';
+import baseCastFunction from './_baseCastFunction';
 import baseEach from './_baseEach';
 import isArray from './isArray';
-import toFunction from './_toFunction';
 
 /**
  * Iterates over elements of `collection` invoking `iteratee` for each element.
@@ -34,7 +34,7 @@ import toFunction from './_toFunction';
 function forEach(collection, iteratee) {
   return (typeof iteratee == 'function' && isArray(collection))
     ? arrayEach(collection, iteratee)
-    : baseEach(collection, toFunction(iteratee));
+    : baseEach(collection, baseCastFunction(iteratee));
 }
 
 export default forEach;

forEachRight.js

@@ -1,7 +1,7 @@
 import arrayEachRight from './_arrayEachRight';
+import baseCastFunction from './_baseCastFunction';
 import baseEachRight from './_baseEachRight';
 import isArray from './isArray';
-import toFunction from './_toFunction';
 
 /**
  * This method is like `_.forEach` except that it iterates over elements of
@@ -24,7 +24,7 @@ import toFunction from './_toFunction';
 function forEachRight(collection, iteratee) {
   return (typeof iteratee == 'function' && isArray(collection))
     ? arrayEachRight(collection, iteratee)
-    : baseEachRight(collection, toFunction(iteratee));
+    : baseEachRight(collection, baseCastFunction(iteratee));
 }
 
 export default forEachRight;

forIn.js

@@ -1,6 +1,6 @@
+import baseCastFunction from './_baseCastFunction';
 import baseFor from './_baseFor';
 import keysIn from './keysIn';
-import toFunction from './_toFunction';
 
 /**
  * Iterates over own and inherited enumerable properties of an object invoking
@@ -29,7 +29,9 @@ import toFunction from './_toFunction';
  * // => logs 'a', 'b', then 'c' (iteration order is not guaranteed)
  */
 function forIn(object, iteratee) {
-  return object == null ? object : baseFor(object, toFunction(iteratee), keysIn);
+  return object == null
+    ? object
+    : baseFor(object, baseCastFunction(iteratee), keysIn);
 }
 
 export default forIn;

forInRight.js

@@ -1,6 +1,6 @@
+import baseCastFunction from './_baseCastFunction';
 import baseForRight from './_baseForRight';
 import keysIn from './keysIn';
-import toFunction from './_toFunction';
 
 /**
  * This method is like `_.forIn` except that it iterates over properties of
@@ -27,7 +27,9 @@ import toFunction from './_toFunction';
  * // => logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'
  */
 function forInRight(object, iteratee) {
-  return object == null ? object : baseForRight(object, toFunction(iteratee), keysIn);
+  return object == null
+    ? object
+    : baseForRight(object, baseCastFunction(iteratee), keysIn);
 }
 
 export default forInRight;

forOwn.js

@@ -1,5 +1,5 @@
+import baseCastFunction from './_baseCastFunction';
 import baseForOwn from './_baseForOwn';
-import toFunction from './_toFunction';
 
 /**
  * Iterates over own enumerable properties of an object invoking `iteratee`
@@ -28,7 +28,7 @@ import toFunction from './_toFunction';
  * // => logs 'a' then 'b' (iteration order is not guaranteed)
  */
 function forOwn(object, iteratee) {
-  return object && baseForOwn(object, toFunction(iteratee));
+  return object && baseForOwn(object, baseCastFunction(iteratee));
 }
 
 export default forOwn;