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.\"" }

+# lodash v4.16.6
+# lodash v4.17.0
 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.16.6-npm) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.17.0-npm) for more details.
 **Note:**<br>
 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;

     replaceHolders = require('./_replaceHolders');
 /** Used to compose bitmasks for function metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    PARTIAL_FLAG = 32;
+var WRAP_BIND_FLAG = 1,
+    WRAP_BIND_KEY_FLAG = 2,
+    WRAP_PARTIAL_FLAG = 32;
 /**
  * Creates a function that invokes the method at `object[key]` with `partials`
  * // => 'hiya fred!'
  */
 var bindKey = baseRest(function(object, key, partials) {
+  var bitmask = BIND_FLAG | BIND_KEY_FLAG;
+  var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
   if (partials.length) {
     var holders = replaceHolders(partials, getHolder(bindKey));
+    bitmask |= PARTIAL_FLAG;
+    bitmask |= WRAP_PARTIAL_FLAG;
+  }
   return createWrap(key, bitmask, object, partials, holders);
 });

 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;

  * @since 1.0.0
  * @category Object
  * @param {Object} object The object to iterate over.
+ * @param {...(string|string[])} [paths] The property paths of elements to pick.
+ * @param {...(string|string[])} [paths] The property paths to pick.
  * @returns {Array} Returns the picked values.
  * @example
+ *

 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;

 var createWrap = require('./_createWrap');
 /** Used to compose bitmasks for function metadata. */
+var ARY_FLAG = 128;
+var WRAP_ARY_FLAG = 128;
 /**
  * Creates a function that invokes `func`, with up to `n` arguments,
 function ary(func, n, guard) {
   n = guard ? undefined : n;
   n = (func && n == null) ? func.length : n;
+  return createWrap(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);
+  return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
+}
 module.exports = ary;

 var createWrap = require('./_createWrap');
 /** Used to compose bitmasks for function metadata. */
