Bump to v4.13.0.

README.md

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

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

_baseConforms.js

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

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

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

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

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

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

_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

@@ -13,7 +13,7 @@ define([], function() {
    * @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,

_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

@@ -5,7 +5,7 @@ define([], function() {
    *
    * @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;
-});

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

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

_createAssigner.js

@@ -17,7 +17,7 @@ define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
           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;
 

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

_createCurryWrapper.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getPlaceholder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getPlaceholder, replaceHolders, root) {
+define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getHolder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getHolder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -20,7 +20,7 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
       var length = arguments.length,
           args = Array(length),
           index = length,
-          placeholder = getPlaceholder(wrapper);
+          placeholder = getHolder(wrapper);
 
       while (index--) {
         args[index] = arguments[index];

_createHybridWrapper.js

@@ -1,4 +1,4 @@
-define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getPlaceholder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getPlaceholder, reorder, replaceHolders, root) {
+define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getHolder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getHolder, reorder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -41,14 +41,14 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
 
     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) {

_createOver.js

@@ -5,7 +5,7 @@ define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_base
    *
    * @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) {

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

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

_createWrapper.js

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

_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;
 
@@ -36,7 +34,10 @@ define(['./_arraySome'], function(arraySome) {
     if (stacked) {
       return stacked == other;
     }
-    var result = true;
+    var index = -1,
+        result = true,
+        seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+
     stack.set(array, other);
 
     // Ignore non-index properties.
@@ -57,10 +58,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;

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

_getSymbols.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./stubArray'], function(stubArray) {
 
   /** Built-in value references. */
   var getOwnPropertySymbols = Object.getOwnPropertySymbols;
@@ -18,9 +18,7 @@ define([], function() {
 
   // Fallback for IE < 11.
   if (!getOwnPropertySymbols) {
-    getSymbols = function() {
-      return [];
-    };
+    getSymbols = stubArray;
   }
 
   return getSymbols;

_getValue.js

@@ -0,0 +1,19 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Gets the value at `key` of `object`.
+   *
+   * @private
+   * @param {Object} [object] The object to query.
+   * @param {string} key The key of the property to get.
+   * @returns {*} Returns the property value.
+   */
+  function getValue(object, key) {
+    return object == null ? undefined : object[key];
+  }
+
+  return getValue;
+});

_hashClear.js

@@ -0,0 +1,15 @@
+define(['./_nativeCreate'], function(nativeCreate) {
+
+  /**
+   * Removes all key-value entries from the hash.
+   *
+   * @private
+   * @name clear
+   * @memberOf Hash
+   */
+  function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  }
+
+  return hashClear;
+});

_hashDelete.js

@@ -1,15 +1,17 @@
-define(['./_hashHas'], function(hashHas) {
+define([], function() {
 
   /**
    * Removes `key` and its value from the hash.
    *
    * @private
+   * @name delete
+   * @memberOf Hash
    * @param {Object} hash The hash to modify.
    * @param {string} key The key of the value to remove.
    * @returns {boolean} Returns `true` if the entry was removed, else `false`.
    */
-  function hashDelete(hash, key) {
-    return hashHas(hash, key) && delete hash[key];
+  function hashDelete(key) {
+    return this.has(key) && delete this.__data__[key];
   }
 
   return hashDelete;

_hashGet.js

@@ -16,16 +16,18 @@ define(['./_nativeCreate'], function(nativeCreate) {
    * Gets the hash value for `key`.
    *
    * @private
-   * @param {Object} hash The hash to query.
+   * @name get
+   * @memberOf Hash
    * @param {string} key The key of the value to get.
    * @returns {*} Returns the entry value.
    */
-  function hashGet(hash, key) {
+  function hashGet(key) {
+    var data = this.__data__;
     if (nativeCreate) {
-      var result = hash[key];
+      var result = data[key];
       return result === HASH_UNDEFINED ? undefined : result;
     }
-    return hasOwnProperty.call(hash, key) ? hash[key] : undefined;
+    return hasOwnProperty.call(data, key) ? data[key] : undefined;
   }
 
   return hashGet;

_hashHas.js

@@ -13,12 +13,14 @@ define(['./_nativeCreate'], function(nativeCreate) {
    * Checks if a hash value for `key` exists.
    *
    * @private
-   * @param {Object} hash The hash to query.
+   * @name has
+   * @memberOf Hash
    * @param {string} key The key of the entry to check.
    * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
    */
-  function hashHas(hash, key) {
-    return nativeCreate ? hash[key] !== undefined : hasOwnProperty.call(hash, key);
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
   }
 
   return hashHas;

_hashSet.js

@@ -10,12 +10,16 @@ define(['./_nativeCreate'], function(nativeCreate) {
    * Sets the hash `key` to `value`.
    *
    * @private
-   * @param {Object} hash The hash to modify.
+   * @name set
+   * @memberOf Hash
    * @param {string} key The key of the value to set.
    * @param {*} value The value to set.
+   * @returns {Object} Returns the hash instance.
    */
-  function hashSet(hash, key, value) {
-    hash[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+  function hashSet(key, value) {
+    var data = this.__data__;
+    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+    return this;
   }
 
   return hashSet;

_indexOfNaN.js

@@ -11,7 +11,7 @@ define([], function() {
    */
   function indexOfNaN(array, fromIndex, fromRight) {
     var length = array.length,
-        index = fromIndex + (fromRight ? 0 : -1);
+        index = fromIndex + (fromRight ? 1 : -1);
 
     while ((fromRight ? index-- : ++index < length)) {
       var other = array[index];

_isFlattenable.js

@@ -1,4 +1,4 @@
-define(['./isArguments', './isArray', './isArrayLikeObject'], function(isArguments, isArray, isArrayLikeObject) {
+define(['./isArguments', './isArray'], function(isArguments, isArray) {
 
   /**
    * Checks if `value` is a flattenable `arguments` object or array.
@@ -8,7 +8,7 @@ define(['./isArguments', './isArray', './isArrayLikeObject'], function(isArgumen
    * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
    */
   function isFlattenable(value) {
-    return isArrayLikeObject(value) && (isArray(value) || isArguments(value));
+    return isArray(value) || isArguments(value);
   }
 
   return isFlattenable;

_isMaskable.js

@@ -0,0 +1,13 @@
+define(['./_coreJsData', './isFunction', './stubFalse'], function(coreJsData, isFunction, stubFalse) {
+
+  /**
+   * Checks if `func` is capable of being masked.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
+   */
+  var isMaskable = !coreJsData ? stubFalse : isFunction;
+
+  return isMaskable;
+});

_isMasked.js

@@ -0,0 +1,21 @@
+define(['./_coreJsData'], function(coreJsData) {
+
+  /** Used to detect methods masquerading as native. */
+  var maskSrcKey = (function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+    return uid ? ('Symbol(src)_1.' + uid) : '';
+  }());
+
+  /**
+   * Checks if `func` has its source masked.
+   *
+   * @private
+   * @param {Function} func The function to check.
+   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+   */
+  function isMasked(func) {
+    return !!maskSrcKey && (maskSrcKey in func);
+  }
+
+  return isMasked;
+});

_listCacheClear.js

@@ -0,0 +1,15 @@
+define([], function() {
+
+  /**
+   * Removes all key-value entries from the list cache.
+   *
+   * @private
+   * @name clear
+   * @memberOf ListCache
+   */
+  function listCacheClear() {
+    this.__data__ = [];
+  }
+
+  return listCacheClear;
+});

_listCacheDelete.js

@@ -7,26 +7,29 @@ define(['./_assocIndexOf'], function(assocIndexOf) {
   var splice = arrayProto.splice;
 
   /**
-   * Removes `key` and its value from the associative array.
+   * Removes `key` and its value from the list cache.
    *
    * @private
-   * @param {Array} array The array to modify.
+   * @name delete
+   * @memberOf ListCache
    * @param {string} key The key of the value to remove.
    * @returns {boolean} Returns `true` if the entry was removed, else `false`.
    */
-  function assocDelete(array, key) {
-    var index = assocIndexOf(array, key);
+  function listCacheDelete(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
     if (index < 0) {
       return false;
     }
-    var lastIndex = array.length - 1;
+    var lastIndex = data.length - 1;
     if (index == lastIndex) {
-      array.pop();
+      data.pop();
     } else {
-      splice.call(array, index, 1);
+      splice.call(data, index, 1);
     }
     return true;
   }
 
-  return assocDelete;
+  return listCacheDelete;
 });

_listCacheGet.js

@@ -4,17 +4,20 @@ define(['./_assocIndexOf'], function(assocIndexOf) {
   var undefined;
 
   /**
-   * Gets the associative array value for `key`.
+   * Gets the list cache value for `key`.
    *
    * @private
-   * @param {Array} array The array to query.
+   * @name get
+   * @memberOf ListCache
    * @param {string} key The key of the value to get.
    * @returns {*} Returns the entry value.
    */
-  function assocGet(array, key) {
-    var index = assocIndexOf(array, key);
-    return index < 0 ? undefined : array[index][1];
+  function listCacheGet(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    return index < 0 ? undefined : data[index][1];
   }
 
-  return assocGet;
+  return listCacheGet;
 });

_listCacheHas.js

@@ -1,16 +1,17 @@
 define(['./_assocIndexOf'], function(assocIndexOf) {
 
   /**
-   * Checks if an associative array value for `key` exists.
+   * Checks if a list cache value for `key` exists.
    *
    * @private
-   * @param {Array} array The array to query.
+   * @name has
+   * @memberOf ListCache
    * @param {string} key The key of the entry to check.
    * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
    */
-  function assocHas(array, key) {
-    return assocIndexOf(array, key) > -1;
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
   }
 
-  return assocHas;
+  return listCacheHas;
 });

_listCacheSet.js

@@ -0,0 +1,26 @@
+define(['./_assocIndexOf'], function(assocIndexOf) {
+
+  /**
+   * Sets the list cache `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf ListCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the list cache instance.
+   */
+  function listCacheSet(key, value) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    if (index < 0) {
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+
+  return listCacheSet;
+});

_mapCacheClear.js

@@ -1,4 +1,4 @@
-define(['./_Hash', './_Map'], function(Hash, Map) {
+define(['./_Hash', './_ListCache', './_Map'], function(Hash, ListCache, Map) {
 
   /**
    * Removes all key-value entries from the map.
@@ -7,13 +7,13 @@ define(['./_Hash', './_Map'], function(Hash, Map) {
    * @name clear
    * @memberOf MapCache
    */
-  function mapClear() {
+  function mapCacheClear() {
     this.__data__ = {
       'hash': new Hash,
-      'map': Map ? new Map : [],
+      'map': new (Map || ListCache),
       'string': new Hash
     };
   }
 
-  return mapClear;
+  return mapCacheClear;
 });

_mapCacheDelete.js

@@ -0,0 +1,17 @@
+define(['./_getMapData'], function(getMapData) {
+
+  /**
+   * Removes `key` and its value from the map.
+   *
+   * @private
+   * @name delete
+   * @memberOf MapCache
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function mapCacheDelete(key) {
+    return getMapData(this, key)['delete'](key);
+  }
+
+  return mapCacheDelete;
+});

_mapCacheGet.js

@@ -0,0 +1,17 @@
+define(['./_getMapData'], function(getMapData) {
+
+  /**
+   * Gets the map value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf MapCache
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+  }
+
+  return mapCacheGet;
+});

_mapCacheHas.js

@@ -0,0 +1,17 @@
+define(['./_getMapData'], function(getMapData) {
+
+  /**
+   * Checks if a map value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf MapCache
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+  }
+
+  return mapCacheHas;
+});

_mapCacheSet.js

@@ -0,0 +1,19 @@
+define(['./_getMapData'], function(getMapData) {
+
+  /**
+   * Sets the map `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf MapCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the map cache instance.
+   */
+  function mapCacheSet(key, value) {
+    getMapData(this, key).set(key, value);
+    return this;
+  }
+
+  return mapCacheSet;
+});

_mapDelete.js

@@ -1,21 +0,0 @@
-define(['./_Map', './_assocDelete', './_hashDelete', './_isKeyable'], function(Map, assocDelete, hashDelete, isKeyable) {
-
-  /**
-   * Removes `key` and its value from the map.
-   *
-   * @private
-   * @name delete
-   * @memberOf MapCache
-   * @param {string} key The key of the value to remove.
-   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
-   */
-  function mapDelete(key) {
-    var data = this.__data__;
-    if (isKeyable(key)) {
-      return hashDelete(typeof key == 'string' ? data.string : data.hash, key);
-    }
-    return Map ? data.map['delete'](key) : assocDelete(data.map, key);
-  }
-
-  return mapDelete;
-});

_mapGet.js

@@ -1,21 +0,0 @@
-define(['./_Map', './_assocGet', './_hashGet', './_isKeyable'], function(Map, assocGet, hashGet, isKeyable) {
-
-  /**
-   * Gets the map value for `key`.
-   *
-   * @private
-   * @name get
-   * @memberOf MapCache
-   * @param {string} key The key of the value to get.
-   * @returns {*} Returns the entry value.
-   */
-  function mapGet(key) {
-    var data = this.__data__;
-    if (isKeyable(key)) {
-      return hashGet(typeof key == 'string' ? data.string : data.hash, key);
-    }
-    return Map ? data.map.get(key) : assocGet(data.map, key);
-  }
-
-  return mapGet;
-});

_mapHas.js

@@ -1,21 +0,0 @@
-define(['./_Map', './_assocHas', './_hashHas', './_isKeyable'], function(Map, assocHas, hashHas, isKeyable) {
-
-  /**
-   * Checks if a map value for `key` exists.
-   *
-   * @private
-   * @name has
-   * @memberOf MapCache
-   * @param {string} key The key of the entry to check.
-   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
-   */
-  function mapHas(key) {
-    var data = this.__data__;
-    if (isKeyable(key)) {
-      return hashHas(typeof key == 'string' ? data.string : data.hash, key);
-    }
-    return Map ? data.map.has(key) : assocHas(data.map, key);
-  }
-
-  return mapHas;
-});

_mapSet.js

@@ -1,26 +0,0 @@
-define(['./_Map', './_assocSet', './_hashSet', './_isKeyable'], function(Map, assocSet, hashSet, isKeyable) {
-
-  /**
-   * Sets the map `key` to `value`.
-   *
-   * @private
-   * @name set
-   * @memberOf MapCache
-   * @param {string} key The key of the value to set.
-   * @param {*} value The value to set.
-   * @returns {Object} Returns the map cache instance.
-   */
-  function mapSet(key, value) {
-    var data = this.__data__;
-    if (isKeyable(key)) {
-      hashSet(typeof key == 'string' ? data.string : data.hash, key, value);
-    } else if (Map) {
-      data.map.set(key, value);
-    } else {
-      assocSet(data.map, key, value);
-    }
-    return this;
-  }
-
-  return mapSet;
-});

_mapToArray.js

@@ -1,11 +1,11 @@
 define([], function() {
 
   /**
-   * Converts `map` to an array.
+   * Converts `map` to its key-value pairs.
    *
    * @private
    * @param {Object} map The map to convert.
-   * @returns {Array} Returns the converted array.
+   * @returns {Array} Returns the key-value pairs.
    */
   function mapToArray(map) {
     var index = -1,

_matchesStrictComparable.js

@@ -10,7 +10,7 @@ define([], function() {
    * @private
    * @param {string} key The key 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 matchesStrictComparable(key, srcValue) {
     return function(object) {

_root.js

@@ -1,45 +1,16 @@
 define(['./_checkGlobal'], function(checkGlobal) {
 
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
-
-  /** Used to determine if values are of the language type `Object`. */
-  var objectTypes = {
-    'function': true,
-    'object': true
-  };
-
-  /** Detect free variable `exports`. */
-  var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType)
-    ? exports
-    : undefined;
-
-  /** Detect free variable `module`. */
-  var freeModule = (objectTypes[typeof module] && module && !module.nodeType)
-    ? module
-    : undefined;
-
   /** Detect free variable `global` from Node.js. */
-  var freeGlobal = checkGlobal(freeExports && freeModule && typeof global == 'object' && global);
+  var freeGlobal = checkGlobal(typeof global == 'object' && global);
 
   /** Detect free variable `self`. */
-  var freeSelf = checkGlobal(objectTypes[typeof self] && self);
-
-  /** Detect free variable `window`. */
-  var freeWindow = checkGlobal(objectTypes[typeof window] && window);
+  var freeSelf = checkGlobal(typeof self == 'object' && self);
 
   /** Detect `this` as the global object. */
-  var thisGlobal = checkGlobal(objectTypes[typeof this] && this);
+  var thisGlobal = checkGlobal(typeof this == 'object' && this);
 
-  /**
-   * Used as a reference to the global object.
-   *
-   * The `this` value is used if it's the global object to avoid Greasemonkey's
-   * restricted `window` object, otherwise the `window` object is used.
-   */
-  var root = freeGlobal ||
-    ((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) ||
-      freeSelf || thisGlobal || Function('return this')();
+  /** Used as a reference to the global object. */
+  var root = freeGlobal || freeSelf || thisGlobal || Function('return this')();
 
   return root;
 });

_setCacheAdd.js

@@ -0,0 +1,22 @@
+define([], function() {
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+  /**
+   * Adds `value` to the array cache.
+   *
+   * @private
+   * @name add
+   * @memberOf SetCache
+   * @alias push
+   * @param {*} value The value to cache.
+   * @returns {Object} Returns the cache instance.
+   */
+  function setCacheAdd(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+  }
+
+  return setCacheAdd;
+});

_setCacheHas.js

@@ -0,0 +1,17 @@
+define([], function() {
+
+  /**
+   * Checks if `value` is in the array cache.
+   *
+   * @private
+   * @name has
+   * @memberOf SetCache
+   * @param {*} value The value to search for.
+   * @returns {number} Returns `true` if `value` is found, else `false`.
+   */
+  function setCacheHas(value) {
+    return this.__data__.has(value);
+  }
+
+  return setCacheHas;
+});

_setToArray.js

@@ -1,11 +1,11 @@
 define([], function() {
 
   /**
-   * Converts `set` to an array.
+   * Converts `set` to an array of its values.
    *
    * @private
    * @param {Object} set The set to convert.
-   * @returns {Array} Returns the converted array.
+   * @returns {Array} Returns the values.
    */
   function setToArray(set) {
     var index = -1,

_setToPairs.js

@@ -0,0 +1,21 @@
+define([], function() {
+
+  /**
+   * Converts `set` to its value-value pairs.
+   *
+   * @private
+   * @param {Object} set The set to convert.
+   * @returns {Array} Returns the value-value pairs.
+   */
+  function setToPairs(set) {
+    var index = -1,
+        result = Array(set.size);
+
+    set.forEach(function(value) {
+      result[++index] = [value, value];
+    });
+    return result;
+  }
+
+  return setToPairs;
+});

_stackClear.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_ListCache'], function(ListCache) {
 
   /**
    * Removes all key-value entries from the stack.
@@ -8,7 +8,7 @@ define([], function() {
    * @memberOf Stack
    */
   function stackClear() {
-    this.__data__ = { 'array': [], 'map': null };
+    this.__data__ = new ListCache;
   }
 
   return stackClear;

_stackDelete.js

@@ -1,4 +1,4 @@
-define(['./_assocDelete'], function(assocDelete) {
+define([], function() {
 
   /**
    * Removes `key` and its value from the stack.
@@ -10,10 +10,7 @@ define(['./_assocDelete'], function(assocDelete) {
    * @returns {boolean} Returns `true` if the entry was removed, else `false`.
    */
   function stackDelete(key) {
-    var data = this.__data__,
-        array = data.array;
-
-    return array ? assocDelete(array, key) : data.map['delete'](key);
+    return this.__data__['delete'](key);
   }
 
   return stackDelete;

_stackGet.js

@@ -1,4 +1,4 @@
-define(['./_assocGet'], function(assocGet) {
+define([], function() {
 
   /**
    * Gets the stack value for `key`.
@@ -10,10 +10,7 @@ define(['./_assocGet'], function(assocGet) {
    * @returns {*} Returns the entry value.
    */
   function stackGet(key) {
-    var data = this.__data__,
-        array = data.array;
-
-    return array ? assocGet(array, key) : data.map.get(key);
+    return this.__data__.get(key);
   }
 
   return stackGet;

_stackHas.js

@@ -1,4 +1,4 @@
-define(['./_assocHas'], function(assocHas) {
+define([], function() {
 
   /**
    * Checks if a stack value for `key` exists.
@@ -10,10 +10,7 @@ define(['./_assocHas'], function(assocHas) {
    * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
    */
   function stackHas(key) {
-    var data = this.__data__,
-        array = data.array;
-
-    return array ? assocHas(array, key) : data.map.has(key);
+    return this.__data__.has(key);
   }
 
   return stackHas;

_stackSet.js

@@ -1,4 +1,4 @@
-define(['./_MapCache', './_assocSet'], function(MapCache, assocSet) {
+define(['./_ListCache', './_MapCache'], function(ListCache, MapCache) {
 
   /** Used as the size to enable large array optimizations. */
   var LARGE_ARRAY_SIZE = 200;
@@ -14,21 +14,11 @@ define(['./_MapCache', './_assocSet'], function(MapCache, assocSet) {
    * @returns {Object} Returns the stack cache instance.
    */
   function stackSet(key, value) {
-    var data = this.__data__,
-        array = data.array;
-
-    if (array) {
-      if (array.length < (LARGE_ARRAY_SIZE - 1)) {
-        assocSet(array, key, value);
-      } else {
-        data.array = null;
-        data.map = new MapCache(array);
-      }
-    }
-    var map = data.map;
-    if (map) {
-      map.set(key, value);
+    var cache = this.__data__;
+    if (cache instanceof ListCache && cache.__data__.length == LARGE_ARRAY_SIZE) {
+      cache = this.__data__ = new MapCache(cache.__data__);
     }
+    cache.set(key, value);
     return this;
   }
 

_stringToPath.js

@@ -1,7 +1,7 @@
 define(['./memoize', './toString'], function(memoize, toString) {
 
   /** Used to match property names within property paths. */
-  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]/g;
+  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(\.|\[\])(?:\4|$))/g;
 
   /** Used to match backslashes in property paths. */
   var reEscapeChar = /\\(\\)?/g;

array.js

@@ -1,4 +1,4 @@
-define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './flatten', './flattenDeep', './flattenDepth', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './nth', './pull', './pullAll', './pullAllBy', './pullAllWith', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
+define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './first', './flatten', './flattenDeep', './flattenDepth', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './nth', './pull', './pullAll', './pullAllBy', './pullAllWith', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, first, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
   return {
     'chunk': chunk,
     'compact': compact,
@@ -13,6 +13,7 @@ define(['./chunk', './compact', './concat', './difference', './differenceBy', '.
     'fill': fill,
     'findIndex': findIndex,
     'findLastIndex': findLastIndex,
+    'first': first,
     'flatten': flatten,
     'flattenDeep': flattenDeep,
     'flattenDepth': flattenDepth,

ary.js

@@ -17,7 +17,7 @@ define(['./_createWrapper'], function(createWrapper) {
    * @param {Function} func The function to cap arguments for.
    * @param {number} [n=func.length] The arity cap.
    * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
-   * @returns {Function} Returns the new function.
+   * @returns {Function} Returns the new capped function.
    * @example
    *
    * _.map(['6', '8', '10'], _.ary(parseInt, 1));

at.js

@@ -9,16 +9,13 @@ define(['./_baseAt', './_baseFlatten', './rest'], function(baseAt, baseFlatten,
    * @category Object
    * @param {Object} object The object to iterate over.
    * @param {...(string|string[])} [paths] The property paths of elements to pick.
-   * @returns {Array} Returns the new array of picked elements.
+   * @returns {Array} Returns the picked values.
    * @example
    *
    * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
    *
    * _.at(object, ['a[0].b.c', 'a[1]']);
    * // => [3, 4]
-   *
-   * _.at(['a', 'b', 'c'], 0, 2);
-   * // => ['a', 'c']
    */
   var at = rest(function(object, paths) {
     return baseAt(object, baseFlatten(paths, 1));

bind.js

@@ -1,4 +1,4 @@
-define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'], function(createWrapper, getPlaceholder, replaceHolders, rest) {
+define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], function(createWrapper, getHolder, replaceHolders, rest) {
 
   /** Used to compose bitmasks for wrapper metadata. */
   var BIND_FLAG = 1,
@@ -11,7 +11,7 @@ define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'],
    * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
    * may be used as a placeholder for partially applied arguments.
    *
-   * **Note:** Unlike native `Function#bind` this method doesn't set the "length"
+   * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
    * property of bound functions.
    *
    * @static
@@ -42,7 +42,7 @@ define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'],
   var bind = rest(function(func, thisArg, partials) {
     var bitmask = BIND_FLAG;
     if (partials.length) {
-      var holders = replaceHolders(partials, getPlaceholder(bind));
+      var holders = replaceHolders(partials, getHolder(bind));
       bitmask |= PARTIAL_FLAG;
     }
     return createWrapper(func, bitmask, thisArg, partials, holders);

bindAll.js

@@ -22,7 +22,7 @@ define(['./_arrayEach', './_baseFlatten', './bind', './rest', './_toKey'], funct
    *   }
    * };
    *
-   * _.bindAll(view, 'onClick');
+   * _.bindAll(view, ['onClick']);
    * jQuery(element).on('click', view.onClick);
    * // => Logs 'clicked docs' when clicked.
    */

bindKey.js

@@ -1,4 +1,4 @@
-define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'], function(createWrapper, getPlaceholder, replaceHolders, rest) {
+define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], function(createWrapper, getHolder, replaceHolders, rest) {
 
   /** Used to compose bitmasks for wrapper metadata. */
   var BIND_FLAG = 1,
@@ -53,7 +53,7 @@ define(['./_createWrapper', './_getPlaceholder', './_replaceHolders', './rest'],
   var bindKey = rest(function(object, key, partials) {
     var bitmask = BIND_FLAG | BIND_KEY_FLAG;
     if (partials.length) {
-      var holders = replaceHolders(partials, getPlaceholder(bindKey));
+      var holders = replaceHolders(partials, getHolder(bindKey));
       bitmask |= PARTIAL_FLAG;
     }
     return createWrapper(key, bitmask, object, partials, holders);

chunk.js

@@ -19,7 +19,7 @@ define(['./_baseSlice', './_isIterateeCall', './toInteger'], function(baseSlice,
    * @param {Array} array The array to process.
    * @param {number} [size=1] The length of each chunk
    * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
-   * @returns {Array} Returns the new array containing chunks.
+   * @returns {Array} Returns the new array of chunks.
    * @example
    *
    * _.chunk(['a', 'b', 'c', 'd'], 2);

concat.js

@@ -1,4 +1,4 @@
-define(['./_arrayConcat', './_baseFlatten', './castArray', './_copyArray'], function(arrayConcat, baseFlatten, castArray, copyArray) {
+define(['./_arrayPush', './_baseFlatten', './_copyArray', './isArray'], function(arrayPush, baseFlatten, copyArray, isArray) {
 
   /**
    * Creates a new array concatenating `array` with any additional arrays
@@ -24,16 +24,16 @@ define(['./_arrayConcat', './_baseFlatten', './castArray', './_copyArray'], func
    */
   function concat() {
     var length = arguments.length,
-        array = castArray(arguments[0]);
+        args = Array(length ? length - 1 : 0),
+        array = arguments[0],
+        index = length;
 
-    if (length < 2) {
-      return length ? copyArray(array) : [];
+    while (index--) {
+      args[index - 1] = arguments[index];
     }
-    var args = Array(length - 1);
-    while (length--) {
-      args[length - 1] = arguments[length];
-    }
-    return arrayConcat(array, baseFlatten(args, 1));
+    return length
+      ? arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1))
+      : [];
   }
 
   return concat;