Bump to v3.6.0.

array/difference.js

@@ -2,15 +2,15 @@ import baseDifference from '../internal/baseDifference';
 import baseFlatten from '../internal/baseFlatten';
 import isArguments from '../lang/isArguments';
 import isArray from '../lang/isArray';
+import restParam from '../function/restParam';
 
 /**
  * Creates an array excluding all values of the provided arrays using
  * `SameValueZero` for equality comparisons.
  *
- * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _
@@ -23,18 +23,10 @@ import isArray from '../lang/isArray';
  * _.difference([1, 2, 3], [4, 2]);
  * // => [1, 3]
  */
-function difference() {
-  var args = arguments,
-      index = -1,
-      length = args.length;
-
-  while (++index < length) {
-    var value = args[index];
-    if (isArray(value) || isArguments(value)) {
-      break;
-    }
-  }
-  return baseDifference(value, baseFlatten(args, false, true, ++index));
-}
+var difference = restParam(function(array, values) {
+  return (isArray(array) || isArguments(array))
+    ? baseDifference(array, baseFlatten(values, false, true))
+    : [];
+});
 
 export default difference;

array/dropRightWhile.js

@@ -1,10 +1,10 @@
 import baseCallback from '../internal/baseCallback';
-import baseSlice from '../internal/baseSlice';
+import baseWhile from '../internal/baseWhile';
 
 /**
  * Creates a slice of `array` excluding elements dropped from the end.
  * Elements are dropped until `predicate` returns falsey. The predicate is
- * bound to `thisArg` and invoked with three arguments; (value, index, array).
+ * bound to `thisArg` and invoked with three arguments: (value, index, array).
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.
@@ -51,13 +51,9 @@ import baseSlice from '../internal/baseSlice';
  * // => ['barney', 'fred', 'pebbles']
  */
 function dropRightWhile(array, predicate, thisArg) {
-  var length = array ? array.length : 0;
-  if (!length) {
-    return [];
-  }
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (length-- && predicate(array[length], length, array)) {}
-  return baseSlice(array, 0, length + 1);
+  return (array && array.length)
+    ? baseWhile(array, baseCallback(predicate, thisArg, 3), true, true)
+    : [];
 }
 
 export default dropRightWhile;

array/dropWhile.js

@@ -1,10 +1,10 @@
 import baseCallback from '../internal/baseCallback';
-import baseSlice from '../internal/baseSlice';
+import baseWhile from '../internal/baseWhile';
 
 /**
  * Creates a slice of `array` excluding elements dropped from the beginning.
  * Elements are dropped until `predicate` returns falsey. The predicate is
- * bound to `thisArg` and invoked with three arguments; (value, index, array).
+ * bound to `thisArg` and invoked with three arguments: (value, index, array).
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.
@@ -51,14 +51,9 @@ import baseSlice from '../internal/baseSlice';
  * // => ['barney', 'fred', 'pebbles']
  */
 function dropWhile(array, predicate, thisArg) {
-  var length = array ? array.length : 0;
-  if (!length) {
-    return [];
-  }
-  var index = -1;
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (++index < length && predicate(array[index], index, array)) {}
-  return baseSlice(array, index);
+  return (array && array.length)
+    ? baseWhile(array, baseCallback(predicate, thisArg, 3), true)
+    : [];
 }
 
 export default dropWhile;

array/fill.js

@@ -15,6 +15,19 @@ import isIterateeCall from '../internal/isIterateeCall';
  * @param {number} [start=0] The start position.
  * @param {number} [end=array.length] The end position.
  * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _.fill(array, 'a');
