node_modules/.bin/cordova

@@ -0,0 +1 @@
+../cordova/bin/cordova

node_modules/.bin/is-ci

@@ -0,0 +1 @@
+../is-ci/bin.js

node_modules/.bin/is-docker

@@ -0,0 +1 @@
+../is-docker/cli.js

node_modules/.bin/md5-file

@@ -0,0 +1 @@
+../md5-file/cli.js

node_modules/.bin/node-which

@@ -0,0 +1 @@
+../which/bin/node-which

node_modules/.bin/rc

@@ -0,0 +1 @@
+../rc/cli.js

node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

node_modules/.bin/sshpk-conv

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-conv

node_modules/.bin/sshpk-sign

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-sign

node_modules/.bin/sshpk-verify

@@ -0,0 +1 @@
+../sshpk/bin/sshpk-verify

node_modules/.bin/systeminformation

@@ -0,0 +1 @@
+../systeminformation/lib/cli.js

node_modules/.bin/uuid

@@ -0,0 +1 @@
+../uuid/bin/uuid

node_modules/@netflix/nerror/CHANGELOG.md

@@ -0,0 +1,41 @@
+<a name="1.1.3"></a>
+### 1.1.3 (2019-11-27)
+
+
+#### Bug Fixes
+
+* **nerror:**  don't call extsprintf if single string passed to VError constructor (#11) ([89b2088b](https://github.com/Netflix/nerror/commit/89b2088b))
+
+
+<a name="1.1.2"></a>
+### 1.1.2 (2019-07-26)
+
+
+<a name="1.1.1"></a>
+### 1.1.1 (2019-07-09)
+
+
+<a name="1.1.0"></a>
+## 1.1.0 (2019-05-06)
+
+
+#### Features
+
+* **errorForEach:** make it MultiError support more general (#2) ([96cc8769](https://github.com/Netflix/nerror/commit/96cc8769))
+
+
+<a name="1.0.0"></a>
+## 1.0.0 (2019-05-02)
+
+
+#### Features
+
+* **nerror:** initial commit ([c959d4fc](https://github.com/Netflix/nerror/commit/c959d4fc))
+
+
+#### Breaking Changes
+
+* initial release
+
+ ([6ae8bd30](https://github.com/Netflix/nerror/commit/6ae8bd30))
+

node_modules/@netflix/nerror/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019, AUTHORS. All rights reserved.
+
+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

node_modules/@netflix/nerror/README.md

@@ -0,0 +1,339 @@
+# nerror: rich JavaScript errors
+
+[![Build Status](https://travis-ci.org/Netflix/nerror.svg?branch=master)](https://travis-ci.org/Netflix/nerror)
+
+*Netflix services uses [VError](https://github.com/joyent/node-verror) to make
+operation of Node.js applications easier  through meaningful error chains.
+VError is an amazing library by Joyent and we  are glad for all the hard work
+for the contributors made during the years.
+In early 2019 Netflix error handling requirements started to broaden enough that
+we had to find a way to make quick iterations on VError with minimizing the
+churn on existing VError customers. As a result of this we decided to fork
+VError as NError. We hope in the future after the initial development period we
+can seek convergence between the two projects.*
+
+This module provides several classes in support of Joyent's [Best Practices for
+Error Handling in Node.js](http://www.joyent.com/developers/node/design/errors).
+If you find any of the behavior here confusing or surprising, check out that
+document first.
+
+## API
+
+See [API](/api.md)
+
+## Classes
+
+The error classes here support:
+
+* printf-style arguments for the message
+* chains of causes
+* properties to provide extra information about the error
+* creating your own subclasses that support all of these
+
+The classes here are:
+
+* **VError**, for chaining errors while preserving each one's error message.
+  This is useful in servers and command-line utilities when you want to
+  propagate an error up a call stack, but allow various levels to add their own
+  context.  See examples below.
+* **WError**, for wrapping errors while hiding the lower-level messages from the
+  top-level error.  This is useful for API endpoints where you don't want to
+  expose internal error messages, but you still want to preserve the error chain
+  for logging and debugging.
+* **PError**, which is just like VError but does not interpret printf-style
+  arguments at all.
+* **SError**, which is just like VError but interprets printf-style arguments
+  more strictly.
+* **MultiError**, which is just an Error that encapsulates one or more other
+  errors.  (This is used for parallel operations that return several errors.)
+
+For the full list of features see [API](/api.md).
+
+## Quick start
+
+First, install the package:
+
+    npm install @netflix/nerror
+
+If nothing else, you can use VError as a drop-in replacement for the built-in
+JavaScript Error class, with the addition of printf-style messages:
+
+```javascript
+const { VError } = require('@netflix/nerror');
+const err = new VError('missing file: "%s"', '/etc/passwd');
+console.log(err.message);
+```
+
+This prints:
+
+    missing file: "/etc/passwd"
+
+You can also pass a `cause` argument, which is any other Error object:
+
+```javascript
+const fs = require('fs');
+const filename = '/nonexistent';
+fs.stat(filename, function (err1) {
+	const err2 = new VError(err1, 'stat "%s"', filename);
+	console.error(err2.message);
+});
+```
+
+This prints out:
+
+    stat "/nonexistent": ENOENT, stat '/nonexistent'
+
+which resembles how Unix programs typically report errors:
+
+    $ sort /nonexistent
+    sort: open failed: /nonexistent: No such file or directory
+
+To match the Unixy feel, when you print out the error, just prepend the
+program's name to the VError's `message`.  Or just call
+[node-cmdutil.fail(your_verror)](https://github.com/joyent/node-cmdutil), which
+does this for you.
+
+You can get the next-level Error using `err.cause()`:
+
+```javascript
+console.error(err2.cause().message);
+```
+
+prints:
+
+    ENOENT, stat '/nonexistent'
+
+Of course, you can chain these as many times as you want, and it works with any
+kind of Error:
+
+```javascript
+const err1 = new Error('No such file or directory');
+const err2 = new VError(err1, 'failed to stat "%s"', '/junk');
+const err3 = new VError(err2, 'request failed');
+console.error(err3.message);
+```
+
+This prints:
+
+    request failed: failed to stat "/junk": No such file or directory
+
+The idea is that each layer in the stack annotates the error with a description
+of what it was doing.  The end result is a message that explains what happened
+at each level.
+
+You can also decorate Error objects with additional information so that callers
+can not only handle each kind of error differently, but also construct their own
+error messages (e.g., to localize them, format them, group them by type, and so
+on).  See the example below.
+
+
+## Deeper dive
+
+The two main goals for VError are:
+
+* **Make it easy to construct clear, complete error messages intended for
+  people.**  Clear error messages greatly improve both user experience and
+  debuggability, so we wanted to make it easy to build them.  That's why the
+  constructor takes printf-style arguments.
+* **Make it easy to construct objects with programmatically-accessible
+  metadata** (which we call _informational properties_).  Instead of just saying
+  "connection refused while connecting to 192.168.1.2:80", you can add
+  properties like `"ip": "192.168.1.2"` and `"tcpPort": 80`.  This can be used
+  for feeding into monitoring systems, analyzing large numbers of Errors (as
+  from a log file), or localizing error messages.
+
+To really make this useful, it also needs to be easy to compose Errors:
+higher-level code should be able to augment the Errors reported by lower-level
+code to provide a more complete description of what happened.  Instead of saying
+"connection refused", you can say "operation X failed: connection refused".
+That's why VError supports `causes`.
+
+In order for all this to work, programmers need to know that it's generally safe
+to wrap lower-level Errors with higher-level ones.  If you have existing code
+that handles Errors produced by a library, you should be able to wrap those
+Errors with a VError to add information without breaking the error handling
+code.  There are two obvious ways that this could break such consumers:
+
+* The error's name might change.  People typically use `name` to determine what
+  kind of Error they've got.  To ensure compatibility, you can create VErrors
+  with custom names, but this approach isn't great because it prevents you from
+  representing complex failures.  For this reason, VError provides
+  `findCauseByName`, which essentially asks: does this Error _or any of its
+  causes_ have this specific type?  If error handling code uses
+  `findCauseByName`, then subsystems can construct very specific causal chains
+  for debuggability and still let people handle simple cases easily.  There's an
+  example below.
+* The error's properties might change.  People often hang additional properties
+  off of Error objects.  If we wrap an existing Error in a new Error, those
+  properties would be lost unless we copied them.  But there are a variety of
+  both standard and non-standard Error properties that should _not_ be copied in
+  this way: most obviously `name`, `message`, and `stack`, but also `fileName`,
+  `lineNumber`, and a few others.  Plus, it's useful for some Error subclasses
+  to have their own private properties -- and there'd be no way to know whether
+  these should be copied.  For these reasons, VError first-classes these
+  information properties.  You have to provide them in the constructor, you can
+  only fetch them with the `info()` function, and VError takes care of making
+  sure properties from causes wind up in the `info()` output.
+
+Let's put this all together with an example from the node-fast RPC library.
+node-fast implements a simple RPC protocol for Node programs.  There's a server
+and client interface, and clients make RPC requests to servers.  Let's say the
+server fails with an UnauthorizedError with message "user 'bob' is not
+authorized".  The client wraps all server errors with a FastServerError.  The
+client also wraps all request errors with a FastRequestError that includes the
+name of the RPC call being made.  The result of this failed RPC might look like
+this:
+
+    name: FastRequestError
+    message: "request failed: server error: user 'bob' is not authorized"
+    rpcMsgid: <unique identifier for this request>
+    rpcMethod: GetObject
+    cause:
+        name: FastServerError
+        message: "server error: user 'bob' is not authorized"
+        cause:
+            name: UnauthorizedError
+            message: "user 'bob' is not authorized"
+            rpcUser: "bob"
+
+When the caller uses `VError.info()`, the information properties are collapsed
+so that it looks like this:
+
+    message: "request failed: server error: user 'bob' is not authorized"
+    rpcMsgid: <unique identifier for this request>
+    rpcMethod: GetObject
+    rpcUser: "bob"
+
+Taking this apart:
+
+* The error's message is a complete description of the problem.  The caller can
+  report this directly to its caller, which can potentially make its way back to
+  an end user (if appropriate).  It can also be logged.
+* The caller can tell that the request failed on the server, rather than as a
+  result of a client problem (e.g., failure to serialize the request), a
+  transport problem (e.g., failure to connect to the server), or something else
+  (e.g., a timeout).  They do this using `findCauseByName('FastServerError')`
+  rather than checking the `name` field directly.
+* If the caller logs this error, the logs can be analyzed to aggregate
+  errors by cause, by RPC method name, by user, or whatever.  Or the
+  error can be correlated with other events for the same rpcMsgid.
+* It wasn't very hard for any part of the code to contribute to this Error.
+  Each part of the stack has just a few lines to provide exactly what it knows,
+  with very little boilerplate.
+
+It's not expected that you'd use these complex forms all the time.  Despite
+supporting the complex case above, you can still just do:
+
+   new VError("my service isn't working");
+
+for the simple cases.
+
+
+## Examples
+
+The "Demo" section above covers several basic cases.  Here's a more advanced
+case:
+
+```javascript
+const err1 = new VError('something bad happened');
+/* ... */
+const err2 = new VError({
+    'name': 'ConnectionError',
+    'cause': err1,
+    'info': {
+        'errno': 'ECONNREFUSED',
+        'remote_ip': '127.0.0.1',
+        'port': 215
+    }
+}, 'failed to connect to "%s:%d"', '127.0.0.1', 215);
+
+console.log(err2.message);
+console.log(err2.name);
+console.log(VError.info(err2));
+console.log(err2.stack);
+```
+
+This outputs:
+
+    failed to connect to "127.0.0.1:215": something bad happened
+    ConnectionError
+    { errno: 'ECONNREFUSED', remote_ip: '127.0.0.1', port: 215 }
+    ConnectionError: failed to connect to "127.0.0.1:215": something bad happened
+        at Object.<anonymous> (/home/dap/node-verror/examples/info.js:5:12)
+        at Module._compile (module.js:456:26)
+        at Object.Module._extensions..js (module.js:474:10)
+        at Module.load (module.js:356:32)
+        at Function.Module._load (module.js:312:12)
+        at Function.Module.runMain (module.js:497:10)
+        at startup (node.js:119:16)
+        at node.js:935:3
+
+Information properties are inherited up the cause chain, with values at the top
+of the chain overriding same-named values lower in the chain.  To continue that
+example:
+
+```javascript
+const err3 = new VError({
+    'name': 'RequestError',
+    'cause': err2,
+    'info': {
+        'errno': 'EBADREQUEST'
+    }
+}, 'request failed');
+
+console.log(err3.message);
+console.log(err3.name);
+console.log(VError.info(err3));
+console.log(err3.stack);
+```
+
+This outputs:
+
+    request failed: failed to connect to "127.0.0.1:215": something bad happened
+    RequestError
+    { errno: 'EBADREQUEST', remote_ip: '127.0.0.1', port: 215 }
+    RequestError: request failed: failed to connect to "127.0.0.1:215": something bad happened
+        at Object.<anonymous> (/home/dap/node-verror/examples/info.js:20:12)
+        at Module._compile (module.js:456:26)
+        at Object.Module._extensions..js (module.js:474:10)
+        at Module.load (module.js:356:32)
+        at Function.Module._load (module.js:312:12)
+        at Function.Module.runMain (module.js:497:10)
+        at startup (node.js:119:16)
+        at node.js:935:3
+
+You can also print the complete stack trace of combined `Error`s by using
+`VError.fullStack(err).`
+
+```javascript
+const err1 = new VError('something bad happened');
+/* ... */
+const err2 = new VError(err1, 'something really bad happened here');
+
+console.log(VError.fullStack(err2));
+```
+
+This outputs:
+
+    VError: something really bad happened here: something bad happened
+        at Object.<anonymous> (/home/dap/node-verror/examples/fullStack.js:5:12)
+        at Module._compile (module.js:409:26)
+        at Object.Module._extensions..js (module.js:416:10)
+        at Module.load (module.js:343:32)
+        at Function.Module._load (module.js:300:12)
+        at Function.Module.runMain (module.js:441:10)
+        at startup (node.js:139:18)
+        at node.js:968:3
+    caused by: VError: something bad happened
+        at Object.<anonymous> (/home/dap/node-verror/examples/fullStack.js:3:12)
+        at Module._compile (module.js:409:26)
+        at Object.Module._extensions..js (module.js:416:10)
+        at Module.load (module.js:343:32)
+        at Function.Module._load (module.js:300:12)
+        at Function.Module.runMain (module.js:441:10)
+        at startup (node.js:139:18)
+        at node.js:968:3
+
+`VError.fullStack` is also safe to use on regular `Error`s, so feel free to use
+it whenever you need to extract the stack trace from an `Error`, regardless if
+it's a `VError` or not.

node_modules/@netflix/nerror/lib/index.d.ts

@@ -0,0 +1,67 @@
+export class VError extends Error {
+    static VError: typeof VError;
+
+    static cause(err: Error): Error | null;
+    static info(err: Error): VError.Info;
+    static fullStack(err: Error): string;
+    static findCauseByName(err: Error, name: string): Error | null;
+    static hasCauseWithName(err: Error, name: string): boolean;
+    static errorFromList<T extends Error>(
+        errors: T[]
+    ): null | T | VError.MultiError;
+    static errorForEach(err: Error, func: (err: Error) => void): void;
+
+    cause(): Error | undefined;
+    constructor(
+        options: VError.Options | Error,
+        message: string,
+        ...params: any[]
+    );
+    constructor(message?: string, ...params: any[]);
+}
+
+export namespace VError {
+    interface Info {
+        [key: string]: any;
+    }
+
+    interface Options {
+        cause?: Error | null;
+        name?: string;
+        strict?: boolean;
+        constructorOpt?(...args: any[]): void;
+        info?: Info;
+    }
+
+    /*
+     * SError is like VError, but stricter about types.  You cannot pass "null" or
+     * "undefined" as string arguments to the formatter.  Since SError is only a
+     * different function, not really a different class, we don't set
+     * SError.prototype.name.
+     */
+    class SError extends VError {}
+
+    /*
+     * PError is like VError, but the message is not run through printf-style
+     * templating.
+     */
+    class PError extends VError {}
+
+    /*
+     * Represents a collection of errors for the purpose of consumers that generally
+     * only deal with one error.  Callers can extract the individual errors
+     * contained in this object, but may also just treat it as a normal single
+     * error, in which case a summary message will be printed.
+     */
+    class MultiError extends VError {
+        constructor(errors: Error[]);
+        errors(): Error[];
+    }
+
+    /*
+     * Like JavaScript's built-in Error class, but supports a "cause" argument which
+     * is wrapped, not "folded in" as with VError.	Accepts a printf-style message.
+     * The cause argument can be null.
+     */
+    class WError extends VError {}
+}

node_modules/@netflix/nerror/lib/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./verror');

node_modules/@netflix/nerror/lib/verror.js

@@ -0,0 +1,813 @@
+'use strict';
+
+/*
+ * verror.js: richer JavaScript errors
+ */
+const util = require('util');
+
+const _ = require('lodash');
+const assert = require('assert-plus');
+const { sprintf } = require('extsprintf');
+
+/*
+ * Public interface
+ */
+
+/* So you can 'var VError = require('@netflix/nerror')' */
+module.exports = VError;
+/* For compatibility */
+VError.VError = VError;
+/* Other exported classes */
+VError.PError = PError;
+VError.SError = SError;
+VError.WError = WError;
+VError.MultiError = MultiError;
+
+/**
+ * Normalized forms, producing an object with the following properties.
+ * @private
+ * @typedef {Object} ParsedOptions parsed Options
+ * @param {Object} options e- quivalent to "options" in third form. This will
+ *              never
+ *    			be a direct reference to what the caller passed in
+ *    			(i.e., it may be a shallow copy), so it can be freely
+ *    			modified.
+ * @param {String} shortmessage - result of sprintf(sprintf_args), taking
+ *              `options.strict` into account as described in README.md.
+ */
+
+/**
+ * Common function used to parse constructor arguments for VError, WError, and
+ * SError.  Named arguments to this function:
+ *
+ *     strict		force strict interpretation of sprintf arguments, even
+ *     			if the options in "argv" don't say so
+ *
+ *     argv		error's constructor arguments, which are to be
+ *     			interpreted as described in README.md.  For quick
+ *     			reference, "argv" has one of the following forms:
+ *
+ *          [ sprintf_args... ]           (argv[0] is a string)
+ *          [ cause, sprintf_args... ]    (argv[0] is an Error)
+ *          [ options, sprintf_args... ]  (argv[0] is an object)
+ *
+
+ * @private
+ * @param {Array} args - arguments
+ * @returns {ParsedOptions} parsed options
+ */
+function parseConstructorArguments(args) {
+    let options, sprintf_args, shortmessage, k;
+
+    assert.object(args, 'args');
+    assert.bool(args.strict, 'args.strict');
+    assert.array(args.argv, 'args.argv');
+    assert.optionalBool(args.skipPrintf, 'args.skipPrintf');
+    const argv = args.argv;
+
+    /*
+     * First, figure out which form of invocation we've been given.
+     */
+    if (argv.length === 0) {
+        options = {};
+        sprintf_args = [];
+    } else if (_.isError(argv[0])) {
+        options = { cause: argv[0] };
+        sprintf_args = argv.slice(1);
+    } else if (typeof argv[0] === 'object') {
+        options = {};
+        // eslint-disable-next-line guard-for-in
+        for (k in argv[0]) {
+            options[k] = argv[0][k];
+        }
+        sprintf_args = argv.slice(1);
+    } else {
+        assert.string(
+            argv[0],
+            'first argument to VError, PError, SError, or WError ' +
+                'constructor must be a string, object, or Error'
+        );
+        options = {};
+        sprintf_args = argv;
+    }
+
+    // Preserve options
+    if (args.skipPrintf) {
+        options.skipPrintf = args.skipPrintf;
+    }
+    if (args.strict) {
+        options.strict = args.strict;
+    }
+
+    /*
+     * Now construct the error's message.
+     *
+     * extsprintf (which we invoke here with our caller's arguments in order
+     * to construct this Error's message) is strict in its interpretation of
+     * values to be processed by the "%s" specifier.  The value passed to
+     * extsprintf must actually be a string or something convertible to a
+     * String using .toString().  Passing other values (notably "null" and
+     * "undefined") is considered a programmer error.  The assumption is
+     * that if you actually want to print the string "null" or "undefined",
+     * then that's easy to do that when you're calling extsprintf; on the
+     * other hand, if you did NOT want that (i.e., there's actually a bug
+     * where the program assumes some variable is non-null and tries to
+     * print it, which might happen when constructing a packet or file in
+     * some specific format), then it's better to stop immediately than
+     * produce bogus output.
+     *
+     * However, sometimes the bug is only in the code calling VError, and a
+     * programmer might prefer to have the error message contain "null" or
+     * "undefined" rather than have the bug in the error path crash the
+     * program (making the first bug harder to identify).  For that reason,
+     * by default VError converts "null" or "undefined" arguments to their
+     * string representations and passes those to extsprintf.  Programmers
+     * desiring the strict behavior can use the SError class or pass the
+     * "strict" option to the VError constructor.
+     */
+    assert.object(options);
+    if (!options.skipPrintf && !options.strict && !args.strict) {
+        sprintf_args = sprintf_args.map(function(a) {
+            return a === null ? 'null' : a === undefined ? 'undefined' : a;
+        });
+    }
+
+    if (sprintf_args.length === 0) {
+        shortmessage = '';
+    } else if (
+        options.skipPrintf ||
+        (sprintf_args.length === 1 && typeof sprintf_args[0] === 'string')
+    ) {
+        assert.equal(
+            sprintf_args.length,
+            1,
+            'only one argument is allowed with options.skipPrintf'
+        );
+        shortmessage = sprintf_args[0];
+    } else {
+        shortmessage = sprintf.apply(null, sprintf_args);
+    }
+
+    return {
+        options: options,
+        shortmessage: shortmessage
+    };
+}
+
+/**
+ * @public
+ * @typedef {Object} VErrorOptions Options
+ * @param {String} name - Name of the error.
+ * @param {Error} [cause] -  Indicates that the new error was caused by `cause`.
+ * @param {Boolean} [strict=false] - If true, then `null` and `undefined` values
+ *  in `sprintf_args` are passed through to `sprintf()`
+ * @param {Function} [constructorOpt] -If specified, then the stack trace for
+ *  this error ends at function `constructorOpt`.
+ * @param {Object} [info]- Specifies arbitrary informational properties.
+ * @param {Boolean} [skipPrintf=false] - If true, then `sprintf()` is not called
+ */
+
+/**
+ *
+ * About Constructor:
+ * All of these forms construct a new VError that behaves just like the built-in
+ * JavaScript `Error` class, with some additional methods described below.
+ *
+ * About Properties:
+ * For all of these classes except `PError`, the printf-style arguments passed to
+ * the constructor are processed with `sprintf()` to form a message.
+ * For `WError`, this becomes the complete `message` property.  For `SError` and
+ * `VError`, this message is prepended to the message of the cause, if any
+ * (with a suitable separator), and the result becomes the `message` property.
+ *
+ * The `stack` property is managed entirely by the underlying JavaScript
+ * implementation.  It's generally implemented using a getter function because
+ * constructing the human-readable stack trace is somewhat expensive.
+ *
+ * @public
+ * @class VError
+ * @param {...String|VErrorOptions|Error} [arg] - sprintf args, options or cause
+ * @param {...String} [args] - sprintf args
+ * @property {String} name - Programmatically-usable name of the error.
+ * @property {String} message - Human-readable summary of the failure.
+ * Programmatically-accessible details are provided through `VError.info(err)`
+ * class method.
+ * @property {String} stack - Human-readable stack trace where the Error was
+ * constructed.
+ * @example
+ * // This is the most general form.  You can specify any supported options
+ * // including "cause" and "info") this way.</caption>
+ * new VError(options, sprintf_args...)
+ * @example
+ * // This is a useful shorthand when the only option you need is "cause".
+ * new VError(cause, sprintf_args...)
+ * @example
+ * // This is a useful shorthand when you don't need any options at all.
+ * new VError(sprintf_args...)
+ */
+function VError(...args) {
+    let obj, ctor, message, k;
+
+    /*
+     * This is a regrettable pattern, but JavaScript's built-in Error class
+     * is defined to work this way, so we allow the constructor to be called
+     * without "new".
+     */
+    if (!(this instanceof VError)) {
+        obj = Object.create(VError.prototype);
+        VError.apply(obj, arguments);
+        return obj;
+    }
+
+    /*
+     * For convenience and backwards compatibility, we support several
+     * different calling forms.  Normalize them here.
+     */
+    const parsed = parseConstructorArguments({
+        argv: args,
+        strict: false
+    });
+
+    /*
+     * If we've been given a name, apply it now.
+     */
+    if (parsed.options.name) {
+        assert.string(parsed.options.name, 'error\'s "name" must be a string');
+        this.name = parsed.options.name;
+    }
+
+    /*
+     * For debugging, we keep track of the original short message (attached
+     * this Error particularly) separately from the complete message (which
+     * includes the messages of our cause chain).
+     */
+    this.jse_shortmsg = parsed.shortmessage;
+    message = parsed.shortmessage;
+
+    /*
+     * If we've been given a cause, record a reference to it and update our
+     * message appropriately.
+     */
+    const cause = parsed.options.cause;
+    if (cause) {
+        VError._assertError(cause, '"cause" must be an Error');
+        this.jse_cause = cause;
+
+        if (!parsed.options.skipCauseMessage) {
+            message += ': ' + cause.message;
+        }
+    }
+
+    /*
+     * If we've been given an object with properties, shallow-copy that
+     * here.  We don't want to use a deep copy in case there are non-plain
+     * objects here, but we don't want to use the original object in case
+     * the caller modifies it later.
+     */
+    this.jse_info = {};
+    if (parsed.options.info) {
+        // eslint-disable-next-line guard-for-in
+        for (k in parsed.options.info) {
+            this.jse_info[k] = parsed.options.info[k];
+        }
+    }
+
+    this.message = message;
+    Error.call(this, message);
+
+    if (Error.captureStackTrace) {
+        ctor = parsed.options.constructorOpt || this.constructor;
+        Error.captureStackTrace(this, ctor);
+    }
+
+    return this;
+}
+
+util.inherits(VError, Error);
+VError.prototype.name = 'VError';
+
+/**
+ * Appends any keys/fields to the existing jse_info. this can stomp over any
+ * existing fields.
+ * @public
+ * @memberof VError.prototype
+ * @param {Object} obj source obj to assign fields from
+ * @return {Object} new info object
+ */
+VError.prototype.assignInfo = function ve_assignInfo(obj) {
+    assert.optionalObject(obj, 'obj');
+    return Object.assign(this.jse_info, obj);
+};
+
+/**
+ * Instance level convenience method vs using the static methods on VError.
+ * @public
+ * @memberof VError.prototype
+ * @return {Object} info object
+ */
+VError.prototype.info = function ve_info() {
+    return VError.info(this);
+};
+
+/**
+ * A string representing the VError.
+ * @public
+ * @memberof VError.prototype
+ * @return {String} string representation
+ */
+VError.prototype.toString = function ve_toString() {
+    let str =
+        (this.hasOwnProperty('name') && this.name) ||
+        this.constructor.name ||
+        this.constructor.prototype.name;
+    if (this.message) {
+        str += ': ' + this.message;
+    }
+
+    return str;
+};
+
+/**
+ * This method is provided for compatibility.  New callers should use
+ * VError.cause() instead.  That method also uses the saner `null` return value
+ * when there is no cause.
+ * @public
+ * @memberof VError.prototype
+ * @return {undefined|Error} Error cause if any
+ */
+VError.prototype.cause = function ve_cause() {
+    const cause = VError.cause(this);
+    return cause === null ? undefined : cause;
+};
+
+/*
+ * Static methods
+ *
+ * These class-level methods are provided so that callers can use them on
+ * instances of Errors that are not VErrors.  New interfaces should be provided
+ * only using static methods to eliminate the class of programming mistake where
+ * people fail to check whether the Error object has the corresponding methods.
+ */
+
+/**
+ * @private
+ * @static
+ * @memberof VError
+ * @param {Error} err - error to assert
+ * @param {String} [msg] - optional message
+ * @returns {undefined} no return value
+ * @throws AssertationError - when input is not an error
+ */
+VError._assertError = function _assertError(err, msg) {
+    assert.optionalString(msg, 'msg');
+    const _msg = (msg || 'err must be an Error') + ` but got ${String(err)}`;
+    assert.ok(_.isError(err), _msg);
+};
+
+/**
+ * Checks if an error is a VError or VError sub-class.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {Error} err - error
+ * @return {Boolean} is a VError or VError sub-class
+ */
+VError.isVError = function assignInfo(err) {
+    // We are checking on internals here instead of using
+    // `err instanceof VError` to being compatible with the original VError lib.
+    return err && err.hasOwnProperty('jse_info');
+};
+
+/**
+ * Appends any keys/fields to the `jse_info`. This can stomp over any existing
+ * fields.
+ *
+ * Note: This method is static because in this way we don't need to check on
+ * VError versions to be sure `assignInfo` method is supported.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {Error} err - error
+ * @param {Object} obj - source obj to assign fields from
+ * @return {Object} new info object
+ */
+VError.assignInfo = function assignInfo(err, obj) {
+    VError._assertError(err);
+    assert.optionalObject(obj, 'obj');
+
+    if (!VError.isVError(err)) {
+        throw new TypeError('err must be an instance of VError');
+    }
+
+    return Object.assign(err.jse_info, obj);
+};
+
+/**
+ * Returns the next Error in the cause chain for `err`, or `null` if there is no
+ * next error.  See the `cause` argument to the constructor.
+ * Errors can have arbitrarily long cause chains.  You can walk the `cause`
+ * chain by invoking `VError.cause(err)` on each subsequent return value.
+ * If `err` is not a `VError`, the cause is `null`.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {VError} err - error
+ * @return {undefined|Error} Error cause if any
+ */
+VError.cause = function cause(err) {
+    VError._assertError(err);
+    return _.isError(err.jse_cause) ? err.jse_cause : null;
+};
+
+/**
+ * Returns an object with all of the extra error information that's been
+ * associated with this Error and all of its causes. These are the properties
+ * passed in using the `info` option to the constructor. Properties not
+ * specified in the constructor for this Error are implicitly inherited from
+ * this error's cause.
+ *
+ * These properties are intended to provide programmatically-accessible metadata
+ * about the error.  For an error that indicates a failure to resolve a DNS
+ * name, informational properties might include the DNS name to be resolved, or
+ * even the list of resolvers used to resolve it.  The values of these
+ * properties should generally be plain objects (i.e., consisting only of null,
+ * undefined, numbers, booleans, strings, and objects and arrays containing only
+ * other plain objects).
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {VError} err - error
+ * @return {Object} info object
+ */
+VError.info = function info(err) {
+    let rv, k;
+
+    VError._assertError(err);
+    const cause = VError.cause(err);
+    if (cause !== null) {
+        rv = VError.info(cause);
+    } else {
+        rv = {};
+    }
+
+    if (typeof err.jse_info === 'object' && err.jse_info !== null) {
+        // eslint-disable-next-line guard-for-in
+        for (k in err.jse_info) {
+            rv[k] = err.jse_info[k];
+        }
+    }
+
+    return rv;
+};
+
+/**
+ * The `findCauseByName()` function traverses the cause chain for `err`, looking
+ * for an error whose `name` property matches the passed in `name` value. If no
+ * match is found, `null` is returned.
+ *
+ * If all you want is to know _whether_ there's a cause (and you don't care what
+ * it is), you can use `VError.hasCauseWithName(err, name)`.
+ *
+ * If a vanilla error or a non-VError error is passed in, then there is no cause
+ * chain to traverse. In this scenario, the function will check the `name`
+ * property of only `err`.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {VError} err - error
+ * @param {String} name - name of cause Error
+ * @return {null|Error} cause if any
+ */
+VError.findCauseByName = function findCauseByName(err, name) {
+    let cause;
+
+    VError._assertError(err);
+    assert.string(name, 'name');
+    assert.ok(name.length > 0, 'name cannot be empty');
+
+    for (cause = err; cause !== null; cause = VError.cause(cause)) {
+        assert.ok(_.isError(cause));
+        if (cause.name === name) {
+            return cause;
+        }
+    }
+
+    return null;
+};
+
+/**
+ * Returns true if and only if `VError.findCauseByName(err, name)` would return
+ * a non-null value.  This essentially determines whether `err` has any cause in
+ * its cause chain that has name `name`.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {VError} err - error
+ * @param {String} name - name of cause Error
+ * @return {Boolean} has cause
+ */
+VError.hasCauseWithName = function hasCauseWithName(err, name) {
+    return VError.findCauseByName(err, name) !== null;
+};
+
+/**
+ * Returns a string containing the full stack trace, with all nested errors
+ * recursively reported as `'caused by:' + err.stack`.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {VError} err - error
+ * @return {String} full stack trace
+ */
+VError.fullStack = function fullStack(err) {
+    VError._assertError(err);
+
+    const cause = VError.cause(err);
+
+    if (cause) {
+        return err.stack + '\ncaused by: ' + VError.fullStack(cause);
+    }
+
+    return err.stack;
+};
+
+/**
+ * Given an array of Error objects (possibly empty), return a single error
+ * representing the whole collection of errors. If the list has:
+ *
+ * * 0 elements, returns `null`
+ * * 1 element, returns the sole error
+ * * more than 1 element, returns a MultiError referencing the whole list
+ *
+ * This is useful for cases where an operation may produce any number of errors,
+ * and you ultimately want to implement the usual `callback(err)` pattern.
+ * You can accumulate the errors in an array and then invoke
+ * `callback(VError.errorFromList(errors))` when the operation is complete.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {Array<Error>} errors - errors
+ * @return {null|Error|MultiError} single or multi error if any
+ */
+VError.errorFromList = function errorFromList(errors) {
+    assert.arrayOfObject(errors, 'errors');
+
+    if (errors.length === 0) {
+        return null;
+    }
+
+    errors.forEach(function(e) {
+        assert.ok(_.isError(e), 'all errors must be an Error');
+    });
+
+    if (errors.length === 1) {
+        return errors[0];
+    }
+
+    return new MultiError(errors);
+};
+
+/**
+ * Convenience function for iterating an error that may itself be a MultiError.
+ *
+ * In all cases, `err` must be an Error.  If `err` is a MultiError, then `func`
+ * is invoked as `func(errorN)` for each of the underlying errors of the
+ * MultiError.
+ * If `err` is any other kind of error, `func` is invoked once as `func(err)`.
+ * In all cases, `func` is invoked synchronously.
+ *
+ * This is useful for cases where an operation may produce any number of
+ * warnings that may be encapsulated with a MultiError -- but may not be.
+ *
+ * This function does not iterate an error's cause chain.
+ *
+ * @public
+ * @static
+ * @memberof VError
+ * @param {Error} err - error
+ * @param {Function} func - iterator
+ * @return {undefined} no return value
+ */
+VError.errorForEach = function errorForEach(err, func) {
+    VError._assertError(err);
+    assert.func(func, 'func');
+
+    if (err.name === 'MultiError') {
+        err.errors().forEach(function iterError(e) {
+            func(e);
+        });
+    } else {
+        func(err);
+    }
+};
+
+/**
+ * PError is like VError, but the message is not run through printf-style
+ * templating.
+ *
+ * @public
+ * @class PError
+ * @extends VError
+ * @param {...String|VErrorOptions|Error} [arg] - sprintf args, options or cause
+ * @param {...String} [args] - sprintf args
+ */
+function PError(...args) {
+    let obj;
+
+    if (!(this instanceof PError)) {
+        obj = Object.create(PError.prototype);
+        PError.apply(obj, args);
+        return obj;
+    }
+
+    const parsed = parseConstructorArguments({
+        argv: args,
+        strict: false,
+        skipPrintf: true
+    });
+
+    VError.call(this, parsed.options, parsed.shortmessage);
+
+    return this;
+}
+
+util.inherits(PError, VError);
+PError.prototype.name = 'PError';
+
+/**
+ * SError is like VError, but stricter about types. You cannot pass "null" or
+ * "undefined" as string arguments to the formatter.
+ *
+ * @public
+ * @class SError
+ * @extends VError
+ * @param {...String|VErrorOptions|Error} [arg] - sprintf args, options or cause
+ * @param {...String} [args] - sprintf args
+ */
+function SError(...args) {
+    let obj;
+
+    if (!(this instanceof SError)) {
+        obj = Object.create(SError.prototype);
+        SError.apply(obj, arguments);
+        return obj;
+    }
+
+    const parsed = parseConstructorArguments({
+        argv: args,
+        strict: true
+    });
+
+    const options = parsed.options;
+    options.skipPrintf = false;
+    VError.call(this, options, '%s', parsed.shortmessage);
+
+    return this;
+}
+
+/*
+ * We don't bother setting SError.prototype.name because once constructed,
+ * SErrors are just like VErrors.
+ */
+util.inherits(SError, VError);
+
+/**
+ * Represents a collection of errors for the purpose of consumers that generally
+ * only deal with one error.  Callers can extract the individual errors
+ * contained in this object, but may also just treat it as a normal single
+ * error, in which case a summary message will be printed.
+ *
+ * @public
+ * @class MultiError
+ * @extends VError
+ * @param {Array<Error>} errors - errors
+ * @example
+ * // `error_list` is an array of at least one `Error` object.
+ * new MultiError(error_list)
+ *
+ * // The cause of the MultiError is the first error provided.  None of the
+ * // other `VError` options are supported.  The `message` for a MultiError
+ * // consists the `message` from the first error, prepended with a message
+ * // indicating that there were other errors.
+ *
+ * //For example:
+ * err = new MultiError([
+ *     new Error('failed to resolve DNS name "abc.example.com"'),
+ *     new Error('failed to resolve DNS name "def.example.com"'),
+ * ]);
+ * console.error(err.message);
+ *
+ * // outputs:
+ * //   first of 2 errors: failed to resolve DNS name "abc.example.com"
+ */
+function MultiError(errors) {
+    assert.array(errors, 'list of errors');
+    assert.ok(errors.length > 0, 'must be at least one error');
+    this.ase_errors = errors;
+
+    VError.call(
+        this,
+        {
+            cause: errors[0]
+        },
+        'first of %d error%s',
+        errors.length,
+        errors.length === 1 ? '' : 's'
+    );
+}
+
+util.inherits(MultiError, VError);
+MultiError.prototype.name = 'MultiError';
+
+/**
+ * Returns an array of the errors used to construct this MultiError.
+ *
+ * @public
+ * @memberof MultiError.prototype
+ * @returns {Array<Error>} errors
+ */
+MultiError.prototype.errors = function me_errors() {
+    return this.ase_errors.slice(0);
+};
+
+/**
+ * WError for wrapping errors while hiding the lower-level messages from the
+ * top-level error.  This is useful for API endpoints where you don't want to
+ * expose internal error messages, but you still want to preserve the error
+ * chain for logging and debugging
+ *
+ * @public
+ * @class WError
+ * @extends VError
+ * @param {...String|VErrorOptions|Error} [arg] - sprintf args, options or cause
+ * @param {...String} [args] - sprintf args
+ */
+function WError(...args) {
+    let obj;
+
+    if (!(this instanceof WError)) {
+        obj = Object.create(WError.prototype);
+        WError.apply(obj, args);
+        return obj;
+    }
+
+    const parsed = parseConstructorArguments({
+        argv: args,
+        strict: false
+    });
+
+    const options = parsed.options;
+    options.skipCauseMessage = true;
+    options.skipPrintf = false;
+    VError.call(this, options, '%s', parsed.shortmessage);
+
+    return this;
+}
+
+util.inherits(WError, VError);
+WError.prototype.name = 'WError';
+
+/**
+ * A string representing the WError.
+ * @public
+ * @memberof WError.prototype
+ * @return {String} string representation
+ */
+WError.prototype.toString = function we_toString() {
+    let str =
+        (this.hasOwnProperty('name') && this.name) ||
+        this.constructor.name ||
+        this.constructor.prototype.name;
+    if (this.message) {
+        str += ': ' + this.message;
+    }
+    if (this.jse_cause && this.jse_cause.message) {
+        str += '; caused by ' + this.jse_cause.toString();
+    }
+
+    return str;
+};
+
+/**
+ * For purely historical reasons, WError's cause() function allows you to set
+ * the cause.
+ * @public
+ * @memberof WError.prototype
+ * @param {Error} c - cause
+ * @return {undefined|Error} Error cause
+ */
+WError.prototype.cause = function we_cause(c) {
+    if (_.isError(c)) {
+        this.jse_cause = c;
+    }
+
+    return this.jse_cause;
+};

node_modules/@netflix/nerror/package.json

@@ -0,0 +1,183 @@
+{
+  "_args": [
+    [
+      "@netflix/nerror@^1.1.3",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/cordova/node_modules/cordova-common"
+    ]
+  ],
+  "_from": "@netflix/nerror@>=1.1.3 <2.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "@netflix/nerror@1.1.3",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@netflix/nerror",
+  "_nodeVersion": "10.16.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/nerror_1.1.3_1574883672939_0.6018803222449305"
+  },
+  "_npmUser": {
+    "email": "email@martonpeter.com",
+    "name": "hekike"
+  },
+  "_npmVersion": "6.12.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@netflix/nerror",
+    "raw": "@netflix/nerror@^1.1.3",
+    "rawSpec": "^1.1.3",
+    "scope": "@netflix",
+    "spec": ">=1.1.3 <2.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/cordova-create/cordova-common",
+    "/cordova-fetch/cordova-common",
+    "/cordova-lib/cordova-common",
+    "/cordova/cordova-common"
+  ],
+  "_resolved": "https://registry.npmjs.org/@netflix/nerror/-/nerror-1.1.3.tgz",
+  "_shasum": "9d88eccca442f1d544f2761d15ea557dc0a44ed2",
+  "_shrinkwrap": null,
+  "_spec": "@netflix/nerror@^1.1.3",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/cordova/node_modules/cordova-common",
+  "bugs": {
+    "url": "https://github.com/Netflix/nerror/issues"
+  },
+  "contributors": [
+    {
+      "name": "Alex Liu",
+      "email": "DonutEspresso@users.noreply.github.com"
+    },
+    {
+      "name": "Peter Marton",
+      "email": "email@martonpeter.com"
+    },
+    {
+      "name": "Peter Marton",
+      "email": "pmarton@netflix.com"
+    },
+    {
+      "name": "Joyent"
+    },
+    {
+      "name": "David Pacheco"
+    },
+    {
+      "name": "Trent Mick"
+    },
+    {
+      "name": "cburroughs"
+    },
+    {
+      "name": "Simen Bekkhus"
+    },
+    {
+      "name": "Samer Masterson"
+    }
+  ],
+  "dependencies": {
+    "assert-plus": "^1.0.0",
+    "extsprintf": "^1.4.0",
+    "lodash": "^4.17.15"
+  },
+  "description": "Rich errors",
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "conventional-changelog-angular": "^5.0.0",
+    "conventional-recommended-bump": "^4.0.0",
+    "documentation": "^8.0.0",
+    "eslint": "^4.19.1",
+    "eslint-config-prettier": "^2.9.0",
+    "eslint-plugin-prettier": "^2.6.0",
+    "mocha": "^5.2.0",
+    "nyc": "^12.0.2",
+    "prettier": "^1.13.5",
+    "tsd": "^0.7.3",
+    "unleash": "^2.0.1"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 7,
+    "integrity": "sha512-b+MGNyP9/LXkapreJzNUzcvuzZslj/RGgdVVJ16P2wSlYatfLycPObImqVJSmNAdyeShvNeM/pl3sVZsObFueg==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJd3tFZCRA9TVsSAnZWagAAFhIP+wRDSXHnoEmTVs+fTqwR\nrsDbA/BmNwdUvDBOPzIWO2oOfKduOYZCerkvWXebxJls4LMEOO81y22wzRxh\noMXl17uEKuGfObOdwSe7NVlP3FOS3DkzoQCJtNVtcbrEhwpJKffxVT3glhsF\nXBhX00N8GWdkqMgleWR09YItaJ7VPwwhf6djInjbP5EpLtajQ6jilfNB5P46\n4KKMyg6Yuey5/ZsmMZg1nkH/AK4WMk6JZl+4VH2OWNkbgQFjirMMHxDzixuE\n/RorHvwhJJlr99ZMMqIO+H66qAMifXPDkEOpazsGCPxda5roAGQNCWqSuWvQ\nLR/ZLOXflH+4mXNWO1CV+Owjty4FjHIogTQCj3hLPHhHkUi3aDiuBRyn7xpe\nMLoZF18ovbhj7zB9JqiplGmuYlHAK/rDjz3HEZdRGIZuptvYlYsmfylX6H1G\nd2Lkm9qUa7CbPHIHA23XWnlpHYZ9g/jrjLweOouqFcPo0eRbriYKiTDKSqSy\n4Tt1ztyqNIpxhw2Yu0umeQzX+mJgggF781G+iCMNWTl7WJ136vDRtC1tDljH\nRd3mVw4/MYlQF0afMHcu+kzLjgqqeXgWKUHV69OTbLgY2MFAVyi9VieJQxpM\nCUOTDSs3KfCYmLPfNVwQUuBxzfyHgDM9Jfbfa856plRKEIWSr121dXIIY+Tm\nIbbT\r\n=nZII\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "9d88eccca442f1d544f2761d15ea557dc0a44ed2",
+    "tarball": "https://registry.npmjs.org/@netflix/nerror/-/nerror-1.1.3.tgz",
+    "unpackedSize": 43306
+  },
+  "gitHead": "e6d624ce0f3e1a60acdd3af1d8dedc9bc745b656",
+  "homepage": "https://github.com/Netflix/nerror",
+  "keywords": [
+    "error",
+    "multierror",
+    "nerror",
+    "verror"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "maintainers": [
+    {
+      "name": "kaylie",
+      "email": "kayliealexa7@gmail.com"
+    },
+    {
+      "name": "abritinthebay",
+      "email": "darkcryst@gmail.com"
+    },
+    {
+      "name": "donutespresso",
+      "email": "donutespresso@gmail.com"
+    },
+    {
+      "name": "ghermeto",
+      "email": "gui.hermeto@gmail.com"
+    },
+    {
+      "name": "gsimpson",
+      "email": "gsimpson@netflix.com"
+    },
+    {
+      "name": "hekike",
+      "email": "email@martonpeter.com"
+    },
+    {
+      "name": "barb_the_builder",
+      "email": "npm@netflix.com"
+    },
+    {
+      "name": "kkwon",
+      "email": "kkwon@netflix.com"
+    },
+    {
+      "name": "mmarchini",
+      "email": "matheusdot@gmail.com"
+    },
+    {
+      "name": "tbranyen",
+      "email": "tim@tabdeveloper.com"
+    },
+    {
+      "name": "tvui",
+      "email": "tvui-npm@netflix.com"
+    },
+    {
+      "name": "tvuiops",
+      "email": "tvui-npm@netflix.com"
+    }
+  ],
+  "name": "@netflix/nerror",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Netflix/nerror.git"
+  },
+  "scripts": {
+    "test": "make prepush & tsd"
+  },
+  "tsd": {
+    "directory": "test"
+  },
+  "types": "lib/index.d.ts",
+  "version": "1.1.3"
+}

node_modules/@nodelib/fs.scandir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+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.

node_modules/@nodelib/fs.scandir/README.md

@@ -0,0 +1,171 @@
+# @nodelib/fs.scandir
+
+> List files and directories inside the specified directory.
+
+## :bulb: Highlights
+
+The package is aimed at obtaining information about entries in the directory.
+
+* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
+* :gear: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type. See [`old` and `modern` mode](#old-and-modern-mode).
+* :link: Can safely work with broken symbolic links.
+
+## Install
+
+```console
+npm install @nodelib/fs.scandir
+```
+
+## Usage
+
+```ts
+import * as fsScandir from '@nodelib/fs.scandir';
+
+fsScandir.scandir('path', (error, stats) => { /* … */ });
+```
+
+## API
+
+### .scandir(path, [optionsOrSettings], callback)
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path with standard callback-style.
+
+```ts
+fsScandir.scandir('path', (error, entries) => { /* … */ });
+fsScandir.scandir('path', {}, (error, entries) => { /* … */ });
+fsScandir.scandir('path', new fsScandir.Settings(), (error, entries) => { /* … */ });
+```
+
+### .scandirSync(path, [optionsOrSettings])
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path.
+
+```ts
+const entries = fsScandir.scandirSync('path');
+const entries = fsScandir.scandirSync('path', {});
+const entries = fsScandir.scandirSync(('path', new fsScandir.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settingsoptions) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsScandir.Settings({ followSymbolicLinks: false });
+
+const entries = fsScandir.scandirSync('path', settings);
+```
+
+## Entry
+
+* `name` — The name of the entry (`unknown.txt`).
+* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
+* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class. On Node.js below 10.10 will be emulated by [`DirentFromStats`](./src/utils/fs.ts) class.
+* `stats` (optional) — An instance of `fs.Stats` class.
+
+For example, the `scandir` call for `tools` directory with one directory inside:
+
+```ts
+{
+	dirent: Dirent { name: 'typedoc', /* … */ },
+	name: 'typedoc',
+	path: 'tools/typedoc'
+}
+```
+
+## Options
+
+### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
+
+> :book: Always use `fs.readdir` without the `withFileTypes` option. ??TODO??
+
+### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `false`
+
+Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely use `lstat` call if `false`.
+
+### `pathSegmentSeparator`
+
+* Type: `string`
+* Default: `path.sep`
+
+By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
+
+### `fs`
+
+* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat?: typeof fs.lstat;
+	stat?: typeof fs.stat;
+	lstatSync?: typeof fs.lstatSync;
+	statSync?: typeof fs.statSync;
+	readdir?: typeof fs.readdir;
+	readdirSync?: typeof fs.readdirSync;
+}
+
+const settings = new fsScandir.Settings({
+	fs: { lstat: fakeLstat }
+});
+```
+
+## `old` and `modern` mode
+
+This package has two modes that are used depending on the environment and parameters of use.
+
+### old
+
+* Node.js below `10.10` or when the `stats` option is enabled
+
+When working in the old mode, the directory is read first (`fs.readdir`), then the type of entries is determined (`fs.lstat` and/or `fs.stat` for symbolic links).
+
+### modern
+
+* Node.js 10.10+ and the `stats` option is disabled
+
+In the modern mode, reading the directory (`fs.readdir` with the `withFileTypes` option) is combined with obtaining information about its entries. An additional call for symbolic links (`fs.stat`) is still present.
+
+This mode makes fewer calls to the file system. It's faster.
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

node_modules/@nodelib/fs.scandir/out/adapters/fs.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type FileSystemAdapter = {
+    lstat: typeof fs.lstat;
+    stat: typeof fs.stat;
+    lstatSync: typeof fs.lstatSync;
+    statSync: typeof fs.statSync;
+    readdir: typeof fs.readdir;
+    readdirSync: typeof fs.readdirSync;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
+//# sourceMappingURL=fs.d.ts.map

node_modules/@nodelib/fs.scandir/out/adapters/fs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;

node_modules/@nodelib/fs.scandir/out/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;
+//# sourceMappingURL=constants.d.ts.map

node_modules/@nodelib/fs.scandir/out/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;

node_modules/@nodelib/fs.scandir/out/index.d.ts

@@ -0,0 +1,13 @@
+import { FileSystemAdapter } from './adapters/fs';
+import * as async from './providers/async';
+import Settings, { Options } from './settings';
+import { Dirent, Entry } from './types';
+declare type AsyncCallback = async.AsyncCallback;
+declare function scandir(path: string, callback: AsyncCallback): void;
+declare function scandir(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
+declare namespace scandir {
+    function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
+}
+declare function scandirSync(path: string, optionsOrSettings?: Options | Settings): Entry[];
+export { scandir, scandirSync, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, Options };
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.scandir/out/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = require("./providers/async");
+const sync = require("./providers/sync");
+const settings_1 = require("./settings");
+exports.Settings = settings_1.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+    }
+    async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+exports.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    return sync.read(path, settings);
+}
+exports.scandirSync = scandirSync;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

node_modules/@nodelib/fs.scandir/out/providers/async.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import Settings from '../settings';
+import { Entry } from '../types';
+export declare type AsyncCallback = (err: NodeJS.ErrnoException, entries: Entry[]) => void;
+export declare function read(directory: string, settings: Settings, callback: AsyncCallback): void;
+export declare function readdirWithFileTypes(directory: string, settings: Settings, callback: AsyncCallback): void;
+export declare function readdir(directory: string, settings: Settings, callback: AsyncCallback): void;
+//# sourceMappingURL=async.d.ts.map

node_modules/@nodelib/fs.scandir/out/providers/async.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = require("@nodelib/fs.stat");
+const rpl = require("run-parallel");
+const constants_1 = require("../constants");
+const utils = require("../utils");
+function read(directory, settings, callback) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings, callback);
+    }
+    return readdir(directory, settings, callback);
+}
+exports.read = read;
+function readdirWithFileTypes(directory, settings, callback) {
+    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+            return callFailureCallback(callback, readdirError);
+        }
+        const entries = dirents.map((dirent) => ({
+            dirent,
+            name: dirent.name,
+            path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
+        }));
+        if (!settings.followSymbolicLinks) {
+            return callSuccessCallback(callback, entries);
+        }
+        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+            if (rplError !== null) {
+                return callFailureCallback(callback, rplError);
+            }
+            callSuccessCallback(callback, rplEntries);
+        });
+    });
+}
+exports.readdirWithFileTypes = readdirWithFileTypes;
+function makeRplTaskEntry(entry, settings) {
+    return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+            return done(null, entry);
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return done(statError);
+                }
+                return done(null, entry);
+            }
+            entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+            return done(null, entry);
+        });
+    };
+}
+function readdir(directory, settings, callback) {
+    settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+            return callFailureCallback(callback, readdirError);
+        }
+        const filepaths = names.map((name) => `${directory}${settings.pathSegmentSeparator}${name}`);
+        const tasks = filepaths.map((filepath) => {
+            return (done) => fsStat.stat(filepath, settings.fsStatSettings, done);
+        });
+        rpl(tasks, (rplError, results) => {
+            if (rplError !== null) {
+                return callFailureCallback(callback, rplError);
+            }
+            const entries = [];
+            names.forEach((name, index) => {
+                const stats = results[index];
+                const entry = {
+                    name,
+                    path: filepaths[index],
+                    dirent: utils.fs.createDirentFromStats(name, stats)
+                };
+                if (settings.stats) {
+                    entry.stats = stats;
+                }
+                entries.push(entry);
+            });
+            callSuccessCallback(callback, entries);
+        });
+    });
+}
+exports.readdir = readdir;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, result) {
+    callback(null, result);
+}

node_modules/@nodelib/fs.scandir/out/providers/sync.d.ts

@@ -0,0 +1,6 @@
+import Settings from '../settings';
+import { Entry } from '../types';
+export declare function read(directory: string, settings: Settings): Entry[];
+export declare function readdirWithFileTypes(directory: string, settings: Settings): Entry[];
+export declare function readdir(directory: string, settings: Settings): Entry[];
+//# sourceMappingURL=sync.d.ts.map

node_modules/@nodelib/fs.scandir/out/providers/sync.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = require("@nodelib/fs.stat");
+const constants_1 = require("../constants");
+const utils = require("../utils");
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir(directory, settings);
+}
+exports.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+exports.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = `${directory}${settings.pathSegmentSeparator}${name}`;
+        const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
+exports.readdir = readdir;

node_modules/@nodelib/fs.scandir/out/settings.d.ts

@@ -0,0 +1,21 @@
+import * as fsStat from '@nodelib/fs.stat';
+import * as fs from './adapters/fs';
+export declare type Options = {
+    followSymbolicLinks?: boolean;
+    fs?: Partial<fs.FileSystemAdapter>;
+    pathSegmentSeparator?: string;
+    stats?: boolean;
+    throwErrorOnBrokenSymbolicLink?: boolean;
+};
+export default class Settings {
+    private readonly _options;
+    readonly followSymbolicLinks: boolean;
+    readonly fs: fs.FileSystemAdapter;
+    readonly pathSegmentSeparator: string;
+    readonly stats: boolean;
+    readonly throwErrorOnBrokenSymbolicLink: boolean;
+    readonly fsStatSettings: fsStat.Settings;
+    constructor(_options?: Options);
+    private _getValue;
+}
+//# sourceMappingURL=settings.d.ts.map

node_modules/@nodelib/fs.scandir/out/settings.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fsStat = require("@nodelib/fs.stat");
+const fs = require("./adapters/fs");
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option === undefined ? value : option;
+    }
+}
+exports.default = Settings;

node_modules/@nodelib/fs.scandir/out/types/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type Entry = {
+    dirent: Dirent;
+    name: string;
+    path: string;
+    stats?: Stats;
+};
+export declare type Stats = fs.Stats;
+export declare type Dirent = {
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isDirectory(): boolean;
+    isFIFO(): boolean;
+    isFile(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.scandir/out/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@nodelib/fs.scandir/out/utils/fs.d.ts

@@ -0,0 +1,3 @@
+import { Dirent, Stats } from '../types';
+export declare function createDirentFromStats(name: string, stats: Stats): Dirent;
+//# sourceMappingURL=fs.d.ts.map

node_modules/@nodelib/fs.scandir/out/utils/fs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+exports.createDirentFromStats = createDirentFromStats;

node_modules/@nodelib/fs.scandir/out/utils/index.d.ts

@@ -0,0 +1,3 @@
+import * as fs from './fs';
+export { fs };
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.scandir/out/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("./fs");
+exports.fs = fs;

node_modules/@nodelib/fs.scandir/package.json

@@ -0,0 +1,95 @@
+{
+  "_args": [
+    [
+      "@nodelib/fs.scandir@2.1.3",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/@nodelib/fs.walk"
+    ]
+  ],
+  "_from": "@nodelib/fs.scandir@2.1.3",
+  "_hasShrinkwrap": false,
+  "_id": "@nodelib/fs.scandir@2.1.3",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@nodelib/fs.scandir",
+  "_nodeVersion": "12.8.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/fs.scandir_2.1.3_1570173166752_0.07827536155873238"
+  },
+  "_npmUser": {
+    "email": "dmalinochkin@rambler.ru",
+    "name": "mrmlnc"
+  },
+  "_npmVersion": "lerna/3.16.4/node@v12.8.0+x64 (win32)",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@nodelib/fs.scandir",
+    "raw": "@nodelib/fs.scandir@2.1.3",
+    "rawSpec": "2.1.3",
+    "scope": "@nodelib",
+    "spec": "2.1.3",
+    "type": "version"
+  },
+  "_requiredBy": [
+    "/@nodelib/fs.walk"
+  ],
+  "_resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz",
+  "_shasum": "3a582bdb53804c6ba6d146579c46e52130cf4a3b",
+  "_shrinkwrap": null,
+  "_spec": "@nodelib/fs.scandir@2.1.3",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/@nodelib/fs.walk",
+  "dependencies": {
+    "@nodelib/fs.stat": "2.0.3",
+    "run-parallel": "^1.1.9"
+  },
+  "description": "List files and directories inside the specified directory",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 21,
+    "integrity": "sha512-eGmwYQn3gxo4r7jdQnkrrN6bY478C3P+a/y72IJukF8LjB6ZHeB3c+Ehacj3sYeSmUXGlnA67/PmbM9CVwL7Dw==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJdlvDvCRA9TVsSAnZWagAAQpwQAImz9Twd2paLWU/2+Z4/\nvEfs7aZHO2sps0DbVGVrVcG8r5nCmUqeBUo/eqfl2xcBGhWSfKiOZyzT/6wQ\n6508wr4fsoa6XdxL9Yf4Mm1AhBRmv9zE9Fw25OVCXvTmPsqFJiU8aSgCAgd/\nlRnZqu9uktqwaMpuoYB7xXr70YYVFB32DVZlZYqjTm1EHkq54RvR7gDU1T0b\n2ayJhGhaZzf2B/CZFtk/Vb06HmYn7FsY7t21w8u3hiBfju5lXwEEy6t/5ITh\nQWJJjOzJzSOqGHv3+QgCUDBZHPjE5LiNZyoMVz0Q3vRvNjRBVei9ovEkja9U\n68I2ufjoxWA333j9xX4wgJI5laD39lNSAorHH3C24Vm+PcttPfJNkeGFcBhP\nN8gHJj3DPipumGdt4Z/CYJkSbQ39mqGOcEB5XJJXHegcNdpBl5rF1GD+/Kg0\n/8Y7B8dPX6NoJH8QHL5PvPGRTs9yzNk+jw1jxU995v7I2g95zfLIHH00evDJ\nfou2c+uT9o9CUQnFAvV07mzJxNn93SJZunf1N+ih0+GoJf7dJynTjwTUocTz\ngFxzs5DazEDDaLmKIcsUHPJutABJo1wqHdoBiU9jXSW7eLxMU2fO8Rm1F1ha\nAWxLTTfPsCw6vhyMIqEy1ist3bC6GTeouc2R1AUoeWSqd/T19baLm3XaHd2D\nu+MV\r\n=176S\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "3a582bdb53804c6ba6d146579c46e52130cf4a3b",
+    "tarball": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz",
+    "unpackedSize": 20514
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
+  "keywords": [
+    "FileSystem",
+    "NodeLib",
+    "dirent",
+    "file system",
+    "fs",
+    "readdir",
+    "scandir"
+  ],
+  "license": "MIT",
+  "main": "out/index.js",
+  "maintainers": [
+    {
+      "name": "mrmlnc",
+      "email": "dmalinochkin@rambler.ru"
+    }
+  ],
+  "name": "@nodelib/fs.scandir",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.scandir"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run compile && npm run lint && npm test",
+    "clean": "rimraf {tsconfig.tsbuildinfo,out}",
+    "compile": "tsc -b .",
+    "compile:watch": "tsc -p . --watch --sourceMap",
+    "lint": "eslint \"src/**/*.ts\" --cache",
+    "test": "mocha \"out/**/*.spec.js\" -s 0",
+    "watch": "npm run clean && npm run compile:watch"
+  },
+  "typings": "out/index.d.ts",
+  "version": "2.1.3"
+}

node_modules/@nodelib/fs.stat/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+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.

node_modules/@nodelib/fs.stat/README.md

@@ -0,0 +1,126 @@
+# @nodelib/fs.stat
+
+> Get the status of a file with some features.
+
+## :bulb: Highlights
+
+Wrapper around standard method `fs.lstat` and `fs.stat` with some features.
+
+* :beginner: Normally follows symbolic link.
+* :gear: Can safely work with broken symbolic link.
+
+## Install
+
+```console
+npm install @nodelib/fs.stat
+```
+
+## Usage
+
+```ts
+import * as fsStat from '@nodelib/fs.stat';
+
+fsStat.stat('path', (error, stats) => { /* … */ });
+```
+
+## API
+
+### .stat(path, [optionsOrSettings], callback)
+
+Returns an instance of `fs.Stats` class for provided path with standard callback-style.
+
+```ts
+fsStat.stat('path', (error, stats) => { /* … */ });
+fsStat.stat('path', {}, (error, stats) => { /* … */ });
+fsStat.stat('path', new fsStat.Settings(), (error, stats) => { /* … */ });
+```
+
+### .statSync(path, [optionsOrSettings])
+
+Returns an instance of `fs.Stats` class for provided path.
+
+```ts
+const stats = fsStat.stat('path');
+const stats = fsStat.stat('path', {});
+const stats = fsStat.stat('path', new fsStat.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsStat.Settings({ followSymbolicLink: false });
+
+const stats = fsStat.stat('path', settings);
+```
+
+## Options
+
+### `followSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Follow symbolic link or not. Call `fs.stat` on symbolic link if `true`.
+
+### `markSymbolicLink`
+
+* Type: `boolean`
+* Default: `false`
+
+Mark symbolic link by setting the return value of `isSymbolicLink` function to always `true` (even after `fs.stat`).
+
+> :book: Can be used if you want to know what is hidden behind a symbolic link, but still continue to know that it is a symbolic link.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
+
+### `fs`
+
+* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat?: typeof fs.lstat;
+	stat?: typeof fs.stat;
+	lstatSync?: typeof fs.lstatSync;
+	statSync?: typeof fs.statSync;
+}
+
+const settings = new fsStat.Settings({
+	fs: { lstat: fakeLstat }
+});
+```
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type FileSystemAdapter = {
+    lstat: typeof fs.lstat;
+    stat: typeof fs.stat;
+    lstatSync: typeof fs.lstatSync;
+    statSync: typeof fs.statSync;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
+//# sourceMappingURL=fs.d.ts.map

node_modules/@nodelib/fs.stat/out/adapters/fs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;

node_modules/@nodelib/fs.stat/out/index.d.ts

@@ -0,0 +1,13 @@
+import { FileSystemAdapter } from './adapters/fs';
+import * as async from './providers/async';
+import Settings, { Options } from './settings';
+import { Stats } from './types';
+declare type AsyncCallback = async.AsyncCallback;
+declare function stat(path: string, callback: AsyncCallback): void;
+declare function stat(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
+declare namespace stat {
+    function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Stats>;
+}
+declare function statSync(path: string, optionsOrSettings?: Options | Settings): Stats;
+export { Settings, stat, statSync, AsyncCallback, FileSystemAdapter, Options, Stats };
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.stat/out/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = require("./providers/async");
+const sync = require("./providers/sync");
+const settings_1 = require("./settings");
+exports.Settings = settings_1.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+    }
+    async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+exports.stat = stat;
+function statSync(path, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    return sync.read(path, settings);
+}
+exports.statSync = statSync;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

node_modules/@nodelib/fs.stat/out/providers/async.d.ts

@@ -0,0 +1,5 @@
+import Settings from '../settings';
+import { ErrnoException, Stats } from '../types';
+export declare type AsyncCallback = (err: ErrnoException, stats: Stats) => void;
+export declare function read(path: string, settings: Settings, callback: AsyncCallback): void;
+//# sourceMappingURL=async.d.ts.map

node_modules/@nodelib/fs.stat/out/providers/async.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings, callback) {
+    settings.fs.lstat(path, (lstatError, lstat) => {
+        if (lstatError !== null) {
+            return callFailureCallback(callback, lstatError);
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            return callSuccessCallback(callback, lstat);
+        }
+        settings.fs.stat(path, (statError, stat) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return callFailureCallback(callback, statError);
+                }
+                return callSuccessCallback(callback, lstat);
+            }
+            if (settings.markSymbolicLink) {
+                stat.isSymbolicLink = () => true;
+            }
+            callSuccessCallback(callback, stat);
+        });
+    });
+}
+exports.read = read;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, result) {
+    callback(null, result);
+}

node_modules/@nodelib/fs.stat/out/providers/sync.d.ts

@@ -0,0 +1,4 @@
+import Settings from '../settings';
+import { Stats } from '../types';
+export declare function read(path: string, settings: Settings): Stats;
+//# sourceMappingURL=sync.d.ts.map

node_modules/@nodelib/fs.stat/out/providers/sync.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings) {
+    const lstat = settings.fs.lstatSync(path);
+    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+        return lstat;
+    }
+    try {
+        const stat = settings.fs.statSync(path);
+        if (settings.markSymbolicLink) {
+            stat.isSymbolicLink = () => true;
+        }
+        return stat;
+    }
+    catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink) {
+            return lstat;
+        }
+        throw error;
+    }
+}
+exports.read = read;

node_modules/@nodelib/fs.stat/out/settings.d.ts

@@ -0,0 +1,17 @@
+import * as fs from './adapters/fs';
+export declare type Options = {
+    followSymbolicLink?: boolean;
+    fs?: Partial<fs.FileSystemAdapter>;
+    markSymbolicLink?: boolean;
+    throwErrorOnBrokenSymbolicLink?: boolean;
+};
+export default class Settings {
+    private readonly _options;
+    readonly followSymbolicLink: boolean;
+    readonly fs: fs.FileSystemAdapter;
+    readonly markSymbolicLink: boolean;
+    readonly throwErrorOnBrokenSymbolicLink: boolean;
+    constructor(_options?: Options);
+    private _getValue;
+}
+//# sourceMappingURL=settings.d.ts.map

node_modules/@nodelib/fs.stat/out/settings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("./adapters/fs");
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(option, value) {
+        return option === undefined ? value : option;
+    }
+}
+exports.default = Settings;

node_modules/@nodelib/fs.stat/out/types/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type Stats = fs.Stats;
+export declare type ErrnoException = NodeJS.ErrnoException;
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.stat/out/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@nodelib/fs.stat/package.json

@@ -0,0 +1,91 @@
+{
+  "_args": [
+    [
+      "@nodelib/fs.stat@^2.0.2",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/fast-glob"
+    ]
+  ],
+  "_from": "@nodelib/fs.stat@>=2.0.2 <3.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "@nodelib/fs.stat@2.0.3",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@nodelib/fs.stat",
+  "_nodeVersion": "12.8.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/fs.stat_2.0.3_1570173163141_0.7325395787436761"
+  },
+  "_npmUser": {
+    "email": "dmalinochkin@rambler.ru",
+    "name": "mrmlnc"
+  },
+  "_npmVersion": "lerna/3.16.4/node@v12.8.0+x64 (win32)",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@nodelib/fs.stat",
+    "raw": "@nodelib/fs.stat@^2.0.2",
+    "rawSpec": "^2.0.2",
+    "scope": "@nodelib",
+    "spec": ">=2.0.2 <3.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/@nodelib/fs.scandir",
+    "/fast-glob"
+  ],
+  "_resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
+  "_shasum": "34dc5f4cabbc720f4e60f75a747e7ecd6c175bd3",
+  "_shrinkwrap": null,
+  "_spec": "@nodelib/fs.stat@^2.0.2",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/fast-glob",
+  "dependencies": {},
+  "description": "Get the status of a file with some features",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 15,
+    "integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJdlvDrCRA9TVsSAnZWagAAPlgP/1IoWIVZ4ikAyMLYWYV5\nspxT3f0dZhAipLIxwQb68bf9eCYHS3apQ+DrIBgPdXpapH2+CBH+wIkYRGMe\n6iS86/wtGGls377ZByPfgFepXUBKeD3h5X738BsGGfE+GkcNnRjIYtNYO00U\nH9yV9POPFICJHRBS0bh1DW8tOa+B5dAEYX/gr8Fb9cI037ESV61HyKPKJm45\nPdjcYsGQROpmfL58R204goQGKcYw+6vu3S8QzhD7eU6Sof5AXotr8B9u8SYo\nv6t4Rn9oyJLo0U+dIc+L0Z8r/qiIBp3NcyZ2Ave0uugCYNOLlHEG7OaW8Esx\nwLHqfydj0QG0SAEY0sYrasMzesswls5NkD3VkWfLbS7sqFXLzPE4GScIvc87\n8E2LlFKJkbfANo2BfFTEAVenBV85nvynAUP3GYO4kjtKHvPhkFAg6/s3usSc\nkPGf9j2ASJO7c5fsFEUBlYg58EEeZqW1/rXiGxVyCVzSSZQmNj7AT8BMTqDj\nrikx0otjIs+iPpxbwslHfGBwV1iMLt7IsUsv5BIDSOzFLayUx6sj6TdInthT\ni2q3Q+xRjh7D4KM0q1rruzsFHQappRTkRaP0HQxvZODvek/ZzmkwfClvn3Yn\nm91VxVR5bxO/+flLCnTH0rVKooZ05tEalNbhSX6V59Orfdf6i1G7Ht26WcvX\nSURC\r\n=jUeA\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "34dc5f4cabbc720f4e60f75a747e7ecd6c175bd3",
+    "tarball": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
+    "unpackedSize": 11410
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
+  "keywords": [
+    "FileSystem",
+    "NodeLib",
+    "file system",
+    "fs",
+    "stat"
+  ],
+  "license": "MIT",
+  "main": "out/index.js",
+  "maintainers": [
+    {
+      "name": "mrmlnc",
+      "email": "dmalinochkin@rambler.ru"
+    }
+  ],
+  "name": "@nodelib/fs.stat",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run compile && npm run lint && npm test",
+    "clean": "rimraf {tsconfig.tsbuildinfo,out}",
+    "compile": "tsc -b .",
+    "compile:watch": "tsc -p . --watch --sourceMap",
+    "lint": "eslint \"src/**/*.ts\" --cache",
+    "test": "mocha \"out/**/*.spec.js\" -s 0",
+    "watch": "npm run clean && npm run compile:watch"
+  },
+  "typings": "out/index.d.ts",
+  "version": "2.0.3"
+}

node_modules/@nodelib/fs.walk/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+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.

node_modules/@nodelib/fs.walk/README.md

@@ -0,0 +1,215 @@
+# @nodelib/fs.walk
+
+> A library for efficiently walking a directory recursively.
+
+## :bulb: Highlights
+
+* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
+* :rocket: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type for performance reasons. See [`old` and `modern` mode](https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode).
+* :gear: Built-in directories/files and error filtering system.
+* :link: Can safely work with broken symbolic links.
+
+## Install
+
+```console
+npm install @nodelib/fs.walk
+```
+
+## Usage
+
+```ts
+import * as fsWalk from '@nodelib/fs.walk';
+
+fsWalk.walk('path', (error, entries) => { /* … */ });
+```
+
+## API
+
+### .walk(path, [optionsOrSettings], callback)
+
+Reads the directory recursively and asynchronously. Requires a callback function.
+
+> :book: If you want to use the Promise API, use `util.promisify`.
+
+```ts
+fsWalk.walk('path', (error, entries) => { /* … */ });
+fsWalk.walk('path', {}, (error, entries) => { /* … */ });
+fsWalk.walk('path', new fsWalk.Settings(), (error, entries) => { /* … */ });
+```
+
+### .walkStream(path, [optionsOrSettings])
+
+Reads the directory recursively and asynchronously. [Readable Stream](https://nodejs.org/dist/latest-v12.x/docs/api/stream.html#stream_readable_streams) is used as a provider.
+
+```ts
+const stream = fsWalk.walkStream('path');
+const stream = fsWalk.walkStream('path', {});
+const stream = fsWalk.walkStream('path', new fsWalk.Settings());
+```
+
+### .walkSync(path, [optionsOrSettings])
+
+Reads the directory recursively and synchronously. Returns an array of entries.
+
+```ts
+const entries = fsWalk.walkSync('path');
+const entries = fsWalk.walkSync('path', {});
+const entries = fsWalk.walkSync('path', new fsWalk.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsWalk.Settings({ followSymbolicLinks: true });
+
+const entries = fsWalk.walkSync('path', settings);
+```
+
+## Entry
+
+* `name` — The name of the entry (`unknown.txt`).
+* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
+* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class.
+* [`stats`] — An instance of `fs.Stats` class.
+
+## Options
+
+### basePath
+
+* Type: `string`
+* Default: `undefined`
+
+By default, all paths are built relative to the root path. You can use this option to set custom root path.
+
+In the example below we read the files from the `root` directory, but in the results the root path will be `custom`.
+
+```ts
+fsWalk.walkSync('root'); // → ['root/file.txt']
+fsWalk.walkSync('root', { basePath: 'custom' }); // → ['custom/file.txt']
+```
+
+### concurrency
+
+* Type: `number`
+* Default: `Infinity`
+
+The maximum number of concurrent calls to `fs.readdir`.
+
+> :book: The higher the number, the higher performance and the load on the File System. If you want to read in quiet mode, set the value to `4 * os.cpus().length` (4 is default size of [thread pool work scheduling](http://docs.libuv.org/en/v1.x/threadpool.html#thread-pool-work-scheduling)).
+
+### deepFilter
+
+* Type: [`DeepFilterFunction`](./src/settings.ts)
+* Default: `undefined`
+
+A function that indicates whether the directory will be read deep or not.
+
+```ts
+// Skip all directories that starts with `node_modules`
+const filter: DeepFilterFunction = (entry) => !entry.path.startsWith('node_modules');
+```
+
+### entryFilter
+
+* Type: [`EntryFilterFunction`](./src/settings.ts)
+* Default: `undefined`
+
+A function that indicates whether the entry will be included to results or not.
+
+```ts
+// Exclude all `.js` files from results
+const filter: EntryFilterFunction = (entry) => !entry.name.endsWith('.js');
+```
+
+### errorFilter
+
+* Type: [`ErrorFilterFunction`](./src/settings.ts)
+* Default: `undefined`
+
+A function that allows you to skip errors that occur when reading directories.
+
+For example, you can skip `ENOENT` errors if required:
+
+```ts
+// Skip all ENOENT errors
+const filter: ErrorFilterFunction = (error) => error.code == 'ENOENT';
+```
+
+### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
+
+> :book: Always use `fs.readdir` with additional `fs.lstat/fs.stat` calls to determine the entry type.
+
+### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `false`
+
+Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
+
+### `pathSegmentSeparator`
+
+* Type: `string`
+* Default: `path.sep`
+
+By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
+
+### `fs`
+
+* Type: `FileSystemAdapter`
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat: typeof fs.lstat;
+	stat: typeof fs.stat;
+	lstatSync: typeof fs.lstatSync;
+	statSync: typeof fs.statSync;
+	readdir: typeof fs.readdir;
+	readdirSync: typeof fs.readdirSync;
+}
+
+const settings = new fsWalk.Settings({
+	fs: { lstat: fakeLstat }
+});
+```
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

node_modules/@nodelib/fs.walk/out/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Dirent, FileSystemAdapter } from '@nodelib/fs.scandir';
+import { AsyncCallback } from './providers/async';
+import Settings, { DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction, Options } from './settings';
+import { Entry } from './types';
+declare function walk(directory: string, callback: AsyncCallback): void;
+declare function walk(directory: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
+declare namespace walk {
+    function __promisify__(directory: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
+}
+declare function walkSync(directory: string, optionsOrSettings?: Options | Settings): Entry[];
+declare function walkStream(directory: string, optionsOrSettings?: Options | Settings): Readable;
+export { walk, walkSync, walkStream, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, Options, DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction };
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.walk/out/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = require("./providers/async");
+const stream_1 = require("./providers/stream");
+const sync_1 = require("./providers/sync");
+const settings_1 = require("./settings");
+exports.Settings = settings_1.default;
+function walk(directory, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+    }
+    new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+exports.walk = walk;
+function walkSync(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new sync_1.default(directory, settings);
+    return provider.read();
+}
+exports.walkSync = walkSync;
+function walkStream(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new stream_1.default(directory, settings);
+    return provider.read();
+}
+exports.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

node_modules/@nodelib/fs.walk/out/providers/async.d.ts

@@ -0,0 +1,13 @@
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+import { Entry, Errno } from '../types';
+export declare type AsyncCallback = (err: Errno, entries: Entry[]) => void;
+export default class AsyncProvider {
+    private readonly _root;
+    private readonly _settings;
+    protected readonly _reader: AsyncReader;
+    private readonly _storage;
+    constructor(_root: string, _settings: Settings);
+    read(callback: AsyncCallback): void;
+}
+//# sourceMappingURL=async.d.ts.map

node_modules/@nodelib/fs.walk/out/providers/async.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = require("../readers/async");
+class AsyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1.default(this._root, this._settings);
+        this._storage = new Set();
+    }
+    read(callback) {
+        this._reader.onError((error) => {
+            callFailureCallback(callback, error);
+        });
+        this._reader.onEntry((entry) => {
+            this._storage.add(entry);
+        });
+        this._reader.onEnd(() => {
+            callSuccessCallback(callback, [...this._storage]);
+        });
+        this._reader.read();
+    }
+}
+exports.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, entries) {
+    callback(null, entries);
+}

node_modules/@nodelib/fs.walk/out/providers/index.d.ts

@@ -0,0 +1,5 @@
+import AsyncProvider from './async';
+import StreamProvider from './stream';
+import SyncProvider from './sync';
+export { AsyncProvider, StreamProvider, SyncProvider };
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.walk/out/providers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = require("./async");
+exports.AsyncProvider = async_1.default;
+const stream_1 = require("./stream");
+exports.StreamProvider = stream_1.default;
+const sync_1 = require("./sync");
+exports.SyncProvider = sync_1.default;

node_modules/@nodelib/fs.walk/out/providers/stream.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+export default class StreamProvider {
+    private readonly _root;
+    private readonly _settings;
+    protected readonly _reader: AsyncReader;
+    protected readonly _stream: Readable;
+    constructor(_root: string, _settings: Settings);
+    read(): Readable;
+}
+//# sourceMappingURL=stream.d.ts.map

node_modules/@nodelib/fs.walk/out/providers/stream.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const async_1 = require("../readers/async");
+class StreamProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1.default(this._root, this._settings);
+        this._stream = new stream_1.Readable({
+            objectMode: true,
+            read: () => { },
+            destroy: this._reader.destroy.bind(this._reader)
+        });
+    }
+    read() {
+        this._reader.onError((error) => {
+            this._stream.emit('error', error);
+        });
+        this._reader.onEntry((entry) => {
+            this._stream.push(entry);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
+    }
+}
+exports.default = StreamProvider;

node_modules/@nodelib/fs.walk/out/providers/sync.d.ts

@@ -0,0 +1,11 @@
+import SyncReader from '../readers/sync';
+import Settings from '../settings';
+import { Entry } from '../types';
+export default class SyncProvider {
+    private readonly _root;
+    private readonly _settings;
+    protected readonly _reader: SyncReader;
+    constructor(_root: string, _settings: Settings);
+    read(): Entry[];
+}
+//# sourceMappingURL=sync.d.ts.map

node_modules/@nodelib/fs.walk/out/providers/sync.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sync_1 = require("../readers/sync");
+class SyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new sync_1.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
+exports.default = SyncProvider;

node_modules/@nodelib/fs.walk/out/readers/async.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import * as fsScandir from '@nodelib/fs.scandir';
+import Settings from '../settings';
+import { Entry, Errno } from '../types';
+import Reader from './reader';
+declare type EntryEventCallback = (entry: Entry) => void;
+declare type ErrorEventCallback = (error: Errno) => void;
+declare type EndEventCallback = () => void;
+export default class AsyncReader extends Reader {
+    protected readonly _settings: Settings;
+    protected readonly _scandir: typeof fsScandir.scandir;
+    protected readonly _emitter: EventEmitter;
+    private readonly _queue;
+    private _isFatalError;
+    private _isDestroyed;
+    constructor(_root: string, _settings: Settings);
+    read(): EventEmitter;
+    destroy(): void;
+    onEntry(callback: EntryEventCallback): void;
+    onError(callback: ErrorEventCallback): void;
+    onEnd(callback: EndEventCallback): void;
+    private _pushToQueue;
+    private _worker;
+    private _handleError;
+    private _handleEntry;
+    private _emitEntry;
+}
+export {};
+//# sourceMappingURL=async.d.ts.map

node_modules/@nodelib/fs.walk/out/readers/async.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const fsScandir = require("@nodelib/fs.scandir");
+const fastq = require("fastq");
+const common = require("./common");
+const reader_1 = require("./reader");
+class AsyncReader extends reader_1.default {
+    constructor(_root, _settings) {
+        super(_root, _settings);
+        this._settings = _settings;
+        this._scandir = fsScandir.scandir;
+        this._emitter = new events_1.EventEmitter();
+        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit('end');
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error('The reader is already destroyed');
+        }
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(callback) {
+        this._emitter.on('entry', callback);
+    }
+    onError(callback) {
+        this._emitter.once('error', callback);
+    }
+    onEnd(callback) {
+        this._emitter.once('end', callback);
+    }
+    _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+            if (error !== null) {
+                this._handleError(error);
+            }
+        });
+    }
+    _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+            if (error !== null) {
+                return done(error, undefined);
+            }
+            for (const entry of entries) {
+                this._handleEntry(entry, item.base);
+            }
+            done(null, undefined);
+        });
+    }
+    _handleError(error) {
+        if (!common.isFatalError(this._settings, error)) {
+            return;
+        }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit('error', error);
+    }
+    _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
+        }
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._emitEntry(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _emitEntry(entry) {
+        this._emitter.emit('entry', entry);
+    }
+}
+exports.default = AsyncReader;

