Bump to v4.17.4.

LICENSE

@@ -1,4 +1,4 @@
-Copyright jQuery Foundation and other contributors <https://jquery.org/>
+Copyright JS Foundation and other contributors <https://js.foundation/>
 
 Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>

README.md

@@ -1,9 +1,9 @@
-# lodash-amd v4.15.0
+# lodash-amd v4.17.4
 
 The [Lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
 Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
-```bash
+```shell
 $ lodash exports=amd -o ./
 $ lodash exports=amd -d -o ./main.js
 ```
@@ -11,8 +11,8 @@ $ lodash exports=amd -d -o ./main.js
 ## Installation
 
 Using npm:
-```bash
-$ {sudo -H} npm i -g npm
+```shell
+$ npm i -g npm
 $ npm i --save lodash-amd
 ```
 
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.15.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.17.4-amd) for more details.

_Hash.js

@@ -9,7 +9,7 @@ define(['./_hashClear', './_hashDelete', './_hashGet', './_hashHas', './_hashSet
    */
   function Hash(entries) {
     var index = -1,
-        length = entries ? entries.length : 0;
+        length = entries == null ? 0 : entries.length;
 
     this.clear();
     while (++index < length) {

_ListCache.js

@@ -9,7 +9,7 @@ define(['./_listCacheClear', './_listCacheDelete', './_listCacheGet', './_listCa
    */
   function ListCache(entries) {
     var index = -1,
-        length = entries ? entries.length : 0;
+        length = entries == null ? 0 : entries.length;
 
     this.clear();
     while (++index < length) {

_MapCache.js

@@ -9,7 +9,7 @@ define(['./_mapCacheClear', './_mapCacheDelete', './_mapCacheGet', './_mapCacheH
    */
   function MapCache(entries) {
     var index = -1,
-        length = entries ? entries.length : 0;
+        length = entries == null ? 0 : entries.length;
 
     this.clear();
     while (++index < length) {

_SetCache.js

@@ -10,7 +10,7 @@ define(['./_MapCache', './_setCacheAdd', './_setCacheHas'], function(MapCache, s
    */
   function SetCache(values) {
     var index = -1,
-        length = values ? values.length : 0;
+        length = values == null ? 0 : values.length;
 
     this.__data__ = new MapCache;
     while (++index < length) {

_Stack.js

@@ -8,7 +8,8 @@ define(['./_ListCache', './_stackClear', './_stackDelete', './_stackGet', './_st
    * @param {Array} [entries] The key-value pairs to cache.
    */
   function Stack(entries) {
-    this.__data__ = new ListCache(entries);
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
   }
 
   // Add methods to `Stack`.

_arrayAggregator.js

@@ -12,7 +12,7 @@ define([], function() {
    */
   function arrayAggregator(array, setter, iteratee, accumulator) {
     var index = -1,
-        length = array ? array.length : 0;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       var value = array[index];

_arrayEach.js

@@ -11,7 +11,7 @@ define([], function() {
    */
   function arrayEach(array, iteratee) {
     var index = -1,
-        length = array ? array.length : 0;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       if (iteratee(array[index], index, array) === false) {

_arrayEachRight.js

@@ -10,7 +10,7 @@ define([], function() {
    * @returns {Array} Returns `array`.
    */
   function arrayEachRight(array, iteratee) {
-    var length = array ? array.length : 0;
+    var length = array == null ? 0 : array.length;
 
     while (length--) {
       if (iteratee(array[length], length, array) === false) {

_arrayEvery.js

@@ -12,7 +12,7 @@ define([], function() {
    */
   function arrayEvery(array, predicate) {
     var index = -1,
-        length = array ? array.length : 0;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       if (!predicate(array[index], index, array)) {

_arrayFilter.js

@@ -11,7 +11,7 @@ define([], function() {
    */
   function arrayFilter(array, predicate) {
     var index = -1,
-        length = array ? array.length : 0,
+        length = array == null ? 0 : array.length,
         resIndex = 0,
         result = [];
 

_arrayIncludes.js

@@ -10,7 +10,7 @@ define(['./_baseIndexOf'], function(baseIndexOf) {
    * @returns {boolean} Returns `true` if `target` is found, else `false`.
    */
   function arrayIncludes(array, value) {
-    var length = array ? array.length : 0;
+    var length = array == null ? 0 : array.length;
     return !!length && baseIndexOf(array, value, 0) > -1;
   }
 

_arrayIncludesWith.js

@@ -11,7 +11,7 @@ define([], function() {
    */
   function arrayIncludesWith(array, value, comparator) {
     var index = -1,
-        length = array ? array.length : 0;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       if (comparator(value, array[index])) {

_arrayLikeKeys.js

@@ -1,4 +1,4 @@
-define(['./_baseTimes', './isArguments', './isArray', './_isIndex'], function(baseTimes, isArguments, isArray, isIndex) {
+define(['./_baseTimes', './isArguments', './isArray', './isBuffer', './_isIndex', './isTypedArray'], function(baseTimes, isArguments, isArray, isBuffer, isIndex, isTypedArray) {
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -15,18 +15,26 @@ define(['./_baseTimes', './isArguments', './isArray', './_isIndex'], function(ba
    * @returns {Array} Returns the array of property names.
    */
   function arrayLikeKeys(value, inherited) {
-    // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
-    // Safari 9 makes `arguments.length` enumerable in strict mode.
-    var result = (isArray(value) || isArguments(value))
-      ? baseTimes(value.length, String)
-      : [];
-
-    var length = result.length,
-        skipIndexes = !!length;
+    var isArr = isArray(value),
+        isArg = !isArr && isArguments(value),
+        isBuff = !isArr && !isArg && isBuffer(value),
+        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+        skipIndexes = isArr || isArg || isBuff || isType,
+        result = skipIndexes ? baseTimes(value.length, String) : [],
+        length = result.length;
 
     for (var key in value) {
       if ((inherited || hasOwnProperty.call(value, key)) &&
-          !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+          !(skipIndexes && (
+             // Safari 9 has enumerable `arguments.length` in strict mode.
+             key == 'length' ||
+             // Node.js 0.10 has enumerable non-index properties on buffers.
+             (isBuff && (key == 'offset' || key == 'parent')) ||
+             // PhantomJS 2 has enumerable non-index properties on typed arrays.
+             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+             // Skip index properties.
+             isIndex(key, length)
+          ))) {
         result.push(key);
       }
     }

_arrayMap.js

@@ -11,7 +11,7 @@ define([], function() {
    */
   function arrayMap(array, iteratee) {
     var index = -1,
-        length = array ? array.length : 0,
+        length = array == null ? 0 : array.length,
         result = Array(length);
 
     while (++index < length) {

_arrayReduce.js

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

_arrayReduceRight.js

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

_arraySample.js

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

_arraySampleSize.js

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

_arrayShuffle.js

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

_arraySome.js

@@ -12,7 +12,7 @@ define([], function() {
    */
   function arraySome(array, predicate) {
     var index = -1,
-        length = array ? array.length : 0;
+        length = array == null ? 0 : array.length;
 
     while (++index < length) {
       if (predicate(array[index], index, array)) {

_assignMergeValue.js

@@ -1,4 +1,4 @@
-define(['./eq'], function(eq) {
+define(['./_baseAssignValue', './eq'], function(baseAssignValue, eq) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,8 +14,8 @@ define(['./eq'], function(eq) {
    */
   function assignMergeValue(object, key, value) {
     if ((value !== undefined && !eq(object[key], value)) ||
-        (typeof key == 'number' && value === undefined && !(key in object))) {
-      object[key] = value;
+        (value === undefined && !(key in object))) {
+      baseAssignValue(object, key, value);
     }
   }
 

_assignValue.js

@@ -1,4 +1,4 @@
-define(['./eq'], function(eq) {
+define(['./_baseAssignValue', './eq'], function(baseAssignValue, eq) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -23,7 +23,7 @@ define(['./eq'], function(eq) {
     var objValue = object[key];
     if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
         (value === undefined && !(key in object))) {
-      object[key] = value;
+      baseAssignValue(object, key, value);
     }
   }
 

_baseAssignIn.js

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

_baseAssignValue.js

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

_baseAt.js

@@ -8,17 +8,17 @@ define(['./get'], function(get) {
    *
    * @private
    * @param {Object} object The object to iterate over.
-   * @param {string[]} paths The property paths of elements to pick.
+   * @param {string[]} paths The property paths to pick.
    * @returns {Array} Returns the picked elements.
    */
   function baseAt(object, paths) {
     var index = -1,
-        isNil = object == null,
         length = paths.length,
-        result = Array(length);
+        result = Array(length),
+        skip = object == null;
 
     while (++index < length) {
-      result[index] = isNil ? undefined : get(object, paths[index]);
+      result[index] = skip ? undefined : get(object, paths[index]);
     }
     return result;
   }

_baseClone.js

@@ -1,8 +1,13 @@
-define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_cloneBuffer', './_copyArray', './_copySymbols', './_getAllKeys', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './_isHostObject', './isObject', './keys'], function(Stack, arrayEach, assignValue, baseAssign, cloneBuffer, copyArray, copySymbols, getAllKeys, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isHostObject, isObject, keys) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseAssignIn', './_cloneBuffer', './_copyArray', './_copySymbols', './_copySymbolsIn', './_getAllKeys', './_getAllKeysIn', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './isObject', './keys'], function(Stack, arrayEach, assignValue, baseAssign, baseAssignIn, cloneBuffer, copyArray, copySymbols, copySymbolsIn, getAllKeys, getAllKeysIn, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isObject, keys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_FLAT_FLAG = 2,
+      CLONE_SYMBOLS_FLAG = 4;
+
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
       arrayTag = '[object Array]',
@@ -54,16 +59,22 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
    *
    * @private
    * @param {*} value The value to clone.
-   * @param {boolean} [isDeep] Specify a deep clone.
-   * @param {boolean} [isFull] Specify a clone including symbols.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Deep clone
+   *  2 - Flatten inherited properties
+   *  4 - Clone symbols
    * @param {Function} [customizer] The function to customize cloning.
    * @param {string} [key] The key of `value`.
    * @param {Object} [object] The parent object of `value`.
    * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
    * @returns {*} Returns the cloned value.
    */
-  function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
-    var result;
+  function baseClone(value, bitmask, customizer, key, object, stack) {
+    var result,
+        isDeep = bitmask & CLONE_DEEP_FLAG,
+        isFlat = bitmask & CLONE_FLAT_FLAG,
+        isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
     }
@@ -87,12 +98,11 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
         return cloneBuffer(value, isDeep);
       }
       if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
-        if (isHostObject(value)) {
-          return object ? value : {};
-        }
-        result = initCloneObject(isFunc ? {} : value);
+        result = (isFlat || isFunc) ? {} : initCloneObject(value);
         if (!isDeep) {
-          return copySymbols(value, baseAssign(result, value));
+          return isFlat
+            ? copySymbolsIn(value, baseAssignIn(result, value))
+            : copySymbols(value, baseAssign(result, value));
         }
       } else {
         if (!cloneableTags[tag]) {
@@ -109,16 +119,18 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
     }
     stack.set(value, result);
 
-    if (!isArr) {
-      var props = isFull ? getAllKeys(value) : keys(value);
-    }
+    var keysFunc = isFull
+      ? (isFlat ? getAllKeysIn : getAllKeys)
+      : (isFlat ? keysIn : keys);
+
+    var props = isArr ? undefined : keysFunc(value);
     arrayEach(props || value, function(subValue, key) {
       if (props) {
         key = subValue;
         subValue = value[key];
       }
       // Recursively populate clone (susceptible to call stack limits).
-      assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
     });
     return result;
   }

_baseCreate.js

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

_baseDelay.js

@@ -3,7 +3,7 @@ define([], function() {
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used as the `TypeError` message for "Functions" methods. */
+  /** Error message constants. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**

_baseDifference.js

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

_baseGet.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isKey', './_toKey'], function(castPath, isKey, toKey) {
+define(['./_castPath', './_toKey'], function(castPath, toKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,7 +12,7 @@ define(['./_castPath', './_isKey', './_toKey'], function(castPath, isKey, toKey)
    * @returns {*} Returns the resolved value.
    */
   function baseGet(object, path) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
     var index = 0,
         length = path.length;

_baseGetTag.js

@@ -1,24 +1,29 @@
-define([], function() {
+define(['./_Symbol', './_getRawTag', './_objectToString'], function(Symbol, getRawTag, objectToString) {
 
-  /** Used for built-in method references. */
-  var objectProto = Object.prototype;
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+      undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
 
   /**
-   * Used to resolve the
-   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
-   * of values.
-   */
-  var objectToString = objectProto.toString;
-
-  /**
-   * The base implementation of `getTag`.
+   * The base implementation of `getTag` without fallbacks for buggy environments.
    *
    * @private
    * @param {*} value The value to query.
    * @returns {string} Returns the `toStringTag`.
    */
   function baseGetTag(value) {
-    return objectToString.call(value);
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(value);
   }
 
   return baseGetTag;

_baseIndexOf.js

@@ -1,4 +1,4 @@
-define(['./_baseFindIndex', './_baseIsNaN'], function(baseFindIndex, baseIsNaN) {
+define(['./_baseFindIndex', './_baseIsNaN', './_strictIndexOf'], function(baseFindIndex, baseIsNaN, strictIndexOf) {
 
   /**
    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
@@ -10,18 +10,9 @@ define(['./_baseFindIndex', './_baseIsNaN'], function(baseFindIndex, baseIsNaN)
    * @returns {number} Returns the index of the matched value, else `-1`.
    */
   function baseIndexOf(array, value, fromIndex) {
-    if (value !== value) {
-      return baseFindIndex(array, baseIsNaN, fromIndex);
-    }
-    var index = fromIndex - 1,
-        length = array.length;
-
-    while (++index < length) {
-      if (array[index] === value) {
-        return index;
-      }
-    }
-    return -1;
+    return value === value
+      ? strictIndexOf(array, value, fromIndex)
+      : baseFindIndex(array, baseIsNaN, fromIndex);
   }
 
   return baseIndexOf;

_baseInvoke.js

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

_baseIsArguments.js

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

_baseIsArrayBuffer.js

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

_baseIsDate.js

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

_baseIsEqual.js

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

_baseIsEqualDeep.js

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

_baseIsMatch.js

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

_baseIsNative.js

@@ -1,4 +1,4 @@
-define(['./isFunction', './_isHostObject', './_isMasked', './isObject', './_toSource'], function(isFunction, isHostObject, isMasked, isObject, toSource) {
+define(['./isFunction', './_isMasked', './isObject', './_toSource'], function(isFunction, isMasked, isObject, toSource) {
 
   /**
    * Used to match `RegExp`
@@ -37,7 +37,7 @@ define(['./isFunction', './_isHostObject', './_isMasked', './isObject', './_toSo
     if (!isObject(value) || isMasked(value)) {
       return false;
     }
-    var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
     return pattern.test(toSource(value));
   }
 

_baseIsRegExp.js

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

_baseIsTypedArray.js

@@ -1,4 +1,4 @@
-define(['./isLength', './isObjectLike'], function(isLength, isObjectLike) {
+define(['./_baseGetTag', './isLength', './isObjectLike'], function(baseGetTag, isLength, isObjectLike) {
 
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
@@ -43,16 +43,6 @@ define(['./isLength', './isObjectLike'], function(isLength, isObjectLike) {
   typedArrayTags[setTag] = typedArrayTags[stringTag] =
   typedArrayTags[weakMapTag] = false;
 
-  /** Used for built-in method references. */
-  var objectProto = Object.prototype;
-
-  /**
-   * Used to resolve the
-   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
-   * of values.
-   */
-  var objectToString = objectProto.toString;
-
   /**
    * The base implementation of `_.isTypedArray` without Node.js optimizations.
    *
@@ -62,7 +52,7 @@ define(['./isLength', './isObjectLike'], function(isLength, isObjectLike) {
    */
   function baseIsTypedArray(value) {
     return isObjectLike(value) &&
-      isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
   }
 
   return baseIsTypedArray;

_baseMatchesProperty.js

@@ -3,9 +3,9 @@ define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
@@ -23,7 +23,7 @@ define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable
       var objValue = get(object, path);
       return (objValue === undefined && objValue === srcValue)
         ? hasIn(object, path)
-        : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+        : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
     };
   }
 

_baseMean.js

@@ -13,7 +13,7 @@ define(['./_baseSum'], function(baseSum) {
    * @returns {number} Returns the mean.
    */
   function baseMean(array, iteratee) {
-    var length = array ? array.length : 0;
+    var length = array == null ? 0 : array.length;
     return length ? (baseSum(array, iteratee) / length) : NAN;
   }
 

_baseMerge.js

@@ -1,4 +1,4 @@
-define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseKeysIn', './_baseMergeDeep', './isArray', './isObject', './isTypedArray'], function(Stack, arrayEach, assignMergeValue, baseKeysIn, baseMergeDeep, isArray, isObject, isTypedArray) {
+define(['./_Stack', './_assignMergeValue', './_baseFor', './_baseMergeDeep', './isObject', './keysIn'], function(Stack, assignMergeValue, baseFor, baseMergeDeep, isObject, keysIn) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -18,14 +18,7 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseKeysIn', './_
     if (object === source) {
       return;
     }
-    if (!(isArray(source) || isTypedArray(source))) {
-      var props = baseKeysIn(source);
-    }
-    arrayEach(props || source, function(srcValue, key) {
-      if (props) {
-        key = srcValue;
-        srcValue = source[key];
-      }
+    baseFor(source, function(srcValue, key) {
       if (isObject(srcValue)) {
         stack || (stack = new Stack);
         baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
@@ -40,7 +33,7 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseKeysIn', './_
         }
         assignMergeValue(object, key, newValue);
       }
-    });
+    }, keysIn);
   }
 
   return baseMerge;

_baseMergeDeep.js

@@ -1,4 +1,4 @@
-define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments', './isArray', './isArrayLikeObject', './isFunction', './isObject', './isPlainObject', './isTypedArray', './toPlainObject'], function(assignMergeValue, baseClone, copyArray, isArguments, isArray, isArrayLikeObject, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
+define(['./_assignMergeValue', './_cloneBuffer', './_cloneTypedArray', './_copyArray', './_initCloneObject', './isArguments', './isArray', './isArrayLikeObject', './isBuffer', './isFunction', './isObject', './isPlainObject', './isTypedArray', './toPlainObject'], function(assignMergeValue, cloneBuffer, cloneTypedArray, copyArray, initCloneObject, isArguments, isArray, isArrayLikeObject, isBuffer, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -34,29 +34,37 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
     var isCommon = newValue === undefined;
 
     if (isCommon) {
+      var isArr = isArray(srcValue),
+          isBuff = !isArr && isBuffer(srcValue),
+          isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
       newValue = srcValue;
-      if (isArray(srcValue) || isTypedArray(srcValue)) {
+      if (isArr || isBuff || isTyped) {
         if (isArray(objValue)) {
           newValue = objValue;
         }
         else if (isArrayLikeObject(objValue)) {
           newValue = copyArray(objValue);
         }
-        else {
+        else if (isBuff) {
           isCommon = false;
-          newValue = baseClone(srcValue, true);
+          newValue = cloneBuffer(srcValue, true);
+        }
+        else if (isTyped) {
+          isCommon = false;
+          newValue = cloneTypedArray(srcValue, true);
+        }
+        else {
+          newValue = [];
         }
       }
       else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+        newValue = objValue;
         if (isArguments(objValue)) {
           newValue = toPlainObject(objValue);
         }
         else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
-          isCommon = false;
-          newValue = baseClone(srcValue, true);
-        }
-        else {
-          newValue = objValue;
+          newValue = initCloneObject(srcValue);
         }
       }
       else {

_basePick.js

@@ -1,4 +1,4 @@
-define(['./_basePickBy'], function(basePickBy) {
+define(['./_basePickBy', './hasIn'], function(basePickBy, hasIn) {
 
   /**
    * The base implementation of `_.pick` without support for individual
@@ -6,13 +6,12 @@ define(['./_basePickBy'], function(basePickBy) {
    *
    * @private
    * @param {Object} object The source object.
-   * @param {string[]} props The property identifiers to pick.
+   * @param {string[]} paths The property paths to pick.
    * @returns {Object} Returns the new object.
    */
-  function basePick(object, props) {
-    object = Object(object);
-    return basePickBy(object, props, function(value, key) {
-      return key in object;
+  function basePick(object, paths) {
+    return basePickBy(object, paths, function(value, path) {
+      return hasIn(object, path);
     });
   }
 

_basePickBy.js

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

_basePullAt.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './_isIndex', './_isKey', './last', './_parent', './_toKey'], function(castPath, isIndex, isKey, last, parent, toKey) {
+define(['./_baseUnset', './_isIndex'], function(baseUnset, isIndex) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -25,17 +25,8 @@ define(['./_castPath', './_isIndex', './_isKey', './last', './_parent', './_toKe
         var previous = index;
         if (isIndex(index)) {
           splice.call(array, index, 1);
-        }
-        else if (!isKey(index, array)) {
-          var path = castPath(index),
-              object = parent(array, path);
-
-          if (object != null) {
-            delete object[toKey(last(path))];
-          }
-        }
-        else {
-          delete array[toKey(index)];
+        } else {
+          baseUnset(array, index);
         }
       }
     }

_baseRest.js

@@ -1,10 +1,4 @@
-define(['./_apply'], function(apply) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
-
-  /* Built-in method references for those with the same name as other `lodash` methods. */
-  var nativeMax = Math.max;
+define(['./identity', './_overRest', './_setToString'], function(identity, overRest, setToString) {
 
   /**
    * The base implementation of `_.rest` which doesn't validate or coerce arguments.
@@ -15,24 +9,7 @@ define(['./_apply'], function(apply) {
    * @returns {Function} Returns the new function.
    */
   function baseRest(func, start) {
-    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
-    return function() {
-      var args = arguments,
-          index = -1,
-          length = nativeMax(args.length - start, 0),
-          array = Array(length);
-
-      while (++index < length) {
-        array[index] = args[start + index];
-      }
-      index = -1;
-      var otherArgs = Array(start + 1);
-      while (++index < start) {
-        otherArgs[index] = args[index];
-      }
-      otherArgs[start] = array;
-      return apply(func, this, otherArgs);
-    };
+    return setToString(overRest(func, start, identity), func + '');
   }
 
   return baseRest;

_baseSample.js

@@ -0,0 +1,15 @@
+define(['./_arraySample', './values'], function(arraySample, values) {
+
+  /**
+   * The base implementation of `_.sample`.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to sample.
+   * @returns {*} Returns the random element.
+   */
+  function baseSample(collection) {
+    return arraySample(values(collection));
+  }
+
+  return baseSample;
+});

_baseSampleSize.js

@@ -0,0 +1,17 @@
+define(['./_baseClamp', './_shuffleSelf', './values'], function(baseClamp, shuffleSelf, values) {
+
+  /**
+   * The base implementation of `_.sampleSize` without param guards.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to sample.
+   * @param {number} n The number of elements to sample.
+   * @returns {Array} Returns the random elements.
+   */
+  function baseSampleSize(collection, n) {
+    var array = values(collection);
+    return shuffleSelf(array, baseClamp(n, 0, array.length));
+  }
+
+  return baseSampleSize;
+});

_baseSet.js

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

_baseSetData.js

@@ -1,7 +1,7 @@
 define(['./identity', './_metaMap'], function(identity, metaMap) {
 
   /**
-   * The base implementation of `setData` without support for hot loop detection.
+   * The base implementation of `setData` without support for hot loop shorting.
    *
    * @private
    * @param {Function} func The function to associate metadata with.

_baseSetToString.js

@@ -0,0 +1,21 @@
+define(['./constant', './_defineProperty', './identity'], function(constant, defineProperty, identity) {
+
+  /**
+   * The base implementation of `setToString` without support for hot loop shorting.
+   *
+   * @private
+   * @param {Function} func The function to modify.
+   * @param {Function} string The `toString` result.
+   * @returns {Function} Returns `func`.
+   */
+  var baseSetToString = !defineProperty ? identity : function(func, string) {
+    return defineProperty(func, 'toString', {
+      'configurable': true,
+      'enumerable': false,
+      'value': constant(string),
+      'writable': true
+    });
+  };
+
+  return baseSetToString;
+});

_baseShuffle.js

@@ -0,0 +1,15 @@
+define(['./_shuffleSelf', './values'], function(shuffleSelf, values) {
+
+  /**
+   * The base implementation of `_.shuffle`.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to shuffle.
+   * @returns {Array} Returns the new shuffled array.
+   */
+  function baseShuffle(collection) {
+    return shuffleSelf(values(collection));
+  }
+
+  return baseShuffle;
+});

_baseSortedIndex.js

@@ -18,7 +18,7 @@ define(['./_baseSortedIndexBy', './identity', './isSymbol'], function(baseSorted
    */
   function baseSortedIndex(array, value, retHighest) {
     var low = 0,
-        high = array ? array.length : low;
+        high = array == null ? low : array.length;
 
     if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
       while (low < high) {

_baseSortedIndexBy.js

@@ -28,7 +28,7 @@ define(['./isSymbol'], function(isSymbol) {
     value = iteratee(value);
 
     var low = 0,
-        high = array ? array.length : 0,
+        high = array == null ? 0 : array.length,
         valIsNaN = value !== value,
         valIsNull = value === null,
         valIsSymbol = isSymbol(value),

_baseToString.js

@@ -1,4 +1,4 @@
-define(['./_Symbol', './isSymbol'], function(Symbol, isSymbol) {
+define(['./_Symbol', './_arrayMap', './isArray', './isSymbol'], function(Symbol, arrayMap, isArray, isSymbol) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -23,6 +23,10 @@ define(['./_Symbol', './isSymbol'], function(Symbol, isSymbol) {
     if (typeof value == 'string') {
       return value;
     }
+    if (isArray(value)) {
+      // Recursively convert values (susceptible to call stack limits).
+      return arrayMap(value, baseToString) + '';
+    }
     if (isSymbol(value)) {
       return symbolToString ? symbolToString.call(value) : '';
     }

_baseUnset.js

@@ -1,25 +1,17 @@
-define(['./_castPath', './_isKey', './last', './_parent', './_toKey'], function(castPath, isKey, last, parent, toKey) {
-
-  /** Used for built-in method references. */
-  var objectProto = Object.prototype;
-
-  /** Used to check objects for own properties. */
-  var hasOwnProperty = objectProto.hasOwnProperty;
+define(['./_castPath', './last', './_parent', './_toKey'], function(castPath, last, parent, toKey) {
 
   /**
    * The base implementation of `_.unset`.
    *
    * @private
    * @param {Object} object The object to modify.
-   * @param {Array|string} path The path of the property to unset.
+   * @param {Array|string} path The property path to unset.
    * @returns {boolean} Returns `true` if the property is deleted, else `false`.
    */
   function baseUnset(object, path) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
     object = parent(object, path);
-
-    var key = toKey(last(path));
-    return !(object != null && hasOwnProperty.call(object, key)) || delete object[key];
+    return object == null || delete object[toKey(last(path))];
   }
 
   return baseUnset;

_baseXor.js

@@ -1,4 +1,4 @@
-define(['./_arrayPush', './_baseDifference', './_baseUniq'], function(arrayPush, baseDifference, baseUniq) {
+define(['./_baseDifference', './_baseFlatten', './_baseUniq'], function(baseDifference, baseFlatten, baseUniq) {
 
   /**
    * The base implementation of methods like `_.xor`, without support for
@@ -11,18 +11,24 @@ define(['./_arrayPush', './_baseDifference', './_baseUniq'], function(arrayPush,
    * @returns {Array} Returns the new array of values.
    */
   function baseXor(arrays, iteratee, comparator) {
+    var length = arrays.length;
+    if (length < 2) {
+      return length ? baseUniq(arrays[0]) : [];
+    }
     var index = -1,
-        length = arrays.length;
+        result = Array(length);
 
     while (++index < length) {
-      var result = result
-        ? arrayPush(
-            baseDifference(result, arrays[index], iteratee, comparator),
-            baseDifference(arrays[index], result, iteratee, comparator)
-          )
-        : arrays[index];
+      var array = arrays[index],
+          othIndex = -1;
+
+      while (++othIndex < length) {
+        if (othIndex != index) {
+          result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
+        }
+      }
     }
-    return (result && result.length) ? baseUniq(result, iteratee, comparator) : [];
+    return baseUniq(baseFlatten(result, 1), iteratee, comparator);
   }
 
   return baseXor;

_cacheHas.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * Checks if a cache value for `key` exists.
+   * Checks if a `cache` value for `key` exists.
    *
    * @private
    * @param {Object} cache The cache to query.

_castPath.js

@@ -1,14 +1,18 @@
-define(['./isArray', './_stringToPath'], function(isArray, stringToPath) {
+define(['./isArray', './_isKey', './_stringToPath', './toString'], function(isArray, isKey, stringToPath, toString) {
 
   /**
    * Casts `value` to a path array if it's not one.
    *
    * @private
    * @param {*} value The value to inspect.
+   * @param {Object} [object] The object to query keys on.
    * @returns {Array} Returns the cast property path array.
    */
-  function castPath(value) {
-    return isArray(value) ? value : stringToPath(value);
+  function castPath(value, object) {
+    if (isArray(value)) {
+      return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toString(value));
   }
 
   return castPath;

_castRest.js

@@ -0,0 +1,15 @@
+define(['./_baseRest'], function(baseRest) {
+
+  /**
+   * A `baseRest` alias which can be replaced with `identity` by module
+   * replacement plugins.
+   *
+   * @private
+   * @type {Function}
+   * @param {Function} func The function to apply a rest parameter to.
+   * @returns {Function} Returns the new function.
+   */
+  var castRest = baseRest;
+
+  return castRest;
+});

_cloneBuffer.js

@@ -1,4 +1,20 @@
-define([], function() {
+define(['./_root'], function(root) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Detect free variable `exports`. */
+  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Built-in value references. */
+  var Buffer = moduleExports ? root.Buffer : undefined,
+      allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
 
   /**
    * Creates a clone of  `buffer`.
@@ -12,7 +28,9 @@ define([], function() {
     if (isDeep) {
       return buffer.slice();
     }
-    var result = new buffer.constructor(buffer.length);
+    var length = buffer.length,
+        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
     buffer.copy(result);
     return result;
   }

_cloneMap.js

@@ -1,5 +1,8 @@
 define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEntry, arrayReduce, mapToArray) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a clone of `map`.
    *
@@ -10,7 +13,7 @@ define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEnt
    * @returns {Object} Returns the cloned map.
    */
   function cloneMap(map, isDeep, cloneFunc) {
-    var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+    var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
     return arrayReduce(array, addMapEntry, new map.constructor);
   }
 

_cloneSet.js

@@ -1,5 +1,8 @@
 define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEntry, arrayReduce, setToArray) {
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1;
+
   /**
    * Creates a clone of `set`.
    *
@@ -10,7 +13,7 @@ define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEnt
    * @returns {Object} Returns the cloned set.
    */
   function cloneSet(set, isDeep, cloneFunc) {
-    var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+    var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
     return arrayReduce(array, addSetEntry, new set.constructor);
   }
 

_copyObject.js

@@ -1,4 +1,4 @@
-define(['./_assignValue'], function(assignValue) {
+define(['./_assignValue', './_baseAssignValue'], function(assignValue, baseAssignValue) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,6 +14,7 @@ define(['./_assignValue'], function(assignValue) {
    * @returns {Object} Returns `object`.
    */
   function copyObject(source, props, object, customizer) {
+    var isNew = !object;
     object || (object = {});
 
     var index = -1,
@@ -26,7 +27,14 @@ define(['./_assignValue'], function(assignValue) {
         ? customizer(object[key], source[key], key, object, source)
         : undefined;
 
-      assignValue(object, key, newValue === undefined ? source[key] : newValue);
+      if (newValue === undefined) {
+        newValue = source[key];
+      }
+      if (isNew) {
+        baseAssignValue(object, key, newValue);
+      } else {
+        assignValue(object, key, newValue);
+      }
     }
     return object;
   }

_copySymbols.js

@@ -1,7 +1,7 @@
 define(['./_copyObject', './_getSymbols'], function(copyObject, getSymbols) {
 
   /**
-   * Copies own symbol properties of `source` to `object`.
+   * Copies own symbols of `source` to `object`.
    *
    * @private
    * @param {Object} source The object to copy symbols from.

_copySymbolsIn.js

@@ -0,0 +1,16 @@
+define(['./_copyObject', './_getSymbolsIn'], function(copyObject, getSymbolsIn) {
+
+  /**
+   * Copies own and inherited symbols of `source` to `object`.
+   *
+   * @private
+   * @param {Object} source The object to copy symbols from.
+   * @param {Object} [object={}] The object to copy symbols to.
+   * @returns {Object} Returns `object`.
+   */
+  function copySymbolsIn(source, object) {
+    return copyObject(source, getSymbolsIn(source), object);
+  }
+
+  return copySymbolsIn;
+});

_countHolders.js

@@ -14,7 +14,7 @@ define([], function() {
 
     while (length--) {
       if (array[length] === placeholder) {
-        result++;
+        ++result;
       }
     }
     return result;

_createBind.js

@@ -1,7 +1,7 @@
 define(['./_createCtor', './_root'], function(createCtor, root) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1;
+  var WRAP_BIND_FLAG = 1;
 
   /**
    * Creates a function that wraps `func` to invoke it with the optional `this`
@@ -14,7 +14,7 @@ define(['./_createCtor', './_root'], function(createCtor, root) {
    * @returns {Function} Returns the new wrapped function.
    */
   function createBind(func, bitmask, thisArg) {
-    var isBind = bitmask & BIND_FLAG,
+    var isBind = bitmask & WRAP_BIND_FLAG,
         Ctor = createCtor(func);
 
     function wrapper() {

_createFlow.js

@@ -1,19 +1,16 @@
-define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_getFuncName', './isArray', './_isLaziable'], function(LodashWrapper, baseFlatten, baseRest, getData, getFuncName, isArray, isLaziable) {
+define(['./_LodashWrapper', './_flatRest', './_getData', './_getFuncName', './isArray', './_isLaziable'], function(LodashWrapper, flatRest, getData, getFuncName, isArray, isLaziable) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used as the size to enable large array optimizations. */
-  var LARGE_ARRAY_SIZE = 200;
-
-  /** Used as the `TypeError` message for "Functions" methods. */
+  /** Error message constants. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /** Used to compose bitmasks for function metadata. */
-  var CURRY_FLAG = 8,
-      PARTIAL_FLAG = 32,
-      ARY_FLAG = 128,
-      REARG_FLAG = 256;
+  var WRAP_CURRY_FLAG = 8,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_ARY_FLAG = 128,
+      WRAP_REARG_FLAG = 256;
 
   /**
    * Creates a `_.flow` or `_.flowRight` function.
@@ -23,9 +20,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_g
    * @returns {Function} Returns the new flow function.
    */
   function createFlow(fromRight) {
-    return baseRest(function(funcs) {
-      funcs = baseFlatten(funcs, 1);
-
+    return flatRest(function(funcs) {
       var length = funcs.length,
           index = length,
           prereq = LodashWrapper.prototype.thru;
@@ -50,7 +45,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_g
             data = funcName == 'wrapper' ? getData(func) : undefined;
 
         if (data && isLaziable(data[0]) &&
-              data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) &&
+              data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
               !data[4].length && data[9] == 1
             ) {
           wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
@@ -64,8 +59,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_g
         var args = arguments,
             value = args[0];
 
-        if (wrapper && args.length == 1 &&
-            isArray(value) && value.length >= LARGE_ARRAY_SIZE) {
+        if (wrapper && args.length == 1 && isArray(value)) {
           return wrapper.plant(value).value();
         }
         var index = 0,

_createHybrid.js

@@ -4,12 +4,12 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_FLAG = 8,
-      CURRY_RIGHT_FLAG = 16,
-      ARY_FLAG = 128,
-      FLIP_FLAG = 512;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_CURRY_RIGHT_FLAG = 16,
+      WRAP_ARY_FLAG = 128,
+      WRAP_FLIP_FLAG = 512;
 
   /**
    * Creates a function that wraps `func` to invoke it with optional `this`
@@ -31,11 +31,11 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    * @returns {Function} Returns the new wrapped function.
    */
   function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
-    var isAry = bitmask & ARY_FLAG,
-        isBind = bitmask & BIND_FLAG,
-        isBindKey = bitmask & BIND_KEY_FLAG,
-        isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
-        isFlip = bitmask & FLIP_FLAG,
+    var isAry = bitmask & WRAP_ARY_FLAG,
+        isBind = bitmask & WRAP_BIND_FLAG,
+        isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
+        isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
+        isFlip = bitmask & WRAP_FLIP_FLAG,
         Ctor = isBindKey ? undefined : createCtor(func);
 
     function wrapper() {

_createOver.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseRest', './_baseUnary', './isArray'], function(apply, arrayMap, baseFlatten, baseIteratee, baseRest, baseUnary, isArray) {
+define(['./_apply', './_arrayMap', './_baseIteratee', './_baseRest', './_baseUnary', './_flatRest'], function(apply, arrayMap, baseIteratee, baseRest, baseUnary, flatRest) {
 
   /**
    * Creates a function like `_.over`.
@@ -8,11 +8,8 @@ define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_base
    * @returns {Function} Returns the new over function.
    */
   function createOver(arrayFunc) {
-    return baseRest(function(iteratees) {
-      iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
-        ? arrayMap(iteratees[0], baseUnary(baseIteratee))
-        : arrayMap(baseFlatten(iteratees, 1), baseUnary(baseIteratee));
-
+    return flatRest(function(iteratees) {
+      iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
       return baseRest(function(args) {
         var thisArg = this;
         return arrayFunc(iteratees, function(iteratee) {

_createPartial.js

@@ -1,7 +1,7 @@
 define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, root) {
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1;
+  var WRAP_BIND_FLAG = 1;
 
   /**
    * Creates a function that wraps `func` to invoke it with the `this` binding
@@ -16,7 +16,7 @@ define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, roo
    * @returns {Function} Returns the new wrapped function.
    */
   function createPartial(func, bitmask, thisArg, partials) {
-    var isBind = bitmask & BIND_FLAG,
+    var isBind = bitmask & WRAP_BIND_FLAG,
         Ctor = createCtor(func);
 
     function wrapper() {

_createRecurry.js

@@ -4,12 +4,12 @@ define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziabl
   var undefined;
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_BOUND_FLAG = 4,
-      CURRY_FLAG = 8,
-      PARTIAL_FLAG = 32,
-      PARTIAL_RIGHT_FLAG = 64;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_BOUND_FLAG = 4,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_PARTIAL_RIGHT_FLAG = 64;
 
   /**
    * Creates a function that wraps `func` to continue currying.
@@ -29,17 +29,17 @@ define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziabl
    * @returns {Function} Returns the new wrapped function.
    */
   function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
-    var isCurry = bitmask & CURRY_FLAG,
+    var isCurry = bitmask & WRAP_CURRY_FLAG,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
         newPartials = isCurry ? partials : undefined,
         newPartialsRight = isCurry ? undefined : partials;
 
-    bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
-    bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
+    bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
+    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
 
-    if (!(bitmask & CURRY_BOUND_FLAG)) {
-      bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
+    if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
+      bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
     }
     var newData = [
       func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,

_createRound.js

@@ -14,7 +14,7 @@ define(['./toInteger', './toNumber', './toString'], function(toInteger, toNumber
     var func = Math[methodName];
     return function(number, precision) {
       number = toNumber(number);
-      precision = nativeMin(toInteger(precision), 292);
+      precision = precision == null ? 0 : 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.

_createWrap.js

@@ -3,16 +3,16 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used as the `TypeError` message for "Functions" methods. */
+  /** Error message constants. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /** Used to compose bitmasks for function metadata. */
-  var BIND_FLAG = 1,
-      BIND_KEY_FLAG = 2,
-      CURRY_FLAG = 8,
-      CURRY_RIGHT_FLAG = 16,
-      PARTIAL_FLAG = 32,
-      PARTIAL_RIGHT_FLAG = 64;
+  var WRAP_BIND_FLAG = 1,
+      WRAP_BIND_KEY_FLAG = 2,
+      WRAP_CURRY_FLAG = 8,
+      WRAP_CURRY_RIGHT_FLAG = 16,
+      WRAP_PARTIAL_FLAG = 32,
+      WRAP_PARTIAL_RIGHT_FLAG = 64;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeMax = Math.max;
@@ -24,17 +24,16 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
    * @private
    * @param {Function|string} func The function or method name to wrap.
    * @param {number} bitmask The bitmask flags.
-   *  The bitmask may be composed of the following flags:
-   *     1 - `_.bind`
-   *     2 - `_.bindKey`
-   *     4 - `_.curry` or `_.curryRight` of a bound function
-   *     8 - `_.curry`
-   *    16 - `_.curryRight`
-   *    32 - `_.partial`
-   *    64 - `_.partialRight`
-   *   128 - `_.rearg`
-   *   256 - `_.ary`
-   *   512 - `_.flip`
+   *    1 - `_.bind`
+   *    2 - `_.bindKey`
+   *    4 - `_.curry` or `_.curryRight` of a bound function
+   *    8 - `_.curry`
+   *   16 - `_.curryRight`
+   *   32 - `_.partial`
+   *   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.
@@ -44,20 +43,20 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
    * @returns {Function} Returns the new wrapped function.
    */
   function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
-    var isBindKey = bitmask & BIND_KEY_FLAG;
+    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
     if (!isBindKey && typeof func != 'function') {
       throw new TypeError(FUNC_ERROR_TEXT);
     }
     var length = partials ? partials.length : 0;
     if (!length) {
-      bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
+      bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
       partials = holders = undefined;
     }
     ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
     arity = arity === undefined ? arity : toInteger(arity);
     length -= holders ? holders.length : 0;
 
-    if (bitmask & PARTIAL_RIGHT_FLAG) {
+    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
       var partialsRight = partials,
           holdersRight = holders;
 
@@ -78,18 +77,18 @@ define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid',
     thisArg = newData[2];
     partials = newData[3];
     holders = newData[4];
-    arity = newData[9] = newData[9] == null
+    arity = newData[9] = newData[9] === undefined
       ? (isBindKey ? 0 : func.length)
       : nativeMax(newData[9] - length, 0);
 
-    if (!arity && bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG)) {
-      bitmask &= ~(CURRY_FLAG | CURRY_RIGHT_FLAG);
+    if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
+      bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
     }
-    if (!bitmask || bitmask == BIND_FLAG) {
+    if (!bitmask || bitmask == WRAP_BIND_FLAG) {
       var result = createBind(func, bitmask, thisArg);
-    } else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
+    } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
       result = createCurry(func, bitmask, arity);
-    } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
+    } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
       result = createPartial(func, bitmask, thisArg, partials);
     } else {
       result = createHybrid.apply(undefined, newData);

_customDefaultsAssignIn.js

@@ -10,7 +10,9 @@ define(['./eq'], function(eq) {
   var hasOwnProperty = objectProto.hasOwnProperty;
 
   /**
-   * Used by `_.defaults` to customize its `_.assignIn` use.
+   * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
+   * of source objects to the destination object for all destination properties
+   * that resolve to `undefined`.
    *
    * @private
    * @param {*} objValue The destination value.
@@ -19,7 +21,7 @@ define(['./eq'], function(eq) {
    * @param {Object} object The parent object of `objValue`.
    * @returns {*} Returns the value to assign.
    */
-  function assignInDefaults(objValue, srcValue, key, object) {
+  function customDefaultsAssignIn(objValue, srcValue, key, object) {
     if (objValue === undefined ||
         (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
       return srcValue;
@@ -27,5 +29,5 @@ define(['./eq'], function(eq) {
     return objValue;
   }
 
-  return assignInDefaults;
+  return customDefaultsAssignIn;
 });

_customDefaultsMerge.js

@@ -4,7 +4,8 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
   var undefined;
 
   /**
-   * Used by `_.defaultsDeep` to customize its `_.merge` use.
+   * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
+   * objects into destination objects that are passed thru.
    *
    * @private
    * @param {*} objValue The destination value.
@@ -16,15 +17,15 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
    *  counterparts.
    * @returns {*} Returns the value to assign.
    */
-  function mergeDefaults(objValue, srcValue, key, object, source, stack) {
+  function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
     if (isObject(objValue) && isObject(srcValue)) {
       // Recursively merge objects and arrays (susceptible to call stack limits).
       stack.set(srcValue, objValue);
-      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack);
+      baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
       stack['delete'](srcValue);
     }
     return objValue;
   }
 
-  return mergeDefaults;
+  return customDefaultsMerge;
 });

_customOmitClone.js

@@ -0,0 +1,20 @@
+define(['./isPlainObject'], function(isPlainObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
+   * objects.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @param {string} key The key of the property to inspect.
+   * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
+   */
+  function customOmitClone(value) {
+    return isPlainObject(value) ? undefined : value;
+  }
+
+  return customOmitClone;
+});

_deburrLetter.js

@@ -55,7 +55,7 @@ define(['./_basePropertyOf'], function(basePropertyOf) {
     '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
     '\u0132': 'IJ', '\u0133': 'ij',
     '\u0152': 'Oe', '\u0153': 'oe',
-    '\u0149': "'n", '\u017f': 'ss'
+    '\u0149': "'n", '\u017f': 's'
   };
 
   /**

_defineProperty.js

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

_equalArrays.js

@@ -1,11 +1,11 @@
-define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
+define(['./_SetCache', './_arraySome', './_cacheHas'], function(SetCache, arraySome, cacheHas) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /**
    * A specialized version of `baseIsEqualDeep` for arrays with support for
@@ -14,15 +14,14 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
    * @private
    * @param {Array} array The array to compare.
    * @param {Array} other The other array to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `array` and `other` objects.
    * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
    */
-  function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
-    var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
         arrLength = array.length,
         othLength = other.length;
 
@@ -36,7 +35,7 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
     }
     var index = -1,
         result = true,
-        seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+        seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
 
     stack.set(array, other);
     stack.set(other, array);
@@ -61,9 +60,9 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
       // Recursively compare arrays (susceptible to call stack limits).
       if (seen) {
         if (!arraySome(other, function(othValue, othIndex) {
-              if (!seen.has(othIndex) &&
-                  (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
-                return seen.add(othIndex);
+              if (!cacheHas(seen, othIndex) &&
+                  (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+                return seen.push(othIndex);
               }
             })) {
           result = false;
@@ -71,7 +70,7 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
         }
       } else if (!(
             arrValue === othValue ||
-              equalFunc(arrValue, othValue, customizer, bitmask, stack)
+              equalFunc(arrValue, othValue, bitmask, customizer, stack)
           )) {
         result = false;
         break;

_equalByTag.js

@@ -3,9 +3,9 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var UNORDERED_COMPARE_FLAG = 1,
-      PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
 
   /** `Object#toString` result references. */
   var boolTag = '[object Boolean]',
@@ -36,14 +36,13 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
    * @param {string} tag The `toStringTag` of the objects to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `object` and `other` objects.
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
-  function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
     switch (tag) {
       case dataViewTag:
         if ((object.byteLength != other.byteLength) ||
@@ -81,7 +80,7 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
         var convert = mapToArray;
 
       case setTag:
-        var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
         convert || (convert = setToArray);
 
         if (object.size != other.size && !isPartial) {
@@ -92,11 +91,11 @@ define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray',
         if (stacked) {
           return stacked == other;
         }
-        bitmask |= UNORDERED_COMPARE_FLAG;
+        bitmask |= COMPARE_UNORDERED_FLAG;
 
         // Recursively compare objects (susceptible to call stack limits).
         stack.set(object, other);
-        var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
         stack['delete'](object);
         return result;
 

_equalObjects.js

@@ -1,10 +1,10 @@
-define(['./keys'], function(keys) {
+define(['./_getAllKeys'], function(getAllKeys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for comparison styles. */
-  var PARTIAL_COMPARE_FLAG = 2;
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1;
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -19,18 +19,17 @@ define(['./keys'], function(keys) {
    * @private
    * @param {Object} object The object to compare.
    * @param {Object} other The other object to compare.
-   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
    * @param {Function} customizer The function to customize comparisons.
-   * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
-   *  for more details.
+   * @param {Function} equalFunc The function to determine equivalents of values.
    * @param {Object} stack Tracks traversed `object` and `other` objects.
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
-  function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
-    var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
-        objProps = keys(object),
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+        objProps = getAllKeys(object),
         objLength = objProps.length,
-        othProps = keys(other),
+        othProps = getAllKeys(other),
         othLength = othProps.length;
 
     if (objLength != othLength && !isPartial) {
@@ -65,7 +64,7 @@ define(['./keys'], function(keys) {
       }
       // Recursively compare objects (susceptible to call stack limits).
       if (!(compared === undefined
-            ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
+            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
             : compared
           )) {
         result = false;

_escapeHtmlChar.js

@@ -6,8 +6,7 @@ define(['./_basePropertyOf'], function(basePropertyOf) {
     '<': '&lt;',
     '>': '&gt;',
     '"': '&quot;',
-    "'": '&#39;',
-    '`': '&#96;'
+    "'": '&#39;'
   };
 
   /**

_flatRest.js

@@ -0,0 +1,18 @@
+define(['./flatten', './_overRest', './_setToString'], function(flatten, overRest, setToString) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * A specialized version of `baseRest` which flattens the rest array.
+   *
+   * @private
+   * @param {Function} func The function to apply a rest parameter to.
+   * @returns {Function} Returns the new function.
+   */
+  function flatRest(func) {
+    return setToString(overRest(func, undefined, flatten), func + '');
+  }
+
+  return flatRest;
+});

_getRawTag.js

@@ -0,0 +1,50 @@
+define(['./_Symbol'], function(Symbol) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+  /**
+   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the raw `toStringTag`.
+   */
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag),
+        tag = value[symToStringTag];
+
+    try {
+      value[symToStringTag] = undefined;
+      var unmasked = true;
+    } catch (e) {}
+
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
+  }
+
+  return getRawTag;
+});

_getSymbols.js

@@ -1,16 +1,30 @@
-define(['./_overArg', './stubArray'], function(overArg, stubArray) {
+define(['./_arrayFilter', './stubArray'], function(arrayFilter, stubArray) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
-   * Creates an array of the own enumerable symbol properties of `object`.
+   * Creates an array of the own enumerable symbols of `object`.
    *
    * @private
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of symbols.
    */
-  var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
 
   return getSymbols;
 });

_getSymbolsIn.js

@@ -4,8 +4,7 @@ define(['./_arrayPush', './_getPrototype', './_getSymbols', './stubArray'], func
   var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
-   * Creates an array of the own and inherited enumerable symbol properties
-   * of `object`.
+   * Creates an array of the own and inherited enumerable symbols of `object`.
    *
    * @private
    * @param {Object} object The object to query.

_getTag.js

@@ -12,16 +12,6 @@ define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_baseG
 
   var dataViewTag = '[object DataView]';
 
-  /** Used for built-in method references. */
-  var objectProto = Object.prototype;
-
-  /**
-   * Used to resolve the
-   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
-   * of values.
-   */
-  var objectToString = objectProto.toString;
-
   /** Used to detect maps, sets, and weakmaps. */
   var dataViewCtorString = toSource(DataView),
       mapCtorString = toSource(Map),
@@ -38,17 +28,16 @@ define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_baseG
    */
   var getTag = baseGetTag;
 
-  // Fallback for data views, maps, sets, and weak maps in IE 11,
-  // for data views in Edge < 14, and promises in Node.js.
+  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
   if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
       (Map && getTag(new Map) != mapTag) ||
       (Promise && getTag(Promise.resolve()) != promiseTag) ||
       (Set && getTag(new Set) != setTag) ||
       (WeakMap && getTag(new WeakMap) != weakMapTag)) {
     getTag = function(value) {
-      var result = objectToString.call(value),
+      var result = baseGetTag(value),
           Ctor = result == objectTag ? value.constructor : undefined,
-          ctorString = Ctor ? toSource(Ctor) : undefined;
+          ctorString = Ctor ? toSource(Ctor) : '';
 
       if (ctorString) {
         switch (ctorString) {

_hasPath.js

@@ -1,4 +1,4 @@
-define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './_toKey'], function(castPath, isArguments, isArray, isIndex, isKey, isLength, toKey) {
+define(['./_castPath', './isArguments', './isArray', './_isIndex', './isLength', './_toKey'], function(castPath, isArguments, isArray, isIndex, isLength, toKey) {
 
   /**
    * Checks if `path` exists on `object`.
@@ -10,11 +10,11 @@ define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', '
    * @returns {boolean} Returns `true` if `path` exists, else `false`.
    */
   function hasPath(object, path, hasFunc) {
-    path = isKey(path, object) ? [path] : castPath(path);
+    path = castPath(path, object);
 
-    var result,
-        index = -1,
-        length = path.length;
+    var index = -1,
+        length = path.length,
+        result = false;
 
     while (++index < length) {
       var key = toKey(path[index]);
@@ -23,10 +23,10 @@ define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', '
       }
       object = object[key];
     }
-    if (result) {
+    if (result || ++index != length) {
       return result;
     }
-    var length = object ? object.length : 0;
+    length = object == null ? 0 : object.length;
     return !!length && isLength(length) && isIndex(key, length) &&
       (isArray(object) || isArguments(object));
   }

_hasUnicode.js

@@ -2,15 +2,17 @@ define([], function() {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
+      rsComboMarksRange = '\\u0300-\\u036f',
+      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+      rsComboSymbolsRange = '\\u20d0-\\u20ff',
+      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
       rsVarRange = '\\ufe0e\\ufe0f';
 
   /** Used to compose unicode capture groups. */
   var rsZWJ = '\\u200d';
 
   /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
-  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
+  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
 
   /**
    * Checks if `string` contains Unicode symbols.

_hashClear.js

@@ -9,6 +9,7 @@ define(['./_nativeCreate'], function(nativeCreate) {
    */
   function hashClear() {
     this.__data__ = nativeCreate ? nativeCreate(null) : {};
+    this.size = 0;
   }
 
   return hashClear;

_hashDelete.js

@@ -11,7 +11,9 @@ define([], function() {
    * @returns {boolean} Returns `true` if the entry was removed, else `false`.
    */
   function hashDelete(key) {
-    return this.has(key) && delete this.__data__[key];
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
   }
 
   return hashDelete;

_hashHas.js

@@ -20,7 +20,7 @@ define(['./_nativeCreate'], function(nativeCreate) {
    */
   function hashHas(key) {
     var data = this.__data__;
-    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
   }
 
   return hashHas;