+var CURRY_FLAG = 8;
+var WRAP_CURRY_FLAG = 8;
 /**
  * Creates a function that accepts arguments of `func` and either invokes
  */
 function curry(func, arity, guard) {
   arity = guard ? undefined : arity;
+  var result = createWrap(func, CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+  var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
   result.placeholder = curry.placeholder;
   return result;
+}

 var createWrap = require('./_createWrap');
 /** Used to compose bitmasks for function metadata. */
+var CURRY_RIGHT_FLAG = 16;
+var WRAP_CURRY_RIGHT_FLAG = 16;
 /**
  * This method is like `_.curry` except that arguments are applied to `func`
  */
 function curryRight(func, arity, guard) {
   arity = guard ? undefined : arity;
+  var result = createWrap(func, CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+  var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
   result.placeholder = curryRight.placeholder;
   return result;
+}

     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,
+    FLIP_FLAG = 512;
+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],
+  ['rearg', REARG_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',
+    rsComboSymbolsRange = '\\u20d0-\\u20f0',
+    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 = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+    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',
+    rsComboSymbolsRange = '\\u20d0-\\u20f0';
+var rsComboMarksRange = '\\u0300-\\u036f',
+    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+    rsComboSymbolsRange = '\\u20d0-\\u20ff',
+    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
 /** Used to compose unicode capture groups. */
+var rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']';
+var rsCombo = '[' + rsComboRange + ']';
 /**
  * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

 /** Used to access faster Node.js helpers. */
 var nodeUtil = (function() {
   try {
+    return freeProcess && freeProcess.binding('util');
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
   } catch (e) {}
 }());

 var createWrap = require('./_createWrap');
 /** Used to compose bitmasks for function metadata. */
+var FLIP_FLAG = 512;
+var WRAP_FLIP_FLAG = 512;
 /**
  * Creates a function that invokes `func` with arguments reversed.
  * // => ['d', 'c', 'b', 'a']
  */
 function flip(func) {
+  return createWrap(func, FLIP_FLAG);
+  return createWrap(func, WRAP_FLIP_FLAG);
+}
 module.exports = flip;

 var PLACEHOLDER = '__lodash_placeholder__';
 /** Used to compose bitmasks for function metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    CURRY_BOUND_FLAG = 4,
+    CURRY_FLAG = 8,
+    ARY_FLAG = 128,
+    REARG_FLAG = 256;
+var WRAP_BIND_FLAG = 1,
+    WRAP_BIND_KEY_FLAG = 2,
+    WRAP_CURRY_BOUND_FLAG = 4,
+    WRAP_CURRY_FLAG = 8,
+    WRAP_ARY_FLAG = 128,
+    WRAP_REARG_FLAG = 256;
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMin = Math.min;
   var bitmask = data[1],
       srcBitmask = source[1],
       newBitmask = bitmask | srcBitmask,
+      isCommon = newBitmask < (BIND_FLAG | BIND_KEY_FLAG | ARY_FLAG);
+      isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
   var isCombo =
+    ((srcBitmask == ARY_FLAG) && (bitmask == CURRY_FLAG)) ||
+    ((srcBitmask == ARY_FLAG) && (bitmask == REARG_FLAG) && (data[7].length <= source[8])) ||
+    ((srcBitmask == (ARY_FLAG | REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == CURRY_FLAG));
+    ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
+    ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
+    ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
   // Exit early if metadata can't be merged.
   if (!(isCommon || isCombo)) {
     return data;
+  }
   // Use source `thisArg` if available.
+  if (srcBitmask & BIND_FLAG) {
+  if (srcBitmask & WRAP_BIND_FLAG) {
     data[2] = source[2];
     // Set when currying a bound function.
+    newBitmask |= bitmask & BIND_FLAG ? 0 : CURRY_BOUND_FLAG;
+    newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
+  }
   // Compose partial arguments.
   var value = source[3];
     data[7] = value;
+  }
   // Use source `ary` if it's smaller.
+  if (srcBitmask & ARY_FLAG) {
+  if (srcBitmask & WRAP_ARY_FLAG) {
     data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
+  }
   // Use source `arity` if one is not provided.

 var nativeGetSymbols = Object.getOwnPropertySymbols;
 /**
+ * Creates an array of the own and inherited enumerable symbol properties
+ * of `object`.
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
  * @private
  * @param {Object} object The object to query.

 function isEqualWith(value, other, customizer) {
   customizer = typeof customizer == 'function' ? customizer : undefined;
   var result = customizer ? customizer(value, other) : undefined;
+  return result === undefined ? baseIsEqual(value, other, customizer) : !!result;
+  return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
+}
 module.exports = isEqualWith;

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

 var keys = require('./keys');
+/** Used to compose bitmasks for comparison styles. */
+var PARTIAL_COMPARE_FLAG = 2;
+/** 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) {
+  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+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, customizer, bitmask, stack))
+          ? (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,
+    PARTIAL_COMPARE_FLAG = 2;
+/** 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, equalFunc, customizer, bitmask, stack) {
+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 & PARTIAL_COMPARE_FLAG;
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
       convert || (convert = setToArray);
       if (object.size != other.size && !isPartial) {
       if (stacked) {
         return stacked == other;
+      }
+      bitmask |= UNORDERED_COMPARE_FLAG;
+      bitmask |= COMPARE_UNORDERED_FLAG;
       // Recursively compare objects (susceptible to call stack limits).
       stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+      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,
+    PARTIAL_COMPARE_FLAG = 2;
+/** 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) {
+  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+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 & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+      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, customizer, bitmask, stack))) {
+                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
               return seen.push(othIndex);
+            }
           })) {
+      }
     } else if (!(
           arrValue === othValue ||
+            equalFunc(arrValue, othValue, customizer, bitmask, stack)
+            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,
+    PARTIAL_RIGHT_FLAG = 64;
+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`
+ *   512 - `_.flip`
+ *    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 & BIND_KEY_FLAG;
+  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 &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
+    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 & PARTIAL_RIGHT_FLAG) {
+  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)) {
+    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 == BIND_FLAG) {
+  if (!bitmask || bitmask == WRAP_BIND_FLAG) {
     var result = createBind(func, bitmask, thisArg);
+  } else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
+  } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
     result = createCurry(func, bitmask, arity);
+  } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
+  } 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);

Comparinglodash@4.16.6

Comparinglodash@4.16.6

Source

npm diff

Options

Bundlephobia

Packagephobia

Packagephobia

+++0---0

Packagephobia

Source

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

Comparing
`lodash@4.16.6`

Comparing
`lodash@4.16.6`

     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,
+    PARTIAL_RIGHT_FLAG = 64;
+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 & CURRY_FLAG,
+  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 ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
+  bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
+  bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
+  if (!(bitmask & CURRY_BOUND_FLAG)) {
+    bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
+  if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
+    bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
+  }
   var newData = [
     func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,

     root = require('./_root');
 /** Used to compose bitmasks for function metadata. */
+var BIND_FLAG = 1;
+var WRAP_BIND_FLAG = 1;
 /**
  * Creates a function that wraps `func` to invoke it with the `this` binding
  * @returns {Function} Returns the new wrapped function.
  */
 function createPartial(func, bitmask, thisArg, partials) {
+  var isBind = bitmask & BIND_FLAG,
+  var isBind = bitmask & WRAP_BIND_FLAG,
       Ctor = createCtor(func);
   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;

 var FUNC_ERROR_TEXT = 'Expected a function';
 /** Used to compose bitmasks for function metadata. */
+var CURRY_FLAG = 8,
+    PARTIAL_FLAG = 32,
+    ARY_FLAG = 128,
+    REARG_FLAG = 256;
+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] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) &&
+            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]);

 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;

     getSymbols = require('./_getSymbols');
 /**
+ * Copies own symbol properties of `source` to `object`.
+ * Copies own symbols of `source` to `object`.
+ *
  * @private
  * @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);
+}

+var arrayMap = require('./_arrayMap'),
+    baseDifference = require('./_baseDifference'),
+    basePick = require('./_basePick'),
+var baseClone = require('./_baseClone'),
+    baseUnset = require('./_baseUnset'),
+    copyObject = require('./_copyObject'),
     flatRest = require('./_flatRest'),
+    getAllKeysIn = require('./_getAllKeysIn'),
+    toKey = require('./_toKey');
+    getAllKeysIn = require('./_getAllKeysIn');
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_FLAT_FLAG = 2,
+    CLONE_SYMBOLS_FLAG = 4;
 /**
  * The opposite of `_.pick`; this method creates an object composed of the
+ * own and inherited enumerable string keyed properties of `object` that are
+ * not omitted.
+ * own and inherited enumerable property paths of `object` that are not omitted.
+ *
+ * **Note:** This method is considerably slower than `_.pick`.
+ *
  * @static
  * @since 0.1.0
  * @memberOf _
  * @category Object
  * @param {Object} object The source object.
+ * @param {...(string|string[])} [props] The property identifiers to omit.
+ * @param {...(string|string[])} [paths] The property paths to omit.
  * @returns {Object} Returns the new object.
  * @example
+ *
  * _.omit(object, ['a', 'c']);
  * // => { 'b': '2' }
  */
+var omit = flatRest(function(object, props) {
+var omit = flatRest(function(object, paths) {
+  var result = {};
   if (object == null) {
+    return {};
+    return result;
+  }
+  props = arrayMap(props, toKey);
+  return basePick(object, baseDifference(getAllKeysIn(object), props));
+  copyObject(object, getAllKeysIn(object), result);
+  result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG);
+  var length = paths.length;
+  while (length--) {
+    baseUnset(result, paths[length]);
+  }
+  return result;
 });
 module.exports = omit;