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

@@ -1,4 +1,4 @@
-define(['./root'], function(root) {
+define(['./_root'], function(root) {
 
   /** Built-in value references. */
   var Symbol = root.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');

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

_arrayIncludes.js

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

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

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

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

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

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

_baseIntersection.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 a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -40,11 +40,17 @@ define(['./SetCache', './arrayIncludes', './arrayIncludesWith', './arrayMap', '.
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
-      if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
+      if (!(seen
+            ? cacheHas(seen, computed)
+            : includes(result, computed, comparator)
+          )) {
         var 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;
@@ -15,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;

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

_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;
@@ -17,7 +17,10 @@ define(['./Stack', './arrayEach', './assignMergeValue', './baseMergeDeep', '../i
     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', '../i
         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

@@ -1,4 +1,4 @@
-define(['./assignMergeValue', './baseClone', './copyArray', '../isArguments', '../isArray', '../isArrayLikeObject', '../isFunction', '../isObject', '../isPlainObject', '../isTypedArray', '../toPlainObject'], function(assignMergeValue, baseClone, copyArray, isArguments, isArray, isArrayLikeObject, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
+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;
@@ -20,26 +20,30 @@ define(['./assignMergeValue', './baseClone', './copyArray', '../isArguments', '.
   function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
     var objValue = object[key],
         srcValue = source[key],
-        stacked = stack.get(srcValue) || stack.get(objValue);
+        stacked = stack.get(srcValue);
 
     if (stacked) {
       assignMergeValue(object, key, stacked);
       return;
     }
-    var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined,
+    var newValue = customizer
-        isCommon = newValue === undefined;
+      ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+      : undefined;
+
+    var isCommon = newValue === undefined;
 
     if (isCommon) {
       newValue = srcValue;
       if (isArray(srcValue) || isTypedArray(srcValue)) {
         if (isArray(objValue)) {
-          newValue = srcIndex ? copyArray(objValue) : objValue;
+          newValue = objValue;
         }
         else if (isArrayLikeObject(objValue)) {
           newValue = copyArray(objValue);
         }
         else {
-          newValue = baseClone(srcValue);
+          isCommon = false;
+          newValue = baseClone(srcValue, true);
         }
       }
       else if (isPlainObject(srcValue) || isArguments(srcValue)) {
@@ -47,10 +51,11 @@ define(['./assignMergeValue', './baseClone', './copyArray', '../isArguments', '.
           newValue = toPlainObject(objValue);
         }
         else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
-          newValue = baseClone(srcValue);
+          isCommon = false;
+          newValue = baseClone(srcValue, true);
         }
         else {
-          newValue = srcIndex ? baseClone(objValue) : objValue;
+          newValue = objValue;
         }
       }
       else {

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

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

_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(['./basePullAllBy'], function(basePullAllBy) {
+define(['./_basePullAllBy'], function(basePullAllBy) {
 
   /**
    * The base implementation of `_.pullAll`.

_basePullAllBy.js

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

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

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