vaderjs 1.1.2 → 1.1.4

package/website/node_modules/arg/README.md

@@ -1,317 +0,0 @@
-# Arg
-
-`arg` is an unopinionated, no-frills CLI argument parser.
-
-## Installation
-
-```bash
-npm install arg
-```
-
-## Usage
-
-`arg()` takes either 1 or 2 arguments:
-
-1. Command line specification object (see below)
-2. Parse options (_Optional_, defaults to `{permissive: false, argv: process.argv.slice(2), stopAtPositional: false}`)
-
-It returns an object with any values present on the command-line (missing options are thus
-missing from the resulting object). Arg performs no validation/requirement checking - we
-leave that up to the application.
-
-All parameters that aren't consumed by options (commonly referred to as "extra" parameters)
-are added to `result._`, which is _always_ an array (even if no extra parameters are passed,
-in which case an empty array is returned).
-
-```javascript
-const arg = require('arg');
-
-// `options` is an optional parameter
-const args = arg(
-	spec,
-	(options = { permissive: false, argv: process.argv.slice(2) })
-);
-```
-
-For example:
-
-```console
-$ node ./hello.js --verbose -vvv --port=1234 -n 'My name' foo bar --tag qux --tag=qix -- --foobar
-```
-
-```javascript
-// hello.js
-const arg = require('arg');
-
-const args = arg({
-	// Types
-	'--help': Boolean,
-	'--version': Boolean,
-	'--verbose': arg.COUNT, // Counts the number of times --verbose is passed
-	'--port': Number, // --port <number> or --port=<number>
-	'--name': String, // --name <string> or --name=<string>
-	'--tag': [String], // --tag <string> or --tag=<string>
-
-	// Aliases
-	'-v': '--verbose',
-	'-n': '--name', // -n <string>; result is stored in --name
-	'--label': '--name' // --label <string> or --label=<string>;
-	//     result is stored in --name
-});
-
-console.log(args);
-/*
-{
-	_: ["foo", "bar", "--foobar"],
-	'--port': 1234,
-	'--verbose': 4,
-	'--name': "My name",
-	'--tag': ["qux", "qix"]
-}
-*/
-```
-
-The values for each key=&gt;value pair is either a type (function or [function]) or a string (indicating an alias).
-
-- In the case of a function, the string value of the argument's value is passed to it,
-  and the return value is used as the ultimate value.
-
-- In the case of an array, the only element _must_ be a type function. Array types indicate
-  that the argument may be passed multiple times, and as such the resulting value in the returned
-  object is an array with all of the values that were passed using the specified flag.
-
-- In the case of a string, an alias is established. If a flag is passed that matches the _key_,
-  then the _value_ is substituted in its place.
-
-Type functions are passed three arguments:
-
-1. The parameter value (always a string)
-2. The parameter name (e.g. `--label`)
-3. The previous value for the destination (useful for reduce-like operations or for supporting `-v` multiple times, etc.)
-
-This means the built-in `String`, `Number`, and `Boolean` type constructors "just work" as type functions.
-
-Note that `Boolean` and `[Boolean]` have special treatment - an option argument is _not_ consumed or passed, but instead `true` is
-returned. These options are called "flags".
-
-For custom handlers that wish to behave as flags, you may pass the function through `arg.flag()`:
-
-```javascript
-const arg = require('arg');
-
-const argv = [
-	'--foo',
-	'bar',
-	'-ff',
-	'baz',
-	'--foo',
-	'--foo',
-	'qux',
-	'-fff',
-	'qix'
-];
-
-function myHandler(value, argName, previousValue) {
-	/* `value` is always `true` */
-	return 'na ' + (previousValue || 'batman!');
-}
-
-const args = arg(
-	{
-		'--foo': arg.flag(myHandler),
-		'-f': '--foo'
-	},
-	{
-		argv
-	}
-);
-
-console.log(args);
-/*
-{
-	_: ['bar', 'baz', 'qux', 'qix'],
-	'--foo': 'na na na na na na na na batman!'
-}
-*/
-```
-
-As well, `arg` supplies a helper argument handler called `arg.COUNT`, which equivalent to a `[Boolean]` argument's `.length`
-property - effectively counting the number of times the boolean flag, denoted by the key, is passed on the command line..
-For example, this is how you could implement `ssh`'s multiple levels of verbosity (`-vvvv` being the most verbose).
-
-```javascript
-const arg = require('arg');
-
-const argv = ['-AAAA', '-BBBB'];
-
-const args = arg(
-	{
-		'-A': arg.COUNT,
-		'-B': [Boolean]
-	},
-	{
-		argv
-	}
-);
-
-console.log(args);
-/*
-{
-	_: [],
-	'-A': 4,
-	'-B': [true, true, true, true]
-}
-*/
-```
-
-### Options
-
-If a second parameter is specified and is an object, it specifies parsing options to modify the behavior of `arg()`.
-
-#### `argv`
-
-If you have already sliced or generated a number of raw arguments to be parsed (as opposed to letting `arg`
-slice them from `process.argv`) you may specify them in the `argv` option.
-
-For example:
-
-```javascript
-const args = arg(
-	{
-		'--foo': String
-	},
-	{
-		argv: ['hello', '--foo', 'world']
-	}
-);
-```
-
-results in:
-
-```javascript
-const args = {
-	_: ['hello'],
-	'--foo': 'world'
-};
-```
-
-#### `permissive`
-
-When `permissive` set to `true`, `arg` will push any unknown arguments
-onto the "extra" argument array (`result._`) instead of throwing an error about
-an unknown flag.
-
-For example:
-
-```javascript
-const arg = require('arg');
-
-const argv = [
-	'--foo',
-	'hello',
-	'--qux',
-	'qix',
-	'--bar',
-	'12345',
-	'hello again'
-];
-
-const args = arg(
-	{
-		'--foo': String,
-		'--bar': Number
-	},
-	{
-		argv,
-		permissive: true
-	}
-);
-```
-
-results in:
-
-```javascript
-const args = {
-	_: ['--qux', 'qix', 'hello again'],
-	'--foo': 'hello',
-	'--bar': 12345
-};
-```
-
-#### `stopAtPositional`
-
-When `stopAtPositional` is set to `true`, `arg` will halt parsing at the first
-positional argument.
-
-For example:
-
-```javascript
-const arg = require('arg');
-
-const argv = ['--foo', 'hello', '--bar'];
-
-const args = arg(
-	{
-		'--foo': Boolean,
-		'--bar': Boolean
-	},
-	{
-		argv,
-		stopAtPositional: true
-	}
-);
-```
-
-results in:
-
-```javascript
-const args = {
-	_: ['hello', '--bar'],
-	'--foo': true
-};
-```
-
-### Errors
-
-Some errors that `arg` throws provide a `.code` property in order to aid in recovering from user error, or to
-differentiate between user error and developer error (bug).
-
-##### ARG_UNKNOWN_OPTION
-
-If an unknown option (not defined in the spec object) is passed, an error with code `ARG_UNKNOWN_OPTION` will be thrown:
-
-```js
-// cli.js
-try {
-	require('arg')({ '--hi': String });
-} catch (err) {
-	if (err.code === 'ARG_UNKNOWN_OPTION') {
-		console.log(err.message);
-	} else {
-		throw err;
-	}
-}
-```
-
-```shell
-node cli.js --extraneous true
-Unknown or unexpected option: --extraneous
-```
-
-# FAQ
-
-A few questions and answers that have been asked before:
-
-### How do I require an argument with `arg`?
-
-Do the assertion yourself, such as:
-
-```javascript
-const args = arg({ '--name': String });
-
-if (!args['--name']) throw new Error('missing required argument: --name');
-```
-
-# License
-
-Released under the [MIT License](LICENSE.md).

