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

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

+# lodash v4.17.0
+# lodash v4.17.19
 The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
 var curryN = require('lodash/fp/curryN');
 ```
+See the [package source](https://github.com/lodash/lodash/tree/4.17.0-npm) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.17.19-npm) for more details.
 **Note:**<br>
 Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.
 ## Support
+Tested in Chrome 53-54, Firefox 48-49, IE 11, Edge 14, Safari 9-10, Node.js 6-7, & PhantomJS 2.1.1.<br>
+Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.<br>
 Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.

+Copyright JS Foundation and other contributors <https://js.foundation/>
+Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 Based on Underscore.js, copyright Jeremy Ashkenas,
 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)',
+    rsOrdUpper = '\\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'),
+    baseRest = require('./_baseRest');
+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);
+  return apply(assignInWith, undefined, args);
+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;

+var memoizeCapped = require('./_memoizeCapped'),
+    toString = require('./toString');
+var memoizeCapped = require('./_memoizeCapped');
 /** Used to match property names within property paths. */
+var reLeadingDot = /^\./,
+    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
 /** Used to match backslashes in property paths. */
 var reEscapeChar = /\\(\\)?/g;
  * @returns {Array} Returns the property path array.
  */
 var stringToPath = memoizeCapped(function(string) {
+  string = toString(string);
   var result = [];
+  if (reLeadingDot.test(string)) {
+  if (string.charCodeAt(0) === 46 /* . */) {
     result.push('');
+  }
+  string.replace(rePropName, function(match, number, quote, string) {
+    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
   });
   return result;
 });

 var apply = require('./_apply'),
     baseRest = require('./_baseRest'),
+    mergeDefaults = require('./_mergeDefaults'),
+    customDefaultsMerge = require('./_customDefaultsMerge'),
     mergeWith = require('./mergeWith');
 /**
  * // => { 'a': { 'b': 2, 'c': 3 } }
  */
 var defaultsDeep = baseRest(function(args) {
+  args.push(undefined, mergeDefaults);
+  args.push(undefined, customDefaultsMerge);
   return apply(mergeWith, undefined, args);
 });

  * @returns {*} Returns the parent value.
  */
 function parent(object, path) {
+  return path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
+  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
+}
 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)) &&
+    (value > -1 && value % 1 == 0 && value < length);
+    (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);

  */
 function initCloneArray(array) {
   var length = array.length,
+      result = array.constructor(length);
+      result = new array.constructor(length);
   // Add properties assigned by `RegExp#exec`.
   if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {

  */
 function hashHas(key) {
   var data = this.__data__;
+  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+}
 module.exports = hashHas;

@@ -2,7 +2,6 @@
2	2	isArguments = require('./isArguments'),
3	3	isArray = require('./isArray'),
4	4	isIndex = require('./_isIndex'),
5		isKey = require('./_isKey'),
6	5	isLength = require('./isLength'),
7	6	toKey = require('./_toKey');
8	7
@@ -16,7 +15,7 @@
16	15	* @returns {boolean} Returns `true` if `path` exists, else `false`.
17	16	*/
18	17	function hasPath(object, path, hasFunc) {
19		path = isKey(path, object) ? [path] : castPath(path);
	18	path = castPath(path, object);
20	19
21	20	var index = -1,
22	21	length = path.length,

@@ -1,7 +1,6 @@
1	1	var assignValue = require('./_assignValue'),
2	2	castPath = require('./_castPath'),
3	3	isIndex = require('./_isIndex'),
4		isKey = require('./_isKey'),
5	4	isObject = require('./isObject'),
6	5	toKey = require('./_toKey');
7	6
@@ -19,7 +18,7 @@
19	18	if (!isObject(object)) {
20	19	return object;
21	20	}
22		path = isKey(path, object) ? [path] : castPath(path);
	21	path = castPath(path, object);
23	22
24	23	var index = -1,
25	24	length = path.length,

     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;
 });

 /** Used to detect strings that need a more robust regexp to match words. */
+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 ]/;
+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 ]/;
 /**
  * Checks if `string` contains a word composed of Unicode symbols.

+var overArg = require('./_overArg'),
+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 ? overArg(nativeGetSymbols, Object) : stubArray;
+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;

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

+var keys = require('./keys');
+var getAllKeys = require('./_getAllKeys');
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1;
  */
 function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
   var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+      objProps = keys(object),
+      objProps = getAllKeys(object),
       objLength = objProps.length,
+      othProps = keys(other),
+      othProps = getAllKeys(other),
       othLength = othProps.length;
   if (objLength != othLength && !isPartial) {

   thisArg = newData[2];
   partials = newData[3];
   holders = newData[4];
+  arity = newData[9] = newData[9] == null
+  arity = newData[9] = newData[9] === undefined
     ? (isBindKey ? 0 : func.length)
     : nativeMax(newData[9] - length, 0);

+var toInteger = require('./toInteger'),
+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 nativeMin = Math.min;
+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);
+    if (precision) {
+    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'),
+    stringToPath = require('./_stringToPath');
+    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) {
+  return isArray(value) ? value : stringToPath(value);
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
 module.exports = castPath;

Packagephobia

Bundlephobia

npm diff

Options

package.json .css-zi1c8q{color:var(--chakra-colors-green-200);padding:0 4px;}+++5.css-ucgdpp{color:var(--chakra-colors-red-200);padding:0 4px;}---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

package.json +++5---5

+var baseClone = require('./_baseClone'),
+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 = isKey(path, object) ? [path] : castPath(path);
+  path = castPath(path, object);
   object = parent(object, path);
+  var key = toKey(last(path));
+  return !(object != null && hasOwnProperty.call(object, key)) || delete object[key];
+  return object == null || delete object[toKey(last(path))];
+}
 module.exports = baseUnset;

+var arrayMap = require('./_arrayMap'),
+    basePick = require('./_basePick'),
+    flatRest = require('./_flatRest'),
+    toKey = require('./_toKey');
+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, arrayMap(paths, toKey));
+  return object == null ? {} : basePick(object, paths);
 });
 module.exports = pick;

+var baseIteratee = require('./_baseIteratee'),
+var arrayMap = require('./_arrayMap'),
+    baseIteratee = require('./_baseIteratee'),
     basePickBy = require('./_basePickBy'),
     getAllKeysIn = require('./_getAllKeysIn');
  * // => { 'a': 1, 'c': 3 }
  */
 function pickBy(object, predicate) {
+  return object == null ? {} : basePickBy(object, getAllKeysIn(object), baseIteratee(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'),
+    toKey = require('./_toKey');
+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	11	* @returns {Object} Returns the new object.
12	12	*/
13	13	function basePick(object, paths) {
14		object = Object(object);
15	14	return basePickBy(object, paths, function(value, path) {
16	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,
+      othTag = 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;