Bump to v4.14.2.

LICENSE

@@ -1,7 +1,17 @@
-Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
-Based on Underscore.js, copyright 2009-2016 Jeremy Ashkenas,
+Copyright jQuery Foundation and other contributors <https://jquery.org/>
+
+Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
 
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/lodash/lodash
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
@@ -20,3 +30,18 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+====
+
+Copyright and related rights for sample code are waived via CC0. Sample
+code is defined as all source code displayed within the prose of the
+documentation.
+
+CC0: http://creativecommons.org/publicdomain/zero/1.0/
+
+====
+
+Files located in the node_modules and vendor directories are externally
+maintained libraries used by this software which have their own
+licenses; we recommend you read them, as their terms may differ from the
+terms above.

README.md

@@ -1,6 +1,6 @@
-# lodash-amd v4.0.1
+# lodash-amd v4.14.2
 
-The [lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
+The [Lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
 Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
 ```bash
@@ -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.14.2-amd) for more details.

_DataView.js

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

_Hash.js

@@ -0,0 +1,29 @@
+define(['./_hashClear', './_hashDelete', './_hashGet', './_hashHas', './_hashSet'], function(hashClear, hashDelete, hashGet, hashHas, hashSet) {
+
+  /**
+   * Creates a hash object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Hash(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `Hash`.
+  Hash.prototype.clear = hashClear;
+  Hash.prototype['delete'] = hashDelete;
+  Hash.prototype.get = hashGet;
+  Hash.prototype.has = hashHas;
+  Hash.prototype.set = hashSet;
+
+  return 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) {
@@ -19,6 +20,7 @@ define(['./baseCreate', './baseLodash'], function(baseCreate, baseLodash) {
     this.__views__ = [];
   }
 
+  // Ensure `LazyWrapper` is an instance of `baseLodash`.
   LazyWrapper.prototype = baseCreate(baseLodash.prototype);
   LazyWrapper.prototype.constructor = LazyWrapper;
 

_ListCache.js

@@ -0,0 +1,29 @@
+define(['./_listCacheClear', './_listCacheDelete', './_listCacheGet', './_listCacheHas', './_listCacheSet'], function(listCacheClear, listCacheDelete, listCacheGet, listCacheHas, listCacheSet) {
+
+  /**
+   * Creates an list cache object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function ListCache(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `ListCache`.
+  ListCache.prototype.clear = listCacheClear;
+  ListCache.prototype['delete'] = listCacheDelete;
+  ListCache.prototype.get = listCacheGet;
+  ListCache.prototype.has = listCacheHas;
+  ListCache.prototype.set = listCacheSet;
+
+  return ListCache;
+});

_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;
@@ -8,7 +8,7 @@ define(['./baseCreate', './baseLodash'], function(baseCreate, baseLodash) {
    *
    * @private
    * @param {*} value The value to wrap.
-   * @param {boolean} [chainAll] Enable chaining for all wrapper methods.
+   * @param {boolean} [chainAll] Enable explicit method chain sequences.
    */
   function LodashWrapper(value, chainAll) {
     this.__wrapped__ = value;

_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

@@ -0,0 +1,29 @@
+define(['./_mapCacheClear', './_mapCacheDelete', './_mapCacheGet', './_mapCacheHas', './_mapCacheSet'], function(mapCacheClear, mapCacheDelete, mapCacheGet, mapCacheHas, mapCacheSet) {
+
+  /**
+   * Creates a map cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function MapCache(entries) {
+    var index = -1,
+        length = entries ? entries.length : 0;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `MapCache`.
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype['delete'] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
+
+  return MapCache;
+});

_Promise.js

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

_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

@@ -0,0 +1,26 @@
+define(['./_MapCache', './_setCacheAdd', './_setCacheHas'], function(MapCache, setCacheAdd, setCacheHas) {
+
+  /**
+   *
+   * Creates an array cache object to store unique values.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [values] The values to cache.
+   */
+  function SetCache(values) {
+    var index = -1,
+        length = values ? values.length : 0;
+
+    this.__data__ = new MapCache;
+    while (++index < length) {
+      this.add(values[index]);
+    }
+  }
+
+  // Add methods to `SetCache`.
+  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+  SetCache.prototype.has = setCacheHas;
+
+  return SetCache;
+});

_Stack.js

@@ -0,0 +1,22 @@
+define(['./_ListCache', './_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_stackSet'], function(ListCache, stackClear, stackDelete, stackGet, stackHas, stackSet) {
+
+  /**
+   * Creates a stack cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Stack(entries) {
+    this.__data__ = new ListCache(entries);
+  }
+
+  // Add methods to `Stack`.
+  Stack.prototype.clear = stackClear;
+  Stack.prototype['delete'] = stackDelete;
+  Stack.prototype.get = stackGet;
+  Stack.prototype.has = stackHas;
+  Stack.prototype.set = stackSet;
+
+  return Stack;
+});

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

_addMapEntry.js

@@ -9,6 +9,7 @@ define([], function() {
    * @returns {Object} Returns `map`.
    */
   function addMapEntry(map, pair) {
+    // Don't return `map.set` because it's not chainable in IE 11.
     map.set(pair[0], pair[1]);
     return map;
   }

_addSetEntry.js

@@ -9,6 +9,7 @@ define([], function() {
    * @returns {Object} Returns `set`.
    */
   function addSetEntry(set, value) {
+    // Don't return `set.add` because it's not chainable in IE 11.
     set.add(value);
     return set;
   }

_apply.js

@@ -7,12 +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 {Array} args The arguments to invoke `func` with.
    * @returns {*} Returns the result of `func`.
    */
   function apply(func, thisArg, args) {
-    var length = args ? args.length : 0;
-    switch (length) {
+    switch (args.length) {
       case 0: return func.call(thisArg);
       case 1: return func.call(thisArg, args[0]);
       case 2: return func.call(thisArg, args[0], args[1]);

_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 ? array.length : 0;
+
+    while (++index < length) {
+      var value = array[index];
+      setter(accumulator, value, iteratee(value), array);
+    }
+    return accumulator;
+  }
+
+  return arrayAggregator;
+});

_arrayEach.js

@@ -5,13 +5,13 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @returns {Array} Returns `array`.
    */
   function arrayEach(array, iteratee) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (iteratee(array[index], index, array) === false) {

_arrayEachRight.js

@@ -5,12 +5,12 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @returns {Array} Returns `array`.
    */
   function arrayEachRight(array, iteratee) {
-    var length = array.length;
+    var length = array ? array.length : 0;
 
     while (length--) {
       if (iteratee(array[length], length, array) === false) {

_arrayEvery.js

@@ -5,13 +5,14 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if all elements pass the predicate check, else `false`.
+   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   *  else `false`.
    */
   function arrayEvery(array, predicate) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (!predicate(array[index], index, array)) {

_arrayFilter.js

@@ -5,20 +5,20 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} predicate The function invoked per iteration.
    * @returns {Array} Returns the new filtered array.
    */
   function arrayFilter(array, predicate) {
     var index = -1,
-        length = array.length,
-        resIndex = -1,
+        length = array ? array.length : 0,
+        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,16 +1,17 @@
-define(['./baseIndexOf'], function(baseIndexOf) {
+define(['./_baseIndexOf'], function(baseIndexOf) {
 
   /**
    * A specialized version of `_.includes` for arrays without support for
    * specifying an index to search from.
    *
    * @private
-   * @param {Array} array The array to search.
+   * @param {Array} [array] The array to search.
    * @param {*} target The value to search for.
    * @returns {boolean} Returns `true` if `target` is found, else `false`.
    */
   function arrayIncludes(array, value) {
-    return !!array.length && baseIndexOf(array, value, 0) > -1;
+    var length = array ? array.length : 0;
+    return !!length && baseIndexOf(array, value, 0) > -1;
   }
 
   return arrayIncludes;

_arrayIncludesWith.js

@@ -1,18 +1,17 @@
 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.
+   * @param {Array} [array] The array to search.
    * @param {*} target The value to search for.
    * @param {Function} comparator The comparator invoked per element.
    * @returns {boolean} Returns `true` if `target` is found, else `false`.
    */
   function arrayIncludesWith(array, value, comparator) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (comparator(value, array[index])) {

_arrayLikeKeys.js

@@ -0,0 +1,35 @@
+define(['./_baseTimes', './isArguments', './isArray', './_isIndex', './isString'], function(baseTimes, isArguments, isArray, isIndex, isString) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * Creates an array of the enumerable property names of the array-like `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @param {boolean} inherited Specify returning inherited property names.
+   * @returns {Array} Returns the array of property names.
+   */
+  function arrayLikeKeys(value, inherited) {
+    var result = (isArray(value) || isString(value) || isArguments(value))
+      ? baseTimes(value.length, String)
+      : [];
+
+    var length = result.length,
+        skipIndexes = !!length;
+
+    for (var key in value) {
+      if ((inherited || hasOwnProperty.call(value, key)) &&
+          !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  return arrayLikeKeys;
+});

_arrayMap.js

@@ -5,13 +5,13 @@ define([], function() {
    * shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @returns {Array} Returns the new mapped array.
    */
   function arrayMap(array, iteratee) {
     var index = -1,
-        length = array.length,
+        length = array ? array.length : 0,
         result = Array(length);
 
     while (++index < length) {

_arrayReduce.js

@@ -5,15 +5,16 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initAccum] 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, initAccum) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     if (initAccum && length) {
       accumulator = array[++index];

_arrayReduceRight.js

@@ -5,14 +5,15 @@ define([], function() {
    * iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initAccum] 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, initAccum) {
-    var length = array.length;
+    var length = array ? array.length : 0;
     if (initAccum && length) {
       accumulator = array[--length];
     }

_arraySome.js

@@ -5,13 +5,14 @@ define([], function() {
    * shorthands.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @param {Array} [array] The array to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+   * @returns {boolean} Returns `true` if any element passes the predicate check,
+   *  else `false`.
    */
   function arraySome(array, predicate) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (predicate(array[index], index, array)) {

_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;
@@ -11,7 +11,7 @@ define(['../eq'], function(eq) {
 
   /**
    * Assigns `value` to `key` of `object` if the existing value is not equivalent
-   * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
    * for equality comparisons.
    *
    * @private
@@ -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;
     }

_assocIndexOf.js

@@ -1,8 +1,7 @@
-define(['../eq'], function(eq) {
+define(['./eq'], function(eq) {
 
   /**
-   * Gets the index at which the first occurrence of `key` is found in `array`
-   * of key-value pairs.
+   * Gets the index at which the `key` is found in `array` of key-value pairs.
    *
    * @private
    * @param {Array} array The array to search.

_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;
@@ -9,7 +9,7 @@ define(['../get'], function(get) {
    * @private
    * @param {Object} object The object to iterate over.
    * @param {string[]} paths The property paths of elements to pick.
-   * @returns {Array} Returns the new array of picked elements.
+   * @returns {Array} Returns the picked elements.
    */
   function baseAt(object, paths) {
     var index = -1,

_baseClamp.js

@@ -4,7 +4,7 @@ define([], function() {
   var undefined;
 
   /**
-   * The base implementation of `_.clamp` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.clamp` which doesn't coerce arguments.
    *
    * @private
    * @param {number} number The number to clamp.

_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', './_cloneBuffer', './_copyArray', './_copySymbols', './_getAllKeys', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './_isHostObject', './isObject', './keys'], function(Stack, arrayEach, assignValue, baseAssign, cloneBuffer, copyArray, copySymbols, getAllKeys, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isHostObject, isObject, keys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -21,6 +21,7 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
       weakMapTag = '[object WeakMap]';
 
   var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
       float32Tag = '[object Float32Array]',
       float64Tag = '[object Float64Array]',
       int8Tag = '[object Int8Array]',
@@ -34,16 +35,16 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
   /** Used to identify `toStringTag` values supported by `_.clone`. */
   var cloneableTags = {};
   cloneableTags[argsTag] = cloneableTags[arrayTag] =
-  cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =
-  cloneableTags[dateTag] = cloneableTags[float32Tag] =
-  cloneableTags[float64Tag] = cloneableTags[int8Tag] =
-  cloneableTags[int16Tag] = cloneableTags[int32Tag] =
-  cloneableTags[mapTag] = cloneableTags[numberTag] =
-  cloneableTags[objectTag] = cloneableTags[regexpTag] =
-  cloneableTags[setTag] = cloneableTags[stringTag] =
-  cloneableTags[symbolTag] = cloneableTags[uint8Tag] =
-  cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] =
-  cloneableTags[uint32Tag] = true;
+  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+  cloneableTags[boolTag] = cloneableTags[dateTag] =
+  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+  cloneableTags[int32Tag] = cloneableTags[mapTag] =
+  cloneableTags[numberTag] = cloneableTags[objectTag] =
+  cloneableTags[regexpTag] = cloneableTags[setTag] =
+  cloneableTags[stringTag] = cloneableTags[symbolTag] =
+  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
   cloneableTags[errorTag] = cloneableTags[funcTag] =
   cloneableTags[weakMapTag] = false;
 
@@ -54,13 +55,14 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
    * @private
    * @param {*} value The value to clone.
    * @param {boolean} [isDeep] Specify a deep clone.
+   * @param {boolean} [isFull] Specify a clone including symbols.
    * @param {Function} [customizer] The function to customize cloning.
    * @param {string} [key] The key of `value`.
    * @param {Object} [object] The parent object of `value`.
    * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
    * @returns {*} Returns the cloned value.
    */
-  function baseClone(value, isDeep, customizer, key, object, stack) {
+  function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
     var result;
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
@@ -81,6 +83,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 +95,10 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
           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, baseClone, isDeep);
       }
     }
     // Check for circular references and return its corresponding clone.
@@ -103,11 +109,18 @@ define(['./Stack', './arrayEach', './assignValue', './baseAssign', './baseForOwn
     }
     stack.set(value, result);
 
-    // Recursively populate clone (susceptible to call stack limits).
-    (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
-      assignValue(result, key, baseClone(subValue, isDeep, customizer, key, value, stack));
+    if (!isArr) {
+      var props = isFull ? getAllKeys(value) : keys(value);
+    }
+    arrayEach(props || value, function(subValue, key) {
+      if (props) {
+        key = subValue;
+        subValue = value[key];
+      }
+      // Recursively populate clone (susceptible to call stack limits).
+      assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
     });
-    return isArr ? result : copySymbols(value, result);
+    return result;
   }
 
   return baseClone;

_baseConforms.js

@@ -0,0 +1,18 @@
+define(['./_baseConformsTo', './keys'], function(baseConformsTo, keys) {
+
+  /**
+   * The base implementation of `_.conforms` which doesn't clone `source`.
+   *
+   * @private
+   * @param {Object} source The object of property predicates to conform to.
+   * @returns {Function} Returns the new spec function.
+   */
+  function baseConforms(source) {
+    var props = keys(source);
+    return function(object) {
+      return baseConformsTo(object, source, props);
+    };
+  }
+
+  return baseConforms;
+});

_baseConformsTo.js

@@ -0,0 +1,33 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.conformsTo` which accepts `props` to check.
+   *
+   * @private
+   * @param {Object} object The object to inspect.
+   * @param {Object} source The object of property predicates to conform to.
+   * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+   */
+  function baseConformsTo(object, source, props) {
+    var length = props.length;
+    if (object == null) {
+      return !length;
+    }
+    object = Object(object);
+    while (length--) {
+      var key = props[length],
+          predicate = source[key],
+          value = object[key];
+
+      if ((value === undefined && !(key in object)) || !predicate(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return baseConformsTo;
+});

_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

@@ -7,14 +7,14 @@ define([], function() {
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
-   * The base implementation of `_.delay` and `_.defer` which accepts an array
-   * of `func` arguments.
+   * The base implementation of `_.delay` and `_.defer` which accepts `args`
+   * to provide to `func`.
    *
    * @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`.
-   * @returns {number} Returns the timer id.
+   * @param {Array} args The arguments to provide to `func`.
+   * @returns {number|Object} Returns the timer id or timeout object.
    */
   function baseDelay(func, wait, args) {
     if (typeof func != 'function') {

_baseDifference.js

@@ -1,11 +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 the size to enable large array optimizations. */
   var LARGE_ARRAY_SIZE = 200;
 
   /**
-   * The base implementation of methods like `_.difference` without support for
-   * excluding multiple arrays or iteratee shorthands.
+   * The base implementation of methods like `_.difference` without support
+   * for excluding multiple arrays or iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to inspect.
@@ -42,6 +42,7 @@ define(['./SetCache', './arrayIncludes', './arrayIncludesWith', './arrayMap', '.
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
+      value = (comparator || value !== 0) ? value : 0;
       if (isCommon && computed === computed) {
         var valuesIndex = valuesLength;
         while (valuesIndex--) {

_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.
@@ -6,7 +6,8 @@ define(['./baseEach'], function(baseEach) {
    * @private
    * @param {Array|Object} collection The collection to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if all elements pass the predicate check, else `false`
+   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   *  else `false`
    */
   function baseEvery(collection, predicate) {
     var result = true;

_baseExtremum.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./isSymbol'], function(isSymbol) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -22,7 +22,7 @@ define([], function() {
           current = iteratee(value);
 
       if (current != null && (computed === undefined
-            ? current === current
+            ? (current === current && !isSymbol(current))
             : comparator(current, computed)
           )) {
         var computed = current,

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

_baseFindIndex.js

@@ -7,12 +7,13 @@ define([], function() {
    * @private
    * @param {Array} array The array to search.
    * @param {Function} predicate The function invoked per iteration.
+   * @param {number} fromIndex The index to search from.
    * @param {boolean} [fromRight] Specify iterating from right to left.
    * @returns {number} Returns the index of the matched value, else `-1`.
    */
-  function baseFindIndex(array, predicate, fromRight) {
+  function baseFindIndex(array, predicate, fromIndex, fromRight) {
     var length = array.length,
-        index = fromRight ? length : -1;
+        index = fromIndex + (fromRight ? 1 : -1);
 
     while ((fromRight ? index-- : ++index < length)) {
       if (predicate(array[index], index, array)) {

_baseFindKey.js

@@ -1,27 +1,26 @@
 define([], function() {
 
   /**
-   * The base implementation of methods like `_.find` and `_.findKey`, without
-   * support for iteratee shorthands, which iterates over `collection` using
-   * `eachFunc`.
+   * The base implementation of methods like `_.findKey` and `_.findLastKey`,
+   * without support for iteratee shorthands, which iterates over `collection`
+   * using `eachFunc`.
    *
    * @private
    * @param {Array|Object} collection The collection to search.
    * @param {Function} predicate The function invoked per iteration.
    * @param {Function} eachFunc The function to iterate over `collection`.
-   * @param {boolean} [retKey] Specify returning the key of the found element instead of the element itself.
    * @returns {*} Returns the found element or its key, else `undefined`.
    */
-  function baseFind(collection, predicate, eachFunc, retKey) {
+  function baseFindKey(collection, predicate, eachFunc) {
     var result;
     eachFunc(collection, function(value, key, collection) {
       if (predicate(value, key, collection)) {
-        result = retKey ? key : value;
+        result = key;
         return false;
       }
     });
     return result;
   }
 
-  return baseFind;
+  return baseFindKey;
 });

_baseFlatten.js

@@ -1,28 +1,29 @@
-define(['./arrayPush', '../isArguments', '../isArray', '../isArrayLikeObject'], function(arrayPush, isArguments, isArray, isArrayLikeObject) {
+define(['./_arrayPush', './_isFlattenable'], function(arrayPush, isFlattenable) {
 
   /**
    * 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 {boolean} [isStrict] Restrict flattening to arrays-like objects.
+   * @param {number} depth The maximum recursion depth.
+   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
    * @param {Array} [result=[]] The initial result value.
    * @returns {Array} Returns the new flattened array.
    */
-  function baseFlatten(array, isDeep, isStrict, result) {
-    result || (result = []);
-
+  function baseFlatten(array, depth, predicate, isStrict, result) {
     var index = -1,
         length = array.length;
 
+    predicate || (predicate = isFlattenable);
+    result || (result = []);
+
     while (++index < length) {
       var value = array[index];
-      if (isArrayLikeObject(value) &&
-          (isStrict || isArray(value) || isArguments(value))) {
-        if (isDeep) {
+      if (depth > 0 && predicate(value)) {
+        if (depth > 1) {
           // Recursively flatten arrays (susceptible to call stack limits).
-          baseFlatten(value, isDeep, isStrict, result);
+          baseFlatten(value, depth - 1, predicate, isStrict, result);
         } else {
           arrayPush(result, value);
         }

_baseFor.js

@@ -1,10 +1,9 @@
-define(['./createBaseFor'], function(createBaseFor) {
+define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
-   * The base implementation of `baseForIn` and `baseForOwn` which iterates
-   * over `object` properties returned by `keysFunc` invoking `iteratee` for
-   * each property. Iteratee functions may exit iteration early by explicitly
-   * returning `false`.
+   * The base implementation of `baseForOwn` which iterates over `object`
+   * properties returned by `keysFunc` and invokes `iteratee` for each property.
+   * Iteratee functions may exit iteration early by explicitly returning `false`.
    *
    * @private
    * @param {Object} object The object to iterate over.

_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,13 +1,13 @@
-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.
    * @param {Array} props The property names to filter.
-   * @returns {Array} Returns the new array of filtered property names.
+   * @returns {Array} Returns the function names.
    */
   function baseFunctions(object, props) {
     return arrayFilter(props, function(key) {

_baseGet.js

@@ -1,4 +1,4 @@
-define(['./baseToPath', './isKey'], function(baseToPath, isKey) {
+define(['./_castPath', './_isKey', './_toKey'], function(castPath, isKey, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,13 +12,13 @@ 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] : castPath(path);
 
     var index = 0,
         length = path.length;
 
     while (object != null && index < length) {
-      object = object[path[index++]];
+      object = object[toKey(path[index++])];
     }
     return (index && index == length) ? object : undefined;
   }

_baseGetAllKeys.js

@@ -0,0 +1,20 @@
+define(['./_arrayPush', './isArray'], function(arrayPush, isArray) {
+
+  /**
+   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+   * symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Function} keysFunc The function to get the keys of `object`.
+   * @param {Function} symbolsFunc The function to get the symbols of `object`.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+  }
+
+  return baseGetAllKeys;
+});

_baseGetTag.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `getTag`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    return objectToString.call(value);
+  }
+
+  return baseGetTag;
+});

_baseGt.js

@@ -0,0 +1,17 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.gt` which doesn't coerce arguments.
+   *
+   * @private
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @returns {boolean} Returns `true` if `value` is greater than `other`,
+   *  else `false`.
+   */
+  function baseGt(value, other) {
+    return value > other;
+  }
+
+  return baseGt;
+});

_baseHas.js

@@ -6,23 +6,16 @@ define([], function() {
   /** Used to check objects for own properties. */
   var hasOwnProperty = objectProto.hasOwnProperty;
 
-  /** Built-in value references. */
-  var getPrototypeOf = Object.getPrototypeOf;
-
   /**
    * The base implementation of `_.has` without support for deep paths.
    *
    * @private
-   * @param {Object} object The object to query.
+   * @param {Object} [object] The object to query.
    * @param {Array|string} key The key to check.
    * @returns {boolean} Returns `true` if `key` exists, else `false`.
    */
   function baseHas(object, key) {
-    // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`,
-    // that are composed entirely of index properties, return `false` for
-    // `hasOwnProperty` checks of them.
-    return hasOwnProperty.call(object, key) ||
-      (typeof object == 'object' && key in object && getPrototypeOf(object) === null);
+    return object != null && hasOwnProperty.call(object, key);
   }
 
   return baseHas;

_baseHasIn.js

@@ -4,12 +4,12 @@ define([], function() {
    * The base implementation of `_.hasIn` without support for deep paths.
    *
    * @private
-   * @param {Object} object The object to query.
+   * @param {Object} [object] The object to query.
    * @param {Array|string} key The key to check.
    * @returns {boolean} Returns `true` if `key` exists, else `false`.
    */
   function baseHasIn(object, key) {
-    return key in Object(object);
+    return object != null && key in Object(object);
   }
 
   return baseHasIn;

_baseInRange.js

@@ -5,7 +5,7 @@ define([], function() {
       nativeMin = Math.min;
 
   /**
-   * The base implementation of `_.inRange` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.inRange` which doesn't coerce arguments.
    *
    * @private
    * @param {number} number The number to check.

_baseIndexOf.js

@@ -1,4 +1,4 @@
-define(['./indexOfNaN'], function(indexOfNaN) {
+define(['./_baseFindIndex', './_baseIsNaN'], function(baseFindIndex, baseIsNaN) {
 
   /**
    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
@@ -11,7 +11,7 @@ define(['./indexOfNaN'], function(indexOfNaN) {
    */
   function baseIndexOf(array, value, fromIndex) {
     if (value !== value) {
-      return indexOfNaN(array, fromIndex);
+      return baseFindIndex(array, baseIsNaN, fromIndex);
     }
     var index = fromIndex - 1,
         length = array.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

@@ -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,33 @@ 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;
+      value = (comparator || value !== 0) ? value : 0;
+      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;
           }
         }

_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', './_castPath', './_isKey', './last', './_parent', './_toKey'], function(apply, castPath, isKey, last, parent, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -15,11 +15,11 @@ define(['./apply', './baseToPath', './isKey', '../last', './parent'], function(a
    */
   function baseInvoke(object, path, args) {
     if (!isKey(path, object)) {
-      path = baseToPath(path);
+      path = castPath(path);
       object = parent(object, path);
       path = last(path);
     }
-    var func = object == null ? object : object[path];
+    var func = object == null ? object : object[toKey(path)];
     return func == null ? undefined : apply(func, object, args);
   }
 

_baseIsArrayBuffer.js

@@ -0,0 +1,27 @@
+define(['./isObjectLike'], function(isObjectLike) {
+
+  var arrayBufferTag = '[object ArrayBuffer]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+   */
+  function baseIsArrayBuffer(value) {
+    return isObjectLike(value) && objectToString.call(value) == arrayBufferTag;
+  }
+
+  return baseIsArrayBuffer;
+});

_baseIsDate.js

@@ -0,0 +1,28 @@
+define(['./isObjectLike'], function(isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var dateTag = '[object Date]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isDate` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+   */
+  function baseIsDate(value) {
+    return isObjectLike(value) && objectToString.call(value) == dateTag;
+  }
+
+  return baseIsDate;
+});

_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;
@@ -24,7 +24,8 @@ define(['./Stack', './equalArrays', './equalByTag', './equalObjects', './getTag'
    * @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 {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`.
    */
@@ -36,41 +37,39 @@ define(['./Stack', './equalArrays', './equalByTag', './equalObjects', './getTag'
 
     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) {
-        return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, bitmask, stack);
+        var objUnwrapped = objIsWrapped ? object.value() : object,
+            othUnwrapped = othIsWrapped ? other.value() : other;
+
+        stack || (stack = new Stack);
+        return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
       }
     }
     if (!isSameTag) {
       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;

_baseIsMap.js

@@ -0,0 +1,18 @@
+define(['./_getTag', './isObjectLike'], function(getTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var mapTag = '[object Map]';
+
+  /**
+   * The base implementation of `_.isMap` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+   */
+  function baseIsMap(value) {
+    return isObjectLike(value) && getTag(value) == mapTag;
+  }
+
+  return baseIsMap;
+});

_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;
@@ -46,9 +46,10 @@ define(['./Stack', './baseIsEqual'], function(Stack, baseIsEqual) {
           return false;
         }
       } else {
-        var stack = new Stack,
-            result = customizer ? customizer(objValue, srcValue, key, object, source, stack) : undefined;
-
+        var stack = new Stack;
+        if (customizer) {
+          var result = customizer(objValue, srcValue, key, object, source, stack);
+        }
         if (!(result === undefined
               ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
               : result

_baseIsNaN.js

@@ -0,0 +1,15 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.isNaN` without support for number objects.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+   */
+  function baseIsNaN(value) {
+    return value !== value;
+  }
+
+  return baseIsNaN;
+});

_baseIsNative.js

@@ -0,0 +1,44 @@
+define(['./isFunction', './_isHostObject', './_isMasked', './isObject', './_toSource'], function(isFunction, isHostObject, isMasked, isObject, toSource) {
+
+  /**
+   * Used to match `RegExp`
+   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+   */
+  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+  /** Used to detect host constructors (Safari). */
+  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString = Function.prototype.toString;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Used to detect if a method is native. */
+  var reIsNative = RegExp('^' +
+    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+  );
+
+  /**
+   * The base implementation of `_.isNative` without bad shim checks.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a native function,
+   *  else `false`.
+   */
+  function baseIsNative(value) {
+    if (!isObject(value) || isMasked(value)) {
+      return false;
+    }
+    var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+  }
+
+  return baseIsNative;
+});

_baseIsRegExp.js

@@ -0,0 +1,28 @@
+define(['./isObject'], function(isObject) {
+
+  /** `Object#toString` result references. */
+  var regexpTag = '[object RegExp]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isRegExp` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
+   */
+  function baseIsRegExp(value) {
+    return isObject(value) && objectToString.call(value) == regexpTag;
+  }
+
+  return baseIsRegExp;
+});

_baseIsSet.js

@@ -0,0 +1,18 @@
+define(['./_getTag', './isObjectLike'], function(getTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var setTag = '[object Set]';
+
+  /**
+   * The base implementation of `_.isSet` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+   */
+  function baseIsSet(value) {
+    return isObjectLike(value) && getTag(value) == setTag;
+  }
+
+  return baseIsSet;
+});

_baseIsTypedArray.js

@@ -0,0 +1,69 @@
+define(['./isLength', './isObjectLike'], function(isLength, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+      arrayTag = '[object Array]',
+      boolTag = '[object Boolean]',
+      dateTag = '[object Date]',
+      errorTag = '[object Error]',
+      funcTag = '[object Function]',
+      mapTag = '[object Map]',
+      numberTag = '[object Number]',
+      objectTag = '[object Object]',
+      regexpTag = '[object RegExp]',
+      setTag = '[object Set]',
+      stringTag = '[object String]',
+      weakMapTag = '[object WeakMap]';
+
+  var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
+      float32Tag = '[object Float32Array]',
+      float64Tag = '[object Float64Array]',
+      int8Tag = '[object Int8Array]',
+      int16Tag = '[object Int16Array]',
+      int32Tag = '[object Int32Array]',
+      uint8Tag = '[object Uint8Array]',
+      uint8ClampedTag = '[object Uint8ClampedArray]',
+      uint16Tag = '[object Uint16Array]',
+      uint32Tag = '[object Uint32Array]';
+
+  /** Used to identify `toStringTag` values of typed arrays. */
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+  typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+  typedArrayTags[setTag] = typedArrayTags[stringTag] =
+  typedArrayTags[weakMapTag] = false;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isTypedArray` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   */
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) &&
+      isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+  }
+
+  return baseIsTypedArray;
+});

_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`.
@@ -8,14 +8,15 @@ define(['./baseMatches', './baseMatchesProperty', '../identity', '../isArray', '
    * @returns {Function} Returns the iteratee.
    */
   function baseIteratee(value) {
-    var type = typeof value;
-    if (type == 'function') {
+    // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+    // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+    if (typeof value == 'function') {
       return value;
     }
     if (value == null) {
       return identity;
     }
-    if (type == 'object') {
+    if (typeof value == 'object') {
       return isArray(value)
         ? baseMatchesProperty(value[0], value[1])
         : baseMatches(value);

_baseKeys.js

@@ -0,0 +1,30 @@
+define(['./_isPrototype', './_nativeKeys'], function(isPrototype, nativeKeys) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function baseKeys(object) {
+    if (!isPrototype(object)) {
+      return nativeKeys(object);
+    }
+    var result = [];
+    for (var key in Object(object)) {
+      if (hasOwnProperty.call(object, key) && key != 'constructor') {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  return baseKeys;
+});

_baseKeysIn.js

@@ -0,0 +1,32 @@
+define(['./isObject', './_isPrototype', './_nativeKeysIn'], function(isObject, isPrototype, nativeKeysIn) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function baseKeysIn(object) {
+    if (!isObject(object)) {
+      return nativeKeysIn(object);
+    }
+    var isProto = isPrototype(object),
+        result = [];
+
+    for (var key in object) {
+      if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  return baseKeysIn;
+});

_baseLodash.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The function whose prototype all chaining wrappers inherit from.
+   * The function whose prototype chain sequence wrappers inherit from.
    *
    * @private
    */

_baseLt.js

@@ -0,0 +1,17 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.lt` which doesn't coerce arguments.
+   *
+   * @private
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @returns {boolean} Returns `true` if `value` is less than `other`,
+   *  else `false`.
+   */
+  function baseLt(value, other) {
+    return value < other;
+  }
+
+  return baseLt;
+});

_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

@@ -0,0 +1,21 @@
+define(['./_baseIsMatch', './_getMatchData', './_matchesStrictComparable'], function(baseIsMatch, getMatchData, matchesStrictComparable) {
+
+  /**
+   * The base implementation of `_.matches` which doesn't clone `source`.
+   *
+   * @private
+   * @param {Object} source The object of property values to match.
+   * @returns {Function} Returns the new spec function.
+   */
+  function baseMatches(source) {
+    var matchData = getMatchData(source);
+    if (matchData.length == 1 && matchData[0][2]) {
+      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+    }
+    return function(object) {
+      return object === source || baseIsMatch(object, source, matchData);
+    };
+  }
+
+  return baseMatches;
+});

_baseMatchesProperty.js

@@ -1,4 +1,4 @@
-define(['./baseIsEqual', '../get', '../hasIn'], function(baseIsEqual, get, hasIn) {
+define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable', './_matchesStrictComparable', './_toKey'], function(baseIsEqual, get, hasIn, isKey, isStrictComparable, matchesStrictComparable, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -13,9 +13,12 @@ define(['./baseIsEqual', '../get', '../hasIn'], function(baseIsEqual, get, hasIn
    * @private
    * @param {string} path The path of the property to get.
    * @param {*} srcValue The value to match.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new spec function.
    */
   function baseMatchesProperty(path, srcValue) {
+    if (isKey(path) && isStrictComparable(srcValue)) {
+      return matchesStrictComparable(toKey(path), srcValue);
+    }
     return function(object) {
       var objValue = get(object, path);
       return (objValue === undefined && objValue === srcValue)

_baseMean.js

@@ -0,0 +1,21 @@
+define(['./_baseSum'], function(baseSum) {
+
+  /** Used as references for various `Number` constants. */
+  var NAN = 0 / 0;
+
+  /**
+   * The base implementation of `_.mean` and `_.meanBy` without support for
+   * iteratee shorthands.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} iteratee The function invoked per iteration.
+   * @returns {number} Returns the mean.
+   */
+  function baseMean(array, iteratee) {
+    var length = array ? array.length : 0;
+    return length ? (baseSum(array, iteratee) / length) : NAN;
+  }
+
+  return baseMean;
+});

_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', './_baseKeysIn', './_baseMergeDeep', './isArray', './isObject', './isTypedArray'], function(Stack, arrayEach, assignMergeValue, baseKeysIn, baseMergeDeep, isArray, isObject, isTypedArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -11,13 +11,16 @@ define(['./Stack', './arrayEach', './assignMergeValue', './baseMergeDeep', '../i
    * @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.
+   * @param {Object} [stack] Tracks traversed source values and their merged
+   *  counterparts.
    */
   function baseMerge(object, source, srcIndex, customizer, stack) {
     if (object === source) {
       return;
     }
-    var props = (isArray(source) || isTypedArray(source)) ? undefined : keysIn(source);
+    if (!(isArray(source) || isTypedArray(source))) {
+      var props = baseKeysIn(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;
@@ -15,31 +15,36 @@ define(['./assignMergeValue', './baseClone', './copyArray', '../isArguments', '.
    * @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.
+   * @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) || 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,
-        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 {
-          newValue = baseClone(srcValue);
+          isCommon = false;
+          newValue = baseClone(srcValue, true);
         }
       }
       else if (isPlainObject(srcValue) || isArguments(srcValue)) {
@@ -47,21 +52,22 @@ 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 {
         isCommon = false;
       }
     }
-    stack.set(srcValue, newValue);
-
     if (isCommon) {
       // Recursively merge objects and arrays (susceptible to call stack limits).
+      stack.set(srcValue, newValue);
       mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+      stack['delete'](srcValue);
     }
     assignMergeValue(object, key, newValue);
   }

_baseNth.js

@@ -0,0 +1,24 @@
+define(['./_isIndex'], function(isIndex) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.nth` which doesn't coerce arguments.
+   *
+   * @private
+   * @param {Array} array The array to query.
+   * @param {number} n The index of the element to return.
+   * @returns {*} Returns the nth element of `array`.
+   */
+  function baseNth(array, n) {
+    var length = array.length;
+    if (!length) {
+      return;
+    }
+    n += n < 0 ? length : 0;
+    return isIndex(n, length) ? array[n] : undefined;
+  }
+
+  return baseNth;
+});

_baseOrderBy.js

@@ -1,4 +1,4 @@
-define(['./arrayMap', './baseIteratee', './baseMap', './baseSortBy', './compareMultiple'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple) {
+define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_baseUnary', './_compareMultiple', './identity'], function(arrayMap, baseIteratee, baseMap, baseSortBy, baseUnary, compareMultiple, identity) {
 
   /**
    * 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,
-        toIteratee = baseIteratee;
-
-    iteratees = arrayMap(iteratees.length ? iteratees : Array(1), function(iteratee) {
-      return toIteratee(iteratee);
-    });
+    var index = -1;
+    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

_basePick.js

@@ -1,22 +1,19 @@
-define(['./arrayReduce'], function(arrayReduce) {
+define(['./_basePickBy'], function(basePickBy) {
 
   /**
    * The base implementation of `_.pick` without support for individual
-   * property names.
+   * property identifiers.
    *
    * @private
    * @param {Object} object The source object.
-   * @param {string[]} props The property names to pick.
+   * @param {string[]} props The property identifiers to pick.
    * @returns {Object} Returns the new object.
    */
   function basePick(object, props) {
     object = Object(object);
-    return arrayReduce(props, function(result, key) {
-      if (key in object) {
-        result[key] = object[key];
-      }
-      return result;
-    }, {});
+    return basePickBy(object, props, function(value, key) {
+      return key in object;
+    });
   }
 
   return basePick;

_basePickBy.js

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

_baseProperty.js

@@ -8,7 +8,7 @@ define([], function() {
    *
    * @private
    * @param {string} key The key of the property to get.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new accessor function.
    */
   function baseProperty(key) {
     return function(object) {

_basePropertyDeep.js

@@ -1,11 +1,11 @@
-define(['./baseGet'], function(baseGet) {
+define(['./_baseGet'], function(baseGet) {
 
   /**
    * A specialized version of `baseProperty` which supports deep paths.
    *
    * @private
    * @param {Array|string} path The path of the property to get.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new accessor function.
    */
   function basePropertyDeep(path) {
     return function(object) {