@corellium/corellium-cli 1.2.1 → 1.2.3

package/node_modules/@babel/cli/node_modules/commander/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "commander",
+  "version": "4.1.1",
+  "description": "the complete solution for node.js command-line programs",
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "lint": "eslint index.js \"tests/**/*.js\"",
+    "test": "jest && npm run test-typings",
+    "test-typings": "tsc -p tsconfig.json"
+  },
+  "main": "index",
+  "files": [
+    "index.js",
+    "typings/index.d.ts"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@types/jest": "^24.0.23",
+    "@types/node": "^12.12.11",
+    "eslint": "^6.7.0",
+    "eslint-plugin-jest": "^22.21.0",
+    "jest": "^24.8.0",
+    "standard": "^14.3.1",
+    "typescript": "^3.7.2"
+  },
+  "typings": "typings/index.d.ts",
+  "engines": {
+    "node": ">= 6"
+  }
+}

package/node_modules/@babel/cli/node_modules/commander/typings/index.d.ts

@@ -0,0 +1,311 @@
+// Type definitions for commander
+// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+
+///<reference types="node" />
+
+declare namespace commander {
+
+  interface CommanderError extends Error {
+    code: string;
+    exitCode: number;
+    message: string;
+    nestedError?: string;
+  }
+  type CommanderErrorConstructor = { new (exitCode: number, code: string, message: string): CommanderError };
+
+  interface Option {
+    flags: string;
+    required: boolean; // A value must be supplied when the option is specified.
+    optional: boolean; // A value is optional when the option is specified.
+    mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
+    bool: boolean;
+    short?: string;
+    long: string;
+    description: string;
+  }
+  type OptionConstructor = { new (flags: string, description?: string): Option };
+
+  interface Command extends NodeJS.EventEmitter {
+    [key: string]: any; // options as properties
+
+    args: string[];
+
+    /**
+     * Set the program version to `str`. 
+     *
+     * This method auto-registers the "-V, --version" flag
+     * which will print the version number when passed.
+     * 
+     * You can optionally supply the  flags and description to override the defaults.
+     */
+    version(str: string, flags?: string, description?: string): Command;
+
+    /**
+     * Define a command, implemented using an action handler.
+     * 
+     * @remarks
+     * The command description is supplied using `.description`, not as a parameter to `.command`.
+     * 
+     * @example
+     * ```ts
+     *  program
+     *    .command('clone <source> [destination]')
+     *    .description('clone a repository into a newly created directory')
+     *    .action((source, destination) => {
+     *      console.log('clone command called');
+     *    });
+     * ```
+     * 
+     * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+     * @param opts - configuration options
+     * @returns new command
+     */
+    command(nameAndArgs: string, opts?: CommandOptions): Command;
+    /**
+     * Define a command, implemented in a separate executable file.
+     * 
+     * @remarks
+     * The command description is supplied as the second parameter to `.command`.
+     * 
+     * @example
+     * ```ts
+     *  program
+     *    .command('start <service>', 'start named service')
+     *    .command('stop [service]', 'stop named serice, or all if no name supplied');
+     * ```
+     * 
+     * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+     * @param description - description of executable command
+     * @param opts - configuration options
+     * @returns top level command for chaining more command definitions
+     */
+    command(nameAndArgs: string, description: string, opts?: commander.CommandOptions): Command;
+
+    /**
+     * Define argument syntax for the top-level command.
+     *
+     * @returns Command for chaining
+     */
+    arguments(desc: string): Command;
+
+    /**
+    * Parse expected `args`.
+     *
+     * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+     *
+     * @returns Command for chaining
+     */
+     parseExpectedArgs(args: string[]): Command;
+
+    /**
+     * Register callback to use as replacement for calling process.exit.
+     */
+    exitOverride(callback?: (err: CommanderError) => never|void): Command;
+
+    /**
+     * Register callback `fn` for the command.
+     *
+     * @example
+     *      program
+     *        .command('help')
+     *        .description('display verbose help')
+     *        .action(function() {
+     *           // output help here
+     *        });
+     *
+     * @returns Command for chaining
+     */
+    action(fn: (...args: any[]) => void | Promise<void>): Command;
+
+    /**
+     * Define option with `flags`, `description` and optional
+     * coercion `fn`.
+     *
+     * The `flags` string should contain both the short and long flags,
+     * separated by comma, a pipe or space. The following are all valid
+     * all will output this way when `--help` is used.
+     *
+     *    "-p, --pepper"
+     *    "-p|--pepper"
+     *    "-p --pepper"
+     *
+     * @example
+     *     // simple boolean defaulting to false
+     *     program.option('-p, --pepper', 'add pepper');
+     *
+     *     --pepper
+     *     program.pepper
+     *     // => Boolean
+     *
+     *     // simple boolean defaulting to true
+     *     program.option('-C, --no-cheese', 'remove cheese');
+     *
+     *     program.cheese
+     *     // => true
+     *
+     *     --no-cheese
+     *     program.cheese
+     *     // => false
+     *
+     *     // required argument
+     *     program.option('-C, --chdir <path>', 'change the working directory');
+     *
+     *     --chdir /tmp
+     *     program.chdir
+     *     // => "/tmp"
+     *
+     *     // optional argument
+     *     program.option('-c, --cheese [type]', 'add cheese [marble]');
+     *
+     * @returns Command for chaining
+     */
+    option(flags: string, description?: string, fn?: ((arg1: any, arg2: any) => void) | RegExp, defaultValue?: any): Command;
+    option(flags: string, description?: string, defaultValue?: any): Command;
+
+    /**
+     * Define a required option, which must have a value after parsing. This usually means
+     * the option must be specified on the command line. (Otherwise the same as .option().)
+     *
+     * The `flags` string should contain both the short and long flags, separated by comma, a pipe or space.
+     */
+    requiredOption(flags: string, description?: string, fn?: ((arg1: any, arg2: any) => void) | RegExp, defaultValue?: any): Command;
+    requiredOption(flags: string, description?: string, defaultValue?: any): Command;
+
+
+    /**
+     * Whether to store option values as properties on command object,
+     * or store separately (specify false). In both cases the option values can be accessed using .opts().
+     *
+     * @return Command for chaining
+     */
+    storeOptionsAsProperties(value?: boolean): Command;
+
+    /**
+     * Whether to pass command to action handler,
+     * or just the options (specify false).
+     * 
+     * @return Command for chaining
+     */
+    passCommandToAction(value?: boolean): Command;
+
+    /**
+     * Allow unknown options on the command line.
+     *
+     * @param [arg] if `true` or omitted, no error will be thrown for unknown options.
+     * @returns Command for chaining
+     */
+    allowUnknownOption(arg?: boolean): Command;
+
+    /**
+     * Parse `argv`, setting options and invoking commands when defined.
+     *
+     * @returns Command for chaining
+     */
+    parse(argv: string[]): Command;
+
+    /**
+     * Parse `argv`, setting options and invoking commands when defined.
+     * 
+     * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+     *
+     * @returns Promise
+     */
+    parseAsync(argv: string[]): Promise<any>;
+
+    /**
+     * Parse options from `argv` returning `argv` void of these options.
+     */
+    parseOptions(argv: string[]): commander.ParseOptionsResult;
+
+    /**
+     * Return an object containing options as key-value pairs
+     */
+    opts(): { [key: string]: any };
+
+    /**
+     * Set the description.
+     * 
+     * @returns Command for chaining
+     */
+    description(str: string, argsDescription?: {[argName: string]: string}): Command;
+    /**
+     * Get the description.
+     */
+    description(): string;
+
+    /**
+     * Set an alias for the command.
+     * 
+     * @returns Command for chaining
+     */
+    alias(alias: string): Command;
+    /**
+     * Get alias for the command.
+     */
+    alias(): string;
+
+    /**
+     * Set the command usage.
+     * 
+     * @returns Command for chaining
+     */
+    usage(str: string): Command;
+    /**
+     * Get the command usage.
+     */
+    usage(): string;
+
+    /**
+     * Set the name of the command.
+     * 
+     * @returns Command for chaining
+     */
+    name(str: string): Command;
+    /**
+     * Get the name of the command.
+     */
+    name(): string;
+
+    /**
+     * Output help information for this command.
+     *
+     * When listener(s) are available for the helpLongFlag
+     * those callbacks are invoked.
+     */
+    outputHelp(cb?: (str: string) => string): void;
+
+    /**
+     * You can pass in flags and a description to override the help
+     * flags and help description for your command.
+     */
+    helpOption(flags?: string, description?: string): Command;
+
+    /** 
+     * Output help information and exit.
+     */
+    help(cb?: (str: string) => string): never;
+  }
+  type CommandConstructor = { new (name?: string): Command };
+
+
+    interface CommandOptions {
+        noHelp?: boolean;
+        isDefault?: boolean;
+        executableFile?: string;
+    }
+
+    interface ParseOptionsResult {
+        args: string[];
+        unknown: string[];
+    }
+
+    interface CommanderStatic extends Command {
+        Command: CommandConstructor;
+        Option: OptionConstructor;
+        CommanderError:CommanderErrorConstructor;
+      }
+
+}
+
+declare const commander: commander.CommanderStatic;
+export = commander;