node_modules/@nodelib/fs.walk/out/readers/common.d.ts

@@ -0,0 +1,7 @@
+import Settings, { FilterFunction } from '../settings';
+import { Errno } from '../types';
+export declare function isFatalError(settings: Settings, error: Errno): boolean;
+export declare function isAppliedFilter<T>(filter: FilterFunction<T> | null, value: T): boolean;
+export declare function replacePathSegmentSeparator(filepath: string, separator: string): string;
+export declare function joinPathSegments(a: string, b: string, separator: string): string;
+//# sourceMappingURL=common.d.ts.map

node_modules/@nodelib/fs.walk/out/readers/common.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isFatalError(settings, error) {
+    if (settings.errorFilter === null) {
+        return true;
+    }
+    return !settings.errorFilter(error);
+}
+exports.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+}
+exports.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[\\/]/).join(separator);
+}
+exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+    if (a === '') {
+        return b;
+    }
+    return a + separator + b;
+}
+exports.joinPathSegments = joinPathSegments;

node_modules/@nodelib/fs.walk/out/readers/reader.d.ts

@@ -0,0 +1,7 @@
+import Settings from '../settings';
+export default class Reader {
+    protected readonly _root: string;
+    protected readonly _settings: Settings;
+    constructor(_root: string, _settings: Settings);
+}
+//# sourceMappingURL=reader.d.ts.map

