@marktrue/dsh-mobile-remote 0.0.0-stage → 3.2.1-alpha.1

package/node_modules/yargs/build/lib/apply-extends.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyExtends = void 0;
+const fs = require("fs");
+const path = require("path");
+const yerror_1 = require("./yerror");
+let previouslyVisitedConfigs = [];
+function checkForCircularExtends(cfgPath) {
+    if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
+        throw new yerror_1.YError(`Circular extended configurations: '${cfgPath}'.`);
+    }
+}
+function getPathToDefaultConfig(cwd, pathToExtend) {
+    return path.resolve(cwd, pathToExtend);
+}
+function mergeDeep(config1, config2) {
+    const target = {};
+    function isObject(obj) {
+        return obj && typeof obj === 'object' && !Array.isArray(obj);
+    }
+    Object.assign(target, config1);
+    for (const key of Object.keys(config2)) {
+        if (isObject(config2[key]) && isObject(target[key])) {
+            target[key] = mergeDeep(config1[key], config2[key]);
+        }
+        else {
+            target[key] = config2[key];
+        }
+    }
+    return target;
+}
+function applyExtends(config, cwd, mergeExtends = false) {
+    let defaultConfig = {};
+    if (Object.prototype.hasOwnProperty.call(config, 'extends')) {
+        if (typeof config.extends !== 'string')
+            return defaultConfig;
+        const isPath = /\.json|\..*rc$/.test(config.extends);
+        let pathToDefault = null;
+        if (!isPath) {
+            try {
+                pathToDefault = require.resolve(config.extends);
+            }
+            catch (err) {
+                // most likely this simply isn't a module.
+            }
+        }
+        else {
+            pathToDefault = getPathToDefaultConfig(cwd, config.extends);
+        }
+        // maybe the module uses key for some other reason,
+        // err on side of caution.
+        if (!pathToDefault && !isPath)
+            return config;
+        if (!pathToDefault)
+            throw new yerror_1.YError(`Unable to find extended config '${config.extends}' in '${cwd}'.`);
+        checkForCircularExtends(pathToDefault);
+        previouslyVisitedConfigs.push(pathToDefault);
+        defaultConfig = isPath ? JSON.parse(fs.readFileSync(pathToDefault, 'utf8')) : require(config.extends);
+        delete config.extends;
+        defaultConfig = applyExtends(defaultConfig, path.dirname(pathToDefault), mergeExtends);
+    }
+    previouslyVisitedConfigs = [];
+    return mergeExtends ? mergeDeep(defaultConfig, config) : Object.assign({}, defaultConfig, config);
+}
+exports.applyExtends = applyExtends;

package/node_modules/yargs/build/lib/argsert.d.ts

@@ -0,0 +1,2 @@
+export declare function argsert(callerArguments: any[], length?: number): void;
+export declare function argsert(expected: string, callerArguments: any[], length?: number): void;

