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

@@ -1,6 +1,6 @@
1	{	1	{
2	"name": "lodash",	2	"name": "lodash",
3	"version": "4.17.0",	3	"version": "4.17.19",
4	"description": "Lodash modular utilities.",	4	"description": "Lodash modular utilities.",
5	"keywords": "modules, stdlib, util",	5	"keywords": "modules, stdlib, util",
6	"homepage": "https://lodash.com/",	6	"homepage": "https://lodash.com/",
@@ -8,10 +8,10 @@
8	"icon": "https://lodash.com/icon.svg",	8	"icon": "https://lodash.com/icon.svg",
9	"license": "MIT",	9	"license": "MIT",
10	"main": "lodash.js",	10	"main": "lodash.js",
11	"author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",	11	"author": "John-David Dalton <john.david.dalton@gmail.com>",
12	"contributors": [	12	"contributors": [
13	"John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
14	"Mathias Bynens <mathias@qiwi.be> (https://mathiasbynens.be/)"	13	"John-David Dalton <john.david.dalton@gmail.com>",
		14	"Mathias Bynens <mathias@qiwi.be>"
15	],	15	],
16	"scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" }	16	"scripts": { "test": "echo \"See https://travis-ci.org/lodash-archive/lodash-cli for testing details.\"" }
17	}	17	}