package/node_modules/@babel/cli/node_modules/make-dir/index.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node"/>
+import * as fs from 'fs';
+
+export interface Options {
+	/**
+	 * Directory [permissions](https://x-team.com/blog/file-system-permissions-umask-node-js/).
+	 *
+	 * @default 0o777 & (~process.umask())
+	 */
+	readonly mode?: number;
+
+	/**
+	 * Use a custom `fs` implementation. For example [`graceful-fs`](https://github.com/isaacs/node-graceful-fs).
+	 *
+	 * Using a custom `fs` implementation will block the use of the native `recursive` option if `fs.mkdir` or `fs.mkdirSync` is not the native function.
+	 *
+	 * @default require('fs')
+	 */
+	readonly fs?: typeof fs;
+}
+
+/**
+ * Make a directory and its parents if needed - Think `mkdir -p`.
+ *
+ * @param path - Directory to create.
+ * @returns A `Promise` for the path to the created directory.
+ */
+export default function makeDir(
+	path: string,
+	options?: Options
+): Promise<string>;
+
+/**
+ * Synchronously make a directory and its parents if needed - Think `mkdir -p`.
+ *
+ * @param path - Directory to create.
+ * @returns The path to the created directory.
+ */
+export function sync(path: string, options?: Options): string;

package/node_modules/@babel/cli/node_modules/make-dir/index.js

