Bump to v4.14.1.

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.11.2
+# lodash-amd v4.14.1
 
 The [Lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.11.2-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.14.1-amd) for more details.

_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 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 ? entries.length : 0;
 
-  // 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;
 });

_ListCache.js

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

_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 ? entries.length : 0;
 
     this.clear();
     while (++index < length) {
-      var entry = values[index];
+      var entry = entries[index];
       this.set(entry[0], entry[1]);
     }
   }
 
   // Add methods to `MapCache`.
-  MapCache.prototype.clear = mapClear;
-  MapCache.prototype['delete'] = mapDelete;
-  MapCache.prototype.get = mapGet;
-  MapCache.prototype.has = mapHas;
-  MapCache.prototype.set = mapSet;
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype['delete'] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
 
   return MapCache;
 });

_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
@@ -14,12 +14,13 @@ define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
 
     this.__data__ = new MapCache;
     while (++index < length) {
-      this.push(values[index]);
+      this.add(values[index]);
     }
   }
 
   // Add methods to `SetCache`.
-  SetCache.prototype.push = cachePush;
+  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+  SetCache.prototype.has = setCacheHas;
 
   return SetCache;
 });

_Stack.js

@@ -1,21 +1,14 @@
-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) {
+    this.__data__ = new ListCache(entries);
   }
 
   // Add methods to `Stack`.

_addMapEntry.js

