:/...`, and vice versa,
+ as if the `//?/` was not present. This behavior only is
+ present when the drive letters are a case-insensitive match to
+ one another. The remaining portions of the path/pattern are
+ compared case sensitively, unless `nocase:true` is set.
+
+Note that specifying a UNC path using `\` characters as path
+separators is always allowed in the file path argument, but only
+allowed in the pattern argument when `windowsPathsNoEscape: true`
+is set in the options.
+
+## Minimatch Class
+
+Create a minimatch object by instantiating the `minimatch.Minimatch` class.
+
+```javascript
+var Minimatch = require('minimatch').Minimatch
+var mm = new Minimatch(pattern, options)
+```
+
+### Properties
+
+- `pattern` The original pattern the minimatch object represents.
+- `options` The options supplied to the constructor.
+- `set` A 2-dimensional array of regexp or string expressions.
+ Each row in the
+ array corresponds to a brace-expanded pattern. Each item in the row
+ corresponds to a single path-part. For example, the pattern
+ `{a,b/c}/d` would expand to a set of patterns like:
+
+ [ [ a, d ]
+ , [ b, c, d ] ]
+
+ If a portion of the pattern doesn't have any "magic" in it
+ (that is, it's something like `"foo"` rather than `fo*o?`), then it
+ will be left as a string rather than converted to a regular
+ expression.
+
+- `regexp` Created by the `makeRe` method. A single regular expression
+ expressing the entire pattern. This is useful in cases where you wish
+ to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+- `negate` True if the pattern is negated.
+- `comment` True if the pattern is a comment.
+- `empty` True if the pattern is `""`.
+
+### Methods
+
+- `makeRe()` Generate the `regexp` member if necessary, and return it.
+ Will return `false` if the pattern is invalid.
+- `match(fname)` Return true if the filename matches the pattern, or
+ false otherwise.
+- `matchOne(fileArray, patternArray, partial)` Take a `/`-split
+ filename, and match it against a single row in the `regExpSet`. This
+ method is mainly for internal use, but is exposed so that it can be
+ used by a glob-walker that needs to avoid excessive filesystem calls.
+- `hasMagic()` Returns true if the parsed pattern contains any
+ magic characters. Returns false if all comparator parts are
+ string literals. If the `magicalBraces` option is set on the
+ constructor, then it will consider brace expansions which are
+ not otherwise magical to be magic. If not set, then a pattern
+ like `a{b,c}d` will return `false`, because neither `abd` nor
+ `acd` contain any special glob characters.
+
+ This does **not** mean that the pattern string can be used as a
+ literal filename, as it may contain magic glob characters that
+ are escaped. For example, the pattern `\\*` or `[*]` would not
+ be considered to have magic, as the matching portion parses to
+ the literal string `'*'` and would match a path named `'*'`,
+ not `'\\*'` or `'[*]'`. The `minimatch.unescape()` method may
+ be used to remove escape characters.
+
+All other methods are internal, and will be called as necessary.
+
+### minimatch(path, pattern, options)
+
+Main export. Tests a path against the pattern using the options.
+
+```javascript
+var isJS = minimatch(file, '*.js', { matchBase: true })
+```
+
+### minimatch.filter(pattern, options)
+
+Returns a function that tests its
+supplied argument, suitable for use with `Array.filter`. Example:
+
+```javascript
+var javascripts = fileList.filter(minimatch.filter('*.js', { matchBase: true }))
+```
+
+### minimatch.escape(pattern, options = {})
+
+Escape all magic characters in a glob pattern, so that it will
+only ever match literal strings
+
+If the `windowsPathsNoEscape` option is used, then characters are
+escaped by wrapping in `[]`, because a magic character wrapped in
+a character class can only be satisfied by that exact character.
+
+Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot
+be escaped or unescaped.
+
+### minimatch.unescape(pattern, options = {})
+
+Un-escape a glob string that may contain some escaped characters.
+
+If the `windowsPathsNoEscape` option is used, then square-brace
+escapes are removed, but not backslash escapes. For example, it
+will turn the string `'[*]'` into `*`, but it will not turn
+`'\\*'` into `'*'`, because `\` is a path separator in
+`windowsPathsNoEscape` mode.
+
+When `windowsPathsNoEscape` is not set, then both brace escapes
+and backslash escapes are removed.
+
+Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot
+be escaped or unescaped.
+
+### minimatch.match(list, pattern, options)
+
+Match against the list of
+files, in the style of fnmatch or glob. If nothing is matched, and
+options.nonull is set, then return a list containing the pattern itself.
+
+```javascript
+var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
+```
+
+### minimatch.makeRe(pattern, options)
+
+Make a regular expression object from the pattern.
+
+## Options
+
+All options are `false` by default.
+
+### debug
+
+Dump a ton of stuff to stderr.
+
+### nobrace
+
+Do not expand `{a,b}` and `{1..3}` brace sets.
+
+### noglobstar
+
+Disable `**` matching against multiple folder names.
+
+### dot
+
+Allow patterns to match filenames starting with a period, even if
+the pattern does not explicitly have a period in that spot.
+
+Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
+is set.
+
+### noext
+
+Disable "extglob" style patterns like `+(a|b)`.
+
+### nocase
+
+Perform a case-insensitive match.
+
+### nocaseMagicOnly
+
+When used with `{nocase: true}`, create regular expressions that
+are case-insensitive, but leave string match portions untouched.
+Has no effect when used without `{nocase: true}`
+
+Useful when some other form of case-insensitive matching is used,
+or if the original string representation is useful in some other
+way.
+
+### nonull
+
+When a match is not found by `minimatch.match`, return a list containing
+the pattern itself if this option is set. When not set, an empty list
+is returned if there are no matches.
+
+### magicalBraces
+
+This only affects the results of the `Minimatch.hasMagic` method.
+
+If the pattern contains brace expansions, such as `a{b,c}d`, but
+no other magic characters, then the `Minimatch.hasMagic()` method
+will return `false` by default. When this option set, it will
+return `true` for brace expansion as well as other magic glob
+characters.
+
+### matchBase
+
+If set, then patterns without slashes will be matched
+against the basename of the path if it contains slashes. For example,
+`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+
+### nocomment
+
+Suppress the behavior of treating `#` at the start of a pattern as a
+comment.
+
+### nonegate
+
+Suppress the behavior of treating a leading `!` character as negation.
+
+### flipNegate
+
+Returns from negate expressions the same as if they were not negated.
+(Ie, true on a hit, false on a miss.)
+
+### partial
+
+Compare a partial path to a pattern. As long as the parts of the path that
+are present are not contradicted by the pattern, it will be treated as a
+match. This is useful in applications where you're walking through a
+folder structure, and don't yet have the full path, but want to ensure that
+you do not walk down paths that can never be a match.
+
+For example,
+
+```js
+minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d
+minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d
+minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
+```
+
+### windowsPathsNoEscape
+
+Use `\\` as a path separator _only_, and _never_ as an escape
+character. If set, all `\\` characters are replaced with `/` in
+the pattern. Note that this makes it **impossible** to match
+against paths containing literal glob pattern characters, but
+allows matching with patterns constructed using `path.join()` and
+`path.resolve()` on Windows platforms, mimicking the (buggy!)
+behavior of earlier versions on Windows. Please use with
+caution, and be mindful of [the caveat about Windows
+paths](#windows).
+
+For legacy reasons, this is also set if
+`options.allowWindowsEscape` is set to the exact value `false`.
+
+### windowsNoMagicRoot
+
+When a pattern starts with a UNC path or drive letter, and in
+`nocase:true` mode, do not convert the root portions of the
+pattern into a case-insensitive regular expression, and instead
+leave them as strings.
+
+This is the default when the platform is `win32` and
+`nocase:true` is set.
+
+### preserveMultipleSlashes
+
+By default, multiple `/` characters (other than the leading `//`
+in a UNC path, see "UNC Paths" above) are treated as a single
+`/`.
+
+That is, a pattern like `a///b` will match the file path `a/b`.
+
+Set `preserveMultipleSlashes: true` to suppress this behavior.
+
+### optimizationLevel
+
+A number indicating the level of optimization that should be done
+to the pattern prior to parsing and using it for matches.
+
+Globstar parts `**` are always converted to `*` when `noglobstar`
+is set, and multiple adjacent `**` parts are converted into a
+single `**` (ie, `a/**/**/b` will be treated as `a/**/b`, as this
+is equivalent in all cases).
+
+- `0` - Make no further changes. In this mode, `.` and `..` are
+ maintained in the pattern, meaning that they must also appear
+ in the same position in the test path string. Eg, a pattern
+ like `a/*/../c` will match the string `a/b/../c` but not the
+ string `a/c`.
+- `1` - (default) Remove cases where a double-dot `..` follows a
+ pattern portion that is not `**`, `.`, `..`, or empty `''`. For
+ example, the pattern `./a/b/../*` is converted to `./a/*`, and
+ so it will match the path string `./a/c`, but not the path
+ string `./a/b/../c`. Dots and empty path portions in the
+ pattern are preserved.
+- `2` (or higher) - Much more aggressive optimizations, suitable
+ for use with file-walking cases:
+
+ - Remove cases where a double-dot `..` follows a pattern
+ portion that is not `**`, `.`, or empty `''`. Remove empty
+ and `.` portions of the pattern, where safe to do so (ie,
+ anywhere other than the last position, the first position, or
+ the second position in a pattern starting with `/`, as this
+ may indicate a UNC path on Windows).
+ - Convert patterns containing `/**/..//` into the
+ equivalent `/{..,**}//`, where `` is a
+ a pattern portion other than `.`, `..`, `**`, or empty
+ `''`.
+ - Dedupe patterns where a `**` portion is present in one and
+ omitted in another, and it is not the final path portion, and
+ they are otherwise equivalent. So `{a/**/b,a/b}` becomes
+ `a/**/b`, because `**` matches against an empty path portion.
+ - Dedupe patterns where a `*` portion is present in one, and a
+ non-dot pattern other than `**`, `.`, `..`, or `''` is in the
+ same position in the other. So `a/{*,x}/b` becomes `a/*/b`,
+ because `*` can match against `x`.
+
+ While these optimizations improve the performance of
+ file-walking use cases such as [glob](http://npm.im/glob) (ie,
+ the reason this module exists), there are cases where it will
+ fail to match a literal string that would have been matched in
+ optimization level 1 or 0.
+
+ Specifically, while the `Minimatch.match()` method will
+ optimize the file path string in the same ways, resulting in
+ the same matches, it will fail when tested with the regular
+ expression provided by `Minimatch.makeRe()`, unless the path
+ string is first processed with
+ `minimatch.levelTwoFileOptimize()` or similar.
+
+### platform
+
+When set to `win32`, this will trigger all windows-specific
+behaviors (special handling for UNC paths, and treating `\` as
+separators in file paths for comparison.)
+
+Defaults to the value of `process.platform`.
+
+## Comparisons to other fnmatch/glob implementations
+
+While strict compliance with the existing standards is a
+worthwhile goal, some discrepancies exist between minimatch and
+other implementations. Some are intentional, and some are
+unavoidable.
+
+If the pattern starts with a `!` character, then it is negated. Set the
+`nonegate` flag to suppress this behavior, and treat leading `!`
+characters normally. This is perhaps relevant if you wish to start the
+pattern with a negative extglob pattern like `!(a|B)`. Multiple `!`
+characters at the start of a pattern will negate the pattern multiple
+times.
+
+If a pattern starts with `#`, then it is treated as a comment, and
+will not match anything. Use `\#` to match a literal `#` at the
+start of a line, or set the `nocomment` flag to suppress this behavior.
+
+The double-star character `**` is supported by default, unless the
+`noglobstar` flag is set. This is supported in the manner of bsdglob
+and bash 4.1, where `**` only has special significance if it is the only
+thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but
+`a/**b` will not.
+
+If an escaped pattern has no matches, and the `nonull` flag is set,
+then minimatch.match returns the pattern as-provided, rather than
+interpreting the character escapes. For example,
+`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
+`"*a?"`. This is akin to setting the `nullglob` option in bash, except
+that it does not resolve escaped pattern characters.
+
+If brace expansion is not disabled, then it is performed before any
+other interpretation of the glob pattern. Thus, a pattern like
+`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
+**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
+checked for validity. Since those two are valid, matching proceeds.
+
+Negated extglob patterns are handled as closely as possible to
+Bash semantics, but there are some cases with negative extglobs
+which are exceedingly difficult to express in a JavaScript
+regular expression. In particular the negated pattern
+`!(*|)*` will in bash match anything that does
+not start with ``. However,
+`!(*)*` _will_ match paths starting with
+``, because the empty string can match against
+the negated portion. In this library, `!(*|)*`
+will _not_ match any pattern starting with ``, due to a
+difference in precisely which patterns are considered "greedy" in
+Regular Expressions vs bash path expansion. This may be fixable,
+but not without incurring some complexity and performance costs,
+and the trade-off seems to not be worth pursuing.
+
+Note that `fnmatch(3)` in libc is an extremely naive string comparison
+matcher, which does not do anything special for slashes. This library is
+designed to be used in glob searching and file walkers, and so it does do
+special things with `/`. Thus, `foo*` will not match `foo/bar` in this
+library, even though it would in `fnmatch(3)`.
diff --git a/node_modules/minimatch/package.json b/node_modules/minimatch/package.json
new file mode 100644
index 0000000..01fc48e
--- /dev/null
+++ b/node_modules/minimatch/package.json
@@ -0,0 +1,82 @@
+{
+ "author": "Isaac Z. Schlueter (http://blog.izs.me)",
+ "name": "minimatch",
+ "description": "a glob matcher in javascript",
+ "version": "9.0.5",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/isaacs/minimatch.git"
+ },
+ "main": "./dist/commonjs/index.js",
+ "types": "./dist/commonjs/index.d.ts",
+ "exports": {
+ "./package.json": "./package.json",
+ ".": {
+ "import": {
+ "types": "./dist/esm/index.d.ts",
+ "default": "./dist/esm/index.js"
+ },
+ "require": {
+ "types": "./dist/commonjs/index.d.ts",
+ "default": "./dist/commonjs/index.js"
+ }
+ }
+ },
+ "files": [
+ "dist"
+ ],
+ "scripts": {
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "prepublishOnly": "git push origin --follow-tags",
+ "prepare": "tshy",
+ "pretest": "npm run prepare",
+ "presnap": "npm run prepare",
+ "test": "tap",
+ "snap": "tap",
+ "format": "prettier --write . --loglevel warn",
+ "benchmark": "node benchmark/index.js",
+ "typedoc": "typedoc --tsconfig tsconfig-esm.json ./src/*.ts"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "dependencies": {
+ "brace-expansion": "^2.0.1"
+ },
+ "devDependencies": {
+ "@types/brace-expansion": "^1.1.0",
+ "@types/node": "^18.15.11",
+ "@types/tap": "^15.0.8",
+ "eslint-config-prettier": "^8.6.0",
+ "mkdirp": "1",
+ "prettier": "^2.8.2",
+ "tap": "^18.7.2",
+ "ts-node": "^10.9.1",
+ "tshy": "^1.12.0",
+ "typedoc": "^0.23.21",
+ "typescript": "^4.9.3"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ },
+ "license": "ISC",
+ "tshy": {
+ "exports": {
+ "./package.json": "./package.json",
+ ".": "./src/index.ts"
+ }
+ },
+ "type": "module"
+}
diff --git a/node_modules/minipass/LICENSE b/node_modules/minipass/LICENSE
new file mode 100644
index 0000000..97f8e32
--- /dev/null
+++ b/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass/README.md b/node_modules/minipass/README.md
new file mode 100644
index 0000000..1126330
--- /dev/null
+++ b/node_modules/minipass/README.md
@@ -0,0 +1,825 @@
+# minipass
+
+A _very_ minimal implementation of a [PassThrough
+stream](https://nodejs.org/api/stream.html#stream_class_stream_passthrough)
+
+[It's very
+fast](https://docs.google.com/spreadsheets/d/1K_HR5oh3r80b8WVMWCPPjfuWXUgfkmhlX7FGI6JJ8tY/edit?usp=sharing)
+for objects, strings, and buffers.
+
+Supports `pipe()`ing (including multi-`pipe()` and backpressure
+transmission), buffering data until either a `data` event handler
+or `pipe()` is added (so you don't lose the first chunk), and
+most other cases where PassThrough is a good idea.
+
+There is a `read()` method, but it's much more efficient to
+consume data from this stream via `'data'` events or by calling
+`pipe()` into some other stream. Calling `read()` requires the
+buffer to be flattened in some cases, which requires copying
+memory.
+
+If you set `objectMode: true` in the options, then whatever is
+written will be emitted. Otherwise, it'll do a minimal amount of
+Buffer copying to ensure proper Streams semantics when `read(n)`
+is called.
+
+`objectMode` can only be set at instantiation. Attempting to
+write something other than a String or Buffer without having set
+`objectMode` in the options will throw an error.
+
+This is not a `through` or `through2` stream. It doesn't
+transform the data, it just passes it right through. If you want
+to transform the data, extend the class, and override the
+`write()` method. Once you're done transforming the data however
+you want, call `super.write()` with the transform output.
+
+For some examples of streams that extend Minipass in various
+ways, check out:
+
+- [minizlib](http://npm.im/minizlib)
+- [fs-minipass](http://npm.im/fs-minipass)
+- [tar](http://npm.im/tar)
+- [minipass-collect](http://npm.im/minipass-collect)
+- [minipass-flush](http://npm.im/minipass-flush)
+- [minipass-pipeline](http://npm.im/minipass-pipeline)
+- [tap](http://npm.im/tap)
+- [tap-parser](http://npm.im/tap-parser)
+- [treport](http://npm.im/treport)
+- [minipass-fetch](http://npm.im/minipass-fetch)
+- [pacote](http://npm.im/pacote)
+- [make-fetch-happen](http://npm.im/make-fetch-happen)
+- [cacache](http://npm.im/cacache)
+- [ssri](http://npm.im/ssri)
+- [npm-registry-fetch](http://npm.im/npm-registry-fetch)
+- [minipass-json-stream](http://npm.im/minipass-json-stream)
+- [minipass-sized](http://npm.im/minipass-sized)
+
+## Usage in TypeScript
+
+The `Minipass` class takes three type template definitions:
+
+- `RType` the type being read, which defaults to `Buffer`. If
+ `RType` is `string`, then the constructor _must_ get an options
+ object specifying either an `encoding` or `objectMode: true`.
+ If it's anything other than `string` or `Buffer`, then it
+ _must_ get an options object specifying `objectMode: true`.
+- `WType` the type being written. If `RType` is `Buffer` or
+ `string`, then this defaults to `ContiguousData` (Buffer,
+ string, ArrayBuffer, or ArrayBufferView). Otherwise, it
+ defaults to `RType`.
+- `Events` type mapping event names to the arguments emitted
+ with that event, which extends `Minipass.Events`.
+
+To declare types for custom events in subclasses, extend the
+third parameter with your own event signatures. For example:
+
+```js
+import { Minipass } from 'minipass'
+
+// a NDJSON stream that emits 'jsonError' when it can't stringify
+export interface Events extends Minipass.Events {
+ jsonError: [e: Error]
+}
+
+export class NDJSONStream extends Minipass {
+ constructor() {
+ super({ objectMode: true })
+ }
+
+ // data is type `any` because that's WType
+ write(data, encoding, cb) {
+ try {
+ const json = JSON.stringify(data)
+ return super.write(json + '\n', encoding, cb)
+ } catch (er) {
+ if (!er instanceof Error) {
+ er = Object.assign(new Error('json stringify failed'), {
+ cause: er,
+ })
+ }
+ // trying to emit with something OTHER than an error will
+ // fail, because we declared the event arguments type.
+ this.emit('jsonError', er)
+ }
+ }
+}
+
+const s = new NDJSONStream()
+s.on('jsonError', e => {
+ // here, TS knows that e is an Error
+})
+```
+
+Emitting/handling events that aren't declared in this way is
+fine, but the arguments will be typed as `unknown`.
+
+## Differences from Node.js Streams
+
+There are several things that make Minipass streams different
+from (and in some ways superior to) Node.js core streams.
+
+Please read these caveats if you are familiar with node-core
+streams and intend to use Minipass streams in your programs.
+
+You can avoid most of these differences entirely (for a very
+small performance penalty) by setting `{async: true}` in the
+constructor options.
+
+### Timing
+
+Minipass streams are designed to support synchronous use-cases.
+Thus, data is emitted as soon as it is available, always. It is
+buffered until read, but no longer. Another way to look at it is
+that Minipass streams are exactly as synchronous as the logic
+that writes into them.
+
+This can be surprising if your code relies on
+`PassThrough.write()` always providing data on the next tick
+rather than the current one, or being able to call `resume()` and
+not have the entire buffer disappear immediately.
+
+However, without this synchronicity guarantee, there would be no
+way for Minipass to achieve the speeds it does, or support the
+synchronous use cases that it does. Simply put, waiting takes
+time.
+
+This non-deferring approach makes Minipass streams much easier to
+reason about, especially in the context of Promises and other
+flow-control mechanisms.
+
+Example:
+
+```js
+// hybrid module, either works
+import { Minipass } from 'minipass'
+// or:
+const { Minipass } = require('minipass')
+
+const stream = new Minipass()
+stream.on('data', () => console.log('data event'))
+console.log('before write')
+stream.write('hello')
+console.log('after write')
+// output:
+// before write
+// data event
+// after write
+```
+
+### Exception: Async Opt-In
+
+If you wish to have a Minipass stream with behavior that more
+closely mimics Node.js core streams, you can set the stream in
+async mode either by setting `async: true` in the constructor
+options, or by setting `stream.async = true` later on.
+
+```js
+// hybrid module, either works
+import { Minipass } from 'minipass'
+// or:
+const { Minipass } = require('minipass')
+
+const asyncStream = new Minipass({ async: true })
+asyncStream.on('data', () => console.log('data event'))
+console.log('before write')
+asyncStream.write('hello')
+console.log('after write')
+// output:
+// before write
+// after write
+// data event <-- this is deferred until the next tick
+```
+
+Switching _out_ of async mode is unsafe, as it could cause data
+corruption, and so is not enabled. Example:
+
+```js
+import { Minipass } from 'minipass'
+const stream = new Minipass({ encoding: 'utf8' })
+stream.on('data', chunk => console.log(chunk))
+stream.async = true
+console.log('before writes')
+stream.write('hello')
+setStreamSyncAgainSomehow(stream) // <-- this doesn't actually exist!
+stream.write('world')
+console.log('after writes')
+// hypothetical output would be:
+// before writes
+// world
+// after writes
+// hello
+// NOT GOOD!
+```
+
+To avoid this problem, once set into async mode, any attempt to
+make the stream sync again will be ignored.
+
+```js
+const { Minipass } = require('minipass')
+const stream = new Minipass({ encoding: 'utf8' })
+stream.on('data', chunk => console.log(chunk))
+stream.async = true
+console.log('before writes')
+stream.write('hello')
+stream.async = false // <-- no-op, stream already async
+stream.write('world')
+console.log('after writes')
+// actual output:
+// before writes
+// after writes
+// hello
+// world
+```
+
+### No High/Low Water Marks
+
+Node.js core streams will optimistically fill up a buffer,
+returning `true` on all writes until the limit is hit, even if
+the data has nowhere to go. Then, they will not attempt to draw
+more data in until the buffer size dips below a minimum value.
+
+Minipass streams are much simpler. The `write()` method will
+return `true` if the data has somewhere to go (which is to say,
+given the timing guarantees, that the data is already there by
+the time `write()` returns).
+
+If the data has nowhere to go, then `write()` returns false, and
+the data sits in a buffer, to be drained out immediately as soon
+as anyone consumes it.
+
+Since nothing is ever buffered unnecessarily, there is much less
+copying data, and less bookkeeping about buffer capacity levels.
+
+### Hazards of Buffering (or: Why Minipass Is So Fast)
+
+Since data written to a Minipass stream is immediately written
+all the way through the pipeline, and `write()` always returns
+true/false based on whether the data was fully flushed,
+backpressure is communicated immediately to the upstream caller.
+This minimizes buffering.
+
+Consider this case:
+
+```js
+const { PassThrough } = require('stream')
+const p1 = new PassThrough({ highWaterMark: 1024 })
+const p2 = new PassThrough({ highWaterMark: 1024 })
+const p3 = new PassThrough({ highWaterMark: 1024 })
+const p4 = new PassThrough({ highWaterMark: 1024 })
+
+p1.pipe(p2).pipe(p3).pipe(p4)
+p4.on('data', () => console.log('made it through'))
+
+// this returns false and buffers, then writes to p2 on next tick (1)
+// p2 returns false and buffers, pausing p1, then writes to p3 on next tick (2)
+// p3 returns false and buffers, pausing p2, then writes to p4 on next tick (3)
+// p4 returns false and buffers, pausing p3, then emits 'data' and 'drain'
+// on next tick (4)
+// p3 sees p4's 'drain' event, and calls resume(), emitting 'resume' and
+// 'drain' on next tick (5)
+// p2 sees p3's 'drain', calls resume(), emits 'resume' and 'drain' on next tick (6)
+// p1 sees p2's 'drain', calls resume(), emits 'resume' and 'drain' on next
+// tick (7)
+
+p1.write(Buffer.alloc(2048)) // returns false
+```
+
+Along the way, the data was buffered and deferred at each stage,
+and multiple event deferrals happened, for an unblocked pipeline
+where it was perfectly safe to write all the way through!
+
+Furthermore, setting a `highWaterMark` of `1024` might lead
+someone reading the code to think an advisory maximum of 1KiB is
+being set for the pipeline. However, the actual advisory
+buffering level is the _sum_ of `highWaterMark` values, since
+each one has its own bucket.
+
+Consider the Minipass case:
+
+```js
+const m1 = new Minipass()
+const m2 = new Minipass()
+const m3 = new Minipass()
+const m4 = new Minipass()
+
+m1.pipe(m2).pipe(m3).pipe(m4)
+m4.on('data', () => console.log('made it through'))
+
+// m1 is flowing, so it writes the data to m2 immediately
+// m2 is flowing, so it writes the data to m3 immediately
+// m3 is flowing, so it writes the data to m4 immediately
+// m4 is flowing, so it fires the 'data' event immediately, returns true
+// m4's write returned true, so m3 is still flowing, returns true
+// m3's write returned true, so m2 is still flowing, returns true
+// m2's write returned true, so m1 is still flowing, returns true
+// No event deferrals or buffering along the way!
+
+m1.write(Buffer.alloc(2048)) // returns true
+```
+
+It is extremely unlikely that you _don't_ want to buffer any data
+written, or _ever_ buffer data that can be flushed all the way
+through. Neither node-core streams nor Minipass ever fail to
+buffer written data, but node-core streams do a lot of
+unnecessary buffering and pausing.
+
+As always, the faster implementation is the one that does less
+stuff and waits less time to do it.
+
+### Immediately emit `end` for empty streams (when not paused)
+
+If a stream is not paused, and `end()` is called before writing
+any data into it, then it will emit `end` immediately.
+
+If you have logic that occurs on the `end` event which you don't
+want to potentially happen immediately (for example, closing file
+descriptors, moving on to the next entry in an archive parse
+stream, etc.) then be sure to call `stream.pause()` on creation,
+and then `stream.resume()` once you are ready to respond to the
+`end` event.
+
+However, this is _usually_ not a problem because:
+
+### Emit `end` When Asked
+
+One hazard of immediately emitting `'end'` is that you may not
+yet have had a chance to add a listener. In order to avoid this
+hazard, Minipass streams safely re-emit the `'end'` event if a
+new listener is added after `'end'` has been emitted.
+
+Ie, if you do `stream.on('end', someFunction)`, and the stream
+has already emitted `end`, then it will call the handler right
+away. (You can think of this somewhat like attaching a new
+`.then(fn)` to a previously-resolved Promise.)
+
+To prevent calling handlers multiple times who would not expect
+multiple ends to occur, all listeners are removed from the
+`'end'` event whenever it is emitted.
+
+### Emit `error` When Asked
+
+The most recent error object passed to the `'error'` event is
+stored on the stream. If a new `'error'` event handler is added,
+and an error was previously emitted, then the event handler will
+be called immediately (or on `process.nextTick` in the case of
+async streams).
+
+This makes it much more difficult to end up trying to interact
+with a broken stream, if the error handler is added after an
+error was previously emitted.
+
+### Impact of "immediate flow" on Tee-streams
+
+A "tee stream" is a stream piping to multiple destinations:
+
+```js
+const tee = new Minipass()
+t.pipe(dest1)
+t.pipe(dest2)
+t.write('foo') // goes to both destinations
+```
+
+Since Minipass streams _immediately_ process any pending data
+through the pipeline when a new pipe destination is added, this
+can have surprising effects, especially when a stream comes in
+from some other function and may or may not have data in its
+buffer.
+
+```js
+// WARNING! WILL LOSE DATA!
+const src = new Minipass()
+src.write('foo')
+src.pipe(dest1) // 'foo' chunk flows to dest1 immediately, and is gone
+src.pipe(dest2) // gets nothing!
+```
+
+One solution is to create a dedicated tee-stream junction that
+pipes to both locations, and then pipe to _that_ instead.
+
+```js
+// Safe example: tee to both places
+const src = new Minipass()
+src.write('foo')
+const tee = new Minipass()
+tee.pipe(dest1)
+tee.pipe(dest2)
+src.pipe(tee) // tee gets 'foo', pipes to both locations
+```
+
+The same caveat applies to `on('data')` event listeners. The
+first one added will _immediately_ receive all of the data,
+leaving nothing for the second:
+
+```js
+// WARNING! WILL LOSE DATA!
+const src = new Minipass()
+src.write('foo')
+src.on('data', handler1) // receives 'foo' right away
+src.on('data', handler2) // nothing to see here!
+```
+
+Using a dedicated tee-stream can be used in this case as well:
+
+```js
+// Safe example: tee to both data handlers
+const src = new Minipass()
+src.write('foo')
+const tee = new Minipass()
+tee.on('data', handler1)
+tee.on('data', handler2)
+src.pipe(tee)
+```
+
+All of the hazards in this section are avoided by setting `{
+async: true }` in the Minipass constructor, or by setting
+`stream.async = true` afterwards. Note that this does add some
+overhead, so should only be done in cases where you are willing
+to lose a bit of performance in order to avoid having to refactor
+program logic.
+
+## USAGE
+
+It's a stream! Use it like a stream and it'll most likely do what
+you want.
+
+```js
+import { Minipass } from 'minipass'
+const mp = new Minipass(options) // options is optional
+mp.write('foo')
+mp.pipe(someOtherStream)
+mp.end('bar')
+```
+
+### OPTIONS
+
+- `encoding` How would you like the data coming _out_ of the
+ stream to be encoded? Accepts any values that can be passed to
+ `Buffer.toString()`.
+- `objectMode` Emit data exactly as it comes in. This will be
+ flipped on by default if you write() something other than a
+ string or Buffer at any point. Setting `objectMode: true` will
+ prevent setting any encoding value.
+- `async` Defaults to `false`. Set to `true` to defer data
+ emission until next tick. This reduces performance slightly,
+ but makes Minipass streams use timing behavior closer to Node
+ core streams. See [Timing](#timing) for more details.
+- `signal` An `AbortSignal` that will cause the stream to unhook
+ itself from everything and become as inert as possible. Note
+ that providing a `signal` parameter will make `'error'` events
+ no longer throw if they are unhandled, but they will still be
+ emitted to handlers if any are attached.
+
+### API
+
+Implements the user-facing portions of Node.js's `Readable` and
+`Writable` streams.
+
+### Methods
+
+- `write(chunk, [encoding], [callback])` - Put data in. (Note
+ that, in the base Minipass class, the same data will come out.)
+ Returns `false` if the stream will buffer the next write, or
+ true if it's still in "flowing" mode.
+- `end([chunk, [encoding]], [callback])` - Signal that you have
+ no more data to write. This will queue an `end` event to be
+ fired when all the data has been consumed.
+- `pause()` - No more data for a while, please. This also
+ prevents `end` from being emitted for empty streams until the
+ stream is resumed.
+- `resume()` - Resume the stream. If there's data in the buffer,
+ it is all discarded. Any buffered events are immediately
+ emitted.
+- `pipe(dest)` - Send all output to the stream provided. When
+ data is emitted, it is immediately written to any and all pipe
+ destinations. (Or written on next tick in `async` mode.)
+- `unpipe(dest)` - Stop piping to the destination stream. This is
+ immediate, meaning that any asynchronously queued data will
+ _not_ make it to the destination when running in `async` mode.
+ - `options.end` - Boolean, end the destination stream when the
+ source stream ends. Default `true`.
+ - `options.proxyErrors` - Boolean, proxy `error` events from
+ the source stream to the destination stream. Note that errors
+ are _not_ proxied after the pipeline terminates, either due
+ to the source emitting `'end'` or manually unpiping with
+ `src.unpipe(dest)`. Default `false`.
+- `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are
+ EventEmitters. Some events are given special treatment,
+ however. (See below under "events".)
+- `promise()` - Returns a Promise that resolves when the stream
+ emits `end`, or rejects if the stream emits `error`.
+- `collect()` - Return a Promise that resolves on `end` with an
+ array containing each chunk of data that was emitted, or
+ rejects if the stream emits `error`. Note that this consumes
+ the stream data.
+- `concat()` - Same as `collect()`, but concatenates the data
+ into a single Buffer object. Will reject the returned promise
+ if the stream is in objectMode, or if it goes into objectMode
+ by the end of the data.
+- `read(n)` - Consume `n` bytes of data out of the buffer. If `n`
+ is not provided, then consume all of it. If `n` bytes are not
+ available, then it returns null. **Note** consuming streams in
+ this way is less efficient, and can lead to unnecessary Buffer
+ copying.
+- `destroy([er])` - Destroy the stream. If an error is provided,
+ then an `'error'` event is emitted. If the stream has a
+ `close()` method, and has not emitted a `'close'` event yet,
+ then `stream.close()` will be called. Any Promises returned by
+ `.promise()`, `.collect()` or `.concat()` will be rejected.
+ After being destroyed, writing to the stream will emit an
+ error. No more data will be emitted if the stream is destroyed,
+ even if it was previously buffered.
+
+### Properties
+
+- `bufferLength` Read-only. Total number of bytes buffered, or in
+ the case of objectMode, the total number of objects.
+- `encoding` Read-only. The encoding that has been set.
+- `flowing` Read-only. Boolean indicating whether a chunk written
+ to the stream will be immediately emitted.
+- `emittedEnd` Read-only. Boolean indicating whether the end-ish
+ events (ie, `end`, `prefinish`, `finish`) have been emitted.
+ Note that listening on any end-ish event will immediateyl
+ re-emit it if it has already been emitted.
+- `writable` Whether the stream is writable. Default `true`. Set
+ to `false` when `end()`
+- `readable` Whether the stream is readable. Default `true`.
+- `pipes` An array of Pipe objects referencing streams that this
+ stream is piping into.
+- `destroyed` A getter that indicates whether the stream was
+ destroyed.
+- `paused` True if the stream has been explicitly paused,
+ otherwise false.
+- `objectMode` Indicates whether the stream is in `objectMode`.
+- `aborted` Readonly property set when the `AbortSignal`
+ dispatches an `abort` event.
+
+### Events
+
+- `data` Emitted when there's data to read. Argument is the data
+ to read. This is never emitted while not flowing. If a listener
+ is attached, that will resume the stream.
+- `end` Emitted when there's no more data to read. This will be
+ emitted immediately for empty streams when `end()` is called.
+ If a listener is attached, and `end` was already emitted, then
+ it will be emitted again. All listeners are removed when `end`
+ is emitted.
+- `prefinish` An end-ish event that follows the same logic as
+ `end` and is emitted in the same conditions where `end` is
+ emitted. Emitted after `'end'`.
+- `finish` An end-ish event that follows the same logic as `end`
+ and is emitted in the same conditions where `end` is emitted.
+ Emitted after `'prefinish'`.
+- `close` An indication that an underlying resource has been
+ released. Minipass does not emit this event, but will defer it
+ until after `end` has been emitted, since it throws off some
+ stream libraries otherwise.
+- `drain` Emitted when the internal buffer empties, and it is
+ again suitable to `write()` into the stream.
+- `readable` Emitted when data is buffered and ready to be read
+ by a consumer.
+- `resume` Emitted when stream changes state from buffering to
+ flowing mode. (Ie, when `resume` is called, `pipe` is called,
+ or a `data` event listener is added.)
+
+### Static Methods
+
+- `Minipass.isStream(stream)` Returns `true` if the argument is a
+ stream, and false otherwise. To be considered a stream, the
+ object must be either an instance of Minipass, or an
+ EventEmitter that has either a `pipe()` method, or both
+ `write()` and `end()` methods. (Pretty much any stream in
+ node-land will return `true` for this.)
+
+## EXAMPLES
+
+Here are some examples of things you can do with Minipass
+streams.
+
+### simple "are you done yet" promise
+
+```js
+mp.promise().then(
+ () => {
+ // stream is finished
+ },
+ er => {
+ // stream emitted an error
+ }
+)
+```
+
+### collecting
+
+```js
+mp.collect().then(all => {
+ // all is an array of all the data emitted
+ // encoding is supported in this case, so
+ // so the result will be a collection of strings if
+ // an encoding is specified, or buffers/objects if not.
+ //
+ // In an async function, you may do
+ // const data = await stream.collect()
+})
+```
+
+### collecting into a single blob
+
+This is a bit slower because it concatenates the data into one
+chunk for you, but if you're going to do it yourself anyway, it's
+convenient this way:
+
+```js
+mp.concat().then(onebigchunk => {
+ // onebigchunk is a string if the stream
+ // had an encoding set, or a buffer otherwise.
+})
+```
+
+### iteration
+
+You can iterate over streams synchronously or asynchronously in
+platforms that support it.
+
+Synchronous iteration will end when the currently available data
+is consumed, even if the `end` event has not been reached. In
+string and buffer mode, the data is concatenated, so unless
+multiple writes are occurring in the same tick as the `read()`,
+sync iteration loops will generally only have a single iteration.
+
+To consume chunks in this way exactly as they have been written,
+with no flattening, create the stream with the `{ objectMode:
+true }` option.
+
+```js
+const mp = new Minipass({ objectMode: true })
+mp.write('a')
+mp.write('b')
+for (let letter of mp) {
+ console.log(letter) // a, b
+}
+mp.write('c')
+mp.write('d')
+for (let letter of mp) {
+ console.log(letter) // c, d
+}
+mp.write('e')
+mp.end()
+for (let letter of mp) {
+ console.log(letter) // e
+}
+for (let letter of mp) {
+ console.log(letter) // nothing
+}
+```
+
+Asynchronous iteration will continue until the end event is reached,
+consuming all of the data.
+
+```js
+const mp = new Minipass({ encoding: 'utf8' })
+
+// some source of some data
+let i = 5
+const inter = setInterval(() => {
+ if (i-- > 0) mp.write(Buffer.from('foo\n', 'utf8'))
+ else {
+ mp.end()
+ clearInterval(inter)
+ }
+}, 100)
+
+// consume the data with asynchronous iteration
+async function consume() {
+ for await (let chunk of mp) {
+ console.log(chunk)
+ }
+ return 'ok'
+}
+
+consume().then(res => console.log(res))
+// logs `foo\n` 5 times, and then `ok`
+```
+
+### subclass that `console.log()`s everything written into it
+
+```js
+class Logger extends Minipass {
+ write(chunk, encoding, callback) {
+ console.log('WRITE', chunk, encoding)
+ return super.write(chunk, encoding, callback)
+ }
+ end(chunk, encoding, callback) {
+ console.log('END', chunk, encoding)
+ return super.end(chunk, encoding, callback)
+ }
+}
+
+someSource.pipe(new Logger()).pipe(someDest)
+```
+
+### same thing, but using an inline anonymous class
+
+```js
+// js classes are fun
+someSource
+ .pipe(
+ new (class extends Minipass {
+ emit(ev, ...data) {
+ // let's also log events, because debugging some weird thing
+ console.log('EMIT', ev)
+ return super.emit(ev, ...data)
+ }
+ write(chunk, encoding, callback) {
+ console.log('WRITE', chunk, encoding)
+ return super.write(chunk, encoding, callback)
+ }
+ end(chunk, encoding, callback) {
+ console.log('END', chunk, encoding)
+ return super.end(chunk, encoding, callback)
+ }
+ })()
+ )
+ .pipe(someDest)
+```
+
+### subclass that defers 'end' for some reason
+
+```js
+class SlowEnd extends Minipass {
+ emit(ev, ...args) {
+ if (ev === 'end') {
+ console.log('going to end, hold on a sec')
+ setTimeout(() => {
+ console.log('ok, ready to end now')
+ super.emit('end', ...args)
+ }, 100)
+ return true
+ } else {
+ return super.emit(ev, ...args)
+ }
+ }
+}
+```
+
+### transform that creates newline-delimited JSON
+
+```js
+class NDJSONEncode extends Minipass {
+ write(obj, cb) {
+ try {
+ // JSON.stringify can throw, emit an error on that
+ return super.write(JSON.stringify(obj) + '\n', 'utf8', cb)
+ } catch (er) {
+ this.emit('error', er)
+ }
+ }
+ end(obj, cb) {
+ if (typeof obj === 'function') {
+ cb = obj
+ obj = undefined
+ }
+ if (obj !== undefined) {
+ this.write(obj)
+ }
+ return super.end(cb)
+ }
+}
+```
+
+### transform that parses newline-delimited JSON
+
+```js
+class NDJSONDecode extends Minipass {
+ constructor(options) {
+ // always be in object mode, as far as Minipass is concerned
+ super({ objectMode: true })
+ this._jsonBuffer = ''
+ }
+ write(chunk, encoding, cb) {
+ if (
+ typeof chunk === 'string' &&
+ typeof encoding === 'string' &&
+ encoding !== 'utf8'
+ ) {
+ chunk = Buffer.from(chunk, encoding).toString()
+ } else if (Buffer.isBuffer(chunk)) {
+ chunk = chunk.toString()
+ }
+ if (typeof encoding === 'function') {
+ cb = encoding
+ }
+ const jsonData = (this._jsonBuffer + chunk).split('\n')
+ this._jsonBuffer = jsonData.pop()
+ for (let i = 0; i < jsonData.length; i++) {
+ try {
+ // JSON.parse can throw, emit an error on that
+ super.write(JSON.parse(jsonData[i]))
+ } catch (er) {
+ this.emit('error', er)
+ continue
+ }
+ }
+ if (cb) cb()
+ }
+}
+```
diff --git a/node_modules/minipass/package.json b/node_modules/minipass/package.json
new file mode 100644
index 0000000..771969b
--- /dev/null
+++ b/node_modules/minipass/package.json
@@ -0,0 +1,82 @@
+{
+ "name": "minipass",
+ "version": "7.1.2",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "./dist/commonjs/index.js",
+ "types": "./dist/commonjs/index.d.ts",
+ "type": "module",
+ "tshy": {
+ "selfLink": false,
+ "main": true,
+ "exports": {
+ "./package.json": "./package.json",
+ ".": "./src/index.ts"
+ }
+ },
+ "exports": {
+ "./package.json": "./package.json",
+ ".": {
+ "import": {
+ "types": "./dist/esm/index.d.ts",
+ "default": "./dist/esm/index.js"
+ },
+ "require": {
+ "types": "./dist/commonjs/index.d.ts",
+ "default": "./dist/commonjs/index.js"
+ }
+ }
+ },
+ "files": [
+ "dist"
+ ],
+ "scripts": {
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "prepublishOnly": "git push origin --follow-tags",
+ "prepare": "tshy",
+ "pretest": "npm run prepare",
+ "presnap": "npm run prepare",
+ "test": "tap",
+ "snap": "tap",
+ "format": "prettier --write . --loglevel warn",
+ "typedoc": "typedoc --tsconfig .tshy/esm.json ./src/*.ts"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 75,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ },
+ "devDependencies": {
+ "@types/end-of-stream": "^1.4.2",
+ "@types/node": "^20.1.2",
+ "end-of-stream": "^1.4.0",
+ "node-abort-controller": "^3.1.1",
+ "prettier": "^2.6.2",
+ "tap": "^19.0.0",
+ "through2": "^2.0.3",
+ "tshy": "^1.14.0",
+ "typedoc": "^0.25.1"
+ },
+ "repository": "https://github.com/isaacs/minipass",
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "tap": {
+ "typecheck": true,
+ "include": [
+ "test/*.ts"
+ ]
+ }
+}
diff --git a/node_modules/mz/HISTORY.md b/node_modules/mz/HISTORY.md
new file mode 100644
index 0000000..6ebee21
--- /dev/null
+++ b/node_modules/mz/HISTORY.md
@@ -0,0 +1,66 @@
+
+2.7.0 / 2017-09-13
+==================
+
+ * feat: support fs.copyFile (#58)
+
+2.6.0 / 2016-11-22
+==================
+
+ * Added fdatasync to fs api (#46)
+
+2.5.0 / 2016-11-04
+==================
+
+ * feat: support fs.mkdtemp
+
+2.4.0 / 2016-03-23
+==================
+
+ * add `fs.truncate()` [#34](https://github.com/normalize/mz/pull/34)
+
+2.3.1 / 2016-02-01
+==================
+
+ * update `any-promise@v1`
+
+2.3.0 / 2016-01-30
+==================
+
+ * feat(package): switch to `any-promise` to support more promise engines
+
+2.2.0 / 2016-01-24
+==================
+
+ * feat(package): add index.js to files
+
+2.1.0 / 2015-10-15
+==================
+
+ * support for readline library
+
+2.0.0 / 2015-05-24
+==================
+
+ * support callbacks as well
+
+1.2.0 / 2014-12-16
+==================
+
+ * refactor promisification to `thenify` and `thenify-all`
+
+1.1.0 / 2014-11-14
+==================
+
+ * use `graceful-fs` if available
+
+1.0.1 / 2014-08-18
+==================
+
+ * don't use `bluebird.promisify()` - unnecessarily wraps runtime errors, causing issues
+
+1.0.0 / 2014-06-18
+==================
+
+ * use `bluebird` by default if found
+ * support node 0.8
diff --git a/node_modules/mz/LICENSE b/node_modules/mz/LICENSE
new file mode 100644
index 0000000..1835f3d
--- /dev/null
+++ b/node_modules/mz/LICENSE
@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
+
+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/mz/README.md b/node_modules/mz/README.md
new file mode 100644
index 0000000..50d6557
--- /dev/null
+++ b/node_modules/mz/README.md
@@ -0,0 +1,106 @@
+
+# MZ - Modernize node.js
+
+[![NPM version][npm-image]][npm-url]
+[![Build status][travis-image]][travis-url]
+[![Test coverage][coveralls-image]][coveralls-url]
+[![Dependency Status][david-image]][david-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+Modernize node.js to current ECMAScript specifications!
+node.js will not update their API to ES6+ [for a while](https://github.com/joyent/node/issues/7549).
+This library is a wrapper for various aspects of node.js' API.
+
+## Installation and Usage
+
+Set `mz` as a dependency and install it.
+
+```bash
+npm i mz
+```
+
+Then prefix the relevant `require()`s with `mz/`:
+
+```js
+var fs = require('mz/fs')
+
+fs.exists(__filename).then(function (exists) {
+ if (exists) // do something
+})
+```
+
+With ES2017, this will allow you to use async functions cleanly with node's core API:
+
+```js
+const fs = require('mz/fs')
+
+
+async function doSomething () {
+ if (await fs.exists(__filename)) // do something
+}
+```
+
+## Promisification
+
+Many node methods are converted into promises.
+Any properties that are deprecated or aren't asynchronous will simply be proxied.
+The modules wrapped are:
+
+- `child_process`
+- `crypto`
+- `dns`
+- `fs` (uses `graceful-fs` if available)
+- `readline`
+- `zlib`
+
+```js
+var exec = require('mz/child_process').exec
+
+exec('node --version').then(function (stdout) {
+ console.log(stdout)
+})
+```
+
+## Promise Engine
+
+`mz` uses [`any-promise`](https://github.com/kevinbeaty/any-promise).
+
+## FAQ
+
+### Can I use this in production?
+
+Yes, Node 4.x ships with stable promises support. For older engines,
+you should probably install your own promise implementation and register it with
+`require('any-promise/register')('bluebird')`.
+
+### Will this make my app faster?
+
+Nope, probably slower actually.
+
+### Can I add more features?
+
+Sure.
+Open an issue.
+
+Currently, the plans are to eventually support:
+
+- New APIs in node.js that are not available in older versions of node
+- ECMAScript7 Streams
+
+[bluebird]: https://github.com/petkaantonov/bluebird
+
+[npm-image]: https://img.shields.io/npm/v/mz.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/mz
+[github-tag]: http://img.shields.io/github/tag/normalize/mz.svg?style=flat-square
+[github-url]: https://github.com/normalize/mz/tags
+[travis-image]: https://img.shields.io/travis/normalize/mz.svg?style=flat-square
+[travis-url]: https://travis-ci.org/normalize/mz
+[coveralls-image]: https://img.shields.io/coveralls/normalize/mz.svg?style=flat-square
+[coveralls-url]: https://coveralls.io/r/normalize/mz?branch=master
+[david-image]: http://img.shields.io/david/normalize/mz.svg?style=flat-square
+[david-url]: https://david-dm.org/normalize/mz
+[license-image]: http://img.shields.io/npm/l/mz.svg?style=flat-square
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/mz.svg?style=flat-square
+[downloads-url]: https://npmjs.org/package/mz
diff --git a/node_modules/mz/child_process.js b/node_modules/mz/child_process.js
new file mode 100644
index 0000000..06d5d9e
--- /dev/null
+++ b/node_modules/mz/child_process.js
@@ -0,0 +1,8 @@
+
+require('thenify-all').withCallback(
+ require('child_process'),
+ exports, [
+ 'exec',
+ 'execFile',
+ ]
+)
diff --git a/node_modules/mz/crypto.js b/node_modules/mz/crypto.js
new file mode 100644
index 0000000..d8cff57
--- /dev/null
+++ b/node_modules/mz/crypto.js
@@ -0,0 +1,9 @@
+
+require('thenify-all').withCallback(
+ require('crypto'),
+ exports, [
+ 'pbkdf2',
+ 'pseudoRandomBytes',
+ 'randomBytes'
+ ]
+)
diff --git a/node_modules/mz/dns.js b/node_modules/mz/dns.js
new file mode 100644
index 0000000..c103582
--- /dev/null
+++ b/node_modules/mz/dns.js
@@ -0,0 +1,16 @@
+
+require('thenify-all').withCallback(
+ require('dns'),
+ exports, [
+ 'lookup',
+ 'resolve',
+ 'resolve4',
+ 'resolve6',
+ 'resolveCname',
+ 'resolveMx',
+ 'resolveNs',
+ 'resolveSrv',
+ 'resolveTxt',
+ 'reverse'
+ ]
+)
diff --git a/node_modules/mz/fs.js b/node_modules/mz/fs.js
new file mode 100644
index 0000000..1cfd2d7
--- /dev/null
+++ b/node_modules/mz/fs.js
@@ -0,0 +1,62 @@
+
+var Promise = require('any-promise')
+var fs
+try {
+ fs = require('graceful-fs')
+} catch(err) {
+ fs = require('fs')
+}
+
+var api = [
+ 'appendFile',
+ 'chmod',
+ 'chown',
+ 'close',
+ 'fchmod',
+ 'fchown',
+ 'fdatasync',
+ 'fstat',
+ 'fsync',
+ 'ftruncate',
+ 'futimes',
+ 'lchown',
+ 'link',
+ 'lstat',
+ 'mkdir',
+ 'open',
+ 'read',
+ 'readFile',
+ 'readdir',
+ 'readlink',
+ 'realpath',
+ 'rename',
+ 'rmdir',
+ 'stat',
+ 'symlink',
+ 'truncate',
+ 'unlink',
+ 'utimes',
+ 'write',
+ 'writeFile'
+]
+
+typeof fs.access === 'function' && api.push('access')
+typeof fs.copyFile === 'function' && api.push('copyFile')
+typeof fs.mkdtemp === 'function' && api.push('mkdtemp')
+
+require('thenify-all').withCallback(fs, exports, api)
+
+exports.exists = function (filename, callback) {
+ // callback
+ if (typeof callback === 'function') {
+ return fs.stat(filename, function (err) {
+ callback(null, !err);
+ })
+ }
+ // or promise
+ return new Promise(function (resolve) {
+ fs.stat(filename, function (err) {
+ resolve(!err)
+ })
+ })
+}
diff --git a/node_modules/mz/index.js b/node_modules/mz/index.js
new file mode 100644
index 0000000..cef508d
--- /dev/null
+++ b/node_modules/mz/index.js
@@ -0,0 +1,8 @@
+module.exports = {
+ fs: require('./fs'),
+ dns: require('./dns'),
+ zlib: require('./zlib'),
+ crypto: require('./crypto'),
+ readline: require('./readline'),
+ child_process: require('./child_process')
+}
diff --git a/node_modules/mz/package.json b/node_modules/mz/package.json
new file mode 100644
index 0000000..de8d542
--- /dev/null
+++ b/node_modules/mz/package.json
@@ -0,0 +1,44 @@
+{
+ "name": "mz",
+ "description": "modernize node.js to current ECMAScript standards",
+ "version": "2.7.0",
+ "author": {
+ "name": "Jonathan Ong",
+ "email": "me@jongleberry.com",
+ "url": "http://jongleberry.com",
+ "twitter": "https://twitter.com/jongleberry"
+ },
+ "license": "MIT",
+ "repository": "normalize/mz",
+ "dependencies": {
+ "any-promise": "^1.0.0",
+ "object-assign": "^4.0.1",
+ "thenify-all": "^1.0.0"
+ },
+ "devDependencies": {
+ "istanbul": "^0.4.0",
+ "bluebird": "^3.0.0",
+ "mocha": "^3.0.0"
+ },
+ "scripts": {
+ "test": "mocha --reporter spec",
+ "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot",
+ "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter dot"
+ },
+ "keywords": [
+ "promisify",
+ "promise",
+ "thenify",
+ "then",
+ "es6"
+ ],
+ "files": [
+ "index.js",
+ "child_process.js",
+ "crypto.js",
+ "dns.js",
+ "fs.js",
+ "readline.js",
+ "zlib.js"
+ ]
+}
diff --git a/node_modules/mz/readline.js b/node_modules/mz/readline.js
new file mode 100644
index 0000000..eb70c46
--- /dev/null
+++ b/node_modules/mz/readline.js
@@ -0,0 +1,64 @@
+var readline = require('readline')
+var Promise = require('any-promise')
+var objectAssign = require('object-assign')
+var Interface = readline.Interface
+
+function wrapCompleter (completer) {
+ if (completer.length === 2) return completer
+
+ return function (line, cb) {
+ var result = completer(line)
+
+ if (typeof result.then !== 'function') {
+ return cb(null, result)
+ }
+
+ result.catch(cb).then(function (result) {
+ process.nextTick(function () { cb(null, result) })
+ })
+ }
+}
+
+function InterfaceAsPromised (input, output, completer, terminal) {
+ if (arguments.length === 1) {
+ var options = input
+
+ if (typeof options.completer === 'function') {
+ options = objectAssign({}, options, {
+ completer: wrapCompleter(options.completer)
+ })
+ }
+
+ Interface.call(this, options)
+ } else {
+ if (typeof completer === 'function') {
+ completer = wrapCompleter(completer)
+ }
+
+ Interface.call(this, input, output, completer, terminal)
+ }
+}
+
+InterfaceAsPromised.prototype = Object.create(Interface.prototype)
+
+InterfaceAsPromised.prototype.question = function (question, callback) {
+ if (typeof callback === 'function') {
+ return Interface.prototype.question.call(this, question, callback)
+ }
+
+ var self = this
+ return new Promise(function (resolve) {
+ Interface.prototype.question.call(self, question, resolve)
+ })
+}
+
+objectAssign(exports, readline, {
+ Interface: InterfaceAsPromised,
+ createInterface: function (input, output, completer, terminal) {
+ if (arguments.length === 1) {
+ return new InterfaceAsPromised(input)
+ }
+
+ return new InterfaceAsPromised(input, output, completer, terminal)
+ }
+})
diff --git a/node_modules/mz/zlib.js b/node_modules/mz/zlib.js
new file mode 100644
index 0000000..a05c26a
--- /dev/null
+++ b/node_modules/mz/zlib.js
@@ -0,0 +1,13 @@
+
+require('thenify-all').withCallback(
+ require('zlib'),
+ exports, [
+ 'deflate',
+ 'deflateRaw',
+ 'gzip',
+ 'gunzip',
+ 'inflate',
+ 'inflateRaw',
+ 'unzip',
+ ]
+)
diff --git a/node_modules/nanoid/LICENSE b/node_modules/nanoid/LICENSE
new file mode 100644
index 0000000..37f56aa
--- /dev/null
+++ b/node_modules/nanoid/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2017 Andrey Sitnik
+
+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/nanoid/README.md b/node_modules/nanoid/README.md
new file mode 100644
index 0000000..35abb57
--- /dev/null
+++ b/node_modules/nanoid/README.md
@@ -0,0 +1,39 @@
+# Nano ID
+
+
+
+**English** | [Русский](./README.ru.md) | [简体中文](./README.zh-CN.md) | [Bahasa Indonesia](./README.id-ID.md)
+
+A tiny, secure, URL-friendly, unique string ID generator for JavaScript.
+
+> “An amazing level of senseless perfectionism,
+> which is simply impossible not to respect.”
+
+* **Small.** 130 bytes (minified and gzipped). No dependencies.
+ [Size Limit] controls the size.
+* **Fast.** It is 2 times faster than UUID.
+* **Safe.** It uses hardware random generator. Can be used in clusters.
+* **Short IDs.** It uses a larger alphabet than UUID (`A-Za-z0-9_-`).
+ So ID size was reduced from 36 to 21 symbols.
+* **Portable.** Nano ID was ported
+ to [20 programming languages](#other-programming-languages).
+
+```js
+import { nanoid } from 'nanoid'
+model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
+```
+
+Supports modern browsers, IE [with Babel], Node.js and React Native.
+
+[online tool]: https://gitpod.io/#https://github.com/ai/nanoid/
+[with Babel]: https://developer.epages.com/blog/coding/how-to-transpile-node-modules-with-babel-and-webpack-in-a-monorepo/
+[Size Limit]: https://github.com/ai/size-limit
+
+
+ 
+
+
+## Docs
+Read full docs **[here](https://github.com/ai/nanoid#readme)**.
diff --git a/node_modules/nanoid/async/index.browser.cjs b/node_modules/nanoid/async/index.browser.cjs
new file mode 100644
index 0000000..7e5bba8
--- /dev/null
+++ b/node_modules/nanoid/async/index.browser.cjs
@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+ let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+ return async (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = crypto.getRandomValues(new Uint8Array(step))
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let nanoid = async (size = 21) => {
+ let id = ''
+ let bytes = crypto.getRandomValues(new Uint8Array(size))
+ while (size--) {
+ let byte = bytes[size] & 63
+ if (byte < 36) {
+ id += byte.toString(36)
+ } else if (byte < 62) {
+ id += (byte - 26).toString(36).toUpperCase()
+ } else if (byte < 63) {
+ id += '_'
+ } else {
+ id += '-'
+ }
+ }
+ return id
+}
+module.exports = { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.browser.js b/node_modules/nanoid/async/index.browser.js
new file mode 100644
index 0000000..5ece04d
--- /dev/null
+++ b/node_modules/nanoid/async/index.browser.js
@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+ let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+ return async (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = crypto.getRandomValues(new Uint8Array(step))
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let nanoid = async (size = 21) => {
+ let id = ''
+ let bytes = crypto.getRandomValues(new Uint8Array(size))
+ while (size--) {
+ let byte = bytes[size] & 63
+ if (byte < 36) {
+ id += byte.toString(36)
+ } else if (byte < 62) {
+ id += (byte - 26).toString(36).toUpperCase()
+ } else if (byte < 63) {
+ id += '_'
+ } else {
+ id += '-'
+ }
+ }
+ return id
+}
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.cjs b/node_modules/nanoid/async/index.cjs
new file mode 100644
index 0000000..50db105
--- /dev/null
+++ b/node_modules/nanoid/async/index.cjs
@@ -0,0 +1,35 @@
+let crypto = require('crypto')
+let { urlAlphabet } = require('../url-alphabet/index.cjs')
+let random = bytes =>
+ new Promise((resolve, reject) => {
+ crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+ if (err) {
+ reject(err)
+ } else {
+ resolve(buf)
+ }
+ })
+ })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+ let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+ let tick = (id, size = defaultSize) =>
+ random(step).then(bytes => {
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ return tick(id, size)
+ })
+ return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+ random(size).then(bytes => {
+ let id = ''
+ while (size--) {
+ id += urlAlphabet[bytes[size] & 63]
+ }
+ return id
+ })
+module.exports = { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.d.ts b/node_modules/nanoid/async/index.d.ts
new file mode 100644
index 0000000..9e91965
--- /dev/null
+++ b/node_modules/nanoid/async/index.d.ts
@@ -0,0 +1,56 @@
+/**
+ * Generate secure URL-friendly unique ID. The non-blocking version.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/async'
+ * nanoid().then(id => {
+ * model.id = id
+ * })
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A promise with a random string.
+ */
+export function nanoid(size?: number): Promise
+
+/**
+ * A low-level function.
+ * Generate secure unique ID with custom alphabet. The non-blocking version.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A function that returns a promise with a random string.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/async'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid().then(id => {
+ * model.id = id //=> "8ё56а"
+ * })
+ * ```
+ */
+export function customAlphabet(
+ alphabet: string,
+ defaultSize?: number
+): (size?: number) => Promise
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { random } from 'nanoid/async'
+ * random(5).then(bytes => {
+ * bytes //=> [10, 67, 212, 67, 89]
+ * })
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns A promise with a random bytes array.
+ */
+export function random(bytes: number): Promise
diff --git a/node_modules/nanoid/async/index.js b/node_modules/nanoid/async/index.js
new file mode 100644
index 0000000..803fad6
--- /dev/null
+++ b/node_modules/nanoid/async/index.js
@@ -0,0 +1,35 @@
+import crypto from 'crypto'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = bytes =>
+ new Promise((resolve, reject) => {
+ crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+ if (err) {
+ reject(err)
+ } else {
+ resolve(buf)
+ }
+ })
+ })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+ let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+ let tick = (id, size = defaultSize) =>
+ random(step).then(bytes => {
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ return tick(id, size)
+ })
+ return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+ random(size).then(bytes => {
+ let id = ''
+ while (size--) {
+ id += urlAlphabet[bytes[size] & 63]
+ }
+ return id
+ })
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.native.js b/node_modules/nanoid/async/index.native.js
new file mode 100644
index 0000000..5cb3d57
--- /dev/null
+++ b/node_modules/nanoid/async/index.native.js
@@ -0,0 +1,26 @@
+import { getRandomBytesAsync } from 'expo-random'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = getRandomBytesAsync
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+ let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+ let tick = (id, size = defaultSize) =>
+ random(step).then(bytes => {
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ return tick(id, size)
+ })
+ return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+ random(size).then(bytes => {
+ let id = ''
+ while (size--) {
+ id += urlAlphabet[bytes[size] & 63]
+ }
+ return id
+ })
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/package.json b/node_modules/nanoid/async/package.json
new file mode 100644
index 0000000..578cdb4
--- /dev/null
+++ b/node_modules/nanoid/async/package.json
@@ -0,0 +1,12 @@
+{
+ "type": "module",
+ "main": "index.cjs",
+ "module": "index.js",
+ "react-native": {
+ "./index.js": "./index.native.js"
+ },
+ "browser": {
+ "./index.js": "./index.browser.js",
+ "./index.cjs": "./index.browser.cjs"
+ }
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/bin/nanoid.cjs b/node_modules/nanoid/bin/nanoid.cjs
new file mode 100644
index 0000000..c76db0f
--- /dev/null
+++ b/node_modules/nanoid/bin/nanoid.cjs
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+let { nanoid, customAlphabet } = require('..')
+
+function print(msg) {
+ process.stdout.write(msg + '\n')
+}
+
+function error(msg) {
+ process.stderr.write(msg + '\n')
+ process.exit(1)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+ print(`
+ Usage
+ $ nanoid [options]
+
+ Options
+ -s, --size Generated ID size
+ -a, --alphabet Alphabet to use
+ -h, --help Show this help
+
+ Examples
+ $ nanoid --s 15
+ S9sBF77U6sDB8Yg
+
+ $ nanoid --size 10 --alphabet abc
+ bcabababca`)
+ process.exit()
+}
+
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+ let arg = process.argv[i]
+ if (arg === '--size' || arg === '-s') {
+ size = Number(process.argv[i + 1])
+ i += 1
+ if (Number.isNaN(size) || size <= 0) {
+ error('Size must be positive integer')
+ }
+ } else if (arg === '--alphabet' || arg === '-a') {
+ alphabet = process.argv[i + 1]
+ i += 1
+ } else {
+ error('Unknown argument ' + arg)
+ }
+}
+
+if (alphabet) {
+ let customNanoid = customAlphabet(alphabet, size)
+ print(customNanoid())
+} else {
+ print(nanoid(size))
+}
diff --git a/node_modules/nanoid/index.browser.cjs b/node_modules/nanoid/index.browser.cjs
new file mode 100644
index 0000000..f800d6f
--- /dev/null
+++ b/node_modules/nanoid/index.browser.cjs
@@ -0,0 +1,34 @@
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+ let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+ let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+ return (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = getRandom(step)
+ let j = step
+ while (j--) {
+ id += alphabet[bytes[j] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let customAlphabet = (alphabet, size = 21) =>
+ customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+ crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+ byte &= 63
+ if (byte < 36) {
+ id += byte.toString(36)
+ } else if (byte < 62) {
+ id += (byte - 26).toString(36).toUpperCase()
+ } else if (byte > 62) {
+ id += '-'
+ } else {
+ id += '_'
+ }
+ return id
+ }, '')
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.browser.js b/node_modules/nanoid/index.browser.js
new file mode 100644
index 0000000..8b3139b
--- /dev/null
+++ b/node_modules/nanoid/index.browser.js
@@ -0,0 +1,34 @@
+import { urlAlphabet } from './url-alphabet/index.js'
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+ let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+ let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+ return (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = getRandom(step)
+ let j = step
+ while (j--) {
+ id += alphabet[bytes[j] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let customAlphabet = (alphabet, size = 21) =>
+ customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+ crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+ byte &= 63
+ if (byte < 36) {
+ id += byte.toString(36)
+ } else if (byte < 62) {
+ id += (byte - 26).toString(36).toUpperCase()
+ } else if (byte > 62) {
+ id += '-'
+ } else {
+ id += '_'
+ }
+ return id
+ }, '')
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.cjs b/node_modules/nanoid/index.cjs
new file mode 100644
index 0000000..0fa85e9
--- /dev/null
+++ b/node_modules/nanoid/index.cjs
@@ -0,0 +1,45 @@
+let crypto = require('crypto')
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+let fillPool = bytes => {
+ if (!pool || pool.length < bytes) {
+ pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+ crypto.randomFillSync(pool)
+ poolOffset = 0
+ } else if (poolOffset + bytes > pool.length) {
+ crypto.randomFillSync(pool)
+ poolOffset = 0
+ }
+ poolOffset += bytes
+}
+let random = bytes => {
+ fillPool((bytes -= 0))
+ return pool.subarray(poolOffset - bytes, poolOffset)
+}
+let customRandom = (alphabet, defaultSize, getRandom) => {
+ let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+ let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+ return (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = getRandom(step)
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let customAlphabet = (alphabet, size = 21) =>
+ customRandom(alphabet, size, random)
+let nanoid = (size = 21) => {
+ fillPool((size -= 0))
+ let id = ''
+ for (let i = poolOffset - size; i < poolOffset; i++) {
+ id += urlAlphabet[pool[i] & 63]
+ }
+ return id
+}
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.d.cts b/node_modules/nanoid/index.d.cts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/node_modules/nanoid/index.d.cts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+ alphabet: string,
+ defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ * const random = []
+ * for (let i = 0; i < size; i++) {
+ * random.push(randomByte())
+ * }
+ * return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+ alphabet: string,
+ size: number,
+ random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/node_modules/nanoid/index.d.ts b/node_modules/nanoid/index.d.ts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/node_modules/nanoid/index.d.ts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+ alphabet: string,
+ defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ * const random = []
+ * for (let i = 0; i < size; i++) {
+ * random.push(randomByte())
+ * }
+ * return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+ alphabet: string,
+ size: number,
+ random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/node_modules/nanoid/index.js b/node_modules/nanoid/index.js
new file mode 100644
index 0000000..21e155f
--- /dev/null
+++ b/node_modules/nanoid/index.js
@@ -0,0 +1,45 @@
+import crypto from 'crypto'
+import { urlAlphabet } from './url-alphabet/index.js'
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+let fillPool = bytes => {
+ if (!pool || pool.length < bytes) {
+ pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+ crypto.randomFillSync(pool)
+ poolOffset = 0
+ } else if (poolOffset + bytes > pool.length) {
+ crypto.randomFillSync(pool)
+ poolOffset = 0
+ }
+ poolOffset += bytes
+}
+let random = bytes => {
+ fillPool((bytes -= 0))
+ return pool.subarray(poolOffset - bytes, poolOffset)
+}
+let customRandom = (alphabet, defaultSize, getRandom) => {
+ let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+ let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+ return (size = defaultSize) => {
+ let id = ''
+ while (true) {
+ let bytes = getRandom(step)
+ let i = step
+ while (i--) {
+ id += alphabet[bytes[i] & mask] || ''
+ if (id.length === size) return id
+ }
+ }
+ }
+}
+let customAlphabet = (alphabet, size = 21) =>
+ customRandom(alphabet, size, random)
+let nanoid = (size = 21) => {
+ fillPool((size -= 0))
+ let id = ''
+ for (let i = poolOffset - size; i < poolOffset; i++) {
+ id += urlAlphabet[pool[i] & 63]
+ }
+ return id
+}
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/nanoid.js b/node_modules/nanoid/nanoid.js
new file mode 100644
index 0000000..ec242ea
--- /dev/null
+++ b/node_modules/nanoid/nanoid.js
@@ -0,0 +1 @@
+export let nanoid=(t=21)=>crypto.getRandomValues(new Uint8Array(t)).reduce(((t,e)=>t+=(e&=63)<36?e.toString(36):e<62?(e-26).toString(36).toUpperCase():e<63?"_":"-"),"");
\ No newline at end of file
diff --git a/node_modules/nanoid/non-secure/index.cjs b/node_modules/nanoid/non-secure/index.cjs
new file mode 100644
index 0000000..09d57cd
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.cjs
@@ -0,0 +1,21 @@
+let urlAlphabet =
+ 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ return (size = defaultSize) => {
+ let id = ''
+ let i = size
+ while (i--) {
+ id += alphabet[(Math.random() * alphabet.length) | 0]
+ }
+ return id
+ }
+}
+let nanoid = (size = 21) => {
+ let id = ''
+ let i = size
+ while (i--) {
+ id += urlAlphabet[(Math.random() * 64) | 0]
+ }
+ return id
+}
+module.exports = { nanoid, customAlphabet }
diff --git a/node_modules/nanoid/non-secure/index.d.ts b/node_modules/nanoid/non-secure/index.d.ts
new file mode 100644
index 0000000..4965322
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.d.ts
@@ -0,0 +1,33 @@
+/**
+ * Generate URL-friendly unique ID. This method uses the non-secure
+ * predictable random generator with bigger collision probability.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/non-secure'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate a unique ID based on a custom alphabet.
+ * This method uses the non-secure predictable random generator
+ * with bigger collision probability.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/non-secure'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * model.id = //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+ alphabet: string,
+ defaultSize?: number
+): (size?: number) => string
diff --git a/node_modules/nanoid/non-secure/index.js b/node_modules/nanoid/non-secure/index.js
new file mode 100644
index 0000000..e7e19ad
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.js
@@ -0,0 +1,21 @@
+let urlAlphabet =
+ 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+let customAlphabet = (alphabet, defaultSize = 21) => {
+ return (size = defaultSize) => {
+ let id = ''
+ let i = size
+ while (i--) {
+ id += alphabet[(Math.random() * alphabet.length) | 0]
+ }
+ return id
+ }
+}
+let nanoid = (size = 21) => {
+ let id = ''
+ let i = size
+ while (i--) {
+ id += urlAlphabet[(Math.random() * 64) | 0]
+ }
+ return id
+}
+export { nanoid, customAlphabet }
diff --git a/node_modules/nanoid/non-secure/package.json b/node_modules/nanoid/non-secure/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/node_modules/nanoid/non-secure/package.json
@@ -0,0 +1,6 @@
+{
+ "type": "module",
+ "main": "index.cjs",
+ "module": "index.js",
+ "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/package.json b/node_modules/nanoid/package.json
new file mode 100644
index 0000000..4f24d96
--- /dev/null
+++ b/node_modules/nanoid/package.json
@@ -0,0 +1,88 @@
+{
+ "name": "nanoid",
+ "version": "3.3.7",
+ "description": "A tiny (116 bytes), secure URL-friendly unique string ID generator",
+ "keywords": [
+ "uuid",
+ "random",
+ "id",
+ "url"
+ ],
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ },
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "author": "Andrey Sitnik ",
+ "license": "MIT",
+ "repository": "ai/nanoid",
+ "browser": {
+ "./index.js": "./index.browser.js",
+ "./async/index.js": "./async/index.browser.js",
+ "./async/index.cjs": "./async/index.browser.cjs",
+ "./index.cjs": "./index.browser.cjs"
+ },
+ "react-native": "index.js",
+ "bin": "./bin/nanoid.cjs",
+ "sideEffects": false,
+ "types": "./index.d.ts",
+ "type": "module",
+ "main": "index.cjs",
+ "module": "index.js",
+ "exports": {
+ ".": {
+ "browser": "./index.browser.js",
+ "require": {
+ "types": "./index.d.cts",
+ "default": "./index.cjs"
+ },
+ "import": {
+ "types": "./index.d.ts",
+ "default": "./index.js"
+ },
+ "default": "./index.js"
+ },
+ "./package.json": "./package.json",
+ "./async/package.json": "./async/package.json",
+ "./async": {
+ "browser": "./async/index.browser.js",
+ "require": {
+ "types": "./index.d.cts",
+ "default": "./async/index.cjs"
+ },
+ "import": {
+ "types": "./index.d.ts",
+ "default": "./async/index.js"
+ },
+ "default": "./async/index.js"
+ },
+ "./non-secure/package.json": "./non-secure/package.json",
+ "./non-secure": {
+ "require": {
+ "types": "./index.d.cts",
+ "default": "./non-secure/index.cjs"
+ },
+ "import": {
+ "types": "./index.d.ts",
+ "default": "./non-secure/index.js"
+ },
+ "default": "./non-secure/index.js"
+ },
+ "./url-alphabet/package.json": "./url-alphabet/package.json",
+ "./url-alphabet": {
+ "require": {
+ "types": "./index.d.cts",
+ "default": "./url-alphabet/index.cjs"
+ },
+ "import": {
+ "types": "./index.d.ts",
+ "default": "./url-alphabet/index.js"
+ },
+ "default": "./url-alphabet/index.js"
+ }
+ }
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/url-alphabet/index.cjs b/node_modules/nanoid/url-alphabet/index.cjs
new file mode 100644
index 0000000..757b709
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/index.cjs
@@ -0,0 +1,3 @@
+let urlAlphabet =
+ 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+module.exports = { urlAlphabet }
diff --git a/node_modules/nanoid/url-alphabet/index.js b/node_modules/nanoid/url-alphabet/index.js
new file mode 100644
index 0000000..c2782e5
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/index.js
@@ -0,0 +1,3 @@
+let urlAlphabet =
+ 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+export { urlAlphabet }
diff --git a/node_modules/nanoid/url-alphabet/package.json b/node_modules/nanoid/url-alphabet/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/package.json
@@ -0,0 +1,6 @@
+{
+ "type": "module",
+ "main": "index.cjs",
+ "module": "index.js",
+ "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/node_modules/normalize-path/LICENSE b/node_modules/normalize-path/LICENSE
new file mode 100644
index 0000000..d32ab44
--- /dev/null
+++ b/node_modules/normalize-path/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-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/normalize-path/README.md b/node_modules/normalize-path/README.md
new file mode 100644
index 0000000..726d4d6
--- /dev/null
+++ b/node_modules/normalize-path/README.md
@@ -0,0 +1,127 @@
+# normalize-path [](https://www.npmjs.com/package/normalize-path) [](https://npmjs.org/package/normalize-path) [](https://npmjs.org/package/normalize-path) [](https://travis-ci.org/jonschlinkert/normalize-path)
+
+> Normalize slashes in a file path to be posix/unix-like forward slashes. Also condenses repeat slashes to a single slash and removes and trailing slashes, unless disabled.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save normalize-path
+```
+
+## Usage
+
+```js
+const normalize = require('normalize-path');
+
+console.log(normalize('\\foo\\bar\\baz\\'));
+//=> '/foo/bar/baz'
+```
+
+**win32 namespaces**
+
+```js
+console.log(normalize('\\\\?\\UNC\\Server01\\user\\docs\\Letter.txt'));
+//=> '//?/UNC/Server01/user/docs/Letter.txt'
+
+console.log(normalize('\\\\.\\CdRomX'));
+//=> '//./CdRomX'
+```
+
+**Consecutive slashes**
+
+Condenses multiple consecutive forward slashes (except for leading slashes in win32 namespaces) to a single slash.
+
+```js
+console.log(normalize('.//foo//bar///////baz/'));
+//=> './foo/bar/baz'
+```
+
+### Trailing slashes
+
+By default trailing slashes are removed. Pass `false` as the last argument to disable this behavior and _**keep** trailing slashes_:
+
+```js
+console.log(normalize('foo\\bar\\baz\\', false)); //=> 'foo/bar/baz/'
+console.log(normalize('./foo/bar/baz/', false)); //=> './foo/bar/baz/'
+```
+
+## Release history
+
+### v3.0
+
+No breaking changes in this release.
+
+* a check was added to ensure that [win32 namespaces](https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces) are handled properly by win32 `path.parse()` after a path has been normalized by this library.
+* a minor optimization was made to simplify how the trailing separator was handled
+
+## About
+
+
+Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+
+
+
+Running Tests
+
+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
+```
+
+
+
+
+Building docs
+
+_(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
+```
+
+
+
+### Related projects
+
+Other useful path-related libraries:
+
+* [contains-path](https://www.npmjs.com/package/contains-path): Return true if a file path contains the given path. | [homepage](https://github.com/jonschlinkert/contains-path "Return true if a file path contains the given path.")
+* [is-absolute](https://www.npmjs.com/package/is-absolute): Returns true if a file path is absolute. Does not rely on the path module… [more](https://github.com/jonschlinkert/is-absolute) | [homepage](https://github.com/jonschlinkert/is-absolute "Returns true if a file path is absolute. Does not rely on the path module and can be used as a polyfill for node.js native `path.isAbolute`.")
+* [is-relative](https://www.npmjs.com/package/is-relative): Returns `true` if the path appears to be relative. | [homepage](https://github.com/jonschlinkert/is-relative "Returns `true` if the path appears to be relative.")
+* [parse-filepath](https://www.npmjs.com/package/parse-filepath): Pollyfill for node.js `path.parse`, parses a filepath into an object. | [homepage](https://github.com/jonschlinkert/parse-filepath "Pollyfill for node.js `path.parse`, parses a filepath into an object.")
+* [path-ends-with](https://www.npmjs.com/package/path-ends-with): Return `true` if a file path ends with the given string/suffix. | [homepage](https://github.com/jonschlinkert/path-ends-with "Return `true` if a file path ends with the given string/suffix.")
+* [unixify](https://www.npmjs.com/package/unixify): Convert Windows file paths to unix paths. | [homepage](https://github.com/jonschlinkert/unixify "Convert Windows file paths to unix paths.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 35 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 1 | [phated](https://github.com/phated) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](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 April 19, 2018._
\ No newline at end of file
diff --git a/node_modules/normalize-path/index.js b/node_modules/normalize-path/index.js
new file mode 100644
index 0000000..6fac553
--- /dev/null
+++ b/node_modules/normalize-path/index.js
@@ -0,0 +1,35 @@
+/*!
+ * normalize-path
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+module.exports = function(path, stripTrailing) {
+ if (typeof path !== 'string') {
+ throw new TypeError('expected path to be a string');
+ }
+
+ if (path === '\\' || path === '/') return '/';
+
+ var len = path.length;
+ if (len <= 1) return path;
+
+ // ensure that win32 namespaces has two leading slashes, so that the path is
+ // handled properly by the win32 version of path.parse() after being normalized
+ // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+ var prefix = '';
+ if (len > 4 && path[3] === '\\') {
+ var ch = path[2];
+ if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+ path = path.slice(2);
+ prefix = '//';
+ }
+ }
+
+ var segs = path.split(/[/\\]+/);
+ if (stripTrailing !== false && segs[segs.length - 1] === '') {
+ segs.pop();
+ }
+ return prefix + segs.join('/');
+};
diff --git a/node_modules/normalize-path/package.json b/node_modules/normalize-path/package.json
new file mode 100644
index 0000000..ad61098
--- /dev/null
+++ b/node_modules/normalize-path/package.json
@@ -0,0 +1,77 @@
+{
+ "name": "normalize-path",
+ "description": "Normalize slashes in a file path to be posix/unix-like forward slashes. Also condenses repeat slashes to a single slash and removes and trailing slashes, unless disabled.",
+ "version": "3.0.0",
+ "homepage": "https://github.com/jonschlinkert/normalize-path",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "contributors": [
+ "Blaine Bublitz (https://twitter.com/BlaineBublitz)",
+ "Jon Schlinkert (http://twitter.com/jonschlinkert)"
+ ],
+ "repository": "jonschlinkert/normalize-path",
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/normalize-path/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "devDependencies": {
+ "gulp-format-md": "^1.0.0",
+ "minimist": "^1.2.0",
+ "mocha": "^3.5.3"
+ },
+ "keywords": [
+ "absolute",
+ "backslash",
+ "delimiter",
+ "file",
+ "file-path",
+ "filepath",
+ "fix",
+ "forward",
+ "fp",
+ "fs",
+ "normalize",
+ "path",
+ "relative",
+ "separator",
+ "slash",
+ "slashes",
+ "trailing",
+ "unix",
+ "urix"
+ ],
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "related": {
+ "description": "Other useful path-related libraries:",
+ "list": [
+ "contains-path",
+ "is-absolute",
+ "is-relative",
+ "parse-filepath",
+ "path-ends-with",
+ "path-ends-with",
+ "unixify"
+ ]
+ },
+ "lint": {
+ "reflinks": true
+ }
+ }
+}
diff --git a/node_modules/object-assign/index.js b/node_modules/object-assign/index.js
new file mode 100644
index 0000000..0930cf8
--- /dev/null
+++ b/node_modules/object-assign/index.js
@@ -0,0 +1,90 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+'use strict';
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
+
+ return Object(val);
+}
+
+function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
+ }
+
+ // Detect buggy property enumeration order in older V8 versions.
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+ var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+ test1[5] = 'de';
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test2 = {};
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+ if (order2.join('') !== '0123456789') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+ if (Object.keys(Object.assign({}, test3)).join('') !==
+ 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ // We don't expect any of the above to throw, but better to be safe.
+ return false;
+ }
+}
+
+module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
+
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty.call(from, key)) {
+ to[key] = from[key];
+ }
+ }
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
+ }
+ }
+ }
+
+ return to;
+};
diff --git a/node_modules/object-assign/license b/node_modules/object-assign/license
new file mode 100644
index 0000000..654d0bf
--- /dev/null
+++ b/node_modules/object-assign/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+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/object-assign/package.json b/node_modules/object-assign/package.json
new file mode 100644
index 0000000..503eb1e
--- /dev/null
+++ b/node_modules/object-assign/package.json
@@ -0,0 +1,42 @@
+{
+ "name": "object-assign",
+ "version": "4.1.1",
+ "description": "ES2015 `Object.assign()` ponyfill",
+ "license": "MIT",
+ "repository": "sindresorhus/object-assign",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "xo && ava",
+ "bench": "matcha bench.js"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "object",
+ "assign",
+ "extend",
+ "properties",
+ "es2015",
+ "ecmascript",
+ "harmony",
+ "ponyfill",
+ "prollyfill",
+ "polyfill",
+ "shim",
+ "browser"
+ ],
+ "devDependencies": {
+ "ava": "^0.16.0",
+ "lodash": "^4.16.4",
+ "matcha": "^0.7.0",
+ "xo": "^0.16.0"
+ }
+}
diff --git a/node_modules/object-assign/readme.md b/node_modules/object-assign/readme.md
new file mode 100644
index 0000000..1be09d3
--- /dev/null
+++ b/node_modules/object-assign/readme.md
@@ -0,0 +1,61 @@
+# object-assign [](https://travis-ci.org/sindresorhus/object-assign)
+
+> ES2015 [`Object.assign()`](http://www.2ality.com/2014/01/object-assign.html) [ponyfill](https://ponyfill.com)
+
+
+## Use the built-in
+
+Node.js 4 and up, as well as every evergreen browser (Chrome, Edge, Firefox, Opera, Safari),
+support `Object.assign()` :tada:. If you target only those environments, then by all
+means, use `Object.assign()` instead of this package.
+
+
+## Install
+
+```
+$ npm install --save object-assign
+```
+
+
+## Usage
+
+```js
+const objectAssign = require('object-assign');
+
+objectAssign({foo: 0}, {bar: 1});
+//=> {foo: 0, bar: 1}
+
+// multiple sources
+objectAssign({foo: 0}, {bar: 1}, {baz: 2});
+//=> {foo: 0, bar: 1, baz: 2}
+
+// overwrites equal keys
+objectAssign({foo: 0}, {foo: 1}, {foo: 2});
+//=> {foo: 2}
+
+// ignores null and undefined sources
+objectAssign({foo: 0}, null, {bar: 1}, undefined);
+//=> {foo: 0, bar: 1}
+```
+
+
+## API
+
+### objectAssign(target, [source, ...])
+
+Assigns enumerable own properties of `source` objects to the `target` object and returns the `target` object. Additional `source` objects will overwrite previous ones.
+
+
+## Resources
+
+- [ES2015 spec - Object.assign](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign)
+
+
+## Related
+
+- [deep-assign](https://github.com/sindresorhus/deep-assign) - Recursive `Object.assign()`
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/object-hash/LICENSE b/node_modules/object-hash/LICENSE
new file mode 100644
index 0000000..6ea185f
--- /dev/null
+++ b/node_modules/object-hash/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 object-hash contributors
+
+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/object-hash/index.js b/node_modules/object-hash/index.js
new file mode 100644
index 0000000..962bf62
--- /dev/null
+++ b/node_modules/object-hash/index.js
@@ -0,0 +1,453 @@
+'use strict';
+
+var crypto = require('crypto');
+
+/**
+ * Exported function
+ *
+ * Options:
+ *
+ * - `algorithm` hash algo to be used by this instance: *'sha1', 'md5'
+ * - `excludeValues` {true|*false} hash object keys, values ignored
+ * - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64'
+ * - `ignoreUnknown` {true|*false} ignore unknown object types
+ * - `replacer` optional function that replaces values before hashing
+ * - `respectFunctionProperties` {*true|false} consider function properties when hashing
+ * - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing
+ * - `respectType` {*true|false} Respect special properties (prototype, constructor)
+ * when hashing to distinguish between types
+ * - `unorderedArrays` {true|*false} Sort all arrays before hashing
+ * - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing
+ * * = default
+ *
+ * @param {object} object value to hash
+ * @param {object} options hashing options
+ * @return {string} hash value
+ * @api public
+ */
+exports = module.exports = objectHash;
+
+function objectHash(object, options){
+ options = applyDefaults(object, options);
+
+ return hash(object, options);
+}
+
+/**
+ * Exported sugar methods
+ *
+ * @param {object} object value to hash
+ * @return {string} hash value
+ * @api public
+ */
+exports.sha1 = function(object){
+ return objectHash(object);
+};
+exports.keys = function(object){
+ return objectHash(object, {excludeValues: true, algorithm: 'sha1', encoding: 'hex'});
+};
+exports.MD5 = function(object){
+ return objectHash(object, {algorithm: 'md5', encoding: 'hex'});
+};
+exports.keysMD5 = function(object){
+ return objectHash(object, {algorithm: 'md5', encoding: 'hex', excludeValues: true});
+};
+
+// Internals
+var hashes = crypto.getHashes ? crypto.getHashes().slice() : ['sha1', 'md5'];
+hashes.push('passthrough');
+var encodings = ['buffer', 'hex', 'binary', 'base64'];
+
+function applyDefaults(object, sourceOptions){
+ sourceOptions = sourceOptions || {};
+
+ // create a copy rather than mutating
+ var options = {};
+ options.algorithm = sourceOptions.algorithm || 'sha1';
+ options.encoding = sourceOptions.encoding || 'hex';
+ options.excludeValues = sourceOptions.excludeValues ? true : false;
+ options.algorithm = options.algorithm.toLowerCase();
+ options.encoding = options.encoding.toLowerCase();
+ options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false
+ options.respectType = sourceOptions.respectType === false ? false : true; // default to true
+ options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+ options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+ options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false
+ options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false
+ options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true
+ options.replacer = sourceOptions.replacer || undefined;
+ options.excludeKeys = sourceOptions.excludeKeys || undefined;
+
+ if(typeof object === 'undefined') {
+ throw new Error('Object argument required.');
+ }
+
+ // if there is a case-insensitive match in the hashes list, accept it
+ // (i.e. SHA256 for sha256)
+ for (var i = 0; i < hashes.length; ++i) {
+ if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
+ options.algorithm = hashes[i];
+ }
+ }
+
+ if(hashes.indexOf(options.algorithm) === -1){
+ throw new Error('Algorithm "' + options.algorithm + '" not supported. ' +
+ 'supported values: ' + hashes.join(', '));
+ }
+
+ if(encodings.indexOf(options.encoding) === -1 &&
+ options.algorithm !== 'passthrough'){
+ throw new Error('Encoding "' + options.encoding + '" not supported. ' +
+ 'supported values: ' + encodings.join(', '));
+ }
+
+ return options;
+}
+
+/** Check if the given function is a native function */
+function isNativeFunction(f) {
+ if ((typeof f) !== 'function') {
+ return false;
+ }
+ var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+ return exp.exec(Function.prototype.toString.call(f)) != null;
+}
+
+function hash(object, options) {
+ var hashingStream;
+
+ if (options.algorithm !== 'passthrough') {
+ hashingStream = crypto.createHash(options.algorithm);
+ } else {
+ hashingStream = new PassThrough();
+ }
+
+ if (typeof hashingStream.write === 'undefined') {
+ hashingStream.write = hashingStream.update;
+ hashingStream.end = hashingStream.update;
+ }
+
+ var hasher = typeHasher(options, hashingStream);
+ hasher.dispatch(object);
+ if (!hashingStream.update) {
+ hashingStream.end('');
+ }
+
+ if (hashingStream.digest) {
+ return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding);
+ }
+
+ var buf = hashingStream.read();
+ if (options.encoding === 'buffer') {
+ return buf;
+ }
+
+ return buf.toString(options.encoding);
+}
+
+/**
+ * Expose streaming API
+ *
+ * @param {object} object Value to serialize
+ * @param {object} options Options, as for hash()
+ * @param {object} stream A stream to write the serializiation to
+ * @api public
+ */
+exports.writeToStream = function(object, options, stream) {
+ if (typeof stream === 'undefined') {
+ stream = options;
+ options = {};
+ }
+
+ options = applyDefaults(object, options);
+
+ return typeHasher(options, stream).dispatch(object);
+};
+
+function typeHasher(options, writeTo, context){
+ context = context || [];
+ var write = function(str) {
+ if (writeTo.update) {
+ return writeTo.update(str, 'utf8');
+ } else {
+ return writeTo.write(str, 'utf8');
+ }
+ };
+
+ return {
+ dispatch: function(value){
+ if (options.replacer) {
+ value = options.replacer(value);
+ }
+
+ var type = typeof value;
+ if (value === null) {
+ type = 'null';
+ }
+
+ //console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type);
+
+ return this['_' + type](value);
+ },
+ _object: function(object) {
+ var pattern = (/\[object (.*)\]/i);
+ var objString = Object.prototype.toString.call(object);
+ var objType = pattern.exec(objString);
+ if (!objType) { // object type did not match [object ...]
+ objType = 'unknown:[' + objString + ']';
+ } else {
+ objType = objType[1]; // take only the class name
+ }
+
+ objType = objType.toLowerCase();
+
+ var objectNumber = null;
+
+ if ((objectNumber = context.indexOf(object)) >= 0) {
+ return this.dispatch('[CIRCULAR:' + objectNumber + ']');
+ } else {
+ context.push(object);
+ }
+
+ if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) {
+ write('buffer:');
+ return write(object);
+ }
+
+ if(objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') {
+ if(this['_' + objType]) {
+ this['_' + objType](object);
+ } else if (options.ignoreUnknown) {
+ return write('[' + objType + ']');
+ } else {
+ throw new Error('Unknown object type "' + objType + '"');
+ }
+ }else{
+ var keys = Object.keys(object);
+ if (options.unorderedObjects) {
+ keys = keys.sort();
+ }
+ // Make sure to incorporate special properties, so
+ // Types with different prototypes will produce
+ // a different hash and objects derived from
+ // different functions (`new Foo`, `new Bar`) will
+ // produce different hashes.
+ // We never do this for native functions since some
+ // seem to break because of that.
+ if (options.respectType !== false && !isNativeFunction(object)) {
+ keys.splice(0, 0, 'prototype', '__proto__', 'constructor');
+ }
+
+ if (options.excludeKeys) {
+ keys = keys.filter(function(key) { return !options.excludeKeys(key); });
+ }
+
+ write('object:' + keys.length + ':');
+ var self = this;
+ return keys.forEach(function(key){
+ self.dispatch(key);
+ write(':');
+ if(!options.excludeValues) {
+ self.dispatch(object[key]);
+ }
+ write(',');
+ });
+ }
+ },
+ _array: function(arr, unordered){
+ unordered = typeof unordered !== 'undefined' ? unordered :
+ options.unorderedArrays !== false; // default to options.unorderedArrays
+
+ var self = this;
+ write('array:' + arr.length + ':');
+ if (!unordered || arr.length <= 1) {
+ return arr.forEach(function(entry) {
+ return self.dispatch(entry);
+ });
+ }
+
+ // the unordered case is a little more complicated:
+ // since there is no canonical ordering on objects,
+ // i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false,
+ // we first serialize each entry using a PassThrough stream
+ // before sorting.
+ // also: we can’t use the same context array for all entries
+ // since the order of hashing should *not* matter. instead,
+ // we keep track of the additions to a copy of the context array
+ // and add all of them to the global context array when we’re done
+ var contextAdditions = [];
+ var entries = arr.map(function(entry) {
+ var strm = new PassThrough();
+ var localContext = context.slice(); // make copy
+ var hasher = typeHasher(options, strm, localContext);
+ hasher.dispatch(entry);
+ // take only what was added to localContext and append it to contextAdditions
+ contextAdditions = contextAdditions.concat(localContext.slice(context.length));
+ return strm.read().toString();
+ });
+ context = context.concat(contextAdditions);
+ entries.sort();
+ return this._array(entries, false);
+ },
+ _date: function(date){
+ return write('date:' + date.toJSON());
+ },
+ _symbol: function(sym){
+ return write('symbol:' + sym.toString());
+ },
+ _error: function(err){
+ return write('error:' + err.toString());
+ },
+ _boolean: function(bool){
+ return write('bool:' + bool.toString());
+ },
+ _string: function(string){
+ write('string:' + string.length + ':');
+ write(string.toString());
+ },
+ _function: function(fn){
+ write('fn:');
+ if (isNativeFunction(fn)) {
+ this.dispatch('[native]');
+ } else {
+ this.dispatch(fn.toString());
+ }
+
+ if (options.respectFunctionNames !== false) {
+ // Make sure we can still distinguish native functions
+ // by their name, otherwise String and Function will
+ // have the same hash
+ this.dispatch("function-name:" + String(fn.name));
+ }
+
+ if (options.respectFunctionProperties) {
+ this._object(fn);
+ }
+ },
+ _number: function(number){
+ return write('number:' + number.toString());
+ },
+ _xml: function(xml){
+ return write('xml:' + xml.toString());
+ },
+ _null: function() {
+ return write('Null');
+ },
+ _undefined: function() {
+ return write('Undefined');
+ },
+ _regexp: function(regex){
+ return write('regex:' + regex.toString());
+ },
+ _uint8array: function(arr){
+ write('uint8array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint8clampedarray: function(arr){
+ write('uint8clampedarray:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int8array: function(arr){
+ write('int8array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint16array: function(arr){
+ write('uint16array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int16array: function(arr){
+ write('int16array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint32array: function(arr){
+ write('uint32array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int32array: function(arr){
+ write('int32array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _float32array: function(arr){
+ write('float32array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _float64array: function(arr){
+ write('float64array:');
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _arraybuffer: function(arr){
+ write('arraybuffer:');
+ return this.dispatch(new Uint8Array(arr));
+ },
+ _url: function(url) {
+ return write('url:' + url.toString(), 'utf8');
+ },
+ _map: function(map) {
+ write('map:');
+ var arr = Array.from(map);
+ return this._array(arr, options.unorderedSets !== false);
+ },
+ _set: function(set) {
+ write('set:');
+ var arr = Array.from(set);
+ return this._array(arr, options.unorderedSets !== false);
+ },
+ _file: function(file) {
+ write('file:');
+ return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+ },
+ _blob: function() {
+ if (options.ignoreUnknown) {
+ return write('[blob]');
+ }
+
+ throw Error('Hashing Blob objects is currently not supported\n' +
+ '(see https://github.com/puleos/object-hash/issues/26)\n' +
+ 'Use "options.replacer" or "options.ignoreUnknown"\n');
+ },
+ _domwindow: function() { return write('domwindow'); },
+ _bigint: function(number){
+ return write('bigint:' + number.toString());
+ },
+ /* Node.js standard native objects */
+ _process: function() { return write('process'); },
+ _timer: function() { return write('timer'); },
+ _pipe: function() { return write('pipe'); },
+ _tcp: function() { return write('tcp'); },
+ _udp: function() { return write('udp'); },
+ _tty: function() { return write('tty'); },
+ _statwatcher: function() { return write('statwatcher'); },
+ _securecontext: function() { return write('securecontext'); },
+ _connection: function() { return write('connection'); },
+ _zlib: function() { return write('zlib'); },
+ _context: function() { return write('context'); },
+ _nodescript: function() { return write('nodescript'); },
+ _httpparser: function() { return write('httpparser'); },
+ _dataview: function() { return write('dataview'); },
+ _signal: function() { return write('signal'); },
+ _fsevent: function() { return write('fsevent'); },
+ _tlswrap: function() { return write('tlswrap'); },
+ };
+}
+
+// Mini-implementation of stream.PassThrough
+// We are far from having need for the full implementation, and we can
+// make assumptions like "many writes, then only one final read"
+// and we can ignore encoding specifics
+function PassThrough() {
+ return {
+ buf: '',
+
+ write: function(b) {
+ this.buf += b;
+ },
+
+ end: function(b) {
+ this.buf += b;
+ },
+
+ read: function() {
+ return this.buf;
+ }
+ };
+}
diff --git a/node_modules/object-hash/package.json b/node_modules/object-hash/package.json
new file mode 100644
index 0000000..a72557f
--- /dev/null
+++ b/node_modules/object-hash/package.json
@@ -0,0 +1,53 @@
+{
+ "name": "object-hash",
+ "version": "3.0.0",
+ "description": "Generate hashes from javascript objects in node and the browser.",
+ "homepage": "https://github.com/puleos/object-hash",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/puleos/object-hash"
+ },
+ "keywords": [
+ "object",
+ "hash",
+ "sha1",
+ "md5"
+ ],
+ "bugs": {
+ "url": "https://github.com/puleos/object-hash/issues"
+ },
+ "scripts": {
+ "test": "node ./node_modules/.bin/mocha test",
+ "prepublish": "gulp dist"
+ },
+ "author": "Scott Puleo ",
+ "files": [
+ "index.js",
+ "dist/object_hash.js"
+ ],
+ "license": "MIT",
+ "devDependencies": {
+ "browserify": "^16.2.3",
+ "gulp": "^4.0.0",
+ "gulp-browserify": "^0.5.1",
+ "gulp-coveralls": "^0.1.4",
+ "gulp-exec": "^3.0.1",
+ "gulp-istanbul": "^1.1.3",
+ "gulp-jshint": "^2.0.0",
+ "gulp-mocha": "^5.0.0",
+ "gulp-rename": "^1.2.0",
+ "gulp-replace": "^1.0.0",
+ "gulp-uglify": "^3.0.0",
+ "jshint": "^2.8.0",
+ "jshint-stylish": "^2.1.0",
+ "karma": "^4.2.0",
+ "karma-chrome-launcher": "^2.2.0",
+ "karma-mocha": "^1.3.0",
+ "mocha": "^6.2.0"
+ },
+ "engines": {
+ "node": ">= 6"
+ },
+ "main": "./index.js",
+ "browser": "./dist/object_hash.js"
+}
diff --git a/node_modules/object-hash/readme.markdown b/node_modules/object-hash/readme.markdown
new file mode 100644
index 0000000..c507cf8
--- /dev/null
+++ b/node_modules/object-hash/readme.markdown
@@ -0,0 +1,198 @@
+# object-hash
+
+Generate hashes from objects and values in node and the browser. Uses node.js
+crypto module for hashing. Supports SHA1 and many others (depending on the platform)
+as well as custom streams (e.g. CRC32).
+
+[](https://www.npmjs.com/package/object-hash)
+
+[](https://secure.travis-ci.org/puleos/object-hash?branch=master)
+[](https://coveralls.io/github/puleos/object-hash?branch=master)
+
+* Hash values of any type.
+* Supports a keys only option for grouping similar objects with different values.
+
+```js
+var hash = require('object-hash');
+
+hash({foo: 'bar'}) // => '67b69634f9880a282c14a0f0cb7ba20cf5d677e9'
+hash([1, 2, 2.718, 3.14159]) // => '136b9b88375971dff9f1af09d7356e3e04281951'
+```
+
+## Versioning Disclaimer
+
+Starting with version `1.1.8` (released April 2017), new versions will consider
+the exact returned hash part of the API contract, i.e. changes that will affect
+hash values will be considered `semver-major`. Previous versions may violate
+that expectation.
+
+For more information, see [this discussion](https://github.com/puleos/object-hash/issues/30).
+
+## hash(value, options)
+
+Generate a hash from any object or type. Defaults to sha1 with hex encoding.
+
+* `algorithm` hash algo to be used: 'sha1', 'md5', 'passthrough'. default: sha1
+ * This supports the algorithms returned by `crypto.getHashes()`. Note that the default of SHA-1 is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
+ * This also supports the `passthrough` algorith, which will return the information that would otherwise have been hashed.
+* `excludeValues` {true|false} hash object keys, values ignored. default: false
+* `encoding` hash encoding, supports 'buffer', 'hex', 'binary', 'base64'. default: hex
+* `ignoreUnknown` {true|*false} ignore unknown object types. default: false
+* `replacer` optional function that replaces values before hashing. default: accept all values
+* `respectFunctionProperties` {true|false} Whether properties on functions are considered when hashing. default: true
+* `respectFunctionNames` {true|false} consider `name` property of functions for hashing. default: true
+* `respectType` {true|false} Whether special type attributes (`.prototype`, `.__proto__`, `.constructor`)
+ are hashed. default: true
+* `unorderedArrays` {true|false} Sort all arrays before hashing. Note that this affects *all* collections,
+ i.e. including typed arrays, Sets, Maps, etc. default: false
+* `unorderedSets` {true|false} Sort `Set` and `Map` instances before hashing, i.e. make
+ `hash(new Set([1, 2])) == hash(new Set([2, 1]))` return `true`. default: true
+* `unorderedObjects` {true|false} Sort objects before hashing, i.e. make `hash({ x: 1, y: 2 }) === hash({ y: 2, x: 1 })`. default: true
+* `excludeKeys` optional function for excluding specific key(s) from hashing, if true is returned then exclude from hash. default: include all keys
+
+## hash.sha1(value)
+
+Hash using the sha1 algorithm.
+
+Note that SHA-1 is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
+
+*Sugar method, equivalent to* `hash(value, {algorithm: 'sha1'})`
+
+## hash.keys(value)
+
+Hash object keys using the sha1 algorithm, values ignored.
+
+*Sugar method, equivalent to* `hash(value, {excludeValues: true})`
+
+## hash.MD5(value)
+
+Hash using the md5 algorithm.
+
+Note that the MD5 algorithm is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
+
+*Sugar method, equivalent to* `hash(value, {algorithm: 'md5'})`
+
+## hash.keysMD5(value)
+
+Hash object keys using the md5 algorithm, values ignored.
+
+Note that the MD5 algorithm is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
+
+*Sugar method, equivalent to* `hash(value, {algorithm: 'md5', excludeValues: true})`
+
+## hash.writeToStream(value, [options,] stream)
+
+Write the information that would otherwise have been hashed to a stream, e.g.:
+
+```js
+hash.writeToStream({foo: 'bar', a: 42}, {respectType: false}, process.stdout)
+// => e.g. 'object:a:number:42foo:string:bar'
+```
+
+## Installation
+
+node:
+
+```js
+npm install object-hash
+```
+
+browser: */dist/object_hash.js*
+
+```html
+
+
+
+```
+
+## Example usage
+
+```js
+var hash = require('object-hash');
+
+var peter = { name: 'Peter', stapler: false, friends: ['Joanna', 'Michael', 'Samir'] };
+var michael = { name: 'Michael', stapler: false, friends: ['Peter', 'Samir'] };
+var bob = { name: 'Bob', stapler: true, friends: [] };
+
+/***
+ * sha1 hex encoding (default)
+ */
+hash(peter);
+// 14fa461bf4b98155e82adc86532938553b4d33a9
+hash(michael);
+// 4b2b30e27699979ce46714253bc2213010db039c
+hash(bob);
+// 38d96106bc8ef3d8bd369b99bb6972702c9826d5
+
+/***
+ * hash object keys, values ignored
+ */
+hash(peter, { excludeValues: true });
+// 48f370a772c7496f6c9d2e6d92e920c87dd00a5c
+hash(michael, { excludeValues: true });
+// 48f370a772c7496f6c9d2e6d92e920c87dd00a5c
+hash.keys(bob);
+// 48f370a772c7496f6c9d2e6d92e920c87dd00a5c
+
+/***
+ * hash object, ignore specific key(s)
+ */
+hash(peter, { excludeKeys: function(key) {
+ if ( key === 'friends') {
+ return true;
+ }
+ return false;
+ }
+});
+// 66b7d7e64871aa9fda1bdc8e88a28df797648d80
+
+/***
+ * md5 base64 encoding
+ */
+hash(peter, { algorithm: 'md5', encoding: 'base64' });
+// 6rkWaaDiG3NynWw4svGH7g==
+hash(michael, { algorithm: 'md5', encoding: 'base64' });
+// djXaWpuWVJeOF8Sb6SFFNg==
+hash(bob, { algorithm: 'md5', encoding: 'base64' });
+// lFzkw/IJ8/12jZI0rQeS3w==
+```
+
+## Legacy Browser Support
+
+IE <= 8 and Opera <= 11 support dropped in version 0.3.0. If you require
+legacy browser support you must either use an ES5 shim or use version 0.2.5
+of this module.
+
+## Development
+
+```sh-session
+git clone https://github.com/puleos/object-hash
+```
+
+## Node Docker Wrapper
+
+If you want to stand this up in a docker container, you should take at look
+at the [](https://github.com/bean5/node-object-hash) project.
+
+### gulp tasks
+
+* `gulp watch` (default) watch files, test and lint on change/add
+* `gulp test` unit tests
+* `gulp karma` browser unit tests
+* `gulp lint` jshint
+* `gulp dist` create browser version in /dist
+
+## License
+
+MIT
+
+## Changelog
+
+### v2.0.0
+
+Only Node.js versions `>= 6.0.0` are being tested in CI now.
+No other breaking changes were introduced.
diff --git a/node_modules/package-json-from-dist/LICENSE.md b/node_modules/package-json-from-dist/LICENSE.md
new file mode 100644
index 0000000..881248b
--- /dev/null
+++ b/node_modules/package-json-from-dist/LICENSE.md
@@ -0,0 +1,63 @@
+All packages under `src/` are licensed according to the terms in
+their respective `LICENSE` or `LICENSE.md` files.
+
+The remainder of this project is licensed under the Blue Oak
+Model License, as follows:
+
+-----
+
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules. The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice. If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+***As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim.***
diff --git a/node_modules/package-json-from-dist/README.md b/node_modules/package-json-from-dist/README.md
new file mode 100644
index 0000000..a9e1344
--- /dev/null
+++ b/node_modules/package-json-from-dist/README.md
@@ -0,0 +1,110 @@
+# package-json-from-dist
+
+Sometimes you want to load the `package.json` into your
+TypeScript program, and it's tempting to just `import
+'../package.json'`, since that seems to work.
+
+However, this requires `tsc` to make an entire copy of your
+`package.json` file into the `dist` folder, which is a problem if
+you're using something like
+[tshy](https://github.com/isaacs/tshy), which uses the
+`package.json` file in dist for another purpose. Even when that
+does work, it's asking the module system to do a bunch of extra
+fs system calls, just to load a version number or something. (See
+[this issue](https://github.com/isaacs/tshy/issues/61).)
+
+This module helps by just finding the package.json file
+appropriately, and reading and parsing it in the most normal
+fashion.
+
+## Caveats
+
+This _only_ works if your code builds into a target folder called
+`dist`, which is in the root of the package. It also requires
+that you do not have a folder named `node_modules` anywhere
+within your dev environment, or else it'll get the wrong answers
+there. (But, at least, that'll be in dev, so you're pretty likely
+to notice.)
+
+If you build to some other location, then you'll need a different
+approach. (Feel free to fork this module and make it your own, or
+just put the code right inline, there's not much of it.)
+
+## USAGE
+
+```js
+// src/index.ts
+import {
+ findPackageJson,
+ loadPackageJson,
+} from 'package-json-from-dist'
+
+const pj = findPackageJson(import.meta.url)
+console.log(`package.json found at ${pj}`)
+
+const pkg = loadPackageJson(import.meta.url)
+console.log(`Hello from ${pkg.name}@${pkg.version}`)
+```
+
+If your module is not directly in the `./src` folder, then you need
+to specify the path that you would expect to find the
+`package.json` when it's _not_ built to the `dist` folder.
+
+```js
+// src/components/something.ts
+import {
+ findPackageJson,
+ loadPackageJson,
+} from 'package-json-from-dist'
+
+const pj = findPackageJson(import.meta.url, '../../package.json')
+console.log(`package.json found at ${pj}`)
+
+const pkg = loadPackageJson(import.meta.url, '../../package.json')
+console.log(`Hello from ${pkg.name}@${pkg.version}`)
+```
+
+When running from CommmonJS, use `__filename` instead of
+`import.meta.url`.
+
+```js
+// src/index.cts
+import {
+ findPackageJson,
+ loadPackageJson,
+} from 'package-json-from-dist'
+
+const pj = findPackageJson(__filename)
+console.log(`package.json found at ${pj}`)
+
+const pkg = loadPackageJson(__filename)
+console.log(`Hello from ${pkg.name}@${pkg.version}`)
+```
+
+Since [tshy](https://github.com/isaacs/tshy) builds _both_
+CommonJS and ESM by default, you may find that you need a
+CommonJS override and some `//@ts-ignore` magic to make it work.
+
+`src/pkg.ts`:
+
+```js
+import {
+ findPackageJson,
+ loadPackageJson,
+} from 'package-json-from-dist'
+//@ts-ignore
+export const pkg = loadPackageJson(import.meta.url)
+//@ts-ignore
+export const pj = findPackageJson(import.meta.url)
+```
+
+`src/pkg-cjs.cts`:
+
+```js
+import {
+ findPackageJson,
+ loadPackageJson,
+} from 'package-json-from-dist'
+export const pkg = loadPackageJson(__filename)
+export const pj = findPackageJson(__filename)
+```
diff --git a/node_modules/package-json-from-dist/package.json b/node_modules/package-json-from-dist/package.json
new file mode 100644
index 0000000..a2d03c3
--- /dev/null
+++ b/node_modules/package-json-from-dist/package.json
@@ -0,0 +1,68 @@
+{
+ "name": "package-json-from-dist",
+ "version": "1.0.1",
+ "description": "Load the local package.json from either src or dist folder",
+ "main": "./dist/commonjs/index.js",
+ "exports": {
+ "./package.json": "./package.json",
+ ".": {
+ "import": {
+ "types": "./dist/esm/index.d.ts",
+ "default": "./dist/esm/index.js"
+ },
+ "require": {
+ "types": "./dist/commonjs/index.d.ts",
+ "default": "./dist/commonjs/index.js"
+ }
+ }
+ },
+ "files": [
+ "dist"
+ ],
+ "scripts": {
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "prepublishOnly": "git push origin --follow-tags",
+ "prepare": "tshy",
+ "pretest": "npm run prepare",
+ "presnap": "npm run prepare",
+ "test": "tap",
+ "snap": "tap",
+ "format": "prettier --write . --log-level warn",
+ "typedoc": "typedoc"
+ },
+ "author": "Isaac Z. Schlueter (https://izs.me)",
+ "license": "BlueOak-1.0.0",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/package-json-from-dist.git"
+ },
+ "devDependencies": {
+ "@types/node": "^20.12.12",
+ "prettier": "^3.2.5",
+ "tap": "^18.5.3",
+ "typedoc": "^0.24.8",
+ "typescript": "^5.1.6",
+ "tshy": "^1.14.0"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 70,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf",
+ "experimentalTernaries": true
+ },
+ "tshy": {
+ "exports": {
+ "./package.json": "./package.json",
+ ".": "./src/index.ts"
+ }
+ },
+ "types": "./dist/commonjs/index.d.ts",
+ "type": "module"
+}
diff --git a/node_modules/path-key/index.d.ts b/node_modules/path-key/index.d.ts
new file mode 100644
index 0000000..7c575d1
--- /dev/null
+++ b/node_modules/path-key/index.d.ts
@@ -0,0 +1,40 @@
+///
+
+declare namespace pathKey {
+ interface Options {
+ /**
+ Use a custom environment variables object. Default: [`process.env`](https://nodejs.org/api/process.html#process_process_env).
+ */
+ readonly env?: {[key: string]: string | undefined};
+
+ /**
+ Get the PATH key for a specific platform. Default: [`process.platform`](https://nodejs.org/api/process.html#process_process_platform).
+ */
+ readonly platform?: NodeJS.Platform;
+ }
+}
+
+declare const pathKey: {
+ /**
+ Get the [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) environment variable key cross-platform.
+
+ @example
+ ```
+ import pathKey = require('path-key');
+
+ const key = pathKey();
+ //=> 'PATH'
+
+ const PATH = process.env[key];
+ //=> '/usr/local/bin:/usr/bin:/bin'
+ ```
+ */
+ (options?: pathKey.Options): string;
+
+ // TODO: Remove this for the next major release, refactor the whole definition to:
+ // declare function pathKey(options?: pathKey.Options): string;
+ // export = pathKey;
+ default: typeof pathKey;
+};
+
+export = pathKey;
diff --git a/node_modules/path-key/index.js b/node_modules/path-key/index.js
new file mode 100644
index 0000000..0cf6415
--- /dev/null
+++ b/node_modules/path-key/index.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const pathKey = (options = {}) => {
+ const environment = options.env || process.env;
+ const platform = options.platform || process.platform;
+
+ if (platform !== 'win32') {
+ return 'PATH';
+ }
+
+ return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
+};
+
+module.exports = pathKey;
+// TODO: Remove this for the next major release
+module.exports.default = pathKey;
diff --git a/node_modules/path-key/license b/node_modules/path-key/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/path-key/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+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/path-key/package.json b/node_modules/path-key/package.json
new file mode 100644
index 0000000..c8cbd38
--- /dev/null
+++ b/node_modules/path-key/package.json
@@ -0,0 +1,39 @@
+{
+ "name": "path-key",
+ "version": "3.1.1",
+ "description": "Get the PATH environment variable key cross-platform",
+ "license": "MIT",
+ "repository": "sindresorhus/path-key",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "keywords": [
+ "path",
+ "key",
+ "environment",
+ "env",
+ "variable",
+ "var",
+ "get",
+ "cross-platform",
+ "windows"
+ ],
+ "devDependencies": {
+ "@types/node": "^11.13.0",
+ "ava": "^1.4.1",
+ "tsd": "^0.7.2",
+ "xo": "^0.24.0"
+ }
+}
diff --git a/node_modules/path-key/readme.md b/node_modules/path-key/readme.md
new file mode 100644
index 0000000..a9052d7
--- /dev/null
+++ b/node_modules/path-key/readme.md
@@ -0,0 +1,61 @@
+# path-key [](https://travis-ci.org/sindresorhus/path-key)
+
+> Get the [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) environment variable key cross-platform
+
+It's usually `PATH`, but on Windows it can be any casing like `Path`...
+
+
+## Install
+
+```
+$ npm install path-key
+```
+
+
+## Usage
+
+```js
+const pathKey = require('path-key');
+
+const key = pathKey();
+//=> 'PATH'
+
+const PATH = process.env[key];
+//=> '/usr/local/bin:/usr/bin:/bin'
+```
+
+
+## API
+
+### pathKey(options?)
+
+#### options
+
+Type: `object`
+
+##### env
+
+Type: `object`
+Default: [`process.env`](https://nodejs.org/api/process.html#process_process_env)
+
+Use a custom environment variables object.
+
+#### platform
+
+Type: `string`
+Default: [`process.platform`](https://nodejs.org/api/process.html#process_process_platform)
+
+Get the PATH key for a specific platform.
+
+
+---
+
+
diff --git a/node_modules/path-parse/LICENSE b/node_modules/path-parse/LICENSE
new file mode 100644
index 0000000..810f3db
--- /dev/null
+++ b/node_modules/path-parse/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Javier Blanco
+
+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/path-parse/README.md b/node_modules/path-parse/README.md
new file mode 100644
index 0000000..05097f8
--- /dev/null
+++ b/node_modules/path-parse/README.md
@@ -0,0 +1,42 @@
+# path-parse [](https://travis-ci.org/jbgutierrez/path-parse)
+
+> Node.js [`path.parse(pathString)`](https://nodejs.org/api/path.html#path_path_parse_pathstring) [ponyfill](https://ponyfill.com).
+
+## Install
+
+```
+$ npm install --save path-parse
+```
+
+## Usage
+
+```js
+var pathParse = require('path-parse');
+
+pathParse('/home/user/dir/file.txt');
+//=> {
+// root : "/",
+// dir : "/home/user/dir",
+// base : "file.txt",
+// ext : ".txt",
+// name : "file"
+// }
+```
+
+## API
+
+See [`path.parse(pathString)`](https://nodejs.org/api/path.html#path_path_parse_pathstring) docs.
+
+### pathParse(path)
+
+### pathParse.posix(path)
+
+The Posix specific version.
+
+### pathParse.win32(path)
+
+The Windows specific version.
+
+## License
+
+MIT © [Javier Blanco](http://jbgutierrez.info)
diff --git a/node_modules/path-parse/index.js b/node_modules/path-parse/index.js
new file mode 100644
index 0000000..f062d0a
--- /dev/null
+++ b/node_modules/path-parse/index.js
@@ -0,0 +1,75 @@
+'use strict';
+
+var isWindows = process.platform === 'win32';
+
+// Regex to split a windows path into into [dir, root, basename, name, ext]
+var splitWindowsRe =
+ /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+
+var win32 = {};
+
+function win32SplitPath(filename) {
+ return splitWindowsRe.exec(filename).slice(1);
+}
+
+win32.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = win32SplitPath(pathString);
+ if (!allParts || allParts.length !== 5) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+ return {
+ root: allParts[1],
+ dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[4],
+ name: allParts[3]
+ };
+};
+
+
+
+// Split a filename into [dir, root, basename, name, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+ /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+var posix = {};
+
+
+function posixSplitPath(filename) {
+ return splitPathRe.exec(filename).slice(1);
+}
+
+
+posix.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = posixSplitPath(pathString);
+ if (!allParts || allParts.length !== 5) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+
+ return {
+ root: allParts[1],
+ dir: allParts[0].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[4],
+ name: allParts[3],
+ };
+};
+
+
+if (isWindows)
+ module.exports = win32.parse;
+else /* posix */
+ module.exports = posix.parse;
+
+module.exports.posix = posix.parse;
+module.exports.win32 = win32.parse;
diff --git a/node_modules/path-parse/package.json b/node_modules/path-parse/package.json
new file mode 100644
index 0000000..36c23f8
--- /dev/null
+++ b/node_modules/path-parse/package.json
@@ -0,0 +1,33 @@
+{
+ "name": "path-parse",
+ "version": "1.0.7",
+ "description": "Node.js path.parse() ponyfill",
+ "main": "index.js",
+ "scripts": {
+ "test": "node test.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/jbgutierrez/path-parse.git"
+ },
+ "keywords": [
+ "path",
+ "paths",
+ "file",
+ "dir",
+ "parse",
+ "built-in",
+ "util",
+ "utils",
+ "core",
+ "ponyfill",
+ "polyfill",
+ "shim"
+ ],
+ "author": "Javier Blanco ",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/jbgutierrez/path-parse/issues"
+ },
+ "homepage": "https://github.com/jbgutierrez/path-parse#readme"
+}
diff --git a/node_modules/path-scurry/LICENSE.md b/node_modules/path-scurry/LICENSE.md
new file mode 100644
index 0000000..c5402b9
--- /dev/null
+++ b/node_modules/path-scurry/LICENSE.md
@@ -0,0 +1,55 @@
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules. The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice. If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+***As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim.***
diff --git a/node_modules/path-scurry/README.md b/node_modules/path-scurry/README.md
new file mode 100644
index 0000000..b5cb495
--- /dev/null
+++ b/node_modules/path-scurry/README.md
@@ -0,0 +1,636 @@
+# path-scurry
+
+Extremely high performant utility for building tools that read
+the file system, minimizing filesystem and path string munging
+operations to the greatest degree possible.
+
+## Ugh, yet another file traversal thing on npm?
+
+Yes. None of the existing ones gave me exactly what I wanted.
+
+## Well what is it you wanted?
+
+While working on [glob](http://npm.im/glob), I found that I
+needed a module to very efficiently manage the traversal over a
+folder tree, such that:
+
+1. No `readdir()` or `stat()` would ever be called on the same
+ file or directory more than one time.
+2. No `readdir()` calls would be made if we can be reasonably
+ sure that the path is not a directory. (Ie, a previous
+ `readdir()` or `stat()` covered the path, and
+ `ent.isDirectory()` is false.)
+3. `path.resolve()`, `dirname()`, `basename()`, and other
+ string-parsing/munging operations are be minimized. This means
+ it has to track "provisional" child nodes that may not exist
+ (and if we find that they _don't_ exist, store that
+ information as well, so we don't have to ever check again).
+4. The API is not limited to use as a stream/iterator/etc. There
+ are many cases where an API like node's `fs` is preferrable.
+5. It's more important to prevent excess syscalls than to be up
+ to date, but it should be smart enough to know what it
+ _doesn't_ know, and go get it seamlessly when requested.
+6. Do not blow up the JS heap allocation if operating on a
+ directory with a huge number of entries.
+7. Handle all the weird aspects of Windows paths, like UNC paths
+ and drive letters and wrongway slashes, so that the consumer
+ can return canonical platform-specific paths without having to
+ parse or join or do any error-prone string munging.
+
+## PERFORMANCE
+
+JavaScript people throw around the word "blazing" a lot. I hope
+that this module doesn't blaze anyone. But it does go very fast,
+in the cases it's optimized for, if used properly.
+
+PathScurry provides ample opportunities to get extremely good
+performance, as well as several options to trade performance for
+convenience.
+
+Benchmarks can be run by executing `npm run bench`.
+
+As is always the case, doing more means going slower, doing less
+means going faster, and there are trade offs between speed and
+memory usage.
+
+PathScurry makes heavy use of [LRUCache](http://npm.im/lru-cache)
+to efficiently cache whatever it can, and `Path` objects remain
+in the graph for the lifetime of the walker, so repeated calls
+with a single PathScurry object will be extremely fast. However,
+adding items to a cold cache means "doing more", so in those
+cases, we pay a price. Nothing is free, but every effort has been
+made to reduce costs wherever possible.
+
+Also, note that a "cache as long as possible" approach means that
+changes to the filesystem may not be reflected in the results of
+repeated PathScurry operations.
+
+For resolving string paths, `PathScurry` ranges from 5-50 times
+faster than `path.resolve` on repeated resolutions, but around
+100 to 1000 times _slower_ on the first resolution. If your
+program is spending a lot of time resolving the _same_ paths
+repeatedly (like, thousands or millions of times), then this can
+be beneficial. But both implementations are pretty fast, and
+speeding up an infrequent operation from 4µs to 400ns is not
+going to move the needle on your app's performance.
+
+For walking file system directory trees, a lot depends on how
+often a given PathScurry object will be used, and also on the
+walk method used.
+
+With default settings on a folder tree of 100,000 items,
+consisting of around a 10-to-1 ratio of normal files to
+directories, PathScurry performs comparably to
+[@nodelib/fs.walk](http://npm.im/@nodelib/fs.walk), which is the
+fastest and most reliable file system walker I could find. As far
+as I can tell, it's almost impossible to go much faster in a
+Node.js program, just based on how fast you can push syscalls out
+to the fs thread pool.
+
+On my machine, that is about 1000-1200 completed walks per second
+for async or stream walks, and around 500-600 walks per second
+synchronously.
+
+In the warm cache state, PathScurry's performance increases
+around 4x for async `for await` iteration, 10-15x faster for
+streams and synchronous `for of` iteration, and anywhere from 30x
+to 80x faster for the rest.
+
+```
+# walk 100,000 fs entries, 10/1 file/dir ratio
+# operations / ms
+ New PathScurry object | Reuse PathScurry object
+ stream: 1112.589 | 13974.917
+sync stream: 492.718 | 15028.343
+ async walk: 1095.648 | 32706.395
+ sync walk: 527.632 | 46129.772
+ async iter: 1288.821 | 5045.510
+ sync iter: 498.496 | 17920.746
+```
+
+A hand-rolled walk calling `entry.readdir()` and recursing
+through the entries can benefit even more from caching, with
+greater flexibility and without the overhead of streams or
+generators.
+
+The cold cache state is still limited by the costs of file system
+operations, but with a warm cache, the only bottleneck is CPU
+speed and VM optimizations. Of course, in that case, some care
+must be taken to ensure that you don't lose performance as a
+result of silly mistakes, like calling `readdir()` on entries
+that you know are not directories.
+
+```
+# manual recursive iteration functions
+ cold cache | warm cache
+async: 1164.901 | 17923.320
+ cb: 1101.127 | 40999.344
+zalgo: 1082.240 | 66689.936
+ sync: 526.935 | 87097.591
+```
+
+In this case, the speed improves by around 10-20x in the async
+case, 40x in the case of using `entry.readdirCB` with protections
+against synchronous callbacks, and 50-100x with callback
+deferrals disabled, and _several hundred times faster_ for
+synchronous iteration.
+
+If you can think of a case that is not covered in these
+benchmarks, or an implementation that performs significantly
+better than PathScurry, please [let me
+know](https://github.com/isaacs/path-scurry/issues).
+
+## USAGE
+
+```ts
+// hybrid module, load with either method
+import { PathScurry, Path } from 'path-scurry'
+// or:
+const { PathScurry, Path } = require('path-scurry')
+
+// very simple example, say we want to find and
+// delete all the .DS_Store files in a given path
+// note that the API is very similar to just a
+// naive walk with fs.readdir()
+import { unlink } from 'fs/promises'
+
+// easy way, iterate over the directory and do the thing
+const pw = new PathScurry(process.cwd())
+for await (const entry of pw) {
+ if (entry.isFile() && entry.name === '.DS_Store') {
+ unlink(entry.fullpath())
+ }
+}
+
+// here it is as a manual recursive method
+const walk = async (entry: Path) => {
+ const promises: Promise = []
+ // readdir doesn't throw on non-directories, it just doesn't
+ // return any entries, to save stack trace costs.
+ // Items are returned in arbitrary unsorted order
+ for (const child of await pw.readdir(entry)) {
+ // each child is a Path object
+ if (child.name === '.DS_Store' && child.isFile()) {
+ // could also do pw.resolve(entry, child.name),
+ // just like fs.readdir walking, but .fullpath is
+ // a *slightly* more efficient shorthand.
+ promises.push(unlink(child.fullpath()))
+ } else if (child.isDirectory()) {
+ promises.push(walk(child))
+ }
+ }
+ return Promise.all(promises)
+}
+
+walk(pw.cwd).then(() => {
+ console.log('all .DS_Store files removed')
+})
+
+const pw2 = new PathScurry('/a/b/c') // pw2.cwd is the Path for /a/b/c
+const relativeDir = pw2.cwd.resolve('../x') // Path entry for '/a/b/x'
+const relative2 = pw2.cwd.resolve('/a/b/d/../x') // same path, same entry
+assert.equal(relativeDir, relative2)
+```
+
+## API
+
+[Full TypeDoc API](https://isaacs.github.io/path-scurry)
+
+There are platform-specific classes exported, but for the most
+part, the default `PathScurry` and `Path` exports are what you
+most likely need, unless you are testing behavior for other
+platforms.
+
+Intended public API is documented here, but the full
+documentation does include internal types, which should not be
+accessed directly.
+
+### Interface `PathScurryOpts`
+
+The type of the `options` argument passed to the `PathScurry`
+constructor.
+
+- `nocase`: Boolean indicating that file names should be compared
+ case-insensitively. Defaults to `true` on darwin and win32
+ implementations, `false` elsewhere.
+
+ **Warning** Performing case-insensitive matching on a
+ case-sensitive filesystem will result in occasionally very
+ bizarre behavior. Performing case-sensitive matching on a
+ case-insensitive filesystem may negatively impact performance.
+
+- `childrenCacheSize`: Number of child entries to cache, in order
+ to speed up `resolve()` and `readdir()` calls. Defaults to
+ `16 * 1024` (ie, `16384`).
+
+ Setting it to a higher value will run the risk of JS heap
+ allocation errors on large directory trees. Setting it to `256`
+ or smaller will significantly reduce the construction time and
+ data consumption overhead, but with the downside of operations
+ being slower on large directory trees. Setting it to `0` will
+ mean that effectively no operations are cached, and this module
+ will be roughly the same speed as `fs` for file system
+ operations, and _much_ slower than `path.resolve()` for
+ repeated path resolution.
+
+- `fs` An object that will be used to override the default `fs`
+ methods. Any methods that are not overridden will use Node's
+ built-in implementations.
+
+ - lstatSync
+ - readdir (callback `withFileTypes` Dirent variant, used for
+ readdirCB and most walks)
+ - readdirSync
+ - readlinkSync
+ - realpathSync
+ - promises: Object containing the following async methods:
+ - lstat
+ - readdir (Dirent variant only)
+ - readlink
+ - realpath
+
+### Interface `WalkOptions`
+
+The options object that may be passed to all walk methods.
+
+- `withFileTypes`: Boolean, default true. Indicates that `Path`
+ objects should be returned. Set to `false` to get string paths
+ instead.
+- `follow`: Boolean, default false. Attempt to read directory
+ entries from symbolic links. Otherwise, only actual directories
+ are traversed. Regardless of this setting, a given target path
+ will only ever be walked once, meaning that a symbolic link to
+ a previously traversed directory will never be followed.
+
+ Setting this imposes a slight performance penalty, because
+ `readlink` must be called on all symbolic links encountered, in
+ order to avoid infinite cycles.
+
+- `filter`: Function `(entry: Path) => boolean`. If provided,
+ will prevent the inclusion of any entry for which it returns a
+ falsey value. This will not prevent directories from being
+ traversed if they do not pass the filter, though it will
+ prevent the directories themselves from being included in the
+ results. By default, if no filter is provided, then all entries
+ are included in the results.
+- `walkFilter`: Function `(entry: Path) => boolean`. If provided,
+ will prevent the traversal of any directory (or in the case of
+ `follow:true` symbolic links to directories) for which the
+ function returns false. This will not prevent the directories
+ themselves from being included in the result set. Use `filter`
+ for that.
+
+Note that TypeScript return types will only be inferred properly
+from static analysis if the `withFileTypes` option is omitted, or
+a constant `true` or `false` value.
+
+### Class `PathScurry`
+
+The main interface. Defaults to an appropriate class based on the
+current platform.
+
+Use `PathScurryWin32`, `PathScurryDarwin`, or `PathScurryPosix`
+if implementation-specific behavior is desired.
+
+All walk methods may be called with a `WalkOptions` argument to
+walk over the object's current working directory with the
+supplied options.
+
+#### `async pw.walk(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Walk the directory tree according to the options provided,
+resolving to an array of all entries found.
+
+#### `pw.walkSync(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Walk the directory tree according to the options provided,
+returning an array of all entries found.
+
+#### `pw.iterate(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Iterate over the directory asynchronously, for use with `for
+await of`. This is also the default async iterator method.
+
+#### `pw.iterateSync(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Iterate over the directory synchronously, for use with `for of`.
+This is also the default sync iterator method.
+
+#### `pw.stream(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Return a [Minipass](http://npm.im/minipass) stream that emits
+each entry or path string in the walk. Results are made available
+asynchronously.
+
+#### `pw.streamSync(entry?: string | Path | WalkOptions, opts?: WalkOptions)`
+
+Return a [Minipass](http://npm.im/minipass) stream that emits
+each entry or path string in the walk. Results are made available
+synchronously, meaning that the walk will complete in a single
+tick if the stream is fully consumed.
+
+#### `pw.cwd`
+
+Path object representing the current working directory for the
+PathScurry.
+
+#### `pw.chdir(path: string)`
+
+Set the new effective current working directory for the scurry
+object, so that `path.relative()` and `path.relativePosix()`
+return values relative to the new cwd path.
+
+#### `pw.depth(path?: Path | string): number`
+
+Return the depth of the specified path (or the PathScurry cwd)
+within the directory tree.
+
+Root entries have a depth of `0`.
+
+#### `pw.resolve(...paths: string[])`
+
+Caching `path.resolve()`.
+
+Significantly faster than `path.resolve()` if called repeatedly
+with the same paths. Significantly slower otherwise, as it builds
+out the cached Path entries.
+
+To get a `Path` object resolved from the `PathScurry`, use
+`pw.cwd.resolve(path)`. Note that `Path.resolve` only takes a
+single string argument, not multiple.
+
+#### `pw.resolvePosix(...paths: string[])`
+
+Caching `path.resolve()`, but always using posix style paths.
+
+This is identical to `pw.resolve(...paths)` on posix systems (ie,
+everywhere except Windows).
+
+On Windows, it returns the full absolute UNC path using `/`
+separators. Ie, instead of `'C:\\foo\\bar`, it would return
+`//?/C:/foo/bar`.
+
+#### `pw.relative(path: string | Path): string`
+
+Return the relative path from the PathWalker cwd to the supplied
+path string or entry.
+
+If the nearest common ancestor is the root, then an absolute path
+is returned.
+
+#### `pw.relativePosix(path: string | Path): string`
+
+Return the relative path from the PathWalker cwd to the supplied
+path string or entry, using `/` path separators.
+
+If the nearest common ancestor is the root, then an absolute path
+is returned.
+
+On posix platforms (ie, all platforms except Windows), this is
+identical to `pw.relative(path)`.
+
+On Windows systems, it returns the resulting string as a
+`/`-delimited path. If an absolute path is returned (because the
+target does not share a common ancestor with `pw.cwd`), then a
+full absolute UNC path will be returned. Ie, instead of
+`'C:\\foo\\bar`, it would return `//?/C:/foo/bar`.
+
+#### `pw.basename(path: string | Path): string`
+
+Return the basename of the provided string or Path.
+
+#### `pw.dirname(path: string | Path): string`
+
+Return the parent directory of the supplied string or Path.
+
+#### `async pw.readdir(dir = pw.cwd, opts = { withFileTypes: true })`
+
+Read the directory and resolve to an array of strings if
+`withFileTypes` is explicitly set to `false` or Path objects
+otherwise.
+
+Can be called as `pw.readdir({ withFileTypes: boolean })` as
+well.
+
+Returns `[]` if no entries are found, or if any error occurs.
+
+Note that TypeScript return types will only be inferred properly
+from static analysis if the `withFileTypes` option is omitted, or
+a constant `true` or `false` value.
+
+#### `pw.readdirSync(dir = pw.cwd, opts = { withFileTypes: true })`
+
+Synchronous `pw.readdir()`
+
+#### `async pw.readlink(link = pw.cwd, opts = { withFileTypes: false })`
+
+Call `fs.readlink` on the supplied string or Path object, and
+return the result.
+
+Can be called as `pw.readlink({ withFileTypes: boolean })` as
+well.
+
+Returns `undefined` if any error occurs (for example, if the
+argument is not a symbolic link), or a `Path` object if
+`withFileTypes` is explicitly set to `true`, or a string
+otherwise.
+
+Note that TypeScript return types will only be inferred properly
+from static analysis if the `withFileTypes` option is omitted, or
+a constant `true` or `false` value.
+
+#### `pw.readlinkSync(link = pw.cwd, opts = { withFileTypes: false })`
+
+Synchronous `pw.readlink()`
+
+#### `async pw.lstat(entry = pw.cwd)`
+
+Call `fs.lstat` on the supplied string or Path object, and fill
+in as much information as possible, returning the updated `Path`
+object.
+
+Returns `undefined` if the entry does not exist, or if any error
+is encountered.
+
+Note that some `Stats` data (such as `ino`, `dev`, and `mode`)
+will not be supplied. For those things, you'll need to call
+`fs.lstat` yourself.
+
+#### `pw.lstatSync(entry = pw.cwd)`
+
+Synchronous `pw.lstat()`
+
+#### `pw.realpath(entry = pw.cwd, opts = { withFileTypes: false })`
+
+Call `fs.realpath` on the supplied string or Path object, and
+return the realpath if available.
+
+Returns `undefined` if any error occurs.
+
+May be called as `pw.realpath({ withFileTypes: boolean })` to run
+on `pw.cwd`.
+
+#### `pw.realpathSync(entry = pw.cwd, opts = { withFileTypes: false })`
+
+Synchronous `pw.realpath()`
+
+### Class `Path` implements [fs.Dirent](https://nodejs.org/docs/latest/api/fs.html#class-fsdirent)
+
+Object representing a given path on the filesystem, which may or
+may not exist.
+
+Note that the actual class in use will be either `PathWin32` or
+`PathPosix`, depending on the implementation of `PathScurry` in
+use. They differ in the separators used to split and join path
+strings, and the handling of root paths.
+
+In `PathPosix` implementations, paths are split and joined using
+the `'/'` character, and `'/'` is the only root path ever in use.
+
+In `PathWin32` implementations, paths are split using either
+`'/'` or `'\\'` and joined using `'\\'`, and multiple roots may
+be in use based on the drives and UNC paths encountered. UNC
+paths such as `//?/C:/` that identify a drive letter, will be
+treated as an alias for the same root entry as their associated
+drive letter (in this case `'C:\\'`).
+
+#### `path.name`
+
+Name of this file system entry.
+
+**Important**: _always_ test the path name against any test
+string using the `isNamed` method, and not by directly comparing
+this string. Otherwise, unicode path strings that the system sees
+as identical will not be properly treated as the same path,
+leading to incorrect behavior and possible security issues.
+
+#### `path.isNamed(name: string): boolean`
+
+Return true if the path is a match for the given path name. This
+handles case sensitivity and unicode normalization.
+
+Note: even on case-sensitive systems, it is **not** safe to test
+the equality of the `.name` property to determine whether a given
+pathname matches, due to unicode normalization mismatches.
+
+Always use this method instead of testing the `path.name`
+property directly.
+
+#### `path.isCWD`
+
+Set to true if this `Path` object is the current working
+directory of the `PathScurry` collection that contains it.
+
+#### `path.getType()`
+
+Returns the type of the Path object, `'File'`, `'Directory'`,
+etc.
+
+#### `path.isType(t: type)`
+
+Returns true if `is{t}()` returns true.
+
+For example, `path.isType('Directory')` is equivalent to
+`path.isDirectory()`.
+
+#### `path.depth()`
+
+Return the depth of the Path entry within the directory tree.
+Root paths have a depth of `0`.
+
+#### `path.fullpath()`
+
+The fully resolved path to the entry.
+
+#### `path.fullpathPosix()`
+
+The fully resolved path to the entry, using `/` separators.
+
+On posix systems, this is identical to `path.fullpath()`. On
+windows, this will return a fully resolved absolute UNC path
+using `/` separators. Eg, instead of `'C:\\foo\\bar'`, it will
+return `'//?/C:/foo/bar'`.
+
+#### `path.isFile()`, `path.isDirectory()`, etc.
+
+Same as the identical `fs.Dirent.isX()` methods.
+
+#### `path.isUnknown()`
+
+Returns true if the path's type is unknown. Always returns true
+when the path is known to not exist.
+
+#### `path.resolve(p: string)`
+
+Return a `Path` object associated with the provided path string
+as resolved from the current Path object.
+
+#### `path.relative(): string`
+
+Return the relative path from the PathWalker cwd to the supplied
+path string or entry.
+
+If the nearest common ancestor is the root, then an absolute path
+is returned.
+
+#### `path.relativePosix(): string`
+
+Return the relative path from the PathWalker cwd to the supplied
+path string or entry, using `/` path separators.
+
+If the nearest common ancestor is the root, then an absolute path
+is returned.
+
+On posix platforms (ie, all platforms except Windows), this is
+identical to `pw.relative(path)`.
+
+On Windows systems, it returns the resulting string as a
+`/`-delimited path. If an absolute path is returned (because the
+target does not share a common ancestor with `pw.cwd`), then a
+full absolute UNC path will be returned. Ie, instead of
+`'C:\\foo\\bar`, it would return `//?/C:/foo/bar`.
+
+#### `async path.readdir()`
+
+Return an array of `Path` objects found by reading the associated
+path entry.
+
+If path is not a directory, or if any error occurs, returns `[]`,
+and marks all children as provisional and non-existent.
+
+#### `path.readdirSync()`
+
+Synchronous `path.readdir()`
+
+#### `async path.readlink()`
+
+Return the `Path` object referenced by the `path` as a symbolic
+link.
+
+If the `path` is not a symbolic link, or any error occurs,
+returns `undefined`.
+
+#### `path.readlinkSync()`
+
+Synchronous `path.readlink()`
+
+#### `async path.lstat()`
+
+Call `lstat` on the path object, and fill it in with details
+determined.
+
+If path does not exist, or any other error occurs, returns
+`undefined`, and marks the path as "unknown" type.
+
+#### `path.lstatSync()`
+
+Synchronous `path.lstat()`
+
+#### `async path.realpath()`
+
+Call `realpath` on the path, and return a Path object
+corresponding to the result, or `undefined` if any error occurs.
+
+#### `path.realpathSync()`
+
+Synchornous `path.realpath()`
diff --git a/node_modules/path-scurry/package.json b/node_modules/path-scurry/package.json
new file mode 100644
index 0000000..e176615
--- /dev/null
+++ b/node_modules/path-scurry/package.json
@@ -0,0 +1,89 @@
+{
+ "name": "path-scurry",
+ "version": "1.11.1",
+ "description": "walk paths fast and efficiently",
+ "author": "Isaac Z. Schlueter (https://blog.izs.me)",
+ "main": "./dist/commonjs/index.js",
+ "type": "module",
+ "exports": {
+ "./package.json": "./package.json",
+ ".": {
+ "import": {
+ "types": "./dist/esm/index.d.ts",
+ "default": "./dist/esm/index.js"
+ },
+ "require": {
+ "types": "./dist/commonjs/index.d.ts",
+ "default": "./dist/commonjs/index.js"
+ }
+ }
+ },
+ "files": [
+ "dist"
+ ],
+ "license": "BlueOak-1.0.0",
+ "scripts": {
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "prepublishOnly": "git push origin --follow-tags",
+ "prepare": "tshy",
+ "pretest": "npm run prepare",
+ "presnap": "npm run prepare",
+ "test": "tap",
+ "snap": "tap",
+ "format": "prettier --write . --loglevel warn",
+ "typedoc": "typedoc --tsconfig tsconfig-esm.json ./src/*.ts",
+ "bench": "bash ./scripts/bench.sh"
+ },
+ "prettier": {
+ "experimentalTernaries": true,
+ "semi": false,
+ "printWidth": 75,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ },
+ "devDependencies": {
+ "@nodelib/fs.walk": "^1.2.8",
+ "@types/node": "^20.12.11",
+ "c8": "^7.12.0",
+ "eslint-config-prettier": "^8.6.0",
+ "mkdirp": "^3.0.0",
+ "prettier": "^3.2.5",
+ "rimraf": "^5.0.1",
+ "tap": "^18.7.2",
+ "ts-node": "^10.9.2",
+ "tshy": "^1.14.0",
+ "typedoc": "^0.25.12",
+ "typescript": "^5.4.3"
+ },
+ "tap": {
+ "typecheck": true
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/path-scurry"
+ },
+ "dependencies": {
+ "lru-cache": "^10.2.0",
+ "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+ },
+ "tshy": {
+ "selfLink": false,
+ "exports": {
+ "./package.json": "./package.json",
+ ".": "./src/index.ts"
+ }
+ },
+ "types": "./dist/commonjs/index.d.ts"
+}
diff --git a/node_modules/picocolors/LICENSE b/node_modules/picocolors/LICENSE
new file mode 100644
index 0000000..46c9b95
--- /dev/null
+++ b/node_modules/picocolors/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/picocolors/README.md b/node_modules/picocolors/README.md
new file mode 100644
index 0000000..8e47aa8
--- /dev/null
+++ b/node_modules/picocolors/README.md
@@ -0,0 +1,21 @@
+# picocolors
+
+The tiniest and the fastest library for terminal output formatting with ANSI colors.
+
+```javascript
+import pc from "picocolors"
+
+console.log(
+ pc.green(`How are ${pc.italic(`you`)} doing?`)
+)
+```
+
+- **No dependencies.**
+- **14 times** smaller and **2 times** faster than chalk.
+- Used by popular tools like PostCSS, SVGO, Stylelint, and Browserslist.
+- Node.js v6+ & browsers support. Support for both CJS and ESM projects.
+- TypeScript type declarations included.
+- [`NO_COLOR`](https://no-color.org/) friendly.
+
+## Docs
+Read **[full docs](https://github.com/alexeyraspopov/picocolors#readme)** on GitHub.
diff --git a/node_modules/picocolors/package.json b/node_modules/picocolors/package.json
new file mode 100644
index 0000000..372d4b6
--- /dev/null
+++ b/node_modules/picocolors/package.json
@@ -0,0 +1,25 @@
+{
+ "name": "picocolors",
+ "version": "1.1.1",
+ "main": "./picocolors.js",
+ "types": "./picocolors.d.ts",
+ "browser": {
+ "./picocolors.js": "./picocolors.browser.js"
+ },
+ "sideEffects": false,
+ "description": "The tiniest and the fastest library for terminal output formatting with ANSI colors",
+ "files": [
+ "picocolors.*",
+ "types.d.ts"
+ ],
+ "keywords": [
+ "terminal",
+ "colors",
+ "formatting",
+ "cli",
+ "console"
+ ],
+ "author": "Alexey Raspopov",
+ "repository": "alexeyraspopov/picocolors",
+ "license": "ISC"
+}
diff --git a/node_modules/picocolors/picocolors.browser.js b/node_modules/picocolors/picocolors.browser.js
new file mode 100644
index 0000000..9dcf637
--- /dev/null
+++ b/node_modules/picocolors/picocolors.browser.js
@@ -0,0 +1,4 @@
+var x=String;
+var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
+module.exports=create();
+module.exports.createColors = create;
diff --git a/node_modules/picocolors/picocolors.d.ts b/node_modules/picocolors/picocolors.d.ts
new file mode 100644
index 0000000..94e146a
--- /dev/null
+++ b/node_modules/picocolors/picocolors.d.ts
@@ -0,0 +1,5 @@
+import { Colors } from "./types"
+
+declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors }
+
+export = picocolors
diff --git a/node_modules/picocolors/picocolors.js b/node_modules/picocolors/picocolors.js
new file mode 100644
index 0000000..e32df85
--- /dev/null
+++ b/node_modules/picocolors/picocolors.js
@@ -0,0 +1,75 @@
+let p = process || {}, argv = p.argv || [], env = p.env || {}
+let isColorSupported =
+ !(!!env.NO_COLOR || argv.includes("--no-color")) &&
+ (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI)
+
+let formatter = (open, close, replace = open) =>
+ input => {
+ let string = "" + input, index = string.indexOf(close, open.length)
+ return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
+ }
+
+let replaceClose = (string, close, replace, index) => {
+ let result = "", cursor = 0
+ do {
+ result += string.substring(cursor, index) + replace
+ cursor = index + close.length
+ index = string.indexOf(close, cursor)
+ } while (~index)
+ return result + string.substring(cursor)
+}
+
+let createColors = (enabled = isColorSupported) => {
+ let f = enabled ? formatter : () => String
+ return {
+ isColorSupported: enabled,
+ reset: f("\x1b[0m", "\x1b[0m"),
+ bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+ dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+ italic: f("\x1b[3m", "\x1b[23m"),
+ underline: f("\x1b[4m", "\x1b[24m"),
+ inverse: f("\x1b[7m", "\x1b[27m"),
+ hidden: f("\x1b[8m", "\x1b[28m"),
+ strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+ black: f("\x1b[30m", "\x1b[39m"),
+ red: f("\x1b[31m", "\x1b[39m"),
+ green: f("\x1b[32m", "\x1b[39m"),
+ yellow: f("\x1b[33m", "\x1b[39m"),
+ blue: f("\x1b[34m", "\x1b[39m"),
+ magenta: f("\x1b[35m", "\x1b[39m"),
+ cyan: f("\x1b[36m", "\x1b[39m"),
+ white: f("\x1b[37m", "\x1b[39m"),
+ gray: f("\x1b[90m", "\x1b[39m"),
+
+ bgBlack: f("\x1b[40m", "\x1b[49m"),
+ bgRed: f("\x1b[41m", "\x1b[49m"),
+ bgGreen: f("\x1b[42m", "\x1b[49m"),
+ bgYellow: f("\x1b[43m", "\x1b[49m"),
+ bgBlue: f("\x1b[44m", "\x1b[49m"),
+ bgMagenta: f("\x1b[45m", "\x1b[49m"),
+ bgCyan: f("\x1b[46m", "\x1b[49m"),
+ bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+ blackBright: f("\x1b[90m", "\x1b[39m"),
+ redBright: f("\x1b[91m", "\x1b[39m"),
+ greenBright: f("\x1b[92m", "\x1b[39m"),
+ yellowBright: f("\x1b[93m", "\x1b[39m"),
+ blueBright: f("\x1b[94m", "\x1b[39m"),
+ magentaBright: f("\x1b[95m", "\x1b[39m"),
+ cyanBright: f("\x1b[96m", "\x1b[39m"),
+ whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+ bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+ bgRedBright: f("\x1b[101m", "\x1b[49m"),
+ bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+ bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+ bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+ bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+ bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+ bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
+ }
+}
+
+module.exports = createColors()
+module.exports.createColors = createColors
diff --git a/node_modules/picocolors/types.d.ts b/node_modules/picocolors/types.d.ts
new file mode 100644
index 0000000..cd1aec4
--- /dev/null
+++ b/node_modules/picocolors/types.d.ts
@@ -0,0 +1,51 @@
+export type Formatter = (input: string | number | null | undefined) => string
+
+export interface Colors {
+ isColorSupported: boolean
+
+ reset: Formatter
+ bold: Formatter
+ dim: Formatter
+ italic: Formatter
+ underline: Formatter
+ inverse: Formatter
+ hidden: Formatter
+ strikethrough: Formatter
+
+ black: Formatter
+ red: Formatter
+ green: Formatter
+ yellow: Formatter
+ blue: Formatter
+ magenta: Formatter
+ cyan: Formatter
+ white: Formatter
+ gray: Formatter
+
+ bgBlack: Formatter
+ bgRed: Formatter
+ bgGreen: Formatter
+ bgYellow: Formatter
+ bgBlue: Formatter
+ bgMagenta: Formatter
+ bgCyan: Formatter
+ bgWhite: Formatter
+
+ blackBright: Formatter
+ redBright: Formatter
+ greenBright: Formatter
+ yellowBright: Formatter
+ blueBright: Formatter
+ magentaBright: Formatter
+ cyanBright: Formatter
+ whiteBright: Formatter
+
+ bgBlackBright: Formatter
+ bgRedBright: Formatter
+ bgGreenBright: Formatter
+ bgYellowBright: Formatter
+ bgBlueBright: Formatter
+ bgMagentaBright: Formatter
+ bgCyanBright: Formatter
+ bgWhiteBright: Formatter
+}
diff --git a/node_modules/picomatch/CHANGELOG.md b/node_modules/picomatch/CHANGELOG.md
new file mode 100644
index 0000000..8ccc6c1
--- /dev/null
+++ b/node_modules/picomatch/CHANGELOG.md
@@ -0,0 +1,136 @@
+# Release history
+
+**All notable changes to this project will be documented in this file.**
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+
+ Guiding Principles
+
+- Changelogs are for humans, not machines.
+- There should be an entry for every single version.
+- The same types of changes should be grouped.
+- Versions and sections should be linkable.
+- The latest version comes first.
+- The release date of each versions is displayed.
+- Mention whether you follow Semantic Versioning.
+
+
+
+
+ Types of changes
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
+
+- `Added` for new features.
+- `Changed` for changes in existing functionality.
+- `Deprecated` for soon-to-be removed features.
+- `Removed` for now removed features.
+- `Fixed` for any bug fixes.
+- `Security` in case of vulnerabilities.
+
+
+
+## 2.3.1 (2022-01-02)
+
+### Fixed
+
+* Fixes bug when a pattern containing an expression after the closing parenthesis (`/!(*.d).{ts,tsx}`) was incorrectly converted to regexp ([9f241ef](https://github.com/micromatch/picomatch/commit/9f241ef)).
+
+### Changed
+
+* Some documentation improvements ([f81d236](https://github.com/micromatch/picomatch/commit/f81d236), [421e0e7](https://github.com/micromatch/picomatch/commit/421e0e7)).
+
+## 2.3.0 (2021-05-21)
+
+### Fixed
+
+* Fixes bug where file names with two dots were not being matched consistently with negation extglobs containing a star ([56083ef](https://github.com/micromatch/picomatch/commit/56083ef))
+
+## 2.2.3 (2021-04-10)
+
+### Fixed
+
+* Do not skip pattern seperator for square brackets ([fb08a30](https://github.com/micromatch/picomatch/commit/fb08a30)).
+* Set negatedExtGlob also if it does not span the whole pattern ([032e3f5](https://github.com/micromatch/picomatch/commit/032e3f5)).
+
+## 2.2.2 (2020-03-21)
+
+### Fixed
+
+* Correctly handle parts of the pattern after parentheses in the `scan` method ([e15b920](https://github.com/micromatch/picomatch/commit/e15b920)).
+
+## 2.2.1 (2020-01-04)
+
+* Fixes [#49](https://github.com/micromatch/picomatch/issues/49), so that braces with no sets or ranges are now propertly treated as literals.
+
+## 2.2.0 (2020-01-04)
+
+* Disable fastpaths mode for the parse method ([5b8d33f](https://github.com/micromatch/picomatch/commit/5b8d33f))
+* Add `tokens`, `slashes`, and `parts` to the object returned by `picomatch.scan()`.
+
+## 2.1.0 (2019-10-31)
+
+* add benchmarks for scan ([4793b92](https://github.com/micromatch/picomatch/commit/4793b92))
+* Add eslint object-curly-spacing rule ([707c650](https://github.com/micromatch/picomatch/commit/707c650))
+* Add prefer-const eslint rule ([5c7501c](https://github.com/micromatch/picomatch/commit/5c7501c))
+* Add support for nonegate in scan API ([275c9b9](https://github.com/micromatch/picomatch/commit/275c9b9))
+* Change lets to consts. Move root import up. ([4840625](https://github.com/micromatch/picomatch/commit/4840625))
+* closes https://github.com/micromatch/picomatch/issues/21 ([766bcb0](https://github.com/micromatch/picomatch/commit/766bcb0))
+* Fix "Extglobs" table in readme ([eb19da8](https://github.com/micromatch/picomatch/commit/eb19da8))
+* fixes https://github.com/micromatch/picomatch/issues/20 ([9caca07](https://github.com/micromatch/picomatch/commit/9caca07))
+* fixes https://github.com/micromatch/picomatch/issues/26 ([fa58f45](https://github.com/micromatch/picomatch/commit/fa58f45))
+* Lint test ([d433a34](https://github.com/micromatch/picomatch/commit/d433a34))
+* lint unit tests ([0159b55](https://github.com/micromatch/picomatch/commit/0159b55))
+* Make scan work with noext ([6c02e03](https://github.com/micromatch/picomatch/commit/6c02e03))
+* minor linting ([c2a2b87](https://github.com/micromatch/picomatch/commit/c2a2b87))
+* minor parser improvements ([197671d](https://github.com/micromatch/picomatch/commit/197671d))
+* remove eslint since it... ([07876fa](https://github.com/micromatch/picomatch/commit/07876fa))
+* remove funding file ([8ebe96d](https://github.com/micromatch/picomatch/commit/8ebe96d))
+* Remove unused funks ([cbc6d54](https://github.com/micromatch/picomatch/commit/cbc6d54))
+* Run eslint during pretest, fix existing eslint findings ([0682367](https://github.com/micromatch/picomatch/commit/0682367))
+* support `noparen` in scan ([3d37569](https://github.com/micromatch/picomatch/commit/3d37569))
+* update changelog ([7b34e77](https://github.com/micromatch/picomatch/commit/7b34e77))
+* update travis ([777f038](https://github.com/micromatch/picomatch/commit/777f038))
+* Use eslint-disable-next-line instead of eslint-disable ([4e7c1fd](https://github.com/micromatch/picomatch/commit/4e7c1fd))
+
+## 2.0.7 (2019-05-14)
+
+* 2.0.7 ([9eb9a71](https://github.com/micromatch/picomatch/commit/9eb9a71))
+* supports lookbehinds ([1f63f7e](https://github.com/micromatch/picomatch/commit/1f63f7e))
+* update .verb.md file with typo change ([2741279](https://github.com/micromatch/picomatch/commit/2741279))
+* fix: typo in README ([0753e44](https://github.com/micromatch/picomatch/commit/0753e44))
+
+## 2.0.4 (2019-04-10)
+
+### Fixed
+
+- Readme link [fixed](https://github.com/micromatch/picomatch/pull/13/commits/a96ab3aa2b11b6861c23289964613d85563b05df) by @danez.
+- `options.capture` now works as expected when fastpaths are enabled. See https://github.com/micromatch/picomatch/pull/12/commits/26aefd71f1cfaf95c37f1c1fcab68a693b037304. Thanks to @DrPizza.
+
+## 2.0.0 (2019-04-10)
+
+### Added
+
+- Adds support for `options.onIgnore`. See the readme for details
+- Adds support for `options.onResult`. See the readme for details
+
+### Breaking changes
+
+- The unixify option was renamed to `windows`
+- caching and all related options and methods have been removed
+
+## 1.0.0 (2018-11-05)
+
+- adds `.onMatch` option
+- improvements to `.scan` method
+- numerous improvements and optimizations for matching and parsing
+- better windows path handling
+
+## 0.1.0 - 2017-04-13
+
+First release.
+
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
diff --git a/node_modules/picomatch/LICENSE b/node_modules/picomatch/LICENSE
new file mode 100644
index 0000000..3608dca
--- /dev/null
+++ b/node_modules/picomatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, 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/picomatch/README.md b/node_modules/picomatch/README.md
new file mode 100644
index 0000000..b0526e2
--- /dev/null
+++ b/node_modules/picomatch/README.md
@@ -0,0 +1,708 @@
+Picomatch
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Blazing fast and accurate glob matcher written in JavaScript.
+No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.
+
+
+
+
+
+## Why picomatch?
+
+* **Lightweight** - No dependencies
+* **Minimal** - Tiny API surface. Main export is a function that takes a glob pattern and returns a matcher function.
+* **Fast** - Loads in about 2ms (that's several times faster than a [single frame of a HD movie](http://www.endmemo.com/sconvert/framespersecondframespermillisecond.php) at 60fps)
+* **Performant** - Use the returned matcher function to speed up repeat matching (like when watching files)
+* **Accurate matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories, [advanced globbing](#advanced-globbing) with extglobs, braces, and POSIX brackets, and support for escaping special characters with `\` or quotes.
+* **Well tested** - Thousands of unit tests
+
+See the [library comparison](#library-comparisons) to other libraries.
+
+
+
+
+## Table of Contents
+
+ Click to expand
+
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+ * [picomatch](#picomatch)
+ * [.test](#test)
+ * [.matchBase](#matchbase)
+ * [.isMatch](#ismatch)
+ * [.parse](#parse)
+ * [.scan](#scan)
+ * [.compileRe](#compilere)
+ * [.makeRe](#makere)
+ * [.toRegex](#toregex)
+- [Options](#options)
+ * [Picomatch options](#picomatch-options)
+ * [Scan Options](#scan-options)
+ * [Options Examples](#options-examples)
+- [Globbing features](#globbing-features)
+ * [Basic globbing](#basic-globbing)
+ * [Advanced globbing](#advanced-globbing)
+ * [Braces](#braces)
+ * [Matching special characters as literals](#matching-special-characters-as-literals)
+- [Library Comparisons](#library-comparisons)
+- [Benchmarks](#benchmarks)
+- [Philosophies](#philosophies)
+- [About](#about)
+ * [Author](#author)
+ * [License](#license)
+
+_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_
+
+
+
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+npm install --save picomatch
+```
+
+
+
+## Usage
+
+The main export is a function that takes a glob pattern and an options object and returns a function for matching strings.
+
+```js
+const pm = require('picomatch');
+const isMatch = pm('*.js');
+
+console.log(isMatch('abcd')); //=> false
+console.log(isMatch('a.js')); //=> true
+console.log(isMatch('a.md')); //=> false
+console.log(isMatch('a/b.js')); //=> false
+```
+
+
+
+## API
+
+### [picomatch](lib/picomatch.js#L32)
+
+Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information.
+
+**Params**
+
+* `globs` **{String|Array}**: One or more glob patterns.
+* `options` **{Object=}**
+* `returns` **{Function=}**: Returns a matcher function.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch(glob[, options]);
+
+const isMatch = picomatch('*.!(*a)');
+console.log(isMatch('a.a')); //=> false
+console.log(isMatch('a.b')); //=> true
+```
+
+### [.test](lib/picomatch.js#L117)
+
+Test `input` with the given `regex`. This is used by the main `picomatch()` function to test the input string.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `regex` **{RegExp}**
+* `returns` **{Object}**: Returns an object with matching info.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.test(input, regex[, options]);
+
+console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+```
+
+### [.matchBase](lib/picomatch.js#L161)
+
+Match the basename of a filepath.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `glob` **{RegExp|String}**: Glob pattern or regex created by [.makeRe](#makeRe).
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.matchBase(input, glob[, options]);
+console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+```
+
+### [.isMatch](lib/picomatch.js#L183)
+
+Returns true if **any** of the given glob `patterns` match the specified `string`.
+
+**Params**
+
+* **{String|Array}**: str The string to test.
+* **{String|Array}**: patterns One or more glob patterns to use for matching.
+* **{Object}**: See available [options](#options).
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.isMatch(string, patterns[, options]);
+
+console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+```
+
+### [.parse](lib/picomatch.js#L199)
+
+Parse a glob pattern to create the source string for a regular expression.
+
+**Params**
+
+* `pattern` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with useful properties and output to be used as a regex source string.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.parse(pattern[, options]);
+```
+
+### [.scan](lib/picomatch.js#L231)
+
+Scan a glob pattern to separate the pattern into segments.
+
+**Params**
+
+* `input` **{String}**: Glob pattern to scan.
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.scan(input[, options]);
+
+const result = picomatch.scan('!./foo/*.js');
+console.log(result);
+{ prefix: '!./',
+ input: '!./foo/*.js',
+ start: 3,
+ base: 'foo',
+ glob: '*.js',
+ isBrace: false,
+ isBracket: false,
+ isGlob: true,
+ isExtglob: false,
+ isGlobstar: false,
+ negated: true }
+```
+
+### [.compileRe](lib/picomatch.js#L245)
+
+Compile a regular expression from the `state` object returned by the
+[parse()](#parse) method.
+
+**Params**
+
+* `state` **{Object}**
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser.
+* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+* `returns` **{RegExp}**
+
+### [.makeRe](lib/picomatch.js#L286)
+
+Create a regular expression from a parsed glob pattern.
+
+**Params**
+
+* `state` **{String}**: The object returned from the `.parse` method.
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+* `returns` **{RegExp}**: Returns a regex created from the given pattern.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const state = picomatch.parse('*.js');
+// picomatch.compileRe(state[, options]);
+
+console.log(picomatch.compileRe(state));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+### [.toRegex](lib/picomatch.js#L321)
+
+Create a regular expression from the given regex source string.
+
+**Params**
+
+* `source` **{String}**: Regular expression source string.
+* `options` **{Object}**
+* `returns` **{RegExp}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.toRegex(source[, options]);
+
+const { output } = picomatch.parse('*.js');
+console.log(picomatch.toRegex(output));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+
+
+## Options
+
+### Picomatch options
+
+The following options may be used with the main `picomatch()` function or any of the methods on the picomatch API.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `basename` | `boolean` | `false` | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. |
+| `bash` | `boolean` | `false` | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). |
+| `capture` | `boolean` | `undefined` | Return regex matches in supporting methods. |
+| `contains` | `boolean` | `undefined` | Allows glob to match any part of the given string(s). |
+| `cwd` | `string` | `process.cwd()` | Current working directory. Used by `picomatch.split()` |
+| `debug` | `boolean` | `undefined` | Debug regular expressions when an error is thrown. |
+| `dot` | `boolean` | `false` | Enable dotfile matching. By default, dotfiles are ignored unless a `.` is explicitly defined in the pattern, or `options.dot` is true |
+| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. |
+| `failglob` | `boolean` | `false` | Throws an error if no matches are found. Based on the bash option of the same name. |
+| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
+| `flags` | `string` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
+| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
+| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
+| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. |
+| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
+| `matchBase` | `boolean` | `false` | Alias for `basename` |
+| `maxLength` | `boolean` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
+| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
+| `nobracket` | `boolean` | `undefined` | Disable matching with regex brackets. |
+| `nocase` | `boolean` | `false` | Make matching case-insensitive. Equivalent to the regex `i` flag. Note that this option is overridden by the `flags` option. |
+| `nodupes` | `boolean` | `true` | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. |
+| `noext` | `boolean` | `false` | Alias for `noextglob` |
+| `noextglob` | `boolean` | `false` | Disable support for matching with extglobs (like `+(a\|b)`) |
+| `noglobstar` | `boolean` | `false` | Disable support for matching nested directories with globstars (`**`) |
+| `nonegate` | `boolean` | `false` | Disable support for negating with leading `!` |
+| `noquantifiers` | `boolean` | `false` | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. |
+| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. |
+| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. |
+| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. |
+| `posix` | `boolean` | `false` | Support POSIX character classes ("posix brackets"). |
+| `posixSlashes` | `boolean` | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself |
+| `prepend` | `boolean` | `undefined` | String to prepend to the generated regex used for matching. |
+| `regex` | `boolean` | `false` | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). |
+| `strictBrackets` | `boolean` | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. |
+| `strictSlashes` | `boolean` | `undefined` | When true, picomatch won't match trailing slashes with single stars. |
+| `unescape` | `boolean` | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. |
+| `unixify` | `boolean` | `undefined` | Alias for `posixSlashes`, for backwards compatibility. |
+
+picomatch has automatic detection for regex positive and negative lookbehinds. If the pattern contains a negative lookbehind, you must be using Node.js >= 8.10 or else picomatch will throw an error.
+
+### Scan Options
+
+In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `tokens` | `boolean` | `false` | When `true`, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern |
+| `parts` | `boolean` | `false` | When `true`, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when `options.tokens` is true |
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.scan('!./foo/*.js', { tokens: true });
+console.log(result);
+// {
+// prefix: '!./',
+// input: '!./foo/*.js',
+// start: 3,
+// base: 'foo',
+// glob: '*.js',
+// isBrace: false,
+// isBracket: false,
+// isGlob: true,
+// isExtglob: false,
+// isGlobstar: false,
+// negated: true,
+// maxDepth: 2,
+// tokens: [
+// { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true },
+// { value: 'foo', depth: 1, isGlob: false },
+// { value: '*.js', depth: 1, isGlob: true }
+// ],
+// slashes: [ 2, 6 ],
+// parts: [ 'foo', '*.js' ]
+// }
+```
+
+
+
+### Options Examples
+
+#### options.expandRange
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need.
+
+**Example**
+
+The following example shows how to create a glob that matches a folder
+
+```js
+const fill = require('fill-range');
+const regex = pm.makeRe('foo/{01..25}/bar', {
+ expandRange(a, b) {
+ return `(${fill(a, b, { toRegex: true })})`;
+ }
+});
+
+console.log(regex);
+//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
+
+console.log(regex.test('foo/00/bar')) // false
+console.log(regex.test('foo/01/bar')) // true
+console.log(regex.test('foo/10/bar')) // true
+console.log(regex.test('foo/22/bar')) // true
+console.log(regex.test('foo/25/bar')) // true
+console.log(regex.test('foo/26/bar')) // false
+```
+
+#### options.format
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for formatting strings before they're matched.
+
+**Example**
+
+```js
+// strip leading './' from strings
+const format = str => str.replace(/^\.\//, '');
+const isMatch = picomatch('foo/*.js', { format });
+console.log(isMatch('./foo/bar.js')); //=> true
+```
+
+#### options.onMatch
+
+```js
+const onMatch = ({ glob, regex, input, output }) => {
+ console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onMatch });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onIgnore
+
+```js
+const onIgnore = ({ glob, regex, input, output }) => {
+ console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onIgnore, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onResult
+
+```js
+const onResult = ({ glob, regex, input, output }) => {
+ console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onResult, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+
+
+
+## Globbing features
+
+* [Basic globbing](#basic-globbing) (Wildcard matching)
+* [Advanced globbing](#advanced-globbing) (extglobs, posix brackets, brace matching)
+
+### Basic globbing
+
+| **Character** | **Description** |
+| --- | --- |
+| `*` | Matches any character zero or more times, excluding path separators. Does _not match_ path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the `dot` option to `true`. |
+| `**` | Matches any character zero or more times, including path separators. Note that `**` will only match path separators (`/`, and `\\` on Windows) when they are the only characters in a path segment. Thus, `foo**/bar` is equivalent to `foo*/bar`, and `foo/a**b/bar` is equivalent to `foo/a*b/bar`, and _more than two_ consecutive stars in a glob path segment are regarded as _a single star_. Thus, `foo/***/bar` is equivalent to `foo/*/bar`. |
+| `?` | Matches any character excluding path separators one time. Does _not match_ path separators or leading dots. |
+| `[abc]` | Matches any characters inside the brackets. For example, `[abc]` would match the characters `a`, `b` or `c`, and nothing else. |
+
+#### Matching behavior vs. Bash
+
+Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions:
+
+* Bash will match `foo/bar/baz` with `*`. Picomatch only matches nested directories with `**`.
+* Bash greedily matches with negated extglobs. For example, Bash 4.3 says that `!(foo)*` should match `foo` and `foobar`, since the trailing `*` bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return `false` for both `foo` and `foobar`.
+
+
+
+### Advanced globbing
+
+* [extglobs](#extglobs)
+* [POSIX brackets](#posix-brackets)
+* [Braces](#brace-expansion)
+
+#### Extglobs
+
+| **Pattern** | **Description** |
+| --- | --- |
+| `@(pattern)` | Match _only one_ consecutive occurrence of `pattern` |
+| `*(pattern)` | Match _zero or more_ consecutive occurrences of `pattern` |
+| `+(pattern)` | Match _one or more_ consecutive occurrences of `pattern` |
+| `?(pattern)` | Match _zero or **one**_ consecutive occurrences of `pattern` |
+| `!(pattern)` | Match _anything but_ `pattern` |
+
+**Examples**
+
+```js
+const pm = require('picomatch');
+
+// *(pattern) matches ZERO or more of "pattern"
+console.log(pm.isMatch('a', 'a*(z)')); // true
+console.log(pm.isMatch('az', 'a*(z)')); // true
+console.log(pm.isMatch('azzz', 'a*(z)')); // true
+
+// +(pattern) matches ONE or more of "pattern"
+console.log(pm.isMatch('a', 'a*(z)')); // true
+console.log(pm.isMatch('az', 'a*(z)')); // true
+console.log(pm.isMatch('azzz', 'a*(z)')); // true
+
+// supports multiple extglobs
+console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false
+
+// supports nested extglobs
+console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true
+```
+
+#### POSIX brackets
+
+POSIX classes are disabled by default. Enable this feature by setting the `posix` option to true.
+
+**Enable POSIX bracket support**
+
+```js
+console.log(pm.makeRe('[[:word:]]+', { posix: true }));
+//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/
+```
+
+**Supported POSIX classes**
+
+The following named POSIX bracket expressions are supported:
+
+* `[:alnum:]` - Alphanumeric characters, equ `[a-zA-Z0-9]`
+* `[:alpha:]` - Alphabetical characters, equivalent to `[a-zA-Z]`.
+* `[:ascii:]` - ASCII characters, equivalent to `[\\x00-\\x7F]`.
+* `[:blank:]` - Space and tab characters, equivalent to `[ \\t]`.
+* `[:cntrl:]` - Control characters, equivalent to `[\\x00-\\x1F\\x7F]`.
+* `[:digit:]` - Numerical digits, equivalent to `[0-9]`.
+* `[:graph:]` - Graph characters, equivalent to `[\\x21-\\x7E]`.
+* `[:lower:]` - Lowercase letters, equivalent to `[a-z]`.
+* `[:print:]` - Print characters, equivalent to `[\\x20-\\x7E ]`.
+* `[:punct:]` - Punctuation and symbols, equivalent to `[\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~]`.
+* `[:space:]` - Extended space characters, equivalent to `[ \\t\\r\\n\\v\\f]`.
+* `[:upper:]` - Uppercase letters, equivalent to `[A-Z]`.
+* `[:word:]` - Word characters (letters, numbers and underscores), equivalent to `[A-Za-z0-9_]`.
+* `[:xdigit:]` - Hexadecimal digits, equivalent to `[A-Fa-f0-9]`.
+
+See the [Bash Reference Manual](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) for more information.
+
+### Braces
+
+Picomatch does not do brace expansion. For [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) and advanced matching with braces, use [micromatch](https://github.com/micromatch/micromatch) instead. Picomatch has very basic support for braces.
+
+### Matching special characters as literals
+
+If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes:
+
+**Special Characters**
+
+Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms.
+
+To match any of the following characters as literals: `$^*+?()[]
+
+Examples:
+
+```js
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+```
+
+
+
+
+## Library Comparisons
+
+The following table shows which features are supported by [minimatch](https://github.com/isaacs/minimatch), [micromatch](https://github.com/micromatch/micromatch), [picomatch](https://github.com/micromatch/picomatch), [nanomatch](https://github.com/micromatch/nanomatch), [extglob](https://github.com/micromatch/extglob), [braces](https://github.com/micromatch/braces), and [expand-brackets](https://github.com/micromatch/expand-brackets).
+
+| **Feature** | `minimatch` | `micromatch` | `picomatch` | `nanomatch` | `extglob` | `braces` | `expand-brackets` |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Wildcard matching (`*?+`) | ✔ | ✔ | ✔ | ✔ | - | - | - |
+| Advancing globbing | ✔ | ✔ | ✔ | - | - | - | - |
+| Brace _matching_ | ✔ | ✔ | ✔ | - | - | ✔ | - |
+| Brace _expansion_ | ✔ | ✔ | - | - | - | ✔ | - |
+| Extglobs | partial | ✔ | ✔ | - | ✔ | - | - |
+| Posix brackets | - | ✔ | ✔ | - | - | - | ✔ |
+| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ |
+| File system operations | - | - | - | - | - | - | - |
+
+
+
+
+## Benchmarks
+
+Performance comparison of picomatch and minimatch.
+
+```
+# .makeRe star
+ picomatch x 1,993,050 ops/sec ±0.51% (91 runs sampled)
+ minimatch x 627,206 ops/sec ±1.96% (87 runs sampled))
+
+# .makeRe star; dot=true
+ picomatch x 1,436,640 ops/sec ±0.62% (91 runs sampled)
+ minimatch x 525,876 ops/sec ±0.60% (88 runs sampled)
+
+# .makeRe globstar
+ picomatch x 1,592,742 ops/sec ±0.42% (90 runs sampled)
+ minimatch x 962,043 ops/sec ±1.76% (91 runs sampled)d)
+
+# .makeRe globstars
+ picomatch x 1,615,199 ops/sec ±0.35% (94 runs sampled)
+ minimatch x 477,179 ops/sec ±1.33% (91 runs sampled)
+
+# .makeRe with leading star
+ picomatch x 1,220,856 ops/sec ±0.40% (92 runs sampled)
+ minimatch x 453,564 ops/sec ±1.43% (94 runs sampled)
+
+# .makeRe - basic braces
+ picomatch x 392,067 ops/sec ±0.70% (90 runs sampled)
+ minimatch x 99,532 ops/sec ±2.03% (87 runs sampled))
+```
+
+
+
+
+## Philosophies
+
+The goal of this library is to be blazing fast, without compromising on accuracy.
+
+**Accuracy**
+
+The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: `!(**/{a,b,*/c})`.
+
+Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements.
+
+**Performance**
+
+Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer.
+
+
+
+
+## About
+
+
+Contributing
+
+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.
+
+
+
+
+Running Tests
+
+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
+```
+
+
+
+
+Building docs
+
+_(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
+```
+
+
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
diff --git a/node_modules/picomatch/index.js b/node_modules/picomatch/index.js
new file mode 100644
index 0000000..d2f2bc5
--- /dev/null
+++ b/node_modules/picomatch/index.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/picomatch');
diff --git a/node_modules/picomatch/package.json b/node_modules/picomatch/package.json
new file mode 100644
index 0000000..3db22d4
--- /dev/null
+++ b/node_modules/picomatch/package.json
@@ -0,0 +1,81 @@
+{
+ "name": "picomatch",
+ "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
+ "version": "2.3.1",
+ "homepage": "https://github.com/micromatch/picomatch",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "funding": "https://github.com/sponsors/jonschlinkert",
+ "repository": "micromatch/picomatch",
+ "bugs": {
+ "url": "https://github.com/micromatch/picomatch/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=8.6"
+ },
+ "scripts": {
+ "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
+ "mocha": "mocha --reporter dot",
+ "test": "npm run lint && npm run mocha",
+ "test:ci": "npm run test:cover",
+ "test:cover": "nyc npm run mocha"
+ },
+ "devDependencies": {
+ "eslint": "^6.8.0",
+ "fill-range": "^7.0.1",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.2.2",
+ "nyc": "^15.0.0",
+ "time-require": "github:jonschlinkert/time-require"
+ },
+ "keywords": [
+ "glob",
+ "match",
+ "picomatch"
+ ],
+ "nyc": {
+ "reporter": [
+ "html",
+ "lcov",
+ "text-summary"
+ ]
+ },
+ "verb": {
+ "toc": {
+ "render": true,
+ "method": "preWrite",
+ "maxdepth": 3
+ },
+ "layout": "empty",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "related": {
+ "list": [
+ "braces",
+ "micromatch"
+ ]
+ },
+ "reflinks": [
+ "braces",
+ "expand-brackets",
+ "extglob",
+ "fill-range",
+ "micromatch",
+ "minimatch",
+ "nanomatch",
+ "picomatch"
+ ]
+ }
+}
diff --git a/node_modules/pify/index.js b/node_modules/pify/index.js
new file mode 100644
index 0000000..7c720eb
--- /dev/null
+++ b/node_modules/pify/index.js
@@ -0,0 +1,68 @@
+'use strict';
+
+var processFn = function (fn, P, opts) {
+ return function () {
+ var that = this;
+ var args = new Array(arguments.length);
+
+ for (var i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i];
+ }
+
+ return new P(function (resolve, reject) {
+ args.push(function (err, result) {
+ if (err) {
+ reject(err);
+ } else if (opts.multiArgs) {
+ var results = new Array(arguments.length - 1);
+
+ for (var i = 1; i < arguments.length; i++) {
+ results[i - 1] = arguments[i];
+ }
+
+ resolve(results);
+ } else {
+ resolve(result);
+ }
+ });
+
+ fn.apply(that, args);
+ });
+ };
+};
+
+var pify = module.exports = function (obj, P, opts) {
+ if (typeof P !== 'function') {
+ opts = P;
+ P = Promise;
+ }
+
+ opts = opts || {};
+ opts.exclude = opts.exclude || [/.+Sync$/];
+
+ var filter = function (key) {
+ var match = function (pattern) {
+ return typeof pattern === 'string' ? key === pattern : pattern.test(key);
+ };
+
+ return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+ };
+
+ var ret = typeof obj === 'function' ? function () {
+ if (opts.excludeMain) {
+ return obj.apply(this, arguments);
+ }
+
+ return processFn(obj, P, opts).apply(this, arguments);
+ } : {};
+
+ return Object.keys(obj).reduce(function (ret, key) {
+ var x = obj[key];
+
+ ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x;
+
+ return ret;
+ }, ret);
+};
+
+pify.all = pify;
diff --git a/node_modules/pify/license b/node_modules/pify/license
new file mode 100644
index 0000000..654d0bf
--- /dev/null
+++ b/node_modules/pify/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+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/pify/package.json b/node_modules/pify/package.json
new file mode 100644
index 0000000..311d198
--- /dev/null
+++ b/node_modules/pify/package.json
@@ -0,0 +1,48 @@
+{
+ "name": "pify",
+ "version": "2.3.0",
+ "description": "Promisify a callback-style function",
+ "license": "MIT",
+ "repository": "sindresorhus/pify",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "xo && ava && npm run optimization-test",
+ "optimization-test": "node --allow-natives-syntax optimization-test.js"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "promise",
+ "promises",
+ "promisify",
+ "denodify",
+ "denodeify",
+ "callback",
+ "cb",
+ "node",
+ "then",
+ "thenify",
+ "convert",
+ "transform",
+ "wrap",
+ "wrapper",
+ "bind",
+ "to",
+ "async",
+ "es2015"
+ ],
+ "devDependencies": {
+ "ava": "*",
+ "pinkie-promise": "^1.0.0",
+ "v8-natives": "0.0.2",
+ "xo": "*"
+ }
+}
diff --git a/node_modules/pify/readme.md b/node_modules/pify/readme.md
new file mode 100644
index 0000000..c79ca8b
--- /dev/null
+++ b/node_modules/pify/readme.md
@@ -0,0 +1,119 @@
+# pify [](https://travis-ci.org/sindresorhus/pify)
+
+> Promisify a callback-style function
+
+
+## Install
+
+```
+$ npm install --save pify
+```
+
+
+## Usage
+
+```js
+const fs = require('fs');
+const pify = require('pify');
+
+// promisify a single function
+
+pify(fs.readFile)('package.json', 'utf8').then(data => {
+ console.log(JSON.parse(data).name);
+ //=> 'pify'
+});
+
+// or promisify all methods in a module
+
+pify(fs).readFile('package.json', 'utf8').then(data => {
+ console.log(JSON.parse(data).name);
+ //=> 'pify'
+});
+```
+
+
+## API
+
+### pify(input, [promiseModule], [options])
+
+Returns a promise wrapped version of the supplied function or module.
+
+#### input
+
+Type: `function`, `object`
+
+Callback-style function or module whose methods you want to promisify.
+
+#### promiseModule
+
+Type: `function`
+
+Custom promise module to use instead of the native one.
+
+Check out [`pinkie-promise`](https://github.com/floatdrop/pinkie-promise) if you need a tiny promise polyfill.
+
+#### options
+
+##### multiArgs
+
+Type: `boolean`
+Default: `false`
+
+By default, the promisified function will only return the second argument from the callback, which works fine for most APIs. This option can be useful for modules like `request` that return multiple arguments. Turning this on will make it return an array of all arguments from the callback, excluding the error argument, instead of just the second argument.
+
+```js
+const request = require('request');
+const pify = require('pify');
+
+pify(request, {multiArgs: true})('https://sindresorhus.com').then(result => {
+ const [httpResponse, body] = result;
+});
+```
+
+##### include
+
+Type: `array` of (`string`|`regex`)
+
+Methods in a module to promisify. Remaining methods will be left untouched.
+
+##### exclude
+
+Type: `array` of (`string`|`regex`)
+Default: `[/.+Sync$/]`
+
+Methods in a module **not** to promisify. Methods with names ending with `'Sync'` are excluded by default.
+
+##### excludeMain
+
+Type: `boolean`
+Default: `false`
+
+By default, if given module is a function itself, this function will be promisified. Turn this option on if you want to promisify only methods of the module.
+
+```js
+const pify = require('pify');
+
+function fn() {
+ return true;
+}
+
+fn.method = (data, callback) => {
+ setImmediate(() => {
+ callback(data, null);
+ });
+};
+
+// promisify methods but not fn()
+const promiseFn = pify(fn, {excludeMain: true});
+
+if (promiseFn()) {
+ promiseFn.method('hi').then(data => {
+ console.log(data);
+ });
+}
+```
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)
diff --git a/node_modules/pirates/LICENSE b/node_modules/pirates/LICENSE
new file mode 100644
index 0000000..acc7a0e
--- /dev/null
+++ b/node_modules/pirates/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-2018 Ari Porad
+
+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/pirates/README.md b/node_modules/pirates/README.md
new file mode 100644
index 0000000..f61065e
--- /dev/null
+++ b/node_modules/pirates/README.md
@@ -0,0 +1,69 @@
+# Pirates [![Coverage][codecov-badge]][codecov-link]
+
+### Properly hijack require
+
+[codecov-badge]: https://img.shields.io/codecov/c/github/danez/pirates/master.svg?style=flat "codecov"
+[codecov-link]: https://codecov.io/gh/danez/pirates "codecov"
+
+## Why?
+
+Two reasons:
+1. Babel and istanbul were breaking each other.
+2. Everyone seemed to re-invent the wheel on this, and everyone wanted a solution that was DRY, simple, easy to use,
+and made everything Just Work™, while allowing multiple require hooks, in a fashion similar to calling `super`.
+
+For some context, see [the Babel issue thread][] which started this all, then [the nyc issue thread][], where
+discussion was moved (as we began to discuss just using the code nyc had developed), and finally to [#1][issue-1]
+where discussion was finally moved.
+
+[the Babel issue thread]: https://github.com/babel/babel/pull/3062 "Babel Issue Thread"
+[the nyc issue thread]: https://github.com/bcoe/nyc/issues/70 "NYC Issue Thread"
+[issue-1]: https://github.com/danez/pirates/issues/1 "Issue #1"
+
+## Installation
+
+ npm install --save pirates
+
+## Usage
+
+Using pirates is really easy:
+```javascript
+// my-module/register.js
+const addHook = require('pirates').addHook;
+// Or if you use ES modules
+// import { addHook } from 'pirates';
+
+function matcher(filename) {
+ // Here, you can inspect the filename to determine if it should be hooked or
+ // not. Just return a truthy/falsey. Files in node_modules are automatically ignored,
+ // unless otherwise specified in options (see below).
+
+ // TODO: Implement your logic here
+ return true;
+}
+
+const revert = addHook(
+ (code, filename) => code.replace('@@foo', 'console.log(\'foo\');'),
+ { exts: ['.js'], matcher }
+);
+
+// And later, if you want to un-hook require, you can just do:
+revert();
+```
+
+## API
+
+### pirates.addHook(hook, [opts={ [matcher: true], [exts: ['.js']], [ignoreNodeModules: true] }]);
+Add a require hook. `hook` must be a function that takes `(code, filename)`, and returns the modified code. `opts` is
+an optional options object. Available options are: `matcher`, which is a function that accepts a filename, and
+returns a truthy value if the file should be hooked (defaults to a function that always returns true), falsey if
+otherwise; `exts`, which is an array of extensions to hook, they should begin with `.` (defaults to `['.js']`);
+`ignoreNodeModules`, if true, any file in a `node_modules` folder wont be hooked (the matcher also wont be called),
+if false, then the matcher will be called for any files in `node_modules` (defaults to true).
+
+
+## Projects that use Pirates
+
+See the [wiki page](https://github.com/danez/pirates/wiki/Projects-using-Pirates). If you add Pirates to your project,
+(And you should! It works best if everyone uses it. Then we can have a happy world full of happy require hooks!), please
+add yourself to the wiki.
diff --git a/node_modules/pirates/index.d.ts b/node_modules/pirates/index.d.ts
new file mode 100644
index 0000000..b2d8ce6
--- /dev/null
+++ b/node_modules/pirates/index.d.ts
@@ -0,0 +1,82 @@
+/* (c) 2015 Ari Porad (@ariporad) . License: ariporad.mit-license.org */
+
+/**
+ * The hook. Accepts the code of the module and the filename.
+ */
+declare type Hook = (code: string, filename: string) => string;
+
+/**
+ * A matcher function, will be called with path to a file.
+ *
+ * Should return truthy if the file should be hooked, falsy otherwise.
+ */
+declare type Matcher = (path: string) => boolean;
+
+/**
+ * Reverts the hook when called.
+ */
+declare type RevertFunction = () => void;
+interface Options {
+ /**
+ * The extensions to hook. Should start with '.' (ex. ['.js']).
+ *
+ * Takes precedence over `exts`, `extension` and `ext`.
+ *
+ * @alias exts
+ * @alias extension
+ * @alias ext
+ * @default ['.js']
+ */
+ extensions?: ReadonlyArray | string;
+
+ /**
+ * The extensions to hook. Should start with '.' (ex. ['.js']).
+ *
+ * Takes precedence over `extension` and `ext`.
+ *
+ * @alias extension
+ * @alias ext
+ * @default ['.js']
+ */
+ exts?: ReadonlyArray | string;
+
+ /**
+ * The extensions to hook. Should start with '.' (ex. ['.js']).
+ *
+ * Takes precedence over `ext`.
+ *
+ * @alias ext
+ * @default ['.js']
+ */
+ extension?: ReadonlyArray | string;
+
+ /**
+ * The extensions to hook. Should start with '.' (ex. ['.js']).
+ *
+ * @default ['.js']
+ */
+ ext?: ReadonlyArray | string;
+
+ /**
+ * A matcher function, will be called with path to a file.
+ *
+ * Should return truthy if the file should be hooked, falsy otherwise.
+ */
+ matcher?: Matcher | null;
+
+ /**
+ * Auto-ignore node_modules. Independent of any matcher.
+ *
+ * @default true
+ */
+ ignoreNodeModules?: boolean;
+}
+
+/**
+ * Add a require hook.
+ *
+ * @param hook The hook. Accepts the code of the module and the filename. Required.
+ * @returns The `revert` function. Reverts the hook when called.
+ */
+export declare function addHook(hook: Hook, opts?: Options): RevertFunction;
+export {};
diff --git a/node_modules/pirates/package.json b/node_modules/pirates/package.json
new file mode 100644
index 0000000..331ed0e
--- /dev/null
+++ b/node_modules/pirates/package.json
@@ -0,0 +1,74 @@
+{
+ "name": "pirates",
+ "description": "Properly hijack require, i.e., properly define require hooks and customizations",
+ "main": "lib/index.js",
+ "types": "index.d.ts",
+ "scripts": {
+ "clean": "rimraf lib",
+ "build": "babel src -d lib",
+ "test": "cross-env BABEL_ENV=test yarn run build && nyc ava",
+ "lint": "eslint --report-unused-disable-directives .",
+ "prepublishOnly": "yarn run build"
+ },
+ "files": [
+ "lib",
+ "index.d.ts"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/danez/pirates.git"
+ },
+ "engines": {
+ "node": ">= 6"
+ },
+ "author": {
+ "name": "Ari Porad",
+ "email": "ari@ariporad.com",
+ "url": "http://ariporad.com"
+ },
+ "devDependencies": {
+ "@babel/cli": "7.21.0",
+ "@babel/core": "7.21.4",
+ "@babel/preset-env": "7.21.4",
+ "ava": "1.4.1",
+ "babel-core": "7.0.0-bridge.0",
+ "babel-eslint": "10.1.0",
+ "babel-plugin-istanbul": "5.2.0",
+ "cross-env": "5.2.1",
+ "decache": "4.6.1",
+ "eslint": "5.16.0",
+ "eslint-config-prettier": "4.3.0",
+ "eslint-plugin-import": "2.27.5",
+ "eslint-plugin-prettier": "3.4.1",
+ "mock-require": "3.0.3",
+ "nyc": "13.3.0",
+ "prettier": "1.19.1",
+ "rewire": "4.0.1",
+ "rimraf": "3.0.2"
+ },
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/danez/pirates/issues"
+ },
+ "homepage": "https://github.com/danez/pirates#readme",
+ "ava": {
+ "files": [
+ "test/*.js"
+ ],
+ "sources": [
+ "lib/**/*.js"
+ ]
+ },
+ "nyc": {
+ "include": [
+ "src/*.js"
+ ],
+ "reporter": [
+ "json",
+ "text"
+ ],
+ "sourceMap": false,
+ "instrument": false
+ },
+ "version": "4.0.6"
+}
diff --git a/node_modules/postcss-import/LICENSE b/node_modules/postcss-import/LICENSE
new file mode 100644
index 0000000..13983fb
--- /dev/null
+++ b/node_modules/postcss-import/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Maxime Thirouin, Jason Campbell & Kevin Mårtensson
+
+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/postcss-import/README.md b/node_modules/postcss-import/README.md
new file mode 100644
index 0000000..ac0148e
--- /dev/null
+++ b/node_modules/postcss-import/README.md
@@ -0,0 +1,244 @@
+# postcss-import
+
+[](https://travis-ci.org/postcss/postcss-import)
+[](https://github.com/postcss/postcss-import/blob/master/CHANGELOG.md)
+[](https://postcss.org/)
+
+> [PostCSS](https://github.com/postcss/postcss) plugin to transform `@import`
+rules by inlining content.
+
+This plugin can consume local files, node modules or web_modules.
+To resolve path of an `@import` rule, it can look into root directory
+(by default `process.cwd()`), `web_modules`, `node_modules`
+or local modules.
+_When importing a module, it will look for `index.css` or file referenced in
+`package.json` in the `style` or `main` fields._
+You can also provide manually multiples paths where to look at.
+
+**Notes:**
+
+- **This plugin should probably be used as the first plugin of your list.
+This way, other plugins will work on the AST as if there were only a single file
+to process, and will probably work as you can expect**.
+- This plugin works great with
+[postcss-url](https://github.com/postcss/postcss-url) plugin,
+which will allow you to adjust assets `url()` (or even inline them) after
+inlining imported files.
+- In order to optimize output, **this plugin will only import a file once** on
+a given scope (root, media query...).
+Tests are made from the path & the content of imported files (using a hash
+table).
+If this behavior is not what you want, look at `skipDuplicates` option
+- If you are looking for **Glob Imports**, you can use [postcss-import-ext-glob](https://github.com/dimitrinicolas/postcss-import-ext-glob) to extend postcss-import.
+- Imports which are not modified (by `options.filter` or because they are remote
+ imports) are moved to the top of the output.
+- **This plugin attempts to follow the CSS `@import` spec**; `@import`
+ statements must precede all other statements (besides `@charset`).
+
+## Installation
+
+```console
+$ npm install -D postcss-import
+```
+
+## Usage
+
+Unless your stylesheet is in the same place where you run postcss
+(`process.cwd()`), you will need to use `from` option to make relative imports
+work.
+
+```js
+// dependencies
+const fs = require("fs")
+const postcss = require("postcss")
+const atImport = require("postcss-import")
+
+// css to be processed
+const css = fs.readFileSync("css/input.css", "utf8")
+
+// process css
+postcss()
+ .use(atImport())
+ .process(css, {
+ // `from` option is needed here
+ from: "css/input.css"
+ })
+ .then((result) => {
+ const output = result.css
+
+ console.log(output)
+ })
+```
+
+`css/input.css`:
+
+```css
+/* can consume `node_modules`, `web_modules` or local modules */
+@import "cssrecipes-defaults"; /* == @import "../node_modules/cssrecipes-defaults/index.css"; */
+@import "normalize.css"; /* == @import "../node_modules/normalize.css/normalize.css"; */
+
+@import "foo.css"; /* relative to css/ according to `from` option above */
+
+@import "bar.css" (min-width: 25em);
+
+@import 'baz.css' layer(baz-layer);
+
+body {
+ background: black;
+}
+```
+
+will give you:
+
+```css
+/* ... content of ../node_modules/cssrecipes-defaults/index.css */
+/* ... content of ../node_modules/normalize.css/normalize.css */
+
+/* ... content of css/foo.css */
+
+@media (min-width: 25em) {
+/* ... content of css/bar.css */
+}
+
+@layer baz-layer {
+/* ... content of css/baz.css */
+}
+
+body {
+ background: black;
+}
+```
+
+Checkout the [tests](test) for more examples.
+
+### Options
+
+### `filter`
+Type: `Function`
+Default: `() => true`
+
+Only transform imports for which the test function returns `true`. Imports for
+which the test function returns `false` will be left as is. The function gets
+the path to import as an argument and should return a boolean.
+
+#### `root`
+
+Type: `String`
+Default: `process.cwd()` or _dirname of
+[the postcss `from`](https://github.com/postcss/postcss#node-source)_
+
+Define the root where to resolve path (eg: place where `node_modules` are).
+Should not be used that much.
+_Note: nested `@import` will additionally benefit of the relative dirname of
+imported files._
+
+#### `path`
+
+Type: `String|Array`
+Default: `[]`
+
+A string or an array of paths in where to look for files.
+
+#### `plugins`
+
+Type: `Array`
+Default: `undefined`
+
+An array of plugins to be applied on each imported files.
+
+#### `resolve`
+
+Type: `Function`
+Default: `null`
+
+You can provide a custom path resolver with this option. This function gets
+`(id, basedir, importOptions)` arguments and should return a path, an array of
+paths or a promise resolving to the path(s). If you do not return an absolute
+path, your path will be resolved to an absolute path using the default
+resolver.
+You can use [resolve](https://github.com/substack/node-resolve) for this.
+
+#### `load`
+
+Type: `Function`
+Default: null
+
+You can overwrite the default loading way by setting this option.
+This function gets `(filename, importOptions)` arguments and returns content or
+promised content.
+
+#### `skipDuplicates`
+
+Type: `Boolean`
+Default: `true`
+
+By default, similar files (based on the same content) are being skipped.
+It's to optimize output and skip similar files like `normalize.css` for example.
+If this behavior is not what you want, just set this option to `false` to
+disable it.
+
+#### `addModulesDirectories`
+
+Type: `Array`
+Default: `[]`
+
+An array of folder names to add to [Node's resolver](https://github.com/substack/node-resolve).
+Values will be appended to the default resolve directories:
+`["node_modules", "web_modules"]`.
+
+This option is only for adding additional directories to default resolver. If
+you provide your own resolver via the `resolve` configuration option above, then
+this value will be ignored.
+
+#### `nameLayer`
+
+Type: `Function`
+Default: `null`
+
+You can provide a custom naming function for anonymous layers (`@import 'baz.css' layer;`).
+This function gets `(index, rootFilename)` arguments and should return a unique string.
+
+This option only influences imports without a layer name.
+Without this option the plugin will warn on anonymous layers.
+
+#### Example with some options
+
+```js
+const postcss = require("postcss")
+const atImport = require("postcss-import")
+
+postcss()
+ .use(atImport({
+ path: ["src/css"],
+ }))
+ .process(cssString)
+ .then((result) => {
+ const { css } = result
+ })
+```
+
+## `dependency` Message Support
+
+`postcss-import` adds a message to `result.messages` for each `@import`. Messages are in the following format:
+
+```
+{
+ type: 'dependency',
+ file: absoluteFilePath,
+ parent: fileContainingTheImport
+}
+```
+
+This is mainly for use by postcss runners that implement file watching.
+
+---
+
+## CONTRIBUTING
+
+* ⇄ Pull requests and ★ Stars are always welcome.
+* For bugs and feature requests, please create an issue.
+* Pull requests must be accompanied by passing automated tests (`$ npm test`).
+
+## [Changelog](CHANGELOG.md)
+
+## [License](LICENSE)
diff --git a/node_modules/postcss-import/index.js b/node_modules/postcss-import/index.js
new file mode 100644
index 0000000..d324a7e
--- /dev/null
+++ b/node_modules/postcss-import/index.js
@@ -0,0 +1,420 @@
+"use strict"
+// builtin tooling
+const path = require("path")
+
+// internal tooling
+const joinMedia = require("./lib/join-media")
+const joinLayer = require("./lib/join-layer")
+const resolveId = require("./lib/resolve-id")
+const loadContent = require("./lib/load-content")
+const processContent = require("./lib/process-content")
+const parseStatements = require("./lib/parse-statements")
+const assignLayerNames = require("./lib/assign-layer-names")
+const dataURL = require("./lib/data-url")
+
+function AtImport(options) {
+ options = {
+ root: process.cwd(),
+ path: [],
+ skipDuplicates: true,
+ resolve: resolveId,
+ load: loadContent,
+ plugins: [],
+ addModulesDirectories: [],
+ nameLayer: null,
+ ...options,
+ }
+
+ options.root = path.resolve(options.root)
+
+ // convert string to an array of a single element
+ if (typeof options.path === "string") options.path = [options.path]
+
+ if (!Array.isArray(options.path)) options.path = []
+
+ options.path = options.path.map(p => path.resolve(options.root, p))
+
+ return {
+ postcssPlugin: "postcss-import",
+ Once(styles, { result, atRule, postcss }) {
+ const state = {
+ importedFiles: {},
+ hashFiles: {},
+ rootFilename: null,
+ anonymousLayerCounter: 0,
+ }
+
+ if (styles.source?.input?.file) {
+ state.rootFilename = styles.source.input.file
+ state.importedFiles[styles.source.input.file] = {}
+ }
+
+ if (options.plugins && !Array.isArray(options.plugins)) {
+ throw new Error("plugins option must be an array")
+ }
+
+ if (options.nameLayer && typeof options.nameLayer !== "function") {
+ throw new Error("nameLayer option must be a function")
+ }
+
+ return parseStyles(result, styles, options, state, [], []).then(
+ bundle => {
+ applyRaws(bundle)
+ applyMedia(bundle)
+ applyStyles(bundle, styles)
+ }
+ )
+
+ function applyRaws(bundle) {
+ bundle.forEach((stmt, index) => {
+ if (index === 0) return
+
+ if (stmt.parent) {
+ const { before } = stmt.parent.node.raws
+ if (stmt.type === "nodes") stmt.nodes[0].raws.before = before
+ else stmt.node.raws.before = before
+ } else if (stmt.type === "nodes") {
+ stmt.nodes[0].raws.before = stmt.nodes[0].raws.before || "\n"
+ }
+ })
+ }
+
+ function applyMedia(bundle) {
+ bundle.forEach(stmt => {
+ if (
+ (!stmt.media.length && !stmt.layer.length) ||
+ stmt.type === "charset"
+ ) {
+ return
+ }
+
+ if (stmt.layer.length > 1) {
+ assignLayerNames(stmt.layer, stmt.node, state, options)
+ }
+
+ if (stmt.type === "import") {
+ const parts = [stmt.fullUri]
+
+ const media = stmt.media.join(", ")
+
+ if (stmt.layer.length) {
+ const layerName = stmt.layer.join(".")
+
+ let layerParams = "layer"
+ if (layerName) {
+ layerParams = `layer(${layerName})`
+ }
+
+ parts.push(layerParams)
+ }
+
+ if (media) {
+ parts.push(media)
+ }
+
+ stmt.node.params = parts.join(" ")
+ } else if (stmt.type === "media") {
+ if (stmt.layer.length) {
+ const layerNode = atRule({
+ name: "layer",
+ params: stmt.layer.join("."),
+ source: stmt.node.source,
+ })
+
+ if (stmt.parentMedia?.length) {
+ const mediaNode = atRule({
+ name: "media",
+ params: stmt.parentMedia.join(", "),
+ source: stmt.node.source,
+ })
+
+ mediaNode.append(layerNode)
+ layerNode.append(stmt.node)
+ stmt.node = mediaNode
+ } else {
+ layerNode.append(stmt.node)
+ stmt.node = layerNode
+ }
+ } else {
+ stmt.node.params = stmt.media.join(", ")
+ }
+ } else {
+ const { nodes } = stmt
+ const { parent } = nodes[0]
+
+ let outerAtRule
+ let innerAtRule
+ if (stmt.media.length && stmt.layer.length) {
+ const mediaNode = atRule({
+ name: "media",
+ params: stmt.media.join(", "),
+ source: parent.source,
+ })
+
+ const layerNode = atRule({
+ name: "layer",
+ params: stmt.layer.join("."),
+ source: parent.source,
+ })
+
+ mediaNode.append(layerNode)
+ innerAtRule = layerNode
+ outerAtRule = mediaNode
+ } else if (stmt.media.length) {
+ const mediaNode = atRule({
+ name: "media",
+ params: stmt.media.join(", "),
+ source: parent.source,
+ })
+
+ innerAtRule = mediaNode
+ outerAtRule = mediaNode
+ } else if (stmt.layer.length) {
+ const layerNode = atRule({
+ name: "layer",
+ params: stmt.layer.join("."),
+ source: parent.source,
+ })
+
+ innerAtRule = layerNode
+ outerAtRule = layerNode
+ }
+
+ parent.insertBefore(nodes[0], outerAtRule)
+
+ // remove nodes
+ nodes.forEach(node => {
+ node.parent = undefined
+ })
+
+ // better output
+ nodes[0].raws.before = nodes[0].raws.before || "\n"
+
+ // wrap new rules with media query and/or layer at rule
+ innerAtRule.append(nodes)
+
+ stmt.type = "media"
+ stmt.node = outerAtRule
+ delete stmt.nodes
+ }
+ })
+ }
+
+ function applyStyles(bundle, styles) {
+ styles.nodes = []
+
+ // Strip additional statements.
+ bundle.forEach(stmt => {
+ if (["charset", "import", "media"].includes(stmt.type)) {
+ stmt.node.parent = undefined
+ styles.append(stmt.node)
+ } else if (stmt.type === "nodes") {
+ stmt.nodes.forEach(node => {
+ node.parent = undefined
+ styles.append(node)
+ })
+ }
+ })
+ }
+
+ function parseStyles(result, styles, options, state, media, layer) {
+ const statements = parseStatements(result, styles)
+
+ return Promise.resolve(statements)
+ .then(stmts => {
+ // process each statement in series
+ return stmts.reduce((promise, stmt) => {
+ return promise.then(() => {
+ stmt.media = joinMedia(media, stmt.media || [])
+ stmt.parentMedia = media
+ stmt.layer = joinLayer(layer, stmt.layer || [])
+
+ // skip protocol base uri (protocol://url) or protocol-relative
+ if (
+ stmt.type !== "import" ||
+ /^(?:[a-z]+:)?\/\//i.test(stmt.uri)
+ ) {
+ return
+ }
+
+ if (options.filter && !options.filter(stmt.uri)) {
+ // rejected by filter
+ return
+ }
+
+ return resolveImportId(result, stmt, options, state)
+ })
+ }, Promise.resolve())
+ })
+ .then(() => {
+ let charset
+ const imports = []
+ const bundle = []
+
+ function handleCharset(stmt) {
+ if (!charset) charset = stmt
+ // charsets aren't case-sensitive, so convert to lower case to compare
+ else if (
+ stmt.node.params.toLowerCase() !==
+ charset.node.params.toLowerCase()
+ ) {
+ throw new Error(
+ `Incompatable @charset statements:
+ ${stmt.node.params} specified in ${stmt.node.source.input.file}
+ ${charset.node.params} specified in ${charset.node.source.input.file}`
+ )
+ }
+ }
+
+ // squash statements and their children
+ statements.forEach(stmt => {
+ if (stmt.type === "charset") handleCharset(stmt)
+ else if (stmt.type === "import") {
+ if (stmt.children) {
+ stmt.children.forEach((child, index) => {
+ if (child.type === "import") imports.push(child)
+ else if (child.type === "charset") handleCharset(child)
+ else bundle.push(child)
+ // For better output
+ if (index === 0) child.parent = stmt
+ })
+ } else imports.push(stmt)
+ } else if (stmt.type === "media" || stmt.type === "nodes") {
+ bundle.push(stmt)
+ }
+ })
+
+ return charset
+ ? [charset, ...imports.concat(bundle)]
+ : imports.concat(bundle)
+ })
+ }
+
+ function resolveImportId(result, stmt, options, state) {
+ if (dataURL.isValid(stmt.uri)) {
+ return loadImportContent(result, stmt, stmt.uri, options, state).then(
+ result => {
+ stmt.children = result
+ }
+ )
+ }
+
+ const atRule = stmt.node
+ let sourceFile
+ if (atRule.source?.input?.file) {
+ sourceFile = atRule.source.input.file
+ }
+ const base = sourceFile
+ ? path.dirname(atRule.source.input.file)
+ : options.root
+
+ return Promise.resolve(options.resolve(stmt.uri, base, options))
+ .then(paths => {
+ if (!Array.isArray(paths)) paths = [paths]
+ // Ensure that each path is absolute:
+ return Promise.all(
+ paths.map(file => {
+ return !path.isAbsolute(file)
+ ? resolveId(file, base, options)
+ : file
+ })
+ )
+ })
+ .then(resolved => {
+ // Add dependency messages:
+ resolved.forEach(file => {
+ result.messages.push({
+ type: "dependency",
+ plugin: "postcss-import",
+ file,
+ parent: sourceFile,
+ })
+ })
+
+ return Promise.all(
+ resolved.map(file => {
+ return loadImportContent(result, stmt, file, options, state)
+ })
+ )
+ })
+ .then(result => {
+ // Merge loaded statements
+ stmt.children = result.reduce((result, statements) => {
+ return statements ? result.concat(statements) : result
+ }, [])
+ })
+ }
+
+ function loadImportContent(result, stmt, filename, options, state) {
+ const atRule = stmt.node
+ const { media, layer } = stmt
+
+ assignLayerNames(layer, atRule, state, options)
+
+ if (options.skipDuplicates) {
+ // skip files already imported at the same scope
+ if (state.importedFiles[filename]?.[media]?.[layer]) {
+ return
+ }
+
+ // save imported files to skip them next time
+ if (!state.importedFiles[filename]) {
+ state.importedFiles[filename] = {}
+ }
+ if (!state.importedFiles[filename][media]) {
+ state.importedFiles[filename][media] = {}
+ }
+ state.importedFiles[filename][media][layer] = true
+ }
+
+ return Promise.resolve(options.load(filename, options)).then(
+ content => {
+ if (content.trim() === "") {
+ result.warn(`${filename} is empty`, { node: atRule })
+ return
+ }
+
+ // skip previous imported files not containing @import rules
+ if (state.hashFiles[content]?.[media]?.[layer]) {
+ return
+ }
+
+ return processContent(
+ result,
+ content,
+ filename,
+ options,
+ postcss
+ ).then(importedResult => {
+ const styles = importedResult.root
+ result.messages = result.messages.concat(importedResult.messages)
+
+ if (options.skipDuplicates) {
+ const hasImport = styles.some(child => {
+ return child.type === "atrule" && child.name === "import"
+ })
+ if (!hasImport) {
+ // save hash files to skip them next time
+ if (!state.hashFiles[content]) {
+ state.hashFiles[content] = {}
+ }
+ if (!state.hashFiles[content][media]) {
+ state.hashFiles[content][media] = {}
+ }
+ state.hashFiles[content][media][layer] = true
+ }
+ }
+
+ // recursion: import @import from imported file
+ return parseStyles(result, styles, options, state, media, layer)
+ })
+ }
+ )
+ }
+ },
+ }
+}
+
+AtImport.postcss = true
+
+module.exports = AtImport
diff --git a/node_modules/postcss-import/package.json b/node_modules/postcss-import/package.json
new file mode 100644
index 0000000..a81ea5f
--- /dev/null
+++ b/node_modules/postcss-import/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "postcss-import",
+ "version": "15.1.0",
+ "description": "PostCSS plugin to import CSS files",
+ "keywords": [
+ "css",
+ "postcss",
+ "postcss-plugin",
+ "import",
+ "node modules",
+ "npm"
+ ],
+ "author": "Maxime Thirouin",
+ "license": "MIT",
+ "repository": "https://github.com/postcss/postcss-import.git",
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "dependencies": {
+ "postcss-value-parser": "^4.0.0",
+ "read-cache": "^1.0.0",
+ "resolve": "^1.1.7"
+ },
+ "devDependencies": {
+ "ava": "^5.0.0",
+ "eslint": "^8.2.0",
+ "eslint-config-problems": "^7.0.0",
+ "eslint-plugin-prettier": "^4.0.0",
+ "postcss": "^8.0.0",
+ "postcss-scss": "^4.0.0",
+ "prettier": "~2.8.0",
+ "sugarss": "^4.0.0"
+ },
+ "peerDependencies": {
+ "postcss": "^8.0.0"
+ },
+ "scripts": {
+ "ci": "eslint . && ava",
+ "lint": "eslint . --fix",
+ "pretest": "npm run lint",
+ "test": "ava"
+ },
+ "eslintConfig": {
+ "extends": "eslint-config-problems",
+ "env": {
+ "node": true
+ },
+ "plugins": [
+ "prettier"
+ ],
+ "rules": {
+ "prettier/prettier": [
+ "error",
+ {
+ "semi": false,
+ "arrowParens": "avoid"
+ }
+ ]
+ }
+ }
+}
diff --git a/node_modules/postcss-js/LICENSE b/node_modules/postcss-js/LICENSE
new file mode 100644
index 0000000..d3bd672
--- /dev/null
+++ b/node_modules/postcss-js/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2015 Andrey Sitnik
+
+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/postcss-js/README.md b/node_modules/postcss-js/README.md
new file mode 100644
index 0000000..a29e3b0
--- /dev/null
+++ b/node_modules/postcss-js/README.md
@@ -0,0 +1,22 @@
+# PostCSS JS
+
+
+
+[PostCSS] for CSS-in-JS and styles in JS objects.
+
+For example, to use [Stylelint] or [RTLCSS] plugins in your workflow.
+
+
+
+
+
+[Stylelint]: https://github.com/stylelint/stylelint
+[PostCSS]: https://github.com/postcss/postcss
+[RTLCSS]: https://github.com/MohammadYounes/rtlcss
+
+
+## Docs
+Read full docs **[here](https://github.com/postcss/postcss-js#readme)**.
diff --git a/node_modules/postcss-js/async.js b/node_modules/postcss-js/async.js
new file mode 100644
index 0000000..4c2f3c6
--- /dev/null
+++ b/node_modules/postcss-js/async.js
@@ -0,0 +1,15 @@
+let postcss = require('postcss')
+
+let processResult = require('./process-result')
+let parse = require('./parser')
+
+module.exports = function async(plugins) {
+ let processor = postcss(plugins)
+ return async input => {
+ let result = await processor.process(input, {
+ parser: parse,
+ from: undefined
+ })
+ return processResult(result)
+ }
+}
diff --git a/node_modules/postcss-js/index.js b/node_modules/postcss-js/index.js
new file mode 100644
index 0000000..8a4274e
--- /dev/null
+++ b/node_modules/postcss-js/index.js
@@ -0,0 +1,11 @@
+let objectify = require('./objectifier')
+let parse = require('./parser')
+let async = require('./async')
+let sync = require('./sync')
+
+module.exports = {
+ objectify,
+ parse,
+ async,
+ sync
+}
diff --git a/node_modules/postcss-js/index.mjs b/node_modules/postcss-js/index.mjs
new file mode 100644
index 0000000..d14b61c
--- /dev/null
+++ b/node_modules/postcss-js/index.mjs
@@ -0,0 +1,8 @@
+import index from './index.js'
+
+export default index
+
+export const objectify = index.objectify
+export const parse = index.parse
+export const async = index.async
+export const sync = index.sync
diff --git a/node_modules/postcss-js/objectifier.js b/node_modules/postcss-js/objectifier.js
new file mode 100644
index 0000000..a4708b8
--- /dev/null
+++ b/node_modules/postcss-js/objectifier.js
@@ -0,0 +1,85 @@
+let camelcase = require('camelcase-css')
+
+let UNITLESS = {
+ boxFlex: true,
+ boxFlexGroup: true,
+ columnCount: true,
+ flex: true,
+ flexGrow: true,
+ flexPositive: true,
+ flexShrink: true,
+ flexNegative: true,
+ fontWeight: true,
+ lineClamp: true,
+ lineHeight: true,
+ opacity: true,
+ order: true,
+ orphans: true,
+ tabSize: true,
+ widows: true,
+ zIndex: true,
+ zoom: true,
+ fillOpacity: true,
+ strokeDashoffset: true,
+ strokeOpacity: true,
+ strokeWidth: true
+}
+
+function atRule(node) {
+ if (typeof node.nodes === 'undefined') {
+ return true
+ } else {
+ return process(node)
+ }
+}
+
+function process(node) {
+ let name
+ let result = {}
+
+ node.each(child => {
+ if (child.type === 'atrule') {
+ name = '@' + child.name
+ if (child.params) name += ' ' + child.params
+ if (typeof result[name] === 'undefined') {
+ result[name] = atRule(child)
+ } else if (Array.isArray(result[name])) {
+ result[name].push(atRule(child))
+ } else {
+ result[name] = [result[name], atRule(child)]
+ }
+ } else if (child.type === 'rule') {
+ let body = process(child)
+ if (result[child.selector]) {
+ for (let i in body) {
+ result[child.selector][i] = body[i]
+ }
+ } else {
+ result[child.selector] = body
+ }
+ } else if (child.type === 'decl') {
+ if (child.prop[0] === '-' && child.prop[1] === '-') {
+ name = child.prop
+ } else if (child.parent && child.parent.selector === ':export') {
+ name = child.prop
+ } else {
+ name = camelcase(child.prop)
+ }
+ let value = child.value
+ if (!isNaN(child.value) && UNITLESS[name]) {
+ value = parseFloat(child.value)
+ }
+ if (child.important) value += ' !important'
+ if (typeof result[name] === 'undefined') {
+ result[name] = value
+ } else if (Array.isArray(result[name])) {
+ result[name].push(value)
+ } else {
+ result[name] = [result[name], value]
+ }
+ }
+ })
+ return result
+}
+
+module.exports = process
diff --git a/node_modules/postcss-js/package.json b/node_modules/postcss-js/package.json
new file mode 100644
index 0000000..ce0ff35
--- /dev/null
+++ b/node_modules/postcss-js/package.json
@@ -0,0 +1,42 @@
+{
+ "name": "postcss-js",
+ "version": "4.0.1",
+ "description": "PostCSS for CSS-in-JS and styles in JS objects",
+ "keywords": [
+ "postcss",
+ "postcss-runner",
+ "js",
+ "inline",
+ "react",
+ "css",
+ "cssinjs"
+ ],
+ "author": "Andrey Sitnik ",
+ "license": "MIT",
+ "repository": "postcss/postcss-js",
+ "engines": {
+ "node": "^12 || ^14 || >= 16"
+ },
+ "exports": {
+ ".": {
+ "require": "./index.js",
+ "import": "./index.mjs"
+ },
+ "./package.json": "./package.json",
+ "./async": "./async.js",
+ "./objectifier": "./objectifier.js",
+ "./parser": "./parser.js",
+ "./process-result": "./process-result.js",
+ "./sync": "./sync.js"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ "peerDependencies": {
+ "postcss": "^8.4.21"
+ },
+ "dependencies": {
+ "camelcase-css": "^2.0.1"
+ }
+}
diff --git a/node_modules/postcss-js/parser.js b/node_modules/postcss-js/parser.js
new file mode 100644
index 0000000..17ae264
--- /dev/null
+++ b/node_modules/postcss-js/parser.js
@@ -0,0 +1,104 @@
+let postcss = require('postcss')
+
+let IMPORTANT = /\s*!important\s*$/i
+
+let UNITLESS = {
+ 'box-flex': true,
+ 'box-flex-group': true,
+ 'column-count': true,
+ 'flex': true,
+ 'flex-grow': true,
+ 'flex-positive': true,
+ 'flex-shrink': true,
+ 'flex-negative': true,
+ 'font-weight': true,
+ 'line-clamp': true,
+ 'line-height': true,
+ 'opacity': true,
+ 'order': true,
+ 'orphans': true,
+ 'tab-size': true,
+ 'widows': true,
+ 'z-index': true,
+ 'zoom': true,
+ 'fill-opacity': true,
+ 'stroke-dashoffset': true,
+ 'stroke-opacity': true,
+ 'stroke-width': true
+}
+
+function dashify(str) {
+ return str
+ .replace(/([A-Z])/g, '-$1')
+ .replace(/^ms-/, '-ms-')
+ .toLowerCase()
+}
+
+function decl(parent, name, value) {
+ if (value === false || value === null) return
+
+ if (!name.startsWith('--')) {
+ name = dashify(name)
+ }
+
+ if (typeof value === 'number') {
+ if (value === 0 || UNITLESS[name]) {
+ value = value.toString()
+ } else {
+ value += 'px'
+ }
+ }
+
+ if (name === 'css-float') name = 'float'
+
+ if (IMPORTANT.test(value)) {
+ value = value.replace(IMPORTANT, '')
+ parent.push(postcss.decl({ prop: name, value, important: true }))
+ } else {
+ parent.push(postcss.decl({ prop: name, value }))
+ }
+}
+
+function atRule(parent, parts, value) {
+ let node = postcss.atRule({ name: parts[1], params: parts[3] || '' })
+ if (typeof value === 'object') {
+ node.nodes = []
+ parse(value, node)
+ }
+ parent.push(node)
+}
+
+function parse(obj, parent) {
+ let name, value, node
+ for (name in obj) {
+ value = obj[name]
+ if (value === null || typeof value === 'undefined') {
+ continue
+ } else if (name[0] === '@') {
+ let parts = name.match(/@(\S+)(\s+([\W\w]*)\s*)?/)
+ if (Array.isArray(value)) {
+ for (let i of value) {
+ atRule(parent, parts, i)
+ }
+ } else {
+ atRule(parent, parts, value)
+ }
+ } else if (Array.isArray(value)) {
+ for (let i of value) {
+ decl(parent, name, i)
+ }
+ } else if (typeof value === 'object') {
+ node = postcss.rule({ selector: name })
+ parse(value, node)
+ parent.push(node)
+ } else {
+ decl(parent, name, value)
+ }
+ }
+}
+
+module.exports = function (obj) {
+ let root = postcss.root()
+ parse(obj, root)
+ return root
+}
diff --git a/node_modules/postcss-js/process-result.js b/node_modules/postcss-js/process-result.js
new file mode 100644
index 0000000..215a95c
--- /dev/null
+++ b/node_modules/postcss-js/process-result.js
@@ -0,0 +1,11 @@
+let objectify = require('./objectifier')
+
+module.exports = function processResult(result) {
+ if (console && console.warn) {
+ result.warnings().forEach(warn => {
+ let source = warn.plugin || 'PostCSS'
+ console.warn(source + ': ' + warn.text)
+ })
+ }
+ return objectify(result.root)
+}
diff --git a/node_modules/postcss-js/sync.js b/node_modules/postcss-js/sync.js
new file mode 100644
index 0000000..745bd27
--- /dev/null
+++ b/node_modules/postcss-js/sync.js
@@ -0,0 +1,12 @@
+let postcss = require('postcss')
+
+let processResult = require('./process-result')
+let parse = require('./parser')
+
+module.exports = function (plugins) {
+ let processor = postcss(plugins)
+ return input => {
+ let result = processor.process(input, { parser: parse, from: undefined })
+ return processResult(result)
+ }
+}
diff --git a/node_modules/postcss-load-config/LICENSE b/node_modules/postcss-load-config/LICENSE
new file mode 100644
index 0000000..458e8a3
--- /dev/null
+++ b/node_modules/postcss-load-config/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright Michael Ciniawsky
+
+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/postcss-load-config/README.md b/node_modules/postcss-load-config/README.md
new file mode 100644
index 0000000..9de4de2
--- /dev/null
+++ b/node_modules/postcss-load-config/README.md
@@ -0,0 +1,466 @@
+
+
+
+
+
+ 
+
+
+
Load Config
+
Install
+
+```bash
+npm i -D postcss-load-config
+```
+
+Usage
+
+```bash
+npm i -S|-D postcss-plugin
+```
+
+Install all required PostCSS plugins and save them to your **package.json** `dependencies`/`devDependencies`
+
+Then create a PostCSS config file by choosing one of the following formats
+
+### `package.json`
+
+Create a **`postcss`** section in your project's **`package.json`**
+
+```
+Project (Root)
+ |– client
+ |– public
+ |
+ |- package.json
+```
+
+```json
+{
+ "postcss": {
+ "parser": "sugarss",
+ "map": false,
+ "plugins": {
+ "postcss-plugin": {}
+ }
+ }
+}
+```
+
+### `.postcssrc`
+
+Create a **`.postcssrc`** file in JSON or YAML format
+
+> ℹ️ It's recommended to use an extension (e.g **`.postcssrc.json`** or **`.postcssrc.yml`**) instead of `.postcssrc`
+
+```
+Project (Root)
+ |– client
+ |– public
+ |
+ |- (.postcssrc|.postcssrc.json|.postcssrc.yml)
+ |- package.json
+```
+
+**`.postcssrc.json`**
+```json
+{
+ "parser": "sugarss",
+ "map": false,
+ "plugins": {
+ "postcss-plugin": {}
+ }
+}
+```
+
+**`.postcssrc.yml`**
+```yaml
+parser: sugarss
+map: false
+plugins:
+ postcss-plugin: {}
+```
+
+### `.postcssrc.js` or `postcss.config.js`
+
+You may need some logic within your config.
+In this case create JS file named:
+- `.postcssrc.js`
+- `.postcssrc.mjs`
+- `.postcssrc.cjs`
+- `.postcssrc.ts`
+- `.postcssrc.cts`
+- `postcss.config.js`
+- `postcss.config.mjs`
+- `postcss.config.cjs`
+- `postcss.config.ts`
+- `postcss.config.cts`
+
+```
+Project (Root)
+ |– client
+ |– public
+ |- (.postcssrc|postcss.config).(js|mjs|cjs|ts|cts)
+ |- package.json
+```
+
+You can export the config as an `{Object}`
+
+**.postcssrc.js**
+```js
+module.exports = {
+ parser: 'sugarss',
+ map: false,
+ plugins: {
+ 'postcss-plugin': {}
+ }
+}
+```
+
+Or export a `{Function}` that returns the config (more about the `ctx` param below)
+
+**.postcssrc.js**
+```js
+module.exports = (ctx) => ({
+ parser: ctx.parser ? 'sugarss' : false,
+ map: ctx.env === 'development' ? ctx.map : false,
+ plugins: {
+ 'postcss-plugin': ctx.options.plugin
+ }
+})
+```
+
+Plugins can be loaded either using an `{Object}` or an `{Array}`
+
+#### `{Object}`
+
+**.postcssrc.js**
+```js
+module.exports = ({ env }) => ({
+ ...options,
+ plugins: {
+ 'postcss-plugin': env === 'production' ? {} : false
+ }
+})
+```
+
+> ℹ️ When using an `{Object}`, the key can be a Node.js module name, a path to a JavaScript file that is relative to the directory of the PostCSS config file, or an absolute path to a JavaScript file.
+
+#### `{Array}`
+
+**.postcssrc.js**
+```js
+module.exports = ({ env }) => ({
+ ...options,
+ plugins: [
+ env === 'production' ? require('postcss-plugin')() : false
+ ]
+})
+```
+> :warning: When using an `{Array}`, make sure to `require()` each plugin
+
+Options
+
+|Name|Type|Default|Description|
+|:--:|:--:|:-----:|:----------|
+|[**`to`**](#to)|`{String}`|`undefined`|Destination File Path|
+|[**`map`**](#map)|`{String\|Object}`|`false`|Enable/Disable Source Maps|
+|[**`from`**](#from)|`{String}`|`undefined`|Source File Path|
+|[**`parser`**](#parser)|`{String\|Function}`|`false`|Custom PostCSS Parser|
+|[**`syntax`**](#syntax)|`{String\|Function}`|`false`|Custom PostCSS Syntax|
+|[**`stringifier`**](#stringifier)|`{String\|Function}`|`false`|Custom PostCSS Stringifier|
+
+### `parser`
+
+**.postcssrc.js**
+```js
+module.exports = {
+ parser: 'sugarss'
+}
+```
+
+### `syntax`
+
+**.postcssrc.js**
+```js
+module.exports = {
+ syntax: 'postcss-scss'
+}
+```
+
+### `stringifier`
+
+**.postcssrc.js**
+```js
+module.exports = {
+ stringifier: 'midas'
+}
+```
+
+### [**`map`**](https://github.com/postcss/postcss/blob/master/docs/source-maps.md)
+
+**.postcssrc.js**
+```js
+module.exports = {
+ map: 'inline'
+}
+```
+
+> :warning: In most cases `options.from` && `options.to` are set by the third-party which integrates this package (CLI, gulp, webpack). It's unlikely one needs to set/use `options.from` && `options.to` within a config file. Unless you're a third-party plugin author using this module and its Node API directly **dont't set `options.from` && `options.to` yourself**
+
+### `to`
+
+```js
+module.exports = {
+ to: 'path/to/dest.css'
+}
+```
+
+### `from`
+
+```js
+module.exports = {
+ from: 'path/to/src.css'
+}
+```
+
+Plugins
+
+### `{} || null`
+
+The plugin will be loaded with defaults
+
+```js
+'postcss-plugin': {} || null
+```
+
+**.postcssrc.js**
+```js
+module.exports = {
+ plugins: {
+ 'postcss-plugin': {} || null
+ }
+}
+```
+
+> :warning: `{}` must be an **empty** `{Object}` literal
+
+### `{Object}`
+
+The plugin will be loaded with given options
+
+```js
+'postcss-plugin': { option: '', option: '' }
+```
+
+**.postcssrc.js**
+```js
+module.exports = {
+ plugins: {
+ 'postcss-plugin': { option: '', option: '' }
+ }
+}
+```
+
+### `false`
+
+The plugin will not be loaded
+
+```js
+'postcss-plugin': false
+```
+
+**.postcssrc.js**
+```js
+module.exports = {
+ plugins: {
+ 'postcss-plugin': false
+ }
+}
+```
+
+### `Ordering`
+
+Plugin **execution order** is determined by declaration in the plugins section (**top-down**)
+
+```js
+{
+ plugins: {
+ 'postcss-plugin': {}, // [0]
+ 'postcss-plugin': {}, // [1]
+ 'postcss-plugin': {} // [2]
+ }
+}
+```
+
+Context
+
+When using a `{Function}` (`postcss.config.js` or `.postcssrc.js`), it's possible to pass context to `postcss-load-config`, which will be evaluated while loading your config. By default `ctx.env (process.env.NODE_ENV)` and `ctx.cwd (process.cwd())` are available on the `ctx` `{Object}`
+
+> ℹ️ Most third-party integrations add additional properties to the `ctx` (e.g `postcss-loader`). Check the specific module's README for more information about what is available on the respective `ctx`
+
+Examples
+
+**postcss.config.js**
+
+```js
+module.exports = (ctx) => ({
+ parser: ctx.parser ? 'sugarss' : false,
+ map: ctx.env === 'development' ? ctx.map : false,
+ plugins: {
+ 'postcss-import': {},
+ 'postcss-nested': {},
+ cssnano: ctx.env === 'production' ? {} : false
+ }
+})
+```
+
+
+
+
+
+
+
+
Maintainers
+
+
+
+Contributors
+
+=14"
+ }
+}
diff --git a/node_modules/postcss-load-config/node_modules/lilconfig/readme.md b/node_modules/postcss-load-config/node_modules/lilconfig/readme.md
new file mode 100644
index 0000000..99c4262
--- /dev/null
+++ b/node_modules/postcss-load-config/node_modules/lilconfig/readme.md
@@ -0,0 +1,98 @@
+# Lilconfig ⚙️
+[](https://badge.fury.io/js/lilconfig)
+[](https://packagephobia.now.sh/result?p=lilconfig)
+[](https://coveralls.io/github/antonk52/lilconfig)
+
+A zero-dependency alternative to [cosmiconfig](https://www.npmjs.com/package/cosmiconfig) with the same API.
+
+## Installation
+
+```sh
+npm install lilconfig
+```
+
+## Usage
+
+```js
+import {lilconfig, lilconfigSync} from 'lilconfig';
+
+// all keys are optional
+const options = {
+ stopDir: '/Users/you/some/dir',
+ searchPlaces: ['package.json', 'myapp.conf.js'],
+ ignoreEmptySearchPlaces: false
+}
+
+lilconfig(
+ 'myapp',
+ options // optional
+).search() // Promise
+
+lilconfigSync(
+ 'myapp',
+ options // optional
+).load(pathToConfig) // LilconfigResult
+
+/**
+ * LilconfigResult
+ * {
+ * config: any; // your config
+ * filepath: string;
+ * }
+ */
+```
+
+## ESM
+
+ESM configs can be loaded with **async API only**. Specifically `js` files in projects with `"type": "module"` in `package.json` or `mjs` files.
+
+## Difference to `cosmiconfig`
+Lilconfig does not intend to be 100% compatible with `cosmiconfig` but tries to mimic it where possible. The key difference is **no** support for yaml files out of the box(`lilconfig` attempts to parse files with no extension as JSON instead of YAML). You can still add the support for YAML files by providing a loader, see an [example](#yaml-loader) below.
+
+### Options difference between the two.
+
+|cosmiconfig option | lilconfig |
+|------------------------|-----------|
+|cache | ✅ |
+|loaders | ✅ |
+|ignoreEmptySearchPlaces | ✅ |
+|packageProp | ✅ |
+|searchPlaces | ✅ |
+|stopDir | ✅ |
+|transform | ✅ |
+
+## Loaders examples
+
+### Yaml loader
+
+If you need the YAML support you can provide your own loader
+
+```js
+import {lilconfig} from 'lilconfig';
+import yaml from 'yaml';
+
+function loadYaml(filepath, content) {
+ return yaml.parse(content);
+}
+
+const options = {
+ loaders: {
+ '.yaml': loadYaml,
+ '.yml': loadYaml,
+ // loader for files with no extension
+ noExt: loadYaml
+ }
+};
+
+lilconfig('myapp', options)
+ .search()
+ .then(result => {
+ result // {config, filepath}
+ });
+```
+
+## Version correlation
+
+- lilconig v1 → cosmiconfig v6
+- lilconig v2 → cosmiconfig v7
+- lilconig v3 → cosmiconfig v8
diff --git a/node_modules/postcss-load-config/node_modules/lilconfig/src/index.d.ts b/node_modules/postcss-load-config/node_modules/lilconfig/src/index.d.ts
new file mode 100644
index 0000000..fa1146b
--- /dev/null
+++ b/node_modules/postcss-load-config/node_modules/lilconfig/src/index.d.ts
@@ -0,0 +1,54 @@
+export type LilconfigResult = null | {
+ filepath: string;
+ config: any;
+ isEmpty?: boolean;
+};
+interface OptionsBase {
+ cache?: boolean;
+ stopDir?: string;
+ searchPlaces?: string[];
+ ignoreEmptySearchPlaces?: boolean;
+ packageProp?: string | string[];
+}
+export type Transform =
+ | TransformSync
+ | ((result: LilconfigResult) => Promise);
+export type TransformSync = (result: LilconfigResult) => LilconfigResult;
+type LoaderResult = any;
+export type LoaderSync = (filepath: string, content: string) => LoaderResult;
+export type Loader =
+ | LoaderSync
+ | ((filepath: string, content: string) => Promise);
+export type Loaders = Record;
+export type LoadersSync = Record;
+export interface Options extends OptionsBase {
+ loaders?: Loaders;
+ transform?: Transform;
+}
+export interface OptionsSync extends OptionsBase {
+ loaders?: LoadersSync;
+ transform?: TransformSync;
+}
+export declare const defaultLoadersSync: LoadersSync;
+export declare const defaultLoaders: Loaders;
+type ClearCaches = {
+ clearLoadCache: () => void;
+ clearSearchCache: () => void;
+ clearCaches: () => void;
+};
+type AsyncSearcher = {
+ search(searchFrom?: string): Promise;
+ load(filepath: string): Promise;
+} & ClearCaches;
+export declare function lilconfig(
+ name: string,
+ options?: Partial,
+): AsyncSearcher;
+type SyncSearcher = {
+ search(searchFrom?: string): LilconfigResult;
+ load(filepath: string): LilconfigResult;
+} & ClearCaches;
+export declare function lilconfigSync(
+ name: string,
+ options?: OptionsSync,
+): SyncSearcher;
diff --git a/node_modules/postcss-load-config/node_modules/lilconfig/src/index.js b/node_modules/postcss-load-config/node_modules/lilconfig/src/index.js
new file mode 100644
index 0000000..c4d055b
--- /dev/null
+++ b/node_modules/postcss-load-config/node_modules/lilconfig/src/index.js
@@ -0,0 +1,457 @@
+// @ts-check
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const fsReadFileAsync = fs.promises.readFile;
+
+/** @type {(name: string, sync: boolean) => string[]} */
+function getDefaultSearchPlaces(name, sync) {
+ return [
+ 'package.json',
+ `.${name}rc.json`,
+ `.${name}rc.js`,
+ `.${name}rc.cjs`,
+ ...(sync ? [] : [`.${name}rc.mjs`]),
+ `.config/${name}rc`,
+ `.config/${name}rc.json`,
+ `.config/${name}rc.js`,
+ `.config/${name}rc.cjs`,
+ ...(sync ? [] : [`.config/${name}rc.mjs`]),
+ `${name}.config.js`,
+ `${name}.config.cjs`,
+ ...(sync ? [] : [`${name}.config.mjs`]),
+ ];
+}
+
+/**
+ * @type {(p: string) => string}
+ *
+ * see #17
+ * On *nix, if cwd is not under homedir,
+ * the last path will be '', ('/build' -> '')
+ * but it should be '/' actually.
+ * And on Windows, this will never happen. ('C:\build' -> 'C:')
+ */
+function parentDir(p) {
+ return path.dirname(p) || path.sep;
+}
+
+/** @type {import('./index').LoaderSync} */
+const jsonLoader = (_, content) => JSON.parse(content);
+// Use plain require in webpack context for dynamic import
+const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+/** @type {import('./index').LoadersSync} */
+const defaultLoadersSync = Object.freeze({
+ '.js': requireFunc,
+ '.json': requireFunc,
+ '.cjs': requireFunc,
+ noExt: jsonLoader,
+});
+module.exports.defaultLoadersSync = defaultLoadersSync;
+
+/** @type {import('./index').Loader} */
+const dynamicImport = async id => {
+ try {
+ const mod = await import(/* webpackIgnore: true */ id);
+
+ return mod.default;
+ } catch (e) {
+ try {
+ return requireFunc(id);
+ } catch (/** @type {any} */ requireE) {
+ if (
+ requireE.code === 'ERR_REQUIRE_ESM' ||
+ (requireE instanceof SyntaxError &&
+ requireE
+ .toString()
+ .includes('Cannot use import statement outside a module'))
+ ) {
+ throw e;
+ }
+ throw requireE;
+ }
+ }
+};
+
+/** @type {import('./index').Loaders} */
+const defaultLoaders = Object.freeze({
+ '.js': dynamicImport,
+ '.mjs': dynamicImport,
+ '.cjs': dynamicImport,
+ '.json': jsonLoader,
+ noExt: jsonLoader,
+});
+module.exports.defaultLoaders = defaultLoaders;
+
+/**
+ * @param {string} name
+ * @param {import('./index').Options | import('./index').OptionsSync} options
+ * @param {boolean} sync
+ * @returns {Required}
+ */
+function getOptions(name, options, sync) {
+ /** @type {Required} */
+ const conf = {
+ stopDir: os.homedir(),
+ searchPlaces: getDefaultSearchPlaces(name, sync),
+ ignoreEmptySearchPlaces: true,
+ cache: true,
+ transform: x => x,
+ packageProp: [name],
+ ...options,
+ loaders: {
+ ...(sync ? defaultLoadersSync : defaultLoaders),
+ ...options.loaders,
+ },
+ };
+ conf.searchPlaces.forEach(place => {
+ const key = path.extname(place) || 'noExt';
+ const loader = conf.loaders[key];
+ if (!loader) {
+ throw new Error(`Missing loader for extension "${place}"`);
+ }
+
+ if (typeof loader !== 'function') {
+ throw new Error(
+ `Loader for extension "${place}" is not a function: Received ${typeof loader}.`,
+ );
+ }
+ });
+
+ return conf;
+}
+
+/** @type {(props: string | string[], obj: Record) => unknown} */
+function getPackageProp(props, obj) {
+ if (typeof props === 'string' && props in obj) return obj[props];
+ return (
+ (Array.isArray(props) ? props : props.split('.')).reduce(
+ (acc, prop) => (acc === undefined ? acc : acc[prop]),
+ obj,
+ ) || null
+ );
+}
+
+/** @param {string} filepath */
+function validateFilePath(filepath) {
+ if (!filepath) throw new Error('load must pass a non-empty string');
+}
+
+/** @type {(loader: import('./index').Loader, ext: string) => void} */
+function validateLoader(loader, ext) {
+ if (!loader) throw new Error(`No loader specified for extension "${ext}"`);
+ if (typeof loader !== 'function') throw new Error('loader is not a function');
+}
+
+/** @type {(enableCache: boolean) => (c: Map, filepath: string, res: T) => T} */
+const makeEmplace = enableCache => (c, filepath, res) => {
+ if (enableCache) c.set(filepath, res);
+ return res;
+};
+
+/** @type {import('./index').lilconfig} */
+module.exports.lilconfig = function lilconfig(name, options) {
+ const {
+ ignoreEmptySearchPlaces,
+ loaders,
+ packageProp,
+ searchPlaces,
+ stopDir,
+ transform,
+ cache,
+ } = getOptions(name, options ?? {}, false);
+ const searchCache = new Map();
+ const loadCache = new Map();
+ const emplace = makeEmplace(cache);
+
+ return {
+ async search(searchFrom = process.cwd()) {
+ /** @type {import('./index').LilconfigResult} */
+ const result = {
+ config: null,
+ filepath: '',
+ };
+
+ /** @type {Set} */
+ const visited = new Set();
+ let dir = searchFrom;
+ dirLoop: while (true) {
+ if (cache) {
+ const r = searchCache.get(dir);
+ if (r !== undefined) {
+ for (const p of visited) searchCache.set(p, r);
+ return r;
+ }
+ visited.add(dir);
+ }
+
+ for (const searchPlace of searchPlaces) {
+ const filepath = path.join(dir, searchPlace);
+ try {
+ await fs.promises.access(filepath);
+ } catch {
+ continue;
+ }
+ const content = String(await fsReadFileAsync(filepath));
+ const loaderKey = path.extname(searchPlace) || 'noExt';
+ const loader = loaders[loaderKey];
+
+ // handle package.json
+ if (searchPlace === 'package.json') {
+ const pkg = await loader(filepath, content);
+ const maybeConfig = getPackageProp(packageProp, pkg);
+ if (maybeConfig != null) {
+ result.config = maybeConfig;
+ result.filepath = filepath;
+ break dirLoop;
+ }
+
+ continue;
+ }
+
+ // handle other type of configs
+ const isEmpty = content.trim() === '';
+ if (isEmpty && ignoreEmptySearchPlaces) continue;
+
+ if (isEmpty) {
+ result.isEmpty = true;
+ result.config = undefined;
+ } else {
+ validateLoader(loader, loaderKey);
+ result.config = await loader(filepath, content);
+ }
+ result.filepath = filepath;
+ break dirLoop;
+ }
+ if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+ dir = parentDir(dir);
+ }
+
+ const transformed =
+ // not found
+ result.filepath === '' && result.config === null
+ ? transform(null)
+ : transform(result);
+
+ if (cache) {
+ for (const p of visited) searchCache.set(p, transformed);
+ }
+
+ return transformed;
+ },
+ async load(filepath) {
+ validateFilePath(filepath);
+ const absPath = path.resolve(process.cwd(), filepath);
+ if (cache && loadCache.has(absPath)) {
+ return loadCache.get(absPath);
+ }
+ const {base, ext} = path.parse(absPath);
+ const loaderKey = ext || 'noExt';
+ const loader = loaders[loaderKey];
+ validateLoader(loader, loaderKey);
+ const content = String(await fsReadFileAsync(absPath));
+
+ if (base === 'package.json') {
+ const pkg = await loader(absPath, content);
+ return emplace(
+ loadCache,
+ absPath,
+ transform({
+ config: getPackageProp(packageProp, pkg),
+ filepath: absPath,
+ }),
+ );
+ }
+ /** @type {import('./index').LilconfigResult} */
+ const result = {
+ config: null,
+ filepath: absPath,
+ };
+ // handle other type of configs
+ const isEmpty = content.trim() === '';
+ if (isEmpty && ignoreEmptySearchPlaces)
+ return emplace(
+ loadCache,
+ absPath,
+ transform({
+ config: undefined,
+ filepath: absPath,
+ isEmpty: true,
+ }),
+ );
+
+ // cosmiconfig returns undefined for empty files
+ result.config = isEmpty ? undefined : await loader(absPath, content);
+
+ return emplace(
+ loadCache,
+ absPath,
+ transform(isEmpty ? {...result, isEmpty, config: undefined} : result),
+ );
+ },
+ clearLoadCache() {
+ if (cache) loadCache.clear();
+ },
+ clearSearchCache() {
+ if (cache) searchCache.clear();
+ },
+ clearCaches() {
+ if (cache) {
+ loadCache.clear();
+ searchCache.clear();
+ }
+ },
+ };
+};
+
+/** @type {import('./index').lilconfigSync} */
+module.exports.lilconfigSync = function lilconfigSync(name, options) {
+ const {
+ ignoreEmptySearchPlaces,
+ loaders,
+ packageProp,
+ searchPlaces,
+ stopDir,
+ transform,
+ cache,
+ } = getOptions(name, options ?? {}, true);
+ const searchCache = new Map();
+ const loadCache = new Map();
+ const emplace = makeEmplace(cache);
+
+ return {
+ search(searchFrom = process.cwd()) {
+ /** @type {import('./index').LilconfigResult} */
+ const result = {
+ config: null,
+ filepath: '',
+ };
+
+ /** @type {Set} */
+ const visited = new Set();
+ let dir = searchFrom;
+ dirLoop: while (true) {
+ if (cache) {
+ const r = searchCache.get(dir);
+ if (r !== undefined) {
+ for (const p of visited) searchCache.set(p, r);
+ return r;
+ }
+ visited.add(dir);
+ }
+
+ for (const searchPlace of searchPlaces) {
+ const filepath = path.join(dir, searchPlace);
+ try {
+ fs.accessSync(filepath);
+ } catch {
+ continue;
+ }
+ const loaderKey = path.extname(searchPlace) || 'noExt';
+ const loader = loaders[loaderKey];
+ const content = String(fs.readFileSync(filepath));
+
+ // handle package.json
+ if (searchPlace === 'package.json') {
+ const pkg = loader(filepath, content);
+ const maybeConfig = getPackageProp(packageProp, pkg);
+ if (maybeConfig != null) {
+ result.config = maybeConfig;
+ result.filepath = filepath;
+ break dirLoop;
+ }
+
+ continue;
+ }
+
+ // handle other type of configs
+ const isEmpty = content.trim() === '';
+ if (isEmpty && ignoreEmptySearchPlaces) continue;
+
+ if (isEmpty) {
+ result.isEmpty = true;
+ result.config = undefined;
+ } else {
+ validateLoader(loader, loaderKey);
+ result.config = loader(filepath, content);
+ }
+ result.filepath = filepath;
+ break dirLoop;
+ }
+ if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+ dir = parentDir(dir);
+ }
+
+ const transformed =
+ // not found
+ result.filepath === '' && result.config === null
+ ? transform(null)
+ : transform(result);
+
+ if (cache) {
+ for (const p of visited) searchCache.set(p, transformed);
+ }
+
+ return transformed;
+ },
+ load(filepath) {
+ validateFilePath(filepath);
+ const absPath = path.resolve(process.cwd(), filepath);
+ if (cache && loadCache.has(absPath)) {
+ return loadCache.get(absPath);
+ }
+ const {base, ext} = path.parse(absPath);
+ const loaderKey = ext || 'noExt';
+ const loader = loaders[loaderKey];
+ validateLoader(loader, loaderKey);
+
+ const content = String(fs.readFileSync(absPath));
+
+ if (base === 'package.json') {
+ const pkg = loader(absPath, content);
+ return transform({
+ config: getPackageProp(packageProp, pkg),
+ filepath: absPath,
+ });
+ }
+ const result = {
+ config: null,
+ filepath: absPath,
+ };
+ // handle other type of configs
+ const isEmpty = content.trim() === '';
+ if (isEmpty && ignoreEmptySearchPlaces)
+ return emplace(
+ loadCache,
+ absPath,
+ transform({
+ filepath: absPath,
+ config: undefined,
+ isEmpty: true,
+ }),
+ );
+
+ // cosmiconfig returns undefined for empty files
+ result.config = isEmpty ? undefined : loader(absPath, content);
+
+ return emplace(
+ loadCache,
+ absPath,
+ transform(isEmpty ? {...result, isEmpty, config: undefined} : result),
+ );
+ },
+ clearLoadCache() {
+ if (cache) loadCache.clear();
+ },
+ clearSearchCache() {
+ if (cache) searchCache.clear();
+ },
+ clearCaches() {
+ if (cache) {
+ loadCache.clear();
+ searchCache.clear();
+ }
+ },
+ };
+};
diff --git a/node_modules/postcss-load-config/package.json b/node_modules/postcss-load-config/package.json
new file mode 100644
index 0000000..80b4116
--- /dev/null
+++ b/node_modules/postcss-load-config/package.json
@@ -0,0 +1,54 @@
+{
+ "name": "postcss-load-config",
+ "version": "4.0.2",
+ "description": "Autoload Config for PostCSS",
+ "main": "src/index.js",
+ "types": "src/index.d.ts",
+ "files": [
+ "src"
+ ],
+ "engines": {
+ "node": ">= 14"
+ },
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "dependencies": {
+ "lilconfig": "^3.0.0",
+ "yaml": "^2.3.4"
+ },
+ "peerDependencies": {
+ "postcss": ">=8.0.9",
+ "ts-node": ">=9.0.0"
+ },
+ "peerDependenciesMeta": {
+ "ts-node": {
+ "optional": true
+ },
+ "postcss": {
+ "optional": true
+ }
+ },
+ "keywords": [
+ "postcss",
+ "postcssrc",
+ "postcss.config.js"
+ ],
+ "author": "Michael Ciniawky ",
+ "contributors": [
+ "Ryan Dunckel",
+ "Mateusz Derks",
+ "Dalton Santos",
+ "Patrick Gilday",
+ "François Wouts"
+ ],
+ "repository": "postcss/postcss-load-config",
+ "license": "MIT"
+}
diff --git a/node_modules/postcss-load-config/src/index.d.ts b/node_modules/postcss-load-config/src/index.d.ts
new file mode 100644
index 0000000..4979220
--- /dev/null
+++ b/node_modules/postcss-load-config/src/index.d.ts
@@ -0,0 +1,65 @@
+// based on @types/postcss-load-config@2.0.1
+// Type definitions for postcss-load-config 2.1
+import Processor from 'postcss/lib/processor';
+import { Plugin, ProcessOptions, Transformer } from 'postcss';
+import { Options as ConfigOptions } from "lilconfig";
+
+declare function postcssrc(
+ ctx?: postcssrc.ConfigContext,
+ path?: string,
+ options?: ConfigOptions
+): Promise;
+
+declare namespace postcssrc {
+ // In the ConfigContext, these three options can be instances of the
+ // appropriate class, or strings. If they are strings, postcss-load-config will
+ // require() them and pass the instances along.
+ export interface ProcessOptionsPreload {
+ parser?: string | ProcessOptions['parser'];
+ stringifier?: string | ProcessOptions['stringifier'];
+ syntax?: string | ProcessOptions['syntax'];
+ }
+
+ // The remaining ProcessOptions, sans the three above.
+ export type RemainingProcessOptions = Pick<
+ ProcessOptions,
+ Exclude
+ >;
+
+ // Additional context options that postcss-load-config understands.
+ export interface Context {
+ cwd?: string;
+ env?: string;
+ }
+
+ // The full shape of the ConfigContext.
+ export type ConfigContext = Context &
+ ProcessOptionsPreload &
+ RemainingProcessOptions;
+
+ // Result of postcssrc is a Promise containing the filename plus the options
+ // and plugins that are ready to pass on to postcss.
+ export type ResultPlugin = Plugin | Transformer | Processor;
+
+ export interface Result {
+ file: string;
+ options: ProcessOptions;
+ plugins: ResultPlugin[];
+ }
+
+ export type ConfigPlugin = Transformer | Plugin | Processor;
+
+ export interface Config {
+ parser?: string | ProcessOptions['parser'] | false;
+ stringifier?: string | ProcessOptions['stringifier'] | false;
+ syntax?: string | ProcessOptions['syntax'] | false;
+ map?: string | false;
+ from?: string;
+ to?: string;
+ plugins?: Array | Record;
+ }
+
+ export type ConfigFn = (ctx: ConfigContext) => Config | Promise;
+}
+
+export = postcssrc;
diff --git a/node_modules/postcss-load-config/src/index.js b/node_modules/postcss-load-config/src/index.js
new file mode 100644
index 0000000..ce86aaa
--- /dev/null
+++ b/node_modules/postcss-load-config/src/index.js
@@ -0,0 +1,185 @@
+'use strict'
+
+const resolve = require('path').resolve
+const url = require('url')
+
+const config = require('lilconfig')
+const yaml = require('yaml')
+
+const loadOptions = require('./options.js')
+const loadPlugins = require('./plugins.js')
+
+/* istanbul ignore next */
+const interopRequireDefault = (obj) => obj && obj.__esModule ? obj : { default: obj }
+
+/**
+ * Process the result from cosmiconfig
+ *
+ * @param {Object} ctx Config Context
+ * @param {Object} result Cosmiconfig result
+ *
+ * @return {Object} PostCSS Config
+ */
+const processResult = (ctx, result) => {
+ const file = result.filepath || ''
+ let config = interopRequireDefault(result.config).default || {}
+
+ if (typeof config === 'function') {
+ config = config(ctx)
+ } else {
+ config = Object.assign({}, config, ctx)
+ }
+
+ if (!config.plugins) {
+ config.plugins = []
+ }
+
+ return {
+ plugins: loadPlugins(config, file),
+ options: loadOptions(config, file),
+ file
+ }
+}
+
+/**
+ * Builds the Config Context
+ *
+ * @param {Object} ctx Config Context
+ *
+ * @return {Object} Config Context
+ */
+const createContext = (ctx) => {
+ /**
+ * @type {Object}
+ *
+ * @prop {String} cwd=process.cwd() Config search start location
+ * @prop {String} env=process.env.NODE_ENV Config Enviroment, will be set to `development` by `postcss-load-config` if `process.env.NODE_ENV` is `undefined`
+ */
+ ctx = Object.assign({
+ cwd: process.cwd(),
+ env: process.env.NODE_ENV
+ }, ctx)
+
+ if (!ctx.env) {
+ process.env.NODE_ENV = 'development'
+ }
+
+ return ctx
+}
+
+const importDefault = async filepath => {
+ const module = await import(url.pathToFileURL(filepath).href)
+ return module.default
+}
+
+const addTypeScriptLoader = (options = {}, loader) => {
+ const moduleName = 'postcss'
+
+ return {
+ ...options,
+ searchPlaces: [
+ ...(options.searchPlaces || []),
+ 'package.json',
+ `.${moduleName}rc`,
+ `.${moduleName}rc.json`,
+ `.${moduleName}rc.yaml`,
+ `.${moduleName}rc.yml`,
+ `.${moduleName}rc.ts`,
+ `.${moduleName}rc.cts`,
+ `.${moduleName}rc.js`,
+ `.${moduleName}rc.cjs`,
+ `.${moduleName}rc.mjs`,
+ `${moduleName}.config.ts`,
+ `${moduleName}.config.cts`,
+ `${moduleName}.config.js`,
+ `${moduleName}.config.cjs`,
+ `${moduleName}.config.mjs`
+ ],
+ loaders: {
+ ...options.loaders,
+ '.yaml': (filepath, content) => yaml.parse(content),
+ '.yml': (filepath, content) => yaml.parse(content),
+ '.js': importDefault,
+ '.cjs': importDefault,
+ '.mjs': importDefault,
+ '.ts': loader,
+ '.cts': loader
+ }
+ }
+}
+
+const withTypeScriptLoader = (rcFunc) => {
+ return (ctx, path, options) => {
+ return rcFunc(ctx, path, addTypeScriptLoader(options, (configFile) => {
+ let registerer = { enabled () {} }
+
+ try {
+ // Register TypeScript compiler instance
+ registerer = require('ts-node').register({
+ // transpile to cjs even if compilerOptions.module in tsconfig is not Node16/NodeNext.
+ moduleTypes: { '**/*.cts': 'cjs' }
+ })
+
+ return require(configFile)
+ } catch (err) {
+ if (err.code === 'MODULE_NOT_FOUND') {
+ throw new Error(
+ `'ts-node' is required for the TypeScript configuration files. Make sure it is installed\nError: ${err.message}`
+ )
+ }
+
+ throw err
+ } finally {
+ registerer.enabled(false)
+ }
+ }))
+ }
+}
+
+/**
+ * Load Config
+ *
+ * @method rc
+ *
+ * @param {Object} ctx Config Context
+ * @param {String} path Config Path
+ * @param {Object} options Config Options
+ *
+ * @return {Promise} config PostCSS Config
+ */
+const rc = withTypeScriptLoader((ctx, path, options) => {
+ /**
+ * @type {Object} The full Config Context
+ */
+ ctx = createContext(ctx)
+
+ /**
+ * @type {String} `process.cwd()`
+ */
+ path = path ? resolve(path) : process.cwd()
+
+ return config.lilconfig('postcss', options)
+ .search(path)
+ .then((result) => {
+ if (!result) {
+ throw new Error(`No PostCSS Config found in: ${path}`)
+ }
+
+ return processResult(ctx, result)
+ })
+})
+
+/**
+ * Autoload Config for PostCSS
+ *
+ * @author Michael Ciniawsky @michael-ciniawsky
+ * @license MIT
+ *
+ * @module postcss-load-config
+ * @version 2.1.0
+ *
+ * @requires comsiconfig
+ * @requires ./options
+ * @requires ./plugins
+ */
+module.exports = rc
diff --git a/node_modules/postcss-load-config/src/options.js b/node_modules/postcss-load-config/src/options.js
new file mode 100644
index 0000000..d3ef2d6
--- /dev/null
+++ b/node_modules/postcss-load-config/src/options.js
@@ -0,0 +1,47 @@
+'use strict'
+
+const req = require('./req.js')
+
+/**
+ * Load Options
+ *
+ * @private
+ * @method options
+ *
+ * @param {Object} config PostCSS Config
+ *
+ * @return {Object} options PostCSS Options
+ */
+const options = (config, file) => {
+ if (config.parser && typeof config.parser === 'string') {
+ try {
+ config.parser = req(config.parser, file)
+ } catch (err) {
+ throw new Error(`Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`)
+ }
+ }
+
+ if (config.syntax && typeof config.syntax === 'string') {
+ try {
+ config.syntax = req(config.syntax, file)
+ } catch (err) {
+ throw new Error(`Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`)
+ }
+ }
+
+ if (config.stringifier && typeof config.stringifier === 'string') {
+ try {
+ config.stringifier = req(config.stringifier, file)
+ } catch (err) {
+ throw new Error(`Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`)
+ }
+ }
+
+ if (config.plugins) {
+ delete config.plugins
+ }
+
+ return config
+}
+
+module.exports = options
diff --git a/node_modules/postcss-load-config/src/plugins.js b/node_modules/postcss-load-config/src/plugins.js
new file mode 100644
index 0000000..6cb994b
--- /dev/null
+++ b/node_modules/postcss-load-config/src/plugins.js
@@ -0,0 +1,85 @@
+'use strict'
+
+const req = require('./req.js')
+
+/**
+ * Plugin Loader
+ *
+ * @private
+ * @method load
+ *
+ * @param {String} plugin PostCSS Plugin Name
+ * @param {Object} options PostCSS Plugin Options
+ *
+ * @return {Function} PostCSS Plugin
+ */
+const load = (plugin, options, file) => {
+ try {
+ if (
+ options === null ||
+ options === undefined ||
+ Object.keys(options).length === 0
+ ) {
+ return req(plugin, file)
+ } else {
+ return req(plugin, file)(options)
+ }
+ } catch (err) {
+ throw new Error(`Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`)
+ }
+}
+
+/**
+ * Load Plugins
+ *
+ * @private
+ * @method plugins
+ *
+ * @param {Object} config PostCSS Config Plugins
+ *
+ * @return {Array} plugins PostCSS Plugins
+ */
+const plugins = (config, file) => {
+ let plugins = []
+
+ if (Array.isArray(config.plugins)) {
+ plugins = config.plugins.filter(Boolean)
+ } else {
+ plugins = Object.keys(config.plugins)
+ .filter((plugin) => {
+ return config.plugins[plugin] !== false ? plugin : ''
+ })
+ .map((plugin) => {
+ return load(plugin, config.plugins[plugin], file)
+ })
+ }
+
+ if (plugins.length && plugins.length > 0) {
+ plugins.forEach((plugin, i) => {
+ if (plugin.default) {
+ plugin = plugin.default
+ }
+
+ if (plugin.postcss === true) {
+ plugin = plugin()
+ } else if (plugin.postcss) {
+ plugin = plugin.postcss
+ }
+
+ if (
+ // eslint-disable-next-line
+ !(
+ (typeof plugin === 'object' && Array.isArray(plugin.plugins)) ||
+ (typeof plugin === 'object' && plugin.postcssPlugin) ||
+ (typeof plugin === 'function')
+ )
+ ) {
+ throw new TypeError(`Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`)
+ }
+ })
+ }
+
+ return plugins
+}
+
+module.exports = plugins
diff --git a/node_modules/postcss-load-config/src/req.js b/node_modules/postcss-load-config/src/req.js
new file mode 100644
index 0000000..42020c9
--- /dev/null
+++ b/node_modules/postcss-load-config/src/req.js
@@ -0,0 +1,10 @@
+// eslint-disable-next-line n/no-deprecated-api
+const { createRequire, createRequireFromPath } = require('module')
+
+function req (name, rootFile) {
+ const create = createRequire || createRequireFromPath
+ const require = create(rootFile)
+ return require(name)
+}
+
+module.exports = req
diff --git a/node_modules/postcss-nested/LICENSE b/node_modules/postcss-nested/LICENSE
new file mode 100644
index 0000000..1ae47a2
--- /dev/null
+++ b/node_modules/postcss-nested/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik
+
+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/postcss-nested/README.md b/node_modules/postcss-nested/README.md
new file mode 100644
index 0000000..c65988d
--- /dev/null
+++ b/node_modules/postcss-nested/README.md
@@ -0,0 +1,85 @@
+# PostCSS Nested
+
+
+
+[PostCSS] plugin to unwrap nested rules closer to Sass syntax.
+
+```css
+.phone {
+ &_title {
+ width: 500px;
+ @media (max-width: 500px) {
+ width: auto;
+ }
+ body.is_dark & {
+ color: white;
+ }
+ }
+ img {
+ display: block;
+ }
+}
+
+.title {
+ font-size: var(--font);
+
+ @at-root html {
+ --font: 16px;
+ }
+}
+```
+
+will be processed to:
+
+```css
+.phone_title {
+ width: 500px;
+}
+@media (max-width: 500px) {
+ .phone_title {
+ width: auto;
+ }
+}
+body.is_dark .phone_title {
+ color: white;
+}
+.phone img {
+ display: block;
+}
+
+.title {
+ font-size: var(--font);
+}
+html {
+ --font: 16px;
+}
+```
+
+Related plugins:
+
+- Use [`postcss-current-selector`] **after** this plugin if you want
+ to use current selector in properties or variables values.
+- Use [`postcss-nested-ancestors`] **before** this plugin if you want
+ to reference any ancestor element directly in your selectors with `^&`.
+
+Alternatives:
+
+- See also [`postcss-nesting`], which implements [CSSWG draft].
+- [`postcss-nested-props`] for nested properties like `font-size`.
+
+
+
+
+
+[`postcss-current-selector`]: https://github.com/komlev/postcss-current-selector
+[`postcss-nested-ancestors`]: https://github.com/toomuchdesign/postcss-nested-ancestors
+[`postcss-nested-props`]: https://github.com/jedmao/postcss-nested-props
+[`postcss-nesting`]: https://github.com/csstools/postcss-plugins/tree/main/plugins/postcss-nesting
+[CSSWG draft]: https://drafts.csswg.org/css-nesting-1/
+[PostCSS]: https://github.com/postcss/postcss
+
+## Docs
+Read full docs **[here](https://github.com/postcss/postcss-nested#readme)**.
diff --git a/node_modules/postcss-nested/index.d.ts b/node_modules/postcss-nested/index.d.ts
new file mode 100644
index 0000000..5367682
--- /dev/null
+++ b/node_modules/postcss-nested/index.d.ts
@@ -0,0 +1,41 @@
+// Original definitions (@types/postcss-nested)
+// by Maxim Vorontsov
+
+import { PluginCreator } from 'postcss'
+
+declare namespace nested {
+ interface Options {
+ /**
+ * By default, plugin will bubble only `@media`, `@supports` and `@layer`
+ * at-rules. Use this option to add your custom at-rules to this list.
+ */
+ bubble?: string[]
+
+ /**
+ * By default, plugin will unwrap only `@font-face`, `@keyframes`,
+ * and `@document` at-rules. You can add your custom at-rules
+ * to this list by this option.
+ */
+ unwrap?: string[]
+
+ /**
+ * By default, plugin will strip out any empty selector generated
+ * by intermediate nesting levels. You can set this option to `true`
+ * to preserve them.
+ */
+ preserveEmpty?: boolean
+
+ /**
+ * The plugin supports the SCSS custom at-rule `@at-root` which breaks
+ * rule blocks out of their nested position. If you want, you can choose
+ * a new custom name for this rule in your code.
+ */
+ rootRuleName?: string
+ }
+
+ type Nested = PluginCreator
+}
+
+declare const nested: nested.Nested
+
+export = nested
diff --git a/node_modules/postcss-nested/index.js b/node_modules/postcss-nested/index.js
new file mode 100644
index 0000000..79831b6
--- /dev/null
+++ b/node_modules/postcss-nested/index.js
@@ -0,0 +1,361 @@
+const { AtRule, Rule } = require('postcss')
+let parser = require('postcss-selector-parser')
+
+/**
+ * Run a selector string through postcss-selector-parser
+ */
+function parse(rawSelector, rule) {
+ let nodes
+ try {
+ parser(parsed => {
+ nodes = parsed
+ }).processSync(rawSelector)
+ } catch (e) {
+ if (rawSelector.includes(':')) {
+ throw rule ? rule.error('Missed semicolon') : e
+ } else {
+ throw rule ? rule.error(e.message) : e
+ }
+ }
+ return nodes.at(0)
+}
+
+/**
+ * Replaces the "&" token in a node's selector with the parent selector
+ * similar to what SCSS does.
+ *
+ * Mutates the nodes list
+ */
+function interpolateAmpInSelector(nodes, parent) {
+ let replaced = false
+ nodes.each(node => {
+ if (node.type === 'nesting') {
+ let clonedParent = parent.clone({})
+ if (node.value !== '&') {
+ node.replaceWith(
+ parse(node.value.replace('&', clonedParent.toString()))
+ )
+ } else {
+ node.replaceWith(clonedParent)
+ }
+ replaced = true
+ } else if ('nodes' in node && node.nodes) {
+ if (interpolateAmpInSelector(node, parent)) {
+ replaced = true
+ }
+ }
+ })
+ return replaced
+}
+
+/**
+ * Combines parent and child selectors, in a SCSS-like way
+ */
+function mergeSelectors(parent, child) {
+ let merged = []
+ parent.selectors.forEach(sel => {
+ let parentNode = parse(sel, parent)
+
+ child.selectors.forEach(selector => {
+ if (!selector) {
+ return
+ }
+ let node = parse(selector, child)
+ let replaced = interpolateAmpInSelector(node, parentNode)
+ if (!replaced) {
+ node.prepend(parser.combinator({ value: ' ' }))
+ node.prepend(parentNode.clone({}))
+ }
+ merged.push(node.toString())
+ })
+ })
+ return merged
+}
+
+/**
+ * Move a child and its preceeding comment(s) to after "after"
+ */
+function breakOut(child, after) {
+ let prev = child.prev()
+ after.after(child)
+ while (prev && prev.type === 'comment') {
+ let nextPrev = prev.prev()
+ after.after(prev)
+ prev = nextPrev
+ }
+ return child
+}
+
+function createFnAtruleChilds(bubble) {
+ return function atruleChilds(rule, atrule, bubbling, mergeSels = bubbling) {
+ let children = []
+ atrule.each(child => {
+ if (child.type === 'rule' && bubbling) {
+ if (mergeSels) {
+ child.selectors = mergeSelectors(rule, child)
+ }
+ } else if (child.type === 'atrule' && child.nodes) {
+ if (bubble[child.name]) {
+ atruleChilds(rule, child, mergeSels)
+ } else if (atrule[rootRuleMergeSel] !== false) {
+ children.push(child)
+ }
+ } else {
+ children.push(child)
+ }
+ })
+ if (bubbling) {
+ if (children.length) {
+ let clone = rule.clone({ nodes: [] })
+ for (let child of children) {
+ clone.append(child)
+ }
+ atrule.prepend(clone)
+ }
+ }
+ }
+}
+
+function pickDeclarations(selector, declarations, after) {
+ let parent = new Rule({
+ nodes: [],
+ selector
+ })
+ parent.append(declarations)
+ after.after(parent)
+ return parent
+}
+
+function atruleNames(defaults, custom) {
+ let list = {}
+ for (let name of defaults) {
+ list[name] = true
+ }
+ if (custom) {
+ for (let name of custom) {
+ list[name.replace(/^@/, '')] = true
+ }
+ }
+ return list
+}
+
+function parseRootRuleParams(params) {
+ params = params.trim()
+ let braceBlock = params.match(/^\((.*)\)$/)
+ if (!braceBlock) {
+ return { selector: params, type: 'basic' }
+ }
+ let bits = braceBlock[1].match(/^(with(?:out)?):(.+)$/)
+ if (bits) {
+ let allowlist = bits[1] === 'with'
+ let rules = Object.fromEntries(
+ bits[2]
+ .trim()
+ .split(/\s+/)
+ .map(name => [name, true])
+ )
+ if (allowlist && rules.all) {
+ return { type: 'noop' }
+ }
+ let escapes = rule => !!rules[rule]
+ if (rules.all) {
+ escapes = () => true
+ } else if (allowlist) {
+ escapes = rule => (rule === 'all' ? false : !rules[rule])
+ }
+
+ return {
+ escapes,
+ type: 'withrules'
+ }
+ }
+ // Unrecognized brace block
+ return { type: 'unknown' }
+}
+
+function getAncestorRules(leaf) {
+ let lineage = []
+ let parent = leaf.parent
+
+ while (parent && parent instanceof AtRule) {
+ lineage.push(parent)
+ parent = parent.parent
+ }
+ return lineage
+}
+
+function unwrapRootRule(rule) {
+ let escapes = rule[rootRuleEscapes]
+
+ if (!escapes) {
+ rule.after(rule.nodes)
+ } else {
+ let nodes = rule.nodes
+
+ let topEscaped
+ let topEscapedIdx = -1
+ let breakoutLeaf
+ let breakoutRoot
+ let clone
+
+ let lineage = getAncestorRules(rule)
+ lineage.forEach((parent, i) => {
+ if (escapes(parent.name)) {
+ topEscaped = parent
+ topEscapedIdx = i
+ breakoutRoot = clone
+ } else {
+ let oldClone = clone
+ clone = parent.clone({ nodes: [] })
+ oldClone && clone.append(oldClone)
+ breakoutLeaf = breakoutLeaf || clone
+ }
+ })
+
+ if (!topEscaped) {
+ rule.after(nodes)
+ } else if (!breakoutRoot) {
+ topEscaped.after(nodes)
+ } else {
+ let leaf = breakoutLeaf
+ leaf.append(nodes)
+ topEscaped.after(breakoutRoot)
+ }
+
+ if (rule.next() && topEscaped) {
+ let restRoot
+ lineage.slice(0, topEscapedIdx + 1).forEach((parent, i, arr) => {
+ let oldRoot = restRoot
+ restRoot = parent.clone({ nodes: [] })
+ oldRoot && restRoot.append(oldRoot)
+
+ let nextSibs = []
+ let _child = arr[i - 1] || rule
+ let next = _child.next()
+ while (next) {
+ nextSibs.push(next)
+ next = next.next()
+ }
+ restRoot.append(nextSibs)
+ })
+ restRoot && (breakoutRoot || nodes[nodes.length - 1]).after(restRoot)
+ }
+ }
+
+ rule.remove()
+}
+
+const rootRuleMergeSel = Symbol('rootRuleMergeSel')
+const rootRuleEscapes = Symbol('rootRuleEscapes')
+
+function normalizeRootRule(rule) {
+ let { params } = rule
+ let { escapes, selector, type } = parseRootRuleParams(params)
+ if (type === 'unknown') {
+ throw rule.error(
+ `Unknown @${rule.name} parameter ${JSON.stringify(params)}`
+ )
+ }
+ if (type === 'basic' && selector) {
+ let selectorBlock = new Rule({ nodes: rule.nodes, selector })
+ rule.removeAll()
+ rule.append(selectorBlock)
+ }
+ rule[rootRuleEscapes] = escapes
+ rule[rootRuleMergeSel] = escapes ? !escapes('all') : type === 'noop'
+}
+
+const hasRootRule = Symbol('hasRootRule')
+
+module.exports = (opts = {}) => {
+ let bubble = atruleNames(
+ ['media', 'supports', 'layer', 'container', 'starting-style'],
+ opts.bubble
+ )
+ let atruleChilds = createFnAtruleChilds(bubble)
+ let unwrap = atruleNames(
+ [
+ 'document',
+ 'font-face',
+ 'keyframes',
+ '-webkit-keyframes',
+ '-moz-keyframes'
+ ],
+ opts.unwrap
+ )
+ let rootRuleName = (opts.rootRuleName || 'at-root').replace(/^@/, '')
+ let preserveEmpty = opts.preserveEmpty
+
+ return {
+ Once(root) {
+ root.walkAtRules(rootRuleName, node => {
+ normalizeRootRule(node)
+ root[hasRootRule] = true
+ })
+ },
+
+ postcssPlugin: 'postcss-nested',
+
+ RootExit(root) {
+ if (root[hasRootRule]) {
+ root.walkAtRules(rootRuleName, unwrapRootRule)
+ root[hasRootRule] = false
+ }
+ },
+
+ Rule(rule) {
+ let unwrapped = false
+ let after = rule
+ let copyDeclarations = false
+ let declarations = []
+
+ rule.each(child => {
+ if (child.type === 'rule') {
+ if (declarations.length) {
+ after = pickDeclarations(rule.selector, declarations, after)
+ declarations = []
+ }
+
+ copyDeclarations = true
+ unwrapped = true
+ child.selectors = mergeSelectors(rule, child)
+ after = breakOut(child, after)
+ } else if (child.type === 'atrule') {
+ if (declarations.length) {
+ after = pickDeclarations(rule.selector, declarations, after)
+ declarations = []
+ }
+ if (child.name === rootRuleName) {
+ unwrapped = true
+ atruleChilds(rule, child, true, child[rootRuleMergeSel])
+ after = breakOut(child, after)
+ } else if (bubble[child.name]) {
+ copyDeclarations = true
+ unwrapped = true
+ atruleChilds(rule, child, true)
+ after = breakOut(child, after)
+ } else if (unwrap[child.name]) {
+ copyDeclarations = true
+ unwrapped = true
+ atruleChilds(rule, child, false)
+ after = breakOut(child, after)
+ } else if (copyDeclarations) {
+ declarations.push(child)
+ }
+ } else if (child.type === 'decl' && copyDeclarations) {
+ declarations.push(child)
+ }
+ })
+
+ if (declarations.length) {
+ after = pickDeclarations(rule.selector, declarations, after)
+ }
+
+ if (unwrapped && preserveEmpty !== true) {
+ rule.raws.semicolon = true
+ if (rule.nodes.length === 0) rule.remove()
+ }
+ }
+ }
+}
+module.exports.postcss = true
diff --git a/node_modules/postcss-nested/package.json b/node_modules/postcss-nested/package.json
new file mode 100644
index 0000000..abc8e6c
--- /dev/null
+++ b/node_modules/postcss-nested/package.json
@@ -0,0 +1,34 @@
+{
+ "name": "postcss-nested",
+ "version": "6.2.0",
+ "description": "PostCSS plugin to unwrap nested rules like how Sass does it",
+ "keywords": [
+ "postcss",
+ "css",
+ "postcss-plugin",
+ "sass",
+ "nested"
+ ],
+ "author": "Andrey Sitnik ",
+ "license": "MIT",
+ "repository": "postcss/postcss-nested",
+ "engines": {
+ "node": ">=12.0"
+ },
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "peerDependencies": {
+ "postcss": "^8.2.14"
+ },
+ "dependencies": {
+ "postcss-selector-parser": "^6.1.1"
+ }
+}
diff --git a/node_modules/postcss-selector-parser/API.md b/node_modules/postcss-selector-parser/API.md
new file mode 100644
index 0000000..c8e55ee
--- /dev/null
+++ b/node_modules/postcss-selector-parser/API.md
@@ -0,0 +1,872 @@
+# API Documentation
+
+*Please use only this documented API when working with the parser. Methods
+not documented here are subject to change at any point.*
+
+## `parser` function
+
+This is the module's main entry point.
+
+```js
+const parser = require('postcss-selector-parser');
+```
+
+### `parser([transform], [options])`
+
+Creates a new `processor` instance
+
+```js
+const processor = parser();
+```
+
+Or, with optional transform function
+
+```js
+const transform = selectors => {
+ selectors.walkUniversals(selector => {
+ selector.remove();
+ });
+};
+
+const processor = parser(transform)
+
+// Example
+const result = processor.processSync('*.class');
+// => .class
+```
+
+[See processor documentation](#processor)
+
+Arguments:
+
+* `transform (function)`: Provide a function to work with the parsed AST.
+* `options (object)`: Provide default options for all calls on the returned `Processor`.
+
+### `parser.attribute([props])`
+
+Creates a new attribute selector.
+
+```js
+parser.attribute({attribute: 'href'});
+// => [href]
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.className([props])`
+
+Creates a new class selector.
+
+```js
+parser.className({value: 'button'});
+// => .button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.combinator([props])`
+
+Creates a new selector combinator.
+
+```js
+parser.combinator({value: '+'});
+// => +
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+Notes:
+* **Descendant Combinators** The value of descendant combinators created by the
+ parser always just a single space (`" "`). For descendant selectors with no
+ comments, additional space is now stored in `node.spaces.before`. Depending
+ on the location of comments, additional spaces may be stored in
+ `node.raws.spaces.before`, `node.raws.spaces.after`, or `node.raws.value`.
+* **Named Combinators** Although, nonstandard and unlikely to ever become a standard,
+ named combinators like `/deep/` and `/for/` are parsed as combinators. The
+ `node.value` is name after being unescaped and normalized as lowercase. The
+ original value for the combinator name is stored in `node.raws.value`.
+
+
+### `parser.comment([props])`
+
+Creates a new comment.
+
+```js
+parser.comment({value: '/* Affirmative, Dave. I read you. */'});
+// => /* Affirmative, Dave. I read you. */
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.id([props])`
+
+Creates a new id selector.
+
+```js
+parser.id({value: 'search'});
+// => #search
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.nesting([props])`
+
+Creates a new nesting selector.
+
+```js
+parser.nesting();
+// => &
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.pseudo([props])`
+
+Creates a new pseudo selector.
+
+```js
+parser.pseudo({value: '::before'});
+// => ::before
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.root([props])`
+
+Creates a new root node.
+
+```js
+parser.root();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.selector([props])`
+
+Creates a new selector node.
+
+```js
+parser.selector();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.string([props])`
+
+Creates a new string node.
+
+```js
+parser.string();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.tag([props])`
+
+Creates a new tag selector.
+
+```js
+parser.tag({value: 'button'});
+// => button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.universal([props])`
+
+Creates a new universal selector.
+
+```js
+parser.universal();
+// => *
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+## Node types
+
+### `node.type`
+
+A string representation of the selector type. It can be one of the following;
+`attribute`, `class`, `combinator`, `comment`, `id`, `nesting`, `pseudo`,
+`root`, `selector`, `string`, `tag`, or `universal`. Note that for convenience,
+these constants are exposed on the main `parser` as uppercased keys. So for
+example you can get `id` by querying `parser.ID`.
+
+```js
+parser.attribute({attribute: 'href'}).type;
+// => 'attribute'
+```
+
+### `node.parent`
+
+Returns the parent node.
+
+```js
+root.nodes[0].parent === root;
+```
+
+### `node.toString()`, `String(node)`, or `'' + node`
+
+Returns a string representation of the node.
+
+```js
+const id = parser.id({value: 'search'});
+console.log(String(id));
+// => #search
+```
+
+### `node.next()` & `node.prev()`
+
+Returns the next/previous child of the parent node.
+
+```js
+const next = id.next();
+if (next && next.type !== 'combinator') {
+ throw new Error('Qualified IDs are not allowed!');
+}
+```
+
+### `node.replaceWith(node)`
+
+Replace a node with another.
+
+```js
+const attr = selectors.first.first;
+const className = parser.className({value: 'test'});
+attr.replaceWith(className);
+```
+
+Arguments:
+
+* `node`: The node to substitute the original with.
+
+### `node.remove()`
+
+Removes the node from its parent node.
+
+```js
+if (node.type === 'id') {
+ node.remove();
+}
+```
+
+### `node.clone([opts])`
+
+Returns a copy of a node, detached from any parent containers that the
+original might have had.
+
+```js
+const cloned = node.clone();
+```
+
+### `node.isAtPosition(line, column)`
+
+Return a `boolean` indicating whether this node includes the character at the
+position of the given line and column. Returns `undefined` if the nodes lack
+sufficient source metadata to determine the position.
+
+Arguments:
+
+* `line`: 1-index based line number relative to the start of the selector.
+* `column`: 1-index based column number relative to the start of the selector.
+
+### `node.spaces`
+
+Extra whitespaces around the node will be moved into `node.spaces.before` and
+`node.spaces.after`. So for example, these spaces will be moved as they have
+no semantic meaning:
+
+```css
+ h1 , h2 {}
+```
+
+For descendent selectors, the value is always a single space.
+
+```css
+h1 h2 {}
+```
+
+Additional whitespace is found in either the `node.spaces.before` and `node.spaces.after` depending on the presence of comments or other whitespace characters. If the actual whitespace does not start or end with a single space, the node's raw value is set to the actual space(s) found in the source.
+
+### `node.source`
+
+An object describing the node's start/end, line/column source position.
+
+Within the following CSS, the `.bar` class node ...
+
+```css
+.foo,
+ .bar {}
+```
+
+... will contain the following `source` object.
+
+```js
+source: {
+ start: {
+ line: 2,
+ column: 3
+ },
+ end: {
+ line: 2,
+ column: 6
+ }
+}
+```
+
+### `node.sourceIndex`
+
+The zero-based index of the node within the original source string.
+
+Within the following CSS, the `.baz` class node will have a `sourceIndex` of `12`.
+
+```css
+.foo, .bar, .baz {}
+```
+
+## Container types
+
+The `root`, `selector`, and `pseudo` nodes have some helper methods for working
+with their children.
+
+### `container.nodes`
+
+An array of the container's children.
+
+```js
+// Input: h1 h2
+selectors.at(0).nodes.length // => 3
+selectors.at(0).nodes[0].value // => 'h1'
+selectors.at(0).nodes[1].value // => ' '
+```
+
+### `container.first` & `container.last`
+
+The first/last child of the container.
+
+```js
+selector.first === selector.nodes[0];
+selector.last === selector.nodes[selector.nodes.length - 1];
+```
+
+### `container.at(index)`
+
+Returns the node at position `index`.
+
+```js
+selector.at(0) === selector.first;
+selector.at(0) === selector.nodes[0];
+```
+
+Arguments:
+
+* `index`: The index of the node to return.
+
+### `container.atPosition(line, column)`
+
+Returns the node at the source position `line` and `column`.
+
+```js
+// Input: :not(.foo),\n#foo > :matches(ol, ul)
+selector.atPosition(1, 1); // => :not(.foo)
+selector.atPosition(2, 1); // => \n#foo
+```
+
+Arguments:
+
+* `line`: The line number of the node to return.
+* `column`: The column number of the node to return.
+
+### `container.index(node)`
+
+Return the index of the node within its container.
+
+```js
+selector.index(selector.nodes[2]) // => 2
+```
+
+Arguments:
+
+* `node`: A node within the current container.
+
+### `container.length`
+
+Proxy to the length of the container's nodes.
+
+```js
+container.length === container.nodes.length
+```
+
+### `container` Array iterators
+
+The container class provides proxies to certain Array methods; these are:
+
+* `container.map === container.nodes.map`
+* `container.reduce === container.nodes.reduce`
+* `container.every === container.nodes.every`
+* `container.some === container.nodes.some`
+* `container.filter === container.nodes.filter`
+* `container.sort === container.nodes.sort`
+
+Note that these methods only work on a container's immediate children; recursive
+iteration is provided by `container.walk`.
+
+### `container.each(callback)`
+
+Iterate the container's immediate children, calling `callback` for each child.
+You may return `false` within the callback to break the iteration.
+
+```js
+let className;
+selectors.each((selector, index) => {
+ if (selector.type === 'class') {
+ className = selector.value;
+ return false;
+ }
+});
+```
+
+Note that unlike `Array#forEach()`, this iterator is safe to use whilst adding
+or removing nodes from the container.
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+ and `index` arguments.
+
+### `container.walk(callback)`
+
+Like `container#each`, but will also iterate child nodes as long as they are
+`container` types.
+
+```js
+selectors.walk((selector, index) => {
+ // all nodes
+});
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+ and `index` arguments.
+
+This iterator is safe to use whilst mutating `container.nodes`,
+like `container#each`.
+
+### `container.walk` proxies
+
+The container class provides proxy methods for iterating over types of nodes,
+so that it is easier to write modules that target specific selectors. Those
+methods are:
+
+* `container.walkAttributes`
+* `container.walkClasses`
+* `container.walkCombinators`
+* `container.walkComments`
+* `container.walkIds`
+* `container.walkNesting`
+* `container.walkPseudos`
+* `container.walkTags`
+* `container.walkUniversals`
+
+### `container.split(callback)`
+
+This method allows you to split a group of nodes by returning `true` from
+a callback. It returns an array of arrays, where each inner array corresponds
+to the groups that you created via the callback.
+
+```js
+// (input) => h1 h2>>h3
+const list = selectors.first.split(selector => {
+ return selector.type === 'combinator';
+});
+
+// (node values) => [['h1', ' '], ['h2', '>>'], ['h3']]
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+ as an argument.
+
+### `container.prepend(node)` & `container.append(node)`
+
+Add a node to the start/end of the container. Note that doing so will set
+the parent property of the node to this container.
+
+```js
+const id = parser.id({value: 'search'});
+selector.append(id);
+```
+
+Arguments:
+
+* `node`: The node to add.
+
+### `container.insertBefore(old, new)` & `container.insertAfter(old, new)`
+
+Add a node before or after an existing node in a container:
+
+```js
+selectors.walk(selector => {
+ if (selector.type !== 'class') {
+ const className = parser.className({value: 'theme-name'});
+ selector.parent.insertAfter(selector, className);
+ }
+});
+```
+
+Arguments:
+
+* `old`: The existing node in the container.
+* `new`: The new node to add before/after the existing node.
+
+### `container.removeChild(node)`
+
+Remove the node from the container. Note that you can also use
+`node.remove()` if you would like to remove just a single node.
+
+```js
+selector.length // => 2
+selector.remove(id)
+selector.length // => 1;
+id.parent // undefined
+```
+
+Arguments:
+
+* `node`: The node to remove.
+
+### `container.removeAll()` or `container.empty()`
+
+Remove all children from the container.
+
+```js
+selector.removeAll();
+selector.length // => 0
+```
+
+## Root nodes
+
+A root node represents a comma separated list of selectors. Indeed, all
+a root's `toString()` method does is join its selector children with a ','.
+Other than this, it has no special functionality and acts like a container.
+
+### `root.trailingComma`
+
+This will be set to `true` if the input has a trailing comma, in order to
+support parsing of legacy CSS hacks.
+
+## Selector nodes
+
+A selector node represents a single complex selector. For example, this
+selector string `h1 h2 h3, [href] > p`, is represented as two selector nodes.
+It has no special functionality of its own.
+
+## Pseudo nodes
+
+A pseudo selector extends a container node; if it has any parameters of its
+own (such as `h1:not(h2, h3)`), they will be its children. Note that the pseudo
+`value` will always contain the colons preceding the pseudo identifier. This
+is so that both `:before` and `::before` are properly represented in the AST.
+
+## Attribute nodes
+
+### `attribute.quoted`
+
+Returns `true` if the attribute's value is wrapped in quotation marks, false if it is not.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* false */
+[href='foo'] /* true */
+[href="foo"] /* true */
+[href] /* undefined */
+```
+
+### `attribute.qualifiedAttribute`
+
+Returns the attribute name qualified with the namespace if one is given.
+
+### `attribute.offsetOf(part)`
+
+ Returns the offset of the attribute part specified relative to the
+ start of the node of the output string. This is useful in raising
+ error messages about a specific part of the attribute, especially
+ in combination with `attribute.sourceIndex`.
+
+ Returns `-1` if the name is invalid or the value doesn't exist in this
+ attribute.
+
+ The legal values for `part` are:
+
+ * `"ns"` - alias for "namespace"
+ * `"namespace"` - the namespace if it exists.
+ * `"attribute"` - the attribute name
+ * `"attributeNS"` - the start of the attribute or its namespace
+ * `"operator"` - the match operator of the attribute
+ * `"value"` - The value (string or identifier)
+ * `"insensitive"` - the case insensitivity flag
+
+### `attribute.raws.unquoted`
+
+Returns the unquoted content of the attribute's value.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* foo */
+[href='foo'] /* foo */
+[href="foo"] /* foo */
+[href] /* undefined */
+```
+
+### `attribute.spaces`
+
+Like `node.spaces` with the `before` and `after` values containing the spaces
+around the element, the parts of the attribute can also have spaces before
+and after them. The for each of `attribute`, `operator`, `value` and
+`insensitive` there is corresponding property of the same nam in
+`node.spaces` that has an optional `before` or `after` string containing only
+whitespace.
+
+Note that corresponding values in `attributes.raws.spaces` contain values
+including any comments. If set, these values will override the
+`attribute.spaces` value. Take care to remove them if changing
+`attribute.spaces`.
+
+### `attribute.raws`
+
+The raws object stores comments and other information necessary to re-render
+the node exactly as it was in the source.
+
+If a comment is embedded within the identifiers for the `namespace`, `attribute`
+or `value` then a property is placed in the raws for that value containing the full source of the propery including comments.
+
+If a comment is embedded within the space between parts of the attribute
+then the raw for that space is set accordingly.
+
+Setting an attribute's property `raws` value to be deleted.
+
+For now, changing the spaces required also updating or removing any of the
+raws values that override them.
+
+Example: `[ /*before*/ href /* after-attr */ = /* after-operator */ te/*inside-value*/st/* wow */ /*omg*/i/*bbq*/ /*whodoesthis*/]` would parse as:
+
+```js
+{
+ attribute: "href",
+ operator: "=",
+ value: "test",
+ spaces: {
+ before: '',
+ after: '',
+ attribute: { before: ' ', after: ' ' },
+ operator: { after: ' ' },
+ value: { after: ' ' },
+ insensitive: { after: ' ' }
+ },
+ raws: {
+ spaces: {
+ attribute: { before: ' /*before*/ ', after: ' /* after-attr */ ' },
+ operator: { after: ' /* after-operator */ ' },
+ value: { after: '/* wow */ /*omg*/' },
+ insensitive: { after: '/*bbq*/ /*whodoesthis*/' }
+ },
+ unquoted: 'test',
+ value: 'te/*inside-value*/st'
+ }
+}
+```
+
+## `Processor`
+
+### `ProcessorOptions`
+
+* `lossless` - When `true`, whitespace is preserved. Defaults to `true`.
+* `updateSelector` - When `true`, if any processor methods are passed a postcss
+ `Rule` node instead of a string, then that Rule's selector is updated
+ with the results of the processing. Defaults to `true`.
+
+### `process|processSync(selectors, [options])`
+
+Processes the `selectors`, returning a string from the result of processing.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+**Example:**
+
+```js
+const parser = require("postcss-selector-parser");
+const processor = parser();
+
+let result = processor.processSync(' .class');
+console.log(result);
+// => .class
+
+// Asynchronous operation
+let promise = processor.process(' .class').then(result => {
+ console.log(result)
+ // => .class
+});
+
+// To have the parser normalize whitespace values, utilize the options
+result = processor.processSync(' .class ', {lossless: false});
+console.log(result);
+// => .class
+
+// For better syntax errors, pass a PostCSS Rule node.
+const postcss = require('postcss');
+rule = postcss.rule({selector: ' #foo > a, .class '});
+processor.process(rule, {lossless: false, updateSelector: true}).then(result => {
+ console.log(result);
+ // => #foo>a,.class
+ console.log("rule:", rule.selector);
+ // => rule: #foo>a,.class
+})
+```
+
+Arguments:
+
+* `selectors (string|postcss.Rule)`: Either a selector string or a PostCSS Rule
+ node.
+* `[options] (object)`: Process options
+
+
+### `ast|astSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the `Root` node of the result
+instead of a string.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### `transform|transformSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the value returned by the
+processor callback.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### Error Handling Within Selector Processors
+
+The root node passed to the selector processor callback
+has a method `error(message, options)` that returns an
+error object. This method should always be used to raise
+errors relating to the syntax of selectors. The options
+to this method are passed to postcss's error constructor
+([documentation](http://postcss.org/api/#container-error)).
+
+#### Async Error Example
+
+```js
+let processor = (root) => {
+ return new Promise((resolve, reject) => {
+ root.walkClasses((classNode) => {
+ if (/^(.*)[-_]/.test(classNode.value)) {
+ let msg = "classes may not have underscores or dashes in them";
+ reject(root.error(msg, {
+ index: classNode.sourceIndex + RegExp.$1.length + 1,
+ word: classNode.value
+ }));
+ }
+ });
+ resolve();
+ });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+ return (root) => {
+ let promises = [];
+ root.walkRules(rule => {
+ promises.push(selectorProcessor.process(rule));
+ });
+ return Promise.all(promises);
+ };
+});
+postcss(plugin()).process(`
+.foo-bar {
+ color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+// | ^
+// 2 | color: red;
+// 3 | }
+```
+
+#### Synchronous Error Example
+
+```js
+let processor = (root) => {
+ root.walkClasses((classNode) => {
+ if (/.*[-_]/.test(classNode.value)) {
+ let msg = "classes may not have underscores or dashes in them";
+ throw root.error(msg, {
+ index: classNode.sourceIndex,
+ word: classNode.value
+ });
+ }
+ });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+ return (root) => {
+ root.walkRules(rule => {
+ selectorProcessor.processSync(rule);
+ });
+ };
+});
+postcss(plugin()).process(`
+.foo-bar {
+ color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+// | ^
+// 2 | color: red;
+// 3 | }
+```
diff --git a/node_modules/postcss-selector-parser/CHANGELOG.md b/node_modules/postcss-selector-parser/CHANGELOG.md
new file mode 100644
index 0000000..14ffadc
--- /dev/null
+++ b/node_modules/postcss-selector-parser/CHANGELOG.md
@@ -0,0 +1,549 @@
+# 6.1.2
+
+- Fixed: erroneous trailing combinators in pseudos
+
+# 6.1.1
+
+- Fixed: improve typings of constructor helpers (#292)
+
+# 6.1.0
+
+- Feature: add `sourceIndex` to `Selector` nodes (#290)
+
+# 6.0.16
+
+- Fixed: add missing `index` argument to `each`/`walk` callback types (#289)
+
+# 6.0.15
+
+- Fixed: Node#prev and Node#next type for the first/last node
+
+# 6.0.14
+
+- Fixed: type definitions
+
+# 6.0.13
+
+- Fixed: throw on unexpected pipe symbols
+
+# 6.0.12
+
+- Fixed: `clone` arguments should be optional
+
+# 6.0.11
+
+- Fixed: parse attribute case insensitivity flag
+
+# 6.0.10
+
+- Fixed: `isPseudoElement()` supports `:first-letter` and `:first-line`
+
+# 6.0.9
+
+- Fixed: `Combinator.raws` property type
+
+# 6.0.8
+
+- Fixed: reduced size
+
+# 6.0.7
+
+- Fixed: parse animation percents
+
+# 6.0.6
+
+- Fixed: parse quoted attributes containing a newline correctly
+
+# 6.0.5
+
+- Perf: rework unesc for a 63+% performance boost
+
+# 6.0.4
+
+- Fixed: ts errors
+
+# 6.0.3
+
+- Fixed: replace node built-in "util" module with "util-deprecate"
+- Fixed: handle uppercase pseudo elements
+- Fixed: do not create invalid combinator before comment
+
+# 6.0.2
+
+- Fixed an issue with parsing and stringifying an empty attribute value
+
+# 6.0.1
+
+- Fixed an issue with unicode surrogate pair parsing
+
+# 6.0.0
+
+- Updated: `cssesc` to 3.0.0 (major)
+- Fixed: Issues with escaped `id` and `class` selectors
+
+# 5.0.0
+
+- Allow escaped dot within class name.
+- Update PostCSS to 7.0.7 (patch)
+
+# 5.0.0-rc.4
+
+- Fixed an issue where comments immediately after an insensitive (in attribute)
+ were not parsed correctly.
+- Updated `cssesc` to 2.0.0 (major).
+- Removed outdated integration tests.
+- Added tests for custom selectors, tags with attributes, the universal
+ selector with pseudos, and tokens after combinators.
+
+# 5.0.0-rc.1
+
+To ease adoption of the v5.0 release, we have relaxed the node version
+check performed by npm at installation time to allow for node 4, which
+remains officially unsupported, but likely to continue working for the
+time being.
+
+# 5.0.0-rc.0
+
+This release has **BREAKING CHANGES** that were required to fix regressions
+in 4.0.0 and to make the Combinator Node API consistent for all combinator
+types. Please read carefully.
+
+## Summary of Changes
+
+* The way a descendent combinator that isn't a single space character (E.g. `.a .b`) is stored in the AST has changed.
+* Named Combinators (E.g. `.a /for/ .b`) are now properly parsed as a combinator.
+* It is now possible to look up a node based on the source location of a character in that node and to query nodes if they contain some character.
+* Several bug fixes that caused the parser to hang and run out of memory when a `/` was encountered have been fixed.
+* The minimum supported version of Node is now `v6.0.0`.
+
+### Changes to the Descendent Combinator
+
+In prior releases, the value of a descendant combinator with multiple spaces included all the spaces.
+
+* `.a .b`: Extra spaces are now stored as space before.
+ - Old & Busted:
+ - `combinator.value === " "`
+ - New hotness:
+ - `combinator.value === " " && combinator.spaces.before === " "`
+* `.a /*comment*/.b`: A comment at the end of the combinator causes extra space to become after space.
+ - Old & Busted:
+ - `combinator.value === " "`
+ - `combinator.raws.value === " /*comment/"`
+ - New hotness:
+ - `combinator.value === " "`
+ - `combinator.spaces.after === " "`
+ - `combinator.raws.spaces.after === " /*comment*/"`
+* `.a.b`: whitespace that doesn't start or end with a single space character is stored as a raw value.
+ - Old & Busted:
+ - `combinator.value === "\n"`
+ - `combinator.raws.value === undefined`
+ - New hotness:
+ - `combinator.value === " "`
+ - `combinator.raws.value === "\n"`
+
+### Support for "Named Combinators"
+
+Although, nonstandard and unlikely to ever become a standard, combinators like `/deep/` and `/for/` are now properly supported.
+
+Because they've been taken off the standardization track, there is no spec-official name for combinators of the form `//`. However, I talked to [Tab Atkins](https://twitter.com/tabatkins) and we agreed to call them "named combinators" so now they are called that.
+
+Before this release such named combinators were parsed without intention and generated three nodes of type `"tag"` where the first and last nodes had a value of `"/"`.
+
+* `.a /for/ .b` is parsed as a combinator.
+ - Old & Busted:
+ - `root.nodes[0].nodes[1].type === "tag"`
+ - `root.nodes[0].nodes[1].value === "/"`
+ - New hotness:
+ - `root.nodes[0].nodes[1].type === "combinator"`
+ - `root.nodes[0].nodes[1].value === "/for/"`
+* `.a /F\6fR/ .b` escapes are handled and uppercase is normalized.
+ - Old & Busted:
+ - `root.nodes[0].nodes[2].type === "tag"`
+ - `root.nodes[0].nodes[2].value === "F\\6fR"`
+ - New hotness:
+ - `root.nodes[0].nodes[1].type === "combinator"`
+ - `root.nodes[0].nodes[1].value === "/for/"`
+ - `root.nodes[0].nodes[1].raws.value === "/F\\6fR/"`
+
+### Source position checks and lookups
+
+A new API was added to look up a node based on the source location.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+// You can find the most specific node for any given character
+let combinator = selectorParser.astSync(".a > .b").atPosition(1,4);
+combinator.toString() === " > ";
+// You can check if a node includes a specific character
+// Whitespace surrounding the node that is owned by that node
+// is included in the check.
+[2,3,4,5,6].map(column => combinator.isAtPosition(1, column));
+// => [false, true, true, true, false]
+```
+
+# 4.0.0
+
+This release has **BREAKING CHANGES** that were required to fix bugs regarding values with escape sequences. Please read carefully.
+
+* **Identifiers with escapes** - CSS escape sequences are now hidden from the public API by default.
+ The normal value of a node like a class name or ID, or an aspect of a node such as attribute
+ selector's value, is unescaped. Escapes representing Non-ascii characters are unescaped into
+ unicode characters. For example: `bu\tton, .\31 00, #i\2764\FE0Fu, [attr="value is \"quoted\""]`
+ will parse respectively to the values `button`, `100`, `i❤️u`, `value is "quoted"`.
+ The original escape sequences for these values can be found in the corresponding property name
+ in `node.raws`. Where possible, deprecation warnings were added, but the nature
+ of escape handling makes it impossible to detect what is escaped or not. Our expectation is
+ that most users are neither expecting nor handling escape sequences in their use of this library,
+ and so for them, this is a bug fix. Users who are taking care to handle escapes correctly can
+ now update their code to remove the escape handling and let us do it for them.
+
+* **Mutating values with escapes** - When you make an update to a node property that has escape handling
+ The value is assumed to be unescaped, and any special characters are escaped automatically and
+ the corresponding `raws` value is immediately updated. This can result in changes to the original
+ escape format. Where the exact value of the escape sequence is important there are methods that
+ allow both values to be set in conjunction. There are a number of new convenience methods for
+ manipulating values that involve escapes, especially for attributes values where the quote mark
+ is involved. See https://github.com/postcss/postcss-selector-parser/pull/133 for an extensive
+ write-up on these changes.
+
+
+**Upgrade/API Example**
+
+In `3.x` there was no unescape handling and internal consistency of several properties was the caller's job to maintain. It was very easy for the developer
+to create a CSS file that did not parse correctly when some types of values
+were in use.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value"});
+attr.value; // => "a-value"
+attr.toString(); // => [id=a-value]
+// Add quotes to an attribute's value.
+// All these values have to be set by the caller to be consistent:
+// no internal consistency is maintained.
+attr.raws.unquoted = attr.value
+attr.value = "'" + attr.value + "'";
+attr.value; // => "'a-value'"
+attr.quoted = true;
+attr.toString(); // => "[id='a-value']"
+```
+
+In `4.0` there is a convenient API for setting and mutating values
+that may need escaping. Especially for attributes.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+
+// The constructor requires you specify the exact escape sequence
+let className = selectorParser.className({value: "illegal class name", raws: {value: "illegal\\ class\\ name"}});
+className.toString(); // => '.illegal\\ class\\ name'
+
+// So it's better to set the value as a property
+className = selectorParser.className();
+// Most properties that deal with identifiers work like this
+className.value = "escape for me";
+className.value; // => 'escape for me'
+className.toString(); // => '.escape\\ for\\ me'
+
+// emoji and all non-ascii are escaped to ensure it works in every css file.
+className.value = "😱🦄😍";
+className.value; // => '😱🦄😍'
+className.toString(); // => '.\\1F631\\1F984\\1F60D'
+
+// you can control the escape sequence if you want, or do bad bad things
+className.setPropertyAndEscape('value', 'xxxx', 'yyyy');
+className.value; // => "xxxx"
+className.toString(); // => ".yyyy"
+
+// Pass a value directly through to the css output without escaping it.
+className.setPropertyWithoutEscape('value', '$REPLACE_ME$');
+className.value; // => "$REPLACE_ME$"
+className.toString(); // => ".$REPLACE_ME$"
+
+// The biggest changes are to the Attribute class
+// passing quoteMark explicitly is required to avoid a deprecation warning.
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value", quoteMark: null});
+attr.toString(); // => "[id=a-value]"
+// Get the value with quotes on it and any necessary escapes.
+// This is the same as reading attr.value in 3.x.
+attr.getQuotedValue(); // => "a-value";
+attr.quoteMark; // => null
+
+// Add quotes to an attribute's value.
+attr.quoteMark = "'"; // This is all that's required.
+attr.toString(); // => "[id='a-value']"
+attr.quoted; // => true
+// The value is still the same, only the quotes have changed.
+attr.value; // => a-value
+attr.getQuotedValue(); // => "'a-value'";
+
+// deprecated assignment, no warning because there's no escapes
+attr.value = "new-value";
+// no quote mark is needed so it is removed
+attr.getQuotedValue(); // => "new-value";
+
+// deprecated assignment,
+attr.value = "\"a 'single quoted' value\"";
+// > (node:27859) DeprecationWarning: Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.
+attr.getQuotedValue(); // => '"a \'single quoted\' value"';
+// quote mark inferred from first and last characters.
+attr.quoteMark; // => '"'
+
+// setValue takes options to make manipulating the value simple.
+attr.setValue('foo', {smart: true});
+// foo doesn't require any escapes or quotes.
+attr.toString(); // => '[id=foo]'
+attr.quoteMark; // => null
+
+// An explicit quote mark can be specified
+attr.setValue('foo', {quoteMark: '"'});
+attr.toString(); // => '[id="foo"]'
+
+// preserves quote mark by default
+attr.setValue('bar');
+attr.toString(); // => '[id="bar"]'
+attr.quoteMark = null;
+attr.toString(); // => '[id=bar]'
+
+// with no arguments, it preserves quote mark even when it's not a great idea
+attr.setValue('a value \n that should be quoted');
+attr.toString(); // => '[id=a\\ value\\ \\A\\ that\\ should\\ be\\ quoted]'
+
+// smart preservation with a specified default
+attr.setValue('a value \n that should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a value \\A that should be quoted']"
+attr.quoteMark = '"';
+// => '[id="a value \\A that should be quoted"]'
+
+// this keeps double quotes because it wants to quote the value and the existing value has double quotes.
+attr.setValue('this should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => '[id="this should be quoted"]'
+
+// picks single quotes because the value has double quotes
+attr.setValue('a "double quoted" value', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a "double quoted" value']"
+
+// setPropertyAndEscape lets you do anything you want. Even things that are a bad idea and illegal.
+attr.setPropertyAndEscape('value', 'xxxx', 'the password is 42');
+attr.value; // => "xxxx"
+attr.toString(); // => "[id=the password is 42]"
+
+// Pass a value directly through to the css output without escaping it.
+attr.setPropertyWithoutEscape('value', '$REPLACEMENT$');
+attr.value; // => "$REPLACEMENT$"
+attr.toString(); // => "[id=$REPLACEMENT$]"
+```
+
+# 3.1.2
+
+* Fix: Removed dot-prop dependency since it's no longer written in es5.
+
+# 3.1.1
+
+* Fix: typescript definitions weren't in the published package.
+
+# 3.1.0
+
+* Fixed numerous bugs in attribute nodes relating to the handling of comments
+ and whitespace. There's significant changes to `attrNode.spaces` and `attrNode.raws` since the `3.0.0` release.
+* Added `Attribute#offsetOf(part)` to get the offset location of
+ attribute parts like `"operator"` and `"value"`. This is most
+ often added to `Attribute#sourceIndex` for error reporting.
+
+# 3.0.0
+
+## Breaking changes
+
+* Some tweaks to the tokenizer/attribute selector parsing mean that whitespace
+ locations might be slightly different to the 2.x code.
+* Better attribute selector parsing with more validation; postcss-selector-parser
+ no longer uses regular expressions to parse attribute selectors.
+* Added an async API (thanks to @jacobp100); the default `process` API is now
+ async, and the sync API is now accessed through `processSync` instead.
+* `process()` and `processSync()` now return a string instead of the Processor
+ instance.
+* Tweaks handling of Less interpolation (thanks to @jwilsson).
+* Removes support for Node 0.12.
+
+## Other changes
+
+* `ast()` and `astSync()` methods have been added to the `Processor`. These
+ return the `Root` node of the selectors after processing them.
+* `transform()` and `transformSync()` methods have been added to the
+ `Processor`. These return the value returned by the processor callback
+ after processing the selectors.
+* Set the parent when inserting a node (thanks to @chriseppstein).
+* Correctly adjust indices when using insertBefore/insertAfter (thanks to @tivac).
+* Fixes handling of namespaces with qualified tag selectors.
+* `process`, `ast` and `transform` (and their sync variants) now accept a
+ `postcss` rule node. When provided, better errors are generated and selector
+ processing is automatically set back to the rule selector (unless the `updateSelector` option is set to `false`.)
+* Now more memory efficient when tokenizing selectors.
+
+### Upgrade hints
+
+The pattern of:
+
+`rule.selector = processor.process(rule.selector).result.toString();`
+
+is now:
+
+`processor.processSync(rule)`
+
+# 2.2.3
+
+* Resolves an issue where the parser would not reduce multiple spaces between an
+ ampersand and another simple selector in lossy mode (thanks to @adam-26).
+
+# 2.2.2
+
+* No longer hangs on an unescaped semicolon; instead the parser will throw
+ an exception for these cases.
+
+# 2.2.1
+
+* Allows a consumer to specify whitespace tokens when creating a new Node
+ (thanks to @Semigradsky).
+
+# 2.2.0
+
+* Added a new option to normalize whitespace when parsing the selector string
+ (thanks to @adam-26).
+
+# 2.1.1
+
+* Better unquoted value handling within attribute selectors
+ (thanks to @evilebottnawi).
+
+# 2.1.0
+
+* Added: Use string constants for all node types & expose them on the main
+ parser instance (thanks to @Aweary).
+
+# 2.0.0
+
+This release contains the following breaking changes:
+
+* Renamed all `eachInside` iterators to `walk`. For example, `eachTag` is now
+ `walkTags`, and `eachInside` is now `walk`.
+* Renamed `Node#removeSelf()` to `Node#remove()`.
+* Renamed `Container#remove()` to `Container#removeChild()`.
+* Renamed `Node#raw` to `Node#raws` (thanks to @davidtheclark).
+* Now parses `&` as the *nesting* selector, rather than a *tag* selector.
+* Fixes misinterpretation of Sass interpolation (e.g. `#{foo}`) as an
+ id selector (thanks to @davidtheclark).
+
+and;
+
+* Fixes parsing of attribute selectors with equals signs in them
+ (e.g. `[data-attr="foo=bar"]`) (thanks to @montmanu).
+* Adds `quoted` and `raw.unquoted` properties to attribute nodes
+ (thanks to @davidtheclark).
+
+# 1.3.3
+
+* Fixes an infinite loop on `)` and `]` tokens when they had no opening pairs.
+ Now postcss-selector-parser will throw when it encounters these lone tokens.
+
+# 1.3.2
+
+* Now uses plain integers rather than `str.charCodeAt(0)` for compiled builds.
+
+# 1.3.1
+
+* Update flatten to v1.x (thanks to @shinnn).
+
+# 1.3.0
+
+* Adds a new node type, `String`, to fix a crash on selectors such as
+ `foo:bar("test")`.
+
+# 1.2.1
+
+* Fixes a crash when the parser encountered a trailing combinator.
+
+# 1.2.0
+
+* A more descriptive error is thrown when the parser expects to find a
+ pseudo-class/pseudo-element (thanks to @ashelley).
+* Adds support for line/column locations for selector nodes, as well as a
+ `Node#sourceIndex` method (thanks to @davidtheclark).
+
+# 1.1.4
+
+* Fixes a crash when a selector started with a `>` combinator. The module will
+ now no longer throw if a selector has a leading/trailing combinator node.
+
+# 1.1.3
+
+* Fixes a crash on `@` tokens.
+
+# 1.1.2
+
+* Fixes an infinite loop caused by using parentheses in a non-pseudo element
+ context.
+
+# 1.1.1
+
+* Fixes a crash when a backslash ended a selector string.
+
+# 1.1.0
+
+* Adds support for replacing multiple nodes at once with `replaceWith`
+ (thanks to @jonathantneal).
+* Parser no longer throws on sequential IDs and trailing commas, to support
+ parsing of selector hacks.
+
+# 1.0.1
+
+* Fixes using `insertAfter` and `insertBefore` during iteration.
+
+# 1.0.0
+
+* Adds `clone` and `replaceWith` methods to nodes.
+* Adds `insertBefore` and `insertAfter` to containers.
+* Stabilises API.
+
+# 0.0.5
+
+* Fixes crash on extra whitespace inside a pseudo selector's parentheses.
+* Adds sort function to the container class.
+* Enables the parser to pass its input through without transforming.
+* Iteration-safe `each` and `eachInside`.
+
+# 0.0.4
+
+* Tidy up redundant duplication.
+* Fixes a bug where the parser would loop infinitely on universal selectors
+ inside pseudo selectors.
+* Adds `length` getter and `eachInside`, `map`, `reduce` to the container class.
+* When a selector has been removed from the tree, the root node will no longer
+ cast it to a string.
+* Adds node type iterators to the container class (e.g. `eachComment`).
+* Adds filter function to the container class.
+* Adds split function to the container class.
+* Create new node types by doing `parser.id(opts)` etc.
+* Adds support for pseudo classes anywhere in the selector.
+
+# 0.0.3
+
+* Adds `next` and `prev` to the node class.
+* Adds `first` and `last` getters to the container class.
+* Adds `every` and `some` iterators to the container class.
+* Add `empty` alias for `removeAll`.
+* Combinators are now types of node.
+* Fixes the at method so that it is not an alias for `index`.
+* Tidy up creation of new nodes in the parser.
+* Refactors how namespaces are handled for consistency & less redundant code.
+* Refactors AST to use `nodes` exclusively, and eliminates excessive nesting.
+* Fixes nested pseudo parsing.
+* Fixes whitespace parsing.
+
+# 0.0.2
+
+* Adds support for namespace selectors.
+* Adds support for selectors joined by escaped spaces - such as `.\31\ 0`.
+
+# 0.0.1
+
+* Initial release.
diff --git a/node_modules/postcss-selector-parser/LICENSE-MIT b/node_modules/postcss-selector-parser/LICENSE-MIT
new file mode 100644
index 0000000..fd0e863
--- /dev/null
+++ b/node_modules/postcss-selector-parser/LICENSE-MIT
@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs (http://beneb.info)
+
+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/postcss-selector-parser/README.md b/node_modules/postcss-selector-parser/README.md
new file mode 100644
index 0000000..28e44f2
--- /dev/null
+++ b/node_modules/postcss-selector-parser/README.md
@@ -0,0 +1,49 @@
+# postcss-selector-parser [](https://github.com/postcss/postcss-selector-parser/actions/workflows/test.yml)
+
+> Selector parser with built in methods for working with selector strings.
+
+## Install
+
+With [npm](https://npmjs.com/package/postcss-selector-parser) do:
+
+```
+npm install postcss-selector-parser
+```
+
+## Quick Start
+
+```js
+const parser = require('postcss-selector-parser');
+const transform = selectors => {
+ selectors.walk(selector => {
+ // do something with the selector
+ console.log(String(selector))
+ });
+};
+
+const transformed = parser(transform).processSync('h1, h2, h3');
+```
+
+To normalize selector whitespace:
+
+```js
+const parser = require('postcss-selector-parser');
+const normalized = parser().processSync('h1, h2, h3', {lossless: false});
+// -> h1,h2,h3
+```
+
+Async support is provided through `parser.process` and will resolve a Promise
+with the resulting selector string.
+
+## API
+
+Please see [API.md](API.md).
+
+## Credits
+
+* Huge thanks to Andrey Sitnik (@ai) for work on PostCSS which helped
+ accelerate this module's development.
+
+## License
+
+MIT
diff --git a/node_modules/postcss-selector-parser/package.json b/node_modules/postcss-selector-parser/package.json
new file mode 100644
index 0000000..0b074d0
--- /dev/null
+++ b/node_modules/postcss-selector-parser/package.json
@@ -0,0 +1,80 @@
+{
+ "name": "postcss-selector-parser",
+ "version": "6.1.2",
+ "devDependencies": {
+ "@babel/cli": "^7.11.6",
+ "@babel/core": "^7.11.6",
+ "@babel/eslint-parser": "^7.11.5",
+ "@babel/eslint-plugin": "^7.11.5",
+ "@babel/plugin-proposal-class-properties": "^7.10.4",
+ "@babel/preset-env": "^7.11.5",
+ "@babel/register": "^7.11.5",
+ "ava": "^5.1.0",
+ "babel-plugin-add-module-exports": "^1.0.4",
+ "coveralls": "^3.1.0",
+ "del-cli": "^5.0.0",
+ "eslint": "^8.28.0",
+ "eslint-plugin-import": "^2.26.0",
+ "glob": "^8.0.3",
+ "minimist": "^1.2.5",
+ "nyc": "^15.1.0",
+ "postcss": "^8.4.31",
+ "semver": "^7.3.2",
+ "typescript": "^4.0.3"
+ },
+ "main": "dist/index.js",
+ "types": "postcss-selector-parser.d.ts",
+ "files": [
+ "API.md",
+ "CHANGELOG.md",
+ "LICENSE-MIT",
+ "dist",
+ "postcss-selector-parser.d.ts",
+ "!**/__tests__"
+ ],
+ "scripts": {
+ "typecheck": "tsc --noEmit --strict postcss-selector-parser.d.ts postcss-selector-parser.test.ts",
+ "pretest": "eslint src && npm run typecheck",
+ "prepare": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/",
+ "lintfix": "eslint --fix src",
+ "report": "nyc report --reporter=html",
+ "test": "nyc ava src/__tests__/*.mjs",
+ "testone": "ava"
+ },
+ "dependencies": {
+ "cssesc": "^3.0.0",
+ "util-deprecate": "^1.0.2"
+ },
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ },
+ "homepage": "https://github.com/postcss/postcss-selector-parser",
+ "contributors": [
+ {
+ "name": "Ben Briggs",
+ "email": "beneb.info@gmail.com",
+ "url": "http://beneb.info"
+ },
+ {
+ "name": "Chris Eppstein",
+ "email": "chris@eppsteins.net",
+ "url": "http://twitter.com/chriseppstein"
+ }
+ ],
+ "repository": "postcss/postcss-selector-parser",
+ "ava": {
+ "require": [
+ "@babel/register"
+ ],
+ "concurrency": 5,
+ "timeout": "25s",
+ "nodeArguments": []
+ },
+ "nyc": {
+ "exclude": [
+ "node_modules",
+ "**/__tests__"
+ ]
+ }
+}
diff --git a/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
new file mode 100644
index 0000000..af609e6
--- /dev/null
+++ b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
@@ -0,0 +1,555 @@
+// Type definitions for postcss-selector-parser 2.2.3
+// Definitions by: Chris Eppstein
+
+/*~ Note that ES6 modules cannot directly export callable functions.
+ *~ This file should be imported using the CommonJS-style:
+ *~ import x = require('someLibrary');
+ *~
+ *~ Refer to the documentation to understand common
+ *~ workarounds for this limitation of ES6 modules.
+ */
+
+/*~ This declaration specifies that the function
+ *~ is the exported object from the file
+ */
+export = parser;
+
+// A type that's T but not U.
+type Diff = T extends U ? never : T;
+
+// TODO: Conditional types in TS 1.8 will really clean this up.
+declare function parser(): parser.Processor;
+declare function parser(processor: parser.AsyncProcessor): parser.Processor;
+declare function parser(processor: parser.AsyncProcessor): parser.Processor;
+declare function parser(processor: parser.SyncProcessor): parser.Processor;
+declare function parser(processor: parser.SyncProcessor): parser.Processor;
+declare function parser(processor?: parser.SyncProcessor | parser.AsyncProcessor): parser.Processor;
+
+/*~ If you want to expose types from your module as well, you can
+ *~ place them in this block. Often you will want to describe the
+ *~ shape of the return type of the function; that type should
+ *~ be declared in here, as this example shows.
+ */
+declare namespace parser {
+ /* copied from postcss -- so we don't need to add a dependency */
+ type ErrorOptions = {
+ plugin?: string;
+ word?: string;
+ index?: number
+ };
+ /* the bits we use of postcss.Rule, copied from postcss -- so we don't need to add a dependency */
+ type PostCSSRuleNode = {
+ selector: string
+ /**
+ * @returns postcss.CssSyntaxError but it's a complex object, caller
+ * should cast to it if they have a dependency on postcss.
+ */
+ error(message: string, options?: ErrorOptions): Error;
+ };
+ /** Accepts a string */
+ type Selectors = string | PostCSSRuleNode
+ type ProcessorFn
+ 
+ 
+ 
+ 
+ 
+
+## Layout DSL
+
+cliui exposes a simple layout DSL:
+
+If you create a single `ui.div`, passing a string rather than an
+object:
+
+* `\n`: characters will be interpreted as new rows.
+* `\t`: characters will be interpreted as new columns.
+* `\s`: characters will be interpreted as padding.
+
+**as an example...**
+
+```js
+var ui = require('./')({
+ width: 60
+})
+
+ui.div(
+ 'Usage: node ./bin/foo.js\n' +
+ ' 
+
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+