package/website/node_modules/arg/index.d.ts

@@ -1,44 +0,0 @@
-declare function arg<T extends arg.Spec>(
-	spec: T,
-	options?: arg.Options
-): arg.Result<T>;
-
-declare namespace arg {
-	export const flagSymbol: unique symbol;
-
-	export function flag<T>(fn: T): T & { [arg.flagSymbol]: true };
-
-	export const COUNT: Handler<number> & { [arg.flagSymbol]: true };
-
-	export type Handler<T = any> = (
-		value: string,
-		name: string,
-		previousValue?: T
-	) => T;
-
-	export class ArgError extends Error {
-		constructor(message: string, code: string);
-
-		code: string;
-	}
-
-	export interface Spec {
-		[key: string]: string | Handler | [Handler];
-	}
-
-	export type Result<T extends Spec> = { _: string[] } & {
-		[K in keyof T]?: T[K] extends Handler
-			? ReturnType<T[K]>
-			: T[K] extends [Handler]
-			? Array<ReturnType<T[K][0]>>
-			: never;
-	};
-
-	export interface Options {
-		argv?: string[];
-		permissive?: boolean;
-		stopAtPositional?: boolean;
-	}
-}
-
-export = arg;

package/website/node_modules/arg/index.js

@@ -1,195 +0,0 @@
-const flagSymbol = Symbol('arg flag');
-
-class ArgError extends Error {
-	constructor(msg, code) {
-		super(msg);
-		this.name = 'ArgError';
-		this.code = code;
-
-		Object.setPrototypeOf(this, ArgError.prototype);
-	}
-}
-
-function arg(
-	opts,
-	{
-		argv = process.argv.slice(2),
-		permissive = false,
-		stopAtPositional = false
-	} = {}
-) {
-	if (!opts) {
-		throw new ArgError(
-			'argument specification object is required',
-			'ARG_CONFIG_NO_SPEC'
-		);
-	}
-
-	const result = { _: [] };
-
-	const aliases = {};
-	const handlers = {};
-
-	for (const key of Object.keys(opts)) {
-		if (!key) {
-			throw new ArgError(
-				'argument key cannot be an empty string',
-				'ARG_CONFIG_EMPTY_KEY'
-			);
-		}
-
-		if (key[0] !== '-') {
-			throw new ArgError(
-				`argument key must start with '-' but found: '${key}'`,
-				'ARG_CONFIG_NONOPT_KEY'
-			);
-		}
-
-		if (key.length === 1) {
-			throw new ArgError(
-				`argument key must have a name; singular '-' keys are not allowed: ${key}`,
-				'ARG_CONFIG_NONAME_KEY'
-			);
-		}
-
-		if (typeof opts[key] === 'string') {
-			aliases[key] = opts[key];
-			continue;
-		}
-
-		let type = opts[key];
-		let isFlag = false;
-
-		if (
-			Array.isArray(type) &&
-			type.length === 1 &&
-			typeof type[0] === 'function'
-		) {
-			const [fn] = type;
-			type = (value, name, prev = []) => {
-				prev.push(fn(value, name, prev[prev.length - 1]));
-				return prev;
-			};
-			isFlag = fn === Boolean || fn[flagSymbol] === true;
-		} else if (typeof type === 'function') {
-			isFlag = type === Boolean || type[flagSymbol] === true;
-		} else {
-			throw new ArgError(
-				`type missing or not a function or valid array type: ${key}`,
-				'ARG_CONFIG_VAD_TYPE'
-			);
-		}
-
-		if (key[1] !== '-' && key.length > 2) {
-			throw new ArgError(
-				`short argument keys (with a single hyphen) must have only one character: ${key}`,
-				'ARG_CONFIG_SHORTOPT_TOOLONG'
-			);
-		}
-
-		handlers[key] = [type, isFlag];
-	}
-
-	for (let i = 0, len = argv.length; i < len; i++) {
-		const wholeArg = argv[i];
-
-		if (stopAtPositional && result._.length > 0) {
-			result._ = result._.concat(argv.slice(i));
-			break;
-		}
-
-		if (wholeArg === '--') {
-			result._ = result._.concat(argv.slice(i + 1));
-			break;
-		}
-
-		if (wholeArg.length > 1 && wholeArg[0] === '-') {
-			/* eslint-disable operator-linebreak */
-			const separatedArguments =
-				wholeArg[1] === '-' || wholeArg.length === 2
-					? [wholeArg]
-					: wholeArg
-							.slice(1)
-							.split('')
-							.map((a) => `-${a}`);
-			/* eslint-enable operator-linebreak */
-
-			for (let j = 0; j < separatedArguments.length; j++) {
-				const arg = separatedArguments[j];
-				const [originalArgName, argStr] =
-					arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
-
-				let argName = originalArgName;
-				while (argName in aliases) {
-					argName = aliases[argName];
-				}
-
-				if (!(argName in handlers)) {
-					if (permissive) {
-						result._.push(arg);
-						continue;
-					} else {
-						throw new ArgError(
-							`unknown or unexpected option: ${originalArgName}`,
-							'ARG_UNKNOWN_OPTION'
-						);
-					}
-				}
-
-				const [type, isFlag] = handlers[argName];
-
-				if (!isFlag && j + 1 < separatedArguments.length) {
-					throw new ArgError(
-						`option requires argument (but was followed by another short argument): ${originalArgName}`,
-						'ARG_MISSING_REQUIRED_SHORTARG'
-					);
-				}
-
-				if (isFlag) {
-					result[argName] = type(true, argName, result[argName]);
-				} else if (argStr === undefined) {
-					if (
-						argv.length < i + 2 ||
-						(argv[i + 1].length > 1 &&
-							argv[i + 1][0] === '-' &&
-							!(
-								argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) &&
-								(type === Number ||
-									// eslint-disable-next-line no-undef
-									(typeof BigInt !== 'undefined' && type === BigInt))
-							))
-					) {
-						const extended =
-							originalArgName === argName ? '' : ` (alias for ${argName})`;
-						throw new ArgError(
-							`option requires argument: ${originalArgName}${extended}`,
-							'ARG_MISSING_REQUIRED_LONGARG'
-						);
-					}
-
-					result[argName] = type(argv[i + 1], argName, result[argName]);
-					++i;
-				} else {
-					result[argName] = type(argStr, argName, result[argName]);
-				}
-			}
-		} else {
-			result._.push(wholeArg);
-		}
-	}
-
-	return result;
-}
-
-arg.flag = (fn) => {
-	fn[flagSymbol] = true;
-	return fn;
-};
-
-// Utility types
-arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
-
-// Expose error class
-arg.ArgError = ArgError;
-
-module.exports = arg;