node_modules/@nodelib/fs.walk/out/readers/reader.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common = require("./common");
+class Reader {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
+}
+exports.default = Reader;

node_modules/@nodelib/fs.walk/out/readers/sync.d.ts

@@ -0,0 +1,16 @@
+import * as fsScandir from '@nodelib/fs.scandir';
+import { Entry } from '../types';
+import Reader from './reader';
+export default class SyncReader extends Reader {
+    protected readonly _scandir: typeof fsScandir.scandirSync;
+    private readonly _storage;
+    private readonly _queue;
+    read(): Entry[];
+    private _pushToQueue;
+    private _handleQueue;
+    private _handleDirectory;
+    private _handleError;
+    private _handleEntry;
+    private _pushToStorage;
+}
+//# sourceMappingURL=sync.d.ts.map

node_modules/@nodelib/fs.walk/out/readers/sync.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsScandir = require("@nodelib/fs.scandir");
+const common = require("./common");
+const reader_1 = require("./reader");
+class SyncReader extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = fsScandir.scandirSync;
+        this._storage = new Set();
+        this._queue = new Set();
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return [...this._storage];
+    }
+    _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+        for (const item of this._queue.values()) {
+            this._handleDirectory(item.directory, item.base);
+        }
+    }
+    _handleDirectory(directory, base) {
+        try {
+            const entries = this._scandir(directory, this._settings.fsScandirSettings);
+            for (const entry of entries) {
+                this._handleEntry(entry, base);
+            }
+        }
+        catch (error) {
+            this._handleError(error);
+        }
+    }
+    _handleError(error) {
+        if (!common.isFatalError(this._settings, error)) {
+            return;
+        }
+        throw error;
+    }
+    _handleEntry(entry, base) {
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._pushToStorage(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _pushToStorage(entry) {
+        this._storage.add(entry);
+    }
+}
+exports.default = SyncReader;

node_modules/@nodelib/fs.walk/out/settings.d.ts

@@ -0,0 +1,31 @@
+import * as fsScandir from '@nodelib/fs.scandir';
+import { Entry, Errno } from './types';
+export declare type FilterFunction<T> = (value: T) => boolean;
+export declare type DeepFilterFunction = FilterFunction<Entry>;
+export declare type EntryFilterFunction = FilterFunction<Entry>;
+export declare type ErrorFilterFunction = FilterFunction<Errno>;
+export declare type Options = {
+    basePath?: string;
+    concurrency?: number;
+    deepFilter?: DeepFilterFunction;
+    entryFilter?: EntryFilterFunction;
+    errorFilter?: ErrorFilterFunction;
+    followSymbolicLinks?: boolean;
+    fs?: Partial<fsScandir.FileSystemAdapter>;
+    pathSegmentSeparator?: string;
+    stats?: boolean;
+    throwErrorOnBrokenSymbolicLink?: boolean;
+};
+export default class Settings {
+    private readonly _options;
+    readonly basePath?: string;
+    readonly concurrency: number;
+    readonly deepFilter: DeepFilterFunction | null;
+    readonly entryFilter: EntryFilterFunction | null;
+    readonly errorFilter: ErrorFilterFunction | null;
+    readonly pathSegmentSeparator: string;
+    readonly fsScandirSettings: fsScandir.Settings;
+    constructor(_options?: Options);
+    private _getValue;
+}
+//# sourceMappingURL=settings.d.ts.map

node_modules/@nodelib/fs.walk/out/settings.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fsScandir = require("@nodelib/fs.scandir");
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Infinity);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+        this.fsScandirSettings = new fsScandir.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option === undefined ? value : option;
+    }
+}
+exports.default = Settings;