package/node_modules/yargs/build/lib/argsert.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argsert = void 0;
+const yerror_1 = require("./yerror");
+const parse_command_1 = require("./parse-command");
+const positionName = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth'];
+function argsert(arg1, arg2, arg3) {
+    function parseArgs() {
+        return typeof arg1 === 'object'
+            ? [{ demanded: [], optional: [] }, arg1, arg2]
+            : [parse_command_1.parseCommand(`cmd ${arg1}`), arg2, arg3];
+    }
+    // TODO: should this eventually raise an exception.
+    try {
+        // preface the argument description with "cmd", so
+        // that we can run it through yargs' command parser.
+        let position = 0;
+        let [parsed, callerArguments, length] = parseArgs();
+        const args = [].slice.call(callerArguments);
+        while (args.length && args[args.length - 1] === undefined)
+            args.pop();
+        length = length || args.length;
+        if (length < parsed.demanded.length) {
+            throw new yerror_1.YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
+        }
+        const totalCommands = parsed.demanded.length + parsed.optional.length;
+        if (length > totalCommands) {
+            throw new yerror_1.YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
+        }
+        parsed.demanded.forEach((demanded) => {
+            const arg = args.shift();
+            const observedType = guessType(arg);
+            const matchingTypes = demanded.cmd.filter(type => type === observedType || type === '*');
+            if (matchingTypes.length === 0)
+                argumentTypeError(observedType, demanded.cmd, position);
+            position += 1;
+        });
+        parsed.optional.forEach((optional) => {
+            if (args.length === 0)
+                return;
+            const arg = args.shift();
+            const observedType = guessType(arg);
+            const matchingTypes = optional.cmd.filter(type => type === observedType || type === '*');
+            if (matchingTypes.length === 0)
+                argumentTypeError(observedType, optional.cmd, position);
+            position += 1;
+        });
+    }
+    catch (err) {
+        console.warn(err.stack);
+    }
+}
+exports.argsert = argsert;
+function guessType(arg) {
+    if (Array.isArray(arg)) {
+        return 'array';
+    }
+    else if (arg === null) {
+        return 'null';
+    }
+    return typeof arg;
+}
+function argumentTypeError(observedType, allowedTypes, position) {
+    throw new yerror_1.YError(`Invalid ${positionName[position] || 'manyith'} argument. Expected ${allowedTypes.join(' or ')} but received ${observedType}.`);
+}

package/node_modules/yargs/build/lib/command.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { Dictionary } from './common-types';
+import { Middleware } from './middleware';
+import { Positional } from './parse-command';
+import { RequireDirectoryOptions } from 'require-directory';
+import { UsageInstance } from './usage';
+import { ValidationInstance } from './validation';
+import { YargsInstance, Options, OptionDefinition, Context, Arguments, DetailedArguments } from './yargs';
+export declare function command(yargs: YargsInstance, usage: UsageInstance, validation: ValidationInstance, globalMiddleware?: Middleware[]): CommandInstance;
+/** Instance of the command module. */
+export interface CommandInstance {
+    addDirectory(dir: string, context: Context, req: NodeRequireFunction, callerFile: string, opts?: RequireDirectoryOptions<any>): void;
+    addHandler(handler: CommandHandlerDefinition): void;
+    addHandler(cmd: string | string[], description: CommandHandler['description'], builder?: CommandBuilderDefinition | CommandBuilder, handler?: CommandHandlerCallback, commandMiddleware?: Middleware[], deprecated?: boolean): void;
+    cmdToParseOptions(cmdString: string): Positionals;
+    freeze(): void;
+    getCommandHandlers(): Dictionary<CommandHandler>;
+    getCommands(): string[];
+    hasDefaultCommand(): boolean;
+    reset(): CommandInstance;
+    runCommand(command: string | null, yargs: YargsInstance, parsed: DetailedArguments, commandIndex?: number): Arguments | Promise<Arguments>;
+    runDefaultBuilderOn(yargs: YargsInstance): void;
+    unfreeze(): void;
+}
+export interface CommandHandlerDefinition extends Partial<Pick<CommandHandler, 'deprecated' | 'description' | 'handler' | 'middlewares'>> {
+    aliases?: string[];
+    builder?: CommandBuilder | CommandBuilderDefinition;
+    command?: string | string[];
+    desc?: CommandHandler['description'];
+    describe?: CommandHandler['description'];
+}
+export declare function isCommandHandlerDefinition(cmd: string | string[] | CommandHandlerDefinition): cmd is CommandHandlerDefinition;
+export interface CommandBuilderDefinition {
+    builder?: CommandBuilder;
+    deprecated?: boolean;
+    handler: CommandHandlerCallback;
+    middlewares?: Middleware[];
+}
+export declare function isCommandBuilderDefinition(builder?: CommandBuilder | CommandBuilderDefinition): builder is CommandBuilderDefinition;
+export interface CommandHandlerCallback {
+    (argv: Arguments): any;
+}
+export interface CommandHandler {
+    builder: CommandBuilder;
+    demanded: Positional[];
+    deprecated?: boolean;
+    description?: string | false;
+    handler: CommandHandlerCallback;
+    middlewares: Middleware[];
+    optional: Positional[];
+    original: string;
+}
+export declare type CommandBuilder = CommandBuilderCallback | Dictionary<OptionDefinition>;
+interface CommandBuilderCallback {
+    (y: YargsInstance): YargsInstance | void;
+}
+export declare function isCommandBuilderCallback(builder: CommandBuilder): builder is CommandBuilderCallback;
+interface Positionals extends Pick<Options, 'alias' | 'array' | 'default'> {
+    demand: Dictionary<boolean>;
+}
+export interface FinishCommandHandler {
+    (handlerResult: any): any;
+}
+export {};