package/website/node_modules/arg/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "arg",
-  "version": "5.0.2",
-  "description": "Unopinionated, no-frills CLI argument parser",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "repository": "vercel/arg",
-  "author": "Josh Junon <junon@wavetilt.com>",
-  "license": "MIT",
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "scripts": {
-    "test": "WARN_EXIT=1 jest --coverage -w 2"
-  },
-  "devDependencies": {
-    "chai": "^4.1.1",
-    "jest": "^27.0.6",
-    "prettier": "^2.3.2"
-  },
-  "prettier": {
-    "arrowParens": "always",
-    "singleQuote": true,
-    "tabWidth": 2,
-    "trailingComma": "none"
-  }
-}

package/website/node_modules/balanced-match/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-tidelift: "npm/balanced-match"
-patreon: juliangruber

package/website/node_modules/balanced-match/LICENSE.md

@@ -1,21 +0,0 @@
-(MIT)
-
-Copyright (c) 2013 Julian Gruber <julian@juliangruber.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.

package/website/node_modules/balanced-match/README.md

@@ -1,97 +0,0 @@
-# balanced-match
-
-Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
-
-[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
-[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
-
-[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
-
-## Example
-
-Get the first matching pair of braces:
-
-```js
-var balanced = require('balanced-match');
-
-console.log(balanced('{', '}', 'pre{in{nested}}post'));
-console.log(balanced('{', '}', 'pre{first}between{second}post'));
-console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'));
-```
-
-The matches are:
-
-```bash
-$ node example.js
-{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
-{ start: 3,
-  end: 9,
-  pre: 'pre',
-  body: 'first',
-  post: 'between{second}post' }
-{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
-```
-
-## API
-
-### var m = balanced(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-object with those keys:
-
-* **start** the index of the first match of `a`
-* **end** the index of the matching `b`
-* **pre** the preamble, `a` and `b` not included
-* **body** the match, `a` and `b` not included
-* **post** the postscript, `a` and `b` not included
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
-
-### var r = balanced.range(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-array with indexes: `[ <a index>, <b index> ]`.
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
-
-## Installation
-
-With [npm](https://npmjs.org) do:
-
-```bash
-npm install balanced-match
-```
-
-## Security contact information
-
-To report a security vulnerability, please use the
-[Tidelift security contact](https://tidelift.com/security).
-Tidelift will coordinate the fix and disclosure.
-
-## License
-
-(MIT)
-
-Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
-
-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.