Bump to v4.14.2.

README.md

@@ -1,6 +1,6 @@
-# lodash v4.7.0
+# lodash v4.14.2
 
-The [lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
+The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
 
 ## Installation
 
@@ -28,13 +28,13 @@ var chunk = require('lodash/chunk');
 var extend = require('lodash/fp/extend');
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.7.0-npm) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.14.2-npm) for more details.
 
 **Note:**<br>
-Don’t assign values to the [special variable](http://nodejs.org/api/repl.html#repl_repl_features) `_` when in the REPL.<br>
+Don’t assign values to the [special variable](http://nodejs.org/api/repl.html#repl_repl_features) `_` in the Node.js < 6 REPL.<br>
-Install [n_](https://www.npmjs.com/package/n_) for a REPL that includes lodash by default.
+Install [n_](https://www.npmjs.com/package/n_) for a REPL that includes `lodash` by default.
 
 ## Support
 
-Tested in Chrome 48-49, Firefox 44-45, IE 9-11, Edge 13, Safari 8-9, Node.js 0.10, 0.12, 4, & 5, & PhantomJS 1.9.8.<br>
+Tested in Chrome 51-52, Firefox 47-48, IE 9-11, Edge 14, Safari 8-9, Node.js 0.10-6, & PhantomJS 2.1.1.<br>
 Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.

_Hash.js

@@ -1,18 +1,32 @@
-var nativeCreate = require('./_nativeCreate');
+var hashClear = require('./_hashClear'),
-
+    hashDelete = require('./_hashDelete'),
-/** Used for built-in method references. */
+    hashGet = require('./_hashGet'),
-var objectProto = Object.prototype;
+    hashHas = require('./_hashHas'),
+    hashSet = require('./_hashSet');
 
 /**
- * Creates an hash object.
+ * Creates a hash object.
  *
  * @private
  * @constructor
- * @returns {Object} Returns the new hash object.
+ * @param {Array} [entries] The key-value pairs to cache.
  */
-function Hash() {}
+function Hash(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
 
-// Avoid inheriting from `Object.prototype` when possible.
+  this.clear();
-Hash.prototype = nativeCreate ? nativeCreate(null) : objectProto;
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
 
 module.exports = Hash;

_ListCache.js

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

_MapCache.js

@@ -1,32 +1,32 @@
-var mapClear = require('./_mapClear'),
+var mapCacheClear = require('./_mapCacheClear'),
-    mapDelete = require('./_mapDelete'),
+    mapCacheDelete = require('./_mapCacheDelete'),
-    mapGet = require('./_mapGet'),
+    mapCacheGet = require('./_mapCacheGet'),
-    mapHas = require('./_mapHas'),
+    mapCacheHas = require('./_mapCacheHas'),
-    mapSet = require('./_mapSet');
+    mapCacheSet = require('./_mapCacheSet');
 
 /**
  * Creates a map cache object to store key-value pairs.
  *
  * @private
  * @constructor
- * @param {Array} [values] The values to cache.
+ * @param {Array} [entries] The key-value pairs to cache.
  */
-function MapCache(values) {
+function MapCache(entries) {
   var index = -1,
-      length = values ? values.length : 0;
+      length = entries ? entries.length : 0;
 
   this.clear();
   while (++index < length) {
-    var entry = values[index];
+    var entry = entries[index];
     this.set(entry[0], entry[1]);
   }
 }
 
 // Add methods to `MapCache`.
-MapCache.prototype.clear = mapClear;
+MapCache.prototype.clear = mapCacheClear;
-MapCache.prototype['delete'] = mapDelete;
+MapCache.prototype['delete'] = mapCacheDelete;
-MapCache.prototype.get = mapGet;
+MapCache.prototype.get = mapCacheGet;
-MapCache.prototype.has = mapHas;
+MapCache.prototype.has = mapCacheHas;
-MapCache.prototype.set = mapSet;
+MapCache.prototype.set = mapCacheSet;
 
 module.exports = MapCache;

_Reflect.js

@@ -1,6 +0,0 @@
-var root = require('./_root');
-
-/** Built-in value references. */
-var Reflect = root.Reflect;
-
-module.exports = Reflect;

_SetCache.js

@@ -1,9 +1,10 @@
 var MapCache = require('./_MapCache'),
-    cachePush = require('./_cachePush');
+    setCacheAdd = require('./_setCacheAdd'),
+    setCacheHas = require('./_setCacheHas');
 
 /**
  *
- * Creates a set cache object to store unique values.
+ * Creates an array cache object to store unique values.
  *
  * @private
  * @constructor
@@ -15,11 +16,12 @@ function SetCache(values) {
 
   this.__data__ = new MapCache;
   while (++index < length) {
-    this.push(values[index]);
+    this.add(values[index]);
   }
 }
 
 // Add methods to `SetCache`.
-SetCache.prototype.push = cachePush;
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
 
 module.exports = SetCache;

_Stack.js

@@ -1,4 +1,5 @@
-var stackClear = require('./_stackClear'),
+var ListCache = require('./_ListCache'),
+    stackClear = require('./_stackClear'),
     stackDelete = require('./_stackDelete'),
     stackGet = require('./_stackGet'),
     stackHas = require('./_stackHas'),
@@ -9,17 +10,10 @@ var stackClear = require('./_stackClear'),
  *
  * @private
  * @constructor
- * @param {Array} [values] The values to cache.
+ * @param {Array} [entries] The key-value pairs to cache.
  */
-function Stack(values) {
+function Stack(entries) {
-  var index = -1,
+  this.__data__ = new ListCache(entries);
-      length = values ? values.length : 0;
-
-  this.clear();
-  while (++index < length) {
-    var entry = values[index];
-    this.set(entry[0], entry[1]);
-  }
 }
 
 // Add methods to `Stack`.

_addMapEntry.js

@@ -7,7 +7,7 @@
  * @returns {Object} Returns `map`.
  */
 function addMapEntry(map, pair) {
-  // Don't return `Map#set` because it doesn't return the map instance in IE 11.
+  // Don't return `map.set` because it's not chainable in IE 11.
   map.set(pair[0], pair[1]);
   return map;
 }

_addSetEntry.js

@@ -7,6 +7,7 @@
  * @returns {Object} Returns `set`.
  */
 function addSetEntry(set, value) {
+  // Don't return `set.add` because it's not chainable in IE 11.
   set.add(value);
   return set;
 }

_apply.js

@@ -5,12 +5,11 @@
  * @private
  * @param {Function} func The function to invoke.
  * @param {*} thisArg The `this` binding of `func`.
- * @param {...*} args The arguments to invoke `func` with.
+ * @param {Array} args The arguments to invoke `func` with.
  * @returns {*} Returns the result of `func`.
  */
 function apply(func, thisArg, args) {
-  var length = args.length;
+  switch (args.length) {
-  switch (length) {
     case 0: return func.call(thisArg);
     case 1: return func.call(thisArg, args[0]);
     case 2: return func.call(thisArg, args[0], args[1]);

_arrayAggregator.js

@@ -2,7 +2,7 @@
  * A specialized version of `baseAggregator` for arrays.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} setter The function to set `accumulator` values.
  * @param {Function} iteratee The iteratee to transform keys.
  * @param {Object} accumulator The initial aggregated object.
@@ -10,7 +10,7 @@
  */
 function arrayAggregator(array, setter, iteratee, accumulator) {
   var index = -1,
-      length = array.length;
+      length = array ? array.length : 0;
 
   while (++index < length) {
     var value = array[index];

_arrayConcat.js

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

_arrayEach.js

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

_arrayEachRight.js

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

_arrayEvery.js

@@ -3,14 +3,14 @@
  * iteratee shorthands.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} predicate The function invoked per iteration.
  * @returns {boolean} Returns `true` if all elements pass the predicate check,
  *  else `false`.
  */
 function arrayEvery(array, predicate) {
   var index = -1,
-      length = array.length;
+      length = array ? array.length : 0;
 
   while (++index < length) {
     if (!predicate(array[index], index, array)) {

_arrayFilter.js

@@ -3,13 +3,13 @@
  * iteratee shorthands.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} predicate The function invoked per iteration.
  * @returns {Array} Returns the new filtered array.
  */
 function arrayFilter(array, predicate) {
   var index = -1,
-      length = array.length,
+      length = array ? array.length : 0,
       resIndex = 0,
       result = [];
 

_arrayIncludes.js

@@ -5,12 +5,13 @@ var baseIndexOf = require('./_baseIndexOf');
  * specifying an index to search from.
  *
  * @private
- * @param {Array} array The array to search.
+ * @param {Array} [array] The array to search.
  * @param {*} target The value to search for.
  * @returns {boolean} Returns `true` if `target` is found, else `false`.
  */
 function arrayIncludes(array, value) {
-  return !!array.length && baseIndexOf(array, value, 0) > -1;
+  var length = array ? array.length : 0;
+  return !!length && baseIndexOf(array, value, 0) > -1;
 }
 
 module.exports = arrayIncludes;

_arrayIncludesWith.js

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

_arrayLikeKeys.js

@@ -0,0 +1,38 @@
+var baseTimes = require('./_baseTimes'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isIndex = require('./_isIndex'),
+    isString = require('./isString');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var result = (isArray(value) || isString(value) || isArguments(value))
+    ? baseTimes(value.length, String)
+    : [];
+
+  var length = result.length,
+      skipIndexes = !!length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) &&
+        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = arrayLikeKeys;

_arrayMap.js

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

_arrayReduce.js

@@ -3,7 +3,7 @@
  * iteratee shorthands.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} iteratee The function invoked per iteration.
  * @param {*} [accumulator] The initial value.
  * @param {boolean} [initAccum] Specify using the first element of `array` as
@@ -12,7 +12,7 @@
  */
 function arrayReduce(array, iteratee, accumulator, initAccum) {
   var index = -1,
-      length = array.length;
+      length = array ? array.length : 0;
 
   if (initAccum && length) {
     accumulator = array[++index];

_arrayReduceRight.js

@@ -3,7 +3,7 @@
  * iteratee shorthands.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} iteratee The function invoked per iteration.
  * @param {*} [accumulator] The initial value.
  * @param {boolean} [initAccum] Specify using the last element of `array` as
@@ -11,7 +11,7 @@
  * @returns {*} Returns the accumulated value.
  */
 function arrayReduceRight(array, iteratee, accumulator, initAccum) {
-  var length = array.length;
+  var length = array ? array.length : 0;
   if (initAccum && length) {
     accumulator = array[--length];
   }

_arraySome.js

@@ -3,14 +3,14 @@
  * shorthands.
  *
  * @private
- * @param {Array} array The array to iterate over.
+ * @param {Array} [array] The array to iterate over.
  * @param {Function} predicate The function invoked per iteration.
  * @returns {boolean} Returns `true` if any element passes the predicate check,
  *  else `false`.
  */
 function arraySome(array, predicate) {
   var index = -1,
-      length = array.length;
+      length = array ? array.length : 0;
 
   while (++index < length) {
     if (predicate(array[index], index, array)) {

_assignValue.js

@@ -8,7 +8,7 @@ var hasOwnProperty = objectProto.hasOwnProperty;
 
 /**
  * Assigns `value` to `key` of `object` if the existing value is not equivalent
- * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
  * for equality comparisons.
  *
  * @private

_assocGet.js

@@ -1,16 +0,0 @@
-var assocIndexOf = require('./_assocIndexOf');
-
-/**
- * Gets the associative array value for `key`.
- *
- * @private
- * @param {Array} array The array to query.
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function assocGet(array, key) {
-  var index = assocIndexOf(array, key);
-  return index < 0 ? undefined : array[index][1];
-}
-
-module.exports = assocGet;

_assocSet.js

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

_baseAt.js

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

_baseCastKey.js

@@ -1,14 +0,0 @@
-var isSymbol = require('./isSymbol');
-
-/**
- * Casts `value` to a string if it's not a string or symbol.
- *
- * @private
- * @param {*} value The value to inspect.
- * @returns {string|symbol} Returns the cast key.
- */
-function baseCastKey(key) {
-  return (typeof key == 'string' || isSymbol(key)) ? key : (key + '');
-}
-
-module.exports = baseCastKey;

_baseClamp.js

@@ -1,5 +1,5 @@
 /**
- * The base implementation of `_.clamp` which doesn't coerce arguments to numbers.
+ * The base implementation of `_.clamp` which doesn't coerce arguments.
  *
  * @private
  * @param {number} number The number to clamp.

_baseClone.js

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

_baseConforms.js

@@ -1,32 +1,17 @@
-var keys = require('./keys');
+var baseConformsTo = require('./_baseConformsTo'),
+    keys = require('./keys');
 
 /**
  * The base implementation of `_.conforms` which doesn't clone `source`.
  *
  * @private
  * @param {Object} source The object of property predicates to conform to.
- * @returns {Function} Returns the new function.
+ * @returns {Function} Returns the new spec function.
  */
 function baseConforms(source) {
-  var props = keys(source),
+  var props = keys(source);
-      length = props.length;
-
   return function(object) {
-    if (object == null) {
+    return baseConformsTo(object, source, props);
-      return !length;
-    }
-    var index = length;
-    while (index--) {
-      var key = props[index],
-          predicate = source[key],
-          value = object[key];
-
-      if ((value === undefined &&
-          !(key in Object(object))) || !predicate(value)) {
-        return false;
-      }
-    }
-    return true;
   };
 }
 

_baseConformsTo.js

@@ -0,0 +1,27 @@
+/**
+ * The base implementation of `_.conformsTo` which accepts `props` to check.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+ */
+function baseConformsTo(object, source, props) {
+  var length = props.length;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (length--) {
+    var key = props[length],
+        predicate = source[key],
+        value = object[key];
+
+    if ((value === undefined && !(key in object)) || !predicate(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = baseConformsTo;

_baseDelay.js

@@ -2,14 +2,14 @@
 var FUNC_ERROR_TEXT = 'Expected a function';
 
 /**
- * The base implementation of `_.delay` and `_.defer` which accepts an array
+ * The base implementation of `_.delay` and `_.defer` which accepts `args`
- * of `func` arguments.
+ * to provide to `func`.
  *
  * @private
  * @param {Function} func The function to delay.
  * @param {number} wait The number of milliseconds to delay invocation.
- * @param {Object} args The arguments to provide to `func`.
+ * @param {Array} args The arguments to provide to `func`.
- * @returns {number} Returns the timer id.
+ * @returns {number|Object} Returns the timer id or timeout object.
  */
 function baseDelay(func, wait, args) {
   if (typeof func != 'function') {

_baseDifference.js

@@ -47,6 +47,7 @@ function baseDifference(array, values, iteratee, comparator) {
     var value = array[index],
         computed = iteratee ? iteratee(value) : value;
 
+    value = (comparator || value !== 0) ? value : 0;
     if (isCommon && computed === computed) {
       var valuesIndex = valuesLength;
       while (valuesIndex--) {

_baseExtremum.js

@@ -1,3 +1,5 @@
+var isSymbol = require('./isSymbol');
+
 /**
  * The base implementation of methods like `_.max` and `_.min` which accepts a
  * `comparator` to determine the extremum value.
@@ -17,7 +19,7 @@ function baseExtremum(array, iteratee, comparator) {
         current = iteratee(value);
 
     if (current != null && (computed === undefined
-          ? current === current
+          ? (current === current && !isSymbol(current))
           : comparator(current, computed)
         )) {
       var computed = current,

_baseFindIndex.js

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

_baseFindKey.js

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

_baseFlatten.js

@@ -1,7 +1,5 @@
 var arrayPush = require('./_arrayPush'),
-    isArguments = require('./isArguments'),
+    isFlattenable = require('./_isFlattenable');
-    isArray = require('./isArray'),
-    isArrayLikeObject = require('./isArrayLikeObject');
 
 /**
  * The base implementation of `_.flatten` with support for restricting flattening.
@@ -9,23 +7,24 @@ var arrayPush = require('./_arrayPush'),
  * @private
  * @param {Array} array The array to flatten.
  * @param {number} depth The maximum recursion depth.
- * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
  * @param {Array} [result=[]] The initial result value.
  * @returns {Array} Returns the new flattened array.
  */
-function baseFlatten(array, depth, isStrict, result) {
+function baseFlatten(array, depth, predicate, isStrict, result) {
-  result || (result = []);
-
   var index = -1,
       length = array.length;
 
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+
   while (++index < length) {
     var value = array[index];
-    if (depth > 0 && isArrayLikeObject(value) &&
+    if (depth > 0 && predicate(value)) {
-        (isStrict || isArray(value) || isArguments(value))) {
       if (depth > 1) {
         // Recursively flatten arrays (susceptible to call stack limits).
-        baseFlatten(value, depth - 1, isStrict, result);
+        baseFlatten(value, depth - 1, predicate, isStrict, result);
       } else {
         arrayPush(result, value);
       }

_baseFor.js

@@ -2,7 +2,7 @@ var createBaseFor = require('./_createBaseFor');
 
 /**
  * The base implementation of `baseForOwn` which iterates over `object`
- * properties returned by `keysFunc` invoking `iteratee` for each property.
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
  * Iteratee functions may exit iteration early by explicitly returning `false`.
  *
  * @private

_baseFunctions.js

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

_baseGet.js

@@ -1,5 +1,6 @@
-var baseCastPath = require('./_baseCastPath'),
+var castPath = require('./_castPath'),
-    isKey = require('./_isKey');
+    isKey = require('./_isKey'),
+    toKey = require('./_toKey');
 
 /**
  * The base implementation of `_.get` without support for default values.
@@ -10,13 +11,13 @@ var baseCastPath = require('./_baseCastPath'),
  * @returns {*} Returns the resolved value.
  */
 function baseGet(object, path) {
-  path = isKey(path, object) ? [path] : baseCastPath(path);
+  path = isKey(path, object) ? [path] : castPath(path);
 
   var index = 0,
       length = path.length;
 
   while (object != null && index < length) {
-    object = object[path[index++]];
+    object = object[toKey(path[index++])];
   }
   return (index && index == length) ? object : undefined;
 }

_baseGetAllKeys.js

@@ -14,9 +14,7 @@ var arrayPush = require('./_arrayPush'),
  */
 function baseGetAllKeys(object, keysFunc, symbolsFunc) {
   var result = keysFunc(object);
-  return isArray(object)
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
-    ? result
-    : arrayPush(result, symbolsFunc(object));
 }
 
 module.exports = baseGetAllKeys;

_baseGetTag.js

@@ -0,0 +1,22 @@
+/** 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 `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  return objectToString.call(value);
+}
+
+module.exports = baseGetTag;

_baseGt.js

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

_baseHas.js

@@ -1,5 +1,3 @@
-var getPrototype = require('./_getPrototype');
-
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 
@@ -10,16 +8,12 @@ var hasOwnProperty = objectProto.hasOwnProperty;
  * The base implementation of `_.has` without support for deep paths.
  *
  * @private
- * @param {Object} object The object to query.
+ * @param {Object} [object] The object to query.
  * @param {Array|string} key The key to check.
  * @returns {boolean} Returns `true` if `key` exists, else `false`.
  */
 function baseHas(object, key) {
-  // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`,
+  return object != null && hasOwnProperty.call(object, key);
-  // that are composed entirely of index properties, return `false` for
-  // `hasOwnProperty` checks of them.
-  return hasOwnProperty.call(object, key) ||
-    (typeof object == 'object' && key in object && getPrototype(object) === null);
 }
 
 module.exports = baseHas;

_baseHasIn.js

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

_baseInRange.js

@@ -3,7 +3,7 @@ var nativeMax = Math.max,
     nativeMin = Math.min;
 
 /**
- * The base implementation of `_.inRange` which doesn't coerce arguments to numbers.
+ * The base implementation of `_.inRange` which doesn't coerce arguments.
  *
  * @private
  * @param {number} number The number to check.

_baseIndexOf.js

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

_baseIntersection.js

@@ -47,6 +47,7 @@ function baseIntersection(arrays, iteratee, comparator) {
     var value = array[index],
         computed = iteratee ? iteratee(value) : value;
 
+    value = (comparator || value !== 0) ? value : 0;
     if (!(seen
           ? cacheHas(seen, computed)
           : includes(result, computed, comparator)

_baseInvoke.js

@@ -1,8 +1,9 @@
 var apply = require('./_apply'),
-    baseCastPath = require('./_baseCastPath'),
+    castPath = require('./_castPath'),
     isKey = require('./_isKey'),
     last = require('./last'),
-    parent = require('./_parent');
+    parent = require('./_parent'),
+    toKey = require('./_toKey');
 
 /**
  * The base implementation of `_.invoke` without support for individual
@@ -16,11 +17,11 @@ var apply = require('./_apply'),
  */
 function baseInvoke(object, path, args) {
   if (!isKey(path, object)) {
-    path = baseCastPath(path);
+    path = castPath(path);
     object = parent(object, path);
     path = last(path);
   }
-  var func = object == null ? object : object[path];
+  var func = object == null ? object : object[toKey(path)];
   return func == null ? undefined : apply(func, object, args);
 }
 

_baseIsArrayBuffer.js

@@ -0,0 +1,26 @@
+var isObjectLike = require('./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.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+ */
+function baseIsArrayBuffer(value) {
+  return isObjectLike(value) && objectToString.call(value) == arrayBufferTag;
+}
+
+module.exports = baseIsArrayBuffer;

_baseIsDate.js

@@ -0,0 +1,27 @@
+var isObjectLike = require('./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.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+ */
+function baseIsDate(value) {
+  return isObjectLike(value) && objectToString.call(value) == dateTag;
+}
+
+module.exports = baseIsDate;

_baseIsMap.js

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

_baseIsNaN.js

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

_baseIsNative.js

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

_baseIsRegExp.js

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

_baseIsSet.js

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

_baseIsTypedArray.js

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

_baseKeys.js

@@ -1,16 +1,30 @@
-/* Built-in method references for those with the same name as other `lodash` methods. */
+var isPrototype = require('./_isPrototype'),
-var nativeKeys = Object.keys;
+    nativeKeys = require('./_nativeKeys');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
 
 /**
- * The base implementation of `_.keys` which doesn't skip the constructor
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
- * property of prototypes or treat sparse arrays as dense.
  *
  * @private
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of property names.
  */
 function baseKeys(object) {
-  return nativeKeys(Object(object));
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
 }
 
 module.exports = baseKeys;

_baseKeysIn.js

@@ -1,36 +1,33 @@
-var Reflect = require('./_Reflect'),
+var isObject = require('./isObject'),
-    iteratorToArray = require('./_iteratorToArray');
+    isPrototype = require('./_isPrototype'),
+    nativeKeysIn = require('./_nativeKeysIn');
 
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 
-/** Built-in value references. */
+/** Used to check objects for own properties. */
-var enumerate = Reflect ? Reflect.enumerate : undefined,
+var hasOwnProperty = objectProto.hasOwnProperty;
-    propertyIsEnumerable = objectProto.propertyIsEnumerable;
 
 /**
- * The base implementation of `_.keysIn` which doesn't skip the constructor
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
- * property of prototypes or treat sparse arrays as dense.
  *
  * @private
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of property names.
  */
 function baseKeysIn(object) {
-  object = object == null ? object : Object(object);
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
 
-  var result = [];
   for (var key in object) {
-    result.push(key);
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
   }
   return result;
 }
 
-// Fallback for IE < 9 with es6-shim.
-if (enumerate && !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf')) {
-  baseKeysIn = function(object) {
-    return iteratorToArray(enumerate(object));
-  };
-}
-
 module.exports = baseKeysIn;

_baseLt.js

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

_baseMatches.js

@@ -1,26 +1,18 @@
 var baseIsMatch = require('./_baseIsMatch'),
-    getMatchData = require('./_getMatchData');
+    getMatchData = require('./_getMatchData'),
+    matchesStrictComparable = require('./_matchesStrictComparable');
 
 /**
  * The base implementation of `_.matches` which doesn't clone `source`.
  *
  * @private
  * @param {Object} source The object of property values to match.
- * @returns {Function} Returns the new function.
+ * @returns {Function} Returns the new spec function.
  */
 function baseMatches(source) {
   var matchData = getMatchData(source);
   if (matchData.length == 1 && matchData[0][2]) {
-    var key = matchData[0][0],
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
-        value = matchData[0][1];
-
-    return function(object) {
-      if (object == null) {
-        return false;
-      }
-      return object[key] === value &&
-        (value !== undefined || (key in Object(object)));
-    };
   }
   return function(object) {
     return object === source || baseIsMatch(object, source, matchData);

_baseMatchesProperty.js

@@ -1,6 +1,10 @@
 var baseIsEqual = require('./_baseIsEqual'),
     get = require('./get'),
-    hasIn = require('./hasIn');
+    hasIn = require('./hasIn'),
+    isKey = require('./_isKey'),
+    isStrictComparable = require('./_isStrictComparable'),
+    matchesStrictComparable = require('./_matchesStrictComparable'),
+    toKey = require('./_toKey');
 
 /** Used to compose bitmasks for comparison styles. */
 var UNORDERED_COMPARE_FLAG = 1,
@@ -12,9 +16,12 @@ var UNORDERED_COMPARE_FLAG = 1,
  * @private
  * @param {string} path The path of the property to get.
  * @param {*} srcValue The value to match.
- * @returns {Function} Returns the new function.
+ * @returns {Function} Returns the new spec function.
  */
 function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
   return function(object) {
     var objValue = get(object, path);
     return (objValue === undefined && objValue === srcValue)

_baseMerge.js

@@ -1,11 +1,11 @@
 var Stack = require('./_Stack'),
     arrayEach = require('./_arrayEach'),
     assignMergeValue = require('./_assignMergeValue'),
+    baseKeysIn = require('./_baseKeysIn'),
     baseMergeDeep = require('./_baseMergeDeep'),
     isArray = require('./isArray'),
     isObject = require('./isObject'),
-    isTypedArray = require('./isTypedArray'),
+    isTypedArray = require('./isTypedArray');
-    keysIn = require('./keysIn');
 
 /**
  * The base implementation of `_.merge` without support for multiple sources.
@@ -23,7 +23,7 @@ function baseMerge(object, source, srcIndex, customizer, stack) {
     return;
   }
   if (!(isArray(source) || isTypedArray(source))) {
-    var props = keysIn(source);
+    var props = baseKeysIn(source);
   }
   arrayEach(props || source, function(srcValue, key) {
     if (props) {

_baseMergeDeep.js

@@ -70,13 +70,12 @@ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, sta
       isCommon = false;
     }
   }
-  stack.set(srcValue, newValue);
-
   if (isCommon) {
     // Recursively merge objects and arrays (susceptible to call stack limits).
+    stack.set(srcValue, newValue);
     mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack['delete'](srcValue);
   }
-  stack['delete'](srcValue);
   assignMergeValue(object, key, newValue);
 }
 

_baseNth.js

@@ -0,0 +1,20 @@
+var isIndex = require('./_isIndex');
+
+/**
+ * The base implementation of `_.nth` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {Array} array The array to query.
+ * @param {number} n The index of the element to return.
+ * @returns {*} Returns the nth element of `array`.
+ */
+function baseNth(array, n) {
+  var length = array.length;
+  if (!length) {
+    return;
+  }
+  n += n < 0 ? length : 0;
+  return isIndex(n, length) ? array[n] : undefined;
+}
+
+module.exports = baseNth;

_baseOrderBy.js

@@ -2,6 +2,7 @@ var arrayMap = require('./_arrayMap'),
     baseIteratee = require('./_baseIteratee'),
     baseMap = require('./_baseMap'),
     baseSortBy = require('./_baseSortBy'),
+    baseUnary = require('./_baseUnary'),
     compareMultiple = require('./_compareMultiple'),
     identity = require('./identity');
 
@@ -16,7 +17,7 @@ var arrayMap = require('./_arrayMap'),
  */
 function baseOrderBy(collection, iteratees, orders) {
   var index = -1;
-  iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseIteratee);
+  iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
 
   var result = baseMap(collection, function(value, key, collection) {
     var criteria = arrayMap(iteratees, function(iteratee) {

_basePick.js

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

_basePickBy.js

@@ -1,16 +1,14 @@
-var getAllKeysIn = require('./_getAllKeysIn');
-
 /**
  * The base implementation of  `_.pickBy` without support for iteratee shorthands.
  *
  * @private
  * @param {Object} object The source object.
+ * @param {string[]} props The property identifiers to pick from.
  * @param {Function} predicate The function invoked per property.
  * @returns {Object} Returns the new object.
  */
-function basePickBy(object, predicate) {
+function basePickBy(object, props, predicate) {
   var index = -1,
-      props = getAllKeysIn(object),
       length = props.length,
       result = {};
 

_baseProperty.js

@@ -3,7 +3,7 @@
  *
  * @private
  * @param {string} key The key of the property to get.
- * @returns {Function} Returns the new function.
+ * @returns {Function} Returns the new accessor function.
  */
 function baseProperty(key) {
   return function(object) {

_basePropertyDeep.js

@@ -5,7 +5,7 @@ var baseGet = require('./_baseGet');
  *
  * @private
  * @param {Array|string} path The path of the property to get.
- * @returns {Function} Returns the new function.
+ * @returns {Function} Returns the new accessor function.
  */
 function basePropertyDeep(path) {
   return function(object) {

_basePropertyOf.js

@@ -0,0 +1,14 @@
+/**
+ * The base implementation of `_.propertyOf` without support for deep paths.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyOf(object) {
+  return function(key) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+module.exports = basePropertyOf;

_basePullAll.js

@@ -1,7 +1,8 @@
 var arrayMap = require('./_arrayMap'),
     baseIndexOf = require('./_baseIndexOf'),
     baseIndexOfWith = require('./_baseIndexOfWith'),
-    baseUnary = require('./_baseUnary');
+    baseUnary = require('./_baseUnary'),
+    copyArray = require('./_copyArray');
 
 /** Used for built-in method references. */
 var arrayProto = Array.prototype;
@@ -26,6 +27,9 @@ function basePullAll(array, values, iteratee, comparator) {
       length = values.length,
       seen = array;
 
+  if (array === values) {
+    values = copyArray(values);
+  }
   if (iteratee) {
     seen = arrayMap(array, baseUnary(iteratee));
   }

_basePullAt.js

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

_baseRange.js

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

_baseRest.js

@@ -0,0 +1,35 @@
+var apply = require('./_apply');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+  return function() {
+    var args = arguments,
+        index = -1,
+        length = nativeMax(args.length - start, 0),
+        array = Array(length);
+
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = array;
+    return apply(func, this, otherArgs);
+  };
+}
+
+module.exports = baseRest;

_baseSet.js

@@ -1,8 +1,9 @@
 var assignValue = require('./_assignValue'),
-    baseCastPath = require('./_baseCastPath'),
+    castPath = require('./_castPath'),
     isIndex = require('./_isIndex'),
     isKey = require('./_isKey'),
-    isObject = require('./isObject');
+    isObject = require('./isObject'),
+    toKey = require('./_toKey');
 
 /**
  * The base implementation of `_.set`.
@@ -15,7 +16,10 @@ var assignValue = require('./_assignValue'),
  * @returns {Object} Returns `object`.
  */
 function baseSet(object, path, value, customizer) {
-  path = isKey(path, object) ? [path] : baseCastPath(path);
+  if (!isObject(object)) {
+    return object;
+  }
+  path = isKey(path, object) ? [path] : castPath(path);
 
   var index = -1,
       length = path.length,
@@ -23,20 +27,19 @@ function baseSet(object, path, value, customizer) {
       nested = object;
 
   while (nested != null && ++index < length) {
-    var key = path[index];
+    var key = toKey(path[index]),
-    if (isObject(nested)) {
+        newValue = value;
-      var newValue = value;
+
-      if (index != lastIndex) {
+    if (index != lastIndex) {
-        var objValue = nested[key];
+      var objValue = nested[key];
-        newValue = customizer ? customizer(objValue, key, nested) : undefined;
+      newValue = customizer ? customizer(objValue, key, nested) : undefined;
-        if (newValue === undefined) {
+      if (newValue === undefined) {
-          newValue = objValue == null
+        newValue = isObject(objValue)
-            ? (isIndex(path[index + 1]) ? [] : {})
+          ? objValue
-            : objValue;
+          : (isIndex(path[index + 1]) ? [] : {});
-        }
       }
-      assignValue(nested, key, newValue);
     }
+    assignValue(nested, key, newValue);
     nested = nested[key];
   }
   return object;

_baseSortedIndex.js

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

_baseSortedIndexBy.js

@@ -1,3 +1,5 @@
+var isSymbol = require('./isSymbol');
+
 /** Used as references for the maximum length and index of an array. */
 var MAX_ARRAY_LENGTH = 4294967295,
     MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
@@ -26,21 +28,26 @@ function baseSortedIndexBy(array, value, iteratee, retHighest) {
       high = array ? array.length : 0,
       valIsNaN = value !== value,
       valIsNull = value === null,
-      valIsUndef = value === undefined;
+      valIsSymbol = isSymbol(value),
+      valIsUndefined = value === undefined;
 
   while (low < high) {
     var mid = nativeFloor((low + high) / 2),
         computed = iteratee(array[mid]),
-        isDef = computed !== undefined,
+        othIsDefined = computed !== undefined,
-        isReflexive = computed === computed;
+        othIsNull = computed === null,
+        othIsReflexive = computed === computed,
+        othIsSymbol = isSymbol(computed);
 
     if (valIsNaN) {
-      var setLow = isReflexive || retHighest;
+      var setLow = retHighest || othIsReflexive;
+    } else if (valIsUndefined) {
+      setLow = othIsReflexive && (retHighest || othIsDefined);
     } else if (valIsNull) {
-      setLow = isReflexive && isDef && (retHighest || computed != null);
+      setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
-    } else if (valIsUndef) {
+    } else if (valIsSymbol) {
-      setLow = isReflexive && (retHighest || isDef);
+      setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
-    } else if (computed == null) {
+    } else if (othIsNull || othIsSymbol) {
       setLow = false;
     } else {
       setLow = retHighest ? (computed <= value) : (computed < value);

_baseSortedUniq.js

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

_baseSortedUniqBy.js

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

_baseToNumber.js

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

_baseToPairs.js

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

_baseToString.js

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

_baseUnary.js

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

_baseUniq.js

@@ -46,6 +46,7 @@ function baseUniq(array, iteratee, comparator) {
     var value = array[index],
         computed = iteratee ? iteratee(value) : value;
 
+    value = (comparator || value !== 0) ? value : 0;
     if (isCommon && computed === computed) {
       var seenIndex = seen.length;
       while (seenIndex--) {

_baseUnset.js

@@ -1,8 +1,14 @@
-var baseCastPath = require('./_baseCastPath'),
+var castPath = require('./_castPath'),
-    has = require('./has'),
     isKey = require('./_isKey'),
     last = require('./last'),
-    parent = require('./_parent');
+    parent = require('./_parent'),
+    toKey = require('./_toKey');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
 
 /**
  * The base implementation of `_.unset`.
@@ -13,10 +19,11 @@ var baseCastPath = require('./_baseCastPath'),
  * @returns {boolean} Returns `true` if the property is deleted, else `false`.
  */
 function baseUnset(object, path) {
-  path = isKey(path, object) ? [path] : baseCastPath(path);
+  path = isKey(path, object) ? [path] : castPath(path);
   object = parent(object, path);
-  var key = last(path);
+
-  return (object != null && has(object, key)) ? delete object[key] : true;
+  var key = toKey(last(path));
+  return !(object != null && hasOwnProperty.call(object, key)) || delete object[key];
 }
 
 module.exports = baseUnset;

_cacheHas.js

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

_cachePush.js

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

_castArrayLikeObject.js

@@ -7,8 +7,8 @@ var isArrayLikeObject = require('./isArrayLikeObject');
  * @param {*} value The value to inspect.
  * @returns {Array|Object} Returns the cast array-like object.
  */
-function baseCastArrayLikeObject(value) {
+function castArrayLikeObject(value) {
   return isArrayLikeObject(value) ? value : [];
 }
 
-module.exports = baseCastArrayLikeObject;
+module.exports = castArrayLikeObject;

_castFunction.js

@@ -7,8 +7,8 @@ var identity = require('./identity');
  * @param {*} value The value to inspect.
  * @returns {Function} Returns cast function.
  */
-function baseCastFunction(value) {
+function castFunction(value) {
   return typeof value == 'function' ? value : identity;
 }
 
-module.exports = baseCastFunction;
+module.exports = castFunction;

_castPath.js

@@ -8,8 +8,8 @@ var isArray = require('./isArray'),
  * @param {*} value The value to inspect.
  * @returns {Array} Returns the cast property path array.
  */
-function baseCastPath(value) {
+function castPath(value) {
   return isArray(value) ? value : stringToPath(value);
 }
 
-module.exports = baseCastPath;
+module.exports = castPath;

_castSlice.js

@@ -0,0 +1,18 @@
+var baseSlice = require('./_baseSlice');
+
+/**
+ * Casts `array` to a slice if it's needed.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {number} start The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the cast slice.
+ */
+function castSlice(array, start, end) {
+  var length = array.length;
+  end = end === undefined ? length : end;
+  return (!start && end >= length) ? array : baseSlice(array, start, end);
+}
+
+module.exports = castSlice;

_checkGlobal.js

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

_compareAscending.js

@@ -1,3 +1,5 @@
+var isSymbol = require('./isSymbol');
+
 /**
  * Compares values to sort them in ascending order.
  *
@@ -8,22 +10,28 @@
  */
 function compareAscending(value, other) {
   if (value !== other) {
-    var valIsNull = value === null,
+    var valIsDefined = value !== undefined,
-        valIsUndef = value === undefined,
+        valIsNull = value === null,
-        valIsReflexive = value === value;
+        valIsReflexive = value === value,
+        valIsSymbol = isSymbol(value);
 
-    var othIsNull = other === null,
+    var othIsDefined = other !== undefined,
-        othIsUndef = other === undefined,
+        othIsNull = other === null,
-        othIsReflexive = other === other;
+        othIsReflexive = other === other,
+        othIsSymbol = isSymbol(other);
 
-    if ((value > other && !othIsNull) || !valIsReflexive ||
+    if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
-        (valIsNull && !othIsUndef && othIsReflexive) ||
+        (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
-        (valIsUndef && othIsReflexive)) {
+        (valIsNull && othIsDefined && othIsReflexive) ||
+        (!valIsDefined && othIsReflexive) ||
+        !valIsReflexive) {
       return 1;
     }
-    if ((value < other && !valIsNull) || !othIsReflexive ||
+    if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
-        (othIsNull && !valIsUndef && valIsReflexive) ||
+        (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
-        (othIsUndef && valIsReflexive)) {
+        (othIsNull && valIsDefined && valIsReflexive) ||
+        (!othIsDefined && valIsReflexive) ||
+        !othIsReflexive) {
       return -1;
     }
   }

_composeArgs.js

@@ -6,7 +6,7 @@ var nativeMax = Math.max;
  * placeholders, and provided arguments into a single array of arguments.
  *
  * @private
- * @param {Array|Object} args The provided arguments.
+ * @param {Array} args The provided arguments.
  * @param {Array} partials The arguments to prepend to those provided.
  * @param {Array} holders The `partials` placeholder indexes.
  * @params {boolean} [isCurried] Specify composing for a curried function.

_composeArgsRight.js

@@ -6,7 +6,7 @@ var nativeMax = Math.max;
  * is tailored for `_.partialRight`.
  *
  * @private
- * @param {Array|Object} args The provided arguments.
+ * @param {Array} args The provided arguments.
  * @param {Array} partials The arguments to append to those provided.
  * @param {Array} holders The `partials` placeholder indexes.
  * @params {boolean} [isCurried] Specify composing for a curried function.

_copyObject.js

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

_copyObjectWith.js

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

_coreJsData.js

@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+module.exports = coreJsData;