Comparing lodash@4.16.6...lodash@4.17.0 • npm-diff.app 📦🔃

 {
   "name": "lodash",
-  "version": "4.16.6",
+  "version": "4.17.0",
   "description": "Lodash modular utilities.",
   "keywords": "modules, stdlib, util",
   "homepage": "https://lodash.com/",
   "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
   "contributors": [
     "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
-    "Blaine Bublitz <blaine.bublitz@gmail.com> (https://github.com/phated)",
     "Mathias Bynens <mathias@qiwi.be> (https://mathiasbynens.be/)"
   ],
   "scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" }

@@ -1,4 +1,4 @@
1	# lodash v4.16.6	1	# lodash v4.17.0
2		2
3	The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.	3	The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
4		4
@@ -28,7 +28,7 @@
28	var curryN = require('lodash/fp/curryN');	28	var curryN = require('lodash/fp/curryN');
29	```	29	```
30		30
31	See the [package source](https://github.com/lodash/lodash/tree/4.16.6-npm) for more details.	31	See the [package source](https://github.com/lodash/lodash/tree/4.17.0-npm) for more details.
32		32
33	Note:<br>	33	Note:<br>
34	Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.	34	Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.

 var baseClone = require('./_baseClone');
+/** Used to compose bitmasks for cloning. */
+var CLONE_SYMBOLS_FLAG = 4;
 /**
  * Creates a shallow clone of `value`.
  *
  * // => true
  */
 function clone(value) {
-  return baseClone(value, false, true);
+  return baseClone(value, CLONE_SYMBOLS_FLAG);
 }
 module.exports = clone;

 var baseClone = require('./_baseClone');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_SYMBOLS_FLAG = 4;
 /**
  * This method is like `_.clone` except that it recursively clones `value`.
  *
  * // => false
  */
 function cloneDeep(value) {
-  return baseClone(value, true, true);
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
 }
 module.exports = cloneDeep;

 var baseClone = require('./_baseClone');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_SYMBOLS_FLAG = 4;
 /**
  * This method is like `_.cloneWith` except that it recursively clones `value`.
  *
  */
 function cloneDeepWith(value, customizer) {
   customizer = typeof customizer == 'function' ? customizer : undefined;
-  return baseClone(value, true, true, customizer);
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
 }
 module.exports = cloneDeepWith;

@@ -4,9 +4,9 @@
4	replaceHolders = require('./_replaceHolders');	4	replaceHolders = require('./_replaceHolders');
5		5
6	/** Used to compose bitmasks for function metadata. */	6	/** Used to compose bitmasks for function metadata. */
7	var BIND_FLAG = 1,
8	BIND_KEY_FLAG = 2,
9	PARTIAL_FLAG = 32;	7	var WRAP_BIND_FLAG = 1,
		8	WRAP_BIND_KEY_FLAG = 2,
		9	WRAP_PARTIAL_FLAG = 32;
10		10
11	/**	11	/**
12	* Creates a function that invokes the method at `object[key]` with `partials`	12	* Creates a function that invokes the method at `object[key]` with `partials`
@@ -54,10 +54,10 @@
54	* // => 'hiya fred!'	54	* // => 'hiya fred!'
55	*/	55	*/
56	var bindKey = baseRest(function(object, key, partials) {	56	var bindKey = baseRest(function(object, key, partials) {
57	var bitmask = BIND_FLAG \| BIND_KEY_FLAG;	57	var bitmask = WRAP_BIND_FLAG \| WRAP_BIND_KEY_FLAG;
58	if (partials.length) {	58	if (partials.length) {
59	var holders = replaceHolders(partials, getHolder(bindKey));	59	var holders = replaceHolders(partials, getHolder(bindKey));
60	bitmask \|= PARTIAL_FLAG;	60	bitmask \|= WRAP_PARTIAL_FLAG;
61	}	61	}
62	return createWrap(key, bitmask, object, partials, holders);	62	return createWrap(key, bitmask, object, partials, holders);
63	});	63	});

 var baseClone = require('./_baseClone');
+/** Used to compose bitmasks for cloning. */
+var CLONE_SYMBOLS_FLAG = 4;
 /**
  * This method is like `_.clone` except that it accepts `customizer` which
  * is invoked to produce the cloned value. If `customizer` returns `undefined`,
  */
 function cloneWith(value, customizer) {
   customizer = typeof customizer == 'function' ? customizer : undefined;
-  return baseClone(value, false, true, customizer);
+  return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
 }
 module.exports = cloneWith;

@@ -4,8 +4,8 @@
4	replaceHolders = require('./_replaceHolders');	4	replaceHolders = require('./_replaceHolders');
5		5
6	/** Used to compose bitmasks for function metadata. */	6	/** Used to compose bitmasks for function metadata. */
7	var BIND_FLAG = 1,
8	PARTIAL_FLAG = 32;	7	var WRAP_BIND_FLAG = 1,
		8	WRAP_PARTIAL_FLAG = 32;
9		9
10	/**	10	/**
11	* Creates a function that invokes `func` with the `this` binding of `thisArg`	11	* Creates a function that invokes `func` with the `this` binding of `thisArg`
@@ -43,10 +43,10 @@
43	* // => 'hi fred!'	43	* // => 'hi fred!'
44	*/	44	*/
45	var bind = baseRest(function(func, thisArg, partials) {	45	var bind = baseRest(function(func, thisArg, partials) {
46	var bitmask = BIND_FLAG;	46	var bitmask = WRAP_BIND_FLAG;
47	if (partials.length) {	47	if (partials.length) {
48	var holders = replaceHolders(partials, getHolder(bind));	48	var holders = replaceHolders(partials, getHolder(bind));
49	bitmask \|= PARTIAL_FLAG;	49	bitmask \|= WRAP_PARTIAL_FLAG;
50	}	50	}
51	return createWrap(func, bitmask, thisArg, partials, holders);	51	return createWrap(func, bitmask, thisArg, partials, holders);
52	});	52	});

@@ -9,7 +9,7 @@
9	* @since 1.0.0	9	* @since 1.0.0
10	* @category Object	10	* @category Object
11	* @param {Object} object The object to iterate over.	11	* @param {Object} object The object to iterate over.
12	* @param {...(string\|string[])} [paths] The property paths of elements to pick.	12	* @param {...(string\|string[])} [paths] The property paths to pick.
13	* @returns {Array} Returns the picked values.	13	* @returns {Array} Returns the picked values.
14	* @example	14	* @example
15	*	15	*

 var baseClone = require('./_baseClone'),
     baseConforms = require('./_baseConforms');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
 /**
  * Creates a function that invokes the predicate properties of `source` with
  * the corresponding property values of a given object, returning `true` if
  * // => [{ 'a': 1, 'b': 2 }]
  */
 function conforms(source) {
-  return baseConforms(baseClone(source, true));
+  return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
 }
 module.exports = conforms;

@@ -1,7 +1,7 @@
1	var createWrap = require('./_createWrap');	1	var createWrap = require('./_createWrap');
2		2
3	/** Used to compose bitmasks for function metadata. */	3	/** Used to compose bitmasks for function metadata. */
4	var ARY_FLAG = 128;	4	var WRAP_ARY_FLAG = 128;
5		5
6	/**	6	/**
7	* Creates a function that invokes `func`, with up to `n` arguments,	7	* Creates a function that invokes `func`, with up to `n` arguments,
@@ -23,7 +23,7 @@
23	function ary(func, n, guard) {	23	function ary(func, n, guard) {
24	n = guard ? undefined : n;	24	n = guard ? undefined : n;
25	n = (func && n == null) ? func.length : n;	25	n = (func && n == null) ? func.length : n;
26	return createWrap(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);	26	return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
27	}	27	}
28		28
29	module.exports = ary;	29	module.exports = ary;

     arrayIncludes = require('./_arrayIncludes');
 /** Used to compose bitmasks for function metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    CURRY_FLAG = 8,
+    CURRY_RIGHT_FLAG = 16,
+    PARTIAL_FLAG = 32,
+    PARTIAL_RIGHT_FLAG = 64,
+    ARY_FLAG = 128,
+    REARG_FLAG = 256,
+var WRAP_BIND_FLAG = 1,
+    WRAP_BIND_KEY_FLAG = 2,
+    WRAP_CURRY_FLAG = 8,
+    WRAP_CURRY_RIGHT_FLAG = 16,
+    WRAP_PARTIAL_FLAG = 32,
+    WRAP_PARTIAL_RIGHT_FLAG = 64,
+    WRAP_ARY_FLAG = 128,
+    WRAP_REARG_FLAG = 256,
+    WRAP_FLIP_FLAG = 512;
 /** Used to associate wrap methods with their bit flags. */
 var wrapFlags = [
+  ['ary', ARY_FLAG],
+  ['bind', BIND_FLAG],
+  ['bindKey', BIND_KEY_FLAG],
+  ['curry', CURRY_FLAG],
+  ['curryRight', CURRY_RIGHT_FLAG],
+  ['flip', FLIP_FLAG],
+  ['partial', PARTIAL_FLAG],
+  ['partialRight', PARTIAL_RIGHT_FLAG],
+  ['ary', WRAP_ARY_FLAG],
+  ['bind', WRAP_BIND_FLAG],
+  ['bindKey', WRAP_BIND_KEY_FLAG],
+  ['curry', WRAP_CURRY_FLAG],
+  ['curryRight', WRAP_CURRY_RIGHT_FLAG],
+  ['flip', WRAP_FLIP_FLAG],
+  ['partial', WRAP_PARTIAL_FLAG],
+  ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
+  ['rearg', WRAP_REARG_FLAG]
 ];
 /**

 /** Used to compose unicode character classes. */
 var rsAstralRange = '\\ud800-\\udfff',
+    rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
+    rsComboMarksRange = '\\u0300-\\u036f',
+    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+    rsComboSymbolsRange = '\\u20d0-\\u20ff',
+    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
     rsDingbatRange = '\\u2700-\\u27bf',
     rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
     rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
 /** Used to compose unicode capture groups. */
 var rsApos = "['\u2019]",
     rsBreak = '[' + rsBreakRange + ']',
+    rsCombo = '[' + rsComboRange + ']',
     rsDigits = '\\d+',
     rsDingbat = '[' + rsDingbatRange + ']',
     rsLower = '[' + rsLowerRange + ']',

 var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
 /** Used to compose unicode character classes. */
+var rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
+var rsComboMarksRange = '\\u0300-\\u036f',
+    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+    rsComboSymbolsRange = '\\u20d0-\\u20ff',
+    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
 /** Used to compose unicode capture groups. */
+var rsCombo = '[' + rsComboRange + ']';
 /**
  * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

@@ -15,7 +15,7 @@
15	/** Used to access faster Node.js helpers. */	15	/** Used to access faster Node.js helpers. */
16	var nodeUtil = (function() {	16	var nodeUtil = (function() {
17	try {	17	try {
18	return freeProcess && freeProcess.binding('util');	18	return freeProcess && freeProcess.binding && freeProcess.binding('util');
19	} catch (e) {}	19	} catch (e) {}
20	}());	20	}());
21		21

@@ -6,12 +6,12 @@
6	var PLACEHOLDER = '__lodash_placeholder__';	6	var PLACEHOLDER = '__lodash_placeholder__';
7		7
8	/** Used to compose bitmasks for function metadata. */	8	/** Used to compose bitmasks for function metadata. */
9	var BIND_FLAG = 1,
10	BIND_KEY_FLAG = 2,
11	CURRY_BOUND_FLAG = 4,
12	CURRY_FLAG = 8,
13	ARY_FLAG = 128,
14	REARG_FLAG = 256;	9	var WRAP_BIND_FLAG = 1,
		10	WRAP_BIND_KEY_FLAG = 2,
		11	WRAP_CURRY_BOUND_FLAG = 4,
		12	WRAP_CURRY_FLAG = 8,
		13	WRAP_ARY_FLAG = 128,
		14	WRAP_REARG_FLAG = 256;
15		15
16	/* Built-in method references for those with the same name as other `lodash` methods. */	16	/* Built-in method references for those with the same name as other `lodash` methods. */
17	var nativeMin = Math.min;	17	var nativeMin = Math.min;
@@ -36,22 +36,22 @@
36	var bitmask = data[1],	36	var bitmask = data[1],
37	srcBitmask = source[1],	37	srcBitmask = source[1],
38	newBitmask = bitmask \| srcBitmask,	38	newBitmask = bitmask \| srcBitmask,
39	isCommon = newBitmask < (BIND_FLAG \| BIND_KEY_FLAG \| ARY_FLAG);	39	isCommon = newBitmask < (WRAP_BIND_FLAG \| WRAP_BIND_KEY_FLAG \| WRAP_ARY_FLAG);
40		40
41	var isCombo =	41	var isCombo =
42	((srcBitmask == ARY_FLAG) && (bitmask == CURRY_FLAG)) \|\|
43	((srcBitmask == ARY_FLAG) && (bitmask == REARG_FLAG) && (data[7].length <= source[8])) \|\|
44	((srcBitmask == (ARY_FLAG \| REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == CURRY_FLAG));	42	((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) \|\|
		43	((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) \|\|
		44	((srcBitmask == (WRAP_ARY_FLAG \| WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
45		45
46	// Exit early if metadata can't be merged.	46	// Exit early if metadata can't be merged.
47	if (!(isCommon \|\| isCombo)) {	47	if (!(isCommon \|\| isCombo)) {
48	return data;	48	return data;
49	}	49	}
50	// Use source `thisArg` if available.	50	// Use source `thisArg` if available.
51	if (srcBitmask & BIND_FLAG) {	51	if (srcBitmask & WRAP_BIND_FLAG) {
52	data[2] = source[2];	52	data[2] = source[2];
53	// Set when currying a bound function.	53	// Set when currying a bound function.
54	newBitmask \|= bitmask & BIND_FLAG ? 0 : CURRY_BOUND_FLAG;	54	newBitmask \|= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;

@@ -7,8 +7,7 @@
7	var nativeGetSymbols = Object.getOwnPropertySymbols;	7	var nativeGetSymbols = Object.getOwnPropertySymbols;
8		8
9	/**	9	/**
10	* Creates an array of the own and inherited enumerable symbol properties
11	* of `object`.	10	* Creates an array of the own and inherited enumerable symbols of `object`.
12	*	11	*
13	* @private	12	* @private
14	* @param {Object} object The object to query.	13	* @param {Object} object The object to query.

@@ -5,7 +5,7 @@
5	var nativeGetSymbols = Object.getOwnPropertySymbols;	5	var nativeGetSymbols = Object.getOwnPropertySymbols;
6		6
7	/**	7	/**
8	* Creates an array of the own enumerable symbol properties of `object`.	8	* Creates an array of the own enumerable symbols of `object`.
9	*	9	*
10	* @private	10	* @private
11	* @param {Object} object The object to query.	11	* @param {Object} object The object to query.

@@ -2,7 +2,7 @@
2	isMaskable = require('./_isMaskable');	2	isMaskable = require('./_isMaskable');
3		3
4	/** Error message constants. */	4	/** Error message constants. */
5	var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://github.com/es-shims.';	5	var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.';
6		6
7	/**	7	/**
8	* Checks if `value` is a pristine native function.	8	* Checks if `value` is a pristine native function.

@@ -35,7 +35,7 @@
35	function isEqualWith(value, other, customizer) {	35	function isEqualWith(value, other, customizer) {
36	customizer = typeof customizer == 'function' ? customizer : undefined;	36	customizer = typeof customizer == 'function' ? customizer : undefined;
37	var result = customizer ? customizer(value, other) : undefined;	37	var result = customizer ? customizer(value, other) : undefined;
38	return result === undefined ? baseIsEqual(value, other, customizer) : !!result;	38	return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
39	}	39	}
40		40
41	module.exports = isEqualWith;	41	module.exports = isEqualWith;

 var keys = require('./keys');
 /** Used to compose bitmasks for comparison styles. */
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1;
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
  * @private
  * @param {Object} object The object to compare.
  * @param {Object} other The other object to compare.
  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  * @param {Function} customizer The function to customize comparisons.
  * @param {Function} equalFunc The function to determine equivalents of values.
  * @param {Function} customizer The function to customize comparisons.
  * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
  *  for more details.
  * @param {Object} stack Tracks traversed `object` and `other` objects.
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
 function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
 function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
   var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
       objProps = keys(object),
       objLength = objProps.length,
       othProps = keys(other),
     }
     // Recursively compare objects (susceptible to call stack limits).
     if (!(compared === undefined
           ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
           : compared
         )) {
       result = false;

     mapToArray = require('./_mapToArray'),
     setToArray = require('./_setToArray');
 /** Used to compose bitmasks for comparison styles. */
 var UNORDERED_COMPARE_FLAG = 1,
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1,
     COMPARE_UNORDERED_FLAG = 2;
 /** `Object#toString` result references. */
 var boolTag = '[object Boolean]',
  * @param {Object} object The object to compare.
  * @param {Object} other The other object to compare.
  * @param {string} tag The `toStringTag` of the objects to compare.
  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  * @param {Function} customizer The function to customize comparisons.
  * @param {Function} equalFunc The function to determine equivalents of values.
  * @param {Function} customizer The function to customize comparisons.
  * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
  *  for more details.
  * @param {Object} stack Tracks traversed `object` and `other` objects.
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
 function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
   switch (tag) {
     case dataViewTag:
       if ((object.byteLength != other.byteLength) ||
       var convert = mapToArray;
     case setTag:
       var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
       convert || (convert = setToArray);
       if (object.size != other.size && !isPartial) {
       if (stacked) {
         return stacked == other;
       }
       bitmask |= COMPARE_UNORDERED_FLAG;
       // Recursively compare objects (susceptible to call stack limits).
       stack.set(object, other);
       var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
       stack['delete'](object);
       return result;

     arraySome = require('./_arraySome'),
     cacheHas = require('./_cacheHas');
 /** Used to compose bitmasks for comparison styles. */
 var UNORDERED_COMPARE_FLAG = 1,
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1,
     COMPARE_UNORDERED_FLAG = 2;
 /**
  * A specialized version of `baseIsEqualDeep` for arrays with support for
  * @private
  * @param {Array} array The array to compare.
  * @param {Array} other The other array to compare.
  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  * @param {Function} customizer The function to customize comparisons.
  * @param {Function} equalFunc The function to determine equivalents of values.
  * @param {Function} customizer The function to customize comparisons.
  * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
  *  for more details.
  * @param {Object} stack Tracks traversed `array` and `other` objects.
  * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
  */
 function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
 function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
   var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
       arrLength = array.length,
       othLength = other.length;
   }
   var index = -1,
       result = true,
       seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
   stack.set(array, other);
   stack.set(other, array);
     if (seen) {
       if (!arraySome(other, function(othValue, othIndex) {
             if (!cacheHas(seen, othIndex) &&
                 (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
               return seen.push(othIndex);
             }
           })) {
       }
     } else if (!(
           arrValue === othValue ||
             equalFunc(arrValue, othValue, bitmask, customizer, stack)
         )) {
       result = false;
       break;

 var FUNC_ERROR_TEXT = 'Expected a function';
 /** Used to compose bitmasks for function metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    CURRY_FLAG = 8,
+    CURRY_RIGHT_FLAG = 16,
+    PARTIAL_FLAG = 32,
+var WRAP_BIND_FLAG = 1,
+    WRAP_BIND_KEY_FLAG = 2,
+    WRAP_CURRY_FLAG = 8,
+    WRAP_CURRY_RIGHT_FLAG = 16,
+    WRAP_PARTIAL_FLAG = 32,
+    WRAP_PARTIAL_RIGHT_FLAG = 64;
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMax = Math.max;
  * @private
  * @param {Function|string} func The function or method name to wrap.
  * @param {number} bitmask The bitmask flags.
+ *  The bitmask may be composed of the following flags:
+ *     1 - `_.bind`
+ *     2 - `_.bindKey`
+ *     4 - `_.curry` or `_.curryRight` of a bound function
+ *     8 - `_.curry`
+ *    16 - `_.curryRight`
+ *    32 - `_.partial`
+ *    64 - `_.partialRight`
+ *   128 - `_.rearg`
+ *   256 - `_.ary`
+ *    1 - `_.bind`
+ *    2 - `_.bindKey`
+ *    4 - `_.curry` or `_.curryRight` of a bound function
+ *    8 - `_.curry`
+ *   16 - `_.curryRight`
+ *   32 - `_.partial`
+ *   64 - `_.partialRight`
+ *  128 - `_.rearg`
+ *  256 - `_.ary`
+ *  512 - `_.flip`
  * @param {*} [thisArg] The `this` binding of `func`.
  * @param {Array} [partials] The arguments to be partially applied.
  * @param {Array} [holders] The `partials` placeholder indexes.
  * @returns {Function} Returns the new wrapped function.
  */
 function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
+  var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
   if (!isBindKey && typeof func != 'function') {
     throw new TypeError(FUNC_ERROR_TEXT);
+  }
   var length = partials ? partials.length : 0;
   if (!length) {
+    bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
     partials = holders = undefined;
+  }
   ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
   arity = arity === undefined ? arity : toInteger(arity);
   length -= holders ? holders.length : 0;
+  if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
     var partialsRight = partials,
         holdersRight = holders;
     ? (isBindKey ? 0 : func.length)
     : nativeMax(newData[9] - length, 0);
+  if (!arity && bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG)) {
+  if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
+    bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
+  }
+  if (!bitmask || bitmask == WRAP_BIND_FLAG) {
     var result = createBind(func, bitmask, thisArg);
+  } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
     result = createCurry(func, bitmask, arity);
+  } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
     result = createPartial(func, bitmask, thisArg, partials);
   } else {
     result = createHybrid.apply(undefined, newData);

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

@@ -3,7 +3,7 @@
3	root = require('./_root');	3	root = require('./_root');
4		4
5	/** Used to compose bitmasks for function metadata. */	5	/** Used to compose bitmasks for function metadata. */
6	var BIND_FLAG = 1;	6	var WRAP_BIND_FLAG = 1;
7		7
8	/**	8	/**
9	* Creates a function that wraps `func` to invoke it with the `this` binding	9	* Creates a function that wraps `func` to invoke it with the `this` binding
@@ -18,7 +18,7 @@
18	* @returns {Function} Returns the new wrapped function.	18	* @returns {Function} Returns the new wrapped function.
19	*/	19	*/
20	function createPartial(func, bitmask, thisArg, partials) {	20	function createPartial(func, bitmask, thisArg, partials) {
21	var isBind = bitmask & BIND_FLAG,	21	var isBind = bitmask & WRAP_BIND_FLAG,
22	Ctor = createCtor(func);	22	Ctor = createCtor(func);
23		23
24	function wrapper() {	24	function wrapper() {

 var baseClone = require('./_baseClone'),
     baseIteratee = require('./_baseIteratee');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
 /**
  * Creates a function that invokes `func` with the arguments of the created
  * function. If `func` is a property name, the created function returns the
  * // => ['def']
  */
 function iteratee(func) {
-  return baseIteratee(typeof func == 'function' ? func : baseClone(func, true));
+  return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
 }
 module.exports = iteratee;

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

 var FUNC_ERROR_TEXT = 'Expected a function';
 /** Used to compose bitmasks for function metadata. */
+var CURRY_FLAG = 8,
+    PARTIAL_FLAG = 32,
+    ARY_FLAG = 128,
+var WRAP_CURRY_FLAG = 8,
+    WRAP_PARTIAL_FLAG = 32,
+    WRAP_ARY_FLAG = 128,
+    WRAP_REARG_FLAG = 256;
 /**
  * Creates a `_.flow` or `_.flowRight` function.
           data = funcName == 'wrapper' ? getData(func) : undefined;
       if (data && isLaziable(data[0]) &&
+            data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
             !data[4].length && data[9] == 1
           ) {
         wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);

Comparinglodash@4.16.6

Comparinglodash@4.16.6

Source

npm diff

Options

Bundlephobia

Packagephobia

Packagephobia

+++0---0

package.json +++1---2

README.md +++2---2

clone.js +++4---1

cloneDeep.js +++5---1

cloneDeepWith.js +++5---1

bindKey.js +++5---5

cloneWith.js +++4---1

bind.js +++4---4

at.js +++1---1

conforms.js +++4---1

core.js +++43---48

ary.js +++2---2

curry.js +++2---2

curryRight.js +++2---2

_updateWrapDetails.js +++18---18

_unicodeWords.js +++5---3

_unicodeToArray.js +++5---3

deburr.js +++5---3

_unicodeSize.js +++5---3

_nodeUtil.js +++1---1

flip.js +++2---2

_mergeData.js +++13---13

_hasUnicode.js +++5---3

_getSymbolsIn.js +++1---2

_getSymbols.js +++1---1

isEqualWith.js +++1---1

isNative.js +++1---1

_equalObjects.js +++7---8

_equalByTag.js +++9---10

_equalArrays.js +++10---11

_createWrap.js +++24---25

_createRecurry.js +++11---11

_createPartial.js +++2---2

iteratee.js +++4---1

_createHybrid.js +++11---11

_createFlow.js +++5---5

lodash.js +++217---168

_createBind.js +++2---2

matches.js +++4---1

_copySymbols.js +++1---1

matchesProperty.js +++4---1

_cloneSet.js +++4---1

_cloneMap.js +++4---1

omit.js +++24---12

_baseUnset.js +++1---1

partial.js +++2---2

partialRight.js +++2---2

pick.js +++3---3

rearg.js +++2---2

_basePickBy.js +++9---8

_basePick.js +++6---5

_baseMatchesProperty.js +++4---4

_baseIsMatch.js +++4---4

_baseIsEqualDeep.js +++10---11

_baseIsEqual.js +++5---6

spread.js +++4---0

_baseClone.js +++28---8

_baseAt.js +++1---1

wrapperAt.js +++1---1

fp/_mapping.js +++6---6

_copySymbolsIn.js +++16---0

_baseAssignIn.js +++17---0

Source

Packagephobia

Comparing
`lodash@4.16.6`

Comparing
`lodash@4.16.6`

 var baseClone = require('./_baseClone'),
     baseMatches = require('./_baseMatches');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
 /**
  * Creates a function that performs a partial deep comparison between a given
  * object and `source`, returning `true` if the given object has equivalent
  * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
  */
 function matches(source) {
-  return baseMatches(baseClone(source, true));
+  return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
 }
 module.exports = matches;

@@ -2,7 +2,7 @@
2	getSymbols = require('./_getSymbols');	2	getSymbols = require('./_getSymbols');
3		3
4	/**	4	/**
5	* Copies own symbol properties of `source` to `object`.	5	* Copies own symbols of `source` to `object`.
6	*	6	*
7	* @private	7	* @private
8	* @param {Object} source The object to copy symbols from.	8	* @param {Object} source The object to copy symbols from.

 var baseClone = require('./_baseClone'),
     baseMatchesProperty = require('./_baseMatchesProperty');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
 /**
  * Creates a function that performs a partial deep comparison between the
  * value at `path` of a given object to `srcValue`, returning `true` if the
  * // => { 'a': 4, 'b': 5, 'c': 6 }
  */
 function matchesProperty(path, srcValue) {
-  return baseMatchesProperty(path, baseClone(srcValue, true));
+  return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
 }
 module.exports = matchesProperty;

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

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

@@ -1,21 +1,26 @@
1	var arrayMap = require('./_arrayMap'),
2	baseDifference = require('./_baseDifference'),
3	basePick = require('./_basePick'),	1	var baseClone = require('./_baseClone'),
		2	baseUnset = require('./_baseUnset'),
		3	copyObject = require('./_copyObject'),
4	flatRest = require('./_flatRest'),	4	flatRest = require('./_flatRest'),
5	getAllKeysIn = require('./_getAllKeysIn'),
6	toKey = require('./_toKey');	5	getAllKeysIn = require('./_getAllKeysIn');
7		6
		7	/** Used to compose bitmasks for cloning. */
		8	var CLONE_DEEP_FLAG = 1,
		9	CLONE_FLAT_FLAG = 2,
		10	CLONE_SYMBOLS_FLAG = 4;
		11
8	/**	12	/**
9	* The opposite of `_.pick`; this method creates an object composed of the	13	* The opposite of `_.pick`; this method creates an object composed of the
10	* own and inherited enumerable string keyed properties of `object` that are
11	* not omitted.	14	* own and inherited enumerable property paths of `object` that are not omitted.
12	*	15	*
		16	* Note: This method is considerably slower than `_.pick`.
		17	*
13	* @static	18	* @static
14	* @since 0.1.0	19	* @since 0.1.0
15	* @memberOf _	20	* @memberOf _
16	* @category Object	21	* @category Object
17	* @param {Object} object The source object.	22	* @param {Object} object The source object.
18	* @param {...(string\|string[])} [props] The property identifiers to omit.	23	* @param {...(string\|string[])} [paths] The property paths to omit.
19	* @returns {Object} Returns the new object.	24	* @returns {Object} Returns the new object.
20	* @example	25	* @example
21	*	26	*
@@ -24,12 +29,19 @@
24	* _.omit(object, ['a', 'c']);	29	* _.omit(object, ['a', 'c']);
25	* // => { 'b': '2' }	30	* // => { 'b': '2' }
26	*/	31	*/
27	var omit = flatRest(function(object, props) {	32	var omit = flatRest(function(object, paths) {
		33	var result = {};
28	if (object == null) {	34	if (object == null) {
29	return {};	35	return result;
30	}	36	}
31	props = arrayMap(props, toKey);
32	return basePick(object, baseDifference(getAllKeysIn(object), props));	37	copyObject(object, getAllKeysIn(object), result);
		38	result = baseClone(result, CLONE_DEEP_FLAG \| CLONE_FLAT_FLAG \| CLONE_SYMBOLS_FLAG);
		39
		40	var length = paths.length;
		41	while (length--) {
		42	baseUnset(result, paths[length]);
		43	}
		44	return result;
33	});	45	});
34		46
35	module.exports = omit;	47	module.exports = omit;

@@ -4,7 +4,7 @@
4	replaceHolders = require('./_replaceHolders');	4	replaceHolders = require('./_replaceHolders');
5		5
6	/** Used to compose bitmasks for function metadata. */	6	/** Used to compose bitmasks for function metadata. */
7	var PARTIAL_FLAG = 32;	7	var WRAP_PARTIAL_FLAG = 32;
8		8
9	/**	9	/**
10	* Creates a function that invokes `func` with `partials` prepended to the	10	* Creates a function that invokes `func` with `partials` prepended to the
@@ -41,7 +41,7 @@
41	*/	41	*/
42	var partial = baseRest(function(func, partials) {	42	var partial = baseRest(function(func, partials) {
43	var holders = replaceHolders(partials, getHolder(partial));	43	var holders = replaceHolders(partials, getHolder(partial));
44	return createWrap(func, PARTIAL_FLAG, undefined, partials, holders);	44	return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
45	});	45	});
46		46
47	// Assign default placeholders.	47	// Assign default placeholders.

  * @memberOf _
  * @category Object
  * @param {Object} object The source object.
- * @param {...(string|string[])} [props] The property identifiers to pick.
+ * @param {...(string|string[])} [paths] The property paths to pick.
  * @returns {Object} Returns the new object.
  * @example
  *
  * _.pick(object, ['a', 'c']);
  * // => { 'a': 1, 'c': 3 }
  */
-var pick = flatRest(function(object, props) {
-  return object == null ? {} : basePick(object, arrayMap(props, toKey));
+var pick = flatRest(function(object, paths) {
+  return object == null ? {} : basePick(object, arrayMap(paths, toKey));
 });
 module.exports = pick;

@@ -2,7 +2,7 @@
2	flatRest = require('./_flatRest');	2	flatRest = require('./_flatRest');
3		3
4	/** Used to compose bitmasks for function metadata. */	4	/** Used to compose bitmasks for function metadata. */
5	var REARG_FLAG = 256;	5	var WRAP_REARG_FLAG = 256;
6		6
7	/**	7	/**
8	* Creates a function that invokes `func` with arguments arranged according	8	* Creates a function that invokes `func` with arguments arranged according
@@ -27,7 +27,7 @@
27	* // => ['a', 'b', 'c']	27	* // => ['a', 'b', 'c']
28	*/	28	*/
29	var rearg = flatRest(function(func, indexes) {	29	var rearg = flatRest(function(func, indexes) {
30	return createWrap(func, REARG_FLAG, undefined, undefined, undefined, indexes);	30	return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
31	});	31	});
32		32
33	module.exports = rearg;	33	module.exports = rearg;

@@ -1,25 +1,26 @@
1	var baseAssignValue = require('./_baseAssignValue');	1	var baseGet = require('./_baseGet'),
		2	baseSet = require('./_baseSet');
2		3
3	/**	4	/**
4	* The base implementation of `_.pickBy` without support for iteratee shorthands.	5	* The base implementation of `_.pickBy` without support for iteratee shorthands.
5	*	6	*
6	* @private	7	* @private
7	* @param {Object} object The source object.	8	* @param {Object} object The source object.
8	* @param {string[]} props The property identifiers to pick from.	9	* @param {string[]} paths The property paths to pick.
9	* @param {Function} predicate The function invoked per property.	10	* @param {Function} predicate The function invoked per property.
10	* @returns {Object} Returns the new object.	11	* @returns {Object} Returns the new object.
11	*/	12	*/
12	function basePickBy(object, props, predicate) {	13	function basePickBy(object, paths, predicate) {
13	var index = -1,	14	var index = -1,
14	length = props.length,	15	length = paths.length,
15	result = {};	16	result = {};
16		17
17	while (++index < length) {	18	while (++index < length) {
18	var key = props[index],
19	value = object[key];	19	var path = paths[index],
		20	value = baseGet(object, path);
20		21
21	if (predicate(value, key)) {
22	baseAssignValue(result, key, value);	22	if (predicate(value, path)) {
		23	baseSet(result, path, value);
23	}	24	}
24	}	25	}
25	return result;	26	return result;