node_modules/@nodelib/fs.walk/out/types/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import * as scandir from '@nodelib/fs.scandir';
+export declare type Entry = scandir.Entry;
+export declare type Errno = NodeJS.ErrnoException;
+export declare type QueueItem = {
+    directory: string;
+    base?: string;
+};
+//# sourceMappingURL=index.d.ts.map

node_modules/@nodelib/fs.walk/out/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@nodelib/fs.walk/package.json

@@ -0,0 +1,95 @@
+{
+  "_args": [
+    [
+      "@nodelib/fs.walk@^1.2.3",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/fast-glob"
+    ]
+  ],
+  "_from": "@nodelib/fs.walk@>=1.2.3 <2.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "@nodelib/fs.walk@1.2.4",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@nodelib/fs.walk",
+  "_nodeVersion": "12.8.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/fs.walk_1.2.4_1570173170330_0.925284813053447"
+  },
+  "_npmUser": {
+    "email": "dmalinochkin@rambler.ru",
+    "name": "mrmlnc"
+  },
+  "_npmVersion": "lerna/3.16.4/node@v12.8.0+x64 (win32)",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@nodelib/fs.walk",
+    "raw": "@nodelib/fs.walk@^1.2.3",
+    "rawSpec": "^1.2.3",
+    "scope": "@nodelib",
+    "spec": ">=1.2.3 <2.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/fast-glob"
+  ],
+  "_resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz",
+  "_shasum": "011b9202a70a6366e436ca5c065844528ab04976",
+  "_shrinkwrap": null,
+  "_spec": "@nodelib/fs.walk@^1.2.3",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/fast-glob",
+  "dependencies": {
+    "@nodelib/fs.scandir": "2.1.3",
+    "fastq": "^1.6.0"
+  },
+  "description": "A library for efficiently walking a directory recursively",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 25,
+    "integrity": "sha512-1V9XOY4rDW0rehzbrcqAmHnz8e7SKvX27gh8Gt2WgB0+pdzdiLV83p72kZPU+jvMbS1qU5mauP2iOvO8rhmurQ==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJdlvDyCRA9TVsSAnZWagAA5GUP/1fn0doM3q3ulxgkjG/u\nd1ooqABgfvL9xPJrJlJ3cCLwZvB6ZCzroj7EcQSrJfB9jyYDEyYrCje7aszw\nIEoR/pM22MAn1f1QbTu5h8znpfzWGhiDYTZ7+3jnsiiVPPzXG5/TThqnKHCM\nKQT6BRfAuZblQbFwXnkPrUotqT7951qDS7se5K5gWBasL1OwoWmni2vZlI4k\nOU0N88QFvpBQ0gjFMjMN3oRrTwX4zl71OwWpsGt7qSBEmGlAk78cm8NRt+VJ\n4xB2LDrI+uKAYzSsV/swj5BGyavl9xUEUIPkKTgu6OlfesUeYh5T/wif80nD\nJpT7BDx8QBZzvKg1ibfpyMph+oVAFhX8k09tsGxGB6rZTSaqeUL4JcT/XrFN\nTk8777lzOp59YvuXZu3BJqP8LGZs36crqJ1QP05bHPYYC6n6hLByzdOD0fZf\nk2zKM/fff9EHSA4MbUaozLckgAAt4MYYuUGCsz26BY+tuXBHtsQVtBO4LouJ\n4LknFwE6a72p2TQPhfxxA47yAY+3p6thG9k0hs5L7EPAaDMFAFw4Wn3108Zq\nYFqI8YPTwgtEICLx36Z4RcxfyYgVWDBtlfsI9aFj53yYe3qbaxHCVzKIoX5k\nNDQ/E+wYU+sAAyCui4gZmwORaYus0Cm8CoTgrB8Af79auv0DENdIFY9Zh7j/\noail\r\n=yPJU\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "011b9202a70a6366e436ca5c065844528ab04976",
+    "tarball": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz",
+    "unpackedSize": 26194
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
+  "keywords": [
+    "FileSystem",
+    "NodeLib",
+    "crawler",
+    "file system",
+    "fs",
+    "scanner",
+    "walk"
+  ],
+  "license": "MIT",
+  "main": "out/index.js",
+  "maintainers": [
+    {
+      "name": "mrmlnc",
+      "email": "dmalinochkin@rambler.ru"
+    }
+  ],
+  "name": "@nodelib/fs.walk",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.walk"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run compile && npm run lint && npm test",
+    "clean": "rimraf {tsconfig.tsbuildinfo,out}",
+    "compile": "tsc -b .",
+    "compile:watch": "tsc -p . --watch --sourceMap",
+    "lint": "eslint \"src/**/*.ts\" --cache",
+    "test": "mocha \"out/**/*.spec.js\" -s 0",
+    "watch": "npm run clean && npm run compile:watch"
+  },
+  "typings": "out/index.d.ts",
+  "version": "1.2.4"
+}