@@ -1,4 +1,4 @@
1	# lodash v4.17.0	1	# lodash v4.17.19
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,12 +28,12 @@
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.17.0-npm) for more details.	31	See the [package source](https://github.com/lodash/lodash/tree/4.17.19-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.
35		35
36	## Support	36	## Support
37		37
38	Tested in Chrome 53-54, Firefox 48-49, IE 11, Edge 14, Safari 9-10, Node.js 6-7, & PhantomJS 2.1.1.<br>	38	Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.<br>
39	Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.	39	Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.

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

     reOptMod = rsModifier + '?',
     rsOptVar = '[' + rsVarRange + ']?',
     rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+    rsOrdLower = '\\d*(?:(?:1st|2nd|3rd|(?![123])\\dth)\\b)',
+    rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
+    rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
     rsSeq = rsOptVar + reOptMod + rsOptJoin,
     rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;

   function remainingWait(time) {
     var timeSinceLastCall = time - lastCallTime,
         timeSinceLastInvoke = time - lastInvokeTime,
-        result = wait - timeSinceLastCall;
+        timeWaiting = wait - timeSinceLastCall;
-    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+    return maxing
+      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+      : timeWaiting;
   }
   function shouldInvoke(time) {
       }
       if (maxing) {
         // Handle invocations in a tight loop.
+        clearTimeout(timerId);
         timerId = setTimeout(timerExpired, wait);
         return invokeFunc(lastCallTime);
       }

+var apply = require('./_apply'),
+    assignInDefaults = require('./_assignInDefaults'),
+    assignInWith = require('./assignInWith'),
+var baseRest = require('./_baseRest'),
+    eq = require('./eq'),
+    isIterateeCall = require('./_isIterateeCall'),
+    keysIn = require('./keysIn');
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
 /**
  * Assigns own and inherited enumerable string keyed properties of source
  * objects to the destination object for all destination properties that
  * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
  * // => { 'a': 1, 'b': 2 }
  */
+var defaults = baseRest(function(args) {
+  args.push(undefined, assignInDefaults);
+var defaults = baseRest(function(object, sources) {
+  object = Object(object);
+  var index = -1;
+  var length = sources.length;
+  var guard = length > 2 ? sources[2] : undefined;
+  if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+    length = 1;
+  }
+  while (++index < length) {
+    var source = sources[index];
+    var props = keysIn(source);
+    var propsIndex = -1;
+    var propsLength = props.length;
+    while (++propsIndex < propsLength) {
+      var key = props[propsIndex];
+      var value = object[key];
+      if (value === undefined ||
+          (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+        object[key] = source[key];
+      }
+    }
+  }
+  return object;
 });
 module.exports = defaults;

@@ -1,9 +1,7 @@
1	var memoizeCapped = require('./_memoizeCapped'),
2	toString = require('./toString');	1	var memoizeCapped = require('./_memoizeCapped');
3		2
4	/** Used to match property names within property paths. */	3	/** Used to match property names within property paths. */
5	var reLeadingDot = /^\./,
6	rePropName = /[^.[\]]+\|\[(?:(-?\d+(?:\.\d+)?)\|(["'])((?:(?!\2)[^\\]\|\\.)*?)\2)\]\|(?=(?:\.\|\[\])(?:\.\|\[\]\|$))/g;	4	var rePropName = /[^.[\]]+\|\[(?:(-?\d+(?:\.\d+)?)\|(["'])((?:(?!\2)[^\\]\|\\.)*?)\2)\]\|(?=(?:\.\|\[\])(?:\.\|\[\]\|$))/g;
7		5
8	/** Used to match backslashes in property paths. */	6	/** Used to match backslashes in property paths. */
9	var reEscapeChar = /\\(\\)?/g;	7	var reEscapeChar = /\\(\\)?/g;
@@ -16,14 +14,12 @@
16	* @returns {Array} Returns the property path array.	14	* @returns {Array} Returns the property path array.
17	*/	15	*/
18	var stringToPath = memoizeCapped(function(string) {	16	var stringToPath = memoizeCapped(function(string) {
19	string = toString(string);
20
21	var result = [];	17	var result = [];
22	if (reLeadingDot.test(string)) {	18	if (string.charCodeAt(0) === 46 /* . */) {
23	result.push('');	19	result.push('');
24	}	20	}
25	string.replace(rePropName, function(match, number, quote, string) {
26	result.push(quote ? string.replace(reEscapeChar, '$1') : (number \|\| match));	21	string.replace(rePropName, function(match, number, quote, subString) {
		22	result.push(quote ? subString.replace(reEscapeChar, '$1') : (number \|\| match));
27	});	23	});
28	return result;	24	return result;
29	});	25	});

@@ -1,6 +1,6 @@
1	var apply = require('./_apply'),	1	var apply = require('./_apply'),
2	baseRest = require('./_baseRest'),	2	baseRest = require('./_baseRest'),
3	mergeDefaults = require('./_mergeDefaults'),	3	customDefaultsMerge = require('./_customDefaultsMerge'),
4	mergeWith = require('./mergeWith');	4	mergeWith = require('./mergeWith');
5		5
6	/**	6	/**
@@ -23,7 +23,7 @@
23	* // => { 'a': { 'b': 2, 'c': 3 } }	23	* // => { 'a': { 'b': 2, 'c': 3 } }
24	*/	24	*/
25	var defaultsDeep = baseRest(function(args) {	25	var defaultsDeep = baseRest(function(args) {
26	args.push(undefined, mergeDefaults);	26	args.push(undefined, customDefaultsMerge);
27	return apply(mergeWith, undefined, args);	27	return apply(mergeWith, undefined, args);
28	});	28	});
29		29

@@ -10,7 +10,7 @@
10	* @returns {*} Returns the parent value.	10	* @returns {*} Returns the parent value.
11	*/	11	*/
12	function parent(object, path) {	12	function parent(object, path) {
13	return path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));	13	return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
14	}	14	}
15		15
16	module.exports = parent;	16	module.exports = parent;

 /** Used to access faster Node.js helpers. */
 var nodeUtil = (function() {
   try {
+    // Use `util.types` for Node.js 10+.
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+    if (types) {
+      return types;
+    }
+    // Legacy `process.binding('util')` for Node.js < 10.
     return freeProcess && freeProcess.binding && freeProcess.binding('util');
   } catch (e) {}
 }());

     getView = require('./_getView'),
     isArray = require('./isArray');
-/** Used as the size to enable large array optimizations. */
-var LARGE_ARRAY_SIZE = 200;
 /** Used to indicate the type of lazy iteratees. */
 var LAZY_FILTER_FLAG = 1,
     LAZY_MAP_FLAG = 2;
       resIndex = 0,
       takeCount = nativeMin(length, this.__takeCount__);
-  if (!isArr || arrLength < LARGE_ARRAY_SIZE ||
-      (arrLength == length && takeCount == length)) {
+  if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
     return baseWrapperValue(array, this.__actions__);
   }
   var result = [];

  * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
  */
 function isIndex(value, length) {
+  var type = typeof value;
   length = length == null ? MAX_SAFE_INTEGER : length;
   return !!length &&
+    (typeof value == 'number' || reIsUint.test(value)) &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
 module.exports = isIndex;

 var cloneArrayBuffer = require('./_cloneArrayBuffer'),
     cloneDataView = require('./_cloneDataView'),
-    cloneMap = require('./_cloneMap'),
     cloneRegExp = require('./_cloneRegExp'),
-    cloneSet = require('./_cloneSet'),
     cloneSymbol = require('./_cloneSymbol'),
     cloneTypedArray = require('./_cloneTypedArray');
  * Initializes an object clone based on its `toStringTag`.
  *
  * **Note:** This function only supports cloning values with tags of
- * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
  *
  * @private
  * @param {Object} object The object to clone.
  * @param {string} tag The `toStringTag` of the object to clone.
- * @param {Function} cloneFunc The function to clone values.
  * @param {boolean} [isDeep] Specify a deep clone.
  * @returns {Object} Returns the initialized clone.
  */
-function initCloneByTag(object, tag, cloneFunc, isDeep) {
+function initCloneByTag(object, tag, isDeep) {
   var Ctor = object.constructor;
   switch (tag) {
     case arrayBufferTag:
       return cloneTypedArray(object, isDeep);
     case mapTag:
-      return cloneMap(object, isDeep, cloneFunc);
+      return new Ctor;
     case numberTag:
     case stringTag:
       return cloneRegExp(object);
     case setTag:
-      return cloneSet(object, isDeep, cloneFunc);
+      return new Ctor;
     case symbolTag:
       return cloneSymbol(object);

@@ -13,7 +13,7 @@
13	*/	13	*/
14	function initCloneArray(array) {	14	function initCloneArray(array) {
15	var length = array.length,	15	var length = array.length,
16	result = array.constructor(length);	16	result = new array.constructor(length);
17		17
18	// Add properties assigned by `RegExp#exec`.	18	// Add properties assigned by `RegExp#exec`.
19	if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {	19	if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {

@@ -17,7 +17,7 @@
17	*/	17	*/
18	function hashHas(key) {	18	function hashHas(key) {
19	var data = this.__data__;	19	var data = this.__data__;
20	return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);	20	return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
21	}	21	}
22		22
23	module.exports = hashHas;	23	module.exports = hashHas;

@@ -1,5 +1,5 @@
1	/** Used to detect strings that need a more robust regexp to match words. */	1	/** Used to detect strings that need a more robust regexp to match words. */
2	var reHasUnicodeWord = /[a-z][A-Z]\|[A-Z]{2,}[a-z]\|[0-9][a-zA-Z]\|[a-zA-Z][0-9]\|[^a-zA-Z0-9 ]/;	2	var reHasUnicodeWord = /[a-z][A-Z]\|[A-Z]{2}[a-z]\|[0-9][a-zA-Z]\|[a-zA-Z][0-9]\|[^a-zA-Z0-9 ]/;
3		3
4	/**	4	/**
5	* Checks if `string` contains a word composed of Unicode symbols.	5	* Checks if `string` contains a word composed of Unicode symbols.

@@ -8,7 +8,7 @@
8	* date objects, error objects, maps, numbers, `Object` objects, regexes,	8	* date objects, error objects, maps, numbers, `Object` objects, regexes,
9	* sets, strings, symbols, and typed arrays. `Object` objects are compared	9	* sets, strings, symbols, and typed arrays. `Object` objects are compared
10	* by their own, not inherited, enumerable properties. Functions and DOM	10	* by their own, not inherited, enumerable properties. Functions and DOM
11	* nodes are not supported.	11	* nodes are compared by strict equality, i.e. `===`.
12	*	12	*
13	* @static	13	* @static
14	* @memberOf _	14	* @memberOf _

@@ -1,4 +1,4 @@
1	var keys = require('./keys');	1	var getAllKeys = require('./_getAllKeys');
2		2
3	/** Used to compose bitmasks for value comparisons. */	3	/** Used to compose bitmasks for value comparisons. */
4	var COMPARE_PARTIAL_FLAG = 1;	4	var COMPARE_PARTIAL_FLAG = 1;
@@ -24,9 +24,9 @@
24	*/	24	*/
25	function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {	25	function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
26	var isPartial = bitmask & COMPARE_PARTIAL_FLAG,	26	var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
27	objProps = keys(object),	27	objProps = getAllKeys(object),
28	objLength = objProps.length,	28	objLength = objProps.length,
29	othProps = keys(other),	29	othProps = getAllKeys(other),
30	othLength = othProps.length;	30	othLength = othProps.length;
31		31
32	if (objLength != othLength && !isPartial) {	32	if (objLength != othLength && !isPartial) {

@@ -83,7 +83,7 @@
83	thisArg = newData[2];	83	thisArg = newData[2];
84	partials = newData[3];	84	partials = newData[3];
85	holders = newData[4];	85	holders = newData[4];
86	arity = newData[9] = newData[9] == null	86	arity = newData[9] = newData[9] === undefined
87	? (isBindKey ? 0 : func.length)	87	? (isBindKey ? 0 : func.length)
88	: nativeMax(newData[9] - length, 0);	88	: nativeMax(newData[9] - length, 0);
89		89

     createInverter = require('./_createInverter'),
     identity = require('./identity');
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
 /**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+/**
  * Creates an object composed of the inverted keys and values of `object`.
  * If `object` contains duplicate values, subsequent values overwrite
  * property assignments of previous values.
  * // => { '1': 'c', '2': 'b' }
  */
 var invert = createInverter(function(result, value, key) {
+  if (value != null &&
+      typeof value.toString != 'function') {
+    value = nativeObjectToString.call(value);
+  }
   result[value] = key;
 }, constant(identity));

     baseEach = require('./_baseEach'),
     baseInvoke = require('./_baseInvoke'),
     baseRest = require('./_baseRest'),
-    isArrayLike = require('./isArrayLike'),
-    isKey = require('./_isKey');
+    isArrayLike = require('./isArrayLike');
 /**
  * Invokes the method at `path` of each element in `collection`, returning
 var invokeMap = baseRest(function(collection, path, args) {
   var index = -1,
       isFunc = typeof path == 'function',
-      isProp = isKey(path),
       result = isArrayLike(collection) ? Array(collection.length) : [];
   baseEach(collection, function(value) {
-    var func = isFunc ? path : ((isProp && value != null) ? value[path] : undefined);
-    result[++index] = func ? apply(func, value, args) : baseInvoke(value, path, args);
+    result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
   });
   return result;
 });

     isArguments = require('./isArguments'),
     isArray = require('./isArray'),
     isIndex = require('./_isIndex'),
-    isKey = require('./_isKey'),
     isLength = require('./isLength'),
     toKey = require('./_toKey');
  * @returns {boolean} Returns `true` if `path` exists, else `false`.
  */
 function hasPath(object, path, hasFunc) {
-  path = isKey(path, object) ? [path] : castPath(path);
+  path = castPath(path, object);
   var index = -1,
       length = path.length,

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

+var root = require('./_root'),
+    toInteger = require('./toInteger'),
     toNumber = require('./toNumber'),
     toString = require('./toString');
 /* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsFinite = root.isFinite,
+    nativeMin = Math.min;
 /**
  * Creates a function like `_.round`.
   var func = Math[methodName];
   return function(number, precision) {
     number = toNumber(number);
+    precision = nativeMin(toInteger(precision), 292);
+    precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
+    if (precision && nativeIsFinite(number)) {
       // Shift with exponential notation to avoid floating-point issues.
       // See [MDN](https://mdn.io/round#Examples) for more details.
       var pair = (toString(number) + 'e').split('e'),

     isArray = require('./isArray'),
     isLaziable = require('./_isLaziable');
-/** Used as the size to enable large array optimizations. */
-var LARGE_ARRAY_SIZE = 200;
 /** Error message constants. */
 var FUNC_ERROR_TEXT = 'Expected a function';
       var args = arguments,
           value = args[0];
-      if (wrapper && args.length == 1 &&
-          isArray(value) && value.length >= LARGE_ARRAY_SIZE) {
+      if (wrapper && args.length == 1 && isArray(value)) {
         return wrapper.plant(value).value();
       }
       var index = 0,

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

+var arrayMap = require('./_arrayMap'),
+    baseClone = require('./_baseClone'),
     baseUnset = require('./_baseUnset'),
+    castPath = require('./_castPath'),
     copyObject = require('./_copyObject'),
+    customOmitClone = require('./_customOmitClone'),
     flatRest = require('./_flatRest'),
     getAllKeysIn = require('./_getAllKeysIn');
   if (object == null) {
     return result;
+  }
+  var isDeep = false;
+  paths = arrayMap(paths, function(path) {
+    path = castPath(path, object);
+    isDeep || (isDeep = path.length > 1);
+    return path;
+  });
   copyObject(object, getAllKeysIn(object), result);
+  result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG);
+  if (isDeep) {
+    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+  }
   var length = paths.length;
   while (length--) {
     baseUnset(result, paths[length]);

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

+var arrayMap = require('./_arrayMap'),
+    basePick = require('./_basePick'),
+    flatRest = require('./_flatRest'),
+var basePick = require('./_basePick'),
+    flatRest = require('./_flatRest');
 /**
  * Creates an object composed of the picked `object` properties.
  * // => { 'a': 1, 'c': 3 }
  */
 var pick = flatRest(function(object, paths) {
+  return object == null ? {} : basePick(object, paths);
 });
 module.exports = pick;

Comparinglodash@4.17.011/14/2016...lodash@4.17.197/8/2020

Bundlephobia

Packagephobia

npm diff

Options

+++0---0

package.json +++5---5

README.md +++3---3

LICENSE +++1---1

core.js +++89---102

_unicodeWords.js +++2---2

debounce.js +++5---2

defaults.js +++39---7

_stringToPath.js +++5---9

defaultsDeep.js +++2---2

_parent.js +++1---1

_nodeUtil.js +++8---0

_mergeDefaults.js +++0---27

_lazyValue.js +++1---5

_isIndex.js +++5---2

_initCloneByTag.js +++4---7

_initCloneArray.js +++1---1

_hashHas.js +++1---1

invert.js +++15---0

invertBy.js +++12---0

invokeMap.js +++2---5

_hasUnicodeWord.js +++1---1

_hasPath.js +++1---2

_getSymbols.js +++16---2

isEqual.js +++1---1

_equalObjects.js +++3---3

_createWrap.js +++1---1

_createRound.js +++6---4

_createFlow.js +++1---5

lodash.js +++330---236

_cloneSet.js +++0---22

_cloneMap.js +++0---22

_castPath.js +++9---3

omit.js +++13---3

_baseUnset.js +++2---11

pick.js +++3---5

pickBy.js +++12---2

_baseSet.js +++1---2

_basePullAt.js +++4---17

_basePickBy.js +++3---2

_basePick.js +++0---1

result.js +++2---3

_baseMergeDeep.js +++4---3

_baseMerge.js +++4---3

_baseIsEqualDeep.js +++5---10

_baseIsEqual.js +++1---2

spread.js +++1---5

_baseInvoke.js +++3---7

startsWith.js +++4---1

_baseGetTag.js +++1---2

_baseGet.js +++1---2

takeWhile.js +++1---1

template.js +++21---6

templateSettings.js +++2---2

_baseClone.js +++13---1

toPath.js +++3---2

toSafeInteger.js +++3---1

_assignInDefaults.js +++0---27

_addSetEntry.js +++0---15

_addMapEntry.js +++0---15

wrapperLodash.js +++3---3

fp/_util.js +++2---1

fp/_mapping.js +++2---11

fp/_baseConvert.js +++54---21

_customDefaultsAssignIn.js +++29---0

_customDefaultsMerge.js +++28---0

_customOmitClone.js +++16---0

_safeGet.js +++21---0

Comparing
`lodash@4.17.0`11/14/2016
`...`
`lodash@4.17.19`7/8/2020

+var arrayMap = require('./_arrayMap'),
+    baseIteratee = require('./_baseIteratee'),
     basePickBy = require('./_basePickBy'),
     getAllKeysIn = require('./_getAllKeysIn');
  * // => { 'a': 1, 'c': 3 }
  */
 function pickBy(object, predicate) {
+  if (object == null) {
+    return {};
+  }
+  var props = arrayMap(getAllKeysIn(object), function(prop) {
+    return [prop];
+  });
+  predicate = baseIteratee(predicate);
+  return basePickBy(object, props, function(value, path) {
+    return predicate(value, path[0]);
+  });
+}
 module.exports = pickBy;

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

 var baseGet = require('./_baseGet'),
-    baseSet = require('./_baseSet');
+    baseSet = require('./_baseSet'),
+    castPath = require('./_castPath');
 /**
  * The base implementation of  `_.pickBy` without support for iteratee shorthands.
         value = baseGet(object, path);
     if (predicate(value, path)) {
-      baseSet(result, path, value);
+      baseSet(result, castPath(path, object), value);
     }
   }
   return result;

@@ -11,7 +11,6 @@
11	* @returns {Object} Returns the new object.	11	* @returns {Object} Returns the new object.
12	*/	12	*/
13	function basePick(object, paths) {	13	function basePick(object, paths) {
14	object = Object(object);
15	return basePickBy(object, paths, function(value, path) {	14	return basePickBy(object, paths, function(value, path) {
16	return hasIn(object, path);	15	return hasIn(object, path);
17	});	16	});

     isObject = require('./isObject'),
     isPlainObject = require('./isPlainObject'),
     isTypedArray = require('./isTypedArray'),
+    safeGet = require('./_safeGet'),
     toPlainObject = require('./toPlainObject');
 /**
  *  counterparts.
  */
 function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
-  var objValue = object[key],
-      srcValue = source[key],
+  var objValue = safeGet(object, key),
+      srcValue = safeGet(source, key),
       stacked = stack.get(srcValue);
   if (stacked) {
       if (isArguments(objValue)) {
         newValue = toPlainObject(objValue);
       }
-      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+      else if (!isObject(objValue) || isFunction(objValue)) {
         newValue = initCloneObject(srcValue);
       }
     }

     baseFor = require('./_baseFor'),
     baseMergeDeep = require('./_baseMergeDeep'),
     isObject = require('./isObject'),
-    keysIn = require('./keysIn');
+    keysIn = require('./keysIn'),
+    safeGet = require('./_safeGet');
 /**
  * The base implementation of `_.merge` without support for multiple sources.
     return;
   }
   baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack);
     if (isObject(srcValue)) {
-      stack || (stack = new Stack);
       baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
     }
     else {
       var newValue = customizer
-        ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
         : undefined;
       if (newValue === undefined) {

 function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
   var objIsArr = isArray(object),
       othIsArr = isArray(other),
       objTag = arrayTag,
       objTag = objIsArr ? arrayTag : getTag(object),
       othTag = othIsArr ? arrayTag : getTag(other);
   if (!objIsArr) {
     objTag = getTag(object);
     objTag = objTag == argsTag ? objectTag : objTag;
   }
   if (!othIsArr) {
     othTag = getTag(other);
     othTag = othTag == argsTag ? objectTag : othTag;
   objTag = objTag == argsTag ? objectTag : objTag;
   othTag = othTag == argsTag ? objectTag : othTag;
   var objIsObj = objTag == objectTag,
       othIsObj = othTag == objectTag,
       isSameTag = objTag == othTag;

 var baseIsEqualDeep = require('./_baseIsEqualDeep'),
-    isObject = require('./isObject'),
     isObjectLike = require('./isObjectLike');
 /**
   if (value === other) {
     return true;
   }
-  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
     return value !== value && other !== other;
   }
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);

   if (typeof func != 'function') {
     throw new TypeError(FUNC_ERROR_TEXT);
   }
-  start = start === undefined ? 0 : nativeMax(toInteger(start), 0);
+  start = start == null ? 0 : nativeMax(toInteger(start), 0);
   return baseRest(function(args) {
     var array = args[start],
-        lastIndex = args.length - 1,
         otherArgs = castSlice(args, 0, start);
     if (array) {
       arrayPush(otherArgs, array);
     }
-    if (start != lastIndex) {
-      arrayPush(otherArgs, castSlice(args, start + 1));
-    }
     return apply(func, this, otherArgs);
   });
 }

@@ -28,7 +28,10 @@
28	*/	28	*/
29	function startsWith(string, target, position) {	29	function startsWith(string, target, position) {
30	string = toString(string);	30	string = toString(string);
31	position = baseClamp(toInteger(position), 0, string.length);	31	position = position == null
		32	? 0
		33	: baseClamp(toInteger(position), 0, string.length);
		34
32	target = baseToString(target);	35	target = baseToString(target);
33	return string.slice(position, position + target.length) == target;	36	return string.slice(position, position + target.length) == target;
34	}	37	}