Bump to v4.12.0.

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.10.0
+# lodash-amd v4.12.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.10.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.12.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`.

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

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

_baseDifference.js

@@ -42,6 +42,7 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
+      value = (comparator || value !== 0) ? value : 0;
       if (isCommon && computed === computed) {
         var valuesIndex = valuesLength;
         while (valuesIndex--) {

_baseExtremum.js

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

_baseFunctions.js

@@ -7,7 +7,7 @@ define(['./_arrayFilter', './isFunction'], function(arrayFilter, isFunction) {
    * @private
    * @param {Object} object The object to inspect.
    * @param {Array} props The property names to filter.
-   * @returns {Array} Returns the new array of filtered property names.
+   * @returns {Array} Returns the function names.
    */
   function baseFunctions(object, props) {
     return arrayFilter(props, function(key) {

_baseGet.js

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

_baseGetAllKeys.js

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

_baseGt.js

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

_baseIntersection.js

@@ -45,6 +45,7 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
+      value = (comparator || value !== 0) ? value : 0;
       if (!(seen
             ? cacheHas(seen, computed)
             : includes(result, computed, comparator)

_baseInvoke.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_castPath', './_isKey', './last', './_parent'], function(apply, castPath, isKey, last, parent) {
+define(['./_apply', './_castPath', './_isKey', './last', './_parent', './_toKey'], function(apply, castPath, isKey, last, parent, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -19,7 +19,7 @@ define(['./_apply', './_castPath', './_isKey', './last', './_parent'], function(
       object = parent(object, path);
       path = last(path);
     }
-    var func = object == null ? object : object[path];
+    var func = object == null ? object : object[toKey(path)];
     return func == null ? undefined : apply(func, object, args);
   }
 

_baseLt.js

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

_baseMatches.js

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

@@ -1,4 +1,4 @@
-define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable', './_matchesStrictComparable'], function(baseIsEqual, get, hasIn, isKey, isStrictComparable, matchesStrictComparable) {
+define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable', './_matchesStrictComparable', './_toKey'], function(baseIsEqual, get, hasIn, isKey, isStrictComparable, matchesStrictComparable, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -13,11 +13,11 @@ 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)) {
-      return matchesStrictComparable(path, srcValue);
+      return matchesStrictComparable(toKey(path), srcValue);
     }
     return function(object) {
       var objValue = get(object, path);

_baseNth.js

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

_baseOrderBy.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_compareMultiple', './identity'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple, identity) {
+define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_baseUnary', './_compareMultiple', './identity'], function(arrayMap, baseIteratee, baseMap, baseSortBy, baseUnary, compareMultiple, identity) {
 
   /**
    * The base implementation of `_.orderBy` without param guards.
@@ -11,7 +11,7 @@ define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_com
    */
   function baseOrderBy(collection, iteratees, orders) {
     var index = -1;
-    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseIteratee);
+    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

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

_basePullAt.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isIndex', './_isKey', './last', './_parent'], function(castPath, isIndex, isKey, last, parent) {
+define(['./_castPath', './_isIndex', './_isKey', './last', './_parent', './_toKey'], function(castPath, isIndex, isKey, last, parent, toKey) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -21,7 +21,7 @@ define(['./_castPath', './_isIndex', './_isKey', './last', './_parent'], functio
 
     while (length--) {
       var index = indexes[length];
-      if (lastIndex == length || index != previous) {
+      if (length == lastIndex || index !== previous) {
         var previous = index;
         if (isIndex(index)) {
           splice.call(array, index, 1);
@@ -31,11 +31,11 @@ define(['./_castPath', './_isIndex', './_isKey', './last', './_parent'], functio
               object = parent(array, path);
 
           if (object != null) {
-            delete object[last(path)];
+            delete object[toKey(last(path))];
           }
         }
         else {
-          delete array[index];
+          delete array[toKey(index)];
         }
       }
     }

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

_baseSet.js

@@ -1,4 +1,4 @@
-define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject'], function(assignValue, castPath, isIndex, isKey, isObject) {
+define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject', './_toKey'], function(assignValue, castPath, isIndex, isKey, isObject, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -22,7 +22,7 @@ define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject']
         nested = object;
 
     while (nested != null && ++index < length) {
-      var key = path[index];
+      var key = toKey(path[index]);
       if (isObject(nested)) {
         var newValue = value;
         if (index != lastIndex) {

_baseSortedIndex.js

@@ -1,4 +1,4 @@
-define(['./_baseSortedIndexBy', './identity'], function(baseSortedIndexBy, identity) {
+define(['./_baseSortedIndexBy', './identity', './isSymbol'], function(baseSortedIndexBy, identity, isSymbol) {
 
   /** Used as references for the maximum length and index of an array. */
   var MAX_ARRAY_LENGTH = 4294967295,
@@ -25,7 +25,8 @@ define(['./_baseSortedIndexBy', './identity'], function(baseSortedIndexBy, ident
         var mid = (low + high) >>> 1,
             computed = array[mid];
 
-        if ((retHighest ? (computed <= value) : (computed < value)) && computed !== null) {
+        if (computed !== null && !isSymbol(computed) &&
+            (retHighest ? (computed <= value) : (computed < value))) {
           low = mid + 1;
         } else {
           high = mid;

_baseSortedIndexBy.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./isSymbol'], function(isSymbol) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -31,21 +31,26 @@ define([], function() {
         high = array ? array.length : 0,
         valIsNaN = value !== value,
         valIsNull = value === null,
-        valIsUndef = value === undefined;
+        valIsSymbol = isSymbol(value),
+        valIsUndefined = value === undefined;
 
     while (low < high) {
       var mid = nativeFloor((low + high) / 2),
           computed = iteratee(array[mid]),
-          isDef = computed !== undefined,
-          isReflexive = computed === computed;
+          othIsDefined = computed !== undefined,
+          othIsNull = computed === null,
+          othIsReflexive = computed === computed,
+          othIsSymbol = isSymbol(computed);
 
       if (valIsNaN) {
-        var setLow = isReflexive || retHighest;
+        var setLow = retHighest || othIsReflexive;
+      } else if (valIsUndefined) {
+        setLow = othIsReflexive && (retHighest || othIsDefined);
       } else if (valIsNull) {
-        setLow = isReflexive && isDef && (retHighest || computed != null);
-      } else if (valIsUndef) {
-        setLow = isReflexive && (retHighest || isDef);
-      } else if (computed == null) {
+        setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+      } else if (valIsSymbol) {
+        setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+      } else if (othIsNull || othIsSymbol) {
         setLow = false;
       } else {
         setLow = retHighest ? (computed <= value) : (computed < value);

_baseSortedUniq.js

@@ -1,14 +1,30 @@
-define(['./_baseSortedUniqBy'], function(baseSortedUniqBy) {
+define(['./eq'], function(eq) {
 
   /**
-   * The base implementation of `_.sortedUniq`.
+   * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
+   * support for iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to inspect.
+   * @param {Function} [iteratee] The iteratee invoked per element.
    * @returns {Array} Returns the new duplicate free array.
    */
-  function baseSortedUniq(array) {
-    return baseSortedUniqBy(array);
+  function baseSortedUniq(array, iteratee) {
+    var index = -1,
+        length = array.length,
+        resIndex = 0,
+        result = [];
+
+    while (++index < length) {
+      var value = array[index],
+          computed = iteratee ? iteratee(value) : value;
+
+      if (!index || !eq(computed, seen)) {
+        var seen = computed;
+        result[resIndex++] = value === 0 ? 0 : value;
+      }
+    }
+    return result;
   }
 
   return baseSortedUniq;

_baseSortedUniqBy.js

@@ -1,34 +0,0 @@
-define(['./eq'], function(eq) {
-
-  /**
-   * The base implementation of `_.sortedUniqBy` without support for iteratee
-   * shorthands.
-   *
-   * @private
-   * @param {Array} array The array to inspect.
-   * @param {Function} [iteratee] The iteratee invoked per element.
-   * @returns {Array} Returns the new duplicate free array.
-   */
-  function baseSortedUniqBy(array, iteratee) {
-    var index = 0,
-        length = array.length,
-        value = array[0],
-        computed = iteratee ? iteratee(value) : value,
-        seen = computed,
-        resIndex = 1,
-        result = [value];
-
-    while (++index < length) {
-      value = array[index],
-      computed = iteratee ? iteratee(value) : value;
-
-      if (!eq(computed, seen)) {
-        seen = computed;
-        result[resIndex++] = value;
-      }
-    }
-    return result;
-  }
-
-  return baseSortedUniqBy;
-});

_baseToNumber.js

@@ -0,0 +1,25 @@
+define(['./isSymbol'], function(isSymbol) {
+
+  /** Used as references for various `Number` constants. */
+  var NAN = 0 / 0;
+
+  /**
+   * The base implementation of `_.toNumber` which doesn't ensure correct
+   * conversions of binary, hexadecimal, or octal string values.
+   *
+   * @private
+   * @param {*} value The value to process.
+   * @returns {number} Returns the number.
+   */
+  function baseToNumber(value) {
+    if (typeof value == 'number') {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    return +value;
+  }
+
+  return baseToNumber;
+});

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

_baseToString.js

@@ -0,0 +1,34 @@
+define(['./_Symbol', './isSymbol'], function(Symbol, isSymbol) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used as references for various `Number` constants. */
+  var INFINITY = 1 / 0;
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto = Symbol ? Symbol.prototype : undefined,
+      symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+  /**
+   * The base implementation of `_.toString` which doesn't convert nullish
+   * values to empty strings.
+   *
+   * @private
+   * @param {*} value The value to process.
+   * @returns {string} Returns the string.
+   */
+  function baseToString(value) {
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value == 'string') {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return symbolToString ? symbolToString.call(value) : '';
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+  }
+
+  return baseToString;
+});

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

_baseUniq.js

@@ -41,6 +41,7 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_cacheHas'
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
+      value = (comparator || value !== 0) ? value : 0;
       if (isCommon && computed === computed) {
         var seenIndex = seen.length;
         while (seenIndex--) {

_baseUnset.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './has', './_isKey', './last', './_parent'], function(castPath, has, isKey, last, parent) {
+define(['./_baseHas', './_castPath', './_isKey', './last', './_parent', './_toKey'], function(baseHas, castPath, isKey, last, parent, toKey) {
 
   /**
    * The base implementation of `_.unset`.
@@ -11,8 +11,9 @@ define(['./_castPath', './has', './_isKey', './last', './_parent'], function(cas
   function baseUnset(object, path) {
     path = isKey(path, object) ? [path] : castPath(path);
     object = parent(object, path);
-    var key = last(path);
-    return (object != null && has(object, key)) ? delete object[key] : true;
+
+    var key = toKey(last(path));
+    return !(object != null && baseHas(object, key)) || delete object[key];
   }
 
   return baseUnset;

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

_compareAscending.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./isSymbol'], function(isSymbol) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -13,22 +13,28 @@ define([], function() {
    */
   function compareAscending(value, other) {
     if (value !== other) {
-      var valIsNull = value === null,
-          valIsUndef = value === undefined,
-          valIsReflexive = value === value;
+      var valIsDefined = value !== undefined,
+          valIsNull = value === null,
+          valIsReflexive = value === value,
+          valIsSymbol = isSymbol(value);
 
-      var othIsNull = other === null,
-          othIsUndef = other === undefined,
-          othIsReflexive = other === other;
+      var othIsDefined = other !== undefined,
+          othIsNull = other === null,
+          othIsReflexive = other === other,
+          othIsSymbol = isSymbol(other);
 
-      if ((value > other && !othIsNull) || !valIsReflexive ||
-          (valIsNull && !othIsUndef && othIsReflexive) ||
-          (valIsUndef && othIsReflexive)) {
+      if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
+          (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
+          (valIsNull && othIsDefined && othIsReflexive) ||
+          (!valIsDefined && othIsReflexive) ||
+          !valIsReflexive) {
         return 1;
       }
-      if ((value < other && !valIsNull) || !othIsReflexive ||
-          (othIsNull && !valIsUndef && valIsReflexive) ||
-          (othIsUndef && valIsReflexive)) {
+      if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
+          (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
+          (othIsNull && valIsDefined && valIsReflexive) ||
+          (!othIsDefined && valIsReflexive) ||
+          !othIsReflexive) {
         return -1;
       }
     }

_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,4 +1,4 @@
-define(['./_copyObjectWith'], function(copyObjectWith) {
+define(['./_assignValue'], function(assignValue) {
 
   /**
    * Copies properties of `source` to `object`.
@@ -7,10 +7,25 @@ define(['./_copyObjectWith'], function(copyObjectWith) {
    * @param {Object} source The object to copy properties from.
    * @param {Array} props The property identifiers to copy.
    * @param {Object} [object={}] The object to copy properties to.
+   * @param {Function} [customizer] The function to customize copied values.
    * @returns {Object} Returns `object`.
    */
-  function copyObject(source, props, object) {
-    return copyObjectWith(source, props, object);
+  function copyObject(source, props, object, customizer) {
+    object || (object = {});
+
+    var index = -1,
+        length = props.length;
+
+    while (++index < length) {
+      var key = props[index];
+
+      var newValue = customizer
+        ? customizer(object[key], source[key], key, object, source)
+        : source[key];
+
+      assignValue(object, key, newValue);
+    }
+    return object;
   }
 
   return copyObject;

_copyObjectWith.js

@@ -1,33 +0,0 @@
-define(['./_assignValue'], function(assignValue) {
-
-  /**
-   * This function is like `copyObject` except that it accepts a function to
-   * customize copied values.
-   *
-   * @private
-   * @param {Object} source The object to copy properties from.
-   * @param {Array} props The property identifiers to copy.
-   * @param {Object} [object={}] The object to copy properties to.
-   * @param {Function} [customizer] The function to customize copied values.
-   * @returns {Object} Returns `object`.
-   */
-  function copyObjectWith(source, props, object, customizer) {
-    object || (object = {});
-
-    var index = -1,
-        length = props.length;
-
-    while (++index < length) {
-      var key = props[index];
-
-      var newValue = customizer
-        ? customizer(object[key], source[key], key, object, source)
-        : source[key];
-
-      assignValue(object, key, newValue);
-    }
-    return object;
-  }
-
-  return copyObjectWith;
-});

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

_createCompounder.js

@@ -1,5 +1,11 @@
 define(['./_arrayReduce', './deburr', './words'], function(arrayReduce, deburr, words) {
 
+  /** Used to compose unicode capture groups. */
+  var rsApos = "['\u2019]";
+
+  /** Used to match apostrophes. */
+  var reApos = RegExp(rsApos, 'g');
+
   /**
    * Creates a function like `_.camelCase`.
    *
@@ -9,7 +15,7 @@ define(['./_arrayReduce', './deburr', './words'], function(arrayReduce, deburr,
    */
   function createCompounder(callback) {
     return function(string) {
-      return arrayReduce(words(deburr(string)), callback, '');
+      return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
     };
   }
 

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

_createMathOperation.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_baseToNumber', './_baseToString'], function(baseToNumber, baseToString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -20,7 +20,17 @@ define([], function() {
         result = value;
       }
       if (other !== undefined) {
-        result = result === undefined ? other : operator(result, other);
+        if (result === undefined) {
+          return other;
+        }
+        if (typeof value == 'string' || typeof other == 'string') {
+          value = baseToString(value);
+          other = baseToString(other);
+        } else {
+          value = baseToNumber(value);
+          other = baseToNumber(other);
+        }
+        result = operator(value, other);
       }
       return result;
     };

_createOver.js

@@ -1,15 +1,18 @@
-define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, isFlattenableIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseUnary', './isArray', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, baseUnary, isArray, isFlattenableIteratee, rest) {
 
   /**
    * 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) {
-      iteratees = arrayMap(baseFlatten(iteratees, 1, isFlattenableIteratee), baseIteratee);
+      iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
+        ? arrayMap(iteratees[0], baseUnary(baseIteratee))
+        : arrayMap(baseFlatten(iteratees, 1, isFlattenableIteratee), baseUnary(baseIteratee));
+
       return rest(function(args) {
         var thisArg = this;
         return arrayFunc(iteratees, function(iteratee) {

_createPadding.js

@@ -1,4 +1,4 @@
-define(['./_baseRepeat', './_castSlice', './_reHasComplexSymbol', './_stringSize', './_stringToArray'], function(baseRepeat, castSlice, reHasComplexSymbol, stringSize, stringToArray) {
+define(['./_baseRepeat', './_baseToString', './_castSlice', './_reHasComplexSymbol', './_stringSize', './_stringToArray'], function(baseRepeat, baseToString, castSlice, reHasComplexSymbol, stringSize, stringToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -16,7 +16,7 @@ define(['./_baseRepeat', './_castSlice', './_reHasComplexSymbol', './_stringSize
    * @returns {string} Returns the padding for `string`.
    */
   function createPadding(length, chars) {
-    chars = chars === undefined ? ' ' : (chars + '');
+    chars = chars === undefined ? ' ' : baseToString(chars);
 
     var charsLength = chars.length;
     if (charsLength < 2) {

_createRecurryWrapper.js

@@ -1,4 +1,4 @@
-define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLaziable, setData) {
+define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -31,7 +31,6 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
    */
   function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
     var isCurry = bitmask & CURRY_FLAG,
-        newArgPos = argPos ? copyArray(argPos) : undefined,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
         newPartials = isCurry ? partials : undefined,
@@ -45,7 +44,7 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
     }
     var newData = [
       func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
-      newHoldersRight, newArgPos, ary, arity
+      newHoldersRight, argPos, ary, arity
     ];
 
     var result = wrapFunc.apply(undefined, newData);

_createRelationalOperation.js

@@ -0,0 +1,21 @@
+define(['./toNumber'], function(toNumber) {
+
+  /**
+   * Creates a function that performs a relational operation on two values.
+   *
+   * @private
+   * @param {Function} operator The function to perform the operation.
+   * @returns {Function} Returns the new relational operation function.
+   */
+  function createRelationalOperation(operator) {
+    return function(value, other) {
+      if (!(typeof value == 'string' && typeof other == 'string')) {
+        value = toNumber(value);
+        other = toNumber(other);
+      }
+      return operator(value, other);
+    };
+  }
+
+  return createRelationalOperation;
+});

_createSet.js

@@ -1,4 +1,7 @@
-define(['./_Set', './noop'], function(Set, noop) {
+define(['./_Set', './noop', './_setToArray'], function(Set, noop, setToArray) {
+
+  /** Used as references for various `Number` constants. */
+  var INFINITY = 1 / 0;
 
   /**
    * Creates a set of `values`.
@@ -7,7 +10,7 @@ define(['./_Set', './noop'], function(Set, noop) {
    * @param {Array} values The values to add to the set.
    * @returns {Object} Returns the new set.
    */
-  var createSet = !(Set && new Set([1, 2]).size === 2) ? noop : function(values) {
+  var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
     return new Set(values);
   };
 

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

_hasPath.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString'], function(castPath, isArguments, isArray, isIndex, isKey, isLength, isString) {
+define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString', './_toKey'], function(castPath, isArguments, isArray, isIndex, isKey, isLength, isString, toKey) {
 
   /**
    * Checks if `path` exists on `object`.
@@ -17,7 +17,7 @@ define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', '
         length = path.length;
 
     while (++index < length) {
-      var key = path[index];
+      var key = toKey(path[index]);
       if (!(result = object != null && hasFunc(object, key))) {
         break;
       }

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

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

_isIndex.js

@@ -15,9 +15,10 @@ define([], function() {
    * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
    */
   function isIndex(value, length) {
-    value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
     length = length == null ? MAX_SAFE_INTEGER : length;
-    return value > -1 && value % 1 == 0 && value < length;
+    return !!length &&
+      (typeof value == 'number' || reIsUint.test(value)) &&
+      (value > -1 && value % 1 == 0 && value < length);
   }
 
   return isIndex;

_isKey.js

@@ -13,13 +13,16 @@ define(['./isArray', './isSymbol'], function(isArray, isSymbol) {
    * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
    */
   function isKey(value, object) {
+    if (isArray(value)) {
+      return false;
+    }
     var type = typeof value;
-    if (type == 'number' || type == 'symbol') {
+    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+        value == null || isSymbol(value)) {
       return true;
     }
-    return !isArray(value) &&
-      (isSymbol(value) || reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
-        (object != null && value in Object(object)));
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+      (object != null && value in Object(object));
   }
 
   return isKey;

_isKeyable.js

@@ -9,8 +9,9 @@ define([], function() {
    */
   function isKeyable(value) {
     var type = typeof value;
-    return type == 'number' || type == 'boolean' ||
-      (type == 'string' && value != '__proto__') || value == null;
+    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+      ? (value !== '__proto__')
+      : (value === null);
   }
 
   return isKeyable;

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

_mergeData.js

@@ -1,4 +1,4 @@
-define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHolders'], function(composeArgs, composeArgsRight, copyArray, replaceHolders) {
+define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(composeArgs, composeArgsRight, replaceHolders) {
 
   /** Used as the internal argument placeholder. */
   var PLACEHOLDER = '__lodash_placeholder__';
@@ -55,20 +55,20 @@ define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHold
     var value = source[3];
     if (value) {
       var partials = data[3];
-      data[3] = partials ? composeArgs(partials, value, source[4]) : copyArray(value);
-      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : copyArray(source[4]);
+      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
+      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
     }
     // Compose partial right arguments.
     value = source[5];
     if (value) {
       partials = data[5];
-      data[5] = partials ? composeArgsRight(partials, value, source[6]) : copyArray(value);
-      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : copyArray(source[6]);
+      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
+      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
     }
     // Use source `argPos` if available.
     value = source[7];
     if (value) {
-      data[7] = copyArray(value);
+      data[7] = value;
     }
     // Use source `ary` if it's smaller.
     if (srcBitmask & ARY_FLAG) {

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

_toKey.js

@@ -1,5 +1,8 @@
 define(['./isSymbol'], function(isSymbol) {
 
+  /** Used as references for various `Number` constants. */
+  var INFINITY = 1 / 0;
+
   /**
    * Converts `value` to a string key if it's not a string or symbol.
    *
@@ -7,8 +10,12 @@ define(['./isSymbol'], function(isSymbol) {
    * @param {*} value The value to inspect.
    * @returns {string|symbol} Returns the key.
    */
-  function toKey(key) {
-    return (typeof key == 'string' || isSymbol(key)) ? key : (key + '');
+  function toKey(value) {
+    if (typeof value == 'string' || isSymbol(value)) {
+      return value;
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
   }
 
   return toKey;

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', './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, 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,
@@ -26,6 +27,7 @@ define(['./chunk', './compact', './concat', './difference', './differenceBy', '.
     'join': join,
     'last': last,
     'lastIndexOf': lastIndexOf,
+    'nth': nth,
     'pull': pull,
     'pullAll': pullAll,
     'pullAllBy': pullAllBy,

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