node_modules/@sindresorhus/is/dist/index.d.ts

@@ -0,0 +1,132 @@
+/// <reference types="node" />
+/// <reference lib="es2016" />
+/// <reference lib="es2017.sharedmemory" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="dom" />
+declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+declare type Primitive = null | undefined | string | number | boolean | Symbol;
+export interface ArrayLike {
+    length: number;
+}
+export interface Class<T = unknown> {
+    new (...args: any[]): T;
+}
+declare type DomElement = object & {
+    nodeType: 1;
+    nodeName: string;
+};
+declare type NodeStream = object & {
+    pipe: Function;
+};
+export declare const enum TypeName {
+    null = "null",
+    boolean = "boolean",
+    undefined = "undefined",
+    string = "string",
+    number = "number",
+    symbol = "symbol",
+    Function = "Function",
+    GeneratorFunction = "GeneratorFunction",
+    AsyncFunction = "AsyncFunction",
+    Observable = "Observable",
+    Array = "Array",
+    Buffer = "Buffer",
+    Object = "Object",
+    RegExp = "RegExp",
+    Date = "Date",
+    Error = "Error",
+    Map = "Map",
+    Set = "Set",
+    WeakMap = "WeakMap",
+    WeakSet = "WeakSet",
+    Int8Array = "Int8Array",
+    Uint8Array = "Uint8Array",
+    Uint8ClampedArray = "Uint8ClampedArray",
+    Int16Array = "Int16Array",
+    Uint16Array = "Uint16Array",
+    Int32Array = "Int32Array",
+    Uint32Array = "Uint32Array",
+    Float32Array = "Float32Array",
+    Float64Array = "Float64Array",
+    ArrayBuffer = "ArrayBuffer",
+    SharedArrayBuffer = "SharedArrayBuffer",
+    DataView = "DataView",
+    Promise = "Promise",
+    URL = "URL"
+}
+declare function is(value: unknown): TypeName;
+declare namespace is {
+    const undefined: (value: unknown) => value is undefined;
+    const string: (value: unknown) => value is string;
+    const number: (value: unknown) => value is number;
+    const function_: (value: unknown) => value is Function;
+    const null_: (value: unknown) => value is null;
+    const class_: (value: unknown) => value is Class<unknown>;
+    const boolean: (value: unknown) => value is boolean;
+    const symbol: (value: unknown) => value is Symbol;
+    const numericString: (value: unknown) => boolean;
+    const array: (arg: any) => arg is any[];
+    const buffer: (input: unknown) => input is Buffer;
+    const nullOrUndefined: (value: unknown) => value is null | undefined;
+    const object: (value: unknown) => value is object;
+    const iterable: (value: unknown) => value is IterableIterator<unknown>;
+    const asyncIterable: (value: unknown) => value is AsyncIterableIterator<unknown>;
+    const generator: (value: unknown) => value is Generator;
+    const nativePromise: (value: unknown) => value is Promise<unknown>;
+    const promise: (value: unknown) => value is Promise<unknown>;
+    const generatorFunction: (value: unknown) => value is GeneratorFunction;
+    const asyncFunction: (value: unknown) => value is Function;
+    const boundFunction: (value: unknown) => value is Function;
+    const regExp: (value: unknown) => value is RegExp;
+    const date: (value: unknown) => value is Date;
+    const error: (value: unknown) => value is Error;
+    const map: (value: unknown) => value is Map<unknown, unknown>;
+    const set: (value: unknown) => value is Set<unknown>;
+    const weakMap: (value: unknown) => value is WeakMap<object, unknown>;
+    const weakSet: (value: unknown) => value is WeakSet<object>;
+    const int8Array: (value: unknown) => value is Int8Array;
+    const uint8Array: (value: unknown) => value is Uint8Array;
+    const uint8ClampedArray: (value: unknown) => value is Uint8ClampedArray;
+    const int16Array: (value: unknown) => value is Int16Array;
+    const uint16Array: (value: unknown) => value is Uint16Array;
+    const int32Array: (value: unknown) => value is Int32Array;
+    const uint32Array: (value: unknown) => value is Uint32Array;
+    const float32Array: (value: unknown) => value is Float32Array;
+    const float64Array: (value: unknown) => value is Float64Array;
+    const arrayBuffer: (value: unknown) => value is ArrayBuffer;
+    const sharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer;
+    const dataView: (value: unknown) => value is DataView;
+    const directInstanceOf: <T>(instance: unknown, klass: Class<T>) => instance is T;
+    const urlInstance: (value: unknown) => value is URL;
+    const urlString: (value: unknown) => boolean;
+    const truthy: (value: unknown) => boolean;
+    const falsy: (value: unknown) => boolean;
+    const nan: (value: unknown) => boolean;
+    const primitive: (value: unknown) => value is Primitive;
+    const integer: (value: unknown) => value is number;
+    const safeInteger: (value: unknown) => value is number;
+    const plainObject: (value: unknown) => boolean;
+    const typedArray: (value: unknown) => value is TypedArray;
+    const arrayLike: (value: unknown) => value is ArrayLike;
+    const inRange: (value: number, range: number | number[]) => boolean;
+    const domElement: (value: unknown) => value is DomElement;
+    const observable: (value: unknown) => boolean;
+    const nodeStream: (value: unknown) => value is NodeStream;
+    const infinite: (value: unknown) => boolean;
+    const even: (value: number) => boolean;
+    const odd: (value: number) => boolean;
+    const emptyArray: (value: unknown) => boolean;
+    const nonEmptyArray: (value: unknown) => boolean;
+    const emptyString: (value: unknown) => boolean;
+    const nonEmptyString: (value: unknown) => boolean;
+    const emptyStringOrWhitespace: (value: unknown) => boolean;
+    const emptyObject: (value: unknown) => boolean;
+    const nonEmptyObject: (value: unknown) => boolean;
+    const emptySet: (value: unknown) => boolean;
+    const nonEmptySet: (value: unknown) => boolean;
+    const emptyMap: (value: unknown) => boolean;
+    const nonEmptyMap: (value: unknown) => boolean;
+    const any: (predicate: unknown, ...values: unknown[]) => boolean;
+    const all: (predicate: unknown, ...values: unknown[]) => boolean;
+}
+export default is;