@@ -0,0 +1,139 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const pify = require('pify');
+const semver = require('semver');
+
+const defaults = {
+	mode: 0o777 & (~process.umask()),
+	fs
+};
+
+const useNativeRecursiveOption = semver.satisfies(process.version, '>=10.12.0');
+
+// https://github.com/nodejs/node/issues/8987
+// https://github.com/libuv/libuv/pull/1088
+const checkPath = pth => {
+	if (process.platform === 'win32') {
+		const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
+
+		if (pathHasInvalidWinCharacters) {
+			const error = new Error(`Path contains invalid characters: ${pth}`);
+			error.code = 'EINVAL';
+			throw error;
+		}
+	}
+};
+
+const permissionError = pth => {
+	// This replicates the exception of `fs.mkdir` with native the
+	// `recusive` option when run on an invalid drive under Windows.
+	const error = new Error(`operation not permitted, mkdir '${pth}'`);
+	error.code = 'EPERM';
+	error.errno = -4048;
+	error.path = pth;
+	error.syscall = 'mkdir';
+	return error;
+};
+
+const makeDir = (input, options) => Promise.resolve().then(() => {
+	checkPath(input);
+	options = Object.assign({}, defaults, options);
+
+	// TODO: Use util.promisify when targeting Node.js 8
+	const mkdir = pify(options.fs.mkdir);
+	const stat = pify(options.fs.stat);
+
+	if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
+		const pth = path.resolve(input);
+
+		return mkdir(pth, {
+			mode: options.mode,
+			recursive: true
+		}).then(() => pth);
+	}
+
+	const make = pth => {
+		return mkdir(pth, options.mode)
+			.then(() => pth)
+			.catch(error => {
+				if (error.code === 'EPERM') {
+					throw error;
+				}
+
+				if (error.code === 'ENOENT') {
+					if (path.dirname(pth) === pth) {
+						throw permissionError(pth);
+					}
+
+					if (error.message.includes('null bytes')) {
+						throw error;
+					}
+
+					return make(path.dirname(pth)).then(() => make(pth));
+				}
+
+				return stat(pth)
+					.then(stats => stats.isDirectory() ? pth : Promise.reject())
+					.catch(() => {
+						throw error;
+					});
+			});
+	};
+
+	return make(path.resolve(input));
+});
+
+module.exports = makeDir;
+module.exports.default = makeDir;
+
+module.exports.sync = (input, options) => {
+	checkPath(input);
+	options = Object.assign({}, defaults, options);
+
+	if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
+		const pth = path.resolve(input);
+
+		fs.mkdirSync(pth, {
+			mode: options.mode,
+			recursive: true
+		});
+
+		return pth;
+	}
+
+	const make = pth => {
+		try {
+			options.fs.mkdirSync(pth, options.mode);
+		} catch (error) {
+			if (error.code === 'EPERM') {
+				throw error;
+			}
+
+			if (error.code === 'ENOENT') {
+				if (path.dirname(pth) === pth) {
+					throw permissionError(pth);
+				}
+
+				if (error.message.includes('null bytes')) {
+					throw error;
+				}
+
+				make(path.dirname(pth));
+				return make(pth);
+			}
+
+			try {
+				if (!options.fs.statSync(pth).isDirectory()) {
+					throw new Error('The path is not a directory');
+				}
+			} catch (_) {
+				throw error;
+			}
+		}
+
+		return pth;
+	};
+
+	return make(path.resolve(input));
+};

