Bump to v3.8.0.

2026-01-31 07:17:50 +00:00 · 2015-05-01 08:25:59 -07:00
58 changed files with 538 additions and 405 deletions
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# lodash v3.7.0
+# lodash v3.8.0

 The [modern build](https://github.com/lodash/lodash/wiki/Build-Differences) of [lodash](https://lodash.com/) exported as [Node.js](http://nodejs.org/)/[io.js](https://iojs.org/) modules.

@@ -28,7 +28,7 @@ var array = require('lodash/array');
 var chunk = require('lodash/array/chunk');
 ```

-See the [package source](https://github.com/lodash/lodash/tree/3.7.0-npm) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/3.8.0-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>
@@ -39,8 +39,8 @@ Install [n_](https://www.npmjs.com/package/n_) for a REPL that includes lodash b
 lodash is also available in a variety of other builds & module formats.

 * npm packages for [modern](https://www.npmjs.com/package/lodash), [compatibility](https://www.npmjs.com/package/lodash-compat), & [per method](https://www.npmjs.com/browse/keyword/lodash-modularized) builds
- * AMD modules for [modern](https://github.com/lodash/lodash/tree/3.7.0-amd) & [compatibility](https://github.com/lodash/lodash-compat/tree/3.7.0-amd) builds
- * ES modules for the [modern](https://github.com/lodash/lodash/tree/3.7.0-es) build
+ * AMD modules for [modern](https://github.com/lodash/lodash/tree/3.8.0-amd) & [compatibility](https://github.com/lodash/lodash-compat/tree/3.8.0-amd) builds
+ * ES modules for the [modern](https://github.com/lodash/lodash/tree/3.8.0-es) build

 ## Further Reading

@@ -66,7 +66,6 @@ lodash is also available in a variety of other builds & module formats.
 * [_.chunk](https://lodash.com/docs#chunk) for splitting an array into chunks of a given size
 * [_.clone](https://lodash.com/docs#clone) supports shallow cloning of `Date` & `RegExp` objects
 * [_.cloneDeep](https://lodash.com/docs#cloneDeep) for deep cloning arrays & objects
- * [_.create](https://lodash.com/docs#create) for easier object inheritance
 * [_.curry](https://lodash.com/docs#curry) & [_.curryRight](https://lodash.com/docs#curryRight) for creating [curried](http://hughfdjackson.com/javascript/why-curry-helps/) functions
 * [_.debounce](https://lodash.com/docs#debounce) & [_.throttle](https://lodash.com/docs#throttle) are cancelable & accept options for more control
 * [_.fill](https://lodash.com/docs#fill) to fill arrays with values
@@ -80,6 +79,7 @@ lodash is also available in a variety of other builds & module formats.
 * [_.isNative](https://lodash.com/docs#isNative) to check for native functions
 * [_.isPlainObject](https://lodash.com/docs#isPlainObject) & [_.toPlainObject](https://lodash.com/docs#toPlainObject) to check for & convert to `Object` objects
 * [_.isTypedArray](https://lodash.com/docs#isTypedArray) to check for typed arrays
+ * [_.mapKeys](https://lodash.com/docs#mapKeys) for mapping keys to an object
 * [_.matches](https://lodash.com/docs#matches) supports deep object comparisons
 * [_.matchesProperty](https://lodash.com/docs#matchesProperty) to complement [_.matches](https://lodash.com/docs#matches) & [_.property](https://lodash.com/docs#property)
 * [_.method](https://lodash.com/docs#method) & [_.methodOf](https://lodash.com/docs#methodOf) to create functions that invoke methods
@@ -95,6 +95,7 @@ lodash is also available in a variety of other builds & module formats.
 * [_.support](https://lodash.com/docs#support) for flagging environment features
 * [_.template](https://lodash.com/docs#template) supports [*“imports”*](https://lodash.com/docs#templateSettings-imports) options & [ES template delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-template-literal-lexical-components)
 * [_.transform](https://lodash.com/docs#transform) as a powerful alternative to [_.reduce](https://lodash.com/docs#reduce) for transforming objects
+ * [_.unzipWith](https://lodash.com/docs#unzipWith) & [_.zipWith](https://lodash.com/docs#zipWith) to specify how grouped values should be combined
 * [_.xor](https://lodash.com/docs#xor) to complement [_.difference](https://lodash.com/docs#difference), [_.intersection](https://lodash.com/docs#intersection), & [_.union](https://lodash.com/docs#union)
 * [_.valuesIn](https://lodash.com/docs#valuesIn) for getting values of all enumerable properties
 * [_.bind](https://lodash.com/docs#bind), [_.curry](https://lodash.com/docs#curry), [_.partial](https://lodash.com/docs#partial), &
@@ -102,17 +103,17 @@ lodash is also available in a variety of other builds & module formats.
 * [_.capitalize](https://lodash.com/docs#capitalize), [_.trim](https://lodash.com/docs#trim), &
   [more](https://lodash.com/docs "_.camelCase, _.deburr, _.endsWith, _.escapeRegExp, _.kebabCase, _.pad, _.padLeft, _.padRight, _.repeat, _.snakeCase, _.startCase, _.startsWith, _.trimLeft, _.trimRight, _.trunc, _.words") string methods
 * [_.clone](https://lodash.com/docs#clone), [_.isEqual](https://lodash.com/docs#isEqual), &
-   [more](https://lodash.com/docs "_.assign, _.cloneDeep, _.merge") accept callbacks
+   [more](https://lodash.com/docs "_.assign, _.cloneDeep, _.merge") accept customizer callbacks
 * [_.dropWhile](https://lodash.com/docs#dropWhile), [_.takeWhile](https://lodash.com/docs#takeWhile), &
-   [more](https://lodash.com/docs "_.drop, _.dropRightWhile, _.take, _.takeRightWhile") to complement [_.first](https://lodash.com/docs#first), [_.initial](https://lodash.com/docs#initial), [_.last](https://lodash.com/docs#last), & [_.rest](https://lodash.com/docs#rest)
+   [more](https://lodash.com/docs "_.drop, _.dropRight, _.dropRightWhile, _.take, _.takeRight, _.takeRightWhile") to complement [_.first](https://lodash.com/docs#first), [_.initial](https://lodash.com/docs#initial), [_.last](https://lodash.com/docs#last), & [_.rest](https://lodash.com/docs#rest)
 * [_.findLast](https://lodash.com/docs#findLast), [_.findLastKey](https://lodash.com/docs#findLastKey), &
-   [more](https://lodash.com/docs "_.flowRight, _.forEachRight, _.forInRight, _.forOwnRight, _.partialRight") right-associative methods
+   [more](https://lodash.com/docs "_.curryRight, _.dropRight, _.dropRightWhile, _.flowRight, _.forEachRight, _.forInRight, _.forOwnRight, _.padRight, partialRight, _.takeRight, _.trimRight, _.takeRightWhile") right-associative methods
 * [_.includes](https://lodash.com/docs#includes), [_.toArray](https://lodash.com/docs#toArray), &
-   [more](https://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.findLast, _.forEach, _.forEachRight, _.groupBy, _.indexBy, _.invoke, _.map, _.max, _.min, _.partition, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.size, _.some, _.sortBy") accept strings
+   [more](https://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.findLast, _.findWhere, _.forEach, _.forEachRight, _.groupBy, _.indexBy, _.invoke, _.map, _.max, _.min, _.partition, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.size, _.some, _.sortBy, _.sortByAll, _.sortByOrder, _.sum, _.where") accept strings
 * [_#commit](https://lodash.com/docs#prototype-commit) & [_#plant](https://lodash.com/docs#prototype-plant) for working with chain sequences
 * [_#thru](https://lodash.com/docs#thru) to pass values thru a chain sequence

 ## Support

-Tested in Chrome 41-42, Firefox 36-37, IE 6-11, Opera 27-28, Safari 5-8, io.js 1.7.1, Node.js 0.8.28, 0.10.38, & 0.12.2, PhantomJS 1.9.8, RingoJS 0.11, & Rhino 1.7RC5.
+Tested in Chrome 41-42, Firefox 36-37, IE 6-11, MS Edge, Opera 27-28, Safari 5-8, io.js 1.8.1, Node.js 0.8.28, 0.10.38, & 0.12.2, PhantomJS 1.9.8, RingoJS 0.11, & Rhino 1.7RC5.
 Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available. Special thanks to [Sauce Labs](https://saucelabs.com/) for providing automated browser testing.
--- a/array.js
+++ b/array.js
@@ -35,8 +35,10 @@ module.exports = {
  'uniq': require('./array/uniq'),
  'unique': require('./array/unique'),
  'unzip': require('./array/unzip'),
+  'unzipWith': require('./array/unzipWith'),
  'without': require('./array/without'),
  'xor': require('./array/xor'),
  'zip': require('./array/zip'),
-  'zipObject': require('./array/zipObject')
+  'zipObject': require('./array/zipObject'),
+  'zipWith': require('./array/zipWith')
 };
--- a/array/difference.js
+++ b/array/difference.js
@@ -1,16 +1,12 @@
 var baseDifference = require('../internal/baseDifference'),
    baseFlatten = require('../internal/baseFlatten'),
-    isArguments = require('../lang/isArguments'),
-    isArray = require('../lang/isArray'),
+    isArrayLike = require('../internal/isArrayLike'),
    restParam = require('../function/restParam');

 /**
 * Creates an array excluding all values of the provided arrays using
- * `SameValueZero` for equality comparisons.
- *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons.
 *
 * @static
 * @memberOf _
@@ -24,7 +20,7 @@ var baseDifference = require('../internal/baseDifference'),
 * // => [1, 3]
 */
 var difference = restParam(function(array, values) {
-  return (isArray(array) || isArguments(array))
+  return isArrayLike(array)
    ? baseDifference(array, baseFlatten(values, false, true))
    : [];
 });
--- a/array/indexOf.js
+++ b/array/indexOf.js
@@ -6,13 +6,10 @@ var nativeMax = Math.max;

 /**
 * Gets the index at which the first occurrence of `value` is found in `array`
- * using `SameValueZero` for equality comparisons. If `fromIndex` is negative,
- * it is used as the offset from the end of `array`. If `array` is sorted
- * providing `true` for `fromIndex` performs a faster binary search.
- *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
+ * using [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons. If `fromIndex` is negative, it is used as the offset
+ * from the end of `array`. If `array` is sorted providing `true` for `fromIndex`
+ * performs a faster binary search.
 *
 * @static
 * @memberOf _
--- a/array/intersection.js
+++ b/array/intersection.js
@@ -1,17 +1,13 @@
 var baseIndexOf = require('../internal/baseIndexOf'),
    cacheIndexOf = require('../internal/cacheIndexOf'),
    createCache = require('../internal/createCache'),
-    isArguments = require('../lang/isArguments'),
-    isArray = require('../lang/isArray');
+    isArrayLike = require('../internal/isArrayLike');

 /**
- * Creates an array of unique values in all provided arrays using `SameValueZero`
+ * Creates an array of unique values in all provided arrays using
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
 * for equality comparisons.
 *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
- *
 * @static
 * @memberOf _
 * @category Array
@@ -32,7 +28,7 @@ function intersection() {

  while (++argsIndex < argsLength) {
    var value = arguments[argsIndex];
-    if (isArray(value) || isArguments(value)) {
+    if (isArrayLike(value)) {
      args.push(value);
      caches.push((isCommon && value.length >= 120) ? createCache(argsIndex && value) : null);
    }
--- a/array/pull.js
+++ b/array/pull.js
@@ -7,14 +7,11 @@ var arrayProto = Array.prototype;
 var splice = arrayProto.splice;

 /**
- * Removes all provided values from `array` using `SameValueZero` for equality
- * comparisons.
+ * Removes all provided values from `array` using
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons.
 *
- * **Notes:**
- *  - Unlike `_.without`, this method mutates `array`
- *  - [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- *    comparisons are like strict equality comparisons, e.g. `===`, except
- *    that `NaN` matches `NaN`
+ * **Note:** Unlike `_.without`, this method mutates `array`.
 *
 * @static
 * @memberOf _
--- a/array/pullAt.js
+++ b/array/pullAt.js
@@ -30,7 +30,6 @@ var baseAt = require('../internal/baseAt'),
 * // => [10, 20]
 */
 var pullAt = restParam(function(array, indexes) {
-  array || (array = []);
  indexes = baseFlatten(indexes);

  var result = baseAt(array, indexes);
--- a/array/union.js
+++ b/array/union.js
@@ -4,11 +4,8 @@ var baseFlatten = require('../internal/baseFlatten'),

 /**
 * Creates an array of unique values, in order, of the provided arrays using
- * `SameValueZero` for equality comparisons.
- *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons.
 *
 * @static
 * @memberOf _
--- a/array/uniq.js
+++ b/array/uniq.js
@@ -4,8 +4,9 @@ var baseCallback = require('../internal/baseCallback'),
    sortedUniq = require('../internal/sortedUniq');

 /**
- * Creates a duplicate-free version of an array, using `SameValueZero` for
- * equality comparisons, in which only the first occurence of each element
+ * Creates a duplicate-free version of an array, using
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons, in which only the first occurence of each element
 * is kept. Providing `true` for `isSorted` performs a faster search algorithm
 * for sorted arrays. If an iteratee function is provided it is invoked for
 * each element in the array to generate the criterion by which uniqueness
@@ -23,10 +24,6 @@ var baseCallback = require('../internal/baseCallback'),
 * callback returns `true` for elements that have the properties of the given
 * object, else `false`.
 *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
- *
 * @static
 * @memberOf _
 * @alias unique
--- a/array/unzip.js
+++ b/array/unzip.js
@@ -1,11 +1,14 @@
-var arrayMap = require('../internal/arrayMap'),
-    arrayMax = require('../internal/arrayMax'),
+var arrayFilter = require('../internal/arrayFilter'),
+    arrayMap = require('../internal/arrayMap'),
    baseProperty = require('../internal/baseProperty'),
-    getLength = require('../internal/getLength');
+    isArrayLike = require('../internal/isArrayLike');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;

 /**
 * This method is like `_.zip` except that it accepts an array of grouped
- * elements and creates an array regrouping the elements to their pre-`_.zip`
+ * elements and creates an array regrouping the elements to their pre-zip
 * configuration.
 *
 * @static
@@ -22,10 +25,19 @@ var arrayMap = require('../internal/arrayMap'),
 * // => [['fred', 'barney'], [30, 40], [true, false]]
 */
 function unzip(array) {
+  if (!(array && array.length)) {
+    return [];
+  }
  var index = -1,
-      length = (array && array.length && arrayMax(arrayMap(array, getLength))) >>> 0,
-      result = Array(length);
+      length = 0;

+  array = arrayFilter(array, function(group) {
+    if (isArrayLike(group)) {
+      length = nativeMax(group.length, length);
+      return true;
+    }
+  });
+  var result = Array(length);
  while (++index < length) {
    result[index] = arrayMap(array, baseProperty(index));
  }
--- a/array/unzipWith.js
+++ b/array/unzipWith.js
@@ -0,0 +1,41 @@
+var arrayMap = require('../internal/arrayMap'),
+    arrayReduce = require('../internal/arrayReduce'),
+    bindCallback = require('../internal/bindCallback'),
+    unzip = require('./unzip');
+
+/**
+ * This method is like `_.unzip` except that it accepts an iteratee to specify
+ * how regrouped values should be combined. The `iteratee` is bound to `thisArg`
+ * and invoked with four arguments: (accumulator, value, index, group).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @param {Function} [iteratee] The function to combine regrouped values.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * _.unzipWith(zipped, _.add);
+ * // => [3, 30, 300]
+ */
+function unzipWith(array, iteratee, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  var result = unzip(array);
+  if (iteratee == null) {
+    return result;
+  }
+  iteratee = bindCallback(iteratee, thisArg, 4);
+  return arrayMap(result, function(group) {
+    return arrayReduce(group, iteratee, undefined, true);
+  });
+}
+
+module.exports = unzipWith;
--- a/array/without.js
+++ b/array/without.js
@@ -1,15 +1,11 @@
 var baseDifference = require('../internal/baseDifference'),
-    isArguments = require('../lang/isArguments'),
-    isArray = require('../lang/isArray'),
+    isArrayLike = require('../internal/isArrayLike'),
    restParam = require('../function/restParam');

 /**
- * Creates an array excluding all provided values using `SameValueZero` for
- * equality comparisons.
- *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
+ * Creates an array excluding all provided values using
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons.
 *
 * @static
 * @memberOf _
@@ -23,7 +19,7 @@ var baseDifference = require('../internal/baseDifference'),
 * // => [3]
 */
 var without = restParam(function(array, values) {
-  return (isArray(array) || isArguments(array))
+  return isArrayLike(array)
    ? baseDifference(array, values)
    : [];
 });
--- a/array/xor.js
+++ b/array/xor.js
@@ -1,7 +1,6 @@
 var baseDifference = require('../internal/baseDifference'),
    baseUniq = require('../internal/baseUniq'),
-    isArguments = require('../lang/isArguments'),
-    isArray = require('../lang/isArray');
+    isArrayLike = require('../internal/isArrayLike');

 /**
 * Creates an array that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
@@ -23,7 +22,7 @@ function xor() {

  while (++index < length) {
    var array = arguments[index];
-    if (isArray(array) || isArguments(array)) {
+    if (isArrayLike(array)) {
      var result = result
        ? baseDifference(result, array).concat(baseDifference(array, result))
        : array;
--- a/array/zipWith.js
+++ b/array/zipWith.js
@@ -0,0 +1,36 @@
+var restParam = require('../function/restParam'),
+    unzipWith = require('./unzipWith');
+
+/**
+ * This method is like `_.zip` except that it accepts an iteratee to specify
+ * how grouped values should be combined. The `iteratee` is bound to `thisArg`
+ * and invoked with four arguments: (accumulator, value, index, group).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @param {Function} [iteratee] The function to combine grouped values.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zipWith([1, 2], [10, 20], [100, 200], _.add);
+ * // => [111, 222]
+ */
+var zipWith = restParam(function(arrays) {
+  var length = arrays.length,
+      iteratee = arrays[length - 2],
+      thisArg = arrays[length - 1];
+
+  if (length > 2 && typeof iteratee == 'function') {
+    length -= 2;
+  } else {
+    iteratee = (length > 1 && typeof thisArg == 'function') ? (--length, thisArg) : undefined;
+    thisArg = undefined;
+  }
+  arrays.length = length;
+  return unzipWith(arrays, iteratee, thisArg);
+});
+
+module.exports = zipWith;
--- a/collection/at.js
+++ b/collection/at.js
@@ -1,9 +1,6 @@
 var baseAt = require('../internal/baseAt'),
    baseFlatten = require('../internal/baseFlatten'),
-    getLength = require('../internal/getLength'),
-    isLength = require('../internal/isLength'),
-    restParam = require('../function/restParam'),
-    toIterable = require('../internal/toIterable');
+    restParam = require('../function/restParam');

 /**
 * Creates an array of elements corresponding to the given keys, or indexes,
@@ -26,10 +23,6 @@ var baseAt = require('../internal/baseAt'),
 * // => ['barney', 'pebbles']
 */
 var at = restParam(function(collection, props) {
-  var length = collection ? getLength(collection) : 0;
-  if (isLength(length)) {
-    collection = toIterable(collection);
-  }
  return baseAt(collection, baseFlatten(props));
 });

--- a/collection/includes.js
+++ b/collection/includes.js
@@ -10,13 +10,10 @@ var baseIndexOf = require('../internal/baseIndexOf'),
 var nativeMax = Math.max;

 /**
- * Checks if `value` is in `collection` using `SameValueZero` for equality
- * comparisons. If `fromIndex` is negative, it is used as the offset from
- * the end of `collection`.
- *
- * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * comparisons are like strict equality comparisons, e.g. `===`, except that
- * `NaN` matches `NaN`.
+ * Checks if `value` is in `collection` using
+ * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for equality comparisons. If `fromIndex` is negative, it is used as the offset
+ * from the end of `collection`.
 *
 * @static
 * @memberOf _
--- a/collection/invoke.js
+++ b/collection/invoke.js
@@ -1,8 +1,7 @@
 var baseEach = require('../internal/baseEach'),
-    getLength = require('../internal/getLength'),
    invokePath = require('../internal/invokePath'),
+    isArrayLike = require('../internal/isArrayLike'),
    isKey = require('../internal/isKey'),
-    isLength = require('../internal/isLength'),
    restParam = require('../function/restParam');

 /**
@@ -31,8 +30,7 @@ var invoke = restParam(function(collection, path, args) {
  var index = -1,
      isFunc = typeof path == 'function',
      isProp = isKey(path),
-      length = getLength(collection),
-      result = isLength(length) ? Array(length) : [];
+      result = isArrayLike(collection) ? Array(collection.length) : [];

  baseEach(collection, function(value) {
    var func = isFunc ? path : (isProp && value != null && value[path]);
--- a/collection/map.js
+++ b/collection/map.js
@@ -23,10 +23,11 @@ var arrayMap = require('../internal/arrayMap'),
 * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
 *
 * The guarded methods are:
- * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, `drop`,
- * `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`, `parseInt`,
- * `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`, `trimLeft`,
- * `trimRight`, `trunc`, `random`, `range`, `sample`, `some`, `uniq`, and `words`
+ * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,
+ * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,
+ * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,
+ * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,
+ * `sum`, `uniq`, and `words`
 *
 * @static
 * @memberOf _
--- a/collection/reduceRight.js
+++ b/collection/reduceRight.js
@@ -24,6 +24,6 @@ var arrayReduceRight = require('../internal/arrayReduceRight'),
 * }, []);
 * // => [4, 5, 2, 3, 0, 1]
 */
-var reduceRight =  createReduce(arrayReduceRight, baseEachRight);
+var reduceRight = createReduce(arrayReduceRight, baseEachRight);

 module.exports = reduceRight;
--- a/collection/reject.js
+++ b/collection/reject.js
@@ -7,17 +7,6 @@ var arrayFilter = require('../internal/arrayFilter'),
 * The opposite of `_.filter`; this method returns the elements of `collection`
 * that `predicate` does **not** return truthy for.
 *
- * If a property name is provided for `predicate` the created `_.property`
- * style callback returns the property value of the given element.
- *
- * If a value is also provided for `thisArg` the created `_.matchesProperty`
- * style callback returns `true` for elements that have a matching property
- * value, else `false`.
- *
- * If an object is provided for `predicate` the created `_.matches` style
- * callback returns `true` for elements that have the properties of the given
- * object, else `false`.
- *
 * @static
 * @memberOf _
 * @category Collection
--- a/index.js
+++ b/index.js
@@ -1,6 +1,6 @@
 /**
 * @license
- * lodash 3.7.0 (Custom Build) <https://lodash.com/>
+ * lodash 3.8.0 (Custom Build) <https://lodash.com/>
 * Build: `lodash modern -d -o ./index.js`
 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
@@ -13,7 +13,7 @@
  var undefined;

  /** Used as the semantic version number. */
-  var VERSION = '3.7.0';
+  var VERSION = '3.8.0';

  /** Used to compose bitmasks for wrapper metadata. */
  var BIND_FLAG = 1,
@@ -88,7 +88,7 @@
      reInterpolate = /<%=([\s\S]+?)%>/g;

  /** Used to match property names within property paths. */
-  var reIsDeepProp = /\.|\[(?:[^[\]]+|(["'])(?:(?!\1)[^\n\\]|\\.)*?)\1\]/,
+  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;

@@ -280,8 +280,6 @@
   */
  var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;

-  /*--------------------------------------------------------------------------*/
-
  /**
   * The base implementation of `compareAscending` which compares values and
   * sorts them in ascending order without guaranteeing a stable sort.
@@ -652,8 +650,6 @@
    return htmlUnescapes[chr];
  }

-  /*--------------------------------------------------------------------------*/
-
  /**
   * Create a new pristine `lodash` function using the given `context` object.
   *
@@ -749,7 +745,7 @@
        getOwnPropertySymbols = isNative(getOwnPropertySymbols = Object.getOwnPropertySymbols) && getOwnPropertySymbols,
        getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
        push = arrayProto.push,
-        preventExtensions = isNative(Object.preventExtensions = Object.preventExtensions) && preventExtensions,
+        preventExtensions = isNative(preventExtensions = Object.preventExtensions) && preventExtensions,
        propertyIsEnumerable = objectProto.propertyIsEnumerable,
        Set = isNative(Set = context.Set) && Set,
        setTimeout = context.setTimeout,
@@ -777,12 +773,19 @@
      //
      // Use `Object.preventExtensions` on a plain object instead of simply using
      // `Object('x')` because Chrome and IE fail to throw an error when attempting
-      // to assign values to readonly indexes of strings in strict mode.
-      var object = { '1': 0 },
-          func = preventExtensions && isNative(func = Object.assign) && func;
-
-      try { func(preventExtensions(object), 'xo'); } catch(e) {}
-      return !object[1] && func;
+      // to assign values to readonly indexes of strings.
+      var func = preventExtensions && isNative(func = Object.assign) && func;
+      try {
+        if (func) {
+          var object = preventExtensions({ '1': 0 });
+          object[0] = 1;
+        }
+      } catch(e) {
+        // Only attempt in strict mode.
+        try { func(object, 'xo'); } catch(e) {}
+        return !object[1] && func;
+      }
+      return false;
    }());

    /* Native method references for those with the same name as other `lodash` methods. */
@@ -803,7 +806,7 @@

    /** Used as references for the maximum length and index of an array. */
    var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1,
-        MAX_ARRAY_INDEX =  MAX_ARRAY_LENGTH - 1,
+        MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
        HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

    /** Used as the size, in bytes, of each `Float64Array` element. */
@@ -821,8 +824,6 @@
    /** Used to lookup unminified function names. */
    var realNames = {};

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates a `lodash` object which wraps `value` to enable implicit chaining.
     * Methods that operate on and return arrays, collections, and functions can
@@ -962,6 +963,7 @@

    (function(x) {
      var Ctor = function() { this.x = x; },
+          args = arguments,
          object = { '0': x, 'length': x },
          props = [];

@@ -1011,7 +1013,7 @@
       * @type boolean
       */
      try {
-        support.nonEnumArgs = !propertyIsEnumerable.call(arguments, 1);
+        support.nonEnumArgs = !propertyIsEnumerable.call(args, 1);
      } catch(e) {
        support.nonEnumArgs = true;
      }
@@ -1078,8 +1080,6 @@
      }
    };

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
     *
@@ -1208,8 +1208,6 @@
      return result;
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates a cache object to store key/value pairs.
     *
@@ -1278,8 +1276,6 @@
      return this;
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     *
     * Creates a cache object to store unique values.
@@ -1329,8 +1325,6 @@
      }
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Copies the values of `source` to `array`.
     *
@@ -1674,8 +1668,9 @@
     */
    function baseAt(collection, props) {
      var index = -1,
-          length = collection.length,
-          isArr = isLength(length),
+          isNil = collection == null,
+          isArr = !isNil && isArrayLike(collection),
+          length = isArr && collection.length,
          propsLength = props.length,
          result = Array(propsLength);

@@ -1684,7 +1679,7 @@
        if (isArr) {
          result[index] = isIndex(key, length) ? collection[key] : undefined;
        } else {
-          result[index] = collection[key];
+          result[index] = isNil ? undefined : collection[key];
        }
      }
      return result;
@@ -2011,8 +2006,8 @@
     *
     * @private
     * @param {Array} array The array to flatten.
-     * @param {boolean} isDeep Specify a deep flatten.
-     * @param {boolean} isStrict Restrict flattening to arrays and `arguments` objects.
+     * @param {boolean} [isDeep] Specify a deep flatten.
+     * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
     * @returns {Array} Returns the new flattened array.
     */
    function baseFlatten(array, isDeep, isStrict) {
@@ -2023,8 +2018,8 @@

      while (++index < length) {
        var value = array[index];
-
-        if (isObjectLike(value) && isLength(value.length) && (isArray(value) || isArguments(value))) {
+        if (isObjectLike(value) && isArrayLike(value) &&
+            (isStrict || isArray(value) || isArguments(value))) {
          if (isDeep) {
            // Recursively flatten arrays (susceptible to call stack limits).
            value = baseFlatten(value, isDeep, isStrict);
@@ -2032,7 +2027,6 @@
          var valIndex = -1,
              valLength = value.length;

-          result.length += valLength;
          while (++valIndex < valLength) {
            result[++resIndex] = value[valIndex];
          }
@@ -2153,9 +2147,9 @@
          length = path.length;

      while (object != null && ++index < length) {
-        var result = object = object[path[index]];
+        object = object[path[index]];
      }
-      return result;
+      return (index && index == length) ? object : undefined;
    }

    /**
@@ -2174,8 +2168,7 @@
    function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
      // Exit early for identical values.
      if (value === other) {
-        // Treat `+0` vs. `-0` as not equal.
-        return value !== 0 || (1 / value == 1 / other);
+        return true;
      }
      var valType = typeof value,
          othType = typeof other;
@@ -2324,8 +2317,7 @@
     */
    function baseMap(collection, iteratee) {
      var index = -1,
-          length = getLength(collection),
-          result = isLength(length) ? Array(length) : [];
+          result = isArrayLike(collection) ? Array(collection.length) : [];

      baseEach(collection, function(value, key, collection) {
        result[++index] = iteratee(value, key, collection);
@@ -2424,7 +2416,7 @@
      if (!isObject(object)) {
        return object;
      }
-      var isSrcArr = isLength(source.length) && (isArray(source) || isTypedArray(source));
+      var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source));
      if (!isSrcArr) {
        var props = keys(source);
        push.apply(props, getSymbols(source));
@@ -2487,10 +2479,10 @@

      if (isCommon) {
        result = srcValue;
-        if (isLength(srcValue.length) && (isArray(srcValue) || isTypedArray(srcValue))) {
+        if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {
          result = isArray(value)
            ? value
-            : (getLength(value) ? arrayCopy(value) : []);
+            : (isArrayLike(value) ? arrayCopy(value) : []);
        }
        else if (isPlainObject(srcValue) || isArguments(srcValue)) {
          result = isArguments(value)
@@ -2552,7 +2544,7 @@
     * @returns {Array} Returns `array`.
     */
    function basePullAt(array, indexes) {
-      var length = indexes.length;
+      var length = array ? indexes.length : 0;
      while (length--) {
        var index = parseFloat(indexes[length]);
        if (index != previous && isIndex(index)) {
@@ -3038,12 +3030,12 @@
      while (++argsIndex < argsLength) {
        result[argsIndex] = args[argsIndex];
      }
-      var pad = argsIndex;
+      var offset = argsIndex;
      while (++rightIndex < rightLength) {
-        result[pad + rightIndex] = partials[rightIndex];
+        result[offset + rightIndex] = partials[rightIndex];
      }
      while (++holdersIndex < holdersLength) {
-        result[pad + holders[holdersIndex]] = args[argsIndex++];
+        result[offset + holders[holdersIndex]] = args[argsIndex++];
      }
      return result;
    }
@@ -3311,7 +3303,7 @@
          return index > -1 ? collection[index] : undefined;
        }
        return baseFind(collection, predicate, eachFunc);
-      }
+      };
    }

    /**
@@ -3377,7 +3369,7 @@
          funcName = getFuncName(func);

          var data = funcName == 'wrapper' ? getData(func) : null;
-          if (data && isLaziable(data[0])) {
+          if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {
            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
          } else {
            wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);
@@ -3447,6 +3439,28 @@
      };
    }

+    /**
+     * Creates a function for `_.mapKeys` or `_.mapValues`.
+     *
+     * @private
+     * @param {boolean} [isMapKeys] Specify mapping keys instead of values.
+     * @returns {Function} Returns the new map function.
+     */
+    function createObjectMapper(isMapKeys) {
+      return function(object, iteratee, thisArg) {
+        var result = {};
+        iteratee = getCallback(iteratee, thisArg, 3);
+
+        baseForOwn(object, function(value, key, object) {
+          var mapped = iteratee(value, key, object);
+          key = isMapKeys ? mapped : key;
+          value = isMapKeys ? value : mapped;
+          result[key] = value;
+        });
+        return result;
+      };
+    }
+
    /**
     * Creates a function for `_.padLeft` or `_.padRight`.
     *
@@ -3457,7 +3471,7 @@
    function createPadDir(fromRight) {
      return function(string, length, chars) {
        string = baseToString(string);
-        return string && ((fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string));
+        return (fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string);
      };
    }

@@ -3803,8 +3817,7 @@
          // Treat `NaN` vs. `NaN` as equal.
          return (object != +object)
            ? other != +other
-            // But, treat `-0` vs. `+0` as not equal.
-            : (object == 0 ? ((1 / object) == (1 / other)) : object == +other);
+            : object == +other;

        case regexpTag:
        case stringTag:
@@ -3984,7 +3997,7 @@
     * Gets the "length" property value of `object`.
     *
     * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
-     * in Safari on iOS 8.1 ARM64.
+     * that affects Safari on at least iOS 8.1-8.3 ARM64.
     *
     * @private
     * @param {Object} object The object to query.
@@ -4123,6 +4136,17 @@
      return func == null ? undefined : func.apply(object, args);
    }

+    /**
+     * Checks if `value` is array-like.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+     */
+    function isArrayLike(value) {
+      return value != null && isLength(getLength(value));
+    }
+
    /**
     * Checks if `value` is a valid array-like index.
     *
@@ -4151,13 +4175,9 @@
        return false;
      }
      var type = typeof index;
-      if (type == 'number') {
-        var length = getLength(object),
-            prereq = isLength(length) && isIndex(index, length);
-      } else {
-        prereq = type == 'string' && index in object;
-      }
-      if (prereq) {
+      if (type == 'number'
+          ? (isArrayLike(object) && isIndex(index, object.length))
+          : (type == 'string' && index in object)) {
        var other = object[index];
        return value === value ? (value === other) : (other !== other);
      }
@@ -4218,7 +4238,7 @@
     *  equality comparisons, else `false`.
     */
    function isStrictComparable(value) {
-      return value === value && (value === 0 ? ((1 / value) > 0) : !isObject(value));
+      return value === value && !isObject(value);
    }

    /**
@@ -4292,7 +4312,7 @@
    }

    /**
-     * A specialized version of `_.pick` that picks `object` properties specified
+     * A specialized version of `_.pick` which picks `object` properties specified
     * by `props`.
     *
     * @private
@@ -4317,7 +4337,7 @@
    }

    /**
-     * A specialized version of `_.pick` that picks `object` properties `predicate`
+     * A specialized version of `_.pick` which picks `object` properties `predicate`
     * returns truthy for.
     *
     * @private
@@ -4462,7 +4482,7 @@
      if (value == null) {
        return [];
      }
-      if (!isLength(getLength(value))) {
+      if (!isArrayLike(value)) {
        return values(value);
      }
      return isObject(value) ? value : Object(value);
@@ -4510,8 +4530,6 @@
        : new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__, arrayCopy(wrapper.__actions__));
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates an array of elements split into groups the length of `size`.
     * If `collection` can't be split evenly, the final chunk will be the remaining
@@ -4580,11 +4598,8 @@

    /**
     * Creates an array excluding all values of the provided arrays using
-     * `SameValueZero` for equality comparisons.
-     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons.
     *
     * @static
     * @memberOf _
@@ -4598,7 +4613,7 @@
     * // => [1, 3]
     */
    var difference = restParam(function(array, values) {
-      return (isArray(array) || isArguments(array))
+      return isArrayLike(array)
        ? baseDifference(array, baseFlatten(values, false, true))
        : [];
    });
@@ -4993,13 +5008,10 @@

    /**
     * Gets the index at which the first occurrence of `value` is found in `array`
-     * using `SameValueZero` for equality comparisons. If `fromIndex` is negative,
-     * it is used as the offset from the end of `array`. If `array` is sorted
-     * providing `true` for `fromIndex` performs a faster binary search.
-     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
+     * using [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons. If `fromIndex` is negative, it is used as the offset
+     * from the end of `array`. If `array` is sorted providing `true` for `fromIndex`
+     * performs a faster binary search.
     *
     * @static
     * @memberOf _
@@ -5059,13 +5071,10 @@
    }

    /**
-     * Creates an array of unique values in all provided arrays using `SameValueZero`
+     * Creates an array of unique values in all provided arrays using
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
     * for equality comparisons.
     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
-     *
     * @static
     * @memberOf _
     * @category Array
@@ -5086,7 +5095,7 @@

      while (++argsIndex < argsLength) {
        var value = arguments[argsIndex];
-        if (isArray(value) || isArguments(value)) {
+        if (isArrayLike(value)) {
          args.push(value);
          caches.push((isCommon && value.length >= 120) ? createCache(argsIndex && value) : null);
        }
@@ -5191,14 +5200,11 @@
    }

    /**
-     * Removes all provided values from `array` using `SameValueZero` for equality
-     * comparisons.
+     * Removes all provided values from `array` using
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons.
     *
-     * **Notes:**
-     *  - Unlike `_.without`, this method mutates `array`
-     *  - [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     *    comparisons are like strict equality comparisons, e.g. `===`, except
-     *    that `NaN` matches `NaN`
+     * **Note:** Unlike `_.without`, this method mutates `array`.
     *
     * @static
     * @memberOf _
@@ -5262,7 +5268,6 @@
     * // => [10, 20]
     */
    var pullAt = restParam(function(array, indexes) {
-      array || (array = []);
      indexes = baseFlatten(indexes);

      var result = baseAt(array, indexes);
@@ -5629,11 +5634,8 @@

    /**
     * Creates an array of unique values, in order, of the provided arrays using
-     * `SameValueZero` for equality comparisons.
-     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons.
     *
     * @static
     * @memberOf _
@@ -5650,8 +5652,9 @@
    });

    /**
-     * Creates a duplicate-free version of an array, using `SameValueZero` for
-     * equality comparisons, in which only the first occurence of each element
+     * Creates a duplicate-free version of an array, using
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons, in which only the first occurence of each element
     * is kept. Providing `true` for `isSorted` performs a faster search algorithm
     * for sorted arrays. If an iteratee function is provided it is invoked for
     * each element in the array to generate the criterion by which uniqueness
@@ -5669,10 +5672,6 @@
     * callback returns `true` for elements that have the properties of the given
     * object, else `false`.
     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
-     *
     * @static
     * @memberOf _
     * @alias unique
@@ -5722,7 +5721,7 @@

    /**
     * This method is like `_.zip` except that it accepts an array of grouped
-     * elements and creates an array regrouping the elements to their pre-`_.zip`
+     * elements and creates an array regrouping the elements to their pre-zip
     * configuration.
     *
     * @static
@@ -5739,10 +5738,19 @@
     * // => [['fred', 'barney'], [30, 40], [true, false]]
     */
    function unzip(array) {
+      if (!(array && array.length)) {
+        return [];
+      }
      var index = -1,
-          length = (array && array.length && arrayMax(arrayMap(array, getLength))) >>> 0,
-          result = Array(length);
+          length = 0;

+      array = arrayFilter(array, function(group) {
+        if (isArrayLike(group)) {
+          length = nativeMax(group.length, length);
+          return true;
+        }
+      });
+      var result = Array(length);
      while (++index < length) {
        result[index] = arrayMap(array, baseProperty(index));
      }
@@ -5750,12 +5758,44 @@
    }

    /**
-     * Creates an array excluding all provided values using `SameValueZero` for
-     * equality comparisons.
+     * This method is like `_.unzip` except that it accepts an iteratee to specify
+     * how regrouped values should be combined. The `iteratee` is bound to `thisArg`
+     * and invoked with four arguments: (accumulator, value, index, group).
     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
+     * @static
+     * @memberOf _
+     * @category Array
+     * @param {Array} array The array of grouped elements to process.
+     * @param {Function} [iteratee] The function to combine regrouped values.
+     * @param {*} [thisArg] The `this` binding of `iteratee`.
+     * @returns {Array} Returns the new array of regrouped elements.
+     * @example
+     *
+     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
+     * // => [[1, 10, 100], [2, 20, 200]]
+     *
+     * _.unzipWith(zipped, _.add);
+     * // => [3, 30, 300]
+     */
+    function unzipWith(array, iteratee, thisArg) {
+      var length = array ? array.length : 0;
+      if (!length) {
+        return [];
+      }
+      var result = unzip(array);
+      if (iteratee == null) {
+        return result;
+      }
+      iteratee = bindCallback(iteratee, thisArg, 4);
+      return arrayMap(result, function(group) {
+        return arrayReduce(group, iteratee, undefined, true);
+      });
+    }
+
+    /**
+     * Creates an array excluding all provided values using
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons.
     *
     * @static
     * @memberOf _
@@ -5769,7 +5809,7 @@
     * // => [3]
     */
    var without = restParam(function(array, values) {
-      return (isArray(array) || isArguments(array))
+      return isArrayLike(array)
        ? baseDifference(array, values)
        : [];
    });
@@ -5794,7 +5834,7 @@

      while (++index < length) {
        var array = arguments[index];
-        if (isArray(array) || isArguments(array)) {
+        if (isArrayLike(array)) {
          var result = result
            ? baseDifference(result, array).concat(baseDifference(array, result))
            : array;
@@ -5860,7 +5900,37 @@
      return result;
    }

-    /*------------------------------------------------------------------------*/
+    /**
+     * This method is like `_.zip` except that it accepts an iteratee to specify
+     * how grouped values should be combined. The `iteratee` is bound to `thisArg`
+     * and invoked with four arguments: (accumulator, value, index, group).
+     *
+     * @static
+     * @memberOf _
+     * @category Array
+     * @param {...Array} [arrays] The arrays to process.
+     * @param {Function} [iteratee] The function to combine grouped values.
+     * @param {*} [thisArg] The `this` binding of `iteratee`.
+     * @returns {Array} Returns the new array of grouped elements.
+     * @example
+     *
+     * _.zipWith([1, 2], [10, 20], [100, 200], _.add);
+     * // => [111, 222]
+     */
+    var zipWith = restParam(function(arrays) {
+      var length = arrays.length,
+          iteratee = arrays[length - 2],
+          thisArg = arrays[length - 1];
+
+      if (length > 2 && typeof iteratee == 'function') {
+        length -= 2;
+      } else {
+        iteratee = (length > 1 && typeof thisArg == 'function') ? (--length, thisArg) : undefined;
+        thisArg = undefined;
+      }
+      arrays.length = length;
+      return unzipWith(arrays, iteratee, thisArg);
+    });

    /**
     * Creates a `lodash` object that wraps `value` with explicit method
@@ -6112,8 +6182,6 @@
      return baseWrapperValue(this.__wrapped__, this.__actions__);
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates an array of elements corresponding to the given keys, or indexes,
     * of `collection`. Keys may be specified as individual arguments or as arrays
@@ -6135,10 +6203,6 @@
     * // => ['barney', 'pebbles']
     */
    var at = restParam(function(collection, props) {
-      var length = collection ? getLength(collection) : 0;
-      if (isLength(length)) {
-        collection = toIterable(collection);
-      }
      return baseAt(collection, baseFlatten(props));
    });

@@ -6511,13 +6575,10 @@
    });

    /**
-     * Checks if `value` is in `collection` using `SameValueZero` for equality
-     * comparisons. If `fromIndex` is negative, it is used as the offset from
-     * the end of `collection`.
-     *
-     * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
-     * comparisons are like strict equality comparisons, e.g. `===`, except that
-     * `NaN` matches `NaN`.
+     * Checks if `value` is in `collection` using
+     * [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+     * for equality comparisons. If `fromIndex` is negative, it is used as the offset
+     * from the end of `collection`.
     *
     * @static
     * @memberOf _
@@ -6637,8 +6698,7 @@
      var index = -1,
          isFunc = typeof path == 'function',
          isProp = isKey(path),
-          length = getLength(collection),
-          result = isLength(length) ? Array(length) : [];
+          result = isArrayLike(collection) ? Array(collection.length) : [];

      baseEach(collection, function(value) {
        var func = isFunc ? path : (isProp && value != null && value[path]);
@@ -6667,10 +6727,11 @@
     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
     *
     * The guarded methods are:
-     * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, `drop`,
-     * `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`, `parseInt`,
-     * `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`, `trimLeft`,
-     * `trimRight`, `trunc`, `random`, `range`, `sample`, `some`, `uniq`, and `words`
+     * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,
+     * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,
+     * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,
+     * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,
+     * `sum`, `uniq`, and `words`
     *
     * @static
     * @memberOf _
@@ -6858,23 +6919,12 @@
     * }, []);
     * // => [4, 5, 2, 3, 0, 1]
     */
-    var reduceRight =  createReduce(arrayReduceRight, baseEachRight);
+    var reduceRight = createReduce(arrayReduceRight, baseEachRight);

    /**
     * The opposite of `_.filter`; this method returns the elements of `collection`
     * that `predicate` does **not** return truthy for.
     *
-     * If a property name is provided for `predicate` the created `_.property`
-     * style callback returns the property value of the given element.
-     *
-     * If a value is also provided for `thisArg` the created `_.matchesProperty`
-     * style callback returns `true` for elements that have a matching property
-     * value, else `false`.
-     *
-     * If an object is provided for `predicate` the created `_.matches` style
-     * callback returns `true` for elements that have the properties of the given
-     * object, else `false`.
-     *
     * @static
     * @memberOf _
     * @category Collection
@@ -7253,8 +7303,6 @@
      return filter(collection, baseMatches(source));
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Gets the number of milliseconds that have elapsed since the Unix epoch
     * (1 January 1970 00:00:00 UTC).
@@ -7273,8 +7321,6 @@
      return new Date().getTime();
    };

-    /*------------------------------------------------------------------------*/
-
    /**
     * The opposite of `_.before`; this method creates a function that invokes
     * `func` once it is called `n` or more times.
@@ -8254,8 +8300,6 @@
      return createWrapper(wrapper, PARTIAL_FLAG, null, [value], []);
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,
     * otherwise they are assigned by reference. If `customizer` is provided it is
@@ -8387,8 +8431,7 @@
     * // => false
     */
    function isArguments(value) {
-      var length = isObjectLike(value) ? value.length : undefined;
-      return isLength(length) && objToString.call(value) == argsTag;
+      return isObjectLike(value) && isArrayLike(value) && objToString.call(value) == argsTag;
    }

    /**
@@ -8509,10 +8552,9 @@
      if (value == null) {
        return true;
      }
-      var length = getLength(value);
-      if (isLength(length) && (isArray(value) || isString(value) || isArguments(value) ||
+      if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) ||
          (isObjectLike(value) && isFunction(value.splice)))) {
-        return !length;
+        return !value.length;
      }
      return !keys(value).length;
    }
@@ -8902,7 +8944,7 @@
     * // => false
     */
    function isRegExp(value) {
-      return (isObjectLike(value) && objToString.call(value) == regexpTag) || false;
+      return isObjectLike(value) && objToString.call(value) == regexpTag;
    }

    /**
@@ -9018,8 +9060,6 @@
      return baseCopy(value, keysIn(value));
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Assigns own enumerable properties of source object(s) to the destination
     * object. Subsequent sources overwrite property assignments of previous sources.
@@ -9030,7 +9070,6 @@
     * **Note:** This method mutates `object` and is based on
     * [`Object.assign`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign).
     *
-     *
     * @static
     * @memberOf _
     * @alias extend
@@ -9502,12 +9541,9 @@
     * // => ['0', '1']
     */
    var keys = !nativeKeys ? shimKeys : function(object) {
-      if (object) {
-        var Ctor = object.constructor,
-            length = object.length;
-      }
+      var Ctor = object != null && object.constructor;
      if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
-          (typeof object != 'function' && isLength(length))) {
+          (typeof object != 'function' && isArrayLike(object))) {
        return shimKeys(object);
      }
      return isObject(object) ? nativeKeys(object) : [];
@@ -9564,6 +9600,28 @@
      return result;
    }

+    /**
+     * The opposite of `_.mapValues`; this method creates an object with the
+     * same values as `object` and keys generated by running each own enumerable
+     * property of `object` through `iteratee`.
+     *
+     * @static
+     * @memberOf _
+     * @category Object
+     * @param {Object} object The object to iterate over.
+     * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+     *  per iteration.
+     * @param {*} [thisArg] The `this` binding of `iteratee`.
+     * @returns {Object} Returns the new mapped object.
+     * @example
+     *
+     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
+     *   return key + value;
+     * });
+     * // => { 'a1': 1, 'b2': 2 }
+     */
+    var mapKeys = createObjectMapper(true);
+
    /**
     * Creates an object with the same keys as `object` and values generated by
     * running each own enumerable property of `object` through `iteratee`. The
@@ -9605,15 +9663,7 @@
     * _.mapValues(users, 'age');
     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
     */
-    function mapValues(object, iteratee, thisArg) {
-      var result = {};
-      iteratee = getCallback(iteratee, thisArg, 3);
-
-      baseForOwn(object, function(value, key, object) {
-        result[key] = iteratee(value, key, object);
-      });
-      return result;
-    }
+    var mapValues = createObjectMapper();

    /**
     * Recursively merges own enumerable properties of the source object(s), that
@@ -9668,11 +9718,6 @@
    /**
     * The opposite of `_.pick`; this method creates an object composed of the
     * own and inherited enumerable properties of `object` that are not omitted.
-     * Property names may be specified as individual arguments or as arrays of
-     * property names. If `predicate` is provided it is invoked for each property
-     * of `object` omitting the properties `predicate` returns truthy for. The
-     * predicate is bound to `thisArg` and invoked with three arguments:
-     * (value, key, object).
     *
     * @static
     * @memberOf _
@@ -9966,8 +10011,6 @@
      return baseValues(object, keysIn(object));
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Checks if `n` is between `start` and up to but not including, `end`. If
     * `end` is not specified it is set to `start` with `start` then set to `0`.
@@ -10072,8 +10115,6 @@
      return baseRandom(min, max);
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
     *
@@ -10939,8 +10980,6 @@
      return string.match(pattern || reWords) || [];
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Attempts to invoke `func`, returning either the result or the caught error
     * object. Any additional arguments are provided to `func` when it is invoked.
@@ -11011,7 +11050,9 @@
      if (guard && isIterateeCall(func, thisArg, guard)) {
        thisArg = null;
      }
-      return baseCallback(func, thisArg);
+      return isObjectLike(func)
+        ? matches(func)
+        : baseCallback(func, thisArg);
    }

    /**
@@ -11136,7 +11177,7 @@
    var method = restParam(function(path, args) {
      return function(object) {
        return invokePath(object, path, args);
-      }
+      };
    });

    /**
@@ -11473,8 +11514,6 @@
      return baseToString(prefix) + id;
    }

-    /*------------------------------------------------------------------------*/
-
    /**
     * Adds two numbers.
     *
@@ -11639,8 +11678,6 @@
        : baseSum(collection, iteratee);
    }

-    /*------------------------------------------------------------------------*/
-
    // Ensure wrappers are instances of `baseLodash`.
    lodash.prototype = baseLodash.prototype;

@@ -11711,6 +11748,7 @@
    lodash.keys = keys;
    lodash.keysIn = keysIn;
    lodash.map = map;
+    lodash.mapKeys = mapKeys;
    lodash.mapValues = mapValues;
    lodash.matches = matches;
    lodash.matchesProperty = matchesProperty;
@@ -11759,6 +11797,7 @@
    lodash.union = union;
    lodash.uniq = uniq;
    lodash.unzip = unzip;
+    lodash.unzipWith = unzipWith;
    lodash.values = values;
    lodash.valuesIn = valuesIn;
    lodash.where = where;
@@ -11767,6 +11806,7 @@
    lodash.xor = xor;
    lodash.zip = zip;
    lodash.zipObject = zipObject;
+    lodash.zipWith = zipWith;

    // Add aliases.
    lodash.backflow = flowRight;
@@ -11785,8 +11825,6 @@
    // Add functions to `lodash.prototype`.
    mixin(lodash, lodash);

-    /*------------------------------------------------------------------------*/
-
    // Add functions that return unwrapped values when chaining.
    lodash.add = add;
    lodash.attempt = attempt;
@@ -11890,8 +11928,6 @@
      return source;
    }()), false);

-    /*------------------------------------------------------------------------*/
-
    // Add functions capable of returning wrapped and unwrapped values when chaining.
    lodash.sample = sample;

@@ -11904,8 +11940,6 @@
      });
    };

-    /*------------------------------------------------------------------------*/
-
    /**
     * The semantic version number.
     *
@@ -12016,8 +12050,13 @@

    LazyWrapper.prototype.slice = function(start, end) {
      start = start == null ? 0 : (+start || 0);
-      var result = start < 0 ? this.takeRight(-start) : this.drop(start);

+      var result = this;
+      if (start < 0) {
+        result = this.takeRight(-start);
+      } else if (start) {
+        result = this.drop(start);
+      }
      if (end !== undefined) {
        end = (+end || 0);
        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
@@ -12040,7 +12079,6 @@

      lodash.prototype[methodName] = function() {
        var args = arguments,
-            length = args.length,
            chainAll = this.__chain__,
            value = this.__wrapped__,
            isHybrid = !!this.__actions__.length,
@@ -12129,8 +12167,6 @@
    return lodash;
  }

-  /*--------------------------------------------------------------------------*/
-
  // Export lodash.
  var _ = runInContext();

--- a/internal/baseAssign.js
+++ b/internal/baseAssign.js
@@ -4,7 +4,7 @@ var baseCopy = require('./baseCopy'),
    keys = require('../object/keys');

 /** Native method references. */
-var preventExtensions = isNative(Object.preventExtensions = Object.preventExtensions) && preventExtensions;
+var preventExtensions = isNative(preventExtensions = Object.preventExtensions) && preventExtensions;

 /** Used as `baseAssign`. */
 var nativeAssign = (function() {
@@ -14,12 +14,19 @@ var nativeAssign = (function() {
  //
  // Use `Object.preventExtensions` on a plain object instead of simply using
  // `Object('x')` because Chrome and IE fail to throw an error when attempting
-  // to assign values to readonly indexes of strings in strict mode.
-  var object = { '1': 0 },
-      func = preventExtensions && isNative(func = Object.assign) && func;
-
-  try { func(preventExtensions(object), 'xo'); } catch(e) {}
-  return !object[1] && func;
+  // to assign values to readonly indexes of strings.
+  var func = preventExtensions && isNative(func = Object.assign) && func;
+  try {
+    if (func) {
+      var object = preventExtensions({ '1': 0 });
+      object[0] = 1;
+    }
+  } catch(e) {
+    // Only attempt in strict mode.
+    try { func(object, 'xo'); } catch(e) {}
+    return !object[1] && func;
+  }
+  return false;
 }());

 /**
--- a/internal/baseAt.js
+++ b/internal/baseAt.js
@@ -1,5 +1,5 @@
-var isIndex = require('./isIndex'),
-    isLength = require('./isLength');
+var isArrayLike = require('./isArrayLike'),
+    isIndex = require('./isIndex');

 /**
 * The base implementation of `_.at` without support for string collections
@@ -12,8 +12,9 @@ var isIndex = require('./isIndex'),
 */
 function baseAt(collection, props) {
  var index = -1,
-      length = collection.length,
-      isArr = isLength(length),
+      isNil = collection == null,
+      isArr = !isNil && isArrayLike(collection),
+      length = isArr && collection.length,
      propsLength = props.length,
      result = Array(propsLength);

@@ -22,7 +23,7 @@ function baseAt(collection, props) {
    if (isArr) {
      result[index] = isIndex(key, length) ? collection[key] : undefined;
    } else {
-      result[index] = collection[key];
+      result[index] = isNil ? undefined : collection[key];
    }
  }
  return result;
--- a/internal/baseFlatten.js
+++ b/internal/baseFlatten.js
@@ -1,6 +1,6 @@
 var isArguments = require('../lang/isArguments'),
    isArray = require('../lang/isArray'),
-    isLength = require('./isLength'),
+    isArrayLike = require('./isArrayLike'),
    isObjectLike = require('./isObjectLike');

 /**
@@ -9,8 +9,8 @@ var isArguments = require('../lang/isArguments'),
 *
 * @private
 * @param {Array} array The array to flatten.
- * @param {boolean} isDeep Specify a deep flatten.
- * @param {boolean} isStrict Restrict flattening to arrays and `arguments` objects.
+ * @param {boolean} [isDeep] Specify a deep flatten.
+ * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
 * @returns {Array} Returns the new flattened array.
 */
 function baseFlatten(array, isDeep, isStrict) {
@@ -21,8 +21,8 @@ function baseFlatten(array, isDeep, isStrict) {

  while (++index < length) {
    var value = array[index];
-
-    if (isObjectLike(value) && isLength(value.length) && (isArray(value) || isArguments(value))) {
+    if (isObjectLike(value) && isArrayLike(value) &&
+        (isStrict || isArray(value) || isArguments(value))) {
      if (isDeep) {
        // Recursively flatten arrays (susceptible to call stack limits).
        value = baseFlatten(value, isDeep, isStrict);
@@ -30,7 +30,6 @@ function baseFlatten(array, isDeep, isStrict) {
      var valIndex = -1,
          valLength = value.length;

-      result.length += valLength;
      while (++valIndex < valLength) {
        result[++resIndex] = value[valIndex];
      }
--- a/internal/baseGet.js
+++ b/internal/baseGet.js
@@ -21,9 +21,9 @@ function baseGet(object, path, pathKey) {
      length = path.length;

  while (object != null && ++index < length) {
-    var result = object = object[path[index]];
+    object = object[path[index]];
  }
-  return result;
+  return (index && index == length) ? object : undefined;
 }

 module.exports = baseGet;
--- a/internal/baseIsEqual.js
+++ b/internal/baseIsEqual.js
@@ -16,8 +16,7 @@ var baseIsEqualDeep = require('./baseIsEqualDeep');
 function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
  // Exit early for identical values.
  if (value === other) {
-    // Treat `+0` vs. `-0` as not equal.
-    return value !== 0 || (1 / value == 1 / other);
+    return true;
  }
  var valType = typeof value,
      othType = typeof other;
--- a/internal/baseMap.js
+++ b/internal/baseMap.js
@@ -1,6 +1,5 @@
 var baseEach = require('./baseEach'),
-    getLength = require('./getLength'),
-    isLength = require('./isLength');
+    isArrayLike = require('./isArrayLike');

 /**
 * The base implementation of `_.map` without support for callback shorthands
@@ -13,8 +12,7 @@ var baseEach = require('./baseEach'),
 */
 function baseMap(collection, iteratee) {
  var index = -1,
-      length = getLength(collection),
-      result = isLength(length) ? Array(length) : [];
+      result = isArrayLike(collection) ? Array(collection.length) : [];

  baseEach(collection, function(value, key, collection) {
    result[++index] = iteratee(value, key, collection);
--- a/internal/baseMerge.js
+++ b/internal/baseMerge.js
@@ -2,7 +2,7 @@ var arrayEach = require('./arrayEach'),
    baseMergeDeep = require('./baseMergeDeep'),
    getSymbols = require('./getSymbols'),
    isArray = require('../lang/isArray'),
-    isLength = require('./isLength'),
+    isArrayLike = require('./isArrayLike'),
    isObject = require('../lang/isObject'),
    isObjectLike = require('./isObjectLike'),
    isTypedArray = require('../lang/isTypedArray'),
@@ -30,7 +30,7 @@ function baseMerge(object, source, customizer, stackA, stackB) {
  if (!isObject(object)) {
    return object;
  }
-  var isSrcArr = isLength(source.length) && (isArray(source) || isTypedArray(source));
+  var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source));
  if (!isSrcArr) {
    var props = keys(source);
    push.apply(props, getSymbols(source));
--- a/internal/baseMergeDeep.js
+++ b/internal/baseMergeDeep.js
@@ -1,8 +1,7 @@
 var arrayCopy = require('./arrayCopy'),
-    getLength = require('./getLength'),
    isArguments = require('../lang/isArguments'),
    isArray = require('../lang/isArray'),
-    isLength = require('./isLength'),
+    isArrayLike = require('./isArrayLike'),
    isPlainObject = require('../lang/isPlainObject'),
    isTypedArray = require('../lang/isTypedArray'),
    toPlainObject = require('../lang/toPlainObject');
@@ -38,10 +37,10 @@ function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stack

  if (isCommon) {
    result = srcValue;
-    if (isLength(srcValue.length) && (isArray(srcValue) || isTypedArray(srcValue))) {
+    if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {
      result = isArray(value)
        ? value
-        : (getLength(value) ? arrayCopy(value) : []);
+        : (isArrayLike(value) ? arrayCopy(value) : []);
    }
    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
      result = isArguments(value)
--- a/internal/basePullAt.js
+++ b/internal/basePullAt.js
@@ -16,7 +16,7 @@ var splice = arrayProto.splice;
 * @returns {Array} Returns `array`.
 */
 function basePullAt(array, indexes) {
-  var length = indexes.length;
+  var length = array ? indexes.length : 0;
  while (length--) {
    var index = parseFloat(indexes[length]);
    if (index != previous && isIndex(index)) {
--- a/internal/binaryIndexBy.js
+++ b/internal/binaryIndexBy.js
@@ -6,7 +6,7 @@ var nativeMin = Math.min;

 /** Used as references for the maximum length and index of an array. */
 var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1,
-    MAX_ARRAY_INDEX =  MAX_ARRAY_LENGTH - 1;
+    MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;

 /**
 * This function is like `binaryIndex` except that it invokes `iteratee` for
--- a/internal/composeArgsRight.js
+++ b/internal/composeArgsRight.js
@@ -23,12 +23,12 @@ function composeArgsRight(args, partials, holders) {
  while (++argsIndex < argsLength) {
    result[argsIndex] = args[argsIndex];
  }
-  var pad = argsIndex;
+  var offset = argsIndex;
  while (++rightIndex < rightLength) {
-    result[pad + rightIndex] = partials[rightIndex];
+    result[offset + rightIndex] = partials[rightIndex];
  }
  while (++holdersIndex < holdersLength) {
-    result[pad + holders[holdersIndex]] = args[argsIndex++];
+    result[offset + holders[holdersIndex]] = args[argsIndex++];
  }
  return result;
 }
--- a/internal/createFind.js
+++ b/internal/createFind.js
@@ -19,7 +19,7 @@ function createFind(eachFunc, fromRight) {
      return index > -1 ? collection[index] : undefined;
    }
    return baseFind(collection, predicate, eachFunc);
-  }
+  };
 }

 module.exports = createFind;
--- a/internal/createFlow.js
+++ b/internal/createFlow.js
@@ -4,6 +4,12 @@ var LodashWrapper = require('./LodashWrapper'),
    isArray = require('../lang/isArray'),
    isLaziable = require('./isLaziable');

+/** Used to compose bitmasks for wrapper metadata. */
+var CURRY_FLAG = 8,
+    PARTIAL_FLAG = 32,
+    ARY_FLAG = 128,
+    REARG_FLAG = 256;
+
 /** Used as the `TypeError` message for "Functions" methods. */
 var FUNC_ERROR_TEXT = 'Expected a function';

@@ -39,7 +45,7 @@ function createFlow(fromRight) {
      funcName = getFuncName(func);

      var data = funcName == 'wrapper' ? getData(func) : null;
-      if (data && isLaziable(data[0])) {
+      if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {
        wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
      } else {
        wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);
--- a/internal/createObjectMapper.js
+++ b/internal/createObjectMapper.js
@@ -0,0 +1,26 @@
+var baseCallback = require('./baseCallback'),
+    baseForOwn = require('./baseForOwn');
+
+/**
+ * Creates a function for `_.mapKeys` or `_.mapValues`.
+ *
+ * @private
+ * @param {boolean} [isMapKeys] Specify mapping keys instead of values.
+ * @returns {Function} Returns the new map function.
+ */
+function createObjectMapper(isMapKeys) {
+  return function(object, iteratee, thisArg) {
+    var result = {};
+    iteratee = baseCallback(iteratee, thisArg, 3);
+
+    baseForOwn(object, function(value, key, object) {
+      var mapped = iteratee(value, key, object);
+      key = isMapKeys ? mapped : key;
+      value = isMapKeys ? value : mapped;
+      result[key] = value;
+    });
+    return result;
+  };
+}
+
+module.exports = createObjectMapper;
--- a/internal/createPadDir.js
+++ b/internal/createPadDir.js
@@ -11,7 +11,7 @@ var baseToString = require('./baseToString'),
 function createPadDir(fromRight) {
  return function(string, length, chars) {
    string = baseToString(string);
-    return string && ((fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string));
+    return (fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string);
  };
 }

--- a/internal/equalByTag.js
+++ b/internal/equalByTag.js
@@ -34,8 +34,7 @@ function equalByTag(object, other, tag) {
      // Treat `NaN` vs. `NaN` as equal.
      return (object != +object)
        ? other != +other
-        // But, treat `-0` vs. `+0` as not equal.
-        : (object == 0 ? ((1 / object) == (1 / other)) : object == +other);
+        : object == +other;

    case regexpTag:
    case stringTag:
--- a/internal/getLength.js
+++ b/internal/getLength.js
@@ -4,7 +4,7 @@ var baseProperty = require('./baseProperty');
 * Gets the "length" property value of `object`.
 *
 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
- * in Safari on iOS 8.1 ARM64.
+ * that affects Safari on at least iOS 8.1-8.3 ARM64.
 *
 * @private
 * @param {Object} object The object to query.
--- a/internal/isArrayLike.js
+++ b/internal/isArrayLike.js
@@ -0,0 +1,15 @@
+var getLength = require('./getLength'),
+    isLength = require('./isLength');
+
+/**
+ * Checks if `value` is array-like.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ */
+function isArrayLike(value) {
+  return value != null && isLength(getLength(value));
+}
+
+module.exports = isArrayLike;
--- a/internal/isIterateeCall.js
+++ b/internal/isIterateeCall.js
@@ -1,6 +1,5 @@
-var getLength = require('./getLength'),
+var isArrayLike = require('./isArrayLike'),
    isIndex = require('./isIndex'),
-    isLength = require('./isLength'),
    isObject = require('../lang/isObject');

 /**
@@ -17,13 +16,9 @@ function isIterateeCall(value, index, object) {
    return false;
  }
  var type = typeof index;
-  if (type == 'number') {
-    var length = getLength(object),
-        prereq = isLength(length) && isIndex(index, length);
-  } else {
-    prereq = type == 'string' && index in object;
-  }
-  if (prereq) {
+  if (type == 'number'
+      ? (isArrayLike(object) && isIndex(index, object.length))
+      : (type == 'string' && index in object)) {
    var other = object[index];
    return value === value ? (value === other) : (other !== other);
  }
--- a/internal/isKey.js
+++ b/internal/isKey.js
@@ -2,7 +2,7 @@ var isArray = require('../lang/isArray'),
    toObject = require('./toObject');

 /** Used to match property names within property paths. */
-var reIsDeepProp = /\.|\[(?:[^[\]]+|(["'])(?:(?!\1)[^\n\\]|\\.)*?)\1\]/,
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,
    reIsPlainProp = /^\w*$/;

 /**
--- a/internal/isStrictComparable.js
+++ b/internal/isStrictComparable.js
@@ -9,7 +9,7 @@ var isObject = require('../lang/isObject');
 *  equality comparisons, else `false`.
 */
 function isStrictComparable(value) {
-  return value === value && (value === 0 ? ((1 / value) > 0) : !isObject(value));
+  return value === value && !isObject(value);
 }

 module.exports = isStrictComparable;
--- a/internal/pickByArray.js
+++ b/internal/pickByArray.js
@@ -1,7 +1,7 @@
 var toObject = require('./toObject');

 /**
- * A specialized version of `_.pick` that picks `object` properties specified
+ * A specialized version of `_.pick` which picks `object` properties specified
 * by `props`.
 *
 * @private
--- a/internal/pickByCallback.js
+++ b/internal/pickByCallback.js
@@ -1,7 +1,7 @@
 var baseForIn = require('./baseForIn');

 /**
- * A specialized version of `_.pick` that picks `object` properties `predicate`
+ * A specialized version of `_.pick` which picks `object` properties `predicate`
 * returns truthy for.
 *
 * @private
--- a/internal/toIterable.js
+++ b/internal/toIterable.js
@@ -1,5 +1,4 @@
-var getLength = require('./getLength'),
-    isLength = require('./isLength'),
+var isArrayLike = require('./isArrayLike'),
    isObject = require('../lang/isObject'),
    values = require('../object/values');

@@ -14,7 +13,7 @@ function toIterable(value) {
  if (value == null) {
    return [];
  }
-  if (!isLength(getLength(value))) {
+  if (!isArrayLike(value)) {
    return values(value);
  }
  return isObject(value) ? value : Object(value);
--- a/lang/isArguments.js
+++ b/lang/isArguments.js
@@ -1,4 +1,4 @@
-var isLength = require('../internal/isLength'),
+var isArrayLike = require('../internal/isArrayLike'),
    isObjectLike = require('../internal/isObjectLike');

 /** `Object#toString` result references. */
@@ -30,8 +30,7 @@ var objToString = objectProto.toString;
 * // => false
 */
 function isArguments(value) {
-  var length = isObjectLike(value) ? value.length : undefined;
-  return isLength(length) && objToString.call(value) == argsTag;
+  return isObjectLike(value) && isArrayLike(value) && objToString.call(value) == argsTag;
 }

 module.exports = isArguments;
--- a/lang/isEmpty.js
+++ b/lang/isEmpty.js
@@ -1,8 +1,7 @@
-var getLength = require('../internal/getLength'),
-    isArguments = require('./isArguments'),
+var isArguments = require('./isArguments'),
    isArray = require('./isArray'),
+    isArrayLike = require('../internal/isArrayLike'),
    isFunction = require('./isFunction'),
-    isLength = require('../internal/isLength'),
    isObjectLike = require('../internal/isObjectLike'),
    isString = require('./isString'),
    keys = require('../object/keys');
@@ -38,10 +37,9 @@ function isEmpty(value) {
  if (value == null) {
    return true;
  }
-  var length = getLength(value);
-  if (isLength(length) && (isArray(value) || isString(value) || isArguments(value) ||
+  if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) ||
      (isObjectLike(value) && isFunction(value.splice)))) {
-    return !length;
+    return !value.length;
  }
  return !keys(value).length;
 }