package/node_modules/yargs/build/lib/command.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCommandBuilderCallback = exports.isCommandBuilderDefinition = exports.isCommandHandlerDefinition = exports.command = void 0;
+const common_types_1 = require("./common-types");
+const is_promise_1 = require("./is-promise");
+const middleware_1 = require("./middleware");
+const parse_command_1 = require("./parse-command");
+const path = require("path");
+const util_1 = require("util");
+const yargs_1 = require("./yargs");
+const requireDirectory = require("require-directory");
+const whichModule = require("which-module");
+const Parser = require("yargs-parser");
+const DEFAULT_MARKER = /(^\*)|(^\$0)/;
+// handles parsing positional arguments,
+// and populating argv with said positional
+// arguments.
+function command(yargs, usage, validation, globalMiddleware = []) {
+    const self = {};
+    let handlers = {};
+    let aliasMap = {};
+    let defaultCommand;
+    self.addHandler = function addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
+        let aliases = [];
+        const middlewares = middleware_1.commandMiddlewareFactory(commandMiddleware);
+        handler = handler || (() => { });
+        if (Array.isArray(cmd)) {
+            aliases = cmd.slice(1);
+            cmd = cmd[0];
+        }
+        else if (isCommandHandlerDefinition(cmd)) {
+            let command = (Array.isArray(cmd.command) || typeof cmd.command === 'string') ? cmd.command : moduleName(cmd);
+            if (cmd.aliases)
+                command = [].concat(command).concat(cmd.aliases);
+            self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
+            return;
+        }
+        // allow a module to be provided instead of separate builder and handler
+        if (isCommandBuilderDefinition(builder)) {
+            self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
+            return;
+        }
+        // parse positionals out of cmd string
+        const parsedCommand = parse_command_1.parseCommand(cmd);
+        // remove positional args from aliases only
+        aliases = aliases.map(alias => parse_command_1.parseCommand(alias).cmd);
+        // check for default and filter out '*''
+        let isDefault = false;
+        const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
+            if (DEFAULT_MARKER.test(c)) {
+                isDefault = true;
+                return false;
+            }
+            return true;
+        });
+        // standardize on $0 for default command.
+        if (parsedAliases.length === 0 && isDefault)
+            parsedAliases.push('$0');
+        // shift cmd and aliases after filtering out '*'
+        if (isDefault) {
+            parsedCommand.cmd = parsedAliases[0];
+            aliases = parsedAliases.slice(1);
+            cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
+        }
+        // populate aliasMap
+        aliases.forEach((alias) => {
+            aliasMap[alias] = parsedCommand.cmd;
+        });
+        if (description !== false) {
+            usage.command(cmd, description, isDefault, aliases, deprecated);
+        }
+        handlers[parsedCommand.cmd] = {
+            original: cmd,
+            description,
+            handler,
+            builder: builder || {},
+            middlewares,
+            deprecated,
+            demanded: parsedCommand.demanded,
+            optional: parsedCommand.optional
+        };
+        if (isDefault)
+            defaultCommand = handlers[parsedCommand.cmd];
+    };
+    self.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
+        opts = opts || {};
+        // disable recursion to support nested directories of subcommands
+        if (typeof opts.recurse !== 'boolean')
+            opts.recurse = false;
+        // exclude 'json', 'coffee' from require-directory defaults
+        if (!Array.isArray(opts.extensions))
+            opts.extensions = ['js'];
+        // allow consumer to define their own visitor function
+        const parentVisit = typeof opts.visit === 'function' ? opts.visit : (o) => o;
+        // call addHandler via visitor function
+        opts.visit = function visit(obj, joined, filename) {
+            const visited = parentVisit(obj, joined, filename);
+            // allow consumer to skip modules with their own visitor
+            if (visited) {
+                // check for cyclic reference
+                // each command file path should only be seen once per execution
+                if (~context.files.indexOf(joined))
+                    return visited;
+                // keep track of visited files in context.files
+                context.files.push(joined);
+                self.addHandler(visited);
+            }
+            return visited;
+        };
+        requireDirectory({ require: req, filename: callerFile }, dir, opts);
+    };
+    // lookup module object from require()d command and derive name
+    // if module was not require()d and no name given, throw error
+    function moduleName(obj) {
+        const mod = whichModule(obj);
+        if (!mod)
+            throw new Error(`No command name given for module: ${util_1.inspect(obj)}`);
+        return commandFromFilename(mod.filename);
+    }
+    // derive command name from filename
+    function commandFromFilename(filename) {
+        return path.basename(filename, path.extname(filename));
+    }
+    function extractDesc({ describe, description, desc }) {
+        for (const test of [describe, description, desc]) {
+            if (typeof test === 'string' || test === false)
+                return test;
+            common_types_1.assertNotStrictEqual(test, true);
+        }
+        return false;
+    }
+    self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap));
+    self.getCommandHandlers = () => handlers;
+    self.hasDefaultCommand = () => !!defaultCommand;
+    self.runCommand = function runCommand(command, yargs, parsed, commandIndex) {
+        let aliases = parsed.aliases;
+        const commandHandler = handlers[command] || handlers[aliasMap[command]] || defaultCommand;
+        const currentContext = yargs.getContext();
+        let numFiles = currentContext.files.length;
+        const parentCommands = currentContext.commands.slice();
+        // what does yargs look like after the builder is run?
+        let innerArgv = parsed.argv;
+        let positionalMap = {};
+        if (command) {
+            currentContext.commands.push(command);
+            currentContext.fullCommands.push(commandHandler.original);
+        }
+        const builder = commandHandler.builder;
+        if (isCommandBuilderCallback(builder)) {
+            // a function can be provided, which builds
+            // up a yargs chain and possibly returns it.
+            const builderOutput = builder(yargs.reset(parsed.aliases));
+            const innerYargs = yargs_1.isYargsInstance(builderOutput) ? builderOutput : yargs;
+            if (shouldUpdateUsage(innerYargs)) {
+                innerYargs.getUsageInstance().usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
+            }
+            innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
+            aliases = innerYargs.parsed.aliases;
+        }
+        else if (isCommandBuilderOptionDefinitions(builder)) {
+            // as a short hand, an object can instead be provided, specifying
+            // the options that a command takes.
+            const innerYargs = yargs.reset(parsed.aliases);
+            if (shouldUpdateUsage(innerYargs)) {
+                innerYargs.getUsageInstance().usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
+            }
+            Object.keys(commandHandler.builder).forEach((key) => {
+                innerYargs.option(key, builder[key]);
+            });
+            innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
+            aliases = innerYargs.parsed.aliases;
+        }
+        if (!yargs._hasOutput()) {
+            positionalMap = populatePositionals(commandHandler, innerArgv, currentContext);
+        }
+        const middlewares = globalMiddleware.slice(0).concat(commandHandler.middlewares);
+        middleware_1.applyMiddleware(innerArgv, yargs, middlewares, true);
+        // we apply validation post-hoc, so that custom
+        // checks get passed populated positional arguments.
+        if (!yargs._hasOutput()) {
+            yargs._runValidation(innerArgv, aliases, positionalMap, yargs.parsed.error, !command);
+        }
+        if (commandHandler.handler && !yargs._hasOutput()) {
+            yargs._setHasOutput();
+            // to simplify the parsing of positionals in commands,
+            // we temporarily populate '--' rather than _, with arguments
+            const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
+            if (!populateDoubleDash)
+                yargs._copyDoubleDash(innerArgv);
+            innerArgv = middleware_1.applyMiddleware(innerArgv, yargs, middlewares, false);
+            let handlerResult;
+            if (is_promise_1.isPromise(innerArgv)) {
+                handlerResult = innerArgv.then(argv => commandHandler.handler(argv));
+            }
+            else {
+                handlerResult = commandHandler.handler(innerArgv);
+            }
+            const handlerFinishCommand = yargs.getHandlerFinishCommand();
+            if (is_promise_1.isPromise(handlerResult)) {
+                yargs.getUsageInstance().cacheHelpMessage();
+                handlerResult
+                    .then(value => {
+                    if (handlerFinishCommand) {
+                        handlerFinishCommand(value);
+                    }
+                })
+                    .catch(error => {
+                    try {
+                        yargs.getUsageInstance().fail(null, error);
+                    }
+                    catch (err) {
+                        // fail's throwing would cause an unhandled rejection.
+                    }
+                })
+                    .then(() => {
+                    yargs.getUsageInstance().clearCachedHelpMessage();
+                });
+            }
+            else {
+                if (handlerFinishCommand) {
+                    handlerFinishCommand(handlerResult);
+                }
+            }
+        }
+        if (command) {
+            currentContext.commands.pop();
+            currentContext.fullCommands.pop();
+        }
+        numFiles = currentContext.files.length - numFiles;
+        if (numFiles > 0)
+            currentContext.files.splice(numFiles * -1, numFiles);
+        return innerArgv;
+    };
+    function shouldUpdateUsage(yargs) {
+        return !yargs.getUsageInstance().getUsageDisabled() &&
+            yargs.getUsageInstance().getUsage().length === 0;
+    }
+    function usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
+        const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, '').trim() : commandHandler.original;
+        const pc = parentCommands.filter((c) => { return !DEFAULT_MARKER.test(c); });
+        pc.push(c);
+        return `$0 ${pc.join(' ')}`;
+    }
+    self.runDefaultBuilderOn = function (yargs) {
+        common_types_1.assertNotStrictEqual(defaultCommand, undefined);
+        if (shouldUpdateUsage(yargs)) {
+            // build the root-level command string from the default string.
+            const commandString = DEFAULT_MARKER.test(defaultCommand.original)
+                ? defaultCommand.original : defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
+            yargs.getUsageInstance().usage(commandString, defaultCommand.description);
+        }
+        const builder = defaultCommand.builder;
+        if (isCommandBuilderCallback(builder)) {
+            builder(yargs);
+        }
+        else {
+            Object.keys(builder).forEach((key) => {
+                yargs.option(key, builder[key]);
+            });
+        }
+    };
+    // transcribe all positional arguments "command <foo> <bar> [apple]"
+    // onto argv.
+    function populatePositionals(commandHandler, argv, context) {
+        argv._ = argv._.slice(context.commands.length); // nuke the current commands
+        const demanded = commandHandler.demanded.slice(0);
+        const optional = commandHandler.optional.slice(0);
+        const positionalMap = {};
+        validation.positionalCount(demanded.length, argv._.length);
+        while (demanded.length) {
+            const demand = demanded.shift();
+            populatePositional(demand, argv, positionalMap);
+        }
+        while (optional.length) {
+            const maybe = optional.shift();
+            populatePositional(maybe, argv, positionalMap);
+        }
+        argv._ = context.commands.concat(argv._);
+        postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original));
+        return positionalMap;
+    }
+    function populatePositional(positional, argv, positionalMap) {
+        const cmd = positional.cmd[0];
+        if (positional.variadic) {
+            positionalMap[cmd] = argv._.splice(0).map(String);
+        }
+        else {
+            if (argv._.length)
+                positionalMap[cmd] = [String(argv._.shift())];
+        }
+    }
+    // we run yargs-parser against the positional arguments
+    // applying the same parsing logic used for flags.
+    function postProcessPositionals(argv, positionalMap, parseOptions) {
+        // combine the parsing hints we've inferred from the command
+        // string with explicitly configured parsing hints.
+        const options = Object.assign({}, yargs.getOptions());
+        options.default = Object.assign(parseOptions.default, options.default);
+        for (const key of Object.keys(parseOptions.alias)) {
+            options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);
+        }
+        options.array = options.array.concat(parseOptions.array);
+        delete options.config; //  don't load config when processing positionals.
+        const unparsed = [];
+        Object.keys(positionalMap).forEach((key) => {
+            positionalMap[key].map((value) => {
+                if (options.configuration['unknown-options-as-args'])
+                    options.key[key] = true;
+                unparsed.push(`--${key}`);
+                unparsed.push(value);
+            });
+        });
+        // short-circuit parse.
+        if (!unparsed.length)
+            return;
+        const config = Object.assign({}, options.configuration, {
+            'populate--': true
+        });
+        const parsed = Parser.detailed(unparsed, Object.assign({}, options, {
+            configuration: config
+        }));
+        if (parsed.error) {
+            yargs.getUsageInstance().fail(parsed.error.message, parsed.error);
+        }
+        else {
+            // only copy over positional keys (don't overwrite
+            // flag arguments that were already parsed).
+            const positionalKeys = Object.keys(positionalMap);
+            Object.keys(positionalMap).forEach((key) => {
+                positionalKeys.push(...parsed.aliases[key]);
+            });
+            Object.keys(parsed.argv).forEach((key) => {
+                if (positionalKeys.indexOf(key) !== -1) {
+                    // any new aliases need to be placed in positionalMap, which
+                    // is used for validation.
+                    if (!positionalMap[key])
+                        positionalMap[key] = parsed.argv[key];
+                    argv[key] = parsed.argv[key];
+                }
+            });
+        }
+    }
+    self.cmdToParseOptions = function (cmdString) {
+        const parseOptions = {
+            array: [],
+            default: {},
+            alias: {},
+            demand: {}
+        };
+        const parsed = parse_command_1.parseCommand(cmdString);
+        parsed.demanded.forEach((d) => {
+            const [cmd, ...aliases] = d.cmd;
+            if (d.variadic) {
+                parseOptions.array.push(cmd);
+                parseOptions.default[cmd] = [];
+            }
+            parseOptions.alias[cmd] = aliases;
+            parseOptions.demand[cmd] = true;
+        });
+        parsed.optional.forEach((o) => {
+            const [cmd, ...aliases] = o.cmd;
+            if (o.variadic) {
+                parseOptions.array.push(cmd);
+                parseOptions.default[cmd] = [];
+            }
+            parseOptions.alias[cmd] = aliases;
+        });
+        return parseOptions;
+    };
+    self.reset = () => {
+        handlers = {};
+        aliasMap = {};
+        defaultCommand = undefined;
+        return self;
+    };
+    // used by yargs.parse() to freeze
+    // the state of commands such that
+    // we can apply .parse() multiple times
+    // with the same yargs instance.
+    const frozens = [];
+    self.freeze = () => {
+        frozens.push({
+            handlers,
+            aliasMap,
+            defaultCommand
+        });
+    };
+    self.unfreeze = () => {
+        const frozen = frozens.pop();
+        common_types_1.assertNotStrictEqual(frozen, undefined);
+        ({
+            handlers,
+            aliasMap,
+            defaultCommand
+        } = frozen);
+    };
+    return self;
+}
+exports.command = command;
+function isCommandHandlerDefinition(cmd) {
+    return typeof cmd === 'object';
+}
+exports.isCommandHandlerDefinition = isCommandHandlerDefinition;
+function isCommandBuilderDefinition(builder) {
+    return typeof builder === 'object' &&
+        !!builder.builder &&
+        typeof builder.handler === 'function';
+}
+exports.isCommandBuilderDefinition = isCommandBuilderDefinition;
+function isCommandBuilderCallback(builder) {
+    return typeof builder === 'function';
+}
+exports.isCommandBuilderCallback = isCommandBuilderCallback;
+function isCommandBuilderOptionDefinitions(builder) {
+    return typeof builder === 'object';
+}