package/node_modules/@babel/cli/node_modules/make-dir/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.

package/node_modules/@babel/cli/node_modules/make-dir/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "make-dir",
+	"version": "2.1.0",
+	"description": "Make a directory and its parents if needed - Think `mkdir -p`",
+	"license": "MIT",
+	"repository": "sindresorhus/make-dir",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=6"
+	},
+	"scripts": {
+		"test": "xo && nyc ava && tsd-check"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"mkdir",
+		"mkdirp",
+		"make",
+		"directories",
+		"dir",
+		"dirs",
+		"folders",
+		"directory",
+		"folder",
+		"path",
+		"parent",
+		"parents",
+		"intermediate",
+		"recursively",
+		"recursive",
+		"create",
+		"fs",
+		"filesystem",
+		"file-system"
+	],
+	"dependencies": {
+		"pify": "^4.0.1",
+		"semver": "^5.6.0"
+	},
+	"devDependencies": {
+		"@types/graceful-fs": "^4.1.3",
+		"@types/node": "^11.10.4",
+		"ava": "^1.2.0",
+		"codecov": "^3.0.0",
+		"graceful-fs": "^4.1.11",
+		"nyc": "^13.1.0",
+		"path-type": "^3.0.0",
+		"tempy": "^0.2.1",
+		"tsd-check": "^0.3.0",
+		"xo": "^0.24.0"
+	}
+}