avo-cli 0.0.3 → 4.2.0.beta.2

data/payload/node_modules/@oclif/core/lib/main.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionAddition = exports.helpAddition = void 0;
+exports.run = run;
+const node_url_1 = require("node:url");
+const cache_1 = __importDefault(require("./cache"));
+const config_1 = require("./config");
+const help_1 = require("./help");
+const logger_1 = require("./logger");
+const performance_1 = require("./performance");
+const symbols_1 = require("./symbols");
+const ux_1 = require("./ux");
+const helpAddition = (argv, config) => {
+    if (argv.length === 0 && !config.isSingleCommandCLI)
+        return true;
+    const mergedHelpFlags = (0, help_1.getHelpFlagAdditions)(config);
+    for (const arg of argv) {
+        if (mergedHelpFlags.includes(arg))
+            return true;
+        if (arg === '--')
+            return false;
+    }
+    return false;
+};
+exports.helpAddition = helpAddition;
+const versionAddition = (argv, config) => {
+    const additionalVersionFlags = config?.pjson.oclif.additionalVersionFlags ?? [];
+    const mergedVersionFlags = [...new Set(['--version', ...additionalVersionFlags]).values()];
+    if (mergedVersionFlags.includes(argv[0]))
+        return true;
+    return false;
+};
+exports.versionAddition = versionAddition;
+async function run(argv, options) {
+    const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'main.run');
+    const initMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'main.run#init');
+    const showHelp = async (argv) => {
+        const Help = await (0, help_1.loadHelpClass)(config);
+        const help = new Help(config, config.pjson.oclif.helpOptions ?? config.pjson.helpOptions);
+        await help.showHelp(argv);
+    };
+    (0, logger_1.setLogger)(options);
+    const { debug } = (0, logger_1.getLogger)('main');
+    debug(`process.execPath: ${process.execPath}`);
+    debug(`process.execArgv: ${process.execArgv}`);
+    debug('process.argv: %O', process.argv);
+    argv = argv ?? process.argv.slice(2);
+    // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
+    if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof node_url_1.URL)) {
+        options = (0, node_url_1.fileURLToPath)(options);
+    }
+    const config = await config_1.Config.load(options ?? require.main?.filename ?? __dirname);
+    cache_1.default.getInstance().set('config', config);
+    // If this is a single command CLI, then insert the SINGLE_COMMAND_CLI_SYMBOL into the argv array to serve as the command id.
+    if (config.isSingleCommandCLI) {
+        argv = [symbols_1.SINGLE_COMMAND_CLI_SYMBOL, ...argv];
+    }
+    const [id, ...argvSlice] = (0, help_1.normalizeArgv)(config, argv);
+    const runFinally = async (cmd, error) => {
+        marker?.stop();
+        if (!initMarker?.stopped)
+            initMarker?.stop();
+        await performance_1.Performance.collect();
+        performance_1.Performance.debug();
+        await config.runHook('finally', { argv: argvSlice, Command: cmd, error, id });
+    };
+    // run init hook
+    await config.runHook('init', { argv: argvSlice, id });
+    // display version if applicable
+    if ((0, exports.versionAddition)(argv, config)) {
+        ux_1.ux.stdout(config.userAgent);
+        await runFinally();
+        return;
+    }
+    // display help version if applicable
+    if ((0, exports.helpAddition)(argv, config)) {
+        await showHelp(argv);
+        await runFinally();
+        return;
+    }
+    // find & run command
+    const cmd = config.findCommand(id);
+    if (!cmd) {
+        const topic = config.flexibleTaxonomy ? null : config.findTopic(id);
+        if (topic) {
+            await showHelp([id]);
+            await runFinally();
+            return;
+        }
+    }
+    initMarker?.stop();
+    let err;
+    try {
+        return await config.runCommand(id, argvSlice, cmd);
+    }
+    catch (error) {
+        err = error;
+        throw error;
+    }
+    finally {
+        await runFinally(cmd, err);
+    }
+}

data/payload/node_modules/@oclif/core/lib/module-loader.d.ts

