Bump to v4.17.5.

LICENSE

@@ -1,23 +1,47 @@
-The MIT License (MIT)
+Copyright JS Foundation and other contributors <https://js.foundation/>
 
-Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
-Based on Underscore.js, copyright 2009-2016 Jeremy Ashkenas,
+Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
 
-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 without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+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 above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The following license applies to all parts of this software except as
+documented below:
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND 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.
+====
+
+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
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+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,9 +1,9 @@
-# lodash-amd v4.5.0
+# lodash-amd v4.17.5
 
-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
+```shell
 $ lodash exports=amd -o ./
 $ lodash exports=amd -d -o ./main.js
 ```
@@ -11,8 +11,8 @@ $ lodash exports=amd -d -o ./main.js
 ## Installation
 
 Using npm:
-```bash
-$ {sudo -H} npm i -g npm
+```shell
+$ npm i -g npm
 $ npm i --save lodash-amd
 ```
 
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.5.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.17.5-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

@@ -1,19 +1,29 @@
-define(['./_nativeCreate'], function(nativeCreate) {
-
-  /** Used for built-in method references. */
-  var objectProto = Object.prototype;
+define(['./_hashClear', './_hashDelete', './_hashGet', './_hashHas', './_hashSet'], function(hashClear, hashDelete, hashGet, hashHas, hashSet) {
 
   /**
-   * Creates an hash object.
+   * Creates a hash object.
    *
    * @private
    * @constructor
-   * @returns {Object} Returns the new hash object.
+   * @param {Array} [entries] The key-value pairs to cache.
    */
-  function Hash() {}
+  function Hash(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
 
-  // Avoid inheriting from `Object.prototype` when possible.
-  Hash.prototype = nativeCreate ? nativeCreate(null) : objectProto;
+    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

@@ -20,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 == null ? 0 : entries.length;
+
+    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

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

_MapCache.js

@@ -1,29 +1,29 @@
-define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], function(mapClear, mapDelete, mapGet, mapHas, mapSet) {
+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} [values] The values to cache.
+   * @param {Array} [entries] The key-value pairs to cache.
    */
-  function MapCache(values) {
+  function MapCache(entries) {
     var index = -1,
-        length = values ? values.length : 0;
+        length = entries == null ? 0 : entries.length;
 
     this.clear();
     while (++index < length) {
-      var entry = values[index];
+      var entry = entries[index];
       this.set(entry[0], entry[1]);
     }
   }
 
-  // Add functions to the `MapCache`.
-  MapCache.prototype.clear = mapClear;
-  MapCache.prototype['delete'] = mapDelete;
-  MapCache.prototype.get = mapGet;
-  MapCache.prototype.has = mapHas;
-  MapCache.prototype.set = mapSet;
+  // 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;
+});

_Reflect.js

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

_SetCache.js

@@ -1,8 +1,8 @@
-define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
+define(['./_MapCache', './_setCacheAdd', './_setCacheHas'], function(MapCache, setCacheAdd, setCacheHas) {
 
   /**
    *
-   * Creates a set cache object to store unique values.
+   * Creates an array cache object to store unique values.
    *
    * @private
    * @constructor
@@ -10,16 +10,17 @@ define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
    */
   function SetCache(values) {
     var index = -1,
-        length = values ? values.length : 0;
+        length = values == null ? 0 : values.length;
 
     this.__data__ = new MapCache;
     while (++index < length) {
-      this.push(values[index]);
+      this.add(values[index]);
     }
   }
 
-  // Add functions to the `SetCache`.
-  SetCache.prototype.push = cachePush;
+  // Add methods to `SetCache`.
+  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+  SetCache.prototype.has = setCacheHas;
 
   return SetCache;
 });

_Stack.js

@@ -1,24 +1,18 @@
-define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_stackSet'], function(stackClear, stackDelete, stackGet, stackHas, stackSet) {
+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} [values] The values to cache.
+   * @param {Array} [entries] The key-value pairs to cache.
    */
-  function Stack(values) {
-    var index = -1,
-        length = values ? values.length : 0;
-
-    this.clear();
-    while (++index < length) {
-      var entry = values[index];
-      this.set(entry[0], entry[1]);
-    }
+  function Stack(entries) {
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
   }
 
-  // Add functions to the `Stack` cache.
+  // Add methods to `Stack`.
   Stack.prototype.clear = stackClear;
   Stack.prototype['delete'] = stackDelete;
   Stack.prototype.get = stackGet;

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

@@ -4,7 +4,7 @@ define([], function() {
    * A specialized version of `baseAggregator` for arrays.
    *
    * @private
-   * @param {Array} array The array to iterate over.
+   * @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.
@@ -12,7 +12,7 @@ define([], function() {
    */
   function arrayAggregator(array, setter, iteratee, accumulator) {
     var index = -1,
-        length = array.length;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       var value = array[index];

_arrayConcat.js

@@ -1,28 +0,0 @@
-define([], function() {
-
-  /**
-   * Creates a new array concatenating `array` with `other`.
-   *
-   * @private
-   * @param {Array} array The first array to concatenate.
-   * @param {Array} other The second array to concatenate.
-   * @returns {Array} Returns the new concatenated array.
-   */
-  function arrayConcat(array, other) {
-    var index = -1,
-        length = array.length,
-        othIndex = -1,
-        othLength = other.length,
-        result = Array(length + othLength);
-
-    while (++index < length) {
-      result[index] = array[index];
-    }
-    while (++othIndex < othLength) {
-      result[index++] = other[othIndex];
-    }
-    return result;
-  }
-
-  return arrayConcat;
-});

_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 == null ? 0 : array.length;
 
     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 == null ? 0 : array.length;
 
     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 == null ? 0 : array.length;
 
     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 == null ? 0 : array.length,
+        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

@@ -5,12 +5,13 @@ define(['./_baseIndexOf'], function(baseIndexOf) {
    * specifying an index to search from.
    *
    * @private
-   * @param {Array} array The array to search.
+   * @param {Array} [array] The array to inspect.
    * @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 == null ? 0 : array.length;
+    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 inspect.
    * @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 == null ? 0 : array.length;
 
     while (++index < length) {
       if (comparator(value, array[index])) {

_arrayLikeKeys.js

@@ -0,0 +1,45 @@
+define(['./_baseTimes', './isArguments', './isArray', './isBuffer', './_isIndex', './isTypedArray'], function(baseTimes, isArguments, isArray, isBuffer, isIndex, isTypedArray) {
+
+  /** 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 isArr = isArray(value),
+        isArg = !isArr && isArguments(value),
+        isBuff = !isArr && !isArg && isBuffer(value),
+        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+        skipIndexes = isArr || isArg || isBuff || isType,
+        result = skipIndexes ? baseTimes(value.length, String) : [],
+        length = result.length;
+
+    for (var key in value) {
+      if ((inherited || hasOwnProperty.call(value, key)) &&
+          !(skipIndexes && (
+             // Safari 9 has enumerable `arguments.length` in strict mode.
+             key == 'length' ||
+             // Node.js 0.10 has enumerable non-index properties on buffers.
+             (isBuff && (key == 'offset' || key == 'parent')) ||
+             // PhantomJS 2 has enumerable non-index properties on typed arrays.
+             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+             // Skip index properties.
+             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 == null ? 0 : array.length,
         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 == null ? 0 : array.length;
 
     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 == null ? 0 : array.length;
     if (initAccum && length) {
       accumulator = array[--length];
     }

_arraySample.js

@@ -0,0 +1,19 @@
+define(['./_baseRandom'], function(baseRandom) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * A specialized version of `_.sample` for arrays.
+   *
+   * @private
+   * @param {Array} array The array to sample.
+   * @returns {*} Returns the random element.
+   */
+  function arraySample(array) {
+    var length = array.length;
+    return length ? array[baseRandom(0, length - 1)] : undefined;
+  }
+
+  return arraySample;
+});

_arraySampleSize.js

@@ -0,0 +1,16 @@
+define(['./_baseClamp', './_copyArray', './_shuffleSelf'], function(baseClamp, copyArray, shuffleSelf) {
+
+  /**
+   * A specialized version of `_.sampleSize` for arrays.
+   *
+   * @private
+   * @param {Array} array The array to sample.
+   * @param {number} n The number of elements to sample.
+   * @returns {Array} Returns the random elements.
+   */
+  function arraySampleSize(array, n) {
+    return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
+  }
+
+  return arraySampleSize;
+});

_arrayShuffle.js

@@ -0,0 +1,15 @@
+define(['./_copyArray', './_shuffleSelf'], function(copyArray, shuffleSelf) {
+
+  /**
+   * A specialized version of `_.shuffle` for arrays.
+   *
+   * @private
+   * @param {Array} array The array to shuffle.
+   * @returns {Array} Returns the new shuffled array.
+   */
+  function arrayShuffle(array) {
+    return shuffleSelf(copyArray(array));
+  }
+
+  return arrayShuffle;
+});

_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 == null ? 0 : array.length;
 
     while (++index < length) {
       if (predicate(array[index], index, array)) {

_asciiSize.js

@@ -0,0 +1,13 @@
+define(['./_baseProperty'], function(baseProperty) {
+
+  /**
+   * Gets the size of an ASCII `string`.
+   *
+   * @private
+   * @param {string} string The string inspect.
+   * @returns {number} Returns the string size.
+   */
+  var asciiSize = baseProperty('length');
+
+  return asciiSize;
+});

_asciiToArray.js

@@ -0,0 +1,15 @@
+define([], function() {
+
+  /**
+   * Converts an ASCII `string` to an array.
+   *
+   * @private
+   * @param {string} string The string to convert.
+   * @returns {Array} Returns the converted array.
+   */
+  function asciiToArray(string) {
+    return string.split('');
+  }
+
+  return asciiToArray;
+});

_asciiWords.js

@@ -0,0 +1,18 @@
+define([], function() {
+
+  /** Used to match words composed of alphanumeric characters. */
+  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+  /**
+   * Splits an ASCII `string` into an array of its words.
+   *
+   * @private
+   * @param {string} The string to inspect.
+   * @returns {Array} Returns the words of `string`.
+   */
+  function asciiWords(string) {
+    return string.match(reAsciiWord) || [];
+  }
+
+  return asciiWords;
+});

_assignMergeValue.js

@@ -1,10 +1,11 @@
-define(['./eq'], function(eq) {
+define(['./_baseAssignValue', './eq'], function(baseAssignValue, 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.
@@ -13,8 +14,8 @@ define(['./eq'], function(eq) {
    */
   function assignMergeValue(object, key, value) {
     if ((value !== undefined && !eq(object[key], value)) ||
-        (typeof key == 'number' && value === undefined && !(key in object))) {
-      object[key] = value;
+        (value === undefined && !(key in object))) {
+      baseAssignValue(object, key, value);
     }
   }
 

_assignValue.js

@@ -1,4 +1,4 @@
-define(['./eq'], function(eq) {
+define(['./_baseAssignValue', './eq'], function(baseAssignValue, 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,10 +21,9 @@ 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;
+      baseAssignValue(object, key, value);
     }
   }
 

_assocIndexOf.js

@@ -1,11 +1,10 @@
 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.
+   * @param {Array} array The array to inspect.
    * @param {*} key The key to search for.
    * @returns {number} Returns the index of the matched value, else `-1`.
    */

_assocSet.js

@@ -1,21 +0,0 @@
-define(['./_assocIndexOf'], function(assocIndexOf) {
-
-  /**
-   * Sets the associative array `key` to `value`.
-   *
-   * @private
-   * @param {Array} array The array to modify.
-   * @param {string} key The key of the value to set.
-   * @param {*} value The value to set.
-   */
-  function assocSet(array, key, value) {
-    var index = assocIndexOf(array, key);
-    if (index < 0) {
-      array.push([key, value]);
-    } else {
-      array[index][1] = value;
-    }
-  }
-
-  return assocSet;
-});

_baseAssignIn.js

@@ -0,0 +1,17 @@
+define(['./_copyObject', './keysIn'], function(copyObject, keysIn) {
+
+  /**
+   * The base implementation of `_.assignIn` without support for multiple sources
+   * or `customizer` functions.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @returns {Object} Returns `object`.
+   */
+  function baseAssignIn(object, source) {
+    return object && copyObject(source, keysIn(source), object);
+  }
+
+  return baseAssignIn;
+});

_baseAssignValue.js

@@ -0,0 +1,26 @@
+define(['./_defineProperty'], function(defineProperty) {
+
+  /**
+   * The base implementation of `assignValue` and `assignMergeValue` without
+   * value checks.
+   *
+   * @private
+   * @param {Object} object The object to modify.
+   * @param {string} key The key of the property to assign.
+   * @param {*} value The value to assign.
+   */
+  function baseAssignValue(object, key, value) {
+    if (key == '__proto__' && defineProperty) {
+      defineProperty(object, key, {
+        'configurable': true,
+        'enumerable': true,
+        'value': value,
+        'writable': true
+      });
+    } else {
+      object[key] = value;
+    }
+  }
+
+  return baseAssignValue;
+});

_baseAt.js

@@ -8,17 +8,17 @@ 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.
+   * @param {string[]} paths The property paths to pick.
+   * @returns {Array} Returns the picked elements.
    */
   function baseAt(object, paths) {
     var index = -1,
-        isNil = object == null,
         length = paths.length,
-        result = Array(length);
+        result = Array(length),
+        skip = object == null;
 
     while (++index < length) {
-      result[index] = isNil ? undefined : get(object, paths[index]);
+      result[index] = skip ? undefined : get(object, paths[index]);
     }
     return result;
   }

_baseCastPath.js

@@ -1,15 +0,0 @@
-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;
-});

_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,8 +1,13 @@
-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) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseAssignIn', './_cloneBuffer', './_copyArray', './_copySymbols', './_copySymbolsIn', './_getAllKeys', './_getAllKeysIn', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './isMap', './isObject', './isSet', './keys'], function(Stack, arrayEach, assignValue, baseAssign, baseAssignIn, cloneBuffer, copyArray, copySymbols, copySymbolsIn, getAllKeys, getAllKeysIn, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isMap, isObject, isSet, keys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_FLAT_FLAG = 2,
+      CLONE_SYMBOLS_FLAG = 4;
+
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
       arrayTag = '[object Array]',
@@ -21,6 +26,7 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
       weakMapTag = '[object WeakMap]';
 
   var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
       float32Tag = '[object Float32Array]',
       float64Tag = '[object Float64Array]',
       int8Tag = '[object Int8Array]',
@@ -34,16 +40,16 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
   /** 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;
 
@@ -53,15 +59,22 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
    *
    * @private
    * @param {*} value The value to clone.
-   * @param {boolean} [isDeep] Specify a deep clone.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Deep clone
+   *  2 - Flatten inherited properties
+   *  4 - Clone 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) {
-    var result;
+  function baseClone(value, bitmask, customizer, key, object, stack) {
+    var result,
+        isDeep = bitmask & CLONE_DEEP_FLAG,
+        isFlat = bitmask & CLONE_FLAT_FLAG,
+        isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
     }
@@ -85,12 +98,11 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
         return cloneBuffer(value, isDeep);
       }
       if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
-        if (isHostObject(value)) {
-          return object ? value : {};
-        }
-        result = initCloneObject(isFunc ? {} : value);
+        result = (isFlat || isFunc) ? {} : initCloneObject(value);
         if (!isDeep) {
-          return copySymbols(value, baseAssign(result, value));
+          return isFlat
+            ? copySymbolsIn(value, baseAssignIn(result, value))
+            : copySymbols(value, baseAssign(result, value));
         }
       } else {
         if (!cloneableTags[tag]) {
@@ -107,11 +119,36 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
     }
     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 (isSet(value)) {
+      value.forEach(function(subValue) {
+        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+      });
+
+      return result;
+    }
+
+    if (isMap(value)) {
+      value.forEach(function(subValue, key) {
+        result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+      });
+
+      return result;
+    }
+
+    var keysFunc = isFull
+      ? (isFlat ? getAllKeysIn : getAllKeys)
+      : (isFlat ? keysIn : keys);
+
+    var props = isArr ? undefined : keysFunc(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, bitmask, customizer, key, value, stack));
     });
-    return isArr ? result : copySymbols(value, result);
+    return result;
   }
 
   return baseClone;

_baseConforms.js

@@ -1,34 +1,16 @@
-define(['./keys'], function(keys) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+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 function.
+   * @returns {Function} Returns the new spec function.
    */
   function baseConforms(source) {
-    var props = keys(source),
-        length = props.length;
-
+    var props = keys(source);
     return function(object) {
-      if (object == null) {
-        return !length;
-      }
-      var index = length;
-      while (index--) {
-        var key = props[index],
-            predicate = source[key],
-            value = object[key];
-
-        if ((value === undefined && !(key in Object(object))) || !predicate(value)) {
-          return false;
-        }
-      }
-      return true;
+      return baseConformsTo(object, source, props);
     };
   }
 

_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

@@ -1,5 +1,8 @@
 define(['./isObject'], function(isObject) {
 
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
   /** Built-in value references. */
   var objectCreate = Object.create;
 
@@ -8,12 +11,24 @@ define(['./isObject'], function(isObject) {
    * properties to the created object.
    *
    * @private
-   * @param {Object} prototype The object to inherit from.
+   * @param {Object} proto The object to inherit from.
    * @returns {Object} Returns the new object.
    */
-  function baseCreate(proto) {
-    return isObject(proto) ? objectCreate(proto) : {};
-  }
+  var baseCreate = (function() {
+    function object() {}
+    return function(proto) {
+      if (!isObject(proto)) {
+        return {};
+      }
+      if (objectCreate) {
+        return objectCreate(proto);
+      }
+      object.prototype = proto;
+      var result = new object;
+      object.prototype = undefined;
+      return result;
+    };
+  }());
 
   return baseCreate;
 });

_baseDelay.js

@@ -3,18 +3,18 @@ define([], function() {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used as the `TypeError` message for "Functions" methods. */
+  /** Error message constants. */
   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 to 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

@@ -4,8 +4,8 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
   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.
@@ -40,8 +40,9 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
     outer:
     while (++index < length) {
       var value = array[index],
-          computed = iteratee ? iteratee(value) : value;
+          computed = iteratee == null ? value : iteratee(value);
 
+      value = (comparator || value !== 0) ? value : 0;
       if (isCommon && computed === computed) {
         var valuesIndex = valuesLength;
         while (valuesIndex--) {

_baseEvery.js

@@ -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,

_baseFind.js

@@ -1,27 +0,0 @@
-define([], function() {
-
-  /**
-   * The base implementation of methods like `_.find` and `_.findKey`, 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) {
-    var result;
-    eachFunc(collection, function(value, key, collection) {
-      if (predicate(value, key, collection)) {
-        result = retKey ? key : value;
-        return false;
-      }
-    });
-    return result;
-  }
-
-  return baseFind;
-});

_baseFindIndex.js

@@ -5,14 +5,15 @@ define([], function() {
    * support for iteratee shorthands.
    *
    * @private
-   * @param {Array} array The array to search.
+   * @param {Array} array The array to inspect.
    * @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

@@ -0,0 +1,26 @@
+define([], function() {
+
+  /**
+   * 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 inspect.
+   * @param {Function} predicate The function invoked per iteration.
+   * @param {Function} eachFunc The function to iterate over `collection`.
+   * @returns {*} Returns the found element or its key, else `undefined`.
+   */
+  function baseFindKey(collection, predicate, eachFunc) {
+    var result;
+    eachFunc(collection, function(value, key, collection) {
+      if (predicate(value, key, collection)) {
+        result = key;
+        return false;
+      }
+    });
+    return result;
+  }
+
+  return baseFindKey;
+});

_baseFlatten.js

@@ -1,4 +1,4 @@
-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.
@@ -6,23 +6,24 @@ define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], fu
    * @private
    * @param {Array} array The array to flatten.
    * @param {number} depth The maximum recursion depth.
-   * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
+   * @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, depth, 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 (depth > 0 && isArrayLikeObject(value) &&
-          (isStrict || isArray(value) || isArguments(value))) {
+      if (depth > 0 && predicate(value)) {
         if (depth > 1) {
           // Recursively flatten arrays (susceptible to call stack limits).
-          baseFlatten(value, depth - 1, isStrict, result);
+          baseFlatten(value, depth - 1, predicate, isStrict, result);
         } else {
           arrayPush(result, value);
         }

_baseFor.js

@@ -1,10 +1,9 @@
 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.

_baseForIn.js

@@ -1,16 +0,0 @@
-define(['./_baseFor', './keysIn'], function(baseFor, keysIn) {
-
-  /**
-   * The base implementation of `_.forIn` without support for iteratee shorthands.
-   *
-   * @private
-   * @param {Object} object The object to iterate over.
-   * @param {Function} iteratee The function invoked per iteration.
-   * @returns {Object} Returns `object`.
-   */
-  function baseForIn(object, iteratee) {
-    return object == null ? object : baseFor(object, iteratee, keysIn);
-  }
-
-  return baseForIn;
-});

_baseFunctions.js

@@ -7,7 +7,7 @@ define(['./_arrayFilter', './isFunction'], function(arrayFilter, isFunction) {
    * @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(['./_baseCastPath', './_isKey'], function(baseCastPath, isKey) {
+define(['./_castPath', './_toKey'], function(castPath, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,13 +12,13 @@ define(['./_baseCastPath', './_isKey'], function(baseCastPath, isKey) {
    * @returns {*} Returns the resolved value.
    */
   function baseGet(object, path) {
-    path = isKey(path, object) ? [path + ''] : baseCastPath(path);
+    path = castPath(path, object);
 
     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,30 @@
+define(['./_Symbol', './_getRawTag', './_objectToString'], function(Symbol, getRawTag, objectToString) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+      undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+  /**
+   * The base implementation of `getTag` without fallbacks for buggy environments.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(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,27 +1,18 @@
-define(['./_indexOfNaN'], function(indexOfNaN) {
+define(['./_baseFindIndex', './_baseIsNaN', './_strictIndexOf'], function(baseFindIndex, baseIsNaN, strictIndexOf) {
 
   /**
    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
    *
    * @private
-   * @param {Array} array The array to search.
+   * @param {Array} array The array to inspect.
    * @param {*} value The value to search for.
    * @param {number} fromIndex The index to search from.
    * @returns {number} Returns the index of the matched value, else `-1`.
    */
   function baseIndexOf(array, value, fromIndex) {
-    if (value !== value) {
-      return indexOfNaN(array, fromIndex);
-    }
-    var index = fromIndex - 1,
-        length = array.length;
-
-    while (++index < length) {
-      if (array[index] === value) {
-        return index;
-      }
-    }
-    return -1;
+    return value === value
+      ? strictIndexOf(array, value, fromIndex)
+      : baseFindIndex(array, baseIsNaN, fromIndex);
   }
 
   return baseIndexOf;

_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 inspect.
+   * @param {*} value The value to search for.
+   * @param {number} fromIndex The index to search from.
+   * @param {Function} comparator The comparator invoked per element.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function baseIndexOfWith(array, value, fromIndex, comparator) {
+    var index = fromIndex - 1,
+        length = array.length;
+
+    while (++index < length) {
+      if (comparator(array[index], value)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  return baseIndexOfWith;
+});

_baseIntersection.js

@@ -3,6 +3,9 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMin = Math.min;
+
   /**
    * The base implementation of methods like `_.intersection`, without support
    * for iteratee shorthands, that accepts an array of arrays to inspect.
@@ -15,9 +18,11 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
    */
   function baseIntersection(arrays, iteratee, comparator) {
     var includes = comparator ? arrayIncludesWith : arrayIncludes,
+        length = arrays[0].length,
         othLength = arrays.length,
         othIndex = othLength,
         caches = Array(othLength),
+        maxLength = Infinity,
         result = [];
 
     while (othIndex--) {
@@ -25,26 +30,27 @@ 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;
 
+      value = (comparator || value !== 0) ? value : 0;
       if (!(seen
             ? cacheHas(seen, computed)
             : includes(result, computed, comparator)
           )) {
-        var othIndex = othLength;
+        othIndex = othLength;
         while (--othIndex) {
           var cache = caches[othIndex];
           if (!(cache

_baseInvoke.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_baseCastPath', './_isKey', './last', './_parent'], function(apply, baseCastPath, isKey, last, parent) {
+define(['./_apply', './_castPath', './last', './_parent', './_toKey'], function(apply, castPath, last, parent, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,12 +14,9 @@ define(['./_apply', './_baseCastPath', './_isKey', './last', './_parent'], funct
    * @returns {*} Returns the result of the invoked method.
    */
   function baseInvoke(object, path, args) {
-    if (!isKey(path, object)) {
-      path = baseCastPath(path);
-      object = parent(object, path);
-      path = last(path);
-    }
-    var func = object == null ? object : object[path];
+    path = castPath(path, object);
+    object = parent(object, path);
+    var func = object == null ? object : object[toKey(last(path))];
     return func == null ? undefined : apply(func, object, args);
   }
 

_baseIsArguments.js

@@ -0,0 +1,18 @@
+define(['./_baseGetTag', './isObjectLike'], function(baseGetTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]';
+
+  /**
+   * The base implementation of `_.isArguments`.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+   */
+  function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag(value) == argsTag;
+  }
+
+  return baseIsArguments;
+});

_baseIsArrayBuffer.js

@@ -0,0 +1,17 @@
+define(['./_baseGetTag', './isObjectLike'], function(baseGetTag, isObjectLike) {
+
+  var arrayBufferTag = '[object ArrayBuffer]';
+
+  /**
+   * 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) && baseGetTag(value) == arrayBufferTag;
+  }
+
+  return baseIsArrayBuffer;
+});

_baseIsDate.js

@@ -0,0 +1,18 @@
+define(['./_baseGetTag', './isObjectLike'], function(baseGetTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var dateTag = '[object Date]';
+
+  /**
+   * 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) && baseGetTag(value) == dateTag;
+  }
+
+  return baseIsDate;
+});

_baseIsEqual.js

@@ -1,4 +1,4 @@
-define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEqualDeep, isObject, isObjectLike) {
+define(['./_baseIsEqualDeep', './isObjectLike'], function(baseIsEqualDeep, isObjectLike) {
 
   /**
    * The base implementation of `_.isEqual` which supports partial comparisons
@@ -7,22 +7,21 @@ define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEq
    * @private
    * @param {*} value The value to compare.
    * @param {*} other The other value to compare.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Unordered comparison
+   *  2 - Partial comparison
    * @param {Function} [customizer] The function to customize comparisons.
-   * @param {boolean} [bitmask] The bitmask of comparison flags.
-   *  The bitmask may be composed of the following flags:
-   *     1 - Unordered comparison
-   *     2 - Partial comparison
    * @param {Object} [stack] Tracks traversed `value` and `other` objects.
    * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
    */
-  function baseIsEqual(value, other, customizer, bitmask, stack) {
+  function baseIsEqual(value, other, bitmask, customizer, stack) {
     if (value === other) {
       return true;
     }
-    if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
       return value !== value && other !== other;
     }
-    return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
   }
 
   return baseIsEqual;

_baseIsEqualDeep.js

@@ -1,7 +1,7 @@
-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', './isBuffer', './isTypedArray'], function(Stack, equalArrays, equalByTag, equalObjects, getTag, isArray, isBuffer, isTypedArray) {
 
-  /** Used to compose bitmasks for comparison styles. */
-  var PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1;
 
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
@@ -22,55 +22,55 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
    * @private
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
    * @param {Function} equalFunc The function to determine equivalents of values.
-   * @param {Function} [customizer] The function to customize comparisons.
-   * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details.
    * @param {Object} [stack] Tracks traversed `object` and `other` objects.
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
-  function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
     var objIsArr = isArray(object),
         othIsArr = isArray(other),
-        objTag = arrayTag,
-        othTag = arrayTag;
+        objTag = objIsArr ? arrayTag : getTag(object),
+        othTag = othIsArr ? arrayTag : getTag(other);
 
-    if (!objIsArr) {
-      objTag = getTag(object);
-      if (objTag == argsTag) {
-        objTag = objectTag;
-      } else if (objTag != objectTag) {
-        objIsArr = isTypedArray(object);
-      }
-    }
-    if (!othIsArr) {
-      othTag = getTag(other);
-      if (othTag == argsTag) {
-        othTag = objectTag;
-      } else if (othTag != objectTag) {
-        othIsArr = isTypedArray(other);
-      }
-    }
-    var objIsObj = objTag == objectTag && !isHostObject(object),
-        othIsObj = othTag == objectTag && !isHostObject(other),
+    objTag = objTag == argsTag ? objectTag : objTag;
+    othTag = othTag == argsTag ? objectTag : othTag;
+
+    var objIsObj = objTag == objectTag,
+        othIsObj = othTag == objectTag,
         isSameTag = objTag == othTag;
 
-    if (isSameTag && !(objIsArr || objIsObj)) {
-      return equalByTag(object, other, objTag, equalFunc, customizer, bitmask);
+    if (isSameTag && isBuffer(object)) {
+      if (!isBuffer(other)) {
+        return false;
+      }
+      objIsArr = true;
+      objIsObj = false;
     }
-    var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
-    if (!isPartial) {
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack);
+      return (objIsArr || isTypedArray(object))
+        ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+        : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    }
+    if (!(bitmask & COMPARE_PARTIAL_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, bitmask, customizer, stack);
       }
     }
     if (!isSameTag) {
       return false;
     }
     stack || (stack = new Stack);
-    return (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, bitmask, stack);
+    return equalObjects(object, other, bitmask, customizer, equalFunc, 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

@@ -3,9 +3,9 @@ define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * The base implementation of `_.isMatch` without support for iteratee shorthands.
@@ -46,11 +46,12 @@ 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)
+              ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
               : result
             )) {
           return false;

_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,45 @@
+define(['./isFunction', './_isMasked', './isObject', './_toSource'], function(isFunction, 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 funcProto = Function.prototype,
+      objectProto = Object.prototype;
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString = funcProto.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) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+  }
+
+  return baseIsNative;
+});

_baseIsRegExp.js

@@ -0,0 +1,18 @@
+define(['./_baseGetTag', './isObjectLike'], function(baseGetTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var regexpTag = '[object RegExp]';
+
+  /**
+   * 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 isObjectLike(value) && baseGetTag(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,59 @@
+define(['./_baseGetTag', './isLength', './isObjectLike'], function(baseGetTag, 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;
+
+  /**
+   * 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[baseGetTag(value)];
+  }
+
+  return baseIsTypedArray;
+});

_baseIteratee.js

@@ -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

@@ -1,18 +1,29 @@
-define([], function() {
+define(['./_isPrototype', './_nativeKeys'], function(isPrototype, nativeKeys) {
 
-  /* Built-in method references for those with the same name as other `lodash` methods. */
-  var nativeKeys = Object.keys;
+  /** 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 skip the constructor
-   * property of prototypes or treat sparse arrays as dense.
+   * 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) {
-    return nativeKeys(Object(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

@@ -1,39 +1,32 @@
-define(['./_Reflect', './_iteratorToArray'], function(Reflect, iteratorToArray) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+define(['./isObject', './_isPrototype', './_nativeKeysIn'], function(isObject, isPrototype, nativeKeysIn) {
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
 
-  /** Built-in value references. */
-  var enumerate = Reflect ? Reflect.enumerate : undefined,
-      propertyIsEnumerable = objectProto.propertyIsEnumerable;
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
 
   /**
-   * The base implementation of `_.keysIn` which doesn't skip the constructor
-   * property of prototypes or treat sparse arrays as dense.
+   * 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) {
-    object = object == null ? object : Object(object);
+    if (!isObject(object)) {
+      return nativeKeysIn(object);
+    }
+    var isProto = isPrototype(object),
+        result = [];
 
-    var result = [];
     for (var key in object) {
-      result.push(key);
+      if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+        result.push(key);
+      }
     }
     return result;
   }
 
-  // Fallback for IE < 9 with es6-shim.
-  if (enumerate && !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf')) {
-    baseKeysIn = function(object) {
-      return iteratorToArray(enumerate(object));
-    };
-  }
-
   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;
+});

_baseMatches.js

@@ -1,28 +1,16 @@
-define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+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 function.
+   * @returns {Function} Returns the new spec function.
    */
   function baseMatches(source) {
     var matchData = getMatchData(source);
     if (matchData.length == 1 && matchData[0][2]) {
-      var key = matchData[0][0],
-          value = matchData[0][1];
-
-      return function(object) {
-        if (object == null) {
-          return false;
-        }
-        return object[key] === value &&
-          (value !== undefined || (key in Object(object)));
-      };
+      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
     }
     return function(object) {
       return object === source || baseIsMatch(object, source, matchData);

_baseMatchesProperty.js

@@ -1,11 +1,11 @@
-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;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
@@ -13,14 +13,17 @@ 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)
         ? hasIn(object, path)
-        : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+        : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
     };
   }
 

_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 == null ? 0 : array.length;
+    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', './_assignMergeValue', './_baseFor', './_baseMergeDeep', './isObject', './keysIn', './_safeGet'], function(Stack, assignMergeValue, baseFor, baseMergeDeep, isObject, keysIn, safeGet) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -11,28 +11,21 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
    * @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);
-
-    arrayEach(props || source, function(srcValue, key) {
-      if (props) {
-        key = srcValue;
-        srcValue = source[key];
-      }
+    baseFor(source, function(srcValue, key) {
       if (isObject(srcValue)) {
         stack || (stack = new Stack);
         baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
       }
       else {
         var newValue = customizer
-          ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+          ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
           : undefined;
 
         if (newValue === undefined) {
@@ -40,7 +33,7 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
         }
         assignMergeValue(object, key, newValue);
       }
-    });
+    }, keysIn);
   }
 
   return baseMerge;

_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', './_cloneBuffer', './_cloneTypedArray', './_copyArray', './_initCloneObject', './isArguments', './isArray', './isArrayLikeObject', './isBuffer', './isFunction', './isObject', './isPlainObject', './isTypedArray', './_safeGet', './toPlainObject'], function(assignMergeValue, cloneBuffer, cloneTypedArray, copyArray, initCloneObject, isArguments, isArray, isArrayLikeObject, isBuffer, isFunction, isObject, isPlainObject, isTypedArray, safeGet, toPlainObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -15,11 +15,12 @@ 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],
+    var objValue = safeGet(object, key),
+        srcValue = safeGet(source, key),
         stacked = stack.get(srcValue);
 
     if (stacked) {
@@ -33,40 +34,48 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
     var isCommon = newValue === undefined;
 
     if (isCommon) {
+      var isArr = isArray(srcValue),
+          isBuff = !isArr && isBuffer(srcValue),
+          isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
       newValue = srcValue;
-      if (isArray(srcValue) || isTypedArray(srcValue)) {
+      if (isArr || isBuff || isTyped) {
         if (isArray(objValue)) {
           newValue = objValue;
         }
         else if (isArrayLikeObject(objValue)) {
           newValue = copyArray(objValue);
         }
-        else {
+        else if (isBuff) {
           isCommon = false;
-          newValue = baseClone(srcValue, true);
+          newValue = cloneBuffer(srcValue, true);
+        }
+        else if (isTyped) {
+          isCommon = false;
+          newValue = cloneTypedArray(srcValue, true);
+        }
+        else {
+          newValue = [];
         }
       }
       else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+        newValue = objValue;
         if (isArguments(objValue)) {
           newValue = toPlainObject(objValue);
         }
         else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
-          isCommon = false;
-          newValue = baseClone(srcValue, true);
-        }
-        else {
-          newValue = objValue;
+          newValue = initCloneObject(srcValue);
         }
       }
       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', './_com
    * @returns {Array} Returns the new sorted array.
    */
   function baseOrderBy(collection, iteratees, orders) {
-    var index = -1,
-        toIteratee = baseIteratee;
-
-    iteratees = arrayMap(iteratees.length ? iteratees : Array(1), function(iteratee) {
-      return toIteratee(iteratee);
-    });
+    var index = -1;
+    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

_basePick.js

@@ -1,22 +1,18 @@
-define(['./_arrayReduce'], function(arrayReduce) {
+define(['./_basePickBy', './hasIn'], function(basePickBy, hasIn) {
 
   /**
    * 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[]} paths The property paths 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;
-    }, {});
+  function basePick(object, paths) {
+    return basePickBy(object, paths, function(value, path) {
+      return hasIn(object, path);
+    });
   }
 
   return basePick;

_basePickBy.js

@@ -1,20 +1,27 @@
-define(['./_baseForIn'], function(baseForIn) {
+define(['./_baseGet', './_baseSet', './_castPath'], function(baseGet, baseSet, castPath) {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
    *
    * @private
    * @param {Object} object The source object.
+   * @param {string[]} paths The property paths to pick.
    * @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) {
-      if (predicate(value, key)) {
-        result[key] = value;
+  function basePickBy(object, paths, predicate) {
+    var index = -1,
+        length = paths.length,
+        result = {};
+
+    while (++index < length) {
+      var path = paths[index],
+          value = baseGet(object, path);
+
+      if (predicate(value, path)) {
+        baseSet(result, castPath(path, object), 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

@@ -5,7 +5,7 @@ define(['./_baseGet'], function(baseGet) {
    *
    * @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) {

_basePropertyOf.js

@@ -0,0 +1,20 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.propertyOf` without support for deep paths.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Function} Returns the new accessor function.
+   */
+  function basePropertyOf(object) {
+    return function(key) {
+      return object == null ? undefined : object[key];
+    };
+  }
+
+  return basePropertyOf;
+});

_basePullAll.js

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

_basePullAllBy.js

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