angular-slickgrid 4.2.0 → 4.2.3

package/test/cypress/node_modules/jsonfile/node_modules/universalify/README.md

@@ -0,0 +1,76 @@
+# universalify
+
+[![Travis branch](https://img.shields.io/travis/RyanZim/universalify/master.svg)](https://travis-ci.org/RyanZim/universalify)
+![Coveralls github branch](https://img.shields.io/coveralls/github/RyanZim/universalify/master.svg)
+![npm](https://img.shields.io/npm/dm/universalify.svg)
+![npm](https://img.shields.io/npm/l/universalify.svg)
+
+Make a callback- or promise-based function support both promises and callbacks.
+
+Uses the native promise implementation.
+
+## Installation
+
+```bash
+npm install universalify
+```
+
+## API
+
+### `universalify.fromCallback(fn)`
+
+Takes a callback-based function to universalify, and returns the universalified  function.
+
+Function must take a callback as the last parameter that will be called with the signature `(error, result)`. `universalify` does not support calling the callback with three or more arguments, and does not ensure that the callback is only called once.
+
+```js
+function callbackFn (n, cb) {
+  setTimeout(() => cb(null, n), 15)
+}
+
+const fn = universalify.fromCallback(callbackFn)
+
+// Works with Promises:
+fn('Hello World!')
+.then(result => console.log(result)) // -> Hello World!
+.catch(error => console.error(error))
+
+// Works with Callbacks:
+fn('Hi!', (error, result) => {
+  if (error) return console.error(error)
+  console.log(result)
+  // -> Hi!
+})
+```
+
+### `universalify.fromPromise(fn)`
+
+Takes a promise-based function to universalify, and returns the universalified  function.
+
+Function must return a valid JS promise. `universalify` does not ensure that a valid promise is returned.
+
+```js
+function promiseFn (n) {
+  return new Promise(resolve => {
+    setTimeout(() => resolve(n), 15)
+  })
+}
+
+const fn = universalify.fromPromise(promiseFn)
+
+// Works with Promises:
+fn('Hello World!')
+.then(result => console.log(result)) // -> Hello World!
+.catch(error => console.error(error))
+
+// Works with Callbacks:
+fn('Hi!', (error, result) => {
+  if (error) return console.error(error)
+  console.log(result)
+  // -> Hi!
+})
+```
+
+## License
+
+MIT

package/test/cypress/node_modules/jsprim/README.md

@@ -0,0 +1,287 @@
+# jsprim: utilities for primitive JavaScript types
+
+This module provides miscellaneous facilities for working with strings,
+numbers, dates, and objects and arrays of these basic types.
+
+
+### deepCopy(obj)
+
+Creates a deep copy of a primitive type, object, or array of primitive types.
+
+
+### deepEqual(obj1, obj2)
+
+Returns whether two objects are equal.
+
+
+### isEmpty(obj)
+
+Returns true if the given object has no properties and false otherwise.  This
+is O(1) (unlike `Object.keys(obj).length === 0`, which is O(N)).
+
+### hasKey(obj, key)
+
+Returns true if the given object has an enumerable, non-inherited property
+called `key`.  [For information on enumerability and ownership of properties, see
+the MDN
+documentation.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties)
+
+### forEachKey(obj, callback)
+
+Like Array.forEach, but iterates enumerable, owned properties of an object
+rather than elements of an array.  Equivalent to:
+
+    for (var key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    callback(key, obj[key]);
+            }
+    }
+
+
+### flattenObject(obj, depth)
+
+Flattens an object up to a given level of nesting, returning an array of arrays
+of length "depth + 1", where the first "depth" elements correspond to flattened
+columns and the last element contains the remaining object .  For example:
+
+    flattenObject({
+        'I': {
+            'A': {
+                'i': {
+                    'datum1': [ 1, 2 ],
+                    'datum2': [ 3, 4 ]
+                },
+                'ii': {
+                    'datum1': [ 3, 4 ]
+                }
+            },
+            'B': {
+                'i': {
+                    'datum1': [ 5, 6 ]
+                },
+                'ii': {
+                    'datum1': [ 7, 8 ],
+                    'datum2': [ 3, 4 ],
+                },
+                'iii': {
+                }
+            }
+        },
+        'II': {
+            'A': {
+                'i': {
+                    'datum1': [ 1, 2 ],
+                    'datum2': [ 3, 4 ]
+                }
+            }
+        }
+    }, 3)
+
+becomes:
+
+    [
+        [ 'I',  'A', 'i',   { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ],
+        [ 'I',  'A', 'ii',  { 'datum1': [ 3, 4 ] } ],
+        [ 'I',  'B', 'i',   { 'datum1': [ 5, 6 ] } ],
+        [ 'I',  'B', 'ii',  { 'datum1': [ 7, 8 ], 'datum2': [ 3, 4 ] } ],
+        [ 'I',  'B', 'iii', {} ],
+        [ 'II', 'A', 'i',   { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ]
+    ]
+
+This function is strict: "depth" must be a non-negative integer and "obj" must
+be a non-null object with at least "depth" levels of nesting under all keys.
+
+
+### flattenIter(obj, depth, func)
+
+This is similar to `flattenObject` except that instead of returning an array,
+this function invokes `func(entry)` for each `entry` in the array that
+`flattenObject` would return.  `flattenIter(obj, depth, func)` is logically
+equivalent to `flattenObject(obj, depth).forEach(func)`.  Importantly, this
+version never constructs the full array.  Its memory usage is O(depth) rather
+than O(n) (where `n` is the number of flattened elements).
+
+There's another difference between `flattenObject` and `flattenIter` that's
+related to the special case where `depth === 0`.  In this case, `flattenObject`
+omits the array wrapping `obj` (which is regrettable).
+
+
+### pluck(obj, key)
+
+Fetch nested property "key" from object "obj", traversing objects as needed.
+For example, `pluck(obj, "foo.bar.baz")` is roughly equivalent to
+`obj.foo.bar.baz`, except that:
+
+1. If traversal fails, the resulting value is undefined, and no error is
+   thrown.  For example, `pluck({}, "foo.bar")` is just undefined.
+2. If "obj" has property "key" directly (without traversing), the
+   corresponding property is returned.  For example,
+   `pluck({ 'foo.bar': 1 }, 'foo.bar')` is 1, not undefined.  This is also
+   true recursively, so `pluck({ 'a': { 'foo.bar': 1 } }, 'a.foo.bar')` is
+   also 1, not undefined.
+
+
+### randElt(array)
+
+Returns an element from "array" selected uniformly at random.  If "array" is
+empty, throws an Error.
+
+
+### startsWith(str, prefix)
+
+Returns true if the given string starts with the given prefix and false
+otherwise.
+
+
+### endsWith(str, suffix)
+
+Returns true if the given string ends with the given suffix and false
+otherwise.
+
+
+### parseInteger(str, options)
+
+Parses the contents of `str` (a string) as an integer. On success, the integer
+value is returned (as a number). On failure, an error is **returned** describing
+why parsing failed.
+
+By default, leading and trailing whitespace characters are not allowed, nor are
+trailing characters that are not part of the numeric representation. This
+behaviour can be toggled by using the options below. The empty string (`''`) is
+not considered valid input. If the return value cannot be precisely represented
+as a number (i.e., is smaller than `Number.MIN_SAFE_INTEGER` or larger than
+`Number.MAX_SAFE_INTEGER`), an error is returned. Additionally, the string
+`'-0'` will be parsed as the integer `0`, instead of as the IEEE floating point
+value `-0`.
+
+This function accepts both upper and lowercase characters for digits, similar to
+`parseInt()`, `Number()`, and [strtol(3C)](https://illumos.org/man/3C/strtol).
+
+The following may be specified in `options`:
+
+Option             | Type    | Default | Meaning
+------------------ | ------- | ------- | ---------------------------
+base               | number  | 10      | numeric base (radix) to use, in the range 2 to 36
+allowSign          | boolean | true    | whether to interpret any leading `+` (positive) and `-` (negative) characters
+allowImprecise     | boolean | false   | whether to accept values that may have lost precision (past `MAX_SAFE_INTEGER` or below `MIN_SAFE_INTEGER`)
+allowPrefix        | boolean | false   | whether to interpret the prefixes `0b` (base 2), `0o` (base 8), `0t` (base 10), or `0x` (base 16)
+allowTrailing      | boolean | false   | whether to ignore trailing characters
+trimWhitespace     | boolean | false   | whether to trim any leading or trailing whitespace/line terminators
+leadingZeroIsOctal | boolean | false   | whether a leading zero indicates octal
+
+Note that if `base` is unspecified, and `allowPrefix` or `leadingZeroIsOctal`
+are, then the leading characters can change the default base from 10. If `base`
+is explicitly specified and `allowPrefix` is true, then the prefix will only be
+accepted if it matches the specified base. `base` and `leadingZeroIsOctal`
+cannot be used together.
+
+**Context:** It's tricky to parse integers with JavaScript's built-in facilities
+for several reasons:
+
+- `parseInt()` and `Number()` by default allow the base to be specified in the
+  input string by a prefix (e.g., `0x` for hex).
+- `parseInt()` allows trailing nonnumeric characters.
+- `Number(str)` returns 0 when `str` is the empty string (`''`).
+- Both functions return incorrect values when the input string represents a
+  valid integer outside the range of integers that can be represented precisely.
+  Specifically, `parseInt('9007199254740993')` returns 9007199254740992.
+- Both functions always accept `-` and `+` signs before the digit.
+- Some older JavaScript engines always interpret a leading 0 as indicating
+  octal, which can be surprising when parsing input from users who expect a
+  leading zero to be insignificant.
+
+While each of these may be desirable in some contexts, there are also times when
+none of them are wanted. `parseInteger()` grants greater control over what
+input's permissible.
+
+### iso8601(date)
+
+Converts a Date object to an ISO8601 date string of the form
+"YYYY-MM-DDTHH:MM:SS.sssZ".  This format is not customizable.
+
+
+### parseDateTime(str)
+
+Parses a date expressed as a string, as either a number of milliseconds since
+the epoch or any string format that Date accepts, giving preference to the
+former where these two sets overlap (e.g., strings containing small numbers).
+
+
+### hrtimeDiff(timeA, timeB)
+
+Given two hrtime readings (as from Node's `process.hrtime()`), where timeA is
+later than timeB, compute the difference and return that as an hrtime.  It is
+illegal to invoke this for a pair of times where timeB is newer than timeA.
+
+### hrtimeAdd(timeA, timeB)
+
+Add two hrtime intervals (as from Node's `process.hrtime()`), returning a new
+hrtime interval array.  This function does not modify either input argument.
+
+
+### hrtimeAccum(timeA, timeB)
+
+Add two hrtime intervals (as from Node's `process.hrtime()`), storing the
+result in `timeA`.  This function overwrites (and returns) the first argument
+passed in.
+
+
+### hrtimeNanosec(timeA), hrtimeMicrosec(timeA), hrtimeMillisec(timeA)
+
+This suite of functions converts a hrtime interval (as from Node's
+`process.hrtime()`) into a scalar number of nanoseconds, microseconds or
+milliseconds.  Results are truncated, as with `Math.floor()`.
+
+
+### validateJsonObject(schema, object)
+
+Uses JSON validation (via JSV) to validate the given object against the given
+schema.  On success, returns null.  On failure, *returns* (does not throw) a
+useful Error object.
+
+
+### extraProperties(object, allowed)
+
+Check an object for unexpected properties.  Accepts the object to check, and an
+array of allowed property name strings.  If extra properties are detected, an
+array of extra property names is returned.  If no properties other than those
+in the allowed list are present on the object, the returned array will be of
+zero length.
+
+### mergeObjects(provided, overrides, defaults)
+
+Merge properties from objects "provided", "overrides", and "defaults".  The
+intended use case is for functions that accept named arguments in an "args"
+object, but want to provide some default values and override other values.  In
+that case, "provided" is what the caller specified, "overrides" are what the
+function wants to override, and "defaults" contains default values.
+
+The function starts with the values in "defaults", overrides them with the
+values in "provided", and then overrides those with the values in "overrides".
+For convenience, any of these objects may be falsey, in which case they will be
+ignored.  The input objects are never modified, but properties in the returned
+object are not deep-copied.
+
+For example:
+
+    mergeObjects(undefined, { 'objectMode': true }, { 'highWaterMark': 0 })
+
+returns:
+
+    { 'objectMode': true, 'highWaterMark': 0 }
+
+For another example:
+
+    mergeObjects(
+        { 'highWaterMark': 16, 'objectMode': 7 }, /* from caller */
+        { 'objectMode': true },                   /* overrides */
+        { 'highWaterMark': 0 });                  /* default */
+
+returns:
+
+    { 'objectMode': true, 'highWaterMark': 16 }
+
+
+# Contributing
+
+See separate [contribution guidelines](CONTRIBUTING.md).

package/test/cypress/node_modules/lazy-ass/README.md

@@ -0,0 +1,269 @@
+# lazy-ass
+
+> Lazy assertions without performance penalty
+
+[![NPM][lazy-ass-icon] ][lazy-ass-url]
+
+[![Build status][lazy-ass-ci-image] ][lazy-ass-ci-url]
+[![manpm](https://img.shields.io/badge/manpm-compatible-3399ff.svg)](https://github.com/bahmutov/manpm)
+[![dependencies][lazy-ass-dependencies-image] ][lazy-ass-dependencies-url]
+[![devdependencies][lazy-ass-devdependencies-image] ][lazy-ass-devdependencies-url]
+
+[![semantic-release][semantic-image] ][semantic-url]
+[![Coverage Status][lazy-ass-coverage-image]][lazy-ass-coverage-url]
+[![Codacy][lazy-ass-codacy-image]][lazy-ass-codacy-url]
+[![Code Climate][lazy-ass-code-climate-image]][lazy-ass-code-climate-url]
+
+[Demo](http://glebbahmutov.com/lazy-ass/)
+
+Is the current code breaking dependencies if released?
+[![Dont-break][circle-ci-image] ][circle-ci-url] - checks using
+[dont-break](https://github.com/bahmutov/dont-break)
+[circle-ci-image]: https://circleci.com/gh/bahmutov/lazy-ass.svg?style=svg
+[circle-ci-url]: https://circleci.com/gh/bahmutov/lazy-ass
+
+## Example
+
+Regular assertions evaluate all arguments and concatenate message
+EVERY time, even if the condition is true.
+
+```js
+console.assert(typeof foo === 'object',
+  'expected ' + JSON.stringify(foo, null, 2) + ' to be an object');
+```
+
+Lazy assertion function evaluates its arguments and forms
+a message ONLY IF the condition is false
+
+```js
+lazyAss(typeof foo === 'object', 'expected', foo, 'to be an object');
+```
+
+Concatenates strings, stringifies objects, calls functions - only if
+condition is false.
+
+```js
+function environment() {
+  // returns string
+}
+var user = {} // an object
+lazyAsync(condition, 'something went wrong for', user, 'in', environment);
+// throws an error with message equivalent of
+// 'something went wrong for ' + JSON.stringify(user) + ' in ' + environment()
+```
+
+## Why?
+
+* Passing an object reference to a function is about
+[2000-3000 times faster](http://jsperf.com/object-json-stringify)
+than serializing an object and passing it as a string.
+* Concatenating 2 strings before passing to a function is about
+[30% slower](http://jsperf.com/string-concat-vs-pass-string-reference)
+than passing 2 separate strings.
+
+## Install
+
+Node: `npm install lazy-ass --save` then `var la = require('lazy-ass');`.
+You can attach the methods to the global object using
+`require('lazy-ass').globalRegister();`.
+
+Browser: `bower install lazy-ass --save`, include `index.js`,
+attaches functions `lazyAss` and `la` to `window` object.
+
+## Notes
+
+You can pass as many arguments to *lazyAss* after the condition. The condition
+will be evaluated every time (this is required for any assertion). The rest of arguments
+will be concatenated according to rules
+
+* string will be left unchanged.
+* function will be called and its output will be concatenated.
+* any array or object will be JSON stringified.
+
+There will be single space between the individual parts.
+
+## Lazy async assertions
+
+Sometimes you do not want to throw an error synchronously, breaking the entire
+execution stack. Instead you can throw an error asynchronously using `lazyAssync`,
+which internally implements logic like this:
+
+```js
+if (!condition) {
+  setTimeout(function () {
+    throw new Error('Conditions is false!');
+  }, 0);
+}
+```
+
+This allows the execution to continue, while your global error handler (like
+my favorite [Sentry](http://glebbahmutov.com/blog/know-unknown-unknowns-with-sentry/))
+can still forward the error with all specified information to your server.
+
+```js
+lazyAss.async(false, 'foo');
+console.log('after assync');
+// output
+after assync
+Uncaught Error: foo
+```
+
+In this case, there is no meaningful error stack, so use good message
+arguments - there is no performance penalty!
+
+## Rethrowing errors
+
+If the condition itself is an instance of Error, it is simply rethrown (synchronously or
+asynchronously).
+
+```js
+lazyAss(new Error('foo'));
+// Uncaught Error: foo
+```
+
+Useful to make sure errors in the promise chains are
+[not silently ignored](https://glebbahmutov.com/blog/why-promises-need-to-be-done/).
+
+For example, a rejected promise below this will be ignored.
+
+```js
+var p = new Promise(function (resolve, reject) {
+  reject(new Error('foo'));
+});
+p.then(...);
+```
+
+We can catch it and rethrow it *synchronously*, but it will be ignored too (same way,
+only one step further)
+
+```js
+var p = new Promise(function (resolve, reject) {
+  reject(new Error('foo'));
+});
+p.then(..., lazyAss);
+```
+
+But we can actually trigger global error if we rethrow the error *asynchronously*
+
+```js
+var p = new Promise(function (resolve, reject) {
+  reject(new Error('foo'));
+});
+p.then(..., lazyAssync);
+// Uncaught Error: foo
+```
+
+## Predicate function as a condition
+
+Typically, JavaScript evaluates the condition expression first, then calls *lazyAss*.
+This means the function itself sees only the true / false result, and not the expression
+itself. This makes makes the error messages cryptic
+
+    lazyAss(2 + 2 === 5);
+    // Error
+
+We usually get around this by giving at least one additional message argument to
+explain the condition tested
+
+    lazyAss(2 + 2 === 5, 'addition')
+    // Error: addition
+
+*lazyAss* has a better solution: if you give a function that evaluates the condition
+expression, if the function returns false, the error message will include the source
+of the function, making the extra arguments unnecessary
+
+    lazyAss(function () { return 2 + 2 === 5; });
+    // Error: function () { return 2 + 2 === 5; }
+
+The condition function has access to any variables in the scope, making it extremely
+powerful
+
+    var foo = 2, bar = 2;
+    lazyAss(function () { return foo + bar === 5; });
+    // Error: function () { return foo + bar === 5; }
+
+In practical terms, I recommend using separate predicates function and
+passing relevant values to the *lazyAss* function. Remember, there is no performance
+penalty!
+
+    var foo = 2, bar = 2;
+    function isValidPair() {
+      return foo + bar === 5;
+    }
+    lazyAss(isValidPair, 'foo', foo, 'bar', bar);
+    // Error: function isValidPair() {
+    //   return foo + bar === 5;
+    // } foo 2 bar 2
+
+## Testing
+
+This library is fully tested under Node and inside browser environment (CasperJs).
+I described how one can test asynchronous assertion throwing in your own projects
+using Jasmine in [a blog post](http://glebbahmutov.com/blog/testing-async-lazy-assertion/).
+
+## TypeScript
+
+If you use this function from a TypeScript project, we provide ambient type
+definition file. Because this is CommonJS library, use it like this
+
+```ts
+import la = require('lazy-ass')
+// la should have type signature
+```
+
+### Small print
+
+Author: Gleb Bahmutov © 2014
+
+* [@bahmutov](https://twitter.com/bahmutov)
+* [glebbahmutov.com](http://glebbahmutov.com)
+* [blog](http://glebbahmutov.com/blog)
+
+License: MIT - do anything with the code, but don't blame me if it does not work.
+
+Spread the word: tweet, star on github, etc.
+
+Support: if you find any problems with this module, email / tweet /
+[open issue](https://github.com/bahmutov/lazy-ass/issues) on Github
+
+## MIT License
+
+Copyright (c) 2014 Gleb Bahmutov
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+[lazy-ass-icon]: https://nodei.co/npm/lazy-ass.svg?downloads=true
+[lazy-ass-url]: https://npmjs.org/package/lazy-ass
+[lazy-ass-ci-image]: https://travis-ci.org/bahmutov/lazy-ass.svg?branch=master
+[lazy-ass-ci-url]: https://travis-ci.org/bahmutov/lazy-ass
+[lazy-ass-coverage-image]: https://coveralls.io/repos/bahmutov/lazy-ass/badge.svg
+[lazy-ass-coverage-url]: https://coveralls.io/r/bahmutov/lazy-ass
+[lazy-ass-code-climate-image]: https://codeclimate.com/github/bahmutov/lazy-ass/badges/gpa.svg
+[lazy-ass-code-climate-url]: https://codeclimate.com/github/bahmutov/lazy-ass
+[lazy-ass-codacy-image]: https://www.codacy.com/project/badge/b60a0810c9af4fe4b2ae685932dbbdb8
+[lazy-ass-codacy-url]: https://www.codacy.com/public/bahmutov/lazy-ass.git
+[lazy-ass-dependencies-image]: https://david-dm.org/bahmutov/lazy-ass.svg
+[lazy-ass-dependencies-url]: https://david-dm.org/bahmutov/lazy-ass
+[lazy-ass-devdependencies-image]: https://david-dm.org/bahmutov/lazy-ass/dev-status.svg
+[lazy-ass-devdependencies-url]: https://david-dm.org/bahmutov/lazy-ass#info=devDependencies
+[semantic-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
+[semantic-url]: https://github.com/semantic-release/semantic-release

package/test/cypress/node_modules/listr2/README.md

@@ -0,0 +1,17 @@
+# listr2
+
+[![Build Status](https://drone.kilic.dev/api/badges/cenk1cenk2/listr2/status.svg)](https://drone.kilic.dev/cenk1cenk2/listr2) [![Version](https://img.shields.io/npm/v/listr2.svg)](https://npmjs.org/package/listr2) [![Downloads/week](https://img.shields.io/npm/dw/listr2.svg)](https://npmjs.org/package/listr2) [![codecov](https://codecov.io/gh/cenk1cenk2/listr2/branch/master/graph/badge.svg)](https://codecov.io/gh/cenk1cenk2/listr2) [![Dependencies](https://img.shields.io/librariesio/release/npm/listr2)](https://npmjs.org/package/listr2) [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+
+**Create beautiful CLI interfaces via easy and logical to implement task lists that feel alive and interactive.**
+
+![Demo](./demo/demo.gif)
+
+---
+
+# Documentation
+
+**[Read the documentation...](https://listr2.kilic.dev)**
+
+# API Endpoints
+
+**All the endpoints can be found [here](./docs/README.md).**

package/test/cypress/node_modules/lodash/README.md

@@ -0,0 +1,39 @@
+# lodash v4.17.21
+
+The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
+
+## Installation
+
+Using npm:
+```shell
+$ npm i -g npm
+$ npm i --save lodash
+```
+
+In Node.js:
+```js
+// Load the full build.
+var _ = require('lodash');
+// Load the core build.
+var _ = require('lodash/core');
+// Load the FP build for immutable auto-curried iteratee-first data-last methods.
+var fp = require('lodash/fp');
+
+// Load method categories.
+var array = require('lodash/array');
+var object = require('lodash/fp/object');
+
+// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
+var at = require('lodash/at');
+var curryN = require('lodash/fp/curryN');
+```
+
+See the [package source](https://github.com/lodash/lodash/tree/4.17.21-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 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.