+ * console.log(array);
+ * // => ['a', 'a', 'a']
+ *
+ * _.fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * _.fill([4, 6, 8], '*', 1, 2);
+ * // => [4, '*', 8]
  */
 function fill(array, value, start, end) {
   var length = array ? array.length : 0;

array/findIndex.js

@@ -1,8 +1,8 @@
-import baseCallback from '../internal/baseCallback';
+import createFindIndex from '../internal/createFindIndex';
 
 /**
  * This method is like `_.find` except that it returns the index of the first
- * element `predicate` returns truthy for, instead of the element itself.
+ * element `predicate` returns truthy for instead of the element itself.
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.
@@ -48,17 +48,6 @@ import baseCallback from '../internal/baseCallback';
  * _.findIndex(users, 'active');
  * // => 2
  */
-function findIndex(array, predicate, thisArg) {
-  var index = -1,
-      length = array ? array.length : 0;
-
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (++index < length) {
-    if (predicate(array[index], index, array)) {
-      return index;
-    }
-  }
-  return -1;
-}
+var findIndex = createFindIndex();
 
 export default findIndex;

array/findLastIndex.js

@@ -1,4 +1,4 @@
-import baseCallback from '../internal/baseCallback';
+import createFindIndex from '../internal/createFindIndex';
 
 /**
  * This method is like `_.findIndex` except that it iterates over elements
@@ -48,15 +48,6 @@ import baseCallback from '../internal/baseCallback';
  * _.findLastIndex(users, 'active');
  * // => 0
  */
-function findLastIndex(array, predicate, thisArg) {
-  var length = array ? array.length : 0;
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (length--) {
-    if (predicate(array[length], length, array)) {
-      return length;
-    }
-  }
-  return -1;
-}
+var findLastIndex = createFindIndex(true);
 
 export default findLastIndex;

array/flatten.js

@@ -15,18 +15,18 @@ import isIterateeCall from '../internal/isIterateeCall';
  * @example
  *
  * _.flatten([1, [2, 3, [4]]]);
- * // => [1, 2, 3, [4]];
+ * // => [1, 2, 3, [4]]
  *
  * // using `isDeep`
  * _.flatten([1, [2, 3, [4]]], true);
- * // => [1, 2, 3, 4];
+ * // => [1, 2, 3, 4]
  */
 function flatten(array, isDeep, guard) {
   var length = array ? array.length : 0;
   if (guard && isIterateeCall(array, isDeep, guard)) {
     isDeep = false;
   }
-  return length ? baseFlatten(array, isDeep, false, 0) : [];
+  return length ? baseFlatten(array, isDeep) : [];
 }
 
 export default flatten;

array/flattenDeep.js

@@ -11,11 +11,11 @@ import baseFlatten from '../internal/baseFlatten';
  * @example
  *
  * _.flattenDeep([1, [2, 3, [4]]]);
- * // => [1, 2, 3, 4];
+ * // => [1, 2, 3, 4]
  */
 function flattenDeep(array) {
   var length = array ? array.length : 0;
-  return length ? baseFlatten(array, true, false, 0) : [];
+  return length ? baseFlatten(array, true) : [];
 }
 
 export default flattenDeep;

array/indexOf.js

@@ -10,10 +10,9 @@ var nativeMax = Math.max;
  * 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` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _

array/intersection.js

@@ -8,10 +8,9 @@ import isArray from '../lang/isArray';
  * Creates an array of unique values in all provided arrays using `SameValueZero`
  * for equality comparisons.
  *
- * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _

array/pull.js

@@ -11,10 +11,10 @@ var splice = arrayProto.splice;
  * comparisons.
  *
  * **Notes:**
- *  - Unlike `_.without`, this method mutates `array`.
- *  - `SameValueZero` comparisons are like strict equality comparisons, e.g. `===`,
- *    except that `NaN` matches `NaN`. See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- *    for more details.
+ *  - 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`
  *
  * @static
  * @memberOf _

array/pullAt.js

@@ -1,5 +1,14 @@
+import baseAt from '../internal/baseAt';
+import baseCompareAscending from '../internal/baseCompareAscending';
 import baseFlatten from '../internal/baseFlatten';
-import basePullAt from '../internal/basePullAt';
+import isIndex from '../internal/isIndex';
+import restParam from '../function/restParam';
+
+/** Used for native method references. */
+var arrayProto = Array.prototype;
+
+/** Native method references. */
+var splice = arrayProto.splice;
 
 /**
  * Removes elements from `array` corresponding to the given indexes and returns
@@ -26,8 +35,22 @@ import basePullAt from '../internal/basePullAt';
  * console.log(evens);
  * // => [10, 20]
  */
-function pullAt(array) {
-  return basePullAt(array || [], baseFlatten(arguments, false, false, 1));
-}
+var pullAt = restParam(function(array, indexes) {
+  array || (array = []);
+  indexes = baseFlatten(indexes);
+
+  var length = indexes.length,
+      result = baseAt(array, indexes);
+
+  indexes.sort(baseCompareAscending);
+  while (length--) {
+    var index = parseFloat(indexes[length]);
+    if (index != previous && isIndex(index)) {
+      var previous = index;
+      splice.call(array, index, 1);
+    }
+  }
+  return result;
+});
 
 export default pullAt;

array/remove.js

@@ -9,7 +9,7 @@ var splice = arrayProto.splice;
 /**
  * Removes all elements from `array` that `predicate` returns truthy for
  * and returns an array of the removed elements. The predicate is bound to
- * `thisArg` and invoked with three arguments; (value, index, array).
+ * `thisArg` and invoked with three arguments: (value, index, array).
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.

array/sortedIndex.js

@@ -1,6 +1,4 @@
-import baseCallback from '../internal/baseCallback';
-import binaryIndex from '../internal/binaryIndex';
-import binaryIndexBy from '../internal/binaryIndexBy';
+import createSortedIndex from '../internal/createSortedIndex';
 
 /**
  * Uses a binary search to determine the lowest index at which `value` should
@@ -9,14 +7,14 @@ import binaryIndexBy from '../internal/binaryIndexBy';
  * to compute their sort ranking. The iteratee is bound to `thisArg` and
  * invoked with one argument; (value).
  *
- * If a property name is provided for `predicate` the created `_.property`
+ * If a property name is provided for `iteratee` 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
+ * If an object is provided for `iteratee` the created `_.matches` style
  * callback returns `true` for elements that have the properties of the given
  * object, else `false`.
  *
@@ -50,10 +48,6 @@ import binaryIndexBy from '../internal/binaryIndexBy';
  * _.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
  * // => 1
  */
-function sortedIndex(array, value, iteratee, thisArg) {
-  return iteratee == null
-    ? binaryIndex(array, value)
-    : binaryIndexBy(array, value, baseCallback(iteratee, thisArg, 1));
-}
+var sortedIndex = createSortedIndex();
 
 export default sortedIndex;

array/sortedLastIndex.js

@@ -1,6 +1,4 @@
-import baseCallback from '../internal/baseCallback';
-import binaryIndex from '../internal/binaryIndex';
-import binaryIndexBy from '../internal/binaryIndexBy';
+import createSortedIndex from '../internal/createSortedIndex';
 
 /**
  * This method is like `_.sortedIndex` except that it returns the highest
@@ -22,10 +20,6 @@ import binaryIndexBy from '../internal/binaryIndexBy';
  * _.sortedLastIndex([4, 4, 5, 5], 5);
  * // => 4
  */
-function sortedLastIndex(array, value, iteratee, thisArg) {
-  return iteratee == null
-    ? binaryIndex(array, value, true)
-    : binaryIndexBy(array, value, baseCallback(iteratee, thisArg, 1), true);
-}
+var sortedLastIndex = createSortedIndex(true);
 
 export default sortedLastIndex;

array/takeRightWhile.js

@@ -1,10 +1,10 @@
 import baseCallback from '../internal/baseCallback';
-import baseSlice from '../internal/baseSlice';
+import baseWhile from '../internal/baseWhile';
 
 /**
  * Creates a slice of `array` with elements taken from the end. Elements are
  * taken until `predicate` returns falsey. The predicate is bound to `thisArg`
- * and invoked with three arguments; (value, index, array).
+ * and invoked with three arguments: (value, index, array).
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.
@@ -51,13 +51,9 @@ import baseSlice from '../internal/baseSlice';
  * // => []
  */
 function takeRightWhile(array, predicate, thisArg) {
-  var length = array ? array.length : 0;
-  if (!length) {
-    return [];
-  }
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (length-- && predicate(array[length], length, array)) {}
-  return baseSlice(array, length + 1);
+  return (array && array.length)
+    ? baseWhile(array, baseCallback(predicate, thisArg, 3), false, true)
+    : [];
 }
 
 export default takeRightWhile;

array/takeWhile.js

@@ -1,10 +1,10 @@
 import baseCallback from '../internal/baseCallback';
-import baseSlice from '../internal/baseSlice';
+import baseWhile from '../internal/baseWhile';
 
 /**
  * Creates a slice of `array` with elements taken from the beginning. Elements
  * are taken until `predicate` returns falsey. The predicate is bound to
- * `thisArg` and invoked with three arguments; (value, index, array).
+ * `thisArg` and invoked with three arguments: (value, index, array).
  *
  * If a property name is provided for `predicate` the created `_.property`
  * style callback returns the property value of the given element.
@@ -51,14 +51,9 @@ import baseSlice from '../internal/baseSlice';
  * // => []
  */
 function takeWhile(array, predicate, thisArg) {
-  var length = array ? array.length : 0;
-  if (!length) {
-    return [];
-  }
-  var index = -1;
-  predicate = baseCallback(predicate, thisArg, 3);
-  while (++index < length && predicate(array[index], index, array)) {}
-  return baseSlice(array, 0, index);
+  return (array && array.length)
+    ? baseWhile(array, baseCallback(predicate, thisArg, 3))
+    : [];
 }
 
 export default takeWhile;

array/union.js

@@ -1,14 +1,14 @@
 import baseFlatten from '../internal/baseFlatten';
 import baseUniq from '../internal/baseUniq';
+import restParam from '../function/restParam';
 
 /**
  * Creates an array of unique values, in order, of the provided arrays using
  * `SameValueZero` for equality comparisons.
  *
- * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _
@@ -20,8 +20,8 @@ import baseUniq from '../internal/baseUniq';
  * _.union([1, 2], [4, 2], [2, 1]);
  * // => [1, 2, 4]
  */
-function union() {
-  return baseUniq(baseFlatten(arguments, false, true, 0));
-}
+var union = restParam(function(arrays) {
+  return baseUniq(baseFlatten(arrays, false, true));
+});
 
 export default union;

array/uniq.js

@@ -9,23 +9,22 @@ import sortedUniq from '../internal/sortedUniq';
  * search algorithm for sorted arrays. If an iteratee function is provided it
  * is invoked for each value in the array to generate the criterion by which
  * uniqueness is computed. The `iteratee` is bound to `thisArg` and invoked
- * with three arguments; (value, index, array).
+ * with three arguments: (value, index, array).
  *
- * If a property name is provided for `predicate` the created `_.property`
+ * If a property name is provided for `iteratee` 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
+ * If an object is provided for `iteratee` the created `_.matches` style
  * callback returns `true` for elements that have the properties of the given
  * object, else `false`.
  *
- * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _

array/without.js

@@ -1,14 +1,15 @@
 import baseDifference from '../internal/baseDifference';
-import baseSlice from '../internal/baseSlice';
+import isArguments from '../lang/isArguments';
+import isArray from '../lang/isArray';
+import restParam from '../function/restParam';
 
 /**
  * Creates an array excluding all provided values using `SameValueZero` for
  * equality comparisons.
  *
- * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
- * e.g. `===`, except that `NaN` matches `NaN`. See the
- * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
- * for more details.
+ * **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 _
@@ -21,8 +22,10 @@ import baseSlice from '../internal/baseSlice';
  * _.without([1, 2, 1, 3], 1, 2);
  * // => [3]
  */
-function without(array) {
-  return baseDifference(array, baseSlice(arguments, 1));
-}
+var without = restParam(function(array, values) {
+  return (isArray(array) || isArguments(array))
+    ? baseDifference(array, values)
+    : [];
+});
 
 export default without;

array/xor.js

@@ -4,9 +4,8 @@ import isArguments from '../lang/isArguments';
 import isArray from '../lang/isArray';
 
 /**
- * Creates an array that is the symmetric difference of the provided arrays.
- * See [Wikipedia](https://en.wikipedia.org/wiki/Symmetric_difference) for
- * more details.
+ * Creates an array that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
+ * of the provided arrays.
  *
  * @static
  * @memberOf _

array/zip.js

@@ -1,3 +1,4 @@
+import restParam from '../function/restParam';
 import unzip from './unzip';
 
 /**
@@ -15,14 +16,6 @@ import unzip from './unzip';
  * _.zip(['fred', 'barney'], [30, 40], [true, false]);
  * // => [['fred', 30, true], ['barney', 40, false]]
  */
-function zip() {
-  var length = arguments.length,
-      array = Array(length);
-
-  while (length--) {
-    array[length] = arguments[length];
-  }
-  return unzip(array);
-}
+var zip = restParam(unzip);
 
 export default zip;

array/zipObject.js

@@ -1,9 +1,10 @@
 import isArray from '../lang/isArray';
 
 /**
- * Creates an object composed from arrays of property names and values. Provide
- * either a single two dimensional array, e.g. `[[key1, value1], [key2, value2]]`
- * or two arrays, one of property names and one of corresponding values.
+ * The inverse of `_.pairs`; this method returns an object composed from arrays
+ * of property names and values. Provide either a single two dimensional array,
+ * e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names
+ * and one of corresponding values.
  *
  * @static
  * @memberOf _
@@ -14,6 +15,9 @@ import isArray from '../lang/isArray';
  * @returns {Object} Returns the new object.
  * @example
  *
+ * _.zipObject([['fred', 30], ['barney', 40]]);
+ * // => { 'fred': 30, 'barney': 40 }
+ *
  * _.zipObject(['fred', 'barney'], [30, 40]);
  * // => { 'fred': 30, 'barney': 40 }
  */