Bump to v4.6.0.

LICENSE

@@ -1,22 +1,23 @@
+The MIT License (MIT)
+
 Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
 Based on Underscore.js, copyright 2009-2016 Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
 
-Permission is hereby granted, free of charge, to any person obtaining
+Permission is hereby granted, free of charge, to any person obtaining a copy
-a copy of this software and associated documentation files (the
+of this software and associated documentation files (the "Software"), to deal
-"Software"), to deal in the Software without restriction, including
+in the Software without restriction, including without limitation the rights
-without limitation the rights to use, copy, modify, merge, publish,
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-distribute, sublicense, and/or sell copies of the Software, and to
+copies of the Software, and to permit persons to whom the Software is
-permit persons to whom the Software is furnished to do so, subject to
+furnished to do so, subject to the following conditions:
-the following conditions:
 
-The above copyright notice and this permission notice shall be
+The above copyright notice and this permission notice shall be included in all
-included in all copies or substantial portions of the Software.
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE.

README.md

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

_Hash.js

@@ -1,4 +1,4 @@
-define(['./nativeCreate'], function(nativeCreate) {
+define(['./_nativeCreate'], function(nativeCreate) {
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -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

@@ -1,4 +1,4 @@
-define(['./baseCreate', './baseLodash'], function(baseCreate, baseLodash) {
+define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
 
   /** Used as references for the maximum length and index of an array. */
   var MAX_ARRAY_LENGTH = 4294967295;
@@ -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) {

_LodashWrapper.js

@@ -1,4 +1,4 @@
-define(['./baseCreate', './baseLodash'], function(baseCreate, baseLodash) {
+define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_Map.js

@@ -1,4 +1,4 @@
-define(['./getNative', './root'], function(getNative, root) {
+define(['./_getNative', './_root'], function(getNative, root) {
 
   /* Built-in method references that are verified to be native. */
   var Map = getNative(root, 'Map');

_MapCache.js

@@ -1,9 +1,10 @@
-define(['./mapClear', './mapDelete', './mapGet', './mapHas', './mapSet'], function(mapClear, mapDelete, mapGet, mapHas, mapSet) {
+define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], function(mapClear, mapDelete, mapGet, mapHas, mapSet) {
 
   /**
    * Creates a map cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function MapCache(values) {

_Reflect.js

@@ -1,4 +1,4 @@
-define(['./root'], function(root) {
+define(['./_root'], function(root) {
 
   /** Built-in value references. */
   var Reflect = root.Reflect;

_Set.js

@@ -1,4 +1,4 @@
-define(['./getNative', './root'], function(getNative, root) {
+define(['./_getNative', './_root'], function(getNative, root) {
 
   /* Built-in method references that are verified to be native. */
   var Set = getNative(root, 'Set');

_SetCache.js

@@ -1,10 +1,11 @@
-define(['./MapCache', './cachePush'], function(MapCache, cachePush) {
+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

@@ -1,9 +1,10 @@
-define(['./stackClear', './stackDelete', './stackGet', './stackHas', './stackSet'], function(stackClear, stackDelete, stackGet, stackHas, stackSet) {
+define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_stackSet'], function(stackClear, stackDelete, stackGet, stackHas, stackSet) {
 
   /**
    * Creates a stack cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function Stack(values) {

_Symbol.js

@@ -0,0 +1,7 @@
+define(['./_root'], function(root) {
+
+  /** Built-in value references. */
+  var Symbol = root.Symbol;
+
+  return Symbol;
+});

_Uint8Array.js

@@ -1,4 +1,4 @@
-define(['./root'], function(root) {
+define(['./_root'], function(root) {
 
   /** Built-in value references. */
   var Uint8Array = root.Uint8Array;

_WeakMap.js

@@ -1,4 +1,4 @@
-define(['./getNative', './root'], function(getNative, root) {
+define(['./_getNative', './_root'], function(getNative, root) {
 
   /* Built-in method references that are verified to be native. */
   var WeakMap = getNative(root, 'WeakMap');

_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;
   }

_apply.js

@@ -7,11 +7,11 @@ define([], function() {
    * @private
    * @param {Function} func The function to invoke.
    * @param {*} thisArg The `this` binding of `func`.
-   * @param {...*} [args] The arguments to invoke `func` with.
+   * @param {...*} args The arguments to invoke `func` with.
    * @returns {*} Returns the result of `func`.
    */
   function apply(func, thisArg, args) {
-    var length = args ? args.length : 0;
+    var length = args.length;
     switch (length) {
       case 0: return func.call(thisArg);
       case 1: return func.call(thisArg, args[0]);

_arrayAggregator.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /**
+   * A specialized version of `baseAggregator` for arrays.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform keys.
+   * @param {Object} accumulator The initial aggregated object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function arrayAggregator(array, setter, iteratee, accumulator) {
+    var index = -1,
+        length = array.length;
+
+    while (++index < length) {
+      var value = array[index];
+      setter(accumulator, value, iteratee(value), array);
+    }
+    return accumulator;
+  }
+
+  return arrayAggregator;
+});

_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;

_arrayIncludes.js

@@ -1,4 +1,4 @@
-define(['./baseIndexOf'], function(baseIndexOf) {
+define(['./_baseIndexOf'], function(baseIndexOf) {
 
   /**
    * A specialized version of `_.includes` for arrays without support for

_arrayIncludesWith.js

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

_arrayReduce.js

@@ -8,14 +8,14 @@ define([], function() {
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initFromArray] Specify using the first element of `array` as the initial value.
+   * @param {boolean} [initAccum] Specify using the first element of `array` as the initial value.
    * @returns {*} Returns the accumulated value.
    */
-  function arrayReduce(array, iteratee, accumulator, initFromArray) {
+  function arrayReduce(array, iteratee, accumulator, initAccum) {
     var index = -1,
         length = array.length;
 
-    if (initFromArray && length) {
+    if (initAccum && length) {
       accumulator = array[++index];
     }
     while (++index < length) {

_arrayReduceRight.js

@@ -8,12 +8,12 @@ define([], function() {
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initFromArray] Specify using the last element of `array` as the initial value.
+   * @param {boolean} [initAccum] Specify using the last element of `array` as the initial value.
    * @returns {*} Returns the accumulated value.
    */
-  function arrayReduceRight(array, iteratee, accumulator, initFromArray) {
+  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
     var length = array.length;
-    if (initFromArray && length) {
+    if (initAccum && length) {
       accumulator = array[--length];
     }
     while (length--) {

_assignInDefaults.js

@@ -1,4 +1,4 @@
-define(['../eq'], function(eq) {
+define(['./eq'], function(eq) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_assignMergeValue.js

@@ -1,10 +1,11 @@
-define(['../eq'], function(eq) {
+define(['./eq'], function(eq) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   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

@@ -1,4 +1,4 @@
-define(['../eq'], function(eq) {
+define(['./eq'], function(eq) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -21,8 +21,7 @@ define(['../eq'], function(eq) {
    */
   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;
     }

_assocDelete.js

@@ -1,4 +1,4 @@
-define(['./assocIndexOf'], function(assocIndexOf) {
+define(['./_assocIndexOf'], function(assocIndexOf) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;

_assocGet.js

@@ -1,4 +1,4 @@
-define(['./assocIndexOf'], function(assocIndexOf) {
+define(['./_assocIndexOf'], function(assocIndexOf) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_assocHas.js

@@ -1,4 +1,4 @@
-define(['./assocIndexOf'], function(assocIndexOf) {
+define(['./_assocIndexOf'], function(assocIndexOf) {
 
   /**
    * Checks if an associative array value for `key` exists.

_assocIndexOf.js

@@ -1,4 +1,4 @@
-define(['../eq'], function(eq) {
+define(['./eq'], function(eq) {
 
   /**
    * Gets the index at which the first occurrence of `key` is found in `array`

_assocSet.js

@@ -1,4 +1,4 @@
-define(['./assocIndexOf'], function(assocIndexOf) {
+define(['./_assocIndexOf'], function(assocIndexOf) {
 
   /**
    * Sets the associative array `key` to `value`.

_baseAggregator.js

@@ -0,0 +1,22 @@
+define(['./_baseEach'], function(baseEach) {
+
+  /**
+   * Aggregates elements of `collection` on `accumulator` with keys transformed
+   * by `iteratee` and values set by `setter`.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform keys.
+   * @param {Object} accumulator The initial aggregated object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function baseAggregator(collection, setter, iteratee, accumulator) {
+    baseEach(collection, function(value, key, collection) {
+      setter(accumulator, value, iteratee(value), collection);
+    });
+    return accumulator;
+  }
+
+  return baseAggregator;
+});

_baseAssign.js

@@ -1,4 +1,4 @@
-define(['./copyObject', '../keys'], function(copyObject, keys) {
+define(['./_copyObject', './keys'], function(copyObject, keys) {
 
   /**
    * The base implementation of `_.assign` without support for multiple sources

_baseAt.js

@@ -1,4 +1,4 @@
-define(['../get'], function(get) {
+define(['./get'], function(get) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseCastArrayLikeObject.js

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

@@ -1,4 +1,4 @@
-define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn', './copyArray', './copySymbols', './getTag', './initCloneArray', './initCloneByTag', './initCloneObject', '../isArray', './isHostObject', '../isObject'], function(Stack, arrayEach, assignValue, baseAssign, baseForOwn, copyArray, copySymbols, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isHostObject, isObject) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseForOwn', './_cloneBuffer', './_copyArray', './_copySymbols', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './_isHostObject', './isObject'], function(Stack, arrayEach, assignValue, baseAssign, baseForOwn, cloneBuffer, copyArray, copySymbols, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isHostObject, isObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -81,6 +81,9 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
       var tag = getTag(value),
           isFunc = tag == funcTag || tag == genTag;
 
+      if (isBuffer(value)) {
+        return cloneBuffer(value, isDeep);
+      }
       if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
         if (isHostObject(value)) {
           return object ? value : {};
@@ -90,9 +93,10 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
           return copySymbols(value, baseAssign(result, value));
         }
       } 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.

_baseConforms.js

@@ -1,4 +1,4 @@
-define(['../keys'], function(keys) {
+define(['./keys'], function(keys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseCreate.js

@@ -0,0 +1,19 @@
+define(['./isObject'], function(isObject) {
+
+  /** Built-in value references. */
+  var objectCreate = Object.create;
+
+  /**
+   * The base implementation of `_.create` without support for assigning
+   * properties to the created object.
+   *
+   * @private
+   * @param {Object} prototype The object to inherit from.
+   * @returns {Object} Returns the new object.
+   */
+  function baseCreate(proto) {
+    return isObject(proto) ? objectCreate(proto) : {};
+  }
+
+  return baseCreate;
+});

_baseDelay.js

@@ -13,7 +13,7 @@ define([], function() {
    * @private
    * @param {Function} func The function to delay.
    * @param {number} wait The number of milliseconds to delay invocation.
-   * @param {Object} args The arguments provide to `func`.
+   * @param {Object} args The arguments to provide to `func`.
    * @returns {number} Returns the timer id.
    */
   function baseDelay(func, wait, args) {

_baseDifference.js

@@ -1,4 +1,4 @@
-define(['./SetCache', './arrayIncludes', './arrayIncludesWith', './arrayMap', './baseUnary', './cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
+define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap', './_baseUnary', './_cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
 
   /** Used as the size to enable large array optimizations. */
   var LARGE_ARRAY_SIZE = 200;

_baseEach.js

@@ -1,4 +1,4 @@
-define(['./baseForOwn', './createBaseEach'], function(baseForOwn, createBaseEach) {
+define(['./_baseForOwn', './_createBaseEach'], function(baseForOwn, createBaseEach) {
 
   /**
    * The base implementation of `_.forEach` without support for iteratee shorthands.

_baseEachRight.js

@@ -1,4 +1,4 @@
-define(['./baseForOwnRight', './createBaseEach'], function(baseForOwnRight, createBaseEach) {
+define(['./_baseForOwnRight', './_createBaseEach'], function(baseForOwnRight, createBaseEach) {
 
   /**
    * The base implementation of `_.forEachRight` without support for iteratee shorthands.

_baseEvery.js

@@ -1,4 +1,4 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
    * The base implementation of `_.every` without support for iteratee shorthands.

_baseFill.js

@@ -1,4 +1,4 @@
-define(['../toInteger', '../toLength'], function(toInteger, toLength) {
+define(['./toInteger', './toLength'], function(toInteger, toLength) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseFilter.js

@@ -1,4 +1,4 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
    * The base implementation of `_.filter` without support for iteratee shorthands.

_baseFind.js

@@ -3,7 +3,7 @@ define([], function() {
   /**
    * The base implementation of methods like `_.find` and `_.findKey`, without
    * support for iteratee shorthands, which iterates over `collection` using
-   * the provided `eachFunc`.
+   * `eachFunc`.
    *
    * @private
    * @param {Array|Object} collection The collection to search.

_baseFlatten.js

@@ -1,16 +1,16 @@
-define(['./arrayPush', '../isArguments', '../isArray', '../isArrayLikeObject'], function(arrayPush, isArguments, isArray, isArrayLikeObject) {
+define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], function(arrayPush, isArguments, isArray, isArrayLikeObject) {
 
   /**
    * The base implementation of `_.flatten` with support for restricting flattening.
    *
    * @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'],
 
     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);
         }

_baseFor.js

@@ -1,4 +1,4 @@
-define(['./createBaseFor'], function(createBaseFor) {
+define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
    * The base implementation of `baseForIn` and `baseForOwn` which iterates

_baseForIn.js

@@ -1,4 +1,4 @@
-define(['./baseFor', '../keysIn'], function(baseFor, keysIn) {
+define(['./_baseFor', './keysIn'], function(baseFor, keysIn) {
 
   /**
    * The base implementation of `_.forIn` without support for iteratee shorthands.

_baseForOwn.js

@@ -1,4 +1,4 @@
-define(['./baseFor', '../keys'], function(baseFor, keys) {
+define(['./_baseFor', './keys'], function(baseFor, keys) {
 
   /**
    * The base implementation of `_.forOwn` without support for iteratee shorthands.

_baseForOwnRight.js

@@ -1,4 +1,4 @@
-define(['./baseForRight', '../keys'], function(baseForRight, keys) {
+define(['./_baseForRight', './keys'], function(baseForRight, keys) {
 
   /**
    * The base implementation of `_.forOwnRight` without support for iteratee shorthands.

_baseForRight.js

@@ -1,4 +1,4 @@
-define(['./createBaseFor'], function(createBaseFor) {
+define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
    * This function is like `baseFor` except that it iterates over properties

_baseFunctions.js

@@ -1,8 +1,8 @@
-define(['./arrayFilter', '../isFunction'], function(arrayFilter, isFunction) {
+define(['./_arrayFilter', './isFunction'], function(arrayFilter, isFunction) {
 
   /**
    * The base implementation of `_.functions` which creates an array of
-   * `object` function property names filtered from those provided.
+   * `object` function property names filtered from `props`.
    *
    * @private
    * @param {Object} object The object to inspect.

_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;

_baseIndexOf.js

@@ -1,4 +1,4 @@
-define(['./indexOfNaN'], function(indexOfNaN) {
+define(['./_indexOfNaN'], function(indexOfNaN) {
 
   /**
    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.

_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

@@ -1,8 +1,11 @@
-define(['./SetCache', './arrayIncludes', './arrayIncludesWith', './arrayMap', './baseUnary', './cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
+define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap', './_baseUnary', './_cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
 
   /** 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))) {
+      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;
           }
         }

_baseInverter.js

@@ -0,0 +1,22 @@
+define(['./_baseForOwn'], function(baseForOwn) {
+
+  /**
+   * The base implementation of `_.invert` and `_.invertBy` which inverts
+   * `object` with values transformed by `iteratee` and set by `setter`.
+   *
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform values.
+   * @param {Object} accumulator The initial inverted object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function baseInverter(object, setter, iteratee, accumulator) {
+    baseForOwn(object, function(value, key, object) {
+      setter(accumulator, iteratee(value), key, object);
+    });
+    return accumulator;
+  }
+
+  return baseInverter;
+});

_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;
@@ -7,7 +7,6 @@ define(['./apply', './baseToPath', './isKey', '../last', './parent'], function(a
    * The base implementation of `_.invoke` without support for individual
    * method arguments.
    *
-   *
    * @private
    * @param {Object} object The object to query.
    * @param {Array|string} path The path of the method to invoke.
@@ -16,7 +15,7 @@ define(['./apply', './baseToPath', './isKey', '../last', './parent'], function(a
    */
   function baseInvoke(object, path, args) {
     if (!isKey(path, object)) {
-      path = baseToPath(path);
+      path = baseCastPath(path);
       object = parent(object, path);
       path = last(path);
     }

_baseIsEqual.js

@@ -1,4 +1,4 @@
-define(['./baseIsEqualDeep', '../isObject', '../isObjectLike'], function(baseIsEqualDeep, isObject, isObjectLike) {
+define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEqualDeep, isObject, isObjectLike) {
 
   /**
    * The base implementation of `_.isEqual` which supports partial comparisons

_baseIsEqualDeep.js

@@ -1,4 +1,4 @@
-define(['./Stack', './equalArrays', './equalByTag', './equalObjects', './getTag', '../isArray', './isHostObject', '../isTypedArray'], function(Stack, equalArrays, equalByTag, equalObjects, getTag, isArray, isHostObject, isTypedArray) {
+define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_getTag', './isArray', './_isHostObject', './isTypedArray'], function(Stack, equalArrays, equalByTag, equalObjects, getTag, isArray, isHostObject, isTypedArray) {
 
   /** Used to compose bitmasks for comparison styles. */
   var PARTIAL_COMPARE_FLAG = 2;
@@ -36,33 +36,28 @@ define(['./Stack', './equalArrays', './equalByTag', './equalObjects', './getTag'
 
     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);
       }
     }
@@ -70,7 +65,7 @@ define(['./Stack', './equalArrays', './equalByTag', './equalObjects', './getTag'
       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;

_baseIsMatch.js

@@ -1,4 +1,4 @@
-define(['./Stack', './baseIsEqual'], function(Stack, baseIsEqual) {
+define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -49,7 +49,10 @@ define(['./Stack', './baseIsEqual'], function(Stack, baseIsEqual) {
         var stack = new Stack,
             result = customizer ? customizer(objValue, srcValue, key, object, source, stack) : undefined;
 
-        if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {
+        if (!(result === undefined
+              ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+              : result
+            )) {
           return false;
         }
       }

_baseIteratee.js

@@ -1,4 +1,4 @@
-define(['./baseMatches', './baseMatchesProperty', '../identity', '../isArray', '../property'], function(baseMatches, baseMatchesProperty, identity, isArray, property) {
+define(['./_baseMatches', './_baseMatchesProperty', './identity', './isArray', './property'], function(baseMatches, baseMatchesProperty, identity, isArray, property) {
 
   /**
    * The base implementation of `_.iteratee`.

_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.
    */

_baseKeysIn.js

@@ -1,4 +1,4 @@
-define(['./Reflect', './iteratorToArray'], function(Reflect, iteratorToArray) {
+define(['./_Reflect', './_iteratorToArray'], function(Reflect, iteratorToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseMap.js

@@ -1,4 +1,4 @@
-define(['./baseEach', '../isArrayLike'], function(baseEach, isArrayLike) {
+define(['./_baseEach', './isArrayLike'], function(baseEach, isArrayLike) {
 
   /**
    * The base implementation of `_.map` without support for iteratee shorthands.

_baseMatches.js

@@ -1,4 +1,4 @@
-define(['./baseIsMatch', './getMatchData'], function(baseIsMatch, getMatchData) {
+define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseMatchesProperty.js

@@ -1,4 +1,4 @@
-define(['./baseIsEqual', '../get', '../hasIn'], function(baseIsEqual, get, hasIn) {
+define(['./_baseIsEqual', './get', './hasIn'], function(baseIsEqual, get, hasIn) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;

_baseMerge.js

@@ -1,4 +1,4 @@
-define(['./Stack', './arrayEach', './assignMergeValue', './baseMergeDeep', '../isArray', '../isObject', '../isTypedArray', '../keysIn'], function(Stack, arrayEach, assignMergeValue, baseMergeDeep, isArray, isObject, isTypedArray, keysIn) {
+define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', './isArray', './isObject', './isTypedArray', './keysIn'], function(Stack, arrayEach, assignMergeValue, baseMergeDeep, isArray, isObject, isTypedArray, keysIn) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -9,14 +9,18 @@ define(['./Stack', './arrayEach', './assignMergeValue', './baseMergeDeep', '../i
    * @private
    * @param {Object} object The destination object.
    * @param {Object} source The source object.
+   * @param {number} srcIndex The index of `source`.
    * @param {Function} [customizer] The function to customize merged values.
    * @param {Object} [stack] Tracks traversed source values and their merged counterparts.
    */
-  function baseMerge(object, source, customizer, stack) {
+  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;
@@ -24,10 +28,13 @@ define(['./Stack', './arrayEach', './assignMergeValue', './baseMergeDeep', '../i
       }
       if (isObject(srcValue)) {
         stack || (stack = new Stack);
-        baseMergeDeep(object, source, key, baseMerge, 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

@@ -0,0 +1,76 @@
+define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments', './isArray', './isArrayLikeObject', './isFunction', './isObject', './isPlainObject', './isTypedArray', './toPlainObject'], function(assignMergeValue, baseClone, copyArray, isArguments, isArray, isArrayLikeObject, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * A specialized version of `baseMerge` for arrays and objects which performs
+   * deep merges and tracks traversed objects enabling objects with circular
+   * references to be merged.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @param {string} key The key of the value to merge.
+   * @param {number} srcIndex The index of `source`.
+   * @param {Function} mergeFunc The function to merge values.
+   * @param {Function} [customizer] The function to customize assigned values.
+   * @param {Object} [stack] Tracks traversed source values and their merged counterparts.
+   */
+  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+    var objValue = object[key],
+        srcValue = source[key],
+        stacked = stack.get(srcValue);
+
+    if (stacked) {
+      assignMergeValue(object, key, stacked);
+      return;
+    }
+    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 = objValue;
+        }
+        else if (isArrayLikeObject(objValue)) {
+          newValue = copyArray(objValue);
+        }
+        else {
+          isCommon = false;
+          newValue = baseClone(srcValue, !customizer);
+        }
+      }
+      else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+        if (isArguments(objValue)) {
+          newValue = toPlainObject(objValue);
+        }
+        else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+          isCommon = false;
+          newValue = baseClone(srcValue, !customizer);
+        }
+        else {
+          newValue = objValue;
+        }
+      }
+      else {
+        isCommon = false;
+      }
+    }
+    stack.set(srcValue, newValue);
+
+    if (isCommon) {
+      // Recursively merge objects and arrays (susceptible to call stack limits).
+      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    }
+    stack['delete'](srcValue);
+    assignMergeValue(object, key, newValue);
+  }
+
+  return baseMergeDeep;
+});

_baseOrderBy.js

@@ -1,4 +1,4 @@
-define(['./arrayMap', './baseIteratee', './baseMap', './baseSortBy', './compareMultiple'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple) {
+define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_compareMultiple'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple) {
 
   /**
    * The base implementation of `_.orderBy` without param guards.
@@ -10,12 +10,8 @@ define(['./arrayMap', './baseIteratee', './baseMap', './baseSortBy', './compareM
    * @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) {

_basePick.js

@@ -1,4 +1,4 @@
-define(['./arrayReduce'], function(arrayReduce) {
+define(['./_arrayReduce'], function(arrayReduce) {
 
   /**
    * The base implementation of `_.pick` without support for individual

_basePickBy.js

@@ -1,4 +1,4 @@
-define(['./baseForIn'], function(baseForIn) {
+define(['./_baseForIn'], function(baseForIn) {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
@@ -11,7 +11,7 @@ define(['./baseForIn'], function(baseForIn) {
   function basePickBy(object, predicate) {
     var result = {};
     baseForIn(object, function(value, key) {
-      if (predicate(value)) {
+      if (predicate(value, key)) {
         result[key] = value;
       }
     });

_basePropertyDeep.js

@@ -1,4 +1,4 @@
-define(['./baseGet'], function(baseGet) {
+define(['./_baseGet'], function(baseGet) {
 
   /**
    * A specialized version of `baseProperty` which supports deep paths.

_basePullAll.js

@@ -1,4 +1,4 @@
-define(['./arrayMap', './baseIndexOf'], function(arrayMap, baseIndexOf) {
+define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary'], function(arrayMap, baseIndexOf, baseIndexOfWith, baseUnary) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -14,22 +14,24 @@ define(['./arrayMap', './baseIndexOf'], function(arrayMap, baseIndexOf) {
    * @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 basePullAllBy(array, values, iteratee) {
+  function basePullAll(array, values, iteratee, comparator) {
-    var index = -1,
+    var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
+        index = -1,
         length = values.length,
         seen = array;
 
     if (iteratee) {
-      seen = arrayMap(array, function(value) { return iteratee(value); });
+      seen = arrayMap(array, baseUnary(iteratee));
     }
     while (++index < length) {
       var fromIndex = 0,
           value = values[index],
           computed = iteratee ? iteratee(value) : value;
 
-      while ((fromIndex = baseIndexOf(seen, computed, fromIndex)) > -1) {
+      while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
         if (seen !== array) {
           splice.call(seen, fromIndex, 1);
         }
@@ -39,5 +41,5 @@ define(['./arrayMap', './baseIndexOf'], function(arrayMap, baseIndexOf) {
     return array;
   }
 
-  return basePullAllBy;
+  return basePullAll;
 });

_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'], function
           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) {

_baseReduce.js

@@ -2,21 +2,20 @@ define([], function() {
 
   /**
    * The base implementation of `_.reduce` and `_.reduceRight`, without support
-   * for iteratee shorthands, which iterates over `collection` using the provided
+   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
-   * `eachFunc`.
    *
    * @private
    * @param {Array|Object} collection The collection to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} accumulator The initial value.
-   * @param {boolean} initFromCollection Specify using the first or last element of `collection` as the initial value.
+   * @param {boolean} initAccum Specify using the first or last element of `collection` as the initial value.
    * @param {Function} eachFunc The function to iterate over `collection`.
    * @returns {*} Returns the accumulated value.
    */
-  function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) {
+  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
     eachFunc(collection, function(value, index, collection) {
-      accumulator = initFromCollection
+      accumulator = initAccum
-        ? (initFromCollection = false, value)
+        ? (initAccum = false, value)
         : iteratee(accumulator, value, index, collection);
     });
     return accumulator;

_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);

_baseSetData.js

@@ -1,4 +1,4 @@
-define(['../identity', './metaMap'], function(identity, metaMap) {
+define(['./identity', './_metaMap'], function(identity, metaMap) {
 
   /**
    * The base implementation of `setData` without support for hot loop detection.

_baseSome.js

@@ -1,4 +1,4 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
    * The base implementation of `_.some` without support for iteratee shorthands.