@corellium/corellium-cli 1.2.0 → 1.2.1

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

@@ -1,236 +0,0 @@
-import { isCommandBuilderCallback } from './command.js';
-import { assertNotStrictEqual } from './typings/common-types.js';
-import * as templates from './completion-templates.js';
-import { isPromise } from './utils/is-promise.js';
-import { parseCommand } from './parse-command.js';
-export class Completion {
-    constructor(yargs, usage, command, shim) {
-        var _a, _b, _c;
-        this.yargs = yargs;
-        this.usage = usage;
-        this.command = command;
-        this.shim = shim;
-        this.completionKey = 'get-yargs-completions';
-        this.aliases = null;
-        this.customCompletionFunction = null;
-        this.indexAfterLastReset = 0;
-        this.zshShell =
-            (_c = (((_a = this.shim.getEnv('SHELL')) === null || _a === void 0 ? void 0 : _a.includes('zsh')) ||
-                ((_b = this.shim.getEnv('ZSH_NAME')) === null || _b === void 0 ? void 0 : _b.includes('zsh')))) !== null && _c !== void 0 ? _c : false;
-    }
-    defaultCompletion(args, argv, current, done) {
-        const handlers = this.command.getCommandHandlers();
-        for (let i = 0, ii = args.length; i < ii; ++i) {
-            if (handlers[args[i]] && handlers[args[i]].builder) {
-                const builder = handlers[args[i]].builder;
-                if (isCommandBuilderCallback(builder)) {
-                    this.indexAfterLastReset = i + 1;
-                    const y = this.yargs.getInternalMethods().reset();
-                    builder(y, true);
-                    return y.argv;
-                }
-            }
-        }
-        const completions = [];
-        this.commandCompletions(completions, args, current);
-        this.optionCompletions(completions, args, argv, current);
-        this.choicesFromOptionsCompletions(completions, args, argv, current);
-        this.choicesFromPositionalsCompletions(completions, args, argv, current);
-        done(null, completions);
-    }
-    commandCompletions(completions, args, current) {
-        const parentCommands = this.yargs
-            .getInternalMethods()
-            .getContext().commands;
-        if (!current.match(/^-/) &&
-            parentCommands[parentCommands.length - 1] !== current &&
-            !this.previousArgHasChoices(args)) {
-            this.usage.getCommands().forEach(usageCommand => {
-                const commandName = parseCommand(usageCommand[0]).cmd;
-                if (args.indexOf(commandName) === -1) {
-                    if (!this.zshShell) {
-                        completions.push(commandName);
-                    }
-                    else {
-                        const desc = usageCommand[1] || '';
-                        completions.push(commandName.replace(/:/g, '\\:') + ':' + desc);
-                    }
-                }
-            });
-        }
-    }
-    optionCompletions(completions, args, argv, current) {
-        if ((current.match(/^-/) || (current === '' && completions.length === 0)) &&
-            !this.previousArgHasChoices(args)) {
-            const options = this.yargs.getOptions();
-            const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
-            Object.keys(options.key).forEach(key => {
-                const negable = !!options.configuration['boolean-negation'] &&
-                    options.boolean.includes(key);
-                const isPositionalKey = positionalKeys.includes(key);
-                if (!isPositionalKey &&
-                    !options.hiddenOptions.includes(key) &&
-                    !this.argsContainKey(args, key, negable)) {
-                    this.completeOptionKey(key, completions, current);
-                    if (negable && !!options.default[key])
-                        this.completeOptionKey(`no-${key}`, completions, current);
-                }
-            });
-        }
-    }
-    choicesFromOptionsCompletions(completions, args, argv, current) {
-        if (this.previousArgHasChoices(args)) {
-            const choices = this.getPreviousArgChoices(args);
-            if (choices && choices.length > 0) {
-                completions.push(...choices.map(c => c.replace(/:/g, '\\:')));
-            }
-        }
-    }
-    choicesFromPositionalsCompletions(completions, args, argv, current) {
-        if (current === '' &&
-            completions.length > 0 &&
-            this.previousArgHasChoices(args)) {
-            return;
-        }
-        const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
-        const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length +
-            1);
-        const positionalKey = positionalKeys[argv._.length - offset - 1];
-        if (!positionalKey) {
-            return;
-        }
-        const choices = this.yargs.getOptions().choices[positionalKey] || [];
-        for (const choice of choices) {
-            if (choice.startsWith(current)) {
-                completions.push(choice.replace(/:/g, '\\:'));
-            }
-        }
-    }
-    getPreviousArgChoices(args) {
-        if (args.length < 1)
-            return;
-        let previousArg = args[args.length - 1];
-        let filter = '';
-        if (!previousArg.startsWith('-') && args.length > 1) {
-            filter = previousArg;
-            previousArg = args[args.length - 2];
-        }
-        if (!previousArg.startsWith('-'))
-            return;
-        const previousArgKey = previousArg.replace(/^-+/, '');
-        const options = this.yargs.getOptions();
-        const possibleAliases = [
-            previousArgKey,
-            ...(this.yargs.getAliases()[previousArgKey] || []),
-        ];
-        let choices;
-        for (const possibleAlias of possibleAliases) {
-            if (Object.prototype.hasOwnProperty.call(options.key, possibleAlias) &&
-                Array.isArray(options.choices[possibleAlias])) {
-                choices = options.choices[possibleAlias];
-                break;
-            }
-        }
-        if (choices) {
-            return choices.filter(choice => !filter || choice.startsWith(filter));
-        }
-    }
-    previousArgHasChoices(args) {
-        const choices = this.getPreviousArgChoices(args);
-        return choices !== undefined && choices.length > 0;
-    }
-    argsContainKey(args, key, negable) {
-        const argsContains = (s) => args.indexOf((/^[^0-9]$/.test(s) ? '-' : '--') + s) !== -1;
-        if (argsContains(key))
-            return true;
-        if (negable && argsContains(`no-${key}`))
-            return true;
-        if (this.aliases) {
-            for (const alias of this.aliases[key]) {
-                if (argsContains(alias))
-                    return true;
-            }
-        }
-        return false;
-    }
-    completeOptionKey(key, completions, current) {
-        const descs = this.usage.getDescriptions();
-        const startsByTwoDashes = (s) => /^--/.test(s);
-        const isShortOption = (s) => /^[^0-9]$/.test(s);
-        const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';
-        if (!this.zshShell) {
-            completions.push(dashes + key);
-        }
-        else {
-            const desc = descs[key] || '';
-            completions.push(dashes +
-                `${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
-        }
-    }
-    customCompletion(args, argv, current, done) {
-        assertNotStrictEqual(this.customCompletionFunction, null, this.shim);
-        if (isSyncCompletionFunction(this.customCompletionFunction)) {
-            const result = this.customCompletionFunction(current, argv);
-            if (isPromise(result)) {
-                return result
-                    .then(list => {
-                    this.shim.process.nextTick(() => {
-                        done(null, list);
-                    });
-                })
-                    .catch(err => {
-                    this.shim.process.nextTick(() => {
-                        done(err, undefined);
-                    });
-                });
-            }
-            return done(null, result);
-        }
-        else if (isFallbackCompletionFunction(this.customCompletionFunction)) {
-            return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), completions => {
-                done(null, completions);
-            });
-        }
-        else {
-            return this.customCompletionFunction(current, argv, completions => {
-                done(null, completions);
-            });
-        }
-    }
-    getCompletion(args, done) {
-        const current = args.length ? args[args.length - 1] : '';
-        const argv = this.yargs.parse(args, true);
-        const completionFunction = this.customCompletionFunction
-            ? (argv) => this.customCompletion(args, argv, current, done)
-            : (argv) => this.defaultCompletion(args, argv, current, done);
-        return isPromise(argv)
-            ? argv.then(completionFunction)
-            : completionFunction(argv);
-    }
-    generateCompletionScript($0, cmd) {
-        let script = this.zshShell
-            ? templates.completionZshTemplate
-            : templates.completionShTemplate;
-        const name = this.shim.path.basename($0);
-        if ($0.match(/\.js$/))
-            $0 = `./${$0}`;
-        script = script.replace(/{{app_name}}/g, name);
-        script = script.replace(/{{completion_command}}/g, cmd);
-        return script.replace(/{{app_path}}/g, $0);
-    }
-    registerFunction(fn) {
-        this.customCompletionFunction = fn;
-    }
-    setParsed(parsed) {
-        this.aliases = parsed.aliases;
-    }
-}
-export function completion(yargs, usage, command, shim) {
-    return new Completion(yargs, usage, command, shim);
-}
-function isSyncCompletionFunction(completionFunction) {
-    return completionFunction.length < 3;
-}
-function isFallbackCompletionFunction(completionFunction) {
-    return completionFunction.length > 3;
-}

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

@@ -1,88 +0,0 @@
-import { argsert } from './argsert.js';
-import { isPromise } from './utils/is-promise.js';
-export class GlobalMiddleware {
-    constructor(yargs) {
-        this.globalMiddleware = [];
-        this.frozens = [];
-        this.yargs = yargs;
-    }
-    addMiddleware(callback, applyBeforeValidation, global = true, mutates = false) {
-        argsert('<array|function> [boolean] [boolean] [boolean]', [callback, applyBeforeValidation, global], arguments.length);
-        if (Array.isArray(callback)) {
-            for (let i = 0; i < callback.length; i++) {
-                if (typeof callback[i] !== 'function') {
-                    throw Error('middleware must be a function');
-                }
-                const m = callback[i];
-                m.applyBeforeValidation = applyBeforeValidation;
-                m.global = global;
-            }
-            Array.prototype.push.apply(this.globalMiddleware, callback);
-        }
-        else if (typeof callback === 'function') {
-            const m = callback;
-            m.applyBeforeValidation = applyBeforeValidation;
-            m.global = global;
-            m.mutates = mutates;
-            this.globalMiddleware.push(callback);
-        }
-        return this.yargs;
-    }
-    addCoerceMiddleware(callback, option) {
-        const aliases = this.yargs.getAliases();
-        this.globalMiddleware = this.globalMiddleware.filter(m => {
-            const toCheck = [...(aliases[option] || []), option];
-            if (!m.option)
-                return true;
-            else
-                return !toCheck.includes(m.option);
-        });
-        callback.option = option;
-        return this.addMiddleware(callback, true, true, true);
-    }
-    getMiddleware() {
-        return this.globalMiddleware;
-    }
-    freeze() {
-        this.frozens.push([...this.globalMiddleware]);
-    }
-    unfreeze() {
-        const frozen = this.frozens.pop();
-        if (frozen !== undefined)
-            this.globalMiddleware = frozen;
-    }
-    reset() {
-        this.globalMiddleware = this.globalMiddleware.filter(m => m.global);
-    }
-}
-export function commandMiddlewareFactory(commandMiddleware) {
-    if (!commandMiddleware)
-        return [];
-    return commandMiddleware.map(middleware => {
-        middleware.applyBeforeValidation = false;
-        return middleware;
-    });
-}
-export function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
-    return middlewares.reduce((acc, middleware) => {
-        if (middleware.applyBeforeValidation !== beforeValidation) {
-            return acc;
-        }
-        if (middleware.mutates) {
-            if (middleware.applied)
-                return acc;
-            middleware.applied = true;
-        }
-        if (isPromise(acc)) {
-            return acc
-                .then(initialObj => Promise.all([initialObj, middleware(initialObj, yargs)]))
-                .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
-        }
-        else {
-            const result = middleware(acc, yargs);
-            return isPromise(result)
-                ? result.then(middlewareObj => Object.assign(acc, middlewareObj))
-                : Object.assign(acc, result);
-        }
-    }, argv);
-}

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

@@ -1,32 +0,0 @@
-export function parseCommand(cmd) {
-    const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ');
-    const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
-    const bregex = /\.*[\][<>]/g;
-    const firstCommand = splitCommand.shift();
-    if (!firstCommand)
-        throw new Error(`No command found in: ${cmd}`);
-    const parsedCommand = {
-        cmd: firstCommand.replace(bregex, ''),
-        demanded: [],
-        optional: [],
-    };
-    splitCommand.forEach((cmd, i) => {
-        let variadic = false;
-        cmd = cmd.replace(/\s/g, '');
-        if (/\.+[\]>]/.test(cmd) && i === splitCommand.length - 1)
-            variadic = true;
-        if (/^\[/.test(cmd)) {
-            parsedCommand.optional.push({
-                cmd: cmd.replace(bregex, '').split('|'),
-                variadic,
-            });
-        }
-        else {
-            parsedCommand.demanded.push({
-                cmd: cmd.replace(bregex, '').split('|'),
-                variadic,
-            });
-        }
-    });
-    return parsedCommand;
-}

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

@@ -1,9 +0,0 @@
-export function assertNotStrictEqual(actual, expected, shim, message) {
-    shim.assert.notStrictEqual(actual, expected, message);
-}
-export function assertSingleKey(actual, shim) {
-    shim.assert.strictEqual(typeof actual, 'string');
-}
-export function objectKeys(object) {
-    return Object.keys(object);
-}

package/node_modules/yargs/build/lib/typings/yargs-parser-types.js

@@ -1 +0,0 @@
-export {};