node_modules/@sindresorhus/is/dist/index.js

@@ -0,0 +1,245 @@
+"use strict";
+/// <reference lib="es2016"/>
+/// <reference lib="es2017.sharedmemory"/>
+/// <reference lib="esnext.asynciterable"/>
+/// <reference lib="dom"/>
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: Use the `URL` global when targeting Node.js 10
+// tslint:disable-next-line
+const URLGlobal = typeof URL === 'undefined' ? require('url').URL : URL;
+const toString = Object.prototype.toString;
+const isOfType = (type) => (value) => typeof value === type;
+const isBuffer = (input) => !is.nullOrUndefined(input) && !is.nullOrUndefined(input.constructor) && is.function_(input.constructor.isBuffer) && input.constructor.isBuffer(input);
+const getObjectType = (value) => {
+    const objectName = toString.call(value).slice(8, -1);
+    if (objectName) {
+        return objectName;
+    }
+    return null;
+};
+const isObjectOfType = (type) => (value) => getObjectType(value) === type;
+function is(value) {
+    switch (value) {
+        case null:
+            return "null" /* null */;
+        case true:
+        case false:
+            return "boolean" /* boolean */;
+        default:
+    }
+    switch (typeof value) {
+        case 'undefined':
+            return "undefined" /* undefined */;
+        case 'string':
+            return "string" /* string */;
+        case 'number':
+            return "number" /* number */;
+        case 'symbol':
+            return "symbol" /* symbol */;
+        default:
+    }
+    if (is.function_(value)) {
+        return "Function" /* Function */;
+    }
+    if (is.observable(value)) {
+        return "Observable" /* Observable */;
+    }
+    if (Array.isArray(value)) {
+        return "Array" /* Array */;
+    }
+    if (isBuffer(value)) {
+        return "Buffer" /* Buffer */;
+    }
+    const tagType = getObjectType(value);
+    if (tagType) {
+        return tagType;
+    }
+    if (value instanceof String || value instanceof Boolean || value instanceof Number) {
+        throw new TypeError('Please don\'t use object wrappers for primitive types');
+    }
+    return "Object" /* Object */;
+}
+(function (is) {
+    // tslint:disable-next-line:strict-type-predicates
+    const isObject = (value) => typeof value === 'object';
+    // tslint:disable:variable-name
+    is.undefined = isOfType('undefined');
+    is.string = isOfType('string');
+    is.number = isOfType('number');
+    is.function_ = isOfType('function');
+    // tslint:disable-next-line:strict-type-predicates
+    is.null_ = (value) => value === null;
+    is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
+    is.boolean = (value) => value === true || value === false;
+    is.symbol = isOfType('symbol');
+    // tslint:enable:variable-name
+    is.numericString = (value) => is.string(value) && value.length > 0 && !Number.isNaN(Number(value));
+    is.array = Array.isArray;
+    is.buffer = isBuffer;
+    is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
+    is.object = (value) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value));
+    is.iterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]);
+    is.asyncIterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.asyncIterator]);
+    is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
+    is.nativePromise = (value) => isObjectOfType("Promise" /* Promise */)(value);
+    const hasPromiseAPI = (value) => !is.null_(value) &&
+        isObject(value) &&
+        is.function_(value.then) &&
+        is.function_(value.catch);
+    is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
+    is.generatorFunction = isObjectOfType("GeneratorFunction" /* GeneratorFunction */);
+    is.asyncFunction = isObjectOfType("AsyncFunction" /* AsyncFunction */);
+    is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
+    is.regExp = isObjectOfType("RegExp" /* RegExp */);
+    is.date = isObjectOfType("Date" /* Date */);
+    is.error = isObjectOfType("Error" /* Error */);
+    is.map = (value) => isObjectOfType("Map" /* Map */)(value);
+    is.set = (value) => isObjectOfType("Set" /* Set */)(value);
+    is.weakMap = (value) => isObjectOfType("WeakMap" /* WeakMap */)(value);
+    is.weakSet = (value) => isObjectOfType("WeakSet" /* WeakSet */)(value);
+    is.int8Array = isObjectOfType("Int8Array" /* Int8Array */);
+    is.uint8Array = isObjectOfType("Uint8Array" /* Uint8Array */);
+    is.uint8ClampedArray = isObjectOfType("Uint8ClampedArray" /* Uint8ClampedArray */);
+    is.int16Array = isObjectOfType("Int16Array" /* Int16Array */);
+    is.uint16Array = isObjectOfType("Uint16Array" /* Uint16Array */);
+    is.int32Array = isObjectOfType("Int32Array" /* Int32Array */);
+    is.uint32Array = isObjectOfType("Uint32Array" /* Uint32Array */);
+    is.float32Array = isObjectOfType("Float32Array" /* Float32Array */);
+    is.float64Array = isObjectOfType("Float64Array" /* Float64Array */);
+    is.arrayBuffer = isObjectOfType("ArrayBuffer" /* ArrayBuffer */);
+    is.sharedArrayBuffer = isObjectOfType("SharedArrayBuffer" /* SharedArrayBuffer */);
+    is.dataView = isObjectOfType("DataView" /* DataView */);
+    is.directInstanceOf = (instance, klass) => Object.getPrototypeOf(instance) === klass.prototype;
+    is.urlInstance = (value) => isObjectOfType("URL" /* URL */)(value);
+    is.urlString = (value) => {
+        if (!is.string(value)) {
+            return false;
+        }
+        try {
+            new URLGlobal(value); // tslint:disable-line no-unused-expression
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    is.truthy = (value) => Boolean(value);
+    is.falsy = (value) => !value;
+    is.nan = (value) => Number.isNaN(value);
+    const primitiveTypes = new Set([
+        'undefined',
+        'string',
+        'number',
+        'boolean',
+        'symbol'
+    ]);
+    is.primitive = (value) => is.null_(value) || primitiveTypes.has(typeof value);
+    is.integer = (value) => Number.isInteger(value);
+    is.safeInteger = (value) => Number.isSafeInteger(value);
+    is.plainObject = (value) => {
+        // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
+        let prototype;
+        return getObjectType(value) === "Object" /* Object */ &&
+            (prototype = Object.getPrototypeOf(value), prototype === null || // tslint:disable-line:ban-comma-operator
+                prototype === Object.getPrototypeOf({}));
+    };
+    const typedArrayTypes = new Set([
+        "Int8Array" /* Int8Array */,
+        "Uint8Array" /* Uint8Array */,
+        "Uint8ClampedArray" /* Uint8ClampedArray */,
+        "Int16Array" /* Int16Array */,
+        "Uint16Array" /* Uint16Array */,
+        "Int32Array" /* Int32Array */,
+        "Uint32Array" /* Uint32Array */,
+        "Float32Array" /* Float32Array */,
+        "Float64Array" /* Float64Array */
+    ]);
+    is.typedArray = (value) => {
+        const objectType = getObjectType(value);
+        if (objectType === null) {
+            return false;
+        }
+        return typedArrayTypes.has(objectType);
+    };
+    const isValidLength = (value) => is.safeInteger(value) && value > -1;
+    is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
+    is.inRange = (value, range) => {
+        if (is.number(range)) {
+            return value >= Math.min(0, range) && value <= Math.max(range, 0);
+        }
+        if (is.array(range) && range.length === 2) {
+            return value >= Math.min(...range) && value <= Math.max(...range);
+        }
+        throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+    };
+    const NODE_TYPE_ELEMENT = 1;
+    const DOM_PROPERTIES_TO_CHECK = [
+        'innerHTML',
+        'ownerDocument',
+        'style',
+        'attributes',
+        'nodeValue'
+    ];
+    is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
+        !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
+    is.observable = (value) => {
+        if (!value) {
+            return false;
+        }
+        if (value[Symbol.observable] && value === value[Symbol.observable]()) {
+            return true;
+        }
+        if (value['@@observable'] && value === value['@@observable']()) {
+            return true;
+        }
+        return false;
+    };
+    is.nodeStream = (value) => !is.nullOrUndefined(value) && isObject(value) && is.function_(value.pipe) && !is.observable(value);
+    is.infinite = (value) => value === Infinity || value === -Infinity;
+    const isAbsoluteMod2 = (rem) => (value) => is.integer(value) && Math.abs(value % 2) === rem;
+    is.even = isAbsoluteMod2(0);
+    is.odd = isAbsoluteMod2(1);
+    const isWhiteSpaceString = (value) => is.string(value) && /\S/.test(value) === false;
+    is.emptyArray = (value) => is.array(value) && value.length === 0;
+    is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
+    is.emptyString = (value) => is.string(value) && value.length === 0;
+    is.nonEmptyString = (value) => is.string(value) && value.length > 0;
+    is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
+    is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
+    is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
+    is.emptySet = (value) => is.set(value) && value.size === 0;
+    is.nonEmptySet = (value) => is.set(value) && value.size > 0;
+    is.emptyMap = (value) => is.map(value) && value.size === 0;
+    is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
+    const predicateOnArray = (method, predicate, values) => {
+        if (is.function_(predicate) === false) {
+            throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+        }
+        if (values.length === 0) {
+            throw new TypeError('Invalid number of values');
+        }
+        return method.call(values, predicate);
+    };
+    // tslint:disable variable-name
+    is.any = (predicate, ...values) => predicateOnArray(Array.prototype.some, predicate, values);
+    is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
+    // tslint:enable variable-name
+})(is || (is = {}));
+// Some few keywords are reserved, but we'll populate them for Node.js users
+// See https://github.com/Microsoft/TypeScript/issues/2536
+Object.defineProperties(is, {
+    class: {
+        value: is.class_
+    },
+    function: {
+        value: is.function_
+    },
+    null: {
+        value: is.null_
+    }
+});
+exports.default = is;
+// For CommonJS default export support
+module.exports = is;
+module.exports.default = is;
+//# sourceMappingURL=index.js.map