package/node_modules/yargs/build/lib/common-types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * An object whose all properties have the same type.
+ */
+export declare type Dictionary<T = any> = {
+    [key: string]: T;
+};
+/**
+ * Returns the keys of T that match Dictionary<U> and are not arrays.
+ */
+export declare type DictionaryKeyof<T, U = any> = Exclude<KeyOf<T, Dictionary<U>>, KeyOf<T, any[]>>;
+/**
+ * Returns the keys of T that match U.
+ */
+export declare type KeyOf<T, U> = Exclude<{
+    [K in keyof T]: T[K] extends U ? K : never;
+}[keyof T], undefined>;
+/**
+ * An array whose first element is not undefined.
+ */
+export declare type NotEmptyArray<T = any> = [T, ...T[]];
+/**
+ * Returns the type of a Dictionary or array values.
+ */
+export declare type ValueOf<T> = T extends (infer U)[] ? U : T[keyof T];
+/**
+ * Typing wrapper around assert.notStrictEqual()
+ */
+export declare function assertNotStrictEqual<N, T>(actual: T | N, expected: N, message?: string | Error): asserts actual is Exclude<T, N>;
+/**
+ * Asserts actual is a single key, not a key array or a key map.
+ */
+export declare function assertSingleKey(actual: string | string[] | Dictionary): asserts actual is string;
+/**
+ * Typing wrapper around Object.keys()
+ */
+export declare function objectKeys<T>(object: T): (keyof T)[];