@@ -9,7 +9,7 @@ define([], function() {
    * @returns {Object} Returns `map`.
    */
   function addMapEntry(map, pair) {
-    // Don't return `Map#set` because it doesn't return the map instance in IE 11.
+    // 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

@@ -11,8 +11,7 @@ define([], function() {
    * @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 ? array.length : 0;
 
     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 ? array.length : 0;
 
     while (++index < length) {
       if (iteratee(array[index], index, array) === false) {

_arrayEachRight.js

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

_arrayEvery.js

@@ -5,14 +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`.
    */
   function arrayEvery(array, predicate) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (!predicate(array[index], index, array)) {

_arrayFilter.js

@@ -5,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} predicate The function invoked per iteration.
    * @returns {Array} Returns the new filtered array.
    */
   function arrayFilter(array, predicate) {
     var index = -1,
-        length = array.length,
+        length = array ? array.length : 0,
         resIndex = 0,
         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 search.
    * @param {*} target The value to search for.
    * @returns {boolean} Returns `true` if `target` is found, else `false`.
    */
   function arrayIncludes(array, value) {
-    return !!array.length && baseIndexOf(array, value, 0) > -1;
+    var length = array ? array.length : 0;
+    return !!length && baseIndexOf(array, value, 0) > -1;
   }
 
   return arrayIncludes;

_arrayIncludesWith.js

@@ -4,14 +4,14 @@ define([], function() {
    * This function is like `arrayIncludes` except that it accepts a comparator.
    *
    * @private
-   * @param {Array} array The array to search.
+   * @param {Array} [array] The array to search.
    * @param {*} target The value to search for.
    * @param {Function} comparator The comparator invoked per element.
    * @returns {boolean} Returns `true` if `target` is found, else `false`.
    */
   function arrayIncludesWith(array, value, comparator) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (comparator(value, array[index])) {

_arrayMap.js

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

_arrayReduce.js

@@ -5,7 +5,7 @@ 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
@@ -14,7 +14,7 @@ define([], function() {
    */
   function arrayReduce(array, iteratee, accumulator, initAccum) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     if (initAccum && length) {
       accumulator = array[++index];

_arrayReduceRight.js

@@ -5,7 +5,7 @@ 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
@@ -13,7 +13,7 @@ define([], function() {
    * @returns {*} Returns the accumulated value.
    */
   function arrayReduceRight(array, iteratee, accumulator, initAccum) {
-    var length = array.length;
+    var length = array ? array.length : 0;
     if (initAccum && length) {
       accumulator = array[--length];
     }

_arraySome.js

@@ -5,14 +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`.
    */
   function arraySome(array, predicate) {
     var index = -1,
-        length = array.length;
+        length = array ? array.length : 0;
 
     while (++index < length) {
       if (predicate(array[index], index, array)) {

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

_baseAt.js

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

_baseClamp.js

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

_baseClone.js

@@ -112,12 +112,12 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
     if (!isArr) {
       var props = isFull ? getAllKeys(value) : keys(value);
     }
-    // Recursively populate clone (susceptible to call stack limits).
     arrayEach(props || value, function(subValue, key) {
       if (props) {
         key = subValue;
         subValue = value[key];
       }
+      // Recursively populate clone (susceptible to call stack limits).
       assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
     });
     return result;

_baseConforms.js

@@ -1,35 +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,34 @@
+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;
+    }
+    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;
+});

_baseDelay.js

@@ -7,13 +7,13 @@ define([], function() {
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
-   * The base implementation of `_.delay` and `_.defer` which accepts an array
-   * of `func` arguments.
+   * The base implementation of `_.delay` and `_.defer` which accepts `args`
+   * to provide to `func`.
    *
    * @private
    * @param {Function} func The function to delay.
    * @param {number} wait The number of milliseconds to delay invocation.
-   * @param {Object} args The arguments to provide to `func`.
+   * @param {Array} args The arguments to provide to `func`.
    * @returns {number} Returns the timer id.
    */
   function baseDelay(func, wait, args) {

_baseFindIndex.js

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

_baseFindKey.js

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

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

_baseGetAllKeys.js

@@ -13,9 +13,7 @@ define(['./_arrayPush', './isArray'], function(arrayPush, isArray) {
    */
   function baseGetAllKeys(object, keysFunc, symbolsFunc) {
     var result = keysFunc(object);
-    return isArray(object)
-      ? result
-      : arrayPush(result, symbolsFunc(object));
+    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
   }
 
   return baseGetAllKeys;

_baseGetTag.js

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

_baseGt.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.gt` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.gt` which doesn't coerce arguments.
    *
    * @private
    * @param {*} value The value to compare.

_baseHas.js

@@ -10,7 +10,7 @@ define(['./_getPrototype'], function(getPrototype) {
    * 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`.
    */
@@ -18,8 +18,9 @@ define(['./_getPrototype'], function(getPrototype) {
     // 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 && getPrototype(object) === null);
+    return object != null &&
+      (hasOwnProperty.call(object, key) ||
+        (typeof object == 'object' && key in object && getPrototype(object) === null));
   }
 
   return baseHas;

_baseHasIn.js

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

_baseInRange.js

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

_baseIndexOf.js

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

_baseIsArrayBuffer.js

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

_baseIsDate.js

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

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

_baseIsNaN.js

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

_baseIsNative.js

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

_baseIsRegExp.js

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

_baseIsSet.js

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

_baseIsTypedArray.js

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

_baseKeys.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_overArg'], function(overArg) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeKeys = Object.keys;
@@ -11,9 +11,7 @@ define([], function() {
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of property names.
    */
-  function baseKeys(object) {
-    return nativeKeys(Object(object));
-  }
+  var baseKeys = overArg(nativeKeys, Object);
 
   return baseKeys;
 });

_baseLt.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.lt` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.lt` which doesn't coerce arguments.
    *
    * @private
    * @param {*} value The value to compare.

_baseMatches.js

@@ -5,7 +5,7 @@ define(['./_baseIsMatch', './_getMatchData', './_matchesStrictComparable'], func
    *
    * @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);

_baseMatchesProperty.js

@@ -13,7 +13,7 @@ define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable
    * @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)) {

_baseMergeDeep.js

@@ -63,13 +63,12 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
         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);
     }
-    stack['delete'](srcValue);
     assignMergeValue(object, key, newValue);
   }
 

_baseNth.js

@@ -4,7 +4,7 @@ define(['./_isIndex'], function(isIndex) {
   var undefined;
 
   /**
-   * The base implementation of `_.nth` which doesn't coerce `n` to an integer.
+   * The base implementation of `_.nth` which doesn't coerce arguments.
    *
    * @private
    * @param {Array} array The array to query.

_basePick.js

@@ -1,4 +1,4 @@
-define(['./_arrayReduce'], function(arrayReduce) {
+define(['./_basePickBy'], function(basePickBy) {
 
   /**
    * The base implementation of `_.pick` without support for individual
@@ -11,12 +11,9 @@ define(['./_arrayReduce'], function(arrayReduce) {
    */
   function basePick(object, props) {
     object = Object(object);
-    return arrayReduce(props, function(result, key) {
-      if (key in object) {
-        result[key] = object[key];
-      }
-      return result;
-    }, {});
+    return basePickBy(object, props, function(value, key) {
+      return key in object;
+    });
   }
 
   return basePick;

_basePickBy.js

@@ -1,16 +1,16 @@
-define(['./_getAllKeysIn'], function(getAllKeysIn) {
+define([], function() {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
    *
    * @private
    * @param {Object} object The source object.
+   * @param {string[]} props The property identifiers to pick from.
    * @param {Function} predicate The function invoked per property.
    * @returns {Object} Returns the new object.
    */
-  function basePickBy(object, predicate) {
+  function basePickBy(object, props, predicate) {
     var index = -1,
-        props = getAllKeysIn(object),
         length = props.length,
         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,4 +1,4 @@
-define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary'], function(arrayMap, baseIndexOf, baseIndexOfWith, baseUnary) {
+define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary', './_copyArray'], function(arrayMap, baseIndexOf, baseIndexOfWith, baseUnary, copyArray) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -23,6 +23,9 @@ define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary'],
         length = values.length,
         seen = array;
 
+    if (array === values) {
+      values = copyArray(values);
+    }
     if (iteratee) {
       seen = arrayMap(array, baseUnary(iteratee));
     }

_baseRange.js

@@ -6,14 +6,14 @@ define([], function() {
 
   /**
    * The base implementation of `_.range` and `_.rangeRight` which doesn't
-   * coerce arguments to numbers.
+   * coerce arguments.
    *
    * @private
    * @param {number} start The start of the range.
    * @param {number} end The end of the range.
    * @param {number} step The value to increment or decrement by.
    * @param {boolean} [fromRight] Specify iterating from right to left.
-   * @returns {Array} Returns the new array of numbers.
+   * @returns {Array} Returns the range of numbers.
    */
   function baseRange(start, end, step, fromRight) {
     var index = -1,

_baseRest.js

@@ -0,0 +1,39 @@
+define(['./_apply'], function(apply) {
+
+  /** 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 nativeMax = Math.max;
+
+  /**
+   * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+   *
+   * @private
+   * @param {Function} func The function to apply a rest parameter to.
+   * @param {number} [start=func.length-1] The start position of the rest parameter.
+   * @returns {Function} Returns the new function.
+   */
+  function baseRest(func, start) {
+    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+    return function() {
+      var args = arguments,
+          index = -1,
+          length = nativeMax(args.length - start, 0),
+          array = Array(length);
+
+      while (++index < length) {
+        array[index] = args[start + index];
+      }
+      index = -1;
+      var otherArgs = Array(start + 1);
+      while (++index < start) {
+        otherArgs[index] = args[index];
+      }
+      otherArgs[start] = array;
+      return apply(func, this, otherArgs);
+    };
+  }
+
+  return baseRest;
+});

_baseToPairs.js

@@ -7,7 +7,7 @@ define(['./_arrayMap'], function(arrayMap) {
    * @private
    * @param {Object} object The object to query.
    * @param {Array} props The property names to get values for.
-   * @returns {Object} Returns the new array of key-value pairs.
+   * @returns {Object} Returns the key-value pairs.
    */
   function baseToPairs(object, props) {
     return arrayMap(props, function(key) {

_baseUnary.js

@@ -1,11 +1,11 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.unary` without support for storing wrapper metadata.
+   * The base implementation of `_.unary` without support for storing metadata.
    *
    * @private
    * @param {Function} func The function to cap arguments for.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new capped function.
    */
   function baseUnary(func) {
     return function(value) {

_cacheHas.js

@@ -1,25 +1,15 @@
-define(['./_isKeyable'], function(isKeyable) {
-
-  /** Used to stand-in for `undefined` hash values. */
-  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+define([], function() {
 
   /**
-   * Checks if `value` is in `cache`.
+   * Checks if a cache value for `key` exists.
    *
    * @private
-   * @param {Object} cache The set cache to search.
-   * @param {*} value The value to search for.
-   * @returns {number} Returns `true` if `value` is found, else `false`.
+   * @param {Object} cache The cache to query.
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
    */
-  function cacheHas(cache, value) {
-    var map = cache.__data__;
-    if (isKeyable(value)) {
-      var data = map.__data__,
-          hash = typeof value == 'string' ? data.string : data.hash;
-
-      return hash[value] === HASH_UNDEFINED;
-    }
-    return map.has(value);
+  function cacheHas(cache, key) {
+    return cache.has(key);
   }
 
   return cacheHas;

_cachePush.js

@@ -1,28 +0,0 @@
-define(['./_isKeyable'], function(isKeyable) {
-
-  /** Used to stand-in for `undefined` hash values. */
-  var HASH_UNDEFINED = '__lodash_hash_undefined__';
-
-  /**
-   * Adds `value` to the set cache.
-   *
-   * @private
-   * @name push
-   * @memberOf SetCache
-   * @param {*} value The value to cache.
-   */
-  function cachePush(value) {
-    var map = this.__data__;
-    if (isKeyable(value)) {
-      var data = map.__data__,
-          hash = typeof value == 'string' ? data.string : data.hash;
-
-      hash[value] = HASH_UNDEFINED;
-    }
-    else {
-      map.set(value, HASH_UNDEFINED);
-    }
-  }
-
-  return cachePush;
-});

_checkGlobal.js

@@ -1,15 +0,0 @@
-define([], function() {
-
-  /**
-   * Checks if `value` is a global object.
-   *
-   * @private
-   * @param {*} value The value to check.
-   * @returns {null|Object} Returns `value` if it's a global object, else `null`.
-   */
-  function checkGlobal(value) {
-    return (value && value.Object === Object) ? value : null;
-  }
-
-  return checkGlobal;
-});

_composeArgs.js

@@ -8,7 +8,7 @@ define([], function() {
    * placeholders, and provided arguments into a single array of arguments.
    *
    * @private
-   * @param {Array|Object} args The provided arguments.
+   * @param {Array} args The provided arguments.
    * @param {Array} partials The arguments to prepend to those provided.
    * @param {Array} holders The `partials` placeholder indexes.
    * @params {boolean} [isCurried] Specify composing for a curried function.

_composeArgsRight.js

@@ -8,7 +8,7 @@ define([], function() {
    * is tailored for `_.partialRight`.
    *
    * @private
-   * @param {Array|Object} args The provided arguments.
+   * @param {Array} args The provided arguments.
    * @param {Array} partials The arguments to append to those provided.
    * @param {Array} holders The `partials` placeholder indexes.
    * @params {boolean} [isCurried] Specify composing for a curried function.

_copyObject.js

@@ -1,5 +1,8 @@
 define(['./_assignValue'], function(assignValue) {
 
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
   /**
    * Copies properties of `source` to `object`.
    *
@@ -21,9 +24,9 @@ define(['./_assignValue'], function(assignValue) {
 
       var newValue = customizer
         ? customizer(object[key], source[key], key, object, source)
-        : source[key];
+        : undefined;
 
-      assignValue(object, key, newValue);
+      assignValue(object, key, newValue === undefined ? source[key] : newValue);
     }
     return object;
   }

_coreJsData.js

@@ -0,0 +1,7 @@
+define(['./_root'], function(root) {
+
+  /** Used to detect overreaching core-js shims. */
+  var coreJsData = root['__core-js_shared__'];
+
+  return coreJsData;
+});

_createAggregator.js

@@ -13,7 +13,7 @@ define(['./_arrayAggregator', './_baseAggregator', './_baseIteratee', './isArray
       var func = isArray(collection) ? arrayAggregator : baseAggregator,
           accumulator = initializer ? initializer() : {};
 
-      return func(collection, setter, baseIteratee(iteratee), accumulator);
+      return func(collection, setter, baseIteratee(iteratee, 2), accumulator);
     };
   }
 

_createAssigner.js

@@ -1,4 +1,4 @@
-define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
+define(['./_baseRest', './_isIterateeCall'], function(baseRest, isIterateeCall) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -11,13 +11,13 @@ define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
    * @returns {Function} Returns the new assigner function.
    */
   function createAssigner(assigner) {
-    return rest(function(object, sources) {
+    return baseRest(function(object, sources) {
       var index = -1,
           length = sources.length,
           customizer = length > 1 ? sources[length - 1] : undefined,
           guard = length > 2 ? sources[2] : undefined;
 
-      customizer = typeof customizer == 'function'
+      customizer = (assigner.length > 3 && typeof customizer == 'function')
         ? (length--, customizer)
         : undefined;
 

_createBind.js

@@ -1,6 +1,6 @@
-define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
+define(['./_createCtor', './_root'], function(createCtor, root) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1;
 
   /**
@@ -9,14 +9,13 @@ define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
-   *  for more details.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createBaseWrapper(func, bitmask, thisArg) {
+  function createBind(func, bitmask, thisArg) {
     var isBind = bitmask & BIND_FLAG,
-        Ctor = createCtorWrapper(func);
+        Ctor = createCtor(func);
 
     function wrapper() {
       var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
@@ -25,5 +24,5 @@ define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
     return wrapper;
   }
 
-  return createBaseWrapper;
+  return createBind;
 });

_createCaseFirst.js

@@ -8,7 +8,7 @@ define(['./_castSlice', './_reHasComplexSymbol', './_stringToArray', './toString
    *
    * @private
    * @param {string} methodName The name of the `String` case method to use.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new case function.
    */
   function createCaseFirst(methodName) {
     return function(string) {

_createCtor.js

@@ -8,7 +8,7 @@ define(['./_baseCreate', './isObject'], function(baseCreate, isObject) {
    * @param {Function} Ctor The constructor to wrap.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createCtorWrapper(Ctor) {
+  function createCtor(Ctor) {
     return function() {
       // Use a `switch` statement to work with class constructors. See
       // http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
@@ -33,5 +33,5 @@ define(['./_baseCreate', './isObject'], function(baseCreate, isObject) {
     };
   }
 
-  return createCtorWrapper;
+  return createCtor;
 });

_createCurry.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getPlaceholder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getPlaceholder, replaceHolders, root) {
+define(['./_apply', './_createCtor', './_createHybrid', './_createRecurry', './_getHolder', './_replaceHolders', './_root'], function(apply, createCtor, createHybrid, createRecurry, getHolder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -8,19 +8,18 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
-   *  for more details.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
    * @param {number} arity The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createCurryWrapper(func, bitmask, arity) {
-    var Ctor = createCtorWrapper(func);
+  function createCurry(func, bitmask, arity) {
+    var Ctor = createCtor(func);
 
     function wrapper() {
       var length = arguments.length,
           args = Array(length),
           index = length,
-          placeholder = getPlaceholder(wrapper);
+          placeholder = getHolder(wrapper);
 
       while (index--) {
         args[index] = arguments[index];
@@ -31,8 +30,8 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
 
       length -= holders.length;
       if (length < arity) {
-        return createRecurryWrapper(
-          func, bitmask, createHybridWrapper, wrapper.placeholder, undefined,
+        return createRecurry(
+          func, bitmask, createHybrid, wrapper.placeholder, undefined,
           args, holders, undefined, undefined, arity - length);
       }
       var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
@@ -41,5 +40,5 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
     return wrapper;
   }
 
-  return createCurryWrapper;
+  return createCurry;
 });

_createFind.js

@@ -0,0 +1,27 @@
+define(['./_baseIteratee', './isArrayLike', './keys'], function(baseIteratee, isArrayLike, keys) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Creates a `_.find` or `_.findLast` function.
+   *
+   * @private
+   * @param {Function} findIndexFunc The function to find the collection index.
+   * @returns {Function} Returns the new find function.
+   */
+  function createFind(findIndexFunc) {
+    return function(collection, predicate, fromIndex) {
+      var iterable = Object(collection);
+      if (!isArrayLike(collection)) {
+        var iteratee = baseIteratee(predicate, 3);
+        collection = keys(collection);
+        predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+      }
+      var index = findIndexFunc(collection, predicate, fromIndex);
+      return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+    };
+  }
+
+  return createFind;
+});

_createFlow.js

@@ -1,4 +1,4 @@
-define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', './isArray', './_isLaziable', './rest'], function(LodashWrapper, baseFlatten, getData, getFuncName, isArray, isLaziable, rest) {
+define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_getFuncName', './isArray', './_isLaziable'], function(LodashWrapper, baseFlatten, baseRest, getData, getFuncName, isArray, isLaziable) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -9,7 +9,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var CURRY_FLAG = 8,
       PARTIAL_FLAG = 32,
       ARY_FLAG = 128,
@@ -23,7 +23,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
    * @returns {Function} Returns the new flow function.
    */
   function createFlow(fromRight) {
-    return rest(function(funcs) {
+    return baseRest(function(funcs) {
       funcs = baseFlatten(funcs, 1);
 
       var length = funcs.length,

_createHybrid.js

@@ -1,9 +1,9 @@
-define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getPlaceholder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getPlaceholder, reorder, replaceHolders, root) {
+define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtor', './_createRecurry', './_getHolder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtor, createRecurry, getHolder, reorder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_FLAG = 8,
@@ -17,8 +17,7 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    *
    * @private
    * @param {Function|string} func The function or method name to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
-   *  for more details.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
    * @param {Array} [partials] The arguments to prepend to those provided to
    *  the new function.
@@ -31,24 +30,24 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
+  function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
     var isAry = bitmask & ARY_FLAG,
         isBind = bitmask & BIND_FLAG,
         isBindKey = bitmask & BIND_KEY_FLAG,
         isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
         isFlip = bitmask & FLIP_FLAG,
-        Ctor = isBindKey ? undefined : createCtorWrapper(func);
+        Ctor = isBindKey ? undefined : createCtor(func);
 
     function wrapper() {
       var length = arguments.length,
-          index = length,
-          args = Array(length);
+          args = Array(length),
+          index = length;
 
       while (index--) {
         args[index] = arguments[index];
       }
       if (isCurried) {
-        var placeholder = getPlaceholder(wrapper),
+        var placeholder = getHolder(wrapper),
             holdersCount = countHolders(args, placeholder);
       }
       if (partials) {
@@ -60,8 +59,8 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
       length -= holdersCount;
       if (isCurried && length < arity) {
         var newHolders = replaceHolders(args, placeholder);
-        return createRecurryWrapper(
-          func, bitmask, createHybridWrapper, wrapper.placeholder, thisArg,
+        return createRecurry(
+          func, bitmask, createHybrid, wrapper.placeholder, thisArg,
           args, newHolders, argPos, ary, arity - length
         );
       }
@@ -78,12 +77,12 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
         args.length = ary;
       }
       if (this && this !== root && this instanceof wrapper) {
-        fn = Ctor || createCtorWrapper(fn);
+        fn = Ctor || createCtor(fn);
       }
       return fn.apply(thisBinding, args);
     }
     return wrapper;
   }
 
-  return createHybridWrapper;
+  return createHybrid;
 });

_createMathOperation.js

@@ -8,13 +8,14 @@ define(['./_baseToNumber', './_baseToString'], function(baseToNumber, baseToStri
    *
    * @private
    * @param {Function} operator The function to perform the operation.
+   * @param {number} [defaultValue] The value used for `undefined` arguments.
    * @returns {Function} Returns the new mathematical operation function.
    */
-  function createMathOperation(operator) {
+  function createMathOperation(operator, defaultValue) {
     return function(value, other) {
       var result;
       if (value === undefined && other === undefined) {
-        return 0;
+        return defaultValue;
       }
       if (value !== undefined) {
         result = value;

_createOver.js

@@ -1,19 +1,19 @@
-define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseUnary', './isArray', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, baseUnary, isArray, isFlattenableIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseRest', './_baseUnary', './isArray'], function(apply, arrayMap, baseFlatten, baseIteratee, baseRest, baseUnary, isArray) {
 
   /**
    * Creates a function like `_.over`.
    *
    * @private
    * @param {Function} arrayFunc The function to iterate over iteratees.
-   * @returns {Function} Returns the new invoker function.
+   * @returns {Function} Returns the new over function.
    */
   function createOver(arrayFunc) {
-    return rest(function(iteratees) {
+    return baseRest(function(iteratees) {
       iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
         ? arrayMap(iteratees[0], baseUnary(baseIteratee))
-        : arrayMap(baseFlatten(iteratees, 1, isFlattenableIteratee), baseUnary(baseIteratee));
+        : arrayMap(baseFlatten(iteratees, 1), baseUnary(baseIteratee));
 
-      return rest(function(args) {
+      return baseRest(function(args) {
         var thisArg = this;
         return arrayFunc(iteratees, function(iteratee) {
           return apply(iteratee, thisArg, args);

_createPartial.js

@@ -1,6 +1,6 @@
-define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCtorWrapper, root) {
+define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, root) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1;
 
   /**
@@ -9,16 +9,15 @@ define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCt
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
-   *  for more details.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
    * @param {*} thisArg The `this` binding of `func`.
    * @param {Array} partials The arguments to prepend to those provided to
    *  the new function.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createPartialWrapper(func, bitmask, thisArg, partials) {
+  function createPartial(func, bitmask, thisArg, partials) {
     var isBind = bitmask & BIND_FLAG,
-        Ctor = createCtorWrapper(func);
+        Ctor = createCtor(func);
 
     function wrapper() {
       var argsIndex = -1,
@@ -39,5 +38,5 @@ define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCt
     return wrapper;
   }
 
-  return createPartialWrapper;
+  return createPartial;
 });

_createRange.js

@@ -1,4 +1,4 @@
-define(['./_baseRange', './_isIterateeCall', './toNumber'], function(baseRange, isIterateeCall, toNumber) {
+define(['./_baseRange', './_isIterateeCall', './toFinite'], function(baseRange, isIterateeCall, toFinite) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -16,15 +16,14 @@ define(['./_baseRange', './_isIterateeCall', './toNumber'], function(baseRange,
         end = step = undefined;
       }
       // Ensure the sign of `-0` is preserved.
-      start = toNumber(start);
-      start = start === start ? start : 0;
+      start = toFinite(start);
       if (end === undefined) {
         end = start;
         start = 0;
       } else {
-        end = toNumber(end) || 0;
+        end = toFinite(end);
       }
-      step = step === undefined ? (start < end ? 1 : -1) : (toNumber(step) || 0);
+      step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
       return baseRange(start, end, step, fromRight);
     };
   }

_createRecurry.js

@@ -1,9 +1,9 @@
-define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
+define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziable, setData, setWrapToString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_BOUND_FLAG = 4,
@@ -16,8 +16,7 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
-   *  for more details.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
    * @param {Function} wrapFunc The function to create the `func` wrapper.
    * @param {*} placeholder The placeholder value.
    * @param {*} [thisArg] The `this` binding of `func`.
@@ -29,7 +28,7 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
+  function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
     var isCurry = bitmask & CURRY_FLAG,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
@@ -52,8 +51,8 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
       setData(result, newData);
     }
     result.placeholder = placeholder;
-    return result;
+    return setWrapToString(result, func, bitmask);
   }
 
-  return createRecurryWrapper;
+  return createRecurry;
 });

_createRound.js

@@ -1,5 +1,8 @@
 define(['./toInteger', './toNumber', './toString'], function(toInteger, toNumber, toString) {
 
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMin = Math.min;
+
   /**
    * Creates a function like `_.round`.
    *
@@ -11,7 +14,7 @@ define(['./toInteger', './toNumber', './toString'], function(toInteger, toNumber
     var func = Math[methodName];
     return function(number, precision) {
       number = toNumber(number);
-      precision = toInteger(precision);
+      precision = nativeMin(toInteger(precision), 292);
       if (precision) {
         // Shift with exponential notation to avoid floating-point issues.
         // See [MDN](https://mdn.io/round#Examples) for more details.

_createSet.js

@@ -4,7 +4,7 @@ define(['./_Set', './noop', './_setToArray'], function(Set, noop, setToArray) {
   var INFINITY = 1 / 0;
 
   /**
-   * Creates a set of `values`.
+   * Creates a set object of `values`.
    *
    * @private
    * @param {Array} values The values to add to the set.

_createToPairs.js

@@ -0,0 +1,28 @@
+define(['./_baseToPairs', './_getTag', './_mapToArray', './_setToPairs'], function(baseToPairs, getTag, mapToArray, setToPairs) {
+
+  /** `Object#toString` result references. */
+  var mapTag = '[object Map]',
+      setTag = '[object Set]';
+
+  /**
+   * Creates a `_.toPairs` or `_.toPairsIn` function.
+   *
+   * @private
+   * @param {Function} keysFunc The function to get the keys of a given object.
+   * @returns {Function} Returns the new pairs function.
+   */
+  function createToPairs(keysFunc) {
+    return function(object) {
+      var tag = getTag(object);
+      if (tag == mapTag) {
+        return mapToArray(object);
+      }
+      if (tag == setTag) {
+        return setToPairs(object);
+      }
+      return baseToPairs(object, keysFunc(object));
+    };
+  }
+
+  return createToPairs;
+});

_createWrap.js

@@ -1,4 +1,4 @@
-define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_createHybridWrapper', './_createPartialWrapper', './_getData', './_mergeData', './_setData', './toInteger'], function(baseSetData, createBaseWrapper, createCurryWrapper, createHybridWrapper, createPartialWrapper, getData, mergeData, setData, toInteger) {
+define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid', './_createPartial', './_getData', './_mergeData', './_setData', './_setWrapToString', './toInteger'], function(baseSetData, createBind, createCurry, createHybrid, createPartial, getData, mergeData, setData, setWrapToString, toInteger) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -6,7 +6,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_FLAG = 8,
@@ -23,7 +23,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
    *
    * @private
    * @param {Function|string} func The function or method name to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags.
+   * @param {number} bitmask The bitmask flags.
    *  The bitmask may be composed of the following flags:
    *     1 - `_.bind`
    *     2 - `_.bindKey`
@@ -34,6 +34,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
    *    64 - `_.partialRight`
    *   128 - `_.rearg`
    *   256 - `_.ary`
+   *   512 - `_.flip`
    * @param {*} [thisArg] The `this` binding of `func`.
    * @param {Array} [partials] The arguments to be partially applied.
    * @param {Array} [holders] The `partials` placeholder indexes.
@@ -42,7 +43,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
+  function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
     var isBindKey = bitmask & BIND_KEY_FLAG;
     if (!isBindKey && typeof func != 'function') {
       throw new TypeError(FUNC_ERROR_TEXT);
@@ -85,17 +86,17 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
       bitmask &= ~(CURRY_FLAG | CURRY_RIGHT_FLAG);
     }
     if (!bitmask || bitmask == BIND_FLAG) {
-      var result = createBaseWrapper(func, bitmask, thisArg);
+      var result = createBind(func, bitmask, thisArg);
     } else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
-      result = createCurryWrapper(func, bitmask, arity);
+      result = createCurry(func, bitmask, arity);
     } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
-      result = createPartialWrapper(func, bitmask, thisArg, partials);
+      result = createPartial(func, bitmask, thisArg, partials);
     } else {
-      result = createHybridWrapper.apply(undefined, newData);
+      result = createHybrid.apply(undefined, newData);
     }
     var setter = data ? baseSetData : setData;
-    return setter(result, newData);
+    return setWrapToString(setter(result, newData), func, bitmask);
   }
 
-  return createWrapper;
+  return createWrap;
 });

_deburrLetter.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_basePropertyOf'], function(basePropertyOf) {
 
   /** Used to map latin-1 supplementary letters to basic latin letters. */
   var deburredLetters = {
@@ -28,9 +28,7 @@ define([], function() {
    * @param {string} letter The matched letter to deburr.
    * @returns {string} Returns the deburred letter.
    */
-  function deburrLetter(letter) {
-    return deburredLetters[letter];
-  }
+  var deburrLetter = basePropertyOf(deburredLetters);
 
   return deburrLetter;
 });

_defineProperty.js

@@ -0,0 +1,15 @@
+define(['./_getNative'], function(getNative) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /* Used to set `toString` methods. */
+  var defineProperty = (function() {
+    var func = getNative(Object, 'defineProperty'),
+        name = getNative.name;
+
+    return (name && name.length > 2) ? func : undefined;
+  }());
+
+  return defineProperty;
+});

_equalArrays.js

@@ -1,4 +1,4 @@
-define(['./_arraySome'], function(arraySome) {
+define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -22,9 +22,7 @@ define(['./_arraySome'], function(arraySome) {
    * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
    */
   function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
-    var index = -1,
-        isPartial = bitmask & PARTIAL_COMPARE_FLAG,
-        isUnordered = bitmask & UNORDERED_COMPARE_FLAG,
+    var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
         arrLength = array.length,
         othLength = other.length;
 
@@ -33,11 +31,15 @@ define(['./_arraySome'], function(arraySome) {
     }
     // Assume cyclic values are equal.
     var stacked = stack.get(array);
-    if (stacked) {
+    if (stacked && stack.get(other)) {
       return stacked == other;
     }
-    var result = true;
+    var index = -1,
+        result = true,
+        seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+
     stack.set(array, other);
+    stack.set(other, array);
 
     // Ignore non-index properties.
     while (++index < arrLength) {
@@ -57,10 +59,12 @@ define(['./_arraySome'], function(arraySome) {
         break;
       }
       // Recursively compare arrays (susceptible to call stack limits).
-      if (isUnordered) {
-        if (!arraySome(other, function(othValue) {
-              return arrValue === othValue ||
-                equalFunc(arrValue, othValue, customizer, bitmask, stack);
+      if (seen) {
+        if (!arraySome(other, function(othValue, othIndex) {
+              if (!seen.has(othIndex) &&
+                  (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+                return seen.add(othIndex);
+              }
             })) {
           result = false;
           break;
@@ -74,6 +78,7 @@ define(['./_arraySome'], function(arraySome) {
       }
     }
     stack['delete'](array);
+    stack['delete'](other);
     return result;
   }
 

_equalByTag.js

@@ -1,4 +1,4 @@
-define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, equalArrays, mapToArray, setToArray) {
+define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, eq, equalArrays, mapToArray, setToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -62,18 +62,14 @@ define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_set
 
       case boolTag:
       case dateTag:
-        // Coerce dates and booleans to numbers, dates to milliseconds and
-        // booleans to `1` or `0` treating invalid dates coerced to `NaN` as
-        // not equal.
-        return +object == +other;
+      case numberTag:
+        // Coerce booleans to `1` or `0` and dates to milliseconds.
+        // Invalid dates are coerced to `NaN`.
+        return eq(+object, +other);
 
       case errorTag:
         return object.name == other.name && object.message == other.message;
 
-      case numberTag:
-        // Treat `NaN` vs. `NaN` as equal.
-        return (object != +object) ? other != +other : object == +other;
-
       case regexpTag:
       case stringTag:
         // Coerce regexes to strings and treat strings, primitives and objects,
@@ -97,10 +93,12 @@ define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_set
           return stacked == other;
         }
         bitmask |= UNORDERED_COMPARE_FLAG;
-        stack.set(object, other);
 
         // Recursively compare objects (susceptible to call stack limits).
-        return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        stack.set(object, other);
+        var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        stack['delete'](object);
+        return result;
 
       case symbolTag:
         if (symbolValueOf) {

_equalObjects.js

@@ -39,11 +39,12 @@ define(['./_baseHas', './keys'], function(baseHas, keys) {
     }
     // Assume cyclic values are equal.
     var stacked = stack.get(object);
-    if (stacked) {
+    if (stacked && stack.get(other)) {
       return stacked == other;
     }
     var result = true;
     stack.set(object, other);
+    stack.set(other, object);
 
     var skipCtor = isPartial;
     while (++index < objLength) {
@@ -79,6 +80,7 @@ define(['./_baseHas', './keys'], function(baseHas, keys) {
       }
     }
     stack['delete'](object);
+    stack['delete'](other);
     return result;
   }
 

_escapeHtmlChar.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_basePropertyOf'], function(basePropertyOf) {
 
   /** Used to map characters to HTML entities. */
   var htmlEscapes = {
@@ -17,9 +17,7 @@ define([], function() {
    * @param {string} chr The matched character to escape.
    * @returns {string} Returns the escaped character.
    */
-  function escapeHtmlChar(chr) {
-    return htmlEscapes[chr];
-  }
+  var escapeHtmlChar = basePropertyOf(htmlEscapes);
 
   return escapeHtmlChar;
 });

_freeGlobal.js

@@ -0,0 +1,7 @@
+define([], function() {
+
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+  return freeGlobal;
+});

_getHolder.js

@@ -7,10 +7,10 @@ define([], function() {
    * @param {Function} func The function to inspect.
    * @returns {*} Returns the placeholder value.
    */
-  function getPlaceholder(func) {
+  function getHolder(func) {
     var object = func;
     return object.placeholder;
   }
 
-  return getPlaceholder;
+  return getHolder;
 });

_getMapData.js

@@ -0,0 +1,19 @@
+define(['./_isKeyable'], function(isKeyable) {
+
+  /**
+   * Gets the data for `map`.
+   *
+   * @private
+   * @param {Object} map The map to query.
+   * @param {string} key The reference key.
+   * @returns {*} Returns the map data.
+   */
+  function getMapData(map, key) {
+    var data = map.__data__;
+    return isKeyable(key)
+      ? data[typeof key == 'string' ? 'string' : 'hash']
+      : data.map;
+  }
+
+  return getMapData;
+});

_getMatchData.js

@@ -1,4 +1,4 @@
-define(['./_isStrictComparable', './toPairs'], function(isStrictComparable, toPairs) {
+define(['./_isStrictComparable', './keys'], function(isStrictComparable, keys) {
 
   /**
    * Gets the property names, values, and compare flags of `object`.
@@ -8,11 +8,14 @@ define(['./_isStrictComparable', './toPairs'], function(isStrictComparable, toPa
    * @returns {Array} Returns the match data of `object`.
    */
   function getMatchData(object) {
-    var result = toPairs(object),
+    var result = keys(object),
         length = result.length;
 
     while (length--) {
-      result[length][2] = isStrictComparable(result[length][1]);
+      var key = result[length],
+          value = object[key];
+
+      result[length] = [key, value, isStrictComparable(value)];
     }
     return result;
   }

_getNative.js

@@ -1,4 +1,4 @@
-define(['./isNative'], function(isNative) {
+define(['./_baseIsNative', './_getValue'], function(baseIsNative, getValue) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,8 +12,8 @@ define(['./isNative'], function(isNative) {
    * @returns {*} Returns the function if it's native, else `undefined`.
    */
   function getNative(object, key) {
-    var value = object[key];
-    return isNative(value) ? value : undefined;
+    var value = getValue(object, key);
+    return baseIsNative(value) ? value : undefined;
   }
 
   return getNative;

_getPrototype.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_overArg'], function(overArg) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeGetPrototype = Object.getPrototypeOf;
@@ -10,9 +10,7 @@ define([], function() {
    * @param {*} value The value to query.
    * @returns {null|Object} Returns the `[[Prototype]]`.
    */
-  function getPrototype(value) {
-    return nativeGetPrototype(Object(value));
-  }
+  var getPrototype = overArg(nativeGetPrototype, Object);
 
   return getPrototype;
 });

_getSymbols.js

@@ -1,7 +1,7 @@
-define([], function() {
+define(['./_overArg', './stubArray'], function(overArg, stubArray) {
 
-  /** Built-in value references. */
-  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
    * Creates an array of the own enumerable symbol properties of `object`.
@@ -10,18 +10,7 @@ define([], function() {
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of symbols.
    */
-  function getSymbols(object) {
-    // Coerce `object` to an object to avoid non-object errors in V8.
-    // See https://bugs.chromium.org/p/v8/issues/detail?id=3443 for more details.
-    return getOwnPropertySymbols(Object(object));
-  }
-
-  // Fallback for IE < 11.
-  if (!getOwnPropertySymbols) {
-    getSymbols = function() {
-      return [];
-    };
-  }
+  var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
 
   return getSymbols;
 });