Comparing lodash@4.15.0...lodash@4.16.0 • npm-diff.app 📦🔃

+{
   "name": "lodash",
+  "version": "4.15.0",
+  "version": "4.16.0",
   "description": "Lodash modular utilities.",
   "keywords": "modules, stdlib, util",
   "homepage": "https://lodash.com/",

+# lodash v4.15.0
+# lodash v4.16.0
 The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
 ## Installation
 Using npm:
+```bash
+$ {sudo -H} npm i -g npm
+```shell
+$ npm i -g npm
 $ npm i --save lodash
 ```
 var _ = require('lodash');
 // Load the core build.
 var _ = require('lodash/core');
+// Load the fp build for immutable auto-curried iteratee-first data-last methods.
+// Load the FP build for immutable auto-curried iteratee-first data-last methods.
 var fp = require('lodash/fp');
+// Load a method category.
+// Load method categories.
 var array = require('lodash/array');
 var object = require('lodash/fp/object');
+// Load a single method for smaller builds with browserify/rollup/webpack.
+// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
 var chunk = require('lodash/chunk');
 var extend = require('lodash/fp/extend');
 ```
+See the [package source](https://github.com/lodash/lodash/tree/4.15.0-npm) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.16.0-npm) for more details.
 **Note:**<br>
+Don’t assign values to the [special variable](http://nodejs.org/api/repl.html#repl_repl_features) `_` in the Node.js < 6 REPL.<br>
+Install [n_](https://www.npmjs.com/package/n_) for a REPL that includes `lodash` by default.
+Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.
 ## Support
+Tested in Chrome 51-52, Firefox 47-48, IE 9-11, Edge 14, Safari 8-9, Node.js 0.10-6, & PhantomJS 2.1.1.<br>
+Tested in Chrome 52-53, Firefox 47-48, IE 11, Edge 14, Safari 8-9, Node.js 4-6, & PhantomJS 2.1.1.<br>
 Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.

+var createAggregator = require('./_createAggregator');
+var baseAssignValue = require('./_baseAssignValue'),
+    createAggregator = require('./_createAggregator');
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
  * // => { '3': 2, '5': 1 }
  */
 var countBy = createAggregator(function(result, value, key) {
+  hasOwnProperty.call(result, key) ? ++result[key] : (result[key] = 1);
+  if (hasOwnProperty.call(result, key)) {
+    ++result[key];
+  } else {
+    baseAssignValue(result, key, 1);
+  }
 });
 module.exports = countBy;

 var arrayEach = require('./_arrayEach'),
+    baseFlatten = require('./_baseFlatten'),
+    baseRest = require('./_baseRest'),
+    baseAssignValue = require('./_baseAssignValue'),
     bind = require('./bind'),
+    flatRest = require('./_flatRest'),
     toKey = require('./_toKey');
 /**
  * jQuery(element).on('click', view.click);
  * // => Logs 'clicked docs' when clicked.
  */
+var bindAll = baseRest(function(object, methodNames) {
+  arrayEach(baseFlatten(methodNames, 1), function(key) {
+var bindAll = flatRest(function(object, methodNames) {
+  arrayEach(methodNames, function(key) {
     key = toKey(key);
+    object[key] = bind(object[key], object);
+    baseAssignValue(object, key, bind(object[key], object));
   });
   return object;
 });

 /**
  * Creates an array of `array` values not included in the other given arrays
  * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons. The order of result values is determined by the
+ * order they occur in the first array.
+ * for equality comparisons. The order and references of result values are
+ * determined by the first array.
+ *
  * **Note:** Unlike `_.pullAll`, this method returns a new array.
+ *

  * _.defer(function(text) {
  *   console.log(text);
  * }, 'deferred');
+ * // => Logs 'deferred' after one or more milliseconds.
+ * // => Logs 'deferred' after one millisecond.
  */
 var defer = baseRest(function(func, args) {
   return baseDelay(func, 1, args);

 var baseAt = require('./_baseAt'),
+    baseFlatten = require('./_baseFlatten'),
+    baseRest = require('./_baseRest');
+    flatRest = require('./_flatRest');
 /**
  * Creates an array of values corresponding to `paths` of `object`.
  * _.at(object, ['a[0].b.c', 'a[1]']);
  * // => [3, 4]
  */
+var at = baseRest(function(object, paths) {
+  return baseAt(object, baseFlatten(paths, 1));
+});
+var at = flatRest(baseAt);
 module.exports = at;

 /**
  * This method is like `_.difference` except that it accepts `iteratee` which
  * is invoked for each element of `array` and `values` to generate the criterion
+ * by which they're compared. Result values are chosen from the first array.
+ * The iteratee is invoked with one argument: (value).
+ * by which they're compared. The order and references of result values are
+ * determined by the first array. The iteratee is invoked with one argument:
+ * (value).
+ *
  * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
+ *

 /**
  * This method is like `_.difference` except that it accepts `comparator`
+ * which is invoked to compare elements of `array` to `values`. Result values
+ * are chosen from the first array. The comparator is invoked with two arguments:
+ * (arrVal, othVal).
+ * which is invoked to compare elements of `array` to `values`. The order and
+ * references of result values are determined by the first array. The comparator
+ * is invoked with two arguments: (arrVal, othVal).
+ *
  * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
+ *

 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');
 /**
  * Assigns own enumerable string keyed properties of source objects to the
  * destination object. Source objects are applied from left to right.
  * // => { 'a': 1, 'c': 3 }
  */
 var assign = createAssigner(function(object, source) {
+  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {
+  if (isPrototype(source) || isArrayLike(source)) {
     copyObject(source, keys(source), object);
     return;
+  }

@@ -34,7 +34,7 @@
34	34	function unicodeSize(string) {
35	35	var result = reUnicode.lastIndex = 0;
36	36	while (reUnicode.test(string)) {
37		result++;
	37	++result;
38	38	}
39	39	return result;
40	40	}

     reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
 /**
+ * Converts the characters "&", "<", ">", '"', "'", and "\`" in `string` to
+ * their corresponding HTML entities.
+ * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
+ * corresponding HTML entities.
+ *
  * **Note:** No other characters are escaped. To escape additional
  * characters use a third-party library like [_he_](https://mths.be/he).
  * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
  * (under "semi-related fun fact") for more details.
+ *
+ * Backticks are escaped because in IE < 9, they can break out of
+ * attribute values or HTML comments. See [#59](https://html5sec.org/#59),
+ * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and
+ * [#133](https://html5sec.org/#133) of the
+ * [HTML5 Security Cheatsheet](https://html5sec.org/) for more details.
+ *
  * When working with HTML you should always
  * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
  * XSS vectors.

   '&lt;': '<',
   '&gt;': '>',
   '&quot;': '"',
+  '&#39;': "'",
+  '&#96;': '`'
+  '&#39;': "'"
 };
 /**

+var memoize = require('./memoize'),
+var memoizeCapped = require('./_memoizeCapped'),
     toString = require('./toString');
 /** Used to match property names within property paths. */
  * @param {string} string The string to convert.
  * @returns {Array} Returns the property path array.
  */
+var stringToPath = memoize(function(string) {
+var stringToPath = memoizeCapped(function(string) {
   string = toString(string);
   var result = [];

  * @returns {Object} Returns the stack cache instance.
  */
 function stackSet(key, value) {
+  var cache = this.__data__;
+  if (cache instanceof ListCache) {
+    var pairs = cache.__data__;
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
     if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
       pairs.push([key, value]);
+      this.size = ++data.size;
       return this;
+    }
+    cache = this.__data__ = new MapCache(pairs);
+    data = this.__data__ = new MapCache(pairs);
+  }
+  cache.set(key, value);
+  data.set(key, value);
+  this.size = data.size;
   return this;
+}

@@ -9,6 +9,7 @@
9	9	*/
10	10	function stackClear() {
11	11	this.__data__ = new ListCache;
	12	this.size = 0;
12	13	}
13	14
14	15	module.exports = stackClear;

@@ -10,6 +10,7 @@
10	10	* @memberOf MapCache
11	11	*/
12	12	function mapCacheClear() {
	13	this.size = 0;
13	14	this.__data__ = {
14	15	'hash': new Hash,
15	16	'map': new (Map \|\| ListCache),

@@ -15,6 +15,7 @@
15	15	index = assocIndexOf(data, key);
16	16
17	17	if (index < 0) {
	18	++this.size;
18	19	data.push([key, value]);
19	20	} else {
20	21	data[index][1] = value;

@@ -28,6 +28,7 @@
28	28	} else {
29	29	splice.call(data, index, 1);
30	30	}
	31	--this.size;
31	32	return true;
32	33	}
33	34

  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function stackDelete(key) {
+  return this.__data__['delete'](key);
+  var data = this.__data__,
+      result = data['delete'](key);
+  this.size = data.size;
+  return result;
+}
 module.exports = stackDelete;

+var constant = require('./constant'),
+    defineProperty = require('./_defineProperty'),
+    getWrapDetails = require('./_getWrapDetails'),
+    identity = require('./identity'),
+var getWrapDetails = require('./_getWrapDetails'),
     insertWrapDetails = require('./_insertWrapDetails'),
+    setToString = require('./_setToString'),
     updateWrapDetails = require('./_updateWrapDetails');
 /**
  * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
  * @returns {Function} Returns `wrapper`.
  */
+var setWrapToString = !defineProperty ? identity : function(wrapper, reference, bitmask) {
+function setWrapToString(wrapper, reference, bitmask) {
   var source = (reference + '');
+  return defineProperty(wrapper, 'toString', {
+    'configurable': true,
+    'enumerable': false,
+    'value': constant(insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)))
+  });
+};
+  return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
+}
 module.exports = setWrapToString;

 var baseSetData = require('./_baseSetData'),
+    now = require('./now');
+    shortOut = require('./_shortOut');
+/** Used to detect hot functions by number of calls within a span of milliseconds. */
+var HOT_COUNT = 150,
+    HOT_SPAN = 16;
 /**
  * Sets metadata for `func`.
+ *
  * @param {*} data The metadata.
  * @returns {Function} Returns `func`.
  */
+var setData = (function() {
+  var count = 0,
+      lastCalled = 0;
+var setData = shortOut(baseSetData);
+  return function(key, value) {
+    var stamp = now(),
+        remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return key;
+      }
+    } else {
+      count = 0;
+    }
+    return baseSetData(key, value);
+  };
+}());
 module.exports = setData;

  * @see _.forEachRight
  * @example
+ *
+ * _([1, 2]).forEach(function(value) {
+ * _.forEach([1, 2], function(value) {
  *   console.log(value);
  * });
  * // => Logs `1` then `2`.

  * @returns {Object} Returns the map cache instance.
  */
 function mapCacheSet(key, value) {
+  getMapData(this, key).set(key, value);
+  var data = getMapData(this, key),
+      size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
   return this;
+}

  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function mapCacheDelete(key) {
+  return getMapData(this, key)['delete'](key);
+  var result = getMapData(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
 module.exports = mapCacheDelete;

@@ -7,6 +7,7 @@
7	7	*/
8	8	function listCacheClear() {
9	9	this.__data__ = [];
	10	this.size = 0;
10	11	}
11	12
12	13	module.exports = listCacheClear;

 /**
  * This method is like `_.intersection` except that it accepts `comparator`
+ * which is invoked to compare elements of `arrays`. Result values are chosen
+ * from the first array. The comparator is invoked with two arguments:
+ * (arrVal, othVal).
+ * which is invoked to compare elements of `arrays`. The order and references
+ * of result values are determined by the first array. The comparator is
+ * invoked with two arguments: (arrVal, othVal).
+ *
  * @static
  * @memberOf _

  * @returns {string} Returns the modified source.
  */
 function insertWrapDetails(source, details) {
+  var length = details.length,
+      lastIndex = length - 1;
+  var length = details.length;
+  if (!length) {
+    return source;
+  }
+  var lastIndex = length - 1;
   details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
   details = details.join(length > 2 ? ', ' : ' ');
   return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');

  * // => false
  */
 function isElement(value) {
+  return !!value && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value);
+  return value != null && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value);
+}
 module.exports = isElement;

Comparinglodash@4.15.0

Comparinglodash@4.15.0

Source

npm diff

Options

Bundlephobia

Packagephobia

Packagephobia

+++0---0

Packagephobia

Source

package.json +++1---1

README.md +++9---10

core.js +++94---61

countBy.js +++7---2

bindAll.js +++5---5

defer.js +++1---1

difference.js +++2---2

at.js +++2---5

differenceBy.js +++3---2

differenceWith.js +++3---3

assign.js +++1---7

_unicodeSize.js +++1---1

escape.js +++2---8

_unescapeHtmlChar.js +++1---2

_stringToPath.js +++2---2

_stackSet.js +++7---5

_stackDelete.js +++5---1

_stackClear.js +++1---0

_setWrapToString.js +++5---11

_setData.js +++2---24

forEach.js +++1---1

_mapCacheSet.js +++5---1

groupBy.js +++3---2

_mapCacheDelete.js +++3---1

_mapCacheClear.js +++1---0

_listCacheSet.js +++1---0

_listCacheDelete.js +++1---0

_listCacheClear.js +++1---0

intersection.js +++2---2

intersectionBy.js +++3---2

intersectionWith.js +++3---3

_isHostObject.js +++0---20

_insertWrapDetails.js +++5---3

isElement.js +++1---1

_hashSet.js +++1---0

isEmpty.js +++1---7

_hashDelete.js +++3---1

_hashClear.js +++1---0

_hasPath.js +++5---5

_getTag.js +++1---2

isObject.js +++1---1

isObjectLike.js +++1---1

isPlainObject.js +++1---3

_escapeHtmlChar.js +++1---2

_equalArrays.js +++4---3

_defineProperty.js +++0---11

_deburrLetter.js +++1---1

keyBy.js +++3---2

lastIndexOf.js +++5---14

lodash.js +++428---266

_createOver.js +++3---7

_createFlow.js +++2---5

mapKeys.js +++3---2

mapValues.js +++3---2

memoize.js +++2---2

_countHolders.js +++1---1

mergeWith.js +++1---1

_copyObject.js +++11---2

omit.js +++3---4

overArgs.js +++2---1

_cacheHas.js +++1---1

concat.js +++6---5

parseInt.js +++1---10

pick.js +++3---4

pullAt.js +++2---5

_baseSetData.js +++1---1

_baseRest.js +++4---22

rearg.js +++4---5

_basePickBy.js +++3---1

Comparing
`lodash@4.15.0`

Comparing
`lodash@4.15.0`

@@ -15,6 +15,7 @@
15	15	*/
16	16	function hashSet(key, value) {
17	17	var data = this.__data__;
	18	this.size += this.has(key) ? 0 : 1;
18	19	data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
19	20	return this;
20	21	}

 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');
 /**
  * Checks if `value` is an empty object, collection, map, or set.
+ *
   if (tag == mapTag || tag == setTag) {
     return !value.size;
+  }
+  if (nonEnumShadows || isPrototype(value)) {
+  if (isPrototype(value)) {
     return !nativeKeys(value).length;
+  }
   for (var key in value) {

  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
 function hashDelete(key) {
+  return this.has(key) && delete this.__data__[key];
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
 module.exports = hashDelete;

@@ -9,6 +9,7 @@
9	9	*/
10	10	function hashClear() {
11	11	this.__data__ = nativeCreate ? nativeCreate(null) : {};
	12	this.size = 0;
12	13	}
13	14
14	15	module.exports = hashClear;

 function hasPath(object, path, hasFunc) {
   path = isKey(path, object) ? [path] : castPath(path);
+  var result,
+      index = -1,
+      length = path.length;
+  var index = -1,
+      length = path.length,
+      result = false;
   while (++index < length) {
     var key = toKey(path[index]);
+    }
     object = object[key];
+  }
+  if (result) {
+  if (result || ++index != length) {
     return result;
+  }
+  var length = object ? object.length : 0;
+  length = object ? object.length : 0;
   return !!length && isLength(length) && isIndex(key, length) &&
     (isArray(object) || isArguments(object));
+}

  */
 var getTag = baseGetTag;
+// Fallback for data views, maps, sets, and weak maps in IE 11,
+// for data views in Edge < 14, and promises in Node.js.
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
 if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
     (Map && getTag(new Map) != mapTag) ||
     (Promise && getTag(Promise.resolve()) != promiseTag) ||

  */
 function isObject(value) {
   var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+  return value != null && (type == 'object' || type == 'function');
+}
 module.exports = isObject;

  * // => false
  */
 function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+  return value != null && typeof value == 'object';
+}
 module.exports = isObjectLike;

 var getPrototype = require('./_getPrototype'),
+    isHostObject = require('./_isHostObject'),
     isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
  * // => true
  */
 function isPlainObject(value) {
+  if (!isObjectLike(value) ||
+      objectToString.call(value) != objectTag || isHostObject(value)) {
+  if (!isObjectLike(value) || objectToString.call(value) != objectTag) {
     return false;
+  }
   var proto = getPrototype(value);

   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;',
+  "'": '&#39;',
+  '`': '&#96;'
+  "'": '&#39;'
 };
 /**