package/node_modules/yargs/build/lib/common-types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectKeys = exports.assertSingleKey = exports.assertNotStrictEqual = void 0;
+const assert_1 = require("assert");
+/**
+ * Typing wrapper around assert.notStrictEqual()
+ */
+function assertNotStrictEqual(actual, expected, message) {
+    assert_1.notStrictEqual(actual, expected, message);
+}
+exports.assertNotStrictEqual = assertNotStrictEqual;
+/**
+ * Asserts actual is a single key, not a key array or a key map.
+ */
+function assertSingleKey(actual) {
+    assert_1.strictEqual(typeof actual, 'string');
+}
+exports.assertSingleKey = assertSingleKey;
+/**
+ * Typing wrapper around Object.keys()
+ */
+function objectKeys(object) {
+    return Object.keys(object);
+}
+exports.objectKeys = objectKeys;

package/node_modules/yargs/build/lib/completion-templates.d.ts

@@ -0,0 +1,2 @@
+export declare const completionShTemplate = "###-begin-{{app_name}}-completions-###\n#\n# yargs command completion script\n#\n# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc\n#    or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.\n#\n_yargs_completions()\n{\n    local cur_word args type_list\n\n    cur_word=\"${COMP_WORDS[COMP_CWORD]}\"\n    args=(\"${COMP_WORDS[@]}\")\n\n    # ask yargs to generate completions.\n    type_list=$({{app_path}} --get-yargs-completions \"${args[@]}\")\n\n    COMPREPLY=( $(compgen -W \"${type_list}\" -- ${cur_word}) )\n\n    # if no match was found, fall back to filename completion\n    if [ ${#COMPREPLY[@]} -eq 0 ]; then\n      COMPREPLY=()\n    fi\n\n    return 0\n}\ncomplete -o default -F _yargs_completions {{app_name}}\n###-end-{{app_name}}-completions-###\n";
+export declare const completionZshTemplate = "###-begin-{{app_name}}-completions-###\n#\n# yargs command completion script\n#\n# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc\n#    or {{app_path}} {{completion_command}} >> ~/.zsh_profile on OSX.\n#\n_{{app_name}}_yargs_completions()\n{\n  local reply\n  local si=$IFS\n  IFS=$'\n' reply=($(COMP_CWORD=\"$((CURRENT-1))\" COMP_LINE=\"$BUFFER\" COMP_POINT=\"$CURSOR\" {{app_path}} --get-yargs-completions \"${words[@]}\"))\n  IFS=$si\n  _describe 'values' reply\n}\ncompdef _{{app_name}}_yargs_completions {{app_name}}\n###-end-{{app_name}}-completions-###\n";