@walkhi/code-relax 0.1.0-beta.29 → 0.1.0-beta.30

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

@@ -1,65 +0,0 @@
-"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

@@ -1,64 +0,0 @@
-/// <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

@@ -1,416 +0,0 @@
-"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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-"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

@@ -1,2 +0,0 @@
-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";

package/node_modules/yargs/build/lib/completion-templates.js

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