Bump to v4.6.0.

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.3.0
+# lodash-amd v4.6.0
 
 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.3.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.6.0-amd) for more details.

_Hash.js

@@ -7,6 +7,7 @@ define(['./_nativeCreate'], function(nativeCreate) {
    * Creates an hash object.
    *
    * @private
+   * @constructor
    * @returns {Object} Returns the new hash object.
    */
   function Hash() {}

_LazyWrapper.js

@@ -7,6 +7,7 @@ define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
    * 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

@@ -4,6 +4,7 @@ define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], f
    * Creates a map cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function MapCache(values) {

_SetCache.js

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

_Stack.js

@@ -4,6 +4,7 @@ define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_sta
    * Creates a stack cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function Stack(values) {

_addMapEntry.js

@@ -9,6 +9,7 @@ define([], function() {
    * @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

@@ -12,13 +12,13 @@ define([], function() {
   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,8 +1,7 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.includesWith` for arrays without support for
-   * specifying an index to search from.
+   * This function is like `arrayIncludes` except that it accepts a comparator.
    *
    * @private
    * @param {Array} array The array to search.

_assignMergeValue.js

@@ -4,7 +4,8 @@ define(['./eq'], function(eq) {
   var undefined;
 
   /**
-   * 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

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

_baseCastArrayLikeObject.js

@@ -1,15 +1,15 @@
 define(['./isArrayLikeObject'], function(isArrayLikeObject) {
 
   /**
-   * Converts `value` to an array-like object if it's not one.
+   * Casts `value` to an empty array if it's not an array like object.
    *
    * @private
-   * @param {*} value The value to process.
+   * @param {*} value The value to inspect.
    * @returns {Array} Returns the array-like object.
    */
-  function toArrayLikeObject(value) {
+  function baseCastArrayLikeObject(value) {
     return isArrayLikeObject(value) ? value : [];
   }
 
-  return toArrayLikeObject;
+  return baseCastArrayLikeObject;
 });

_baseCastFunction.js

@@ -0,0 +1,15 @@
+define(['./identity'], function(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;
+  }
+
+  return baseCastFunction;
+});

_baseCastPath.js

@@ -0,0 +1,15 @@
+define(['./isArray', './_stringToPath'], function(isArray, 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);
+  }
+
+  return baseCastPath;
+});

_baseClone.js

@@ -93,9 +93,10 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
           return copySymbols(value, baseAssign(result, value));
         }
       } else {
-        return cloneableTags[tag]
-          ? initCloneByTag(value, tag, isDeep)
-          : (object ? value : {});
+        if (!cloneableTags[tag]) {
+          return object ? value : {};
+        }
+        result = initCloneByTag(value, tag, isDeep);
       }
     }
     // Check for circular references and return its corresponding clone.

_baseCreate.js

@@ -1,7 +1,7 @@
 define(['./isObject'], function(isObject) {
 
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+  /** Built-in value references. */
+  var objectCreate = Object.create;
 
   /**
    * The base implementation of `_.create` without support for assigning
@@ -11,17 +11,9 @@ define(['./isObject'], function(isObject) {
    * @param {Object} prototype The object to inherit from.
    * @returns {Object} Returns the new object.
    */
-  var baseCreate = (function() {
-    function object() {}
-    return function(prototype) {
-      if (isObject(prototype)) {
-        object.prototype = prototype;
-        var result = new object;
-        object.prototype = undefined;
-      }
-      return result || {};
-    };
-  }());
+  function baseCreate(proto) {
+    return isObject(proto) ? objectCreate(proto) : {};
+  }
 
   return baseCreate;
 });

_baseFlatten.js

@@ -5,12 +5,12 @@ define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], fu
    *
    * @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,
@@ -18,11 +18,11 @@ define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], fu
 
     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 @@
-define(['./_baseToPath', './_isKey'], function(baseToPath, isKey) {
+define(['./_baseCastPath', './_isKey'], function(baseCastPath, isKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,7 +12,7 @@ define(['./_baseToPath', './_isKey'], function(baseToPath, 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,26 @@
+define([], function() {
+
+  /**
+   * 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;
+  }
+
+  return baseIndexOfWith;
+});

_baseIntersection.js

@@ -3,6 +3,9 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /* 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.
@@ -15,9 +18,11 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
    */
   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--) {
@@ -25,26 +30,32 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
       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))) {
-        var othIndex = othLength;
+      if (!(seen
+            ? 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,4 +1,4 @@
-define(['./_apply', './_baseToPath', './_isKey', './last', './_parent'], function(apply, baseToPath, isKey, last, parent) {
+define(['./_apply', './_baseCastPath', './_isKey', './last', './_parent'], function(apply, baseCastPath, isKey, last, parent) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -15,7 +15,7 @@ define(['./_apply', './_baseToPath', './_isKey', './last', './_parent'], functio
    */
   function baseInvoke(object, path, args) {
     if (!isKey(path, object)) {
-      path = baseToPath(path);
+      path = baseCastPath(path);
       object = parent(object, path);
       path = last(path);
     }

_baseIsEqualDeep.js

@@ -36,33 +36,28 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
 
     if (!objIsArr) {
       objTag = getTag(object);
-      if (objTag == argsTag) {
-        objTag = objectTag;
-      } else if (objTag != objectTag) {
-        objIsArr = isTypedArray(object);
-      }
+      objTag = objTag == argsTag ? objectTag : objTag;
     }
     if (!othIsArr) {
       othTag = getTag(other);
-      if (othTag == argsTag) {
-        othTag = objectTag;
-      } else if (othTag != objectTag) {
-        othIsArr = isTypedArray(other);
-      }
+      othTag = othTag == argsTag ? objectTag : othTag;
     }
     var objIsObj = objTag == objectTag && !isHostObject(object),
         othIsObj = othTag == objectTag && !isHostObject(other),
         isSameTag = objTag == othTag;
 
-    if (isSameTag && !(objIsArr || objIsObj)) {
-      return equalByTag(object, other, objTag, equalFunc, customizer, bitmask);
+    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);
     }
-    var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
-    if (!isPartial) {
+    if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
       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);
       }
     }
@@ -70,7 +65,7 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
       return false;
     }
     stack || (stack = new Stack);
-    return (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, bitmask, stack);
+    return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
   }
 
   return baseIsEqualDeep;

_baseKeys.js

@@ -8,7 +8,6 @@ define([], function() {
    * 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

@@ -17,7 +17,10 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
     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;
@@ -28,7 +31,10 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
         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

@@ -26,21 +26,24 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
       assignMergeValue(object, key, stacked);
       return;
     }
-    var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined,
-        isCommon = newValue === undefined;
+    var newValue = customizer
+      ? 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)) {
@@ -49,10 +52,10 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
         }
         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 {
@@ -65,6 +68,7 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
       // 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

@@ -10,12 +10,8 @@ define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_com
    * @returns {Array} Returns the new sorted array.
    */
   function baseOrderBy(collection, iteratees, orders) {
-    var index = -1,
-        toIteratee = baseIteratee;
-
-    iteratees = arrayMap(iteratees.length ? iteratees : Array(1), function(iteratee) {
-      return toIteratee(iteratee);
-    });
+    var index = -1;
+    iteratees = arrayMap(iteratees.length ? iteratees : Array(1), baseIteratee);
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

_basePullAll.js

@@ -1,15 +1,44 @@
-define(['./_basePullAllBy'], function(basePullAllBy) {
+define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary'], function(arrayMap, baseIndexOf, baseIndexOfWith, 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) {
-    return basePullAllBy(array, values);
+  function basePullAll(array, values, iteratee, comparator) {
+    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;
   }
 
   return basePullAll;

_basePullAllBy.js

@@ -1,43 +0,0 @@
-define(['./_arrayMap', './_baseIndexOf'], function(arrayMap, 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;
-  }
-
-  return basePullAllBy;
-});

_basePullAt.js

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './_isIndex', './_isKey', './last', './_parent'], function(baseToPath, isIndex, isKey, last, parent) {
+define(['./_baseCastPath', './_isIndex', './_isKey', './last', './_parent'], function(baseCastPath, isIndex, isKey, last, parent) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -27,7 +27,7 @@ define(['./_baseToPath', './_isIndex', './_isKey', './last', './_parent'], funct
           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,4 +1,4 @@
-define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject'], function(assignValue, baseToPath, isIndex, isKey, isObject) {
+define(['./_assignValue', './_baseCastPath', './_isIndex', './_isKey', './isObject'], function(assignValue, baseCastPath, isIndex, isKey, isObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,7 +14,7 @@ define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './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,
@@ -29,7 +29,9 @@ define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject
           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,9 +1,9 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.sortBy` which uses `comparer` to define
-   * the sort order of `array` and replaces criteria objects with their
-   * corresponding values.
+   * The base implementation of `_.sortBy` which uses `comparer` to define the
+   * sort order of `array` and replaces criteria objects with their corresponding
+   * values.
    *
    * @private
    * @param {Array} array The array to sort.

_baseSortedUniqBy.js

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

_baseToPath.js

@@ -1,16 +0,0 @@
-define(['./isArray', './_stringToPath'], function(isArray, 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);
-  }
-
-  return baseToPath;
-});

_baseUnset.js

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './has', './_isKey', './last', './_parent'], function(baseToPath, has, isKey, last, parent) {
+define(['./_baseCastPath', './has', './_isKey', './last', './_parent'], function(baseCastPath, has, isKey, last, parent) {
 
   /**
    * The base implementation of `_.unset`.
@@ -9,7 +9,7 @@ define(['./_baseToPath', './has', './_isKey', './last', './_parent'], function(b
    * @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 @@
+define(['./_baseGet', './_baseSet'], function(baseGet, 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);
+  }
+
+  return baseUpdate;
+});

_cloneArrayBuffer.js

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

_cloneBuffer.js

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

_cloneMap.js

@@ -8,8 +8,7 @@ define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEnt
    * @returns {Object} Returns the cloned map.
    */
   function cloneMap(map) {
-    var Ctor = map.constructor;
-    return arrayReduce(mapToArray(map), addMapEntry, new Ctor);
+    return arrayReduce(mapToArray(map), addMapEntry, new map.constructor);
   }
 
   return cloneMap;

_cloneRegExp.js

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

_cloneSet.js

@@ -8,8 +8,7 @@ define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEnt
    * @returns {Object} Returns the cloned set.
    */
   function cloneSet(set) {
-    var Ctor = set.constructor;
-    return arrayReduce(setToArray(set), addSetEntry, new Ctor);
+    return arrayReduce(setToArray(set), addSetEntry, new set.constructor);
   }
 
   return cloneSet;

_cloneSymbol.js

@@ -5,7 +5,7 @@ define(['./_Symbol'], function(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.
@@ -15,7 +15,7 @@ define(['./_Symbol'], function(Symbol) {
    * @returns {Object} Returns the cloned symbol object.
    */
   function cloneSymbol(symbol) {
-    return Symbol ? Object(symbolValueOf.call(symbol)) : {};
+    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
   }
 
   return cloneSymbol;

_cloneTypedArray.js

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

_composeArgs.js

@@ -11,23 +11,28 @@ define([], function() {
    * @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) {
-    var holdersLength = holders.length,
-        argsIndex = -1,
-        argsLength = nativeMax(args.length - holdersLength, 0),
+  function composeArgs(args, partials, holders, isCurried) {
+    var argsIndex = -1,
+        argsLength = args.length,
+        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

@@ -11,18 +11,21 @@ define([], function() {
    * @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) {
-    var holdersIndex = -1,
+  function composeArgsRight(args, partials, holders, isCurried) {
+    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;
@@ -30,7 +33,9 @@ define([], function() {
       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 @@ define(['./_assignValue'], function(assignValue) {
         length = props.length;
 
     while (++index < length) {
-      var key = props[index],
-          newValue = customizer ? customizer(object[key], source[key], key, object, source) : source[key];
+      var key = props[index];
+
+      var newValue = customizer
+        ? customizer(object[key], source[key], key, object, source)
+        : source[key];
 
       assignValue(object, key, newValue);
     }

_countHolders.js

@@ -0,0 +1,24 @@
+define([], function() {
+
+  /**
+   * 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;
+  }
+
+  return countHolders;
+});

_createAssigner.js

@@ -17,7 +17,10 @@ define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
           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

@@ -26,8 +26,11 @@ define(['./_stringToArray', './toString'], function(stringToArray, toString) {
     return function(string) {
       string = toString(string);
 
-      var strSymbols = reHasComplexSymbol.test(string) ? stringToArray(string) : undefined,
-          chr = strSymbols ? strSymbols[0] : string.charAt(0),
+      var strSymbols = reHasComplexSymbol.test(string)
+        ? 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

@@ -1,4 +1,4 @@
-define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, replaceHolders, root) {
+define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getPlaceholder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getPlaceholder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -17,10 +17,9 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
 
     function wrapper() {
       var length = arguments.length,
-          index = length,
           args = Array(length),
-          fn = (this && this !== root && this instanceof wrapper) ? Ctor : func,
-          placeholder = wrapper.placeholder;
+          index = length,
+          placeholder = getPlaceholder(wrapper);
 
       while (index--) {
         args[index] = arguments[index];
@@ -30,9 +29,13 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
         : replaceHolders(args, placeholder);
 
       length -= holders.length;
-      return length < arity
-        ? createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, undefined, args, holders, undefined, undefined, arity - length)
-        : apply(fn, this, args);
+      if (length < arity) {
+        return createRecurryWrapper(
+          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

@@ -3,18 +3,18 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** 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.
    *
@@ -24,7 +24,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
    */
   function createFlow(fromRight) {
     return rest(function(funcs) {
-      funcs = baseFlatten(funcs);
+      funcs = baseFlatten(funcs, 1);
 
       var length = funcs.length,
           index = length,
@@ -49,7 +49,10 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
         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);
@@ -59,7 +62,8 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
         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,4 +1,4 @@
-define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_createRecurryWrapper', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, createCtorWrapper, createRecurryWrapper, reorder, replaceHolders, root) {
+define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getPlaceholder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getPlaceholder, reorder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -32,8 +32,7 @@ define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_cre
     var isAry = bitmask & ARY_FLAG,
         isBind = bitmask & BIND_FLAG,
         isBindKey = bitmask & BIND_KEY_FLAG,
-        isCurry = bitmask & CURRY_FLAG,
-        isCurryRight = bitmask & CURRY_RIGHT_FLAG,
+        isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
         isFlip = bitmask & FLIP_FLAG,
         Ctor = isBindKey ? undefined : createCtorWrapper(func);
 
@@ -45,30 +44,34 @@ define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_cre
       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) {
-        var placeholder = wrapper.placeholder,
-            argsHolders = replaceHolders(args, placeholder);
-
-        length -= argsHolders.length;
-        if (length < arity) {
-          return createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, thisArg, args, argsHolders, argPos, ary, arity - length);
-        }
+      length -= holdersCount;
+      if (isCurried && length < arity) {
+        var newHolders = replaceHolders(args, placeholder);
+        return createRecurryWrapper(
+          func, bitmask, createHybridWrapper, wrapper.placeholder, thisArg,
+          args, newHolders, 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

@@ -9,7 +9,7 @@ define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './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

@@ -18,7 +18,7 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
    * @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.
@@ -30,7 +30,7 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
   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;
@@ -41,9 +41,12 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
     if (!(bitmask & CURRY_BOUND_FLAG)) {
       bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
     }
-    var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, arity],
-        result = wrapFunc.apply(undefined, newData);
+    var 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

@@ -3,6 +3,9 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** 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,
@@ -11,9 +14,6 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
       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;
 
@@ -62,8 +62,12 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
 
       partials = holders = undefined;
     }
-    var data = isBindKey ? undefined : getData(func),
-        newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];
+    var data = isBindKey ? undefined : getData(func);
+
+    var newData = [
+      func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
+      argPos, ary, arity
+    ];
 
     if (data) {
       mergeData(newData, data);

_equalArrays.js

@@ -15,9 +15,9 @@ define(['./_arraySome'], function(arraySome) {
    * @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 {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
-   * @param {Object} [stack] Tracks traversed `array` and `other` objects.
+   * @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 `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,4 +1,4 @@
-define(['./_Symbol', './_Uint8Array', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, mapToArray, setToArray) {
+define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, equalArrays, mapToArray, setToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -22,7 +22,7 @@ define(['./_Symbol', './_Uint8Array', './_mapToArray', './_setToArray'], functio
 
   /** 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 +36,12 @@ define(['./_Symbol', './_Uint8Array', './_mapToArray', './_setToArray'], functio
    * @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 {number} [bitmask] The bitmask of comparison 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 {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 +76,21 @@ define(['./_Symbol', './_Uint8Array', './_mapToArray', './_setToArray'], functio
         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) &&
-          equalFunc(convert(object), convert(other), customizer, bitmask | UNORDERED_COMPARE_FLAG);
+        return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask | UNORDERED_COMPARE_FLAG, stack.set(object, other));
 
       case symbolTag:
-        return !!Symbol && (symbolValueOf.call(object) == symbolValueOf.call(other));
+        if (symbolValueOf) {
+          return symbolValueOf.call(object) == symbolValueOf.call(other);
+        }
     }
     return false;
   }

_equalObjects.js

@@ -14,9 +14,9 @@ define(['./_baseHas', './keys'], function(baseHas, keys) {
    * @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 {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
-   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+   * @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 equalObjects(object, other, equalFunc, customizer, bitmask, stack) {

_getNative.js

@@ -12,7 +12,7 @@ define(['./isNative'], function(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,16 @@
+define([], function() {
+
+  /**
+   * 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;
+  }
+
+  return getPlaceholder;
+});

_hasPath.js

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString', './last', './_parent'], function(baseToPath, isArguments, isArray, isIndex, isKey, isLength, isString, last, parent) {
+define(['./_baseCastPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString', './last', './_parent'], function(baseCastPath, isArguments, isArray, isIndex, isKey, isLength, isString, last, parent) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -18,7 +18,7 @@ define(['./_baseToPath', './isArguments', './isArray', './_isIndex', './_isKey',
     }
     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,7 @@
-define(['./_baseCreate', './isFunction', './_isPrototype'], function(baseCreate, isFunction, isPrototype) {
+define(['./_baseCreate', './_isPrototype'], function(baseCreate, isPrototype) {
 
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+  /** Built-in value references. */
+  var getPrototypeOf = Object.getPrototypeOf;
 
   /**
    * Initializes an object clone.
@@ -11,11 +11,9 @@ define(['./_baseCreate', './isFunction', './_isPrototype'], function(baseCreate,
    * @returns {Object} Returns the initialized clone.
    */
   function initCloneObject(object) {
-    if (isPrototype(object)) {
-      return {};
-    }
-    var Ctor = object.constructor;
-    return baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);
+    return (typeof object.constructor == 'function' && !isPrototype(object))
+      ? baseCreate(getPrototypeOf(object))
+      : {};
   }
 
   return initCloneObject;

_isKeyable.js

@@ -10,7 +10,7 @@ define([], function() {
   function isKeyable(value) {
     var type = typeof value;
     return type == 'number' || type == 'boolean' ||
-      (type == 'string' && value !== '__proto__') || value == null;
+      (type == 'string' && value != '__proto__') || value == null;
   }
 
   return isKeyable;

_lazyValue.js

@@ -34,7 +34,8 @@ 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 || arrLength < LARGE_ARRAY_SIZE ||
+        (arrLength == length && takeCount == length)) {
       return baseWrapperValue(array, this.__actions__);
     }
     var result = [];

_mapClear.js

@@ -8,7 +8,11 @@ define(['./_Hash', './_Map'], function(Hash, 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
+    };
   }
 
   return mapClear;

_mergeData.js

@@ -1,5 +1,8 @@
 define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHolders'], function(composeArgs, composeArgsRight, copyArray, 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,
@@ -8,9 +11,6 @@ define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHold
       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;
 
@@ -36,9 +36,9 @@ define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHold
         isCommon = newBitmask < (BIND_FLAG | BIND_KEY_FLAG | 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 == 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));
 
     // Exit early if metadata can't be merged.
     if (!(isCommon || isCombo)) {
@@ -48,7 +48,7 @@ define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHold
     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

@@ -17,8 +17,7 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
    */
   function mergeDefaults(objValue, srcValue, key, object, source, stack) {
     if (isObject(objValue) && isObject(srcValue)) {
-      stack.set(srcValue, objValue);
-      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack);
+      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack.set(srcValue, objValue));
     }
     return objValue;
   }

_replaceHolders.js

@@ -15,13 +15,14 @@ define([], function() {
   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

@@ -1,5 +1,8 @@
 define(['./_checkGlobal'], function(checkGlobal) {
 
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
   /** Used to determine if values are of the language type `Object`. */
   var objectTypes = {
     'function': true,
@@ -7,10 +10,14 @@ define(['./_checkGlobal'], function(checkGlobal) {
   };
 
   /** 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,7 +37,9 @@ define(['./_checkGlobal'], function(checkGlobal) {
    * 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')();
 
   return root;
 });

_toFunction.js

@@ -1,15 +0,0 @@
-define(['./identity'], function(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;
-  }
-
-  return toFunction;
-});

array.js

@@ -1,4 +1,4 @@
-define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './flatten', './flattenDeep', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './pull', './pullAll', './pullAllBy', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, flatten, flattenDeep, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, pull, pullAll, pullAllBy, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
+define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './flatten', './flattenDeep', './flattenDepth', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './pull', './pullAll', './pullAllBy', './pullAllWith', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
   return {
     'chunk': chunk,
     'compact': compact,
@@ -15,6 +15,7 @@ define(['./chunk', './compact', './concat', './difference', './differenceBy', '.
     'findLastIndex': findLastIndex,
     'flatten': flatten,
     'flattenDeep': flattenDeep,
+    'flattenDepth': flattenDepth,
     'fromPairs': fromPairs,
     'head': head,
     'indexOf': indexOf,
@@ -28,6 +29,7 @@ define(['./chunk', './compact', './concat', './difference', './differenceBy', '.
     'pull': pull,
     'pullAll': pullAll,
     'pullAllBy': pullAllBy,
+    'pullAllWith': pullAllWith,
     'pullAt': pullAt,
     'remove': remove,
     'reverse': reverse,

assign.js

@@ -1,4 +1,13 @@
-define(['./_copyObject', './_createAssigner', './keys'], function(copyObject, createAssigner, keys) {
+define(['./_assignValue', './_copyObject', './_createAssigner', './isArrayLike', './_isPrototype', './keys'], function(assignValue, copyObject, createAssigner, isArrayLike, isPrototype, keys) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+  var nonEnumShadows = !({ 'valueOf': 1 }).propertyIsEnumerable('valueOf');
 
   /**
    * Assigns own enumerable properties of source objects to the destination
@@ -31,7 +40,15 @@ define(['./_copyObject', './_createAssigner', './keys'], function(copyObject, cr
    * // => { '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]);
+      }
+    }
   });
 
   return assign;

assignIn.js

@@ -1,4 +1,7 @@
-define(['./_copyObject', './_createAssigner', './keysIn'], function(copyObject, createAssigner, keysIn) {
+define(['./_assignValue', './_copyObject', './_createAssigner', './isArrayLike', './_isPrototype', './keysIn'], function(assignValue, copyObject, createAssigner, isArrayLike, isPrototype, keysIn) {
+
+  /** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+  var nonEnumShadows = !({ 'valueOf': 1 }).propertyIsEnumerable('valueOf');
 
   /**
    * This method is like `_.assign` except that it iterates over own and
@@ -30,7 +33,13 @@ define(['./_copyObject', './_createAssigner', './keysIn'], function(copyObject,
    * // => { '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]);
+    }
   });
 
   return assignIn;

at.js

@@ -21,7 +21,7 @@ define(['./_baseAt', './_baseFlatten', './rest'], function(baseAt, baseFlatten,
    * // => ['a', 'c']
    */
   var at = rest(function(object, paths) {
-    return baseAt(object, baseFlatten(paths));
+    return baseAt(object, baseFlatten(paths, 1));
   });
 
   return at;

attempt.js

@@ -1,4 +1,4 @@
-define(['./_apply', './isObject', './rest'], function(apply, isObject, rest) {
+define(['./_apply', './isError', './rest'], function(apply, isError, rest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -27,7 +27,7 @@ define(['./_apply', './isObject', './rest'], function(apply, isObject, rest) {
     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,4 @@
-define(['./_createWrapper', './_replaceHolders', './rest'], function(createWrapper, replaceHolders, rest) {
+define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'], function(createWrapper, getPlaceholder, replaceHolders, rest) {
 
   /** Used to compose bitmasks for wrapper metadata. */
   var BIND_FLAG = 1,
@@ -42,9 +42,7 @@ define(['./_createWrapper', './_replaceHolders', './rest'], function(createWrapp
   var bind = rest(function(func, thisArg, partials) {
     var bitmask = BIND_FLAG;
     if (partials.length) {
-      var placeholder = bind.placeholder,
-          holders = replaceHolders(partials, placeholder);
-
+      var holders = replaceHolders(partials, getPlaceholder(bind));
       bitmask |= PARTIAL_FLAG;
     }
     return createWrapper(func, bitmask, thisArg, partials, holders);

bindAll.js

@@ -27,7 +27,7 @@ define(['./_arrayEach', './_baseFlatten', './bind', './rest'], function(arrayEac
    * // => 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,4 @@
-define(['./_createWrapper', './_replaceHolders', './rest'], function(createWrapper, replaceHolders, rest) {
+define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'], function(createWrapper, getPlaceholder, replaceHolders, rest) {
 
   /** Used to compose bitmasks for wrapper metadata. */
   var BIND_FLAG = 1,
@@ -52,9 +52,7 @@ define(['./_createWrapper', './_replaceHolders', './rest'], function(createWrapp
   var bindKey = rest(function(object, key, partials) {
     var bitmask = BIND_FLAG | BIND_KEY_FLAG;
     if (partials.length) {
-      var placeholder = bindKey.placeholder,
-          holders = replaceHolders(partials, placeholder);
-
+      var holders = replaceHolders(partials, getPlaceholder(bindKey));
       bitmask |= PARTIAL_FLAG;
     }
     return createWrapper(key, bitmask, object, partials, holders);

castArray.js

@@ -0,0 +1,44 @@
+define(['./isArray'], function(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];
+  }
+
+  return castArray;
+});

chunk.js

@@ -31,11 +31,11 @@ define(['./_baseSlice', './toInteger'], function(baseSlice, toInteger) {
       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;
   }

compact.js

@@ -17,13 +17,13 @@ define([], function() {
   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

@@ -25,7 +25,7 @@ define(['./_arrayConcat', './_baseFlatten', './isArray', './rest'], function(arr
     if (!isArray(array)) {
       array = array == null ? [] : [Object(array)];
     }
-    values = baseFlatten(values);
+    values = baseFlatten(values, 1);
     return arrayConcat(array, values);
   });
 

debounce.js

@@ -139,8 +139,10 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
         if (!lastCalled && !maxTimeoutId && !leading) {
           lastCalled = stamp;
         }
-        var remaining = maxWait - (stamp - lastCalled),
-            isCalled = remaining <= 0 || remaining > maxWait;
+        var remaining = maxWait - (stamp - lastCalled);
+
+        var isCalled = (remaining <= 0 || remaining > maxWait) &&
+          (leading || maxTimeoutId);
 
         if (isCalled) {
           if (maxTimeoutId) {

difference.js

@@ -3,7 +3,8 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './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 _
@@ -18,7 +19,7 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './rest'],
    */
   var difference = rest(function(array, values) {
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, false, true))
+      ? baseDifference(array, baseFlatten(values, 1, true))
       : [];
   });
 

differenceBy.js

@@ -6,7 +6,8 @@ define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLike
   /**
    * 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 _
@@ -30,7 +31,7 @@ define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLike
       iteratee = undefined;
     }
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, false, true), baseIteratee(iteratee))
+      ? baseDifference(array, baseFlatten(values, 1, true), baseIteratee(iteratee))
       : [];
   });
 

differenceWith.js

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

flatMap.js

@@ -21,7 +21,7 @@ define(['./_baseFlatten', './map'], function(baseFlatten, map) {
    * // => [1, 1, 2, 2]
    */
   function flatMap(collection, iteratee) {
-    return baseFlatten(map(collection, iteratee));
+    return baseFlatten(map(collection, iteratee), 1);
   }
 
   return flatMap;

flatten.js

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

flattenDeep.js

@@ -1,21 +1,24 @@
 define(['./_baseFlatten'], function(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]]]);
-   * // => [1, 2, 3, 4]
+   * _.flattenDeep([1, [2, [3, [4]], 5]]);
+   * // => [1, 2, 3, 4, 5]
    */
   function flattenDeep(array) {
     var length = array ? array.length : 0;
-    return length ? baseFlatten(array, true) : [];
+    return length ? baseFlatten(array, INFINITY) : [];
   }
 
   return flattenDeep;

flattenDepth.js

@@ -0,0 +1,35 @@
+define(['./_baseFlatten', './toInteger'], function(baseFlatten, toInteger) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * 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);
+  }
+
+  return flattenDepth;
+});

forEach.js

@@ -1,4 +1,4 @@
-define(['./_arrayEach', './_baseEach', './isArray', './_toFunction'], function(arrayEach, baseEach, isArray, toFunction) {
+define(['./_arrayEach', './_baseCastFunction', './_baseEach', './isArray'], function(arrayEach, baseCastFunction, baseEach, isArray) {
 
   /**
    * Iterates over elements of `collection` invoking `iteratee` for each element.
@@ -31,7 +31,7 @@ define(['./_arrayEach', './_baseEach', './isArray', './_toFunction'], function(a
   function forEach(collection, iteratee) {
     return (typeof iteratee == 'function' && isArray(collection))
       ? arrayEach(collection, iteratee)
-      : baseEach(collection, toFunction(iteratee));
+      : baseEach(collection, baseCastFunction(iteratee));
   }
 
   return forEach;

forEachRight.js

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

forIn.js

@@ -1,4 +1,4 @@
-define(['./_baseFor', './keysIn', './_toFunction'], function(baseFor, keysIn, toFunction) {
+define(['./_baseCastFunction', './_baseFor', './keysIn'], function(baseCastFunction, baseFor, keysIn) {
 
   /**
    * Iterates over own and inherited enumerable properties of an object invoking
@@ -27,7 +27,9 @@ define(['./_baseFor', './keysIn', './_toFunction'], function(baseFor, keysIn, to
    * // => 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);
   }
 
   return forIn;

forInRight.js

@@ -1,4 +1,4 @@
-define(['./_baseForRight', './keysIn', './_toFunction'], function(baseForRight, keysIn, toFunction) {
+define(['./_baseCastFunction', './_baseForRight', './keysIn'], function(baseCastFunction, baseForRight, keysIn) {
 
   /**
    * This method is like `_.forIn` except that it iterates over properties of
@@ -25,7 +25,9 @@ define(['./_baseForRight', './keysIn', './_toFunction'], function(baseForRight,
    * // => 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);
   }
 
   return forInRight;

forOwn.js

@@ -1,4 +1,4 @@
-define(['./_baseForOwn', './_toFunction'], function(baseForOwn, toFunction) {
+define(['./_baseCastFunction', './_baseForOwn'], function(baseCastFunction, baseForOwn) {
 
   /**
    * Iterates over own enumerable properties of an object invoking `iteratee`
@@ -27,7 +27,7 @@ define(['./_baseForOwn', './_toFunction'], function(baseForOwn, 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));
   }
 
   return forOwn;

forOwnRight.js

@@ -1,4 +1,4 @@
-define(['./_baseForOwnRight', './_toFunction'], function(baseForOwnRight, toFunction) {
+define(['./_baseCastFunction', './_baseForOwnRight'], function(baseCastFunction, baseForOwnRight) {
 
   /**
    * This method is like `_.forOwn` except that it iterates over properties of
@@ -25,7 +25,7 @@ define(['./_baseForOwnRight', './_toFunction'], function(baseForOwnRight, toFunc
    * // => logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'
    */
   function forOwnRight(object, iteratee) {
-    return object && baseForOwnRight(object, toFunction(iteratee));
+    return object && baseForOwnRight(object, baseCastFunction(iteratee));
   }
 
   return forOwnRight;

intersection.js

@@ -1,22 +1,23 @@
-define(['./_arrayMap', './_baseIntersection', './rest', './_toArrayLikeObject'], function(arrayMap, baseIntersection, rest, toArrayLikeObject) {
+define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, rest) {
 
   /**
    * Creates an array of unique values that are included in all 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 _
    * @category Array
    * @param {...Array} [arrays] The arrays to inspect.
-   * @returns {Array} Returns the new array of shared values.
+   * @returns {Array} Returns the new array of intersecting values.
    * @example
    *
    * _.intersection([2, 1], [4, 2], [1, 2]);
    * // => [2]
    */
   var intersection = rest(function(arrays) {
-    var mapped = arrayMap(arrays, toArrayLikeObject);
+    var mapped = arrayMap(arrays, baseCastArrayLikeObject);
     return (mapped.length && mapped[0] === arrays[0])
       ? baseIntersection(mapped)
       : [];

intersectionBy.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseIntersection', './_baseIteratee', './last', './rest', './_toArrayLikeObject'], function(arrayMap, baseIntersection, baseIteratee, last, rest, toArrayLikeObject) {
+define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './_baseIteratee', './last', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, baseIteratee, last, rest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -6,14 +6,15 @@ define(['./_arrayMap', './_baseIntersection', './_baseIteratee', './last', './re
   /**
    * This method is like `_.intersection` except that it accepts `iteratee`
    * which is invoked for each element of each `arrays` 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 _
    * @category Array
    * @param {...Array} [arrays] The arrays to inspect.
    * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
-   * @returns {Array} Returns the new array of shared values.
+   * @returns {Array} Returns the new array of intersecting values.
    * @example
    *
    * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
@@ -25,7 +26,7 @@ define(['./_arrayMap', './_baseIntersection', './_baseIteratee', './last', './re
    */
   var intersectionBy = rest(function(arrays) {
     var iteratee = last(arrays),
-        mapped = arrayMap(arrays, toArrayLikeObject);
+        mapped = arrayMap(arrays, baseCastArrayLikeObject);
 
     if (iteratee === last(mapped)) {
       iteratee = undefined;

intersectionWith.js

@@ -1,19 +1,20 @@
-define(['./_arrayMap', './_baseIntersection', './last', './rest', './_toArrayLikeObject'], function(arrayMap, baseIntersection, last, rest, toArrayLikeObject) {
+define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './last', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, last, rest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
   /**
    * This method is like `_.intersection` except that it accepts `comparator`
-   * which is invoked to compare elements of `arrays`. The comparator is invoked
-   * with two arguments: (arrVal, othVal).
+   * which is invoked to compare elements of `arrays`. Result values are chosen
+   * from the first array. The comparator is invoked with two arguments:
+   * (arrVal, othVal).
    *
    * @static
    * @memberOf _
    * @category Array
    * @param {...Array} [arrays] The arrays to inspect.
    * @param {Function} [comparator] The comparator invoked per element.
-   * @returns {Array} Returns the new array of shared values.
+   * @returns {Array} Returns the new array of intersecting values.
    * @example
    *
    * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
@@ -24,7 +25,7 @@ define(['./_arrayMap', './_baseIntersection', './last', './rest', './_toArrayLik
    */
   var intersectionWith = rest(function(arrays) {
     var comparator = last(arrays),
-        mapped = arrayMap(arrays, toArrayLikeObject);
+        mapped = arrayMap(arrays, baseCastArrayLikeObject);
 
     if (comparator === last(mapped)) {
       comparator = undefined;

isArray.js

@@ -5,7 +5,7 @@ define([], function() {
    *
    * @static
    * @memberOf _
-   * @type Function
+   * @type {Function}
    * @category Lang
    * @param {*} value The value to check.
    * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.

isArrayBuffer.js

@@ -16,7 +16,6 @@ define(['./isObjectLike'], function(isObjectLike) {
    *
    * @static
    * @memberOf _
-   * @type Function
    * @category Lang
    * @param {*} value The value to check.
    * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.