--- a/lang/isRegExp.js
+++ b/lang/isRegExp.js
@@ -29,7 +29,7 @@ var objToString = objectProto.toString;
 * // => false
 */
 function isRegExp(value) {
-  return (isObjectLike(value) && objToString.call(value) == regexpTag) || false;
+  return isObjectLike(value) && objToString.call(value) == regexpTag;
 }

 module.exports = isRegExp;
--- a/object.js
+++ b/object.js
@@ -15,6 +15,7 @@ module.exports = {
  'invert': require('./object/invert'),
  'keys': require('./object/keys'),
  'keysIn': require('./object/keysIn'),
+  'mapKeys': require('./object/mapKeys'),
  'mapValues': require('./object/mapValues'),
  'merge': require('./object/merge'),
  'methods': require('./object/methods'),
--- a/object/assign.js
+++ b/object/assign.js
@@ -12,7 +12,6 @@ var assignWith = require('../internal/assignWith'),
 * **Note:** This method mutates `object` and is based on
 * [`Object.assign`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign).
 *
- *
 * @static
 * @memberOf _
 * @alias extend
--- a/object/keys.js
+++ b/object/keys.js
@@ -1,4 +1,4 @@
-var isLength = require('../internal/isLength'),
+var isArrayLike = require('../internal/isArrayLike'),
    isNative = require('../lang/isNative'),
    isObject = require('../lang/isObject'),
    shimKeys = require('../internal/shimKeys');
@@ -34,12 +34,9 @@ var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys;
 * // => ['0', '1']
 */
 var keys = !nativeKeys ? shimKeys : function(object) {
-  if (object) {
-    var Ctor = object.constructor,
-        length = object.length;
-  }
+  var Ctor = object != null && object.constructor;
  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
-      (typeof object != 'function' && isLength(length))) {
+      (typeof object != 'function' && isArrayLike(object))) {
    return shimKeys(object);
  }
  return isObject(object) ? nativeKeys(object) : [];
--- a/object/mapKeys.js
+++ b/object/mapKeys.js
@@ -0,0 +1,25 @@
+var createObjectMapper = require('../internal/createObjectMapper');
+
+/**
+ * The opposite of `_.mapValues`; this method creates an object with the
+ * same values as `object` and keys generated by running each own enumerable
+ * property of `object` through `iteratee`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+ *  per iteration.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Object} Returns the new mapped object.
+ * @example
+ *
+ * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
+ *   return key + value;
+ * });
+ * // => { 'a1': 1, 'b2': 2 }
+ */
+var mapKeys = createObjectMapper(true);
+
+module.exports = mapKeys;
--- a/object/mapValues.js
+++ b/object/mapValues.js
@@ -1,5 +1,4 @@
-var baseCallback = require('../internal/baseCallback'),
-    baseForOwn = require('../internal/baseForOwn');
+var createObjectMapper = require('../internal/createObjectMapper');

 /**
 * Creates an object with the same keys as `object` and values generated by
@@ -42,14 +41,6 @@ var baseCallback = require('../internal/baseCallback'),
 * _.mapValues(users, 'age');
 * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
 */
-function mapValues(object, iteratee, thisArg) {
-  var result = {};
-  iteratee = baseCallback(iteratee, thisArg, 3);
-
-  baseForOwn(object, function(value, key, object) {
-    result[key] = iteratee(value, key, object);
-  });
-  return result;
-}
+var mapValues = createObjectMapper();

 module.exports = mapValues;
--- a/object/omit.js
+++ b/object/omit.js
@@ -10,11 +10,6 @@ var arrayMap = require('../internal/arrayMap'),
 /**
 * The opposite of `_.pick`; this method creates an object composed of the
 * own and inherited enumerable properties of `object` that are not omitted.
- * Property names may be specified as individual arguments or as arrays of
- * property names. If `predicate` is provided it is invoked for each property
- * of `object` omitting the properties `predicate` returns truthy for. The
- * predicate is bound to `thisArg` and invoked with three arguments:
- * (value, key, object).
 *
 * @static
 * @memberOf _
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "lodash",
-  "version": "3.7.0",
+  "version": "3.8.0",
  "description": "The modern build of lodash modular utilities.",
  "homepage": "https://lodash.com/",
  "icon": "https://lodash.com/icon.svg",
--- a/support.js
+++ b/support.js
@@ -18,6 +18,7 @@ var support = {};

 (function(x) {
  var Ctor = function() { this.x = x; },
+      args = arguments,
      object = { '0': x, 'length': x },
      props = [];

@@ -67,7 +68,7 @@ var support = {};
   * @type boolean
   */
  try {
-    support.nonEnumArgs = !propertyIsEnumerable.call(arguments, 1);
+    support.nonEnumArgs = !propertyIsEnumerable.call(args, 1);
  } catch(e) {
    support.nonEnumArgs = true;
  }
--- a/utility/callback.js
+++ b/utility/callback.js
@@ -1,5 +1,7 @@
 var baseCallback = require('../internal/baseCallback'),
-    isIterateeCall = require('../internal/isIterateeCall');
+    isIterateeCall = require('../internal/isIterateeCall'),
+    isObjectLike = require('../internal/isObjectLike'),
+    matches = require('./matches');

 /**
 * Creates a function that invokes `func` with the `this` binding of `thisArg`
@@ -43,7 +45,9 @@ function callback(func, thisArg, guard) {
  if (guard && isIterateeCall(func, thisArg, guard)) {
    thisArg = null;
  }
-  return baseCallback(func, thisArg);
+  return isObjectLike(func)
+    ? matches(func)
+    : baseCallback(func, thisArg);
 }

 module.exports = callback;
--- a/utility/method.js
+++ b/utility/method.js
@@ -25,7 +25,7 @@ var invokePath = require('../internal/invokePath'),
 var method = restParam(function(path, args) {
  return function(object) {
    return invokePath(object, path, args);
-  }
+  };
 });

 module.exports = method;