node_modules/@sindresorhus/is/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (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.

node_modules/@sindresorhus/is/package.json

@@ -0,0 +1,125 @@
+{
+  "_args": [
+    [
+      "@sindresorhus/is@^0.14.0",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/got"
+    ]
+  ],
+  "_from": "@sindresorhus/is@>=0.14.0 <0.15.0",
+  "_hasShrinkwrap": false,
+  "_id": "@sindresorhus/is@0.14.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@sindresorhus/is",
+  "_nodeVersion": "10.13.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/is_0.14.0_1544716808201_0.7722326585650734"
+  },
+  "_npmUser": {
+    "email": "sindresorhus@gmail.com",
+    "name": "sindresorhus"
+  },
+  "_npmVersion": "6.5.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@sindresorhus/is",
+    "raw": "@sindresorhus/is@^0.14.0",
+    "rawSpec": "^0.14.0",
+    "scope": "@sindresorhus",
+    "spec": ">=0.14.0 <0.15.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/got"
+  ],
+  "_resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz",
+  "_shasum": "9fb3a3cf3132328151f353de4632e01e52102bea",
+  "_shrinkwrap": null,
+  "_spec": "@sindresorhus/is@^0.14.0",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/got",
+  "author": {
+    "email": "sindresorhus@gmail.com",
+    "name": "Sindre Sorhus",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/sindresorhus/is/issues"
+  },
+  "dependencies": {},
+  "description": "Type check values: `is.string('🦄') //=> true`",
+  "devDependencies": {
+    "@sindresorhus/tsconfig": "^0.1.0",
+    "@types/jsdom": "^11.12.0",
+    "@types/node": "^10.12.10",
+    "@types/tempy": "^0.2.0",
+    "@types/zen-observable": "^0.8.0",
+    "ava": "^0.25.0",
+    "del-cli": "^1.1.0",
+    "jsdom": "^11.6.2",
+    "rxjs": "^6.3.3",
+    "tempy": "^0.2.1",
+    "tslint": "^5.9.1",
+    "tslint-xo": "^0.10.0",
+    "typescript": "^3.2.1",
+    "zen-observable": "^0.8.8"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 6,
+    "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJcEoIJCRA9TVsSAnZWagAAU08QAKRmmjyTcJv4iAVu+wry\n2CzzAwXJWrHc93Jw/6+u0TBj54yGGGblVjDyL9zh8oDte+ea3h7q9boPKgFb\nq5e2uTUcqreN3ACUae3RPfTMysurTujN6Bd+iet8CRcAmC8n8Isdano2UB5Q\nEvgP1BJgRIgIrHKCr+OwLNLCfN7K5XQPuZeymMaU1BhzIoz8e0vRRnyrQSsC\nIb5NnhpVi3GsLqwlr7yGbTvNZ28mTm3wzDSivpNbZ/ceEecNUdFc/ioRhzTn\nusAzAD2aIjp/WSVuokPgCQYz5fzFj19clZfuvoURD/uS+EOQQaWPQ0xESHx2\nN5qENeQo1u1m1Snq5l5AVxpz5GDiE8DQKxIV1iR6Nh+rg18hVEu8Y8Q9DPgS\n91D+4ue1cTql2mKFtRS6SilDmvmmKhAoCROJw3wvv1Pef4Q9Ke9aqkW53ay7\nE0xfbWXtdu491hdOfYglED4F79BQi5ExUWQRKrVWM4cXs6QE87cwsBd9+p5c\nV99QHu4ZgOJoV5EOJyB2sOf/U0emh4rTV1So0Dz8HLhRQ4JbBNwZmVD4CSAX\nqQo1WG3DntAYTnk44nHkiwmVM4tlL3U6kyN7hxMeWrpA5qSIhokc2uYZNOxE\n7c+gmo7WteSsKKYekDdoFYVTL+c9dsszU9OWGdr6f7vsdTKkbVp913BN7v0S\ncjHv\r\n=KAWq\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "9fb3a3cf3132328151f353de4632e01e52102bea",
+    "tarball": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz",
+    "unpackedSize": 40158
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "gitHead": "6cb1d1e91073ada3d0e298e2fef361f0d418b668",
+  "homepage": "https://github.com/sindresorhus/is#readme",
+  "keywords": [
+    "assert",
+    "assertion",
+    "check",
+    "checking",
+    "compare",
+    "instanceof",
+    "is",
+    "kind",
+    "object",
+    "primitive",
+    "test",
+    "type",
+    "typeof",
+    "types",
+    "util",
+    "utility",
+    "validate",
+    "validation",
+    "verify"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "maintainers": [
+    {
+      "name": "sindresorhus",
+      "email": "sindresorhus@gmail.com"
+    }
+  ],
+  "name": "@sindresorhus/is",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sindresorhus/is.git"
+  },
+  "scripts": {
+    "build": "del dist && tsc",
+    "lint": "tslint --format stylish --project .",
+    "prepublish": "npm run build && del dist/tests",
+    "test": "npm run lint && npm run build && ava dist/tests"
+  },
+  "types": "dist/index.d.ts",
+  "version": "0.14.0"
+}

node_modules/@sindresorhus/is/readme.md