@@ -0,0 +1,71 @@
+import { Command } from './command';
+import { Config as IConfig, Plugin as IPlugin } from './interfaces';
+/**
+ * Loads and returns a module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
+ */
+export declare function load<T = any>(config: IConfig | IPlugin, modulePath: string): Promise<T>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+export declare function loadWithData<T = any>(config: IConfig | IPlugin, modulePath: string): Promise<{
+    filePath: string;
+    isESM: boolean;
+    module: T;
+}>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+export declare function loadWithDataFromManifest<T = any>(cached: Command.Cached, modulePath: string): Promise<{
+    filePath: string;
+    isESM: boolean;
+    module: T;
+}>;
+/**
+ * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+ * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+ *
+ * @param {string} filePath - File path to test.
+ *
+ * @returns {boolean} The modulePath is an ES Module.
+ * @see https://www.npmjs.com/package/get-package-type
+ */
+export declare function isPathModule(filePath: string): boolean;

data/payload/node_modules/@oclif/core/lib/module-loader.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+exports.loadWithData = loadWithData;
+exports.loadWithDataFromManifest = loadWithDataFromManifest;
+exports.isPathModule = isPathModule;
+const getPackageType = require('get-package-type');
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const ts_path_1 = require("./config/ts-path");
+const module_load_1 = require("./errors/errors/module-load");
+const fs_1 = require("./util/fs");
+/**
+ * Defines file extension resolution when source files do not have an extension.
+ */
+const SUPPORTED_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts', '.tsx', '.jsx'];
+const isPlugin = (config) => config.type !== undefined;
+function handleError(error, isESM, path) {
+    if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
+        throw new module_load_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${path}: ${error.message}`);
+    }
+    throw error;
+}
+/**
+ * Loads and returns a module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
+ */
+async function load(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ;
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
+        return (isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath));
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithData(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ;
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { filePath, isESM, module };
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithDataFromManifest(cached, modulePath) {
+    const { id, isESM, relativePath } = cached;
+    if (!relativePath) {
+        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have a relative path`);
+    }
+    if (isESM === undefined) {
+        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have the isESM property set`);
+    }
+    const filePath = (0, node_path_1.join)(modulePath, relativePath.join(node_path_1.sep));
+    try {
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { filePath, isESM, module };
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+ * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+ *
+ * @param {string} filePath - File path to test.
+ *
+ * @returns {boolean} The modulePath is an ES Module.
+ * @see https://www.npmjs.com/package/get-package-type
+ */
+function isPathModule(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    switch (extension) {
+        case '.js':
+        case '.jsx':
+        case '.ts':
+        case '.tsx': {
+            return getPackageType.sync(filePath) === 'module';
+        }
+        case '.mjs':
+        case '.mts': {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+/**
+ * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
+ * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
+ * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
+ * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - File path to load.
+ *
+ * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
+ */
+async function resolvePath(config, modulePath) {
+    let isESM;
+    let filePath;
+    try {
+        filePath = require.resolve(modulePath);
+        isESM = isPathModule(filePath);
+    }
+    catch {
+        filePath =
+            (isPlugin(config) ? await (0, ts_path_1.tsPath)(config.root, modulePath, config) : await (0, ts_path_1.tsPath)(config.root, modulePath)) ??
+                modulePath;
+        let fileExists = false;
+        let isDirectory = false;
+        if ((0, fs_1.existsSync)(filePath)) {
+            fileExists = true;
+            try {
+                if ((0, node_fs_1.lstatSync)(filePath)?.isDirectory?.()) {
+                    fileExists = false;
+                    isDirectory = true;
+                }
+            }
+            catch { }
+        }
+        if (!fileExists) {
+            // Try all supported extensions.
+            let foundPath = findFile(filePath);
+            if (!foundPath && isDirectory) {
+                // Since filePath is a directory, try looking for index file.
+                foundPath = findFile((0, node_path_1.join)(filePath, 'index'));
+            }
+            if (foundPath) {
+                filePath = foundPath;
+            }
+        }
+        isESM = isPathModule(filePath);
+    }
+    return { filePath, isESM };
+}
+/**
+ * Try adding the different extensions from `s_EXTENSIONS` to find the file.
+ *
+ * @param {string} filePath - File path to load.
+ *
+ * @returns {string | null} Modified file path including extension or null if file is not found.
+ */
+function findFile(filePath) {
+    for (const extension of SUPPORTED_EXTENSIONS) {
+        const testPath = `${filePath}${extension}`;
+        if ((0, fs_1.existsSync)(testPath)) {
+            return testPath;
+        }
+    }
+    return null;
+}

data/payload/node_modules/@oclif/core/lib/parser/errors.d.ts

@@ -0,0 +1,58 @@
+import { CLIError } from '../errors';
+import { Arg, ArgInput, CLIParseErrorOptions, OptionFlag } from '../interfaces/parser';
+export { CLIError } from '../errors';
+export type Validation = {
+    name: string;
+    reason?: string | undefined;
+    status: 'failed' | 'success';
+    validationFn: string;
+};
+export declare class CLIParseError extends CLIError {
+    parse: CLIParseErrorOptions['parse'];
+    showHelp: boolean;
+    constructor(options: CLIParseErrorOptions & {
+        message: string;
+    });
+}
+export declare class InvalidArgsSpecError extends CLIParseError {
+    args: ArgInput;
+    constructor({ args, exit, parse, reason }: CLIParseErrorOptions & {
+        args: ArgInput;
+        reason?: string;
+    });
+}
+export declare class RequiredArgsError extends CLIParseError {
+    args: Arg<any>[];
+    constructor({ args, exit, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
+        args: Arg<any>[];
+        flagsWithMultiple?: string[];
+    });
+}
+export declare class UnexpectedArgsError extends CLIParseError {
+    args: unknown[];
+    constructor({ args, exit, parse }: CLIParseErrorOptions & {
+        args: unknown[];
+    });
+}
+export declare class NonExistentFlagsError extends CLIParseError {
+    flags: string[];
+    constructor({ exit, flags, parse }: CLIParseErrorOptions & {
+        flags: string[];
+    });
+}
+export declare class FlagInvalidOptionError extends CLIParseError {
+    constructor(flag: OptionFlag<any>, input: string);
+}
+export declare class ArgInvalidOptionError extends CLIParseError {
+    constructor(arg: Arg<any>, input: string);
+}
+export declare class FailedFlagValidationError extends CLIParseError {
+    constructor({ exit, failed, parse }: CLIParseErrorOptions & {
+        failed: Validation[];
+    });
+}
+export declare class ViolatedFlagConstraintError extends CLIParseError {
+    constructor({ exit, failed, parse }: CLIParseErrorOptions & {
+        failed: Validation[];
+    });
+}

data/payload/node_modules/@oclif/core/lib/parser/errors.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViolatedFlagConstraintError = exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+const cache_1 = __importDefault(require("../cache"));
+const errors_1 = require("../errors");
+const util_1 = require("../util/util");
+const list_1 = __importDefault(require("../ux/list"));
+const theme_1 = require("../ux/theme");
+var errors_2 = require("../errors");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
+class CLIParseError extends errors_1.CLIError {
+    parse;
+    showHelp = false;
+    constructor(options) {
+        options.message += '\nSee more help with --help';
+        super(options.message, { exit: options.exit });
+        this.parse = options.parse;
+    }
+}
+exports.CLIParseError = CLIParseError;
+class InvalidArgsSpecError extends CLIParseError {
+    args;
+    constructor({ args, exit, parse, reason }) {
+        let message = 'Invalid argument spec';
+        if (reason) {
+            message += `: ${reason}`;
+        }
+        const namedArgs = Object.values(args).filter((a) => a.name);
+        if (namedArgs.length > 0) {
+            const list = (0, list_1.default)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            message += `:\n${list}`;
+        }
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.invalidArgsSpec ?? exit, message, parse });
+        this.args = args;
+    }
+}
+exports.InvalidArgsSpecError = InvalidArgsSpecError;
+class RequiredArgsError extends CLIParseError {
+    args;
+    constructor({ args, exit, flagsWithMultiple, parse, }) {
+        let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
+        const namedArgs = args.filter((a) => a.name);
+        if (namedArgs.length > 0) {
+            const list = (0, list_1.default)(namedArgs.map((a) => {
+                const description = a.options ? `(${a.options.join('|')}) ${a.description}` : a.description;
+                return [a.name, description];
+            }));
+            message += `:\n${list}`;
+        }
+        if (flagsWithMultiple?.length) {
+            const flags = flagsWithMultiple.map((f) => `--${f}`).join(', ');
+            message += `\n\nNote: ${flags} allow${flagsWithMultiple.length === 1 ? 's' : ''} multiple values. Because of this you need to provide all arguments before providing ${flagsWithMultiple.length === 1 ? 'that flag' : 'those flags'}.`;
+            message += '\nAlternatively, you can use "--" to signify the end of the flags and the beginning of arguments.';
+        }
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.requiredArgs ?? exit, message, parse });
+        this.args = args;
+        this.showHelp = true;
+    }
+}
+exports.RequiredArgsError = RequiredArgsError;
+class UnexpectedArgsError extends CLIParseError {
+    args;
+    constructor({ args, exit, parse }) {
+        const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.unexpectedArgs ?? exit, message, parse });
+        this.args = args;
+        this.showHelp = true;
+    }
+}
+exports.UnexpectedArgsError = UnexpectedArgsError;
+class NonExistentFlagsError extends CLIParseError {
+    flags;
+    constructor({ exit, flags, parse }) {
+        const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.nonExistentFlag ?? exit, message, parse });
+        this.flags = flags;
+        this.showHelp = true;
+    }
+}
+exports.NonExistentFlagsError = NonExistentFlagsError;
+class FlagInvalidOptionError extends CLIParseError {
+    constructor(flag, input) {
+        const message = `Expected --${flag.name}=${input} to be one of: ${flag.options.join(', ')}`;
+        super({ message, parse: {} });
+    }
+}
+exports.FlagInvalidOptionError = FlagInvalidOptionError;
+class ArgInvalidOptionError extends CLIParseError {
+    constructor(arg, input) {
+        const message = `Expected ${input} to be one of: ${arg.options.join(', ')}`;
+        super({ message, parse: {} });
+    }
+}
+exports.ArgInvalidOptionError = ArgInvalidOptionError;
+class FailedFlagValidationError extends CLIParseError {
+    constructor({ exit, failed, parse }) {
+        const reasons = failed.map((r) => r.reason);
+        const deduped = (0, util_1.uniq)(reasons);
+        const errString = deduped.length === 1 ? 'error' : 'errors';
+        const message = `The following ${errString} occurred:\n  ${(0, theme_1.colorize)('dim', deduped.join('\n  '))}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagValidation ?? exit, message, parse });
+    }
+}
+exports.FailedFlagValidationError = FailedFlagValidationError;
+class ViolatedFlagConstraintError extends CLIParseError {
+    constructor({ exit, failed, parse }) {
+        const reasons = failed.map((r) => r.reason);
+        const deduped = (0, util_1.uniq)(reasons);
+        const errString = deduped.length === 1 ? 'error' : 'errors';
+        const message = `The following ${errString} occurred:\n ${(0, theme_1.colorize)('dim', deduped.join('\n'))}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.violatedFlagConstraint ?? exit, message, parse });
+    }
+}
+exports.ViolatedFlagConstraintError = ViolatedFlagConstraintError;

data/payload/node_modules/@oclif/core/lib/parser/help.d.ts

@@ -0,0 +1,3 @@
+import { Flag, FlagUsageOptions } from '../interfaces/parser';
+export declare function flagUsage(flag: Flag<any>, options?: FlagUsageOptions): [string, string | undefined];
+export declare function flagUsages(flags: Flag<any>[], options?: FlagUsageOptions): [string, string | undefined][];

data/payload/node_modules/@oclif/core/lib/parser/help.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flagUsage = flagUsage;
+exports.flagUsages = flagUsages;
+const util_1 = require("../util/util");
+const ux_1 = require("../ux");
+function flagUsage(flag, options = {}) {
+    const label = [];
+    if (flag.helpLabel) {
+        label.push(flag.helpLabel);
+    }
+    else {
+        if (flag.char)
+            label.push(`-${flag.char}`);
+        if (flag.name)
+            label.push(` --${flag.name}`);
+    }
+    const usage = flag.type === 'option' ? ` ${flag.name.toUpperCase()}` : '';
+    let description = flag.summary || flag.description || '';
+    if (options.displayRequired && flag.required)
+        description = `(required) ${description}`;
+    description = description ? (0, ux_1.colorize)('dim', description) : undefined;
+    return [` ${label.join(',').trim()}${usage}`, description];
+}
+function flagUsages(flags, options = {}) {
+    if (flags.length === 0)
+        return [];
+    return (0, util_1.sortBy)(flags, (f) => [f.char ? -1 : 1, f.char, f.name]).map((f) => flagUsage(f, options));
+}

data/payload/node_modules/@oclif/core/lib/parser/index.d.ts

@@ -0,0 +1,5 @@
+import type { Input, OutputArgs, OutputFlags, ParserOutput } from '../interfaces/parser';
+export type { ArgInput, FlagInput, Input, OutputArgs, OutputFlags, ParserOutput } from '../interfaces/parser';
+export { flagUsages } from './help';
+export { validate } from './validate';
+export declare function parse<TFlags extends OutputFlags<any>, BFlags extends OutputFlags<any>, TArgs extends OutputArgs<any>>(argv: string[], options: Input<TFlags, BFlags, TArgs>): Promise<ParserOutput<TFlags, BFlags, TArgs>>;

data/payload/node_modules/@oclif/core/lib/parser/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.flagUsages = void 0;
+exports.parse = parse;
+const parse_1 = require("./parse");
+const validate_1 = require("./validate");
+var help_1 = require("./help");
+Object.defineProperty(exports, "flagUsages", { enumerable: true, get: function () { return help_1.flagUsages; } });
+var validate_2 = require("./validate");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return validate_2.validate; } });
+async function parse(argv, options) {
+    const input = {
+        '--': options['--'],
+        args: (options.args ?? {}),
+        argv,
+        constraints: options.constraints,
+        context: options.context,
+        flags: (options.flags ?? {}),
+        strict: options.strict !== false,
+    };
+    const parser = new parse_1.Parser(input);
+    const output = await parser.parse();
+    await (0, validate_1.validate)({ input, output });
+    return output;
+}

data/payload/node_modules/@oclif/core/lib/parser/parse.d.ts

@@ -0,0 +1,37 @@
+import { OutputArgs, OutputFlags, ParserInput, ParserOutput } from '../interfaces/parser';
+declare global {
+    /**
+     * Cache the stdin so that it can be read multiple times.
+     *
+     * This fixes a bug where the stdin would be read multiple times (because Parser.parse() was called more than once)
+     * but only the first read would be successful - all other reads would return null.
+     *
+     * Storing in global is necessary because we want the cache to be shared across all versions of @oclif/core in
+     * in the dependency tree. Storing in a variable would only share the cache within the same version of @oclif/core.
+     */
+    var oclif: {
+        stdinCache?: string;
+    };
+}
+export declare const readStdin: () => Promise<null | string>;
+export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, BFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs<T['args']>> {
+    private readonly input;
+    private readonly argv;
+    private readonly booleanFlags;
+    private readonly context;
+    private currentFlag?;
+    private readonly flagAliases;
+    private readonly raw;
+    constructor(input: T);
+    private get _argTokens();
+    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
+    private _args;
+    private _debugInput;
+    private _debugOutput;
+    private _flags;
+    private _setNames;
+    private findFlag;
+    private findLongFlag;
+    private findShortFlag;
+    private mapAndValidateFlags;
+}