build: Add some required modules for node

9 files changed, 3344 insertions, 0 deletions

diff --git a/node_modules/nanomatch/CHANGELOG.md b/node_modules/nanomatch/CHANGELOG.md
new file mode 100644
index 0000000..8c3aead
--- /dev/null
+++ b/node_modules/nanomatch/CHANGELOG.md
@@ -0,0 +1,57 @@
+## History
+
+### key
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog][]_):
+
+- `added`: for new features
+- `changed`: for changes in existing functionality
+- `deprecated`: for once-stable features removed in upcoming releases
+- `removed`: for deprecated features removed in this release
+- `fixed`: for any bug fixes
+- `bumped`: updated dependencies, only minor or higher will be listed.
+
+### [1.1.0] - 2017-04-11
+
+**Fixed**
+
+- adds support for unclosed quotes
+
+**Added**
+
+- adds support for `options.noglobstar`
+
+### [1.0.4] - 2017-04-06
+
+Housekeeping updates. Adds documentation section about escaping, cleans up utils.
+
+### [1.0.3] - 2017-04-06
+
+This release includes fixes for windows path edge cases and other improvements for stricter adherence to bash spec. 
+
+**Fixed**
+
+- More windows path edge cases
+
+**Added**
+
+- Support for bash-like quoted strings for escaping sequences of characters, such as `foo/"**"/bar` where `**` should be matched literally and not evaluated as special characters.
+
+### [1.0.1] - 2016-12-12
+
+**Added**
+
+- Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
+
+### [1.0.0] - 2016-12-12
+
+Stable release.
+
+### [0.1.0] - 2016-10-08
+
+First release.
+
+[Unreleased]: https://github.com/jonschlinkert/nanomatch/compare/0.1.0...HEAD
+[0.2.0]: https://github.com/jonschlinkert/nanomatch/compare/0.1.0...0.2.0
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
diff --git a/node_modules/nanomatch/LICENSE b/node_modules/nanomatch/LICENSE
new file mode 100644
index 0000000..7c9987b
--- /dev/null
+++ b/node_modules/nanomatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2018, Jon Schlinkert.
+
+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.
diff --git a/node_modules/nanomatch/README.md b/node_modules/nanomatch/README.md
new file mode 100644
index 0000000..bdd35a9
--- /dev/null
+++ b/node_modules/nanomatch/README.md
@@ -0,0 +1,1148 @@
+# nanomatch [![NPM version](https://img.shields.io/npm/v/nanomatch.svg?style=flat)](https://www.npmjs.com/package/nanomatch) [![NPM monthly downloads](https://img.shields.io/npm/dm/nanomatch.svg?style=flat)](https://npmjs.org/package/nanomatch) [![NPM total downloads](https://img.shields.io/npm/dt/nanomatch.svg?style=flat)](https://npmjs.org/package/nanomatch) [![Linux Build Status](https://img.shields.io/travis/micromatch/nanomatch.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/nanomatch) [![Windows Build Status](https://img.shields.io/appveyor/ci/micromatch/nanomatch.svg?style=flat&label=AppVeyor)](https://ci.appveyor.com/project/micromatch/nanomatch)
+
+> Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Table of Contents
+
+<details>
+<summary><strong>Details</strong></summary>
+
+- [Install](#install)
+- [What is nanomatch?](#what-is-nanomatch)
+- [Getting started](#getting-started)
+  * [Installing nanomatch](#installing-nanomatch)
+  * [Usage](#usage)
+- [Documentation](#documentation)
+  * [Escaping](#escaping)
+- [API](#api)
+- [Options](#options)
+  * [options.basename](#optionsbasename)
+  * [options.bash](#optionsbash)
+  * [options.cache](#optionscache)
+  * [options.dot](#optionsdot)
+  * [options.failglob](#optionsfailglob)
+  * [options.ignore](#optionsignore)
+  * [options.matchBase](#optionsmatchbase)
+  * [options.nocase](#optionsnocase)
+  * [options.nodupes](#optionsnodupes)
+  * [options.noglobstar](#optionsnoglobstar)
+  * [options.nonegate](#optionsnonegate)
+  * [options.nonull](#optionsnonull)
+  * [options.nullglob](#optionsnullglob)
+  * [options.slash](#optionsslash)
+  * [options.star](#optionsstar)
+  * [options.snapdragon](#optionssnapdragon)
+  * [options.sourcemap](#optionssourcemap)
+  * [options.unescape](#optionsunescape)
+  * [options.unixify](#optionsunixify)
+- [Features](#features)
+- [Bash expansion libs](#bash-expansion-libs)
+- [Benchmarks](#benchmarks)
+  * [Running benchmarks](#running-benchmarks)
+  * [Nanomatch vs. Minimatch vs. Multimatch](#nanomatch-vs-minimatch-vs-multimatch)
+- [About](#about)
+
+</details>
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save nanomatch
+```
+
+<details>
+<summary><strong>Release history</strong></summary>
+
+## History
+
+### key
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](https://github.com/olivierlacan/keep-a-changelog)_):
+
+* `added`: for new features
+* `changed`: for changes in existing functionality
+* `deprecated`: for once-stable features removed in upcoming releases
+* `removed`: for deprecated features removed in this release
+* `fixed`: for any bug fixes
+* `bumped`: updated dependencies, only minor or higher will be listed.
+
+### [1.1.0](https://github.com/micromatch/nanomatch/compare/1.0.4...1.1.0) - 2017-04-11
+
+**Fixed**
+
+* adds support for unclosed quotes
+
+**Added**
+
+* adds support for `options.noglobstar`
+
+### [1.0.4](https://github.com/micromatch/nanomatch/compare/1.0.3...1.0.4) - 2017-04-06
+
+Housekeeping updates. Adds documentation section about escaping, cleans up utils.
+
+### [1.0.3](https://github.com/micromatch/nanomatch/compare/1.0.1...1.0.3) - 2017-04-06
+
+This release includes fixes for windows path edge cases and other improvements for stricter adherence to bash spec.
+
+**Fixed**
+
+* More windows path edge cases
+
+**Added**
+
+* Support for bash-like quoted strings for escaping sequences of characters, such as `foo/"**"/bar` where `**` should be matched literally and not evaluated as special characters.
+
+### [1.0.1](https://github.com/micromatch/nanomatch/compare/1.0.0...1.0.1) - 2016-12-12
+
+**Added**
+
+* Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
+
+### [1.0.0](https://github.com/micromatch/nanomatch/compare/0.1.0...1.0.0) - 2016-12-12
+
+Stable release.
+
+### [0.1.0] - 2016-10-08
+
+First release.
+
+</details>
+
+## What is nanomatch?
+
+Nanomatch is a fast and accurate glob matcher with full support for standard Bash glob features, including the following "metacharacters": `*`, `**`, `?` and `[...]`.
+
+**Learn more**
+
+* [Getting started](#getting-started): learn how to install and begin using nanomatch
+* [Features](#features): jump to info about supported patterns, and a glob matching reference
+* [API documentation](#api): jump to available options and methods
+* [Unit tests](test): visit unit tests. there is no better way to learn a code library than spending time the unit tests. Nanomatch has 36,000 unit tests - go become a glob matching ninja!
+
+<details>
+<summary><strong>How is this different?</strong></summary>
+
+**Speed and accuracy**
+
+Nanomatch uses [snapdragon](https://github.com/jonschlinkert/snapdragon) for parsing and compiling globs, which results in:
+
+* Granular control over the entire conversion process in a way that is easy to understand, reason about, and customize.
+* Faster matching, from a combination of optimized glob patterns and (optional) caching.
+* Much greater accuracy than minimatch. In fact, nanomatch passes _all of the spec tests_ from bash, including some that bash still fails. However, since there is no real specification for globs, if you encounter a pattern that yields unexpected match results [after researching previous issues](../../issues), [please let us know](../../issues/new).
+
+**Basic globbing only**
+
+Nanomatch supports [basic globbing only](#features), which is limited to `*`, `**`, `?` and regex-like brackets.
+
+If you need support for the other [bash "expansion" types](#bash-expansion-libs) (in addition to the wildcard matching provided by nanomatch), consider using [micromatch](https://github.com/micromatch/micromatch) instead. _(micromatch >=3.0.0  uses the nanomatch parser and compiler for basic glob matching)_
+
+</details>
+
+## Getting started
+
+### Installing nanomatch
+
+**Install with [yarn](https://yarnpkg.com/)**
+
+```sh
+$ yarn add nanomatch
+```
+
+**Install with [npm](https://npmjs.com)**
+
+```sh
+$ npm install nanomatch
+```
+
+### Usage
+
+Add nanomatch to your project using node's `require()` system:
+
+```js
+var nanomatch = require('nanomatch');
+
+// the main export is a function that takes an array of strings to match
+// and a string or array of patterns to use for matching
+nanomatch(list, patterns[, options]);
+```
+
+**Params**
+
+* `list` **{String|Array}**: List of strings to perform matches against. This is often a list of file paths.
+* `patterns` **{String|Array}**: One or more [glob paterns](#features) to use for matching.
+* `options` **{Object}**: Any [supported options](#options) may be passed
+
+**Examples**
+
+```js
+var nm = require('nanomatch');
+console.log(nm(['a', 'b/b', 'c/c/c'], '*'));
+//=> ['a']
+
+console.log(nm(['a', 'b/b', 'c/c/c'], '*/*'));
+//=> ['b/b']
+
+console.log(nm(['a', 'b/b', 'c/c/c'], '**'));
+//=> ['a', 'b/b', 'c/c/c']
+```
+
+See the [API documentation](#api) for available methods and [options](https://github.com/einaros/options.js).
+
+## Documentation
+
+### Escaping
+
+_Backslashes and quotes_ can be used to escape characters, forcing nanomatch to regard those characters as a literal characters.
+
+**Backslashes**
+
+Use backslashes to escape single characters. For example, the following pattern would match `foo/*/bar` exactly:
+
+```js
+'foo/\*/bar'
+```
+
+The following pattern would match `foo/` followed by a literal `*`, followed by zero or more of any characters besides `/`, followed by `/bar`.
+
+```js
+'foo/\**/bar'
+```
+
+**Quoted strings**
+
+Use single or double quotes to escape sequences of characters. For example, the following patterns would match `foo/**/bar` exactly:
+
+```js
+'foo/"**"/bar'
+'foo/\'**\'/bar'
+"foo/'**'/bar"
+```
+
+**Matching literal quotes**
+
+If you need to match quotes literally, you can escape them as well. For example, the following will match `foo/"*"/bar`, `foo/"a"/bar`, `foo/"b"/bar`, or `foo/"c"/bar`:
+
+```js
+'foo/\\"*\\"/bar'
+```
+
+And the following will match `foo/'*'/bar`, `foo/'a'/bar`, `foo/'b'/bar`, or `foo/'c'/bar`:
+
+```js
+'foo/\\\'*\\\'/bar'
+```
+
+## API
+
+### [nanomatch](index.js#L40)
+
+The main function takes a list of strings and one or more glob patterns to use for matching.
+
+**Params**
+
+* `list` **{Array}**: A list of strings to match
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Array}**: Returns an array of matches
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm(list, patterns[, options]);
+
+console.log(nm(['a.js', 'a.txt'], ['*.js']));
+//=> [ 'a.js' ]
+```
+
+### [.match](index.js#L106)
+
+Similar to the main function, but `pattern` must be a string.
+
+**Params**
+
+* `list` **{Array}**: Array of strings to match
+* `pattern` **{String}**: Glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Array}**: Returns an array of matches
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.match(list, pattern[, options]);
+
+console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
+//=> ['a.a', 'a.aa']
+```
+
+### [.isMatch](index.js#L167)
+
+Returns true if the specified `string` matches the given glob `pattern`.
+
+**Params**
+
+* `string` **{String}**: String to match
+* `pattern` **{String}**: Glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if the string matches the glob pattern.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.isMatch(string, pattern[, options]);
+
+console.log(nm.isMatch('a.a', '*.a'));
+//=> true
+console.log(nm.isMatch('a.b', '*.a'));
+//=> false
+```
+
+### [.some](index.js#L205)
+
+Returns true if some of the elements in the given `list` match any of the given glob `patterns`.
+
+**Params**
+
+* `list` **{String|Array}**: The string or array of strings to test. Returns as soon as the first match is found.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.some(list, patterns[, options]);
+
+console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+// true
+console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
+// false
+```
+
+### [.every](index.js#L243)
+
+Returns true if every element in the given `list` matches at least one of the given glob `patterns`.
+
+**Params**
+
+* `list` **{String|Array}**: The string or array of strings to test.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.every(list, patterns[, options]);
+
+console.log(nm.every('foo.js', ['foo.js']));
+// true
+console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
+// true
+console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+// false
+console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
+// false
+```
+
+### [.any](index.js#L277)
+
+Returns true if **any** of the given glob `patterns` match the specified `string`.
+
+**Params**
+
+* `str` **{String|Array}**: The string to test.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.any(string, patterns[, options]);
+
+console.log(nm.any('a.a', ['b.*', '*.a']));
+//=> true
+console.log(nm.any('a.a', 'b.*'));
+//=> false
+```
+
+### [.all](index.js#L325)
+
+Returns true if **all** of the given `patterns` match the specified string.
+
+**Params**
+
+* `str` **{String|Array}**: The string to test.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.all(string, patterns[, options]);
+
+console.log(nm.all('foo.js', ['foo.js']));
+// true
+
+console.log(nm.all('foo.js', ['*.js', '!foo.js']));
+// false
+
+console.log(nm.all('foo.js', ['*.js', 'foo.js']));
+// true
+
+console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+// true
+```
+
+### [.not](index.js#L359)
+
+Returns a list of strings that _**do not match any**_ of the given `patterns`.
+
+**Params**
+
+* `list` **{Array}**: Array of strings to match.
+* `patterns` **{String|Array}**: One or more glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Array}**: Returns an array of strings that **do not match** the given patterns.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.not(list, patterns[, options]);
+
+console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+//=> ['b.b', 'c.c']
+```
+
+### [.contains](index.js#L394)
+
+Returns true if the given `string` contains the given pattern. Similar to [.isMatch](#isMatch) but the pattern can match any part of the string.
+
+**Params**
+
+* `str` **{String}**: The string to match.
+* `patterns` **{String|Array}**: Glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if the patter matches any part of `str`.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.contains(string, pattern[, options]);
+
+console.log(nm.contains('aa/bb/cc', '*b'));
+//=> true
+console.log(nm.contains('aa/bb/cc', '*d'));
+//=> false
+```
+
+### [.matchKeys](index.js#L450)
+
+Filter the keys of the given object with the given `glob` pattern and `options`. Does not attempt to match nested keys. If you need this feature, use [glob-object](https://github.com/jonschlinkert/glob-object) instead.
+
+**Params**
+
+* `object` **{Object}**: The object with keys to filter.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Object}**: Returns an object with only keys that match the given patterns.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.matchKeys(object, patterns[, options]);
+
+var obj = { aa: 'a', ab: 'b', ac: 'c' };
+console.log(nm.matchKeys(obj, '*b'));
+//=> { ab: 'b' }
+```
+
+### [.matcher](index.js#L479)
+
+Returns a memoized matcher function from the given glob `pattern` and `options`. The returned function takes a string to match as its only argument and returns true if the string is a match.
+
+**Params**
+
+* `pattern` **{String}**: Glob pattern
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed.
+* `returns` **{Function}**: Returns a matcher function.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.matcher(pattern[, options]);
+
+var isMatch = nm.matcher('*.!(*a)');
+console.log(isMatch('a.a'));
+//=> false
+console.log(isMatch('a.b'));
+//=> true
+```
+
+### [.capture](index.js#L560)
+
+Returns an array of matches captured by `pattern` in `string, or`null` if the pattern did not match.
+
+**Params**
+
+* `pattern` **{String}**: Glob pattern to use for matching.
+* `string` **{String}**: String to match
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns an array of captures if the string matches the glob pattern, otherwise `null`.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.capture(pattern, string[, options]);
+
+console.log(nm.capture('test/*.js', 'test/foo.js'));
+//=> ['foo']
+console.log(nm.capture('test/*.js', 'foo/bar.css'));
+//=> null
+```
+
+### [.makeRe](index.js#L595)
+
+Create a regular expression from the given glob `pattern`.
+
+**Params**
+
+* `pattern` **{String}**: A glob pattern to convert to regex.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed.
+* `returns` **{RegExp}**: Returns a regex created from the given pattern.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.makeRe(pattern[, options]);
+
+console.log(nm.makeRe('*.js'));
+//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+```
+
+### [.create](index.js#L658)
+
+Parses the given glob `pattern` and returns an object with the compiled `output` and optional source `map`.
+
+**Params**
+
+* `pattern` **{String}**: Glob pattern to parse and compile.
+* `options` **{Object}**: Any [options](#options) to change how parsing and compiling is performed.
+* `returns` **{Object}**: Returns an object with the parsed AST, compiled string and optional source map.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.create(pattern[, options]);
+
+console.log(nm.create('abc/*.js'));
+// { options: { source: 'string', sourcemap: true },
+//   state: {},
+//   compilers:
+//    { ... },
+//   output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
+//   ast:
+//    { type: 'root',
+//      errors: [],
+//      nodes:
+//       [ ... ],
+//      dot: false,
+//      input: 'abc/*.js' },
+//   parsingErrors: [],
+//   map:
+//    { version: 3,
+//      sources: [ 'string' ],
+//      names: [],
+//      mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
+//      sourcesContent: [ 'abc/*.js' ] },
+//   position: { line: 1, column: 28 },
+//   content: {},
+//   files: {},
+//   idx: 6 }
+```
+
+### [.parse](index.js#L697)
+
+Parse the given `str` with the given `options`.
+
+**Params**
+
+* `str` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an AST
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.parse(pattern[, options]);
+
+var ast = nm.parse('a/{b,c}/d');
+console.log(ast);
+// { type: 'root',
+//   errors: [],
+//   input: 'a/{b,c}/d',
+//   nodes:
+//    [ { type: 'bos', val: '' },
+//      { type: 'text', val: 'a/' },
+//      { type: 'brace',
+//        nodes:
+//         [ { type: 'brace.open', val: '{' },
+//           { type: 'text', val: 'b,c' },
+//           { type: 'brace.close', val: '}' } ] },
+//      { type: 'text', val: '/d' },
+//      { type: 'eos', val: '' } ] }
+```
+
+### [.compile](index.js#L745)
+
+Compile the given `ast` or string with the given `options`.
+
+**Params**
+
+* `ast` **{Object|String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object that has an `output` property with the compiled string.
+
+**Example**
+
+```js
+var nm = require('nanomatch');
+nm.compile(ast[, options]);
+
+var ast = nm.parse('a/{b,c}/d');
+console.log(nm.compile(ast));
+// { options: { source: 'string' },
+//   state: {},
+//   compilers:
+//    { eos: [Function],
+//      noop: [Function],
+//      bos: [Function],
+//      brace: [Function],
+//      'brace.open': [Function],
+//      text: [Function],
+//      'brace.close': [Function] },
+//   output: [ 'a/(b|c)/d' ],
+//   ast:
+//    { ... },
+//   parsingErrors: [] }
+```
+
+### [.clearCache](index.js#L768)
+
+Clear the regex cache.
+
+**Example**
+
+```js
+nm.clearCache();
+```
+
+## Options
+
+<details>
+<summary><strong>basename</strong></summary>
+
+### options.basename
+
+Allow glob patterns without slashes to match a file path based on its basename. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `matchBase`.
+
+Type: `boolean`
+
+Default: `false`
+
+**Example**
+
+```js
+nm(['a/b.js', 'a/c.md'], '*.js');
+//=> []
+
+nm(['a/b.js', 'a/c.md'], '*.js', {matchBase: true});
+//=> ['a/b.js']
+```
+
+</details>
+
+<details>
+<summary><strong>bash</strong></summary>
+
+### options.bash
+
+Enabled by default, this option enforces bash-like behavior with stars immediately following a bracket expression. Bash bracket expressions are similar to regex character classes, but unlike regex, a star following a bracket expression **does not repeat the bracketed characters**. Instead, the star is treated the same as an other star.
+
+Type: `boolean`
+
+Default: `true`
+
+**Example**
+
+```js
+var files = ['abc', 'ajz'];
+console.log(nm(files, '[a-c]*'));
+//=> ['abc', 'ajz']
+
+console.log(nm(files, '[a-c]*', {bash: false}));
+```
+
+</details>
+
+<details>
+<summary><strong>cache</strong></summary>
+
+### options.cache
+
+Disable regex and function memoization.
+
+Type: `boolean`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>dot</strong></summary>
+
+### options.dot
+
+Match dotfiles. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `dot`.
+
+Type: `boolean`
+
+Default: `false`
+
+</details>
+
+<details>
+<summary><strong>failglob</strong></summary>
+
+### options.failglob
+
+Similar to the `--failglob` behavior in Bash, throws an error when no matches are found.
+
+Type: `boolean`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>ignore</strong></summary>
+
+### options.ignore
+
+String or array of glob patterns to match files to ignore.
+
+Type: `String|Array`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>matchBase</strong></summary>
+
+### options.matchBase
+
+Alias for [options.basename](#options-basename).
+
+</details>
+
+<details>
+<summary><strong>nocase</strong></summary>
+
+### options.nocase
+
+Use a case-insensitive regex for matching files. Same behavior as [minimatch](https://github.com/isaacs/minimatch).
+
+Type: `boolean`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>nodupes</strong></summary>
+
+### options.nodupes
+
+Remove duplicate elements from the result array.
+
+Type: `boolean`
+
+Default: `true` (enabled by default)
+
+**Example**
+
+Example of using the `unescape` and `nodupes` options together:
+
+```js
+nm.match(['a/b/c', 'a/b/c'], '**');
+//=> ['abc']
+
+nm.match(['a/b/c', 'a/b/c'], '**', {nodupes: false});
+//=> ['a/b/c', 'a/b/c']
+```
+
+</details>
+
+<details>
+<summary><strong>nonegate</strong></summary>
+
+### options.noglobstar
+
+Disable matching with globstars (`**`).
+
+Type: `boolean`
+
+Default: `undefined`
+
+```js
+nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**');
+//=> ['a/b', 'a/b/c', 'a/b/c/d']
+
+nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true});
+//=> ['a/b']
+```
+
+</details>
+
+<details>
+<summary><strong>nonegate</strong></summary>
+
+### options.nonegate
+
+Disallow negation (`!`) patterns, and treat leading `!` as a literal character to match.
+
+Type: `boolean`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>nonull</strong></summary>
+
+### options.nonull
+
+Alias for [options.nullglob](#options-nullglob).
+
+</details>
+
+<details>
+<summary><strong>nullglob</strong></summary>
+
+### options.nullglob
+
+If `true`, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `nonull`.
+
+Type: `boolean`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong><a name="slash">slash</a></strong></summary>
+
+### options.slash
+
+Customize the slash character(s) to use for matching.
+
+Type: `string|function`
+
+Default: `[/\\]` (forward slash and backslash)
+
+</details>
+
+<details>
+<summary><strong><a name="star">star</a></strong></summary>
+
+### options.star
+
+Customize the star character(s) to use for matching. It's not recommended that you modify this unless you have advanced knowledge of the compiler and matching rules.
+
+Type: `string|function`
+
+Default: `[^/\\]*?`
+
+</details>
+
+<details>
+<summary><strong><a name="snapdragon">snapdragon</a></strong></summary>
+
+### options.snapdragon
+
+Pass your own instance of [snapdragon](https://github.com/jonschlinkert/snapdragon) to customize parsers or compilers.
+
+Type: `object`
+
+Default: `undefined`
+
+</details>
+
+<details>
+<summary><strong>snapdragon</strong></summary>
+
+### options.sourcemap
+
+Generate a source map by enabling the `sourcemap` option with the `.parse`, `.compile`, or `.create` methods.
+
+**Examples**
+
+```js
+var nm = require('nanomatch');
+
+var res = nm.create('abc/*.js', {sourcemap: true});
+console.log(res.map);
+// { version: 3,
+//   sources: [ 'string' ],
+//   names: [],
+//   mappings: 'AAAA,GAAG,EAAC,iBAAC,EAAC,EAAE',
+//   sourcesContent: [ 'abc/*.js' ] }
+
+var ast = nm.parse('abc/**/*.js');
+var res = nm.compile(ast, {sourcemap: true});
+console.log(res.map);
+// { version: 3,
+//   sources: [ 'string' ],
+//   names: [],
+//   mappings: 'AAAA,GAAG,EAAC,2BAAE,EAAC,iBAAC,EAAC,EAAE',
+//   sourcesContent: [ 'abc/**/*.js' ] }
+```
+
+</details>
+
+<details>
+<summary><strong>unescape</strong></summary>
+
+### options.unescape
+
+Remove backslashes from returned matches.
+
+Type: `boolean`
+
+Default: `undefined`
+
+**Example**
+
+In this example we want to match a literal `*`:
+
+```js
+nm.match(['abc', 'a\\*c'], 'a\\*c');
+//=> ['a\\*c']
+
+nm.match(['abc', 'a\\*c'], 'a\\*c', {unescape: true});
+//=> ['a*c']
+```
+
+</details>
+
+<details>
+<summary><strong>unixify</strong></summary>
+
+### options.unixify
+
+Convert path separators on returned files to posix/unix-style forward slashes.
+
+Type: `boolean`
+
+Default: `true`
+
+**Example**
+
+```js
+nm.match(['a\\b\\c'], 'a/**');
+//=> ['a/b/c']
+
+nm.match(['a\\b\\c'], {unixify: false});
+//=> ['a\\b\\c']
+```
+
+</details>
+
+## Features
+
+Nanomatch has full support for standard Bash glob features, including the following "metacharacters": `*`, `**`, `?` and `[...]`.
+
+Here are some examples of how they work:
+
+| **Pattern** | **Description** | 
+| --- | --- |
+| `*` | Matches any string except for `/`, leading `.`, or `/.` inside a path |
+| `**` | Matches any string including `/`, but not a leading `.` or `/.` inside a path. More than two stars (e.g. `***` is treated the same as one star, and `**` loses its special meaning | when it's not the only thing in a path segment, per Bash specifications) |
+| `foo*` | Matches any string beginning with `foo` |
+| `*bar*` | Matches any string containing `bar` (beginning, middle or end) |
+| `*.min.js` | Matches any string ending with `.min.js` |
+| `[abc]*.js` | Matches any string beginning with `a`, `b`, or `c` and ending with `.js` |
+| `abc?` | Matches `abcd` or `abcz` but not `abcde` |
+
+The exceptions noted for `*` apply to all patterns that contain a `*`.
+
+**Not supported**
+
+The following extended-globbing features are not supported:
+
+* [brace expansion](https://github.com/jonschlinkert/braces) (e.g. `{a,b,c}`)
+* [extglobs](https://github.com/jonschlinkert/extglob) (e.g. `@(a|!(c|d))`)
+* [POSIX brackets](https://github.com/jonschlinkert/expand-brackets) (e.g. `[[:alpha:][:digit:]]`)
+
+If you need any of these features consider using [micromatch](https://github.com/micromatch/micromatch) instead.
+
+## Bash expansion libs
+
+Nanomatch is part of a suite of libraries aimed at bringing the power and expressiveness of [Bash's](https://www.gnu.org/software/bash/) matching and expansion capabilities to JavaScript, _and - as you can see by the [benchmarks](#benchmarks) - without sacrificing speed_.
+
+| **Related library** | **Matching Type** | **Example** | **Description** | 
+| --- | --- | --- | --- |
+| `nanomatch` (you are here) | Wildcards | `*` | [Filename expansion](https://www.gnu.org/software/bash/manual/html_node/Filename-Expansion.html#Filename-Expansion), also referred to as globbing and pathname expansion, allows the use of [wildcards](#features) for matching. |
+| [expand-tilde](https://github.com/jonschlinkert/expand-tilde) | Tildes | `~` | [Tilde expansion](https://www.gnu.org/software/bash/manual/html_node/Tilde-Expansion.html#Tilde-Expansion) converts the leading tilde in a file path to the user home directory. |
+| [braces](https://github.com/jonschlinkert/braces) | Braces | `{a,b,c}` | [Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) |
+| [expand-brackets](https://github.com/jonschlinkert/expand-brackets) | Brackets | `[[:alpha:]]` | [POSIX character classes](https://www.gnu.org/software/grep/manual/html_node/Character-Classes-and-Bracket-Expressions.html) (also referred to as POSIX brackets, or POSIX character classes) |
+| [extglob](https://github.com/jonschlinkert/extglob) | Parens | `!(a\ | b)` | [Extglobs](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html#Pattern-Matching) |
+| [micromatch](https://github.com/micromatch/micromatch) | All | all | Micromatch is built on top of the other libraries. |
+
+There are many resources available on the web if you want to dive deeper into how these features work in Bash.
+
+## Benchmarks
+
+### Running benchmarks
+
+Install dev dependencies:
+
+```bash
+npm i -d && node benchmark
+```
+
+### Nanomatch vs. Minimatch vs. Multimatch
+
+```bash
+# globstar-basic (182 bytes)
+  minimatch x 69,512 ops/sec ±1.92% (88 runs sampled)
+  multimatch x 63,376 ops/sec ±1.41% (89 runs sampled)
+  nanomatch x 432,451 ops/sec ±0.92% (88 runs sampled)
+
+  fastest is nanomatch (by 651% avg)
+
+# large-list-globstar (485686 bytes)
+  minimatch x 34.02 ops/sec ±1.42% (59 runs sampled)
+  multimatch x 33.58 ops/sec ±1.97% (58 runs sampled)
+  nanomatch x 483 ops/sec ±1.06% (86 runs sampled)
+
+  fastest is nanomatch (by 1429% avg)
+
+# long-list-globstar (194085 bytes)
+  minimatch x 383 ops/sec ±0.74% (90 runs sampled)
+  multimatch x 378 ops/sec ±0.59% (89 runs sampled)
+  nanomatch x 990 ops/sec ±1.14% (85 runs sampled)
+
+  fastest is nanomatch (by 260% avg)
+
+# negation-basic (132 bytes)
+  minimatch x 242,145 ops/sec ±1.17% (89 runs sampled)
+  multimatch x 76,403 ops/sec ±0.78% (92 runs sampled)
+  nanomatch x 537,253 ops/sec ±1.44% (86 runs sampled)
+
+  fastest is nanomatch (by 337% avg)
+
+# not-glob-basic (93 bytes)
+  minimatch x 252,402 ops/sec ±1.33% (89 runs sampled)
+  multimatch x 209,954 ops/sec ±1.30% (90 runs sampled)
+  nanomatch x 1,716,468 ops/sec ±1.13% (86 runs sampled)
+
+  fastest is nanomatch (by 742% avg)
+
+# star-basic (93 bytes)
+  minimatch x 182,780 ops/sec ±1.41% (91 runs sampled)
+  multimatch x 153,210 ops/sec ±0.72% (89 runs sampled)
+  nanomatch x 599,621 ops/sec ±1.22% (90 runs sampled)
+
+  fastest is nanomatch (by 357% avg)
+
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [extglob](https://www.npmjs.com/package/extglob): Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… [more](https://github.com/micromatch/extglob) | [homepage](https://github.com/micromatch/extglob "Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob patterns.")
+* [is-extglob](https://www.npmjs.com/package/is-extglob): Returns true if a string has an extglob. | [homepage](https://github.com/jonschlinkert/is-extglob "Returns true if a string has an extglob.")
+* [is-glob](https://www.npmjs.com/package/is-glob): Returns `true` if the given string looks like a glob pattern or an extglob pattern… [more](https://github.com/jonschlinkert/is-glob) | [homepage](https://github.com/jonschlinkert/is-glob "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet")
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
+
+### Contributors
+
+| **Commits** | **Contributor** | 
+| --- | --- |
+| 164 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 1 | [devongovett](https://github.com/devongovett) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [linkedin/in/jonschlinkert](https://linkedin.com/in/jonschlinkert)
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on February 18, 2018._
\ No newline at end of file
diff --git a/node_modules/nanomatch/index.js b/node_modules/nanomatch/index.js
new file mode 100644
index 0000000..dddc612
--- /dev/null
+++ b/node_modules/nanomatch/index.js
@@ -0,0 +1,838 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+var util = require('util');
+var toRegex = require('to-regex');
+var extend = require('extend-shallow');
+
+/**
+ * Local dependencies
+ */
+
+var compilers = require('./lib/compilers');
+var parsers = require('./lib/parsers');
+var cache = require('./lib/cache');
+var utils = require('./lib/utils');
+var MAX_LENGTH = 1024 * 64;
+
+/**
+ * The main function takes a list of strings and one or more
+ * glob patterns to use for matching.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm(list, patterns[, options]);
+ *
+ * console.log(nm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {Array} `list` A list of strings to match
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+function nanomatch(list, patterns, options) {
+  patterns = utils.arrayify(patterns);
+  list = utils.arrayify(list);
+
+  var len = patterns.length;
+  if (list.length === 0 || len === 0) {
+    return [];
+  }
+
+  if (len === 1) {
+    return nanomatch.match(list, patterns[0], options);
+  }
+
+  var negated = false;
+  var omit = [];
+  var keep = [];
+  var idx = -1;
+
+  while (++idx < len) {
+    var pattern = patterns[idx];
+
+    if (typeof pattern === 'string' && pattern.charCodeAt(0) === 33 /* ! */) {
+      omit.push.apply(omit, nanomatch.match(list, pattern.slice(1), options));
+      negated = true;
+    } else {
+      keep.push.apply(keep, nanomatch.match(list, pattern, options));
+    }
+  }
+
+  // minimatch.match parity
+  if (negated && keep.length === 0) {
+    if (options && options.unixify === false) {
+      keep = list.slice();
+    } else {
+      var unixify = utils.unixify(options);
+      for (var i = 0; i < list.length; i++) {
+        keep.push(unixify(list[i]));
+      }
+    }
+  }
+
+  var matches = utils.diff(keep, omit);
+  if (!options || options.nodupes !== false) {
+    return utils.unique(matches);
+  }
+
+  return matches;
+}
+
+/**
+ * Similar to the main function, but `pattern` must be a string.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.match(list, pattern[, options]);
+ *
+ * console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
+ * //=> ['a.a', 'a.aa']
+ * ```
+ * @param {Array} `list` Array of strings to match
+ * @param {String} `pattern` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of matches
+ * @api public
+ */
+
+nanomatch.match = function(list, pattern, options) {
+  if (Array.isArray(pattern)) {
+    throw new TypeError('expected pattern to be a string');
+  }
+
+  var unixify = utils.unixify(options);
+  var isMatch = memoize('match', pattern, options, nanomatch.matcher);
+  var matches = [];
+
+  list = utils.arrayify(list);
+  var len = list.length;
+  var idx = -1;
+
+  while (++idx < len) {
+    var ele = list[idx];
+    if (ele === pattern || isMatch(ele)) {
+      matches.push(utils.value(ele, unixify, options));
+    }
+  }
+
+  // if no options were passed, uniquify results and return
+  if (typeof options === 'undefined') {
+    return utils.unique(matches);
+  }
+
+  if (matches.length === 0) {
+    if (options.failglob === true) {
+      throw new Error('no matches found for "' + pattern + '"');
+    }
+    if (options.nonull === true || options.nullglob === true) {
+      return [options.unescape ? utils.unescape(pattern) : pattern];
+    }
+  }
+
+  // if `opts.ignore` was defined, diff ignored list
+  if (options.ignore) {
+    matches = nanomatch.not(matches, options.ignore, options);
+  }
+
+  return options.nodupes !== false ? utils.unique(matches) : matches;
+};
+
+/**
+ * Returns true if the specified `string` matches the given glob `pattern`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.isMatch(string, pattern[, options]);
+ *
+ * console.log(nm.isMatch('a.a', '*.a'));
+ * //=> true
+ * console.log(nm.isMatch('a.b', '*.a'));
+ * //=> false
+ * ```
+ * @param {String} `string` String to match
+ * @param {String} `pattern` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if the string matches the glob pattern.
+ * @api public
+ */
+
+nanomatch.isMatch = function(str, pattern, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('expected a string: "' + util.inspect(str) + '"');
+  }
+
+  if (utils.isEmptyString(str) || utils.isEmptyString(pattern)) {
+    return false;
+  }
+
+  var equals = utils.equalsPattern(options);
+  if (equals(str)) {
+    return true;
+  }
+
+  var isMatch = memoize('isMatch', pattern, options, nanomatch.matcher);
+  return isMatch(str);
+};
+
+/**
+ * Returns true if some of the elements in the given `list` match any of the
+ * given glob `patterns`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.some(list, patterns[, options]);
+ *
+ * console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param  {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+nanomatch.some = function(list, patterns, options) {
+  if (typeof list === 'string') {
+    list = [list];
+  }
+
+  for (var i = 0; i < list.length; i++) {
+    if (nanomatch(list[i], patterns, options).length === 1) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Returns true if every element in the given `list` matches
+ * at least one of the given glob `patterns`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.every(list, patterns[, options]);
+ *
+ * console.log(nm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param  {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+nanomatch.every = function(list, patterns, options) {
+  if (typeof list === 'string') {
+    list = [list];
+  }
+
+  for (var i = 0; i < list.length; i++) {
+    if (nanomatch(list[i], patterns, options).length !== 1) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns`
+ * match the specified `string`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.any(string, patterns[, options]);
+ *
+ * console.log(nm.any('a.a', ['b.*', '*.a']));
+ * //=> true
+ * console.log(nm.any('a.a', 'b.*'));
+ * //=> false
+ * ```
+ * @param  {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+nanomatch.any = function(str, patterns, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('expected a string: "' + util.inspect(str) + '"');
+  }
+
+  if (utils.isEmptyString(str) || utils.isEmptyString(patterns)) {
+    return false;
+  }
+
+  if (typeof patterns === 'string') {
+    patterns = [patterns];
+  }
+
+  for (var i = 0; i < patterns.length; i++) {
+    if (nanomatch.isMatch(str, patterns[i], options)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Returns true if **all** of the given `patterns`
+ * match the specified string.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.all(string, patterns[, options]);
+ *
+ * console.log(nm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(nm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(nm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param  {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+nanomatch.all = function(str, patterns, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('expected a string: "' + util.inspect(str) + '"');
+  }
+
+  if (typeof patterns === 'string') {
+    patterns = [patterns];
+  }
+
+  for (var i = 0; i < patterns.length; i++) {
+    if (!nanomatch.isMatch(str, patterns[i], options)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.not(list, patterns[, options]);
+ *
+ * console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+nanomatch.not = function(list, patterns, options) {
+  var opts = extend({}, options);
+  var ignore = opts.ignore;
+  delete opts.ignore;
+
+  list = utils.arrayify(list);
+
+  var matches = utils.diff(list, nanomatch(list, patterns, opts));
+  if (ignore) {
+    matches = utils.diff(matches, nanomatch(list, ignore));
+  }
+
+  return opts.nodupes !== false ? utils.unique(matches) : matches;
+};
+
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.contains(string, pattern[, options]);
+ *
+ * console.log(nm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(nm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if the patter matches any part of `str`.
+ * @api public
+ */
+
+nanomatch.contains = function(str, patterns, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('expected a string: "' + util.inspect(str) + '"');
+  }
+
+  if (typeof patterns === 'string') {
+    if (utils.isEmptyString(str) || utils.isEmptyString(patterns)) {
+      return false;
+    }
+
+    var equals = utils.equalsPattern(patterns, options);
+    if (equals(str)) {
+      return true;
+    }
+    var contains = utils.containsPattern(patterns, options);
+    if (contains(str)) {
+      return true;
+    }
+  }
+
+  var opts = extend({}, options, {contains: true});
+  return nanomatch.any(str, patterns, opts);
+};
+
+/**
+ * Returns true if the given pattern and options should enable
+ * the `matchBase` option.
+ * @return {Boolean}
+ * @api private
+ */
+
+nanomatch.matchBase = function(pattern, options) {
+  if (pattern && pattern.indexOf('/') !== -1 || !options) return false;
+  return options.basename === true || options.matchBase === true;
+};
+
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.matchKeys(object, patterns[, options]);
+ *
+ * var obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(nm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
+
+nanomatch.matchKeys = function(obj, patterns, options) {
+  if (!utils.isObject(obj)) {
+    throw new TypeError('expected the first argument to be an object');
+  }
+  var keys = nanomatch(Object.keys(obj), patterns, options);
+  return utils.pick(obj, keys);
+};
+
+/**
+ * Returns a memoized matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.matcher(pattern[, options]);
+ *
+ * var isMatch = nm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a'));
+ * //=> false
+ * console.log(isMatch('a.b'));
+ * //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed.
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+nanomatch.matcher = function matcher(pattern, options) {
+  if (utils.isEmptyString(pattern)) {
+    return function() {
+      return false;
+    };
+  }
+
+  if (Array.isArray(pattern)) {
+    return compose(pattern, options, matcher);
+  }
+
+  // if pattern is a regex
+  if (pattern instanceof RegExp) {
+    return test(pattern);
+  }
+
+  // if pattern is invalid
+  if (!utils.isString(pattern)) {
+    throw new TypeError('expected pattern to be an array, string or regex');
+  }
+
+  // if pattern is a non-glob string
+  if (!utils.hasSpecialChars(pattern)) {
+    if (options && options.nocase === true) {
+      pattern = pattern.toLowerCase();
+    }
+    return utils.matchPath(pattern, options);
+  }
+
+  // if pattern is a glob string
+  var re = nanomatch.makeRe(pattern, options);
+
+  // if `options.matchBase` or `options.basename` is defined
+  if (nanomatch.matchBase(pattern, options)) {
+    return utils.matchBasename(re, options);
+  }
+
+  function test(regex) {
+    var equals = utils.equalsPattern(options);
+    var unixify = utils.unixify(options);
+
+    return function(str) {
+      if (equals(str)) {
+        return true;
+      }
+
+      if (regex.test(unixify(str))) {
+        return true;
+      }
+      return false;
+    };
+  }
+
+  // create matcher function
+  var matcherFn = test(re);
+  // set result object from compiler on matcher function,
+  // as a non-enumerable property. useful for debugging
+  utils.define(matcherFn, 'result', re.result);
+  return matcherFn;
+};
+
+/**
+ * Returns an array of matches captured by `pattern` in `string, or
+ * `null` if the pattern did not match.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.capture(pattern, string[, options]);
+ *
+ * console.log(nm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(nm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `pattern` Glob pattern to use for matching.
+ * @param {String} `string` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns an array of captures if the string matches the glob pattern, otherwise `null`.
+ * @api public
+ */
+
+nanomatch.capture = function(pattern, str, options) {
+  var re = nanomatch.makeRe(pattern, extend({capture: true}, options));
+  var unixify = utils.unixify(options);
+
+  function match() {
+    return function(string) {
+      var match = re.exec(unixify(string));
+      if (!match) {
+        return null;
+      }
+
+      return match.slice(1);
+    };
+  }
+
+  var capture = memoize('capture', pattern, options, match);
+  return capture(str);
+};
+
+/**
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.makeRe(pattern[, options]);
+ *
+ * console.log(nm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+nanomatch.makeRe = function(pattern, options) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError('expected pattern to be a string');
+  }
+
+  if (pattern.length > MAX_LENGTH) {
+    throw new Error('expected pattern to be less than ' + MAX_LENGTH + ' characters');
+  }
+
+  function makeRe() {
+    var opts = utils.extend({wrap: false}, options);
+    var result = nanomatch.create(pattern, opts);
+    var regex = toRegex(result.output, opts);
+    utils.define(regex, 'result', result);
+    return regex;
+  }
+
+  return memoize('makeRe', pattern, options, makeRe);
+};
+
+/**
+ * Parses the given glob `pattern` and returns an object with the compiled `output`
+ * and optional source `map`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.create(pattern[, options]);
+ *
+ * console.log(nm.create('abc/*.js'));
+ * // { options: { source: 'string', sourcemap: true },
+ * //   state: {},
+ * //   compilers:
+ * //    { ... },
+ * //   output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
+ * //   ast:
+ * //    { type: 'root',
+ * //      errors: [],
+ * //      nodes:
+ * //       [ ... ],
+ * //      dot: false,
+ * //      input: 'abc/*.js' },
+ * //   parsingErrors: [],
+ * //   map:
+ * //    { version: 3,
+ * //      sources: [ 'string' ],
+ * //      names: [],
+ * //      mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
+ * //      sourcesContent: [ 'abc/*.js' ] },
+ * //   position: { line: 1, column: 28 },
+ * //   content: {},
+ * //   files: {},
+ * //   idx: 6 }
+ * ```
+ * @param {String} `pattern` Glob pattern to parse and compile.
+ * @param {Object} `options` Any [options](#options) to change how parsing and compiling is performed.
+ * @return {Object} Returns an object with the parsed AST, compiled string and optional source map.
+ * @api public
+ */
+
+nanomatch.create = function(pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('expected a string');
+  }
+  function create() {
+    return nanomatch.compile(nanomatch.parse(pattern, options), options);
+  }
+  return memoize('create', pattern, options, create);
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.parse(pattern[, options]);
+ *
+ * var ast = nm.parse('a/{b,c}/d');
+ * console.log(ast);
+ * // { type: 'root',
+ * //   errors: [],
+ * //   input: 'a/{b,c}/d',
+ * //   nodes:
+ * //    [ { type: 'bos', val: '' },
+ * //      { type: 'text', val: 'a/' },
+ * //      { type: 'brace',
+ * //        nodes:
+ * //         [ { type: 'brace.open', val: '{' },
+ * //           { type: 'text', val: 'b,c' },
+ * //           { type: 'brace.close', val: '}' } ] },
+ * //      { type: 'text', val: '/d' },
+ * //      { type: 'eos', val: '' } ] }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+nanomatch.parse = function(pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('expected a string');
+  }
+
+  function parse() {
+    var snapdragon = utils.instantiate(null, options);
+    parsers(snapdragon, options);
+
+    var ast = snapdragon.parse(pattern, options);
+    utils.define(ast, 'snapdragon', snapdragon);
+    ast.input = pattern;
+    return ast;
+  }
+
+  return memoize('parse', pattern, options, parse);
+};
+
+/**
+ * Compile the given `ast` or string with the given `options`.
+ *
+ * ```js
+ * var nm = require('nanomatch');
+ * nm.compile(ast[, options]);
+ *
+ * var ast = nm.parse('a/{b,c}/d');
+ * console.log(nm.compile(ast));
+ * // { options: { source: 'string' },
+ * //   state: {},
+ * //   compilers:
+ * //    { eos: [Function],
+ * //      noop: [Function],
+ * //      bos: [Function],
+ * //      brace: [Function],
+ * //      'brace.open': [Function],
+ * //      text: [Function],
+ * //      'brace.close': [Function] },
+ * //   output: [ 'a/(b|c)/d' ],
+ * //   ast:
+ * //    { ... },
+ * //   parsingErrors: [] }
+ * ```
+ * @param {Object|String} `ast`
+ * @param {Object} `options`
+ * @return {Object} Returns an object that has an `output` property with the compiled string.
+ * @api public
+ */
+
+nanomatch.compile = function(ast, options) {
+  if (typeof ast === 'string') {
+    ast = nanomatch.parse(ast, options);
+  }
+
+  function compile() {
+    var snapdragon = utils.instantiate(ast, options);
+    compilers(snapdragon, options);
+    return snapdragon.compile(ast, options);
+  }
+
+  return memoize('compile', ast.input, options, compile);
+};
+
+/**
+ * Clear the regex cache.
+ *
+ * ```js
+ * nm.clearCache();
+ * ```
+ * @api public
+ */
+
+nanomatch.clearCache = function() {
+  nanomatch.cache.__data__ = {};
+};
+
+/**
+ * Compose a matcher function with the given patterns.
+ * This allows matcher functions to be compiled once and
+ * called multiple times.
+ */
+
+function compose(patterns, options, matcher) {
+  var matchers;
+
+  return memoize('compose', String(patterns), options, function() {
+    return function(file) {
+      // delay composition until it's invoked the first time,
+      // after that it won't be called again
+      if (!matchers) {
+        matchers = [];
+        for (var i = 0; i < patterns.length; i++) {
+          matchers.push(matcher(patterns[i], options));
+        }
+      }
+
+      var len = matchers.length;
+      while (len--) {
+        if (matchers[len](file) === true) {
+          return true;
+        }
+      }
+      return false;
+    };
+  });
+}
+
+/**
+ * Memoize a generated regex or function. A unique key is generated
+ * from the `type` (usually method name), the `pattern`, and
+ * user-defined options.
+ */
+
+function memoize(type, pattern, options, fn) {
+  var key = utils.createKey(type + '=' + pattern, options);
+
+  if (options && options.cache === false) {
+    return fn(pattern, options);
+  }
+
+  if (cache.has(type, key)) {
+    return cache.get(type, key);
+  }
+
+  var val = fn(pattern, options);
+  cache.set(type, key, val);
+  return val;
+}
+
+/**
+ * Expose compiler, parser and cache on `nanomatch`
+ */
+
+nanomatch.compilers = compilers;
+nanomatch.parsers = parsers;
+nanomatch.cache = cache;
+
+/**
+ * Expose `nanomatch`
+ * @type {Function}
+ */
+
+module.exports = nanomatch;
diff --git a/node_modules/nanomatch/lib/cache.js b/node_modules/nanomatch/lib/cache.js
new file mode 100644
index 0000000..fffc4c1
--- /dev/null
+++ b/node_modules/nanomatch/lib/cache.js
@@ -0,0 +1 @@
+module.exports = new (require('fragment-cache'))();
diff --git a/node_modules/nanomatch/lib/compilers.js b/node_modules/nanomatch/lib/compilers.js
new file mode 100644
index 0000000..d7a786e
--- /dev/null
+++ b/node_modules/nanomatch/lib/compilers.js
@@ -0,0 +1,339 @@
+'use strict';
+
+/**
+* Nanomatch compilers
+*/
+
+module.exports = function(nanomatch, options) {
+  function slash() {
+    if (options && typeof options.slash === 'string') {
+      return options.slash;
+    }
+    if (options && typeof options.slash === 'function') {
+      return options.slash.call(nanomatch);
+    }
+    return '\\\\/';
+  }
+
+  function star() {
+    if (options && typeof options.star === 'string') {
+      return options.star;
+    }
+    if (options && typeof options.star === 'function') {
+      return options.star.call(nanomatch);
+    }
+    return '[^' + slash() + ']*?';
+  }
+
+  var ast = nanomatch.ast = nanomatch.parser.ast;
+  ast.state = nanomatch.parser.state;
+  nanomatch.compiler.state = ast.state;
+  nanomatch.compiler
+
+    /**
+     * Negation / escaping
+     */
+
+    .set('not', function(node) {
+      var prev = this.prev();
+      if (this.options.nonegate === true || prev.type !== 'bos') {
+        return this.emit('\\' + node.val, node);
+      }
+      return this.emit(node.val, node);
+    })
+    .set('escape', function(node) {
+      if (this.options.unescape && /^[-\w_.]/.test(node.val)) {
+        return this.emit(node.val, node);
+      }
+      return this.emit('\\' + node.val, node);
+    })
+    .set('quoted', function(node) {
+      return this.emit(node.val, node);
+    })
+
+    /**
+     * Regex
+     */
+
+    .set('dollar', function(node) {
+      if (node.parent.type === 'bracket') {
+        return this.emit(node.val, node);
+      }
+      return this.emit('\\' + node.val, node);
+    })
+
+    /**
+     * Dot: "."
+     */
+
+    .set('dot', function(node) {
+      if (node.dotfiles === true) this.dotfiles = true;
+      return this.emit('\\' + node.val, node);
+    })
+
+    /**
+     * Slashes: "/" and "\"
+     */
+
+    .set('backslash', function(node) {
+      return this.emit(node.val, node);
+    })
+    .set('slash', function(node, nodes, i) {
+      var val = '[' + slash() + ']';
+      var parent = node.parent;
+      var prev = this.prev();
+
+      // set "node.hasSlash" to true on all ancestor parens nodes
+      while (parent.type === 'paren' && !parent.hasSlash) {
+        parent.hasSlash = true;
+        parent = parent.parent;
+      }
+
+      if (prev.addQmark) {
+        val += '?';
+      }
+
+      // word boundary
+      if (node.rest.slice(0, 2) === '\\b') {
+        return this.emit(val, node);
+      }
+
+      // globstars
+      if (node.parsed === '**' || node.parsed === './**') {
+        this.output = '(?:' + this.output;
+        return this.emit(val + ')?', node);
+      }
+
+      // negation
+      if (node.parsed === '!**' && this.options.nonegate !== true) {
+        return this.emit(val + '?\\b', node);
+      }
+      return this.emit(val, node);
+    })
+
+    /**
+     * Square brackets
+     */
+
+    .set('bracket', function(node) {
+      var close = node.close;
+      var open = !node.escaped ? '[' : '\\[';
+      var negated = node.negated;
+      var inner = node.inner;
+      var val = node.val;
+
+      if (node.escaped === true) {
+        inner = inner.replace(/\\?(\W)/g, '\\$1');
+        negated = '';
+      }
+
+      if (inner === ']-') {
+        inner = '\\]\\-';
+      }
+
+      if (negated && inner.indexOf('.') === -1) {
+        inner += '.';
+      }
+      if (negated && inner.indexOf('/') === -1) {
+        inner += '/';
+      }
+
+      val = open + negated + inner + close;
+      return this.emit(val, node);
+    })
+
+    /**
+     * Square: "[.]" (only matches a single character in brackets)
+     */
+
+    .set('square', function(node) {
+      var val = (/^\W/.test(node.val) ? '\\' : '') + node.val;
+      return this.emit(val, node);
+    })
+
+    /**
+     * Question mark: "?"
+     */
+
+    .set('qmark', function(node) {
+      var prev = this.prev();
+      // don't use "slash" variable so that we always avoid
+      // matching backslashes and slashes with a qmark
+      var val = '[^.\\\\/]';
+      if (this.options.dot || (prev.type !== 'bos' && prev.type !== 'slash')) {
+        val = '[^\\\\/]';
+      }
+
+      if (node.parsed.slice(-1) === '(') {
+        var ch = node.rest.charAt(0);
+        if (ch === '!' || ch === '=' || ch === ':') {
+          return this.emit(node.val, node);
+        }
+      }
+
+      if (node.val.length > 1) {
+        val += '{' + node.val.length + '}';
+      }
+      return this.emit(val, node);
+    })
+
+    /**
+     * Plus
+     */
+
+    .set('plus', function(node) {
+      var prev = node.parsed.slice(-1);
+      if (prev === ']' || prev === ')') {
+        return this.emit(node.val, node);
+      }
+      if (!this.output || (/[?*+]/.test(ch) && node.parent.type !== 'bracket')) {
+        return this.emit('\\+', node);
+      }
+      var ch = this.output.slice(-1);
+      if (/\w/.test(ch) && !node.inside) {
+        return this.emit('+\\+?', node);
+      }
+      return this.emit('+', node);
+    })
+
+    /**
+     * globstar: '**'
+     */
+
+    .set('globstar', function(node, nodes, i) {
+      if (!this.output) {
+        this.state.leadingGlobstar = true;
+      }
+
+      var prev = this.prev();
+      var before = this.prev(2);
+      var next = this.next();
+      var after = this.next(2);
+      var type = prev.type;
+      var val = node.val;
+
+      if (prev.type === 'slash' && next.type === 'slash') {
+        if (before.type === 'text') {
+          this.output += '?';
+
+          if (after.type !== 'text') {
+            this.output += '\\b';
+          }
+        }
+      }
+
+      var parsed = node.parsed;
+      if (parsed.charAt(0) === '!') {
+        parsed = parsed.slice(1);
+      }
+
+      var isInside = node.isInside.paren || node.isInside.brace;
+      if (parsed && type !== 'slash' && type !== 'bos' && !isInside) {
+        val = star();
+      } else {
+        val = this.options.dot !== true
+          ? '(?:(?!(?:[' + slash() + ']|^)\\.).)*?'
+          : '(?:(?!(?:[' + slash() + ']|^)(?:\\.{1,2})($|[' + slash() + ']))(?!\\.{2}).)*?';
+      }
+
+      if ((type === 'slash' || type === 'bos') && this.options.dot !== true) {
+        val = '(?!\\.)' + val;
+      }
+
+      if (prev.type === 'slash' && next.type === 'slash' && before.type !== 'text') {
+        if (after.type === 'text' || after.type === 'star') {
+          node.addQmark = true;
+        }
+      }
+
+      if (this.options.capture) {
+        val = '(' + val + ')';
+      }
+
+      return this.emit(val, node);
+    })
+
+    /**
+     * Star: "*"
+     */
+
+    .set('star', function(node, nodes, i) {
+      var prior = nodes[i - 2] || {};
+      var prev = this.prev();
+      var next = this.next();
+      var type = prev.type;
+
+      function isStart(n) {
+        return n.type === 'bos' || n.type === 'slash';
+      }
+
+      if (this.output === '' && this.options.contains !== true) {
+        this.output = '(?![' + slash() + '])';
+      }
+
+      if (type === 'bracket' && this.options.bash === false) {
+        var str = next && next.type === 'bracket' ? star() : '*?';
+        if (!prev.nodes || prev.nodes[1].type !== 'posix') {
+          return this.emit(str, node);
+        }
+      }
+
+      var prefix = !this.dotfiles && type !== 'text' && type !== 'escape'
+        ? (this.options.dot ? '(?!(?:^|[' + slash() + '])\\.{1,2}(?:$|[' + slash() + ']))' : '(?!\\.)')
+        : '';
+
+      if (isStart(prev) || (isStart(prior) && type === 'not')) {
+        if (prefix !== '(?!\\.)') {
+          prefix += '(?!(\\.{2}|\\.[' + slash() + ']))(?=.)';
+        } else {
+          prefix += '(?=.)';
+        }
+      } else if (prefix === '(?!\\.)') {
+        prefix = '';
+      }
+
+      if (prev.type === 'not' && prior.type === 'bos' && this.options.dot === true) {
+        this.output = '(?!\\.)' + this.output;
+      }
+
+      var output = prefix + star();
+      if (this.options.capture) {
+        output = '(' + output + ')';
+      }
+
+      return this.emit(output, node);
+    })
+
+    /**
+     * Text
+     */
+
+    .set('text', function(node) {
+      return this.emit(node.val, node);
+    })
+
+    /**
+     * End-of-string
+     */
+
+    .set('eos', function(node) {
+      var prev = this.prev();
+      var val = node.val;
+
+      this.output = '(?:\\.[' + slash() + '](?=.))?' + this.output;
+      if (this.state.metachar && prev.type !== 'qmark' && prev.type !== 'slash') {
+        val += (this.options.contains ? '[' + slash() + ']?' : '(?:[' + slash() + ']|$)');
+      }
+
+      return this.emit(val, node);
+    });
+
+  /**
+   * Allow custom compilers to be passed on options
+   */
+
+  if (options && typeof options.compilers === 'function') {
+    options.compilers(nanomatch.compiler);
+  }
+};
+
diff --git a/node_modules/nanomatch/lib/parsers.js b/node_modules/nanomatch/lib/parsers.js
new file mode 100644
index 0000000..f87df8f
--- /dev/null
+++ b/node_modules/nanomatch/lib/parsers.js
@@ -0,0 +1,386 @@
+'use strict';
+
+var regexNot = require('regex-not');
+var toRegex = require('to-regex');
+
+/**
+ * Characters to use in negation regex (we want to "not" match
+ * characters that are matched by other parsers)
+ */
+
+var cached;
+var NOT_REGEX = '[\\[!*+?$^"\'.\\\\/]+';
+var not = createTextRegex(NOT_REGEX);
+
+/**
+ * Nanomatch parsers
+ */
+
+module.exports = function(nanomatch, options) {
+  var parser = nanomatch.parser;
+  var opts = parser.options;
+
+  parser.state = {
+    slashes: 0,
+    paths: []
+  };
+
+  parser.ast.state = parser.state;
+  parser
+
+    /**
+     * Beginning-of-string
+     */
+
+    .capture('prefix', function() {
+      if (this.parsed) return;
+      var m = this.match(/^\.[\\/]/);
+      if (!m) return;
+      this.state.strictOpen = !!this.options.strictOpen;
+      this.state.addPrefix = true;
+    })
+
+    /**
+     * Escape: "\\."
+     */
+
+    .capture('escape', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(/^(?:\\(.)|([$^]))/);
+      if (!m) return;
+
+      return pos({
+        type: 'escape',
+        val: m[2] || m[1]
+      });
+    })
+
+    /**
+     * Quoted strings
+     */
+
+    .capture('quoted', function() {
+      var pos = this.position();
+      var m = this.match(/^["']/);
+      if (!m) return;
+
+      var quote = m[0];
+      if (this.input.indexOf(quote) === -1) {
+        return pos({
+          type: 'escape',
+          val: quote
+        });
+      }
+
+      var tok = advanceTo(this.input, quote);
+      this.consume(tok.len);
+
+      return pos({
+        type: 'quoted',
+        val: tok.esc
+      });
+    })
+
+    /**
+     * Negations: "!"
+     */
+
+    .capture('not', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(this.notRegex || /^!+/);
+      if (!m) return;
+      var val = m[0];
+
+      var isNegated = (val.length % 2) === 1;
+      if (parsed === '' && !isNegated) {
+        val = '';
+      }
+
+      // if nothing has been parsed, we know `!` is at the start,
+      // so we need to wrap the result in a negation regex
+      if (parsed === '' && isNegated && this.options.nonegate !== true) {
+        this.bos.val = '(?!^(?:';
+        this.append = ')$).*';
+        val = '';
+      }
+      return pos({
+        type: 'not',
+        val: val
+      });
+    })
+
+    /**
+     * Dot: "."
+     */
+
+    .capture('dot', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\.+/);
+      if (!m) return;
+
+      var val = m[0];
+      this.state.dot = val === '.' && (parsed === '' || parsed.slice(-1) === '/');
+
+      return pos({
+        type: 'dot',
+        dotfiles: this.state.dot,
+        val: val
+      });
+    })
+
+    /**
+     * Plus: "+"
+     */
+
+    .capture('plus', /^\+(?!\()/)
+
+    /**
+     * Question mark: "?"
+     */
+
+    .capture('qmark', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\?+(?!\()/);
+      if (!m) return;
+
+      this.state.metachar = true;
+      this.state.qmark = true;
+
+      return pos({
+        type: 'qmark',
+        parsed: parsed,
+        val: m[0]
+      });
+    })
+
+    /**
+     * Globstar: "**"
+     */
+
+    .capture('globstar', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\*{2}(?![*(])(?=[,)/]|$)/);
+      if (!m) return;
+
+      var type = opts.noglobstar !== true ? 'globstar' : 'star';
+      var node = pos({type: type, parsed: parsed});
+      this.state.metachar = true;
+
+      while (this.input.slice(0, 4) === '/**/') {
+        this.input = this.input.slice(3);
+      }
+
+      node.isInside = {
+        brace: this.isInside('brace'),
+        paren: this.isInside('paren')
+      };
+
+      if (type === 'globstar') {
+        this.state.globstar = true;
+        node.val = '**';
+
+      } else {
+        this.state.star = true;
+        node.val = '*';
+      }
+
+      return node;
+    })
+
+    /**
+     * Star: "*"
+     */
+
+    .capture('star', function() {
+      var pos = this.position();
+      var starRe = /^(?:\*(?![*(])|[*]{3,}(?!\()|[*]{2}(?![(/]|$)|\*(?=\*\())/;
+      var m = this.match(starRe);
+      if (!m) return;
+
+      this.state.metachar = true;
+      this.state.star = true;
+      return pos({
+        type: 'star',
+        val: m[0]
+      });
+    })
+
+    /**
+     * Slash: "/"
+     */
+
+    .capture('slash', function() {
+      var pos = this.position();
+      var m = this.match(/^\//);
+      if (!m) return;
+
+      this.state.slashes++;
+      return pos({
+        type: 'slash',
+        val: m[0]
+      });
+    })
+
+    /**
+     * Backslash: "\\"
+     */
+
+    .capture('backslash', function() {
+      var pos = this.position();
+      var m = this.match(/^\\(?![*+?(){}[\]'"])/);
+      if (!m) return;
+
+      var val = m[0];
+
+      if (this.isInside('bracket')) {
+        val = '\\';
+      } else if (val.length > 1) {
+        val = '\\\\';
+      }
+
+      return pos({
+        type: 'backslash',
+        val: val
+      });
+    })
+
+    /**
+     * Square: "[.]"
+     */
+
+    .capture('square', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(/^\[([^!^\\])\]/);
+      if (!m) return;
+
+      return pos({
+        type: 'square',
+        val: m[1]
+      });
+    })
+
+    /**
+     * Brackets: "[...]" (basic, this can be overridden by other parsers)
+     */
+
+    .capture('bracket', function() {
+      var pos = this.position();
+      var m = this.match(/^(?:\[([!^]?)([^\]]+|\]-)(\]|[^*+?]+)|\[)/);
+      if (!m) return;
+
+      var val = m[0];
+      var negated = m[1] ? '^' : '';
+      var inner = (m[2] || '').replace(/\\\\+/, '\\\\');
+      var close = m[3] || '';
+
+      if (m[2] && inner.length < m[2].length) {
+        val = val.replace(/\\\\+/, '\\\\');
+      }
+
+      var esc = this.input.slice(0, 2);
+      if (inner === '' && esc === '\\]') {
+        inner += esc;
+        this.consume(2);
+
+        var str = this.input;
+        var idx = -1;
+        var ch;
+
+        while ((ch = str[++idx])) {
+          this.consume(1);
+          if (ch === ']') {
+            close = ch;
+            break;
+          }
+          inner += ch;
+        }
+      }
+
+      return pos({
+        type: 'bracket',
+        val: val,
+        escaped: close !== ']',
+        negated: negated,
+        inner: inner,
+        close: close
+      });
+    })
+
+    /**
+     * Text
+     */
+
+    .capture('text', function() {
+      if (this.isInside('bracket')) return;
+      var pos = this.position();
+      var m = this.match(not);
+      if (!m || !m[0]) return;
+
+      return pos({
+        type: 'text',
+        val: m[0]
+      });
+    });
+
+  /**
+   * Allow custom parsers to be passed on options
+   */
+
+  if (options && typeof options.parsers === 'function') {
+    options.parsers(nanomatch.parser);
+  }
+};
+
+/**
+ * Advance to the next non-escaped character
+ */
+
+function advanceTo(input, endChar) {
+  var ch = input.charAt(0);
+  var tok = { len: 1, val: '', esc: '' };
+  var idx = 0;
+
+  function advance() {
+    if (ch !== '\\') {
+      tok.esc += '\\' + ch;
+      tok.val += ch;
+    }
+
+    ch = input.charAt(++idx);
+    tok.len++;
+
+    if (ch === '\\') {
+      advance();
+      advance();
+    }
+  }
+
+  while (ch && ch !== endChar) {
+    advance();
+  }
+  return tok;
+}
+
+/**
+ * Create text regex
+ */
+
+function createTextRegex(pattern) {
+  if (cached) return cached;
+  var opts = {contains: true, strictClose: false};
+  var not = regexNot.create(pattern, opts);
+  var re = toRegex('^(?:[*]\\((?=.)|' + not + ')', opts);
+  return (cached = re);
+}
+
+/**
+ * Expose negation string
+ */
+
+module.exports.not = NOT_REGEX;
diff --git a/node_modules/nanomatch/lib/utils.js b/node_modules/nanomatch/lib/utils.js
new file mode 100644
index 0000000..0cf1501
--- /dev/null
+++ b/node_modules/nanomatch/lib/utils.js
@@ -0,0 +1,379 @@
+'use strict';
+
+var utils = module.exports;
+var path = require('path');
+
+/**
+ * Module dependencies
+ */
+
+var isWindows = require('is-windows')();
+var Snapdragon = require('snapdragon');
+utils.define = require('define-property');
+utils.diff = require('arr-diff');
+utils.extend = require('extend-shallow');
+utils.pick = require('object.pick');
+utils.typeOf = require('kind-of');
+utils.unique = require('array-unique');
+
+/**
+ * Returns true if the given value is effectively an empty string
+ */
+
+utils.isEmptyString = function(val) {
+  return String(val) === '' || String(val) === './';
+};
+
+/**
+ * Returns true if the platform is windows, or `path.sep` is `\\`.
+ * This is defined as a function to allow `path.sep` to be set in unit tests,
+ * or by the user, if there is a reason to do so.
+ * @return {Boolean}
+ */
+
+utils.isWindows = function() {
+  return path.sep === '\\' || isWindows === true;
+};
+
+/**
+ * Return the last element from an array
+ */
+
+utils.last = function(arr, n) {
+  return arr[arr.length - (n || 1)];
+};
+
+/**
+ * Get the `Snapdragon` instance to use
+ */
+
+utils.instantiate = function(ast, options) {
+  var snapdragon;
+  // if an instance was created by `.parse`, use that instance
+  if (utils.typeOf(ast) === 'object' && ast.snapdragon) {
+    snapdragon = ast.snapdragon;
+  // if the user supplies an instance on options, use that instance
+  } else if (utils.typeOf(options) === 'object' && options.snapdragon) {
+    snapdragon = options.snapdragon;
+  // create a new instance
+  } else {
+    snapdragon = new Snapdragon(options);
+  }
+
+  utils.define(snapdragon, 'parse', function(str, options) {
+    var parsed = Snapdragon.prototype.parse.call(this, str, options);
+    parsed.input = str;
+
+    // escape unmatched brace/bracket/parens
+    var last = this.parser.stack.pop();
+    if (last && this.options.strictErrors !== true) {
+      var open = last.nodes[0];
+      var inner = last.nodes[1];
+      if (last.type === 'bracket') {
+        if (inner.val.charAt(0) === '[') {
+          inner.val = '\\' + inner.val;
+        }
+
+      } else {
+        open.val = '\\' + open.val;
+        var sibling = open.parent.nodes[1];
+        if (sibling.type === 'star') {
+          sibling.loose = true;
+        }
+      }
+    }
+
+    // add non-enumerable parser reference
+    utils.define(parsed, 'parser', this.parser);
+    return parsed;
+  });
+
+  return snapdragon;
+};
+
+/**
+ * Create the key to use for memoization. The key is generated
+ * by iterating over the options and concatenating key-value pairs
+ * to the pattern string.
+ */
+
+utils.createKey = function(pattern, options) {
+  if (typeof options === 'undefined') {
+    return pattern;
+  }
+  var key = pattern;
+  for (var prop in options) {
+    if (options.hasOwnProperty(prop)) {
+      key += ';' + prop + '=' + String(options[prop]);
+    }
+  }
+  return key;
+};
+
+/**
+ * Cast `val` to an array
+ * @return {Array}
+ */
+
+utils.arrayify = function(val) {
+  if (typeof val === 'string') return [val];
+  return val ? (Array.isArray(val) ? val : [val]) : [];
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isString = function(val) {
+  return typeof val === 'string';
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isRegex = function(val) {
+  return utils.typeOf(val) === 'regexp';
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isObject = function(val) {
+  return utils.typeOf(val) === 'object';
+};
+
+/**
+ * Escape regex characters in the given string
+ */
+
+utils.escapeRegex = function(str) {
+  return str.replace(/[-[\]{}()^$|*+?.\\/\s]/g, '\\$&');
+};
+
+/**
+ * Combines duplicate characters in the provided `input` string.
+ * @param {String} `input`
+ * @returns {String}
+ */
+
+utils.combineDupes = function(input, patterns) {
+  patterns = utils.arrayify(patterns).join('|').split('|');
+  patterns = patterns.map(function(s) {
+    return s.replace(/\\?([+*\\/])/g, '\\$1');
+  });
+  var substr = patterns.join('|');
+  var regex = new RegExp('(' + substr + ')(?=\\1)', 'g');
+  return input.replace(regex, '');
+};
+
+/**
+ * Returns true if the given `str` has special characters
+ */
+
+utils.hasSpecialChars = function(str) {
+  return /(?:(?:(^|\/)[!.])|[*?+()|[\]{}]|[+@]\()/.test(str);
+};
+
+/**
+ * Normalize slashes in the given filepath.
+ *
+ * @param {String} `filepath`
+ * @return {String}
+ */
+
+utils.toPosixPath = function(str) {
+  return str.replace(/\\+/g, '/');
+};
+
+/**
+ * Strip backslashes before special characters in a string.
+ *
+ * @param {String} `str`
+ * @return {String}
+ */
+
+utils.unescape = function(str) {
+  return utils.toPosixPath(str.replace(/\\(?=[*+?!.])/g, ''));
+};
+
+/**
+ * Strip the drive letter from a windows filepath
+ * @param {String} `fp`
+ * @return {String}
+ */
+
+utils.stripDrive = function(fp) {
+  return utils.isWindows() ? fp.replace(/^[a-z]:[\\/]+?/i, '/') : fp;
+};
+
+/**
+ * Strip the prefix from a filepath
+ * @param {String} `fp`
+ * @return {String}
+ */
+
+utils.stripPrefix = function(str) {
+  if (str.charAt(0) === '.' && (str.charAt(1) === '/' || str.charAt(1) === '\\')) {
+    return str.slice(2);
+  }
+  return str;
+};
+
+/**
+ * Returns true if `str` is a common character that doesn't need
+ * to be processed to be used for matching.
+ * @param {String} `str`
+ * @return {Boolean}
+ */
+
+utils.isSimpleChar = function(str) {
+  return str.trim() === '' || str === '.';
+};
+
+/**
+ * Returns true if the given str is an escaped or
+ * unescaped path character
+ */
+
+utils.isSlash = function(str) {
+  return str === '/' || str === '\\/' || str === '\\' || str === '\\\\';
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern matches or contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.matchPath = function(pattern, options) {
+  return (options && options.contains)
+    ? utils.containsPattern(pattern, options)
+    : utils.equalsPattern(pattern, options);
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path are equal
+ * to the given pattern.
+ */
+
+utils._equals = function(filepath, unixPath, pattern) {
+  return pattern === filepath || pattern === unixPath;
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path contain
+ * the given pattern.
+ */
+
+utils._contains = function(filepath, unixPath, pattern) {
+  return filepath.indexOf(pattern) !== -1 || unixPath.indexOf(pattern) !== -1;
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern is the same as a given `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.equalsPattern = function(pattern, options) {
+  var unixify = utils.unixify(options);
+  options = options || {};
+
+  return function fn(filepath) {
+    var equal = utils._equals(filepath, unixify(filepath), pattern);
+    if (equal === true || options.nocase !== true) {
+      return equal;
+    }
+    var lower = filepath.toLowerCase();
+    return utils._equals(lower, unixify(lower), pattern);
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.containsPattern = function(pattern, options) {
+  var unixify = utils.unixify(options);
+  options = options || {};
+
+  return function(filepath) {
+    var contains = utils._contains(filepath, unixify(filepath), pattern);
+    if (contains === true || options.nocase !== true) {
+      return contains;
+    }
+    var lower = filepath.toLowerCase();
+    return utils._contains(lower, unixify(lower), pattern);
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * regex matches the `filename` of a file path.
+ *
+ * @param {RegExp} `re` Matching regex
+ * @return {Function}
+ */
+
+utils.matchBasename = function(re) {
+  return function(filepath) {
+    return re.test(filepath) || re.test(path.basename(filepath));
+  };
+};
+
+/**
+ * Returns the given value unchanced.
+ * @return {any}
+ */
+
+utils.identity = function(val) {
+  return val;
+};
+
+/**
+ * Determines the filepath to return based on the provided options.
+ * @return {any}
+ */
+
+utils.value = function(str, unixify, options) {
+  if (options && options.unixify === false) {
+    return str;
+  }
+  if (options && typeof options.unixify === 'function') {
+    return options.unixify(str);
+  }
+  return unixify(str);
+};
+
+/**
+ * Returns a function that normalizes slashes in a string to forward
+ * slashes, strips `./` from beginning of paths, and optionally unescapes
+ * special characters.
+ * @return {Function}
+ */
+
+utils.unixify = function(options) {
+  var opts = options || {};
+  return function(filepath) {
+    if (opts.stripPrefix !== false) {
+      filepath = utils.stripPrefix(filepath);
+    }
+    if (opts.unescape === true) {
+      filepath = utils.unescape(filepath);
+    }
+    if (opts.unixify === true || utils.isWindows()) {
+      filepath = utils.toPosixPath(filepath);
+    }
+    return filepath;
+  };
+};
diff --git a/node_modules/nanomatch/package.json b/node_modules/nanomatch/package.json
new file mode 100644
index 0000000..e15c0e3
--- /dev/null
+++ b/node_modules/nanomatch/package.json
@@ -0,0 +1,175 @@
+{
+  "_args": [
+    [
+      "nanomatch@1.2.13",
+      "/home/dstaesse/git/website"
+    ]
+  ],
+  "_development": true,
+  "_from": "nanomatch@1.2.13",
+  "_id": "nanomatch@1.2.13",
+  "_inBundle": false,
+  "_integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
+  "_location": "/nanomatch",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "nanomatch@1.2.13",
+    "name": "nanomatch",
+    "escapedName": "nanomatch",
+    "rawSpec": "1.2.13",
+    "saveSpec": null,
+    "fetchSpec": "1.2.13"
+  },
+  "_requiredBy": [
+    "/micromatch"
+  ],
+  "_resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz",
+  "_spec": "1.2.13",
+  "_where": "/home/dstaesse/git/website",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "bugs": {
+    "url": "https://github.com/micromatch/nanomatch/issues"
+  },
+  "contributors": [
+    {
+      "name": "Devon Govett",
+      "url": "http://badassjs.com"
+    },
+    {
+      "name": "Jon Schlinkert",
+      "url": "http://twitter.com/jonschlinkert"
+    }
+  ],
+  "dependencies": {
+    "arr-diff": "^4.0.0",
+    "array-unique": "^0.3.2",
+    "define-property": "^2.0.2",
+    "extend-shallow": "^3.0.2",
+    "fragment-cache": "^0.2.1",
+    "is-windows": "^1.0.2",
+    "kind-of": "^6.0.2",
+    "object.pick": "^1.3.0",
+    "regex-not": "^1.0.0",
+    "snapdragon": "^0.8.1",
+    "to-regex": "^3.0.1"
+  },
+  "description": "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)",
+  "devDependencies": {
+    "bash-match": "^1.0.2",
+    "for-own": "^1.0.0",
+    "gulp": "^3.9.1",
+    "gulp-format-md": "^1.0.0",
+    "gulp-istanbul": "^1.1.3",
+    "gulp-mocha": "^5.0.0",
+    "helper-changelog": "^0.3.0",
+    "minimatch": "^3.0.4",
+    "minimist": "^1.2.0",
+    "mocha": "^3.5.3",
+    "multimatch": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "homepage": "https://github.com/micromatch/nanomatch",
+  "keywords": [
+    "bash",
+    "expand",
+    "expansion",
+    "expression",
+    "file",
+    "files",
+    "filter",
+    "find",
+    "glob",
+    "globbing",
+    "globs",
+    "globstar",
+    "match",
+    "matcher",
+    "matches",
+    "matching",
+    "micromatch",
+    "minimatch",
+    "multimatch",
+    "nanomatch",
+    "path",
+    "pattern",
+    "patterns",
+    "regex",
+    "regexp",
+    "regular",
+    "shell",
+    "wildcard"
+  ],
+  "license": "MIT",
+  "lintDeps": {
+    "dependencies": {
+      "options": {
+        "lock": {
+          "snapdragon": "^0.8.1"
+        }
+      }
+    },
+    "devDependencies": {
+      "files": {
+        "options": {
+          "ignore": [
+            "benchmark/**"
+          ]
+        }
+      }
+    }
+  },
+  "main": "index.js",
+  "name": "nanomatch",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/micromatch/nanomatch.git"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "verb": {
+    "toc": "collapsible",
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "helpers": [
+      "helper-changelog"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "related": {
+      "list": [
+        "extglob",
+        "is-extglob",
+        "is-glob",
+        "micromatch"
+      ]
+    },
+    "reflinks": [
+      "expand-brackets",
+      "expand-tilde",
+      "glob-object",
+      "micromatch",
+      "minimatch",
+      "options",
+      "snapdragon"
+    ],
+    "lint": {
+      "reflinks": true
+    }
+  },
+  "version": "1.2.13"
+}