@epilot360/icons 0.0.2 → 1.0.0

package/iac/node_modules/diff-sequences/README.md

@@ -1,404 +0,0 @@
-# diff-sequences
-
-Compare items in two sequences to find a **longest common subsequence**.
-
-The items not in common are the items to delete or insert in a **shortest edit script**.
-
-To maximize flexibility and minimize memory, you write **callback** functions as configuration:
-
-**Input** function `isCommon(aIndex, bIndex)` compares items at indexes in the sequences and returns a truthy/falsey value. This package might call your function more than once for some pairs of indexes.
-
-- Because your function encapsulates **comparison**, this package can compare items according to `===` operator, `Object.is` method, or other criterion.
-- Because your function encapsulates **sequences**, this package can find differences in arrays, strings, or other data.
-
-**Output** function `foundSubsequence(nCommon, aCommon, bCommon)` receives the number of adjacent items and starting indexes of each common subsequence. If sequences do not have common items, then this package does not call your function.
-
-If N is the sum of lengths of sequences and L is length of a longest common subsequence, then D = N – 2L is the number of **differences** in the corresponding shortest edit script.
-
-[_An O(ND) Difference Algorithm and Its Variations_](http://xmailserver.org/diff2.pdf) by Eugene W. Myers is fast when sequences have **few** differences.
-
-This package implements the **linear space** variation with optimizations so it is fast even when sequences have **many** differences.
-
-## Usage
-
-To add this package as a dependency of a project, do either of the following:
-
-- `npm install diff-sequences`
-- `yarn add diff-sequences`
-
-To use `diff` as the name of the default export from this package, do either of the following:
-
-- `var diff = require('diff-sequences').default; // CommonJS modules`
-- `import diff from 'diff-sequences'; // ECMAScript modules`
-
-Call `diff` with the **lengths** of sequences and your **callback** functions:
-
-```js
-const a = ['a', 'b', 'c', 'a', 'b', 'b', 'a'];
-const b = ['c', 'b', 'a', 'b', 'a', 'c'];
-
-function isCommon(aIndex, bIndex) {
-  return a[aIndex] === b[bIndex];
-}
-function foundSubsequence(nCommon, aCommon, bCommon) {
-  // see examples
-}
-
-diff(a.length, b.length, isCommon, foundSubsequence);
-```
-
-## Example of longest common subsequence
-
-Some sequences (for example, `a` and `b` in the example of usage) have more than one longest common subsequence.
-
-This package finds the following common items:
-
-| comparisons of common items      | values     |            output arguments |
-| :------------------------------- | :--------- | --------------------------: |
-| `a[2] === b[0]`                  | `'c'`      | `foundSubsequence(1, 2, 0)` |
-| `a[4] === b[1]`                  | `'b'`      | `foundSubsequence(1, 4, 1)` |
-| `a[5] === b[3] && a[6] === b[4]` | `'b', 'a'` | `foundSubsequence(2, 5, 3)` |
-
-The “edit graph” analogy in the Myers paper shows the following common items:
-
-| comparisons of common items      | values     |
-| :------------------------------- | :--------- |
-| `a[2] === b[0]`                  | `'c'`      |
-| `a[3] === b[2] && a[4] === b[3]` | `'a', 'b'` |
-| `a[6] === b[4]`                  | `'a'`      |
-
-Various packages which implement the Myers algorithm will **always agree** on the **length** of a longest common subsequence, but might **sometimes disagree** on which **items** are in it.
-
-## Example of callback functions to count common items
-
-```js
-// Return length of longest common subsequence according to === operator.
-function countCommonItems(a, b) {
-  let n = 0;
-  function isCommon(aIndex, bIndex) {
-    return a[aIndex] === b[bIndex];
-  }
-  function foundSubsequence(nCommon) {
-    n += nCommon;
-  }
-
-  diff(a.length, b.length, isCommon, foundSubsequence);
-
-  return n;
-}
-
-const commonLength = countCommonItems(
-  ['a', 'b', 'c', 'a', 'b', 'b', 'a'],
-  ['c', 'b', 'a', 'b', 'a', 'c'],
-);
-```
-
-| category of items  |                expression | value |
-| :----------------- | ------------------------: | ----: |
-| in common          |            `commonLength` |   `4` |
-| to delete from `a` | `a.length - commonLength` |   `3` |
-| to insert from `b` | `b.length - commonLength` |   `2` |
-
-If the length difference `b.length - a.length` is:
-
-- negative: its absolute value is the minimum number of items to **delete** from `a`
-- positive: it is the minimum number of items to **insert** from `b`
-- zero: there is an **equal** number of items to delete from `a` and insert from `b`
-- non-zero: there is an equal number of **additional** items to delete from `a` and insert from `b`
-
-In this example, `6 - 7` is:
-
-- negative: `1` is the minimum number of items to **delete** from `a`
-- non-zero: `2` is the number of **additional** items to delete from `a` and insert from `b`
-
-## Example of callback functions to find common items
-
-```js
-// Return array of items in longest common subsequence according to Object.is method.
-const findCommonItems = (a, b) => {
-  const array = [];
-  diff(
-    a.length,
-    b.length,
-    (aIndex, bIndex) => Object.is(a[aIndex], b[bIndex]),
-    (nCommon, aCommon) => {
-      for (; nCommon !== 0; nCommon -= 1, aCommon += 1) {
-        array.push(a[aCommon]);
-      }
-    },
-  );
-  return array;
-};
-
-const commonItems = findCommonItems(
-  ['a', 'b', 'c', 'a', 'b', 'b', 'a'],
-  ['c', 'b', 'a', 'b', 'a', 'c'],
-);
-```
-
-| `i` | `commonItems[i]` | `aIndex` |
-| --: | :--------------- | -------: |
-| `0` | `'c'`            |      `2` |
-| `1` | `'b'`            |      `4` |
-| `2` | `'b'`            |      `5` |
-| `3` | `'a'`            |      `6` |
-
-## Example of callback functions to diff index intervals
-
-Instead of slicing array-like objects, you can adjust indexes in your callback functions.
-
-```js
-// Diff index intervals that are half open [start, end) like array slice method.
-const diffIndexIntervals = (a, aStart, aEnd, b, bStart, bEnd) => {
-  // Validate: 0 <= aStart and aStart <= aEnd and aEnd <= a.length
-  // Validate: 0 <= bStart and bStart <= bEnd and bEnd <= b.length
-
-  diff(
-    aEnd - aStart,
-    bEnd - bStart,
-    (aIndex, bIndex) => Object.is(a[aStart + aIndex], b[bStart + bIndex]),
-    (nCommon, aCommon, bCommon) => {
-      // aStart + aCommon, bStart + bCommon
-    },
-  );
-
-  // After the last common subsequence, do any remaining work.
-};
-```
-
-## Example of callback functions to emulate diff command
-
-Linux or Unix has a `diff` command to compare files line by line. Its output is a **shortest edit script**:
-
-- **c**hange adjacent lines from the first file to lines from the second file
-- **d**elete lines from the first file
-- **a**ppend or insert lines from the second file
-
-```js
-// Given zero-based half-open range [start, end) of array indexes,
-// return one-based closed range [start + 1, end] as string.
-const getRange = (start, end) =>
-  start + 1 === end ? `${start + 1}` : `${start + 1},${end}`;
-
-// Given index intervals of lines to delete or insert, or both, or neither,
-// push formatted diff lines onto array.
-const pushDelIns = (aLines, aIndex, aEnd, bLines, bIndex, bEnd, array) => {
-  const deleteLines = aIndex !== aEnd;
-  const insertLines = bIndex !== bEnd;
-  const changeLines = deleteLines && insertLines;
-  if (changeLines) {
-    array.push(getRange(aIndex, aEnd) + 'c' + getRange(bIndex, bEnd));
-  } else if (deleteLines) {
-    array.push(getRange(aIndex, aEnd) + 'd' + String(bIndex));
-  } else if (insertLines) {
-    array.push(String(aIndex) + 'a' + getRange(bIndex, bEnd));
-  } else {
-    return;
-  }
-
-  for (; aIndex !== aEnd; aIndex += 1) {
-    array.push('< ' + aLines[aIndex]); // delete is less than
-  }
-
-  if (changeLines) {
-    array.push('---');
-  }
-
-  for (; bIndex !== bEnd; bIndex += 1) {
-    array.push('> ' + bLines[bIndex]); // insert is greater than
-  }
-};
-
-// Given content of two files, return emulated output of diff utility.
-const findShortestEditScript = (a, b) => {
-  const aLines = a.split('\n');
-  const bLines = b.split('\n');
-  const aLength = aLines.length;
-  const bLength = bLines.length;
-
-  const isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];
-
-  let aIndex = 0;
-  let bIndex = 0;
-  const array = [];
-  const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    pushDelIns(aLines, aIndex, aCommon, bLines, bIndex, bCommon, array);
-    aIndex = aCommon + nCommon; // number of lines compared in a
-    bIndex = bCommon + nCommon; // number of lines compared in b
-  };
-
-  diff(aLength, bLength, isCommon, foundSubsequence);
-
-  // After the last common subsequence, push remaining change lines.
-  pushDelIns(aLines, aIndex, aLength, bLines, bIndex, bLength, array);
-
-  return array.length === 0 ? '' : array.join('\n') + '\n';
-};
-```
-
-## Example of callback functions to format diff lines
-
-Here is simplified code to format **changed and unchanged lines** in expected and received values after a test fails in Jest:
-
-```js
-// Format diff with minus or plus for change lines and space for common lines.
-const formatDiffLines = (a, b) => {
-  // Jest depends on pretty-format package to serialize objects as strings.
-  // Unindented for comparison to avoid distracting differences:
-  const aLinesUn = format(a, {indent: 0 /*, other options*/}).split('\n');
-  const bLinesUn = format(b, {indent: 0 /*, other options*/}).split('\n');
-  // Indented to display changed and unchanged lines:
-  const aLinesIn = format(a, {indent: 2 /*, other options*/}).split('\n');
-  const bLinesIn = format(b, {indent: 2 /*, other options*/}).split('\n');
-
-  const aLength = aLinesIn.length; // Validate: aLinesUn.length === aLength
-  const bLength = bLinesIn.length; // Validate: bLinesUn.length === bLength
-
-  const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
-
-  // Only because the GitHub Flavored Markdown doc collapses adjacent spaces,
-  // this example code and the following table represent spaces as middle dots.
-  let aIndex = 0;
-  let bIndex = 0;
-  const array = [];
-  const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    for (; aIndex !== aCommon; aIndex += 1) {
-      array.push('-·' + aLinesIn[aIndex]); // delete is minus
-    }
-    for (; bIndex !== bCommon; bIndex += 1) {
-      array.push('+·' + bLinesIn[bIndex]); // insert is plus
-    }
-    for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
-      // For common lines, received indentation seems more intuitive.
-      array.push('··' + bLinesIn[bIndex]); // common is space
-    }
-  };
-
-  diff(aLength, bLength, isCommon, foundSubsequence);
-
-  // After the last common subsequence, push remaining change lines.
-  for (; aIndex !== aLength; aIndex += 1) {
-    array.push('-·' + aLinesIn[aIndex]);
-  }
-  for (; bIndex !== bLength; bIndex += 1) {
-    array.push('+·' + bLinesIn[bIndex]);
-  }
-
-  return array;
-};
-
-const expected = {
-  searching: '',
-  sorting: {
-    ascending: true,
-    fieldKey: 'what',
-  },
-};
-const received = {
-  searching: '',
-  sorting: [
-    {
-      descending: false,
-      fieldKey: 'what',
-    },
-  ],
-};
-
-const diffLines = formatDiffLines(expected, received);
-```
-
-If N is the sum of lengths of sequences and L is length of a longest common subsequence, then N – L is length of an array of diff lines. In this example, N is 7 + 9, L is 5, and N – L is 11.
-
-|  `i` | `diffLines[i]`                     | `aIndex` | `bIndex` |
-| ---: | :--------------------------------- | -------: | -------: |
-|  `0` | `'··Object {'`                     |      `0` |      `0` |
-|  `1` | `'····"searching": "",'`           |      `1` |      `1` |
-|  `2` | `'-···"sorting": Object {'`        |      `2` |          |
-|  `3` | `'-·····"ascending": true,'`       |      `3` |          |
-|  `4` | `'+·····"sorting": Array ['`       |          |      `2` |
-|  `5` | `'+·······Object {'`               |          |      `3` |
-|  `6` | `'+·········"descending": false,'` |          |      `4` |
-|  `7` | `'··········"fieldKey": "what",'`  |      `4` |      `5` |
-|  `8` | `'········},'`                     |      `5` |      `6` |
-|  `9` | `'+·····],'`                       |          |      `7` |
-| `10` | `'··}'`                            |      `6` |      `8` |
-
-## Example of callback functions to find diff items
-
-Here is simplified code to find changed and unchanged substrings **within adjacent changed lines** in expected and received values after a test fails in Jest:
-
-```js
-// Return diff items for strings (compatible with diff-match-patch package).
-const findDiffItems = (a, b) => {
-  const isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];
-
-  let aIndex = 0;
-  let bIndex = 0;
-  const array = [];
-  const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    if (aIndex !== aCommon) {
-      array.push([-1, a.slice(aIndex, aCommon)]); // delete is -1
-    }
-    if (bIndex !== bCommon) {
-      array.push([1, b.slice(bIndex, bCommon)]); // insert is 1
-    }
-
-    aIndex = aCommon + nCommon; // number of characters compared in a
-    bIndex = bCommon + nCommon; // number of characters compared in b
-    array.push([0, a.slice(aCommon, aIndex)]); // common is 0
-  };
-
-  diff(a.length, b.length, isCommon, foundSubsequence);
-
-  // After the last common subsequence, push remaining change items.
-  if (aIndex !== a.length) {
-    array.push([-1, a.slice(aIndex)]);
-  }
-  if (bIndex !== b.length) {
-    array.push([1, b.slice(bIndex)]);
-  }
-
-  return array;
-};
-
-const expectedDeleted = ['"sorting": Object {', '"ascending": true,'].join(
-  '\n',
-);
-const receivedInserted = [
-  '"sorting": Array [',
-  'Object {',
-  '"descending": false,',
-].join('\n');
-
-const diffItems = findDiffItems(expectedDeleted, receivedInserted);
-```
-
-| `i` | `diffItems[i][0]` | `diffItems[i][1]` |
-| --: | ----------------: | :---------------- |
-| `0` |               `0` | `'"sorting": '`   |
-| `1` |               `1` | `'Array [\n'`     |
-| `2` |               `0` | `'Object {\n"'`   |
-| `3` |              `-1` | `'a'`             |
-| `4` |               `1` | `'de'`            |
-| `5` |               `0` | `'scending": '`   |
-| `6` |              `-1` | `'tru'`           |
-| `7` |               `1` | `'fals'`          |
-| `8` |               `0` | `'e,'`            |
-
-The length difference `b.length - a.length` is equal to the sum of `diffItems[i][0]` values times `diffItems[i][1]` lengths. In this example, the difference `48 - 38` is equal to the sum `10`.
-
-| category of diff item | `[0]` |      `[1]` lengths | subtotal |
-| :-------------------- | ----: | -----------------: | -------: |
-| in common             |   `0` | `11 + 10 + 11 + 2` |      `0` |
-| to delete from `a`    |  `–1` |            `1 + 3` |     `-4` |
-| to insert from `b`    |   `1` |        `8 + 2 + 4` |     `14` |
-
-Instead of formatting the changed substrings with escape codes for colors in the `foundSubsequence` function to save memory, this example spends memory to **gain flexibility** before formatting, so a separate heuristic algorithm might modify the generic array of diff items to show changes more clearly:
-
-| `i` | `diffItems[i][0]` | `diffItems[i][1]` |
-| --: | ----------------: | :---------------- |
-| `6` |              `-1` | `'true'`          |
-| `7` |               `1` | `'false'`         |
-| `8` |               `0` | `','`             |
-
-For expected and received strings of serialized data, the result of finding changed **lines**, and then finding changed **substrings** within adjacent changed lines (as in the preceding two examples) sometimes displays the changes in a more intuitive way than the result of finding changed substrings, and then splitting them into changed and unchanged lines.

package/iac/node_modules/fs-extra/LICENSE

@@ -1,15 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2011-2017 JP Richardson
-
-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.

package/iac/node_modules/fs-extra/README.md

@@ -1,264 +0,0 @@
-Node.js: fs-extra
-=================
-
-`fs-extra` adds file system methods that aren't included in the native `fs` module and adds promise support to the `fs` methods. It also uses [`graceful-fs`](https://github.com/isaacs/node-graceful-fs) to prevent `EMFILE` errors. It should be a drop in replacement for `fs`.
-
-[![npm Package](https://img.shields.io/npm/v/fs-extra.svg)](https://www.npmjs.org/package/fs-extra)
-[![License](https://img.shields.io/npm/l/express.svg)](https://github.com/jprichardson/node-fs-extra/blob/master/LICENSE)
-[![build status](https://img.shields.io/travis/jprichardson/node-fs-extra/master.svg)](http://travis-ci.org/jprichardson/node-fs-extra)
-[![windows Build status](https://img.shields.io/appveyor/ci/jprichardson/node-fs-extra/master.svg?label=windows%20build)](https://ci.appveyor.com/project/jprichardson/node-fs-extra/branch/master)
-[![downloads per month](http://img.shields.io/npm/dm/fs-extra.svg)](https://www.npmjs.org/package/fs-extra)
-[![Coverage Status](https://img.shields.io/coveralls/github/jprichardson/node-fs-extra/master.svg)](https://coveralls.io/github/jprichardson/node-fs-extra)
-[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
-
-Why?
-----
-
-I got tired of including `mkdirp`, `rimraf`, and `ncp` in most of my projects.
-
-
-
-
-Installation
-------------
-
-    npm install fs-extra
-
-
-
-Usage
------
-
-`fs-extra` is a drop in replacement for native `fs`. All methods in `fs` are attached to `fs-extra`. All `fs` methods return promises if the callback isn't passed.
-
-You don't ever need to include the original `fs` module again:
-
-```js
-const fs = require('fs') // this is no longer necessary
-```
-
-you can now do this:
-
-```js
-const fs = require('fs-extra')
-```
-
-or if you prefer to make it clear that you're using `fs-extra` and not `fs`, you may want
-to name your `fs` variable `fse` like so:
-
-```js
-const fse = require('fs-extra')
-```
-
-you can also keep both, but it's redundant:
-
-```js
-const fs = require('fs')
-const fse = require('fs-extra')
-```
-
-Sync vs Async vs Async/Await
--------------
-Most methods are async by default. All async methods will return a promise if the callback isn't passed.
-
-Sync methods on the other hand will throw if an error occurs.
-
-Also Async/Await will throw an error if one occurs.
-
-Example:
-
-```js
-const fs = require('fs-extra')
-
-// Async with promises:
-fs.copy('/tmp/myfile', '/tmp/mynewfile')
-  .then(() => console.log('success!'))
-  .catch(err => console.error(err))
-
-// Async with callbacks:
-fs.copy('/tmp/myfile', '/tmp/mynewfile', err => {
-  if (err) return console.error(err)
-  console.log('success!')
-})
-
-// Sync:
-try {
-  fs.copySync('/tmp/myfile', '/tmp/mynewfile')
-  console.log('success!')
-} catch (err) {
-  console.error(err)
-}
-
-// Async/Await:
-async function copyFiles () {
-  try {
-    await fs.copy('/tmp/myfile', '/tmp/mynewfile')
-    console.log('success!')
-  } catch (err) {
-    console.error(err)
-  }
-}
-
-copyFiles()
-```
-
-
-Methods
--------
-
-### Async
-
-- [copy](docs/copy.md)
-- [emptyDir](docs/emptyDir.md)
-- [ensureFile](docs/ensureFile.md)
-- [ensureDir](docs/ensureDir.md)
-- [ensureLink](docs/ensureLink.md)
-- [ensureSymlink](docs/ensureSymlink.md)
-- [mkdirp](docs/ensureDir.md)
-- [mkdirs](docs/ensureDir.md)
-- [move](docs/move.md)
-- [outputFile](docs/outputFile.md)
-- [outputJson](docs/outputJson.md)
-- [pathExists](docs/pathExists.md)
-- [readJson](docs/readJson.md)
-- [remove](docs/remove.md)
-- [writeJson](docs/writeJson.md)
-
-### Sync
-
-- [copySync](docs/copy-sync.md)
-- [emptyDirSync](docs/emptyDir-sync.md)
-- [ensureFileSync](docs/ensureFile-sync.md)
-- [ensureDirSync](docs/ensureDir-sync.md)
-- [ensureLinkSync](docs/ensureLink-sync.md)
-- [ensureSymlinkSync](docs/ensureSymlink-sync.md)
-- [mkdirpSync](docs/ensureDir-sync.md)
-- [mkdirsSync](docs/ensureDir-sync.md)
-- [moveSync](docs/move-sync.md)
-- [outputFileSync](docs/outputFile-sync.md)
-- [outputJsonSync](docs/outputJson-sync.md)
-- [pathExistsSync](docs/pathExists-sync.md)
-- [readJsonSync](docs/readJson-sync.md)
-- [removeSync](docs/remove-sync.md)
-- [writeJsonSync](docs/writeJson-sync.md)
-
-
-**NOTE:** You can still use the native Node.js methods. They are promisified and copied over to `fs-extra`. See [notes on `fs.read()`, `fs.write()`, & `fs.writev()`](docs/fs-read-write-writev.md)
-
-### What happened to `walk()` and `walkSync()`?
-
-They were removed from `fs-extra` in v2.0.0. If you need the functionality, `walk` and `walkSync` are available as separate packages, [`klaw`](https://github.com/jprichardson/node-klaw) and [`klaw-sync`](https://github.com/manidlou/node-klaw-sync).
-
-
-Third Party
------------
-
-### CLI
-
-[fse-cli](https://www.npmjs.com/package/@atao60/fse-cli) allows you to run `fs-extra` from a console or from [npm](https://www.npmjs.com) scripts.
-
-### TypeScript
-
-If you like TypeScript, you can use `fs-extra` with it: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fs-extra
-
-
-### File / Directory Watching
-
-If you want to watch for changes to files or directories, then you should use [chokidar](https://github.com/paulmillr/chokidar).
-
-### Obtain Filesystem (Devices, Partitions) Information
-
-[fs-filesystem](https://github.com/arthurintelligence/node-fs-filesystem) allows you to read the state of the filesystem of the host on which it is run. It returns information about both the devices and the partitions (volumes) of the system.
-
-### Misc.
-
-- [fs-extra-debug](https://github.com/jdxcode/fs-extra-debug) - Send your fs-extra calls to [debug](https://npmjs.org/package/debug).
-- [mfs](https://github.com/cadorn/mfs) - Monitor your fs-extra calls.
-
-
-
-Hacking on fs-extra
--------------------
-
-Wanna hack on `fs-extra`? Great! Your help is needed! [fs-extra is one of the most depended upon Node.js packages](http://nodei.co/npm/fs-extra.png?downloads=true&downloadRank=true&stars=true). This project
-uses [JavaScript Standard Style](https://github.com/feross/standard) - if the name or style choices bother you,
-you're gonna have to get over it :) If `standard` is good enough for `npm`, it's good enough for `fs-extra`.
-
-[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
-
-What's needed?
-- First, take a look at existing issues. Those are probably going to be where the priority lies.
-- More tests for edge cases. Specifically on different platforms. There can never be enough tests.
-- Improve test coverage. See coveralls output for more info.
-
-Note: If you make any big changes, **you should definitely file an issue for discussion first.**
-
-### Running the Test Suite
-
-fs-extra contains hundreds of tests.
-
-- `npm run lint`: runs the linter ([standard](http://standardjs.com/))
-- `npm run unit`: runs the unit tests
-- `npm test`: runs both the linter and the tests
-
-
-### Windows
-
-If you run the tests on the Windows and receive a lot of symbolic link `EPERM` permission errors, it's
-because on Windows you need elevated privilege to create symbolic links. You can add this to your Windows's
-account by following the instructions here: http://superuser.com/questions/104845/permission-to-make-symbolic-links-in-windows-7
-However, I didn't have much luck doing this.
-
-Since I develop on Mac OS X, I use VMWare Fusion for Windows testing. I create a shared folder that I map to a drive on Windows.
-I open the `Node.js command prompt` and run as `Administrator`. I then map the network drive running the following command:
-
-    net use z: "\\vmware-host\Shared Folders"
-
-I can then navigate to my `fs-extra` directory and run the tests.
-
-
-Naming
-------
-
-I put a lot of thought into the naming of these functions. Inspired by @coolaj86's request. So he deserves much of the credit for raising the issue. See discussion(s) here:
-
-* https://github.com/jprichardson/node-fs-extra/issues/2
-* https://github.com/flatiron/utile/issues/11
-* https://github.com/ryanmcgrath/wrench-js/issues/29
-* https://github.com/substack/node-mkdirp/issues/17
-
-First, I believe that in as many cases as possible, the [Node.js naming schemes](http://nodejs.org/api/fs.html) should be chosen. However, there are problems with the Node.js own naming schemes.
-
-For example, `fs.readFile()` and `fs.readdir()`: the **F** is capitalized in *File* and the **d** is not capitalized in *dir*. Perhaps a bit pedantic, but they should still be consistent. Also, Node.js has chosen a lot of POSIX naming schemes, which I believe is great. See: `fs.mkdir()`, `fs.rmdir()`, `fs.chown()`, etc.
-
-We have a dilemma though. How do you consistently name methods that perform the following POSIX commands: `cp`, `cp -r`, `mkdir -p`, and `rm -rf`?
-
-My perspective: when in doubt, err on the side of simplicity. A directory is just a hierarchical grouping of directories and files. Consider that for a moment. So when you want to copy it or remove it, in most cases you'll want to copy or remove all of its contents. When you want to create a directory, if the directory that it's suppose to be contained in does not exist, then in most cases you'll want to create that too.
-
-So, if you want to remove a file or a directory regardless of whether it has contents, just call `fs.remove(path)`. If you want to copy a file or a directory whether it has contents, just call `fs.copy(source, destination)`. If you want to create a directory regardless of whether its parent directories exist, just call `fs.mkdirs(path)` or `fs.mkdirp(path)`.
-
-
-Credit
-------
-
-`fs-extra` wouldn't be possible without using the modules from the following authors:
-
-- [Isaac Shlueter](https://github.com/isaacs)
-- [Charlie McConnel](https://github.com/avianflu)
-- [James Halliday](https://github.com/substack)
-- [Andrew Kelley](https://github.com/andrewrk)
-
-
-
-
-License
--------
-
-Licensed under MIT
-
-Copyright (c) 2011-2017 [JP Richardson](https://github.com/jprichardson)
-
-[1]: http://nodejs.org/docs/latest/api/fs.html
-
-
-[jsonfile]: https://github.com/jprichardson/node-jsonfile