@@ -0,0 +1,451 @@
+# is [![Build Status](https://travis-ci.org/sindresorhus/is.svg?branch=master)](https://travis-ci.org/sindresorhus/is)
+
+> Type check values: `is.string('🦄') //=> true`
+
+<img src="header.gif" width="182" align="right">
+
+
+## Install
+
+```
+$ npm install @sindresorhus/is
+```
+
+
+## Usage
+
+```js
+const is = require('@sindresorhus/is');
+
+is('🦄');
+//=> 'string'
+
+is(new Map());
+//=> 'Map'
+
+is.number(6);
+//=> true
+```
+
+When using `is` together with TypeScript, [type guards](http://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types) are being used to infer the correct type inside if-else statements.
+
+```ts
+import is from '@sindresorhus/is';
+
+const padLeft = (value: string, padding: string | number) => {
+	if (is.number(padding)) {
+		// `padding` is typed as `number`
+		return Array(padding + 1).join(' ') + value;
+	}
+
+	if (is.string(padding)) {
+		// `padding` is typed as `string`
+		return padding + value;
+	}
+
+	throw new TypeError(`Expected 'padding' to be of type 'string' or 'number', got '${is(padding)}'.`);
+}
+
+padLeft('🦄', 3);
+//=> '   🦄'
+
+padLeft('🦄', '🌈');
+//=> '🌈🦄'
+```
+
+
+## API
+
+### is(value)
+
+Returns the type of `value`.
+
+Primitives are lowercase and object types are camelcase.
+
+Example:
+
+- `'undefined'`
+- `'null'`
+- `'string'`
+- `'symbol'`
+- `'Array'`
+- `'Function'`
+- `'Object'`
+
+Note: It will throw an error if you try to feed it object-wrapped primitives, as that's a bad practice. For example `new String('foo')`.
+
+### is.{method}
+
+All the below methods accept a value and returns a boolean for whether the value is of the desired type.
+
+#### Primitives
+
+##### .undefined(value)
+##### .null(value)
+##### .string(value)
+##### .number(value)
+##### .boolean(value)
+##### .symbol(value)
+
+#### Built-in types
+
+##### .array(value)
+##### .function(value)
+##### .buffer(value)
+##### .object(value)
+
+Keep in mind that [functions are objects too](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions).
+
+##### .numericString(value)
+
+Returns `true` for a string that represents a number. For example, `'42'` and `'-8'`.
+
+Note: `'NaN'` returns `false`, but `'Infinity'` and `'-Infinity'` return `true`.
+
+##### .regExp(value)
+##### .date(value)
+##### .error(value)
+##### .nativePromise(value)
+##### .promise(value)
+
+Returns `true` for any object with a `.then()` and `.catch()` method. Prefer this one over `.nativePromise()` as you usually want to allow userland promise implementations too.
+
+##### .generator(value)
+
+Returns `true` for any object that implements its own `.next()` and `.throw()` methods and has a function definition for `Symbol.iterator`.
+
+##### .generatorFunction(value)
+
+##### .asyncFunction(value)
+
+Returns `true` for any `async` function that can be called with the `await` operator.
+
+```js
+is.asyncFunction(async () => {});
+// => true
+
+is.asyncFunction(() => {});
+// => false
+```
+
+##### .boundFunction(value)
+
+Returns `true` for any `bound` function.
+
+```js
+is.boundFunction(() => {});
+// => true
+
+is.boundFunction(function () {}.bind(null));
+// => true
+
+is.boundFunction(function () {});
+// => false
+```
+
+##### .map(value)
+##### .set(value)
+##### .weakMap(value)
+##### .weakSet(value)
+
+#### Typed arrays
+
+##### .int8Array(value)
+##### .uint8Array(value)
+##### .uint8ClampedArray(value)
+##### .int16Array(value)
+##### .uint16Array(value)
+##### .int32Array(value)
+##### .uint32Array(value)
+##### .float32Array(value)
+##### .float64Array(value)
+
+#### Structured data
+
+##### .arrayBuffer(value)
+##### .sharedArrayBuffer(value)
+##### .dataView(value)
+
+#### Emptiness
+
+##### .emptyString(value)
+
+Returns `true` if the value is a `string` and the `.length` is 0.
+
+##### .nonEmptyString(value)
+
+Returns `true` if the value is a `string` and the `.length` is more than 0.
+
+##### .emptyStringOrWhitespace(value)
+
+Returns `true` if `is.emptyString(value)` or if it's a `string` that is all whitespace.
+
+##### .emptyArray(value)
+
+Returns `true` if the value is an `Array` and the `.length` is 0.
+
+##### .nonEmptyArray(value)
+
+Returns `true` if the value is an `Array` and the `.length` is more than 0.
+
+##### .emptyObject(value)
+
+Returns `true` if the value is an `Object` and `Object.keys(value).length` is 0.
+
+Please note that `Object.keys` returns only own enumerable properties. Hence something like this can happen:
+
+```js
+const object1 = {};
+
+Object.defineProperty(object1, 'property1', {
+	value: 42,
+	writable: true,
+	enumerable: false,
+	configurable: true
+});
+
+is.emptyObject(object1);
+// => true
+```
+
+##### .nonEmptyObject(value)
+
+Returns `true` if the value is an `Object` and `Object.keys(value).length` is more than 0.
+
+##### .emptySet(value)
+
+Returns `true` if the value is a `Set` and the `.size` is 0.
+
+##### .nonEmptySet(Value)
+
+Returns `true` if the value is a `Set` and the `.size` is more than 0.
+
+##### .emptyMap(value)
+
+Returns `true` if the value is a `Map` and the `.size` is 0.
+
+##### .nonEmptyMap(value)
+
+Returns `true` if the value is a `Map` and the `.size` is more than 0.
+
+#### Miscellaneous
+
+##### .directInstanceOf(value, class)
+
+Returns `true` if `value` is a direct instance of `class`.
+
+```js
+is.directInstanceOf(new Error(), Error);
+//=> true
+
+class UnicornError extends Error {}
+
+is.directInstanceOf(new UnicornError(), Error);
+//=> false
+```
+
+##### .urlInstance(value)
+
+Returns `true` if `value` is an instance of the [`URL` class](https://developer.mozilla.org/en-US/docs/Web/API/URL).
+
+```js
+const url = new URL('https://example.com');
+
+is.urlInstance(url);
+//=> true
+```
+
+### .url(value)
+
+Returns `true` if `value` is a URL string.
+
+Note: this only does basic checking using the [`URL` class](https://developer.mozilla.org/en-US/docs/Web/API/URL) constructor.
+
+```js
+const url = 'https://example.com';
+
+is.url(url);
+//=> true
+
+is.url(new URL(url));
+//=> false
+```
+
+##### .truthy(value)
+
+Returns `true` for all values that evaluate to true in a boolean context:
+
+```js
+is.truthy('🦄');
+//=> true
+
+is.truthy(undefined);
+//=> false
+```
+
+##### .falsy(value)
+
+Returns `true` if `value` is one of: `false`, `0`, `''`, `null`, `undefined`, `NaN`.
+
+##### .nan(value)
+##### .nullOrUndefined(value)
+##### .primitive(value)
+
+JavaScript primitives are as follows: `null`, `undefined`, `string`, `number`, `boolean`, `symbol`.
+
+##### .integer(value)
+
+##### .safeInteger(value)
+
+Returns `true` if `value` is a [safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
+
+##### .plainObject(value)
+
+An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`.
+
+##### .iterable(value)
+##### .asyncIterable(value)
+##### .class(value)
+
+Returns `true` for instances created by a class.
+
+##### .typedArray(value)
+
+##### .arrayLike(value)
+
+A `value` is array-like if it is not a function and has a `value.length` that is a safe integer greater than or equal to 0.
+
+```js
+is.arrayLike(document.forms);
+//=> true
+
+function foo() {
+	is.arrayLike(arguments);
+	//=> true
+}
+foo();
+```
+
+##### .inRange(value, range)
+
+Check if `value` (number) is in the given `range`. The range is an array of two values, lower bound and upper bound, in no specific order.
+
+```js
+is.inRange(3, [0, 5]);
+is.inRange(3, [5, 0]);
+is.inRange(0, [-2, 2]);
+```
+
+##### .inRange(value, upperBound)
+
+Check if `value` (number) is in the range of `0` to `upperBound`.
+
+```js
+is.inRange(3, 10);
+```
+
+##### .domElement(value)
+
+Returns `true` if `value` is a DOM Element.
+
+##### .nodeStream(value)
+
+Returns `true` if `value` is a Node.js [stream](https://nodejs.org/api/stream.html).
+
+```js
+const fs = require('fs');
+
+is.nodeStream(fs.createReadStream('unicorn.png'));
+//=> true
+```
+
+##### .observable(value)
+
+Returns `true` if `value` is an `Observable`.
+
+```js
+const {Observable} = require('rxjs');
+
+is.observable(new Observable());
+//=> true
+```
+
+##### .infinite(value)
+
+Check if `value` is `Infinity` or `-Infinity`.
+
+##### .even(value)
+
+Returns `true` if `value` is an even integer.
+
+##### .odd(value)
+
+Returns `true` if `value` is an odd integer.
+
+##### .any(predicate, ...values)
+
+Returns `true` if **any** of the input `values` returns true in the `predicate`:
+
+```js
+is.any(is.string, {}, true, '🦄');
+//=> true
+
+is.any(is.boolean, 'unicorns', [], new Map());
+//=> false
+```
+
+##### .all(predicate, ...values)
+
+Returns `true` if **all** of the input `values` returns true in the `predicate`:
+
+```js
+is.all(is.object, {}, new Map(), new Set());
+//=> true
+
+is.all(is.string, '🦄', [], 'unicorns');
+//=> false
+```
+
+
+## FAQ
+
+### Why yet another type checking module?
+
+There are hundreds of type checking modules on npm, unfortunately, I couldn't find any that fit my needs:
+
+- Includes both type methods and ability to get the type
+- Types of primitives returned as lowercase and object types as camelcase
+- Covers all built-ins
+- Unsurprising behavior
+- Well-maintained
+- Comprehensive test suite
+
+For the ones I found, pick 3 of these.
+
+The most common mistakes I noticed in these modules was using `instanceof` for type checking, forgetting that functions are objects, and omitting `symbol` as a primitive.
+
+
+## Related
+
+- [ow](https://github.com/sindresorhus/ow) - Function argument validation for humans
+- [is-stream](https://github.com/sindresorhus/is-stream) - Check if something is a Node.js stream
+- [is-observable](https://github.com/sindresorhus/is-observable) - Check if a value is an Observable
+- [file-type](https://github.com/sindresorhus/file-type) - Detect the file type of a Buffer/Uint8Array
+- [is-ip](https://github.com/sindresorhus/is-ip) - Check if a string is an IP address
+- [is-array-sorted](https://github.com/sindresorhus/is-array-sorted) - Check if an Array is sorted
+- [is-error-constructor](https://github.com/sindresorhus/is-error-constructor) - Check if a value is an error constructor
+- [is-empty-iterable](https://github.com/sindresorhus/is-empty-iterable) - Check if an Iterable is empty
+- [is-blob](https://github.com/sindresorhus/is-blob) - Check if a value is a Blob - File-like object of immutable, raw data
+- [has-emoji](https://github.com/sindresorhus/has-emoji) - Check whether a string has any emoji
+
+
+## Created by
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Giora Guttsait](https://github.com/gioragutt)
+- [Brandon Smith](https://github.com/brandon93s)
+
+
+## License
+
+MIT

node_modules/@szmarczak/http-timer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Szymon Marczak
+
+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.

node_modules/@szmarczak/http-timer/README.md

@@ -0,0 +1,70 @@
+# http-timer
+> Timings for HTTP requests
+
+[![Build Status](https://travis-ci.org/szmarczak/http-timer.svg?branch=master)](https://travis-ci.org/szmarczak/http-timer)
+[![Coverage Status](https://coveralls.io/repos/github/szmarczak/http-timer/badge.svg?branch=master)](https://coveralls.io/github/szmarczak/http-timer?branch=master)
+[![install size](https://packagephobia.now.sh/badge?p=@szmarczak/http-timer)](https://packagephobia.now.sh/result?p=@szmarczak/http-timer)
+
+Inspired by the [`request` package](https://github.com/request/request).
+
+## Usage
+```js
+'use strict';
+const https = require('https');
+const timer = require('@szmarczak/http-timer');
+
+const request = https.get('https://httpbin.org/anything');
+const timings = timer(request);
+
+request.on('response', response => {
+	response.on('data', () => {}); // Consume the data somehow
+	response.on('end', () => {
+		console.log(timings);
+	});
+});
+
+// { start: 1535708511443,
+//   socket: 1535708511444,
+//   lookup: 1535708511444,
+//   connect: 1535708511582,
+//   upload: 1535708511887,
+//   response: 1535708512037,
+//   end: 1535708512040,
+//   phases:
+//    { wait: 1,
+//      dns: 0,
+//      tcp: 138,
+//      request: 305,
+//      firstByte: 150,
+//      download: 3,
+//      total: 597 } }
+```
+
+## API
+
+### timer(request)
+
+Returns: `Object`
+
+- `start` - Time when the request started.
+- `socket` - Time when a socket was assigned to the request.
+- `lookup` - Time when the DNS lookup finished.
+- `connect` - Time when the socket successfully connected.
+- `upload` - Time when the request finished uploading.
+- `response` - Time when the request fired the `response` event.
+- `end` - Time when the response fired the `end` event.
+- `error` - Time when the request fired the `error` event.
+- `phases`
+	- `wait` - `timings.socket - timings.start`
+	- `dns` - `timings.lookup - timings.socket`
+	- `tcp` - `timings.connect - timings.lookup`
+	- `request` - `timings.upload - timings.connect`
+	- `firstByte` - `timings.response - timings.upload`
+	- `download` - `timings.end - timings.response`
+	- `total` - `timings.end - timings.start` or `timings.error - timings.start`
+
+**Note**: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+
+## License
+
+MIT

node_modules/@szmarczak/http-timer/package.json

@@ -0,0 +1,103 @@
+{
+  "_args": [
+    [
+      "@szmarczak/http-timer@^1.1.2",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/got"
+    ]
+  ],
+  "_from": "@szmarczak/http-timer@>=1.1.2 <2.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "@szmarczak/http-timer@1.1.2",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@szmarczak/http-timer",
+  "_nodeVersion": "11.6.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/http-timer_1.1.2_1546619937020_0.7812035537643258"
+  },
+  "_npmUser": {
+    "email": "sz.marczak@gmail.com",
+    "name": "szmarczak"
+  },
+  "_npmVersion": "6.5.0-next.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@szmarczak/http-timer",
+    "raw": "@szmarczak/http-timer@^1.1.2",
+    "rawSpec": "^1.1.2",
+    "scope": "@szmarczak",
+    "spec": ">=1.1.2 <2.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/got"
+  ],
+  "_resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz",
+  "_shasum": "b1665e2c461a2cd92f4c1bbf50d5454de0d4b421",
+  "_shrinkwrap": null,
+  "_spec": "@szmarczak/http-timer@^1.1.2",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/got",
+  "author": {
+    "name": "Szymon Marczak"
+  },
+  "bugs": {
+    "url": "https://github.com/szmarczak/http-timer/issues"
+  },
+  "dependencies": {
+    "defer-to-connect": "^1.0.1"
+  },
+  "description": "Timings for HTTP requests",
+  "devDependencies": {
+    "ava": "^0.25.0",
+    "coveralls": "^3.0.2",
+    "nyc": "^12.0.2",
+    "p-event": "^2.1.0",
+    "xo": "^0.22.0"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 4,
+    "integrity": "sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJcL4whCRA9TVsSAnZWagAA5pgP/3DWndgx0zab0GQZ0r6z\nxahulxeCKn6PCn+v4S214bPpTO7rRnOiotJT46gx7aKx0G8rx5Vnaf3Isx/s\nJ3rdoO3qLw8ISl9CnRlqRHnr1xd7k+IKir5tAHIJTA0eFEZpaizaH56j/xDS\nLcTsmXRlGkDp8Xp7fRTN1dXseCdtDcOM7+4f3+18oviB3vW65Z1UFa1SrvJ4\nJOmgsn/Q8d9yIlmL6TpXpiHoymOx35Aqu/vMFnXMnRJQ1zHJd9XmS1EBfBl5\n4VWrB//a/c9IrYmt7z+xIms173qmVEA3TwRVjkaMfs/9baafKMdyI4ztUtsW\nnwf6aoYBMbf/06VPiU3L5rKIht9WesfBrk01vZDr3M9+Yjy294PAvvTSTJEw\nj4Yyp55HJ6NzLYO6MbS4k0+TNK4vexYI3ocRosaEZyqpye6gAr0Xo6mvmWDD\nI7q4oyaIicAiidgLkgrd46URKddKwvx9PoycyRxZS9MxjUte6X0XK2ODjYqI\n8BSgwMIhk87fSPTL7UeFQpD9vFm15YVhV+gyiPVFy43LtuevAVJsnZQ9EV2S\nV5M7TwSmiI1Ue0FH3sQIeeQtDu2pM0ewCQmNTHDfq/Fj63FAxWEFqPZgWxTF\nOtnFgQNTZX9YXQMpvgsvJWm8a59vo17ene7vXqeXNPHHLWcJaF5VhkugBk6L\n8Uy/\r\n=WwTF\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "b1665e2c461a2cd92f4c1bbf50d5454de0d4b421",
+    "tarball": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz",
+    "unpackedSize": 6296
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "gitHead": "010f7732043933ec6309045f01473af3495591c4",
+  "homepage": "https://github.com/szmarczak/http-timer#readme",
+  "keywords": [
+    "http",
+    "https",
+    "timer",
+    "timings"
+  ],
+  "license": "MIT",
+  "main": "source",
+  "maintainers": [
+    {
+      "name": "szmarczak",
+      "email": "sz.marczak@gmail.com"
+    }
+  ],
+  "name": "@szmarczak/http-timer",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/szmarczak/http-timer.git"
+  },
+  "scripts": {
+    "coveralls": "nyc report --reporter=text-lcov | coveralls",
+    "test": "xo && nyc ava"
+  },
+  "version": "1.1.2",
+  "xo": {
+    "rules": {
+      "unicorn/filename-case": "camelCase"
+    }
+  }
+}

node_modules/@szmarczak/http-timer/source/index.js

@@ -0,0 +1,99 @@
+'use strict';
+const deferToConnect = require('defer-to-connect');
+
+module.exports = request => {
+	const timings = {
+		start: Date.now(),
+		socket: null,
+		lookup: null,
+		connect: null,
+		upload: null,
+		response: null,
+		end: null,
+		error: null,
+		phases: {
+			wait: null,
+			dns: null,
+			tcp: null,
+			request: null,
+			firstByte: null,
+			download: null,
+			total: null
+		}
+	};
+
+	const handleError = origin => {
+		const emit = origin.emit.bind(origin);
+		origin.emit = (event, ...args) => {
+			// Catches the `error` event
+			if (event === 'error') {
+				timings.error = Date.now();
+				timings.phases.total = timings.error - timings.start;
+
+				origin.emit = emit;
+			}
+
+			// Saves the original behavior
+			return emit(event, ...args);
+		};
+	};
+
+	let uploadFinished = false;
+	const onUpload = () => {
+		timings.upload = Date.now();
+		timings.phases.request = timings.upload - timings.connect;
+	};
+
+	handleError(request);
+
+	request.once('socket', socket => {
+		timings.socket = Date.now();
+		timings.phases.wait = timings.socket - timings.start;
+
+		const lookupListener = () => {
+			timings.lookup = Date.now();
+			timings.phases.dns = timings.lookup - timings.socket;
+		};
+
+		socket.once('lookup', lookupListener);
+
+		deferToConnect(socket, () => {
+			timings.connect = Date.now();
+
+			if (timings.lookup === null) {
+				socket.removeListener('lookup', lookupListener);
+				timings.lookup = timings.connect;
+				timings.phases.dns = timings.lookup - timings.socket;
+			}
+
+			timings.phases.tcp = timings.connect - timings.lookup;
+
+			if (uploadFinished && !timings.upload) {
+				onUpload();
+			}
+		});
+	});
+
+	request.once('finish', () => {
+		uploadFinished = true;
+
+		if (timings.connect) {
+			onUpload();
+		}
+	});
+
+	request.once('response', response => {
+		timings.response = Date.now();
+		timings.phases.firstByte = timings.response - timings.upload;
+
+		handleError(response);
+
+		response.once('end', () => {
+			timings.end = Date.now();
+			timings.phases.download = timings.end - timings.response;
+			timings.phases.total = timings.end - timings.start;
+		});
+	});
+
+	return timings;
+};

node_modules/@types/color-name/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

node_modules/@types/color-name/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/color-name`
+
+# Summary
+This package contains type definitions for color-name ( https://github.com/colorjs/color-name ).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/color-name
+
+Additional Details
+ * Last updated: Wed, 13 Feb 2019 16:16:48 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by Junyoung Clare Jang <https://github.com/Ailrun>.

node_modules/@types/color-name/index.d.ts

@@ -0,0 +1,161 @@
+// Type definitions for color-name 1.1
+// Project: https://github.com/colorjs/color-name
+// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Tuple of Red, Green, and Blue
+ * @example
+ * // Red = 55, Green = 70, Blue = 0
+ * const rgb: RGB = [55, 70, 0];
+ */
+export type RGB = [number, number, number];
+
+export const aliceblue: RGB;
+export const antiquewhite: RGB;
+export const aqua: RGB;
+export const aquamarine: RGB;
+export const azure: RGB;
+export const beige: RGB;
+export const bisque: RGB;
+export const black: RGB;
+export const blanchedalmond: RGB;
+export const blue: RGB;
+export const blueviolet: RGB;
+export const brown: RGB;
+export const burlywood: RGB;
+export const cadetblue: RGB;
+export const chartreuse: RGB;
+export const chocolate: RGB;
+export const coral: RGB;
+export const cornflowerblue: RGB;
+export const cornsilk: RGB;
+export const crimson: RGB;
+export const cyan: RGB;
+export const darkblue: RGB;
+export const darkcyan: RGB;
+export const darkgoldenrod: RGB;
+export const darkgray: RGB;
+export const darkgreen: RGB;
+export const darkgrey: RGB;
+export const darkkhaki: RGB;
+export const darkmagenta: RGB;
+export const darkolivegreen: RGB;
+export const darkorange: RGB;
+export const darkorchid: RGB;
+export const darkred: RGB;
+export const darksalmon: RGB;
+export const darkseagreen: RGB;
+export const darkslateblue: RGB;
+export const darkslategray: RGB;
+export const darkslategrey: RGB;
+export const darkturquoise: RGB;
+export const darkviolet: RGB;
+export const deeppink: RGB;
+export const deepskyblue: RGB;
+export const dimgray: RGB;
+export const dimgrey: RGB;
+export const dodgerblue: RGB;
+export const firebrick: RGB;
+export const floralwhite: RGB;
+export const forestgreen: RGB;
+export const fuchsia: RGB;
+export const gainsboro: RGB;
+export const ghostwhite: RGB;
+export const gold: RGB;
+export const goldenrod: RGB;
+export const gray: RGB;
+export const green: RGB;
+export const greenyellow: RGB;
+export const grey: RGB;
+export const honeydew: RGB;
+export const hotpink: RGB;
+export const indianred: RGB;
+export const indigo: RGB;
+export const ivory: RGB;
+export const khaki: RGB;
+export const lavender: RGB;
+export const lavenderblush: RGB;
+export const lawngreen: RGB;
+export const lemonchiffon: RGB;
+export const lightblue: RGB;
+export const lightcoral: RGB;
+export const lightcyan: RGB;
+export const lightgoldenrodyellow: RGB;
+export const lightgray: RGB;
+export const lightgreen: RGB;
+export const lightgrey: RGB;
+export const lightpink: RGB;
+export const lightsalmon: RGB;
+export const lightseagreen: RGB;
+export const lightskyblue: RGB;
+export const lightslategray: RGB;
+export const lightslategrey: RGB;
+export const lightsteelblue: RGB;
+export const lightyellow: RGB;
+export const lime: RGB;
+export const limegreen: RGB;
+export const linen: RGB;
+export const magenta: RGB;
+export const maroon: RGB;
+export const mediumaquamarine: RGB;
+export const mediumblue: RGB;
+export const mediumorchid: RGB;
+export const mediumpurple: RGB;
+export const mediumseagreen: RGB;
+export const mediumslateblue: RGB;
+export const mediumspringgreen: RGB;
+export const mediumturquoise: RGB;
+export const mediumvioletred: RGB;
+export const midnightblue: RGB;
+export const mintcream: RGB;
+export const mistyrose: RGB;
+export const moccasin: RGB;
+export const navajowhite: RGB;
+export const navy: RGB;
+export const oldlace: RGB;
+export const olive: RGB;
+export const olivedrab: RGB;
+export const orange: RGB;
+export const orangered: RGB;
+export const orchid: RGB;
+export const palegoldenrod: RGB;
+export const palegreen: RGB;
+export const paleturquoise: RGB;
+export const palevioletred: RGB;
+export const papayawhip: RGB;
+export const peachpuff: RGB;
+export const peru: RGB;
+export const pink: RGB;
+export const plum: RGB;
+export const powderblue: RGB;
+export const purple: RGB;
+export const rebeccapurple: RGB;
+export const red: RGB;
+export const rosybrown: RGB;
+export const royalblue: RGB;
+export const saddlebrown: RGB;
+export const salmon: RGB;
+export const sandybrown: RGB;
+export const seagreen: RGB;
+export const seashell: RGB;
+export const sienna: RGB;
+export const silver: RGB;
+export const skyblue: RGB;
+export const slateblue: RGB;
+export const slategray: RGB;
+export const slategrey: RGB;
+export const snow: RGB;
+export const springgreen: RGB;
+export const steelblue: RGB;
+export const tan: RGB;
+export const teal: RGB;
+export const thistle: RGB;
+export const tomato: RGB;
+export const turquoise: RGB;
+export const violet: RGB;
+export const wheat: RGB;
+export const white: RGB;
+export const whitesmoke: RGB;
+export const yellow: RGB;
+export const yellowgreen: RGB;

node_modules/@types/color-name/package.json

@@ -0,0 +1,83 @@
+{
+  "_args": [
+    [
+      "@types/color-name@^1.1.1",
+      "/home/lyxaira/Artesanias/artesanias/node_modules/cordova-lib/node_modules/ansi-styles"
+    ]
+  ],
+  "_from": "@types/color-name@>=1.1.1 <2.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "@types/color-name@1.1.1",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@types/color-name",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/color-name_1.1.1_1550075907636_0.27445667614815705"
+  },
+  "_npmUser": {
+    "email": "ts-npm-types@microsoft.com",
+    "name": "types"
+  },
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@types/color-name",
+    "raw": "@types/color-name@^1.1.1",
+    "rawSpec": "^1.1.1",
+    "scope": "@types",
+    "spec": ">=1.1.1 <2.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/boxen/ansi-styles",
+    "/cordova-lib/ansi-styles",
+    "/update-notifier/ansi-styles"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz",
+  "_shasum": "1c1261bbeaa10a8055bbc5d8ab84b7b2afc846a0",
+  "_shrinkwrap": null,
+  "_spec": "@types/color-name@^1.1.1",
+  "_where": "/home/lyxaira/Artesanias/artesanias/node_modules/cordova-lib/node_modules/ansi-styles",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "contributors": [
+    {
+      "name": "Junyoung Clare Jang",
+      "url": "https://github.com/Ailrun"
+    }
+  ],
+  "dependencies": {},
+  "description": "TypeScript definitions for color-name",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 4,
+    "integrity": "sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJcZEgECRA9TVsSAnZWagAAfA8QAJC+L3IXpCHyUwm7u4oN\ngbtWuc7X0zfKubrTpG5ozUde6sBP4N3mLLllqHewqzcZx0zrQoqrmv96Xja+\nWqNEbYoLuByI2AtPbV30P30uKolldeFCf/dTHenjujdt1Vmk2MBMHJWUkRuU\n0vJK5UnY5ybprWvgVOs51psNIR+MGuNFKl5aVuM+wPttZt83JEElyMCQQaWg\nnSwvv+GEElBf62pJCfWllyIYG/oH0nfDz02Ba8b2jNDLwYefOrVJalyEhf97\nWqXBM+DyZfc8ZCEYVP9pB8eUgiRqr96olbs1kKc6dbKt4nCaxOLHD0zT7IsD\nWIdMkRkiycX7vQDXxN9gQcS1iULQdssZHD/c4eVXVlGIczfxW5kPn0PXul/F\nTGiuPsf6Oa9ca28f/IX/pmr2VDOnB3Aaj4mlC4WlQ1KMaEbry2nVvu98Owiz\ngz0/AFvkKHzgaBlPi7BV/XVgQdd5dGyvPlYfH2+EwMmQSGuzDpXr7Uys3AlV\nDCQS+A07/vl4vW+9YPZR5rZwkw+vNi8s6qXUL7gLHQiJNaMGS7057QUOJg0s\nTXtRelzcBVD4+RTXFCfXliIY5rKy9LEL/A4gKbqZj5DKI0u2K7O72jkjvUaK\nw1emj6txBxHpXA7rvUkvEyWuLfQEMXn95Oi2B90V/ZKnpAG+rdzQ1WhxMTG6\nnzh1\r\n=7zdn\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "1c1261bbeaa10a8055bbc5d8ab84b7b2afc846a0",
+    "tarball": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz",
+    "unpackedSize": 7015
+  },
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "maintainers": [
+    {
+      "name": "types",
+      "email": "ts-npm-types@microsoft.com"
+    }
+  ],
+  "name": "@types/color-name",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "typeScriptVersion": "2.0",
+  "types": "index",
+  "typesPublisherContentHash": "e22c6881e2dcf766e32142cbb82d9acf9c08258bdf0da8e76c8a448d1be44ac7",
+  "version": "1.1.1"
+}

node_modules/ajv/.tonic_example.js

@@ -0,0 +1,20 @@
+var Ajv = require('ajv');
+var ajv = new Ajv({allErrors: true});
+
+var schema = {
+  "properties": {
+    "foo": { "type": "string" },
+    "bar": { "type": "number", "maximum": 3 }
+  }
+};
+
+var validate = ajv.compile(schema);
+
+test({"foo": "abc", "bar": 2});
+test({"foo": 2, "bar": 4});
+
+function test(data) {
+  var valid = validate(data);
+  if (valid) console.log('Valid!');
+  else console.log('Invalid: ' + ajv.errorsText(validate.errors));
+}

node_modules/ajv/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2017 Evgeny Poberezkin
+
+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.
+