{"version":3,"sources":["/home/x/core/projects/battle/dist/cli.cjs","../src/cli.ts","../../../node_modules/yargs/index.mjs","../../../node_modules/yargs/lib/platform-shims/esm.mjs","../../../node_modules/cliui/index.mjs","../../../node_modules/cliui/build/lib/index.js","../../../node_modules/cliui/build/lib/string-utils.js","../../../node_modules/escalade/sync/index.mjs","../../../node_modules/yargs-parser/build/lib/index.js","../../../node_modules/yargs-parser/build/lib/string-utils.js","../../../node_modules/yargs-parser/build/lib/yargs-parser.js","../../../node_modules/yargs-parser/build/lib/tokenize-arg-string.js","../../../node_modules/yargs-parser/build/lib/yargs-parser-types.js","../../../node_modules/yargs/build/lib/utils/process-argv.js","../../../node_modules/yargs/build/lib/yerror.js","../../../node_modules/y18n/index.mjs","../../../node_modules/y18n/build/lib/platform-shims/node.js","../../../node_modules/y18n/build/lib/index.js","../../../node_modules/yargs/build/lib/yargs-factory.js","../../../node_modules/yargs/build/lib/command.js","../../../node_modules/yargs/build/lib/typings/common-types.js","../../../node_modules/yargs/build/lib/utils/is-promise.js","../../../node_modules/yargs/build/lib/middleware.js","../../../node_modules/yargs/build/lib/argsert.js","../../../node_modules/yargs/build/lib/parse-command.js","../../../node_modules/yargs/build/lib/utils/maybe-async-result.js","../../../node_modules/yargs/build/lib/utils/which-module.js","../../../node_modules/yargs/build/lib/usage.js","../../../node_modules/yargs/build/lib/utils/obj-filter.js","../../../node_modules/yargs/build/lib/utils/set-blocking.js","../../../node_modules/yargs/build/lib/completion.js","../../../node_modules/yargs/build/lib/completion-templates.js","../../../node_modules/yargs/build/lib/validation.js","../../../node_modules/yargs/build/lib/utils/levenshtein.js","../../../node_modules/yargs/build/lib/utils/apply-extends.js","../../../node_modules/yargs/helpers/helpers.mjs"],"names":["_a","DefaultValuesForTypeKey","mixin","args","env","argv","aliases","key","guessType","resolve","path","format","statSync","y18n","dirname","cmd","usage","command","validation","shim","fail","wrap","ui","maxWidth","_b","desc"],"mappings":"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;AAcV;AACA;AACA;AACA;AACU;AACV;AACA;AACA;AACA;AACA;AACA;AACS;AACT;AACA;AACA;AACA;AACA;AACU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACU;AACD;AACT;AACA;AACA;AACA;AACO;AAAc,EAAA;AAAA,IAAA;AAAA,EAAA;AACX,EAAA;AACH,IAAA;AACA,IAAA;AACL,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACU,IAAA;AACC,IAAA;AACX,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACJ,EAAA;AACW,EAAA;AACD,IAAA;AACE,IAAA;AACJ,IAAA;AACK,MAAA;AACL,MAAA;AACJ,IAAA;AACI,IAAA;AACO,MAAA;AACX,IAAA;AACK,IAAA;AACA,IAAA;AACE,IAAA;AACX,EAAA;AACU,EAAA;AACC,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACJ,IAAA;AACO,MAAA;AACL,IAAA;AACD,IAAA;AACA,IAAA;AACL,IAAA;AACO,IAAA;AACX,EAAA;AACW,EAAA;AACA,IAAA;AACX,EAAA;AACW,EAAA;AACC,IAAA;AACH,IAAA;AACE,IAAA;AACX,EAAA;AACY,EAAA;AACA,IAAA;AACH,IAAA;AACA,IAAA;AACE,IAAA;AACX,EAAA;AACQ,EAAA;AACI,IAAA;AACH,IAAA;AACA,IAAA;AACE,IAAA;AACX,EAAA;AACS,EAAA;AACG,IAAA;AACH,IAAA;AACM,MAAA;AACI,QAAA;AACP,MAAA;AACK,QAAA;AACD,UAAA;AACJ,QAAA;AAEI,UAAA;AACJ,QAAA;AACO,QAAA;AACP,MAAA;AACA,QAAA;AACO,QAAA;AACV,MAAA;AACK,IAAA;AACH,IAAA;AACX,EAAA;AACa,EAAA;AACD,IAAA;AACH,IAAA;AACE,IAAA;AACX,EAAA;AACa,EAAA;AACD,IAAA;AACE,IAAA;AACD,MAAA;AACK,QAAA;AACV,MAAA;AACA,MAAA;AACS,QAAA;AACT,MAAA;AACO,MAAA;AAEF,IAAA;AACL,MAAA;AACS,QAAA;AACT,MAAA;AACO,MAAA;AACX,IAAA;AACK,IAAA;AACK,MAAA;AACV,IAAA;AACA,IAAA;AACA,IAAA;AACQ,MAAA;AACE,MAAA;AACD,MAAA;AACM,QAAA;AACX,MAAA;AACO,MAAA;AACH,QAAA;AACO,QAAA;AACP,MAAA;AACK,QAAA;AACC,QAAA;AAGF,QAAA;AACA,UAAA;AACI,YAAA;AACJ,UAAA;AACJ,QAAA;AACO,QAAA;AACP,MAAA;AACM,QAAA;AACT,MAAA;AACE,IAAA;AACA,IAAA;AACX,EAAA;AACU,EAAA;AACE,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACa,EAAA;AACD,IAAA;AACG,IAAA;AACD,MAAA;AACN,MAAA;AACO,MAAA;AACX,IAAA;AACW,IAAA;AACP,MAAA;AACM,MAAA;AACV,IAAA;AACK,IAAA;AACE,IAAA;AACH,MAAA;AACH,IAAA;AACM,IAAA;AACX,EAAA;AACW,EAAA;AACC,IAAA;AACG,IAAA;AACF,MAAA;AACE,MAAA;AACX,IAAA;AACA,IAAA;AACK,IAAA;AACM,MAAA;AACX,IAAA;AACK,IAAA;AACD,IAAA;AACA,MAAA;AACG,IAAA;AACX,EAAA;AACa,EAAA;AACD,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACS,EAAA;AACE,IAAA;AACX,EAAA;AACW,EAAA;AACC,IAAA;AACF,IAAA;AACN,IAAA;AACO,IAAA;AACX,EAAA;AACY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AACI,QAAA;AACK,UAAA;AAER,MAAA;AACG,QAAA;AACK,UAAA;AACb,MAAA;AACH,IAAA;AACU,IAAA;AACJ,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACS,EAAA;AACE,IAAA;AACX,EAAA;AACQ,EAAA;AACG,IAAA;AACX,EAAA;AACY,EAAA;AACA,IAAA;AACG,IAAA;AACA,MAAA;AAEN,IAAA;AACI,MAAA;AACT,IAAA;AACO,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACG,IAAA;AACX,IAAA;AACO,IAAA;AACX,EAAA;AACS,EAAA;AACG,IAAA;AACR,IAAA;AACK,IAAA;AACI,MAAA;AACK,QAAA;AACF,QAAA;AACA,UAAA;AACI,YAAA;AACH,UAAA;AACD,UAAA;AACJ,QAAA;AACJ,MAAA;AACM,MAAA;AACF,MAAA;AACA,QAAA;AACI,UAAA;AACH,QAAA;AACM,QAAA;AACX,MAAA;AACJ,IAAA;AACA,IAAA;AACO,IAAA;AACX,EAAA;AACW,EAAA;AACF,IAAA;AACK,IAAA;AACH,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACY,EAAA;AACA,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACH,IAAA;AACE,IAAA;AACX,EAAA;AACO,EAAA;AACK,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACR,IAAA;AACO,IAAA;AACX,EAAA;AACa,EAAA;AACD,IAAA;AACH,IAAA;AACA,IAAA;AACE,IAAA;AACX,EAAA;AACA,EAAA;AACa,IAAA;AACF,IAAA;AACX,EAAA;AACa,EAAA;AACF,IAAA;AACX,EAAA;AACA,EAAA;AACY,IAAA;AACR,IAAA;AACA,IAAA;AACO,IAAA;AACX,EAAA;AACW,EAAA;AACC,IAAA;AACJ,IAAA;AACA,MAAA;AACK,MAAA;AACM,QAAA;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","file":"/home/x/core/projects/battle/dist/cli.cjs","sourcesContent":[null,"#!/usr/bin/env node\n\n/**\n * Battle CLI\n * Command-line interface for the Battle testing framework\n */\n\n// @ts-ignore - yargs types in workspace conflict\nimport yargs from 'yargs'\n// @ts-ignore - yargs types in workspace conflict  \nimport { hideBin } from 'yargs/helpers'\nimport { Battle, Runner, Silent } from './index.js'\nimport { Replay } from './Replay/index.js'\nimport { CommandSanitizer, SecureErrorHandler } from './security/index.js'\nimport fs from 'fs'\nimport path from 'path'\nimport { color as chalk } from './utils/colors.js'\n\n// Yargs configuration moved to main function\n\nasync function main() {\n    const argv = await yargs(hideBin(process.argv))\n        .command('test [file]', 'Run tests from a file or directory', (yargs: any) => {\n            return yargs\n                .positional('file', {\n                    describe: 'Test file or directory',\n                    default: './test'\n                })\n        })\n        .command('run <command>', 'Run a single command test', (yargs: any) => {\n            return yargs\n                .positional('command', {\n                    describe: 'Command to test',\n                    type: 'string'\n                })\n        })\n        .command('silent <command>', 'Run a silent (non-interactive) test', (yargs: any) => {\n            return yargs\n                .positional('command', {\n                    describe: 'Command to test',\n                    type: 'string'\n                })\n        })\n        .command('replay <action> [file]', 'Replay operations', (yargs: any) => {\n            return yargs\n                .positional('action', {\n                    describe: 'Action: play, export',\n                    choices: ['play', 'export'] as const,\n                    type: 'string'\n                })\n                .positional('file', {\n                    describe: 'Replay file path',\n                    type: 'string'\n                })\n                .option('speed', {\n                    type: 'number',\n                    description: 'Playback speed multiplier',\n                    default: 1.0\n                })\n                .option('format', {\n                    type: 'string',\n                    description: 'Export format (html, json)',\n                    choices: ['html', 'json'] as const,\n                    default: 'html'\n                })\n        })\n        .option('verbose', {\n            alias: 'v',\n            type: 'boolean',\n            description: 'Enable verbose output'\n        })\n        .option('timeout', {\n            alias: 't',\n            type: 'number',\n            description: 'Timeout in seconds',\n            default: 30\n        })\n        .help()\n        .alias('help', 'h')\n        .parseAsync()\n    const command = argv._[0] as string\n    \n    if (command === 'test') {\n        // Run test files\n        const testPath = (argv.file || './test') as string\n        \n        if (fs.existsSync(testPath)) {\n            const stats = fs.statSync(testPath)\n            \n            if (stats.isDirectory()) {\n                // Run all test files in directory\n                const files = fs.readdirSync(testPath)\n                    .filter(f => f.endsWith('.test.ts') || f.endsWith('.test.js'))\n                \n                for (const file of files) {\n                    console.log(chalk.blue(`Running ${file}...`))\n                    const fullPath = path.join(testPath, file)\n                    \n                    if (file.endsWith('.ts')) {\n                        // For TypeScript files, use tsx if available\n                        try {\n                            const { spawn } = await import('child_process')\n                            const child = spawn('tsx', [fullPath], { stdio: 'inherit' })\n                            await new Promise((resolve, reject) => {\n                                child.on('close', (code) => {\n                                    if (code === 0) resolve(void 0)\n                                    else reject(new Error(`tsx exited with code ${code}`))\n                                })\n                                child.on('error', reject)\n                            })\n                        } catch {\n                            console.error(chalk.red('TypeScript files require tsx to be installed: npm install -g tsx'))\n                            process.exit(1)\n                        }\n                    } else {\n                        await import(fullPath)\n                    }\n                }\n            } else {\n                // Run single test file\n                if (testPath.endsWith('.ts')) {\n                    // For TypeScript files, use tsx if available\n                    try {\n                        const { spawn } = await import('child_process')\n                        const child = spawn('tsx', [testPath], { stdio: 'inherit' })\n                        await new Promise((resolve, reject) => {\n                            child.on('close', (code) => {\n                                if (code === 0) resolve(void 0)\n                                else reject(new Error(`tsx exited with code ${code}`))\n                            })\n                            child.on('error', reject)\n                        })\n                    } catch {\n                        console.error(chalk.red('TypeScript files require tsx to be installed: npm install -g tsx'))\n                        process.exit(1)\n                    }\n                } else {\n                    await import(path.resolve(testPath))\n                }\n            }\n        } else {\n            console.error(chalk.red(`Test file not found: ${testPath}`))\n            process.exit(1)\n        }\n        \n    } else if (command === 'run') {\n        // Run single command test\n        const cmd = argv.command as string\n        // Validate command for security\n        const validation = CommandSanitizer.validate(cmd)\n        if (!validation.valid) {\n            console.error(chalk.red('Security Error:'), validation.error)\n            process.exit(1)\n        }\n        \n        const battle = new Battle({\n            verbose: argv.verbose,\n            timeout: argv.timeout\n        })\n        \n        const result = await battle.run(async (b) => {\n            // Parse command safely\n            const parts = cmd.trim().split(/\\s+/)\n            const program = parts[0]\n            const args = CommandSanitizer.sanitizeArgs(parts.slice(1))\n            \n            b.spawn(program, args)\n            \n            if (argv.screenshot) {\n                setTimeout(() => b.screenshot('cli-test'), 1000)\n            }\n        })\n        \n        if (result.success) {\n            console.log(chalk.green('Test passed'))\n            if (result.replayPath) {\n                console.log(chalk.blue(`Replay saved: ${result.replayPath}`))\n                console.log(chalk.gray(`To replay: battle replay play ${result.replayPath}`))\n            }\n        } else {\n            console.log(chalk.red('Test failed:'), result.error)\n            if (result.replayPath) {\n                console.log(chalk.blue(`Replay saved: ${result.replayPath}`))\n                console.log(chalk.gray(`To replay: battle replay play ${result.replayPath}`))\n            }\n            process.exit(1)\n        }\n        \n    } else if (command === 'silent') {\n        // Run silent test with security warning\n        const cmd = argv.command as string\n        \n        console.log(chalk.yellow('WARNING: Silent mode bypasses PTY security features'))\n        console.log(chalk.yellow('Consider using \"battle run\" for secure command execution'))\n        \n        // Validate command for security\n        const validation = CommandSanitizer.validate(cmd)\n        if (!validation.valid) {\n            console.error(chalk.red('Security Error:'), validation.error)\n            console.error(chalk.gray('Use \"battle run\" for secure command execution'))\n            process.exit(1)\n        }\n        \n        const silent = new Silent()\n        const result = silent.exec(cmd)\n        \n        if (result.success) {\n            console.log(chalk.green('Command succeeded'))\n            console.log(result.stdout)\n        } else {\n            console.log(chalk.red('Command failed'))\n            console.log(result.stderr)\n            process.exit(1)\n        }\n        \n    } else if (command === 'replay') {\n        // Handle replay commands\n        const action = argv.action as string\n        const file = argv.file as string\n        \n        if (action === 'play') {\n            if (!file) {\n                console.error(chalk.red('Replay file path required'))\n                process.exit(1)\n            }\n            \n            if (!fs.existsSync(file)) {\n                console.error(chalk.red(`Replay file not found: ${file}`))\n                process.exit(1)\n            }\n            \n            const replay = new Replay()\n            replay.load(file)\n            await replay.play({\n                speed: argv.speed,\n                verbose: argv.verbose !== false\n            })\n            \n        } else if (action === 'export') {\n            if (!file) {\n                console.error(chalk.red('Replay file path required'))\n                process.exit(1)\n            }\n            \n            if (!fs.existsSync(file)) {\n                console.error(chalk.red(`Replay file not found: ${file}`))\n                process.exit(1)\n            }\n            \n            const replay = new Replay()\n            replay.load(file)\n            \n            const format = argv.format as 'html' | 'json'\n            const output = replay.export(format)\n            \n            const outputFile = file.replace('.json', `.${format}`)\n            fs.writeFileSync(outputFile, output)\n            \n            console.log(chalk.green(`Exported to: ${outputFile}`))\n        }\n        \n    } else {\n        // Show help - just log usage info since no command provided\n        console.log('Usage: battle <command> [options]')\n        console.log('Commands:')\n        console.log('  test [file]         Run tests from file or directory')\n        console.log('  run <command>       Run a single command test')\n        console.log('  silent <command>    Run a silent test')\n        console.log('  replay <action>     Replay operations')\n        console.log('\\nUse --help for more information')\n    }\n}\n\nmain().catch(error => {\n    console.error(chalk.red('Error:'), error)\n    process.exit(1)\n})","'use strict';\n\n// Bootstraps yargs for ESM:\nimport esmPlatformShim from './lib/platform-shims/esm.mjs';\nimport {YargsFactory} from './build/lib/yargs-factory.js';\n\nconst Yargs = YargsFactory(esmPlatformShim);\nexport default Yargs;\n","'use strict'\n\nimport { notStrictEqual, strictEqual } from 'assert'\nimport cliui from 'cliui'\nimport escalade from 'escalade/sync'\nimport { inspect } from 'util'\nimport { readFileSync } from 'fs'\nimport { fileURLToPath } from 'url';\nimport Parser from 'yargs-parser'\nimport { basename, dirname, extname, relative, resolve } from 'path'\nimport { getProcessArgvBin } from '../../build/lib/utils/process-argv.js'\nimport { YError } from '../../build/lib/yerror.js'\nimport y18n from 'y18n'\n\nconst REQUIRE_ERROR = 'require is not supported by ESM'\nconst REQUIRE_DIRECTORY_ERROR = 'loading a directory of commands is not supported yet for ESM'\n\nlet __dirname;\ntry {\n  __dirname = fileURLToPath(import.meta.url);\n} catch (e) {\n  __dirname = process.cwd();\n}\nconst mainFilename = __dirname.substring(0, __dirname.lastIndexOf('node_modules'));\n\nexport default {\n  assert: {\n    notStrictEqual,\n    strictEqual\n  },\n  cliui,\n  findUp: escalade,\n  getEnv: (key) => {\n    return process.env[key]\n  },\n  inspect,\n  getCallerFile: () => {\n    throw new YError(REQUIRE_DIRECTORY_ERROR)\n  },\n  getProcessArgvBin,\n  mainFilename: mainFilename || process.cwd(),\n  Parser,\n  path: {\n    basename,\n    dirname,\n    extname,\n    relative,\n    resolve\n  },\n  process: {\n    argv: () => process.argv,\n    cwd: process.cwd,\n    emitWarning: (warning, type) => process.emitWarning(warning, type),\n    execPath: () => process.execPath,\n    exit: process.exit,\n    nextTick: process.nextTick,\n    stdColumns: typeof process.stdout.columns !== 'undefined' ? process.stdout.columns : null\n  },\n  readFileSync,\n  require: () => {\n    throw new YError(REQUIRE_ERROR)\n  },\n  requireDirectory: () => {\n    throw new YError(REQUIRE_DIRECTORY_ERROR)\n  },\n  stringWidth: (str) => {\n    return [...str].length\n  },\n  y18n: y18n({\n    directory: resolve(__dirname, '../../../locales'),\n    updateFiles: false\n  })\n}\n","// Bootstrap cliui with CommonJS dependencies:\nimport { cliui } from './build/lib/index.js'\nimport { wrap, stripAnsi } from './build/lib/string-utils.js'\n\nexport default function ui (opts) {\n  return cliui(opts, {\n    stringWidth: (str) => {\n      return [...str].length\n    },\n    stripAnsi,\n    wrap\n  })\n}\n","'use strict';\nconst align = {\n    right: alignRight,\n    center: alignCenter\n};\nconst top = 0;\nconst right = 1;\nconst bottom = 2;\nconst left = 3;\nexport class UI {\n    constructor(opts) {\n        var _a;\n        this.width = opts.width;\n        this.wrap = (_a = opts.wrap) !== null && _a !== void 0 ? _a : true;\n        this.rows = [];\n    }\n    span(...args) {\n        const cols = this.div(...args);\n        cols.span = true;\n    }\n    resetOutput() {\n        this.rows = [];\n    }\n    div(...args) {\n        if (args.length === 0) {\n            this.div('');\n        }\n        if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === 'string') {\n            return this.applyLayoutDSL(args[0]);\n        }\n        const cols = args.map(arg => {\n            if (typeof arg === 'string') {\n                return this.colFromString(arg);\n            }\n            return arg;\n        });\n        this.rows.push(cols);\n        return cols;\n    }\n    shouldApplyLayoutDSL(...args) {\n        return args.length === 1 && typeof args[0] === 'string' &&\n            /[\\t\\n]/.test(args[0]);\n    }\n    applyLayoutDSL(str) {\n        const rows = str.split('\\n').map(row => row.split('\\t'));\n        let leftColumnWidth = 0;\n        // simple heuristic for layout, make sure the\n        // second column lines up along the left-hand.\n        // don't allow the first column to take up more\n        // than 50% of the screen.\n        rows.forEach(columns => {\n            if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) {\n                leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin.stringWidth(columns[0]));\n            }\n        });\n        // generate a table:\n        //  replacing ' ' with padding calculations.\n        //  using the algorithmically generated width.\n        rows.forEach(columns => {\n            this.div(...columns.map((r, i) => {\n                return {\n                    text: r.trim(),\n                    padding: this.measurePadding(r),\n                    width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined\n                };\n            }));\n        });\n        return this.rows[this.rows.length - 1];\n    }\n    colFromString(text) {\n        return {\n            text,\n            padding: this.measurePadding(text)\n        };\n    }\n    measurePadding(str) {\n        // measure padding without ansi escape codes\n        const noAnsi = mixin.stripAnsi(str);\n        return [0, noAnsi.match(/\\s*$/)[0].length, 0, noAnsi.match(/^\\s*/)[0].length];\n    }\n    toString() {\n        const lines = [];\n        this.rows.forEach(row => {\n            this.rowToString(row, lines);\n        });\n        // don't display any lines with the\n        // hidden flag set.\n        return lines\n            .filter(line => !line.hidden)\n            .map(line => line.text)\n            .join('\\n');\n    }\n    rowToString(row, lines) {\n        this.rasterize(row).forEach((rrow, r) => {\n            let str = '';\n            rrow.forEach((col, c) => {\n                const { width } = row[c]; // the width with padding.\n                const wrapWidth = this.negatePadding(row[c]); // the width without padding.\n                let ts = col; // temporary string used during alignment/padding.\n                if (wrapWidth > mixin.stringWidth(col)) {\n                    ts += ' '.repeat(wrapWidth - mixin.stringWidth(col));\n                }\n                // align the string within its column.\n                if (row[c].align && row[c].align !== 'left' && this.wrap) {\n                    const fn = align[row[c].align];\n                    ts = fn(ts, wrapWidth);\n                    if (mixin.stringWidth(ts) < wrapWidth) {\n                        ts += ' '.repeat((width || 0) - mixin.stringWidth(ts) - 1);\n                    }\n                }\n                // apply border and padding to string.\n                const padding = row[c].padding || [0, 0, 0, 0];\n                if (padding[left]) {\n                    str += ' '.repeat(padding[left]);\n                }\n                str += addBorder(row[c], ts, '| ');\n                str += ts;\n                str += addBorder(row[c], ts, ' |');\n                if (padding[right]) {\n                    str += ' '.repeat(padding[right]);\n                }\n                // if prior row is span, try to render the\n                // current row on the prior line.\n                if (r === 0 && lines.length > 0) {\n                    str = this.renderInline(str, lines[lines.length - 1]);\n                }\n            });\n            // remove trailing whitespace.\n            lines.push({\n                text: str.replace(/ +$/, ''),\n                span: row.span\n            });\n        });\n        return lines;\n    }\n    // if the full 'source' can render in\n    // the target line, do so.\n    renderInline(source, previousLine) {\n        const match = source.match(/^ */);\n        const leadingWhitespace = match ? match[0].length : 0;\n        const target = previousLine.text;\n        const targetTextWidth = mixin.stringWidth(target.trimRight());\n        if (!previousLine.span) {\n            return source;\n        }\n        // if we're not applying wrapping logic,\n        // just always append to the span.\n        if (!this.wrap) {\n            previousLine.hidden = true;\n            return target + source;\n        }\n        if (leadingWhitespace < targetTextWidth) {\n            return source;\n        }\n        previousLine.hidden = true;\n        return target.trimRight() + ' '.repeat(leadingWhitespace - targetTextWidth) + source.trimLeft();\n    }\n    rasterize(row) {\n        const rrows = [];\n        const widths = this.columnWidths(row);\n        let wrapped;\n        // word wrap all columns, and create\n        // a data-structure that is easy to rasterize.\n        row.forEach((col, c) => {\n            // leave room for left and right padding.\n            col.width = widths[c];\n            if (this.wrap) {\n                wrapped = mixin.wrap(col.text, this.negatePadding(col), { hard: true }).split('\\n');\n            }\n            else {\n                wrapped = col.text.split('\\n');\n            }\n            if (col.border) {\n                wrapped.unshift('.' + '-'.repeat(this.negatePadding(col) + 2) + '.');\n                wrapped.push(\"'\" + '-'.repeat(this.negatePadding(col) + 2) + \"'\");\n            }\n            // add top and bottom padding.\n            if (col.padding) {\n                wrapped.unshift(...new Array(col.padding[top] || 0).fill(''));\n                wrapped.push(...new Array(col.padding[bottom] || 0).fill(''));\n            }\n            wrapped.forEach((str, r) => {\n                if (!rrows[r]) {\n                    rrows.push([]);\n                }\n                const rrow = rrows[r];\n                for (let i = 0; i < c; i++) {\n                    if (rrow[i] === undefined) {\n                        rrow.push('');\n                    }\n                }\n                rrow.push(str);\n            });\n        });\n        return rrows;\n    }\n    negatePadding(col) {\n        let wrapWidth = col.width || 0;\n        if (col.padding) {\n            wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);\n        }\n        if (col.border) {\n            wrapWidth -= 4;\n        }\n        return wrapWidth;\n    }\n    columnWidths(row) {\n        if (!this.wrap) {\n            return row.map(col => {\n                return col.width || mixin.stringWidth(col.text);\n            });\n        }\n        let unset = row.length;\n        let remainingWidth = this.width;\n        // column widths can be set in config.\n        const widths = row.map(col => {\n            if (col.width) {\n                unset--;\n                remainingWidth -= col.width;\n                return col.width;\n            }\n            return undefined;\n        });\n        // any unset widths should be calculated.\n        const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;\n        return widths.map((w, i) => {\n            if (w === undefined) {\n                return Math.max(unsetWidth, _minWidth(row[i]));\n            }\n            return w;\n        });\n    }\n}\nfunction addBorder(col, ts, style) {\n    if (col.border) {\n        if (/[.']-+[.']/.test(ts)) {\n            return '';\n        }\n        if (ts.trim().length !== 0) {\n            return style;\n        }\n        return '  ';\n    }\n    return '';\n}\n// calculates the minimum width of\n// a column, based on padding preferences.\nfunction _minWidth(col) {\n    const padding = col.padding || [];\n    const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);\n    if (col.border) {\n        return minWidth + 4;\n    }\n    return minWidth;\n}\nfunction getWindowWidth() {\n    /* istanbul ignore next: depends on terminal */\n    if (typeof process === 'object' && process.stdout && process.stdout.columns) {\n        return process.stdout.columns;\n    }\n    return 80;\n}\nfunction alignRight(str, width) {\n    str = str.trim();\n    const strWidth = mixin.stringWidth(str);\n    if (strWidth < width) {\n        return ' '.repeat(width - strWidth) + str;\n    }\n    return str;\n}\nfunction alignCenter(str, width) {\n    str = str.trim();\n    const strWidth = mixin.stringWidth(str);\n    /* istanbul ignore next */\n    if (strWidth >= width) {\n        return str;\n    }\n    return ' '.repeat((width - strWidth) >> 1) + str;\n}\nlet mixin;\nexport function cliui(opts, _mixin) {\n    mixin = _mixin;\n    return new UI({\n        width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),\n        wrap: opts === null || opts === void 0 ? void 0 : opts.wrap\n    });\n}\n","// Minimal replacement for ansi string helpers \"wrap-ansi\" and \"strip-ansi\".\n// to facilitate ESM and Deno modules.\n// TODO: look at porting https://www.npmjs.com/package/wrap-ansi to ESM.\n// The npm application\n// Copyright (c) npm, Inc. and Contributors\n// Licensed on the terms of The Artistic License 2.0\n// See: https://github.com/npm/cli/blob/4c65cd952bc8627811735bea76b9b110cc4fc80e/lib/utils/ansi-trim.js\nconst ansi = new RegExp('\\x1b(?:\\\\[(?:\\\\d+[ABCDEFGJKSTm]|\\\\d+;\\\\d+[Hfm]|' +\n    '\\\\d+;\\\\d+;\\\\d+m|6n|s|u|\\\\?25[lh])|\\\\w)', 'g');\nexport function stripAnsi(str) {\n    return str.replace(ansi, '');\n}\nexport function wrap(str, width) {\n    const [start, end] = str.match(ansi) || ['', ''];\n    str = stripAnsi(str);\n    let wrapped = '';\n    for (let i = 0; i < str.length; i++) {\n        if (i !== 0 && (i % width) === 0) {\n            wrapped += '\\n';\n        }\n        wrapped += str.charAt(i);\n    }\n    if (start && end) {\n        wrapped = `${start}${wrapped}${end}`;\n    }\n    return wrapped;\n}\n","import { dirname, resolve } from 'path';\nimport { readdirSync, statSync } from 'fs';\n\nexport default function (start, callback) {\n\tlet dir = resolve('.', start);\n\tlet tmp, stats = statSync(dir);\n\n\tif (!stats.isDirectory()) {\n\t\tdir = dirname(dir);\n\t}\n\n\twhile (true) {\n\t\ttmp = callback(dir, readdirSync(dir));\n\t\tif (tmp) return resolve(dir, tmp);\n\t\tdir = dirname(tmp = dir);\n\t\tif (tmp === dir) break;\n\t}\n}\n","/**\n * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js\n * CJS and ESM environments.\n *\n * @license\n * Copyright (c) 2016, Contributors\n * SPDX-License-Identifier: ISC\n */\nvar _a, _b, _c;\nimport { format } from 'util';\nimport { normalize, resolve } from 'path';\nimport { camelCase, decamelize, looksLikeNumber } from './string-utils.js';\nimport { YargsParser } from './yargs-parser.js';\nimport { readFileSync } from 'fs';\n// See https://github.com/yargs/yargs-parser#supported-nodejs-versions for our\n// version support policy. The YARGS_MIN_NODE_VERSION is used for testing only.\nconst minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION)\n    ? Number(process.env.YARGS_MIN_NODE_VERSION)\n    : 12;\nconst nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);\nif (nodeVersion) {\n    const major = Number(nodeVersion.match(/^([^.]+)/)[1]);\n    if (major < minNodeVersion) {\n        throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);\n    }\n}\n// Creates a yargs-parser instance using Node.js standard libraries:\nconst env = process ? process.env : {};\nconst parser = new YargsParser({\n    cwd: process.cwd,\n    env: () => {\n        return env;\n    },\n    format,\n    normalize,\n    resolve,\n    // TODO: figure  out a  way to combine ESM and CJS coverage, such  that\n    // we can exercise all the lines below:\n    require: (path) => {\n        if (typeof require !== 'undefined') {\n            return require(path);\n        }\n        else if (path.match(/\\.json$/)) {\n            // Addresses: https://github.com/yargs/yargs/issues/2040\n            return JSON.parse(readFileSync(path, 'utf8'));\n        }\n        else {\n            throw Error('only .json config files are supported in ESM');\n        }\n    }\n});\nconst yargsParser = function Parser(args, opts) {\n    const result = parser.parse(args.slice(), opts);\n    return result.argv;\n};\nyargsParser.detailed = function (args, opts) {\n    return parser.parse(args.slice(), opts);\n};\nyargsParser.camelCase = camelCase;\nyargsParser.decamelize = decamelize;\nyargsParser.looksLikeNumber = looksLikeNumber;\nexport default yargsParser;\n","/**\n * @license\n * Copyright (c) 2016, Contributors\n * SPDX-License-Identifier: ISC\n */\nexport function camelCase(str) {\n    // Handle the case where an argument is provided as camel case, e.g., fooBar.\n    // by ensuring that the string isn't already mixed case:\n    const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();\n    if (!isCamelCase) {\n        str = str.toLowerCase();\n    }\n    if (str.indexOf('-') === -1 && str.indexOf('_') === -1) {\n        return str;\n    }\n    else {\n        let camelcase = '';\n        let nextChrUpper = false;\n        const leadingHyphens = str.match(/^-+/);\n        for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {\n            let chr = str.charAt(i);\n            if (nextChrUpper) {\n                nextChrUpper = false;\n                chr = chr.toUpperCase();\n            }\n            if (i !== 0 && (chr === '-' || chr === '_')) {\n                nextChrUpper = true;\n            }\n            else if (chr !== '-' && chr !== '_') {\n                camelcase += chr;\n            }\n        }\n        return camelcase;\n    }\n}\nexport function decamelize(str, joinString) {\n    const lowercase = str.toLowerCase();\n    joinString = joinString || '-';\n    let notCamelcase = '';\n    for (let i = 0; i < str.length; i++) {\n        const chrLower = lowercase.charAt(i);\n        const chrString = str.charAt(i);\n        if (chrLower !== chrString && i > 0) {\n            notCamelcase += `${joinString}${lowercase.charAt(i)}`;\n        }\n        else {\n            notCamelcase += chrString;\n        }\n    }\n    return notCamelcase;\n}\nexport function looksLikeNumber(x) {\n    if (x === null || x === undefined)\n        return false;\n    // if loaded from config, may already be a number.\n    if (typeof x === 'number')\n        return true;\n    // hexadecimal.\n    if (/^0x[0-9a-f]+$/i.test(x))\n        return true;\n    // don't treat 0123 as a number; as it drops the leading '0'.\n    if (/^0[^.]/.test(x))\n        return false;\n    return /^[-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(e[-+]?\\d+)?$/.test(x);\n}\n","/**\n * @license\n * Copyright (c) 2016, Contributors\n * SPDX-License-Identifier: ISC\n */\nimport { tokenizeArgString } from './tokenize-arg-string.js';\nimport { DefaultValuesForTypeKey } from './yargs-parser-types.js';\nimport { camelCase, decamelize, looksLikeNumber } from './string-utils.js';\nlet mixin;\nexport class YargsParser {\n    constructor(_mixin) {\n        mixin = _mixin;\n    }\n    parse(argsInput, options) {\n        const opts = Object.assign({\n            alias: undefined,\n            array: undefined,\n            boolean: undefined,\n            config: undefined,\n            configObjects: undefined,\n            configuration: undefined,\n            coerce: undefined,\n            count: undefined,\n            default: undefined,\n            envPrefix: undefined,\n            narg: undefined,\n            normalize: undefined,\n            string: undefined,\n            number: undefined,\n            __: undefined,\n            key: undefined\n        }, options);\n        // allow a string argument to be passed in rather\n        // than an argv array.\n        const args = tokenizeArgString(argsInput);\n        // tokenizeArgString adds extra quotes to args if argsInput is a string\n        // only strip those extra quotes in processValue if argsInput is a string\n        const inputIsString = typeof argsInput === 'string';\n        // aliases might have transitive relationships, normalize this.\n        const aliases = combineAliases(Object.assign(Object.create(null), opts.alias));\n        const configuration = Object.assign({\n            'boolean-negation': true,\n            'camel-case-expansion': true,\n            'combine-arrays': false,\n            'dot-notation': true,\n            'duplicate-arguments-array': true,\n            'flatten-duplicate-arrays': true,\n            'greedy-arrays': true,\n            'halt-at-non-option': false,\n            'nargs-eats-options': false,\n            'negation-prefix': 'no-',\n            'parse-numbers': true,\n            'parse-positional-numbers': true,\n            'populate--': false,\n            'set-placeholder-key': false,\n            'short-option-groups': true,\n            'strip-aliased': false,\n            'strip-dashed': false,\n            'unknown-options-as-args': false\n        }, opts.configuration);\n        const defaults = Object.assign(Object.create(null), opts.default);\n        const configObjects = opts.configObjects || [];\n        const envPrefix = opts.envPrefix;\n        const notFlagsOption = configuration['populate--'];\n        const notFlagsArgv = notFlagsOption ? '--' : '_';\n        const newAliases = Object.create(null);\n        const defaulted = Object.create(null);\n        // allow a i18n handler to be passed in, default to a fake one (util.format).\n        const __ = opts.__ || mixin.format;\n        const flags = {\n            aliases: Object.create(null),\n            arrays: Object.create(null),\n            bools: Object.create(null),\n            strings: Object.create(null),\n            numbers: Object.create(null),\n            counts: Object.create(null),\n            normalize: Object.create(null),\n            configs: Object.create(null),\n            nargs: Object.create(null),\n            coercions: Object.create(null),\n            keys: []\n        };\n        const negative = /^-([0-9]+(\\.[0-9]+)?|\\.[0-9]+)$/;\n        const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)');\n        [].concat(opts.array || []).filter(Boolean).forEach(function (opt) {\n            const key = typeof opt === 'object' ? opt.key : opt;\n            // assign to flags[bools|strings|numbers]\n            const assignment = Object.keys(opt).map(function (key) {\n                const arrayFlagKeys = {\n                    boolean: 'bools',\n                    string: 'strings',\n                    number: 'numbers'\n                };\n                return arrayFlagKeys[key];\n            }).filter(Boolean).pop();\n            // assign key to be coerced\n            if (assignment) {\n                flags[assignment][key] = true;\n            }\n            flags.arrays[key] = true;\n            flags.keys.push(key);\n        });\n        [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) {\n            flags.bools[key] = true;\n            flags.keys.push(key);\n        });\n        [].concat(opts.string || []).filter(Boolean).forEach(function (key) {\n            flags.strings[key] = true;\n            flags.keys.push(key);\n        });\n        [].concat(opts.number || []).filter(Boolean).forEach(function (key) {\n            flags.numbers[key] = true;\n            flags.keys.push(key);\n        });\n        [].concat(opts.count || []).filter(Boolean).forEach(function (key) {\n            flags.counts[key] = true;\n            flags.keys.push(key);\n        });\n        [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) {\n            flags.normalize[key] = true;\n            flags.keys.push(key);\n        });\n        if (typeof opts.narg === 'object') {\n            Object.entries(opts.narg).forEach(([key, value]) => {\n                if (typeof value === 'number') {\n                    flags.nargs[key] = value;\n                    flags.keys.push(key);\n                }\n            });\n        }\n        if (typeof opts.coerce === 'object') {\n            Object.entries(opts.coerce).forEach(([key, value]) => {\n                if (typeof value === 'function') {\n                    flags.coercions[key] = value;\n                    flags.keys.push(key);\n                }\n            });\n        }\n        if (typeof opts.config !== 'undefined') {\n            if (Array.isArray(opts.config) || typeof opts.config === 'string') {\n                ;\n                [].concat(opts.config).filter(Boolean).forEach(function (key) {\n                    flags.configs[key] = true;\n                });\n            }\n            else if (typeof opts.config === 'object') {\n                Object.entries(opts.config).forEach(([key, value]) => {\n                    if (typeof value === 'boolean' || typeof value === 'function') {\n                        flags.configs[key] = value;\n                    }\n                });\n            }\n        }\n        // create a lookup table that takes into account all\n        // combinations of aliases: {f: ['foo'], foo: ['f']}\n        extendAliases(opts.key, aliases, opts.default, flags.arrays);\n        // apply default values to all aliases.\n        Object.keys(defaults).forEach(function (key) {\n            (flags.aliases[key] || []).forEach(function (alias) {\n                defaults[alias] = defaults[key];\n            });\n        });\n        let error = null;\n        checkConfiguration();\n        let notFlags = [];\n        const argv = Object.assign(Object.create(null), { _: [] });\n        // TODO(bcoe): for the first pass at removing object prototype  we didn't\n        // remove all prototypes from objects returned by this API, we might want\n        // to gradually move towards doing so.\n        const argvReturn = {};\n        for (let i = 0; i < args.length; i++) {\n            const arg = args[i];\n            const truncatedArg = arg.replace(/^-{3,}/, '---');\n            let broken;\n            let key;\n            let letters;\n            let m;\n            let next;\n            let value;\n            // any unknown option (except for end-of-options, \"--\")\n            if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {\n                pushPositional(arg);\n                // ---, ---=, ----, etc,\n            }\n            else if (truncatedArg.match(/^---+(=|$)/)) {\n                // options without key name are invalid.\n                pushPositional(arg);\n                continue;\n                // -- separated by =\n            }\n            else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) {\n                // Using [\\s\\S] instead of . because js doesn't support the\n                // 'dotall' regex modifier. See:\n                // http://stackoverflow.com/a/1068308/13216\n                m = arg.match(/^--?([^=]+)=([\\s\\S]*)$/);\n                // arrays format = '--f=a b c'\n                if (m !== null && Array.isArray(m) && m.length >= 3) {\n                    if (checkAllAliases(m[1], flags.arrays)) {\n                        i = eatArray(i, m[1], args, m[2]);\n                    }\n                    else if (checkAllAliases(m[1], flags.nargs) !== false) {\n                        // nargs format = '--f=monkey washing cat'\n                        i = eatNargs(i, m[1], args, m[2]);\n                    }\n                    else {\n                        setArg(m[1], m[2], true);\n                    }\n                }\n            }\n            else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {\n                m = arg.match(negatedBoolean);\n                if (m !== null && Array.isArray(m) && m.length >= 2) {\n                    key = m[1];\n                    setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);\n                }\n                // -- separated by space.\n            }\n            else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) {\n                m = arg.match(/^--?(.+)/);\n                if (m !== null && Array.isArray(m) && m.length >= 2) {\n                    key = m[1];\n                    if (checkAllAliases(key, flags.arrays)) {\n                        // array format = '--foo a b c'\n                        i = eatArray(i, key, args);\n                    }\n                    else if (checkAllAliases(key, flags.nargs) !== false) {\n                        // nargs format = '--foo a b c'\n                        // should be truthy even if: flags.nargs[key] === 0\n                        i = eatNargs(i, key, args);\n                    }\n                    else {\n                        next = args[i + 1];\n                        if (next !== undefined && (!next.match(/^-/) ||\n                            next.match(negative)) &&\n                            !checkAllAliases(key, flags.bools) &&\n                            !checkAllAliases(key, flags.counts)) {\n                            setArg(key, next);\n                            i++;\n                        }\n                        else if (/^(true|false)$/.test(next)) {\n                            setArg(key, next);\n                            i++;\n                        }\n                        else {\n                            setArg(key, defaultValue(key));\n                        }\n                    }\n                }\n                // dot-notation flag separated by '='.\n            }\n            else if (arg.match(/^-.\\..+=/)) {\n                m = arg.match(/^-([^=]+)=([\\s\\S]*)$/);\n                if (m !== null && Array.isArray(m) && m.length >= 3) {\n                    setArg(m[1], m[2]);\n                }\n                // dot-notation flag separated by space.\n            }\n            else if (arg.match(/^-.\\..+/) && !arg.match(negative)) {\n                next = args[i + 1];\n                m = arg.match(/^-(.\\..+)/);\n                if (m !== null && Array.isArray(m) && m.length >= 2) {\n                    key = m[1];\n                    if (next !== undefined && !next.match(/^-/) &&\n                        !checkAllAliases(key, flags.bools) &&\n                        !checkAllAliases(key, flags.counts)) {\n                        setArg(key, next);\n                        i++;\n                    }\n                    else {\n                        setArg(key, defaultValue(key));\n                    }\n                }\n            }\n            else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {\n                letters = arg.slice(1, -1).split('');\n                broken = false;\n                for (let j = 0; j < letters.length; j++) {\n                    next = arg.slice(j + 2);\n                    if (letters[j + 1] && letters[j + 1] === '=') {\n                        value = arg.slice(j + 3);\n                        key = letters[j];\n                        if (checkAllAliases(key, flags.arrays)) {\n                            // array format = '-f=a b c'\n                            i = eatArray(i, key, args, value);\n                        }\n                        else if (checkAllAliases(key, flags.nargs) !== false) {\n                            // nargs format = '-f=monkey washing cat'\n                            i = eatNargs(i, key, args, value);\n                        }\n                        else {\n                            setArg(key, value);\n                        }\n                        broken = true;\n                        break;\n                    }\n                    if (next === '-') {\n                        setArg(letters[j], next);\n                        continue;\n                    }\n                    // current letter is an alphabetic character and next value is a number\n                    if (/[A-Za-z]/.test(letters[j]) &&\n                        /^-?\\d+(\\.\\d*)?(e-?\\d+)?$/.test(next) &&\n                        checkAllAliases(next, flags.bools) === false) {\n                        setArg(letters[j], next);\n                        broken = true;\n                        break;\n                    }\n                    if (letters[j + 1] && letters[j + 1].match(/\\W/)) {\n                        setArg(letters[j], next);\n                        broken = true;\n                        break;\n                    }\n                    else {\n                        setArg(letters[j], defaultValue(letters[j]));\n                    }\n                }\n                key = arg.slice(-1)[0];\n                if (!broken && key !== '-') {\n                    if (checkAllAliases(key, flags.arrays)) {\n                        // array format = '-f a b c'\n                        i = eatArray(i, key, args);\n                    }\n                    else if (checkAllAliases(key, flags.nargs) !== false) {\n                        // nargs format = '-f a b c'\n                        // should be truthy even if: flags.nargs[key] === 0\n                        i = eatNargs(i, key, args);\n                    }\n                    else {\n                        next = args[i + 1];\n                        if (next !== undefined && (!/^(-|--)[^-]/.test(next) ||\n                            next.match(negative)) &&\n                            !checkAllAliases(key, flags.bools) &&\n                            !checkAllAliases(key, flags.counts)) {\n                            setArg(key, next);\n                            i++;\n                        }\n                        else if (/^(true|false)$/.test(next)) {\n                            setArg(key, next);\n                            i++;\n                        }\n                        else {\n                            setArg(key, defaultValue(key));\n                        }\n                    }\n                }\n            }\n            else if (arg.match(/^-[0-9]$/) &&\n                arg.match(negative) &&\n                checkAllAliases(arg.slice(1), flags.bools)) {\n                // single-digit boolean alias, e.g: xargs -0\n                key = arg.slice(1);\n                setArg(key, defaultValue(key));\n            }\n            else if (arg === '--') {\n                notFlags = args.slice(i + 1);\n                break;\n            }\n            else if (configuration['halt-at-non-option']) {\n                notFlags = args.slice(i);\n                break;\n            }\n            else {\n                pushPositional(arg);\n            }\n        }\n        // order of precedence:\n        // 1. command line arg\n        // 2. value from env var\n        // 3. value from config file\n        // 4. value from config objects\n        // 5. configured default value\n        applyEnvVars(argv, true); // special case: check env vars that point to config file\n        applyEnvVars(argv, false);\n        setConfig(argv);\n        setConfigObjects();\n        applyDefaultsAndAliases(argv, flags.aliases, defaults, true);\n        applyCoercions(argv);\n        if (configuration['set-placeholder-key'])\n            setPlaceholderKeys(argv);\n        // for any counts either not in args or without an explicit default, set to 0\n        Object.keys(flags.counts).forEach(function (key) {\n            if (!hasKey(argv, key.split('.')))\n                setArg(key, 0);\n        });\n        // '--' defaults to undefined.\n        if (notFlagsOption && notFlags.length)\n            argv[notFlagsArgv] = [];\n        notFlags.forEach(function (key) {\n            argv[notFlagsArgv].push(key);\n        });\n        if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {\n            Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {\n                delete argv[key];\n            });\n        }\n        if (configuration['strip-aliased']) {\n            ;\n            [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {\n                if (configuration['camel-case-expansion'] && alias.includes('-')) {\n                    delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')];\n                }\n                delete argv[alias];\n            });\n        }\n        // Push argument into positional array, applying numeric coercion:\n        function pushPositional(arg) {\n            const maybeCoercedNumber = maybeCoerceNumber('_', arg);\n            if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') {\n                argv._.push(maybeCoercedNumber);\n            }\n        }\n        // how many arguments should we consume, based\n        // on the nargs option?\n        function eatNargs(i, key, args, argAfterEqualSign) {\n            let ii;\n            let toEat = checkAllAliases(key, flags.nargs);\n            // NaN has a special meaning for the array type, indicating that one or\n            // more values are expected.\n            toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat;\n            if (toEat === 0) {\n                if (!isUndefined(argAfterEqualSign)) {\n                    error = Error(__('Argument unexpected for: %s', key));\n                }\n                setArg(key, defaultValue(key));\n                return i;\n            }\n            let available = isUndefined(argAfterEqualSign) ? 0 : 1;\n            if (configuration['nargs-eats-options']) {\n                // classic behavior, yargs eats positional and dash arguments.\n                if (args.length - (i + 1) + available < toEat) {\n                    error = Error(__('Not enough arguments following: %s', key));\n                }\n                available = toEat;\n            }\n            else {\n                // nargs will not consume flag arguments, e.g., -abc, --foo,\n                // and terminates when one is observed.\n                for (ii = i + 1; ii < args.length; ii++) {\n                    if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii]))\n                        available++;\n                    else\n                        break;\n                }\n                if (available < toEat)\n                    error = Error(__('Not enough arguments following: %s', key));\n            }\n            let consumed = Math.min(available, toEat);\n            if (!isUndefined(argAfterEqualSign) && consumed > 0) {\n                setArg(key, argAfterEqualSign);\n                consumed--;\n            }\n            for (ii = i + 1; ii < (consumed + i + 1); ii++) {\n                setArg(key, args[ii]);\n            }\n            return (i + consumed);\n        }\n        // if an option is an array, eat all non-hyphenated arguments\n        // following it... YUM!\n        // e.g., --foo apple banana cat becomes [\"apple\", \"banana\", \"cat\"]\n        function eatArray(i, key, args, argAfterEqualSign) {\n            let argsToSet = [];\n            let next = argAfterEqualSign || args[i + 1];\n            // If both array and nargs are configured, enforce the nargs count:\n            const nargsCount = checkAllAliases(key, flags.nargs);\n            if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {\n                argsToSet.push(true);\n            }\n            else if (isUndefined(next) ||\n                (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {\n                // for keys without value ==> argsToSet remains an empty []\n                // set user default value, if available\n                if (defaults[key] !== undefined) {\n                    const defVal = defaults[key];\n                    argsToSet = Array.isArray(defVal) ? defVal : [defVal];\n                }\n            }\n            else {\n                // value in --option=value is eaten as is\n                if (!isUndefined(argAfterEqualSign)) {\n                    argsToSet.push(processValue(key, argAfterEqualSign, true));\n                }\n                for (let ii = i + 1; ii < args.length; ii++) {\n                    if ((!configuration['greedy-arrays'] && argsToSet.length > 0) ||\n                        (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount))\n                        break;\n                    next = args[ii];\n                    if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))\n                        break;\n                    i = ii;\n                    argsToSet.push(processValue(key, next, inputIsString));\n                }\n            }\n            // If both array and nargs are configured, create an error if less than\n            // nargs positionals were found. NaN has special meaning, indicating\n            // that at least one value is required (more are okay).\n            if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) ||\n                (isNaN(nargsCount) && argsToSet.length === 0))) {\n                error = Error(__('Not enough arguments following: %s', key));\n            }\n            setArg(key, argsToSet);\n            return i;\n        }\n        function setArg(key, val, shouldStripQuotes = inputIsString) {\n            if (/-/.test(key) && configuration['camel-case-expansion']) {\n                const alias = key.split('.').map(function (prop) {\n                    return camelCase(prop);\n                }).join('.');\n                addNewAlias(key, alias);\n            }\n            const value = processValue(key, val, shouldStripQuotes);\n            const splitKey = key.split('.');\n            setKey(argv, splitKey, value);\n            // handle populating aliases of the full key\n            if (flags.aliases[key]) {\n                flags.aliases[key].forEach(function (x) {\n                    const keyProperties = x.split('.');\n                    setKey(argv, keyProperties, value);\n                });\n            }\n            // handle populating aliases of the first element of the dot-notation key\n            if (splitKey.length > 1 && configuration['dot-notation']) {\n                ;\n                (flags.aliases[splitKey[0]] || []).forEach(function (x) {\n                    let keyProperties = x.split('.');\n                    // expand alias with nested objects in key\n                    const a = [].concat(splitKey);\n                    a.shift(); // nuke the old key.\n                    keyProperties = keyProperties.concat(a);\n                    // populate alias only if is not already an alias of the full key\n                    // (already populated above)\n                    if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) {\n                        setKey(argv, keyProperties, value);\n                    }\n                });\n            }\n            // Set normalize getter and setter when key is in 'normalize' but isn't an array\n            if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {\n                const keys = [key].concat(flags.aliases[key] || []);\n                keys.forEach(function (key) {\n                    Object.defineProperty(argvReturn, key, {\n                        enumerable: true,\n                        get() {\n                            return val;\n                        },\n                        set(value) {\n                            val = typeof value === 'string' ? mixin.normalize(value) : value;\n                        }\n                    });\n                });\n            }\n        }\n        function addNewAlias(key, alias) {\n            if (!(flags.aliases[key] && flags.aliases[key].length)) {\n                flags.aliases[key] = [alias];\n                newAliases[alias] = true;\n            }\n            if (!(flags.aliases[alias] && flags.aliases[alias].length)) {\n                addNewAlias(alias, key);\n            }\n        }\n        function processValue(key, val, shouldStripQuotes) {\n            // strings may be quoted, clean this up as we assign values.\n            if (shouldStripQuotes) {\n                val = stripQuotes(val);\n            }\n            // handle parsing boolean arguments --foo=true --bar false.\n            if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {\n                if (typeof val === 'string')\n                    val = val === 'true';\n            }\n            let value = Array.isArray(val)\n                ? val.map(function (v) { return maybeCoerceNumber(key, v); })\n                : maybeCoerceNumber(key, val);\n            // increment a count given as arg (either no value or value parsed as boolean)\n            if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {\n                value = increment();\n            }\n            // Set normalized value when key is in 'normalize' and in 'arrays'\n            if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {\n                if (Array.isArray(val))\n                    value = val.map((val) => { return mixin.normalize(val); });\n                else\n                    value = mixin.normalize(val);\n            }\n            return value;\n        }\n        function maybeCoerceNumber(key, value) {\n            if (!configuration['parse-positional-numbers'] && key === '_')\n                return value;\n            if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {\n                const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`))));\n                if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) {\n                    value = Number(value);\n                }\n            }\n            return value;\n        }\n        // set args from config.json file, this should be\n        // applied last so that defaults can be applied.\n        function setConfig(argv) {\n            const configLookup = Object.create(null);\n            // expand defaults/aliases, in-case any happen to reference\n            // the config.json file.\n            applyDefaultsAndAliases(configLookup, flags.aliases, defaults);\n            Object.keys(flags.configs).forEach(function (configKey) {\n                const configPath = argv[configKey] || configLookup[configKey];\n                if (configPath) {\n                    try {\n                        let config = null;\n                        const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);\n                        const resolveConfig = flags.configs[configKey];\n                        if (typeof resolveConfig === 'function') {\n                            try {\n                                config = resolveConfig(resolvedConfigPath);\n                            }\n                            catch (e) {\n                                config = e;\n                            }\n                            if (config instanceof Error) {\n                                error = config;\n                                return;\n                            }\n                        }\n                        else {\n                            config = mixin.require(resolvedConfigPath);\n                        }\n                        setConfigObject(config);\n                    }\n                    catch (ex) {\n                        // Deno will receive a PermissionDenied error if an attempt is\n                        // made to load config without the --allow-read flag:\n                        if (ex.name === 'PermissionDenied')\n                            error = ex;\n                        else if (argv[configKey])\n                            error = Error(__('Invalid JSON config file: %s', configPath));\n                    }\n                }\n            });\n        }\n        // set args from config object.\n        // it recursively checks nested objects.\n        function setConfigObject(config, prev) {\n            Object.keys(config).forEach(function (key) {\n                const value = config[key];\n                const fullKey = prev ? prev + '.' + key : key;\n                // if the value is an inner object and we have dot-notation\n                // enabled, treat inner objects in config the same as\n                // heavily nested dot notations (foo.bar.apple).\n                if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) {\n                    // if the value is an object but not an array, check nested object\n                    setConfigObject(value, fullKey);\n                }\n                else {\n                    // setting arguments via CLI takes precedence over\n                    // values within the config file.\n                    if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {\n                        setArg(fullKey, value);\n                    }\n                }\n            });\n        }\n        // set all config objects passed in opts\n        function setConfigObjects() {\n            if (typeof configObjects !== 'undefined') {\n                configObjects.forEach(function (configObject) {\n                    setConfigObject(configObject);\n                });\n            }\n        }\n        function applyEnvVars(argv, configOnly) {\n            if (typeof envPrefix === 'undefined')\n                return;\n            const prefix = typeof envPrefix === 'string' ? envPrefix : '';\n            const env = mixin.env();\n            Object.keys(env).forEach(function (envVar) {\n                if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {\n                    // get array of nested keys and convert them to camel case\n                    const keys = envVar.split('__').map(function (key, i) {\n                        if (i === 0) {\n                            key = key.substring(prefix.length);\n                        }\n                        return camelCase(key);\n                    });\n                    if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {\n                        setArg(keys.join('.'), env[envVar]);\n                    }\n                }\n            });\n        }\n        function applyCoercions(argv) {\n            let coerce;\n            const applied = new Set();\n            Object.keys(argv).forEach(function (key) {\n                if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases\n                    coerce = checkAllAliases(key, flags.coercions);\n                    if (typeof coerce === 'function') {\n                        try {\n                            const value = maybeCoerceNumber(key, coerce(argv[key]));\n                            ([].concat(flags.aliases[key] || [], key)).forEach(ali => {\n                                applied.add(ali);\n                                argv[ali] = value;\n                            });\n                        }\n                        catch (err) {\n                            error = err;\n                        }\n                    }\n                }\n            });\n        }\n        function setPlaceholderKeys(argv) {\n            flags.keys.forEach((key) => {\n                // don't set placeholder keys for dot notation options 'foo.bar'.\n                if (~key.indexOf('.'))\n                    return;\n                if (typeof argv[key] === 'undefined')\n                    argv[key] = undefined;\n            });\n            return argv;\n        }\n        function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) {\n            Object.keys(defaults).forEach(function (key) {\n                if (!hasKey(obj, key.split('.'))) {\n                    setKey(obj, key.split('.'), defaults[key]);\n                    if (canLog)\n                        defaulted[key] = true;\n                    (aliases[key] || []).forEach(function (x) {\n                        if (hasKey(obj, x.split('.')))\n                            return;\n                        setKey(obj, x.split('.'), defaults[key]);\n                    });\n                }\n            });\n        }\n        function hasKey(obj, keys) {\n            let o = obj;\n            if (!configuration['dot-notation'])\n                keys = [keys.join('.')];\n            keys.slice(0, -1).forEach(function (key) {\n                o = (o[key] || {});\n            });\n            const key = keys[keys.length - 1];\n            if (typeof o !== 'object')\n                return false;\n            else\n                return key in o;\n        }\n        function setKey(obj, keys, value) {\n            let o = obj;\n            if (!configuration['dot-notation'])\n                keys = [keys.join('.')];\n            keys.slice(0, -1).forEach(function (key) {\n                // TODO(bcoe): in the next major version of yargs, switch to\n                // Object.create(null) for dot notation:\n                key = sanitizeKey(key);\n                if (typeof o === 'object' && o[key] === undefined) {\n                    o[key] = {};\n                }\n                if (typeof o[key] !== 'object' || Array.isArray(o[key])) {\n                    // ensure that o[key] is an array, and that the last item is an empty object.\n                    if (Array.isArray(o[key])) {\n                        o[key].push({});\n                    }\n                    else {\n                        o[key] = [o[key], {}];\n                    }\n                    // we want to update the empty object at the end of the o[key] array, so set o to that object\n                    o = o[key][o[key].length - 1];\n                }\n                else {\n                    o = o[key];\n                }\n            });\n            // TODO(bcoe): in the next major version of yargs, switch to\n            // Object.create(null) for dot notation:\n            const key = sanitizeKey(keys[keys.length - 1]);\n            const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays);\n            const isValueArray = Array.isArray(value);\n            let duplicate = configuration['duplicate-arguments-array'];\n            // nargs has higher priority than duplicate\n            if (!duplicate && checkAllAliases(key, flags.nargs)) {\n                duplicate = true;\n                if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {\n                    o[key] = undefined;\n                }\n            }\n            if (value === increment()) {\n                o[key] = increment(o[key]);\n            }\n            else if (Array.isArray(o[key])) {\n                if (duplicate && isTypeArray && isValueArray) {\n                    o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);\n                }\n                else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {\n                    o[key] = value;\n                }\n                else {\n                    o[key] = o[key].concat([value]);\n                }\n            }\n            else if (o[key] === undefined && isTypeArray) {\n                o[key] = isValueArray ? value : [value];\n            }\n            else if (duplicate && !(o[key] === undefined ||\n                checkAllAliases(key, flags.counts) ||\n                checkAllAliases(key, flags.bools))) {\n                o[key] = [o[key], value];\n            }\n            else {\n                o[key] = value;\n            }\n        }\n        // extend the aliases list with inferred aliases.\n        function extendAliases(...args) {\n            args.forEach(function (obj) {\n                Object.keys(obj || {}).forEach(function (key) {\n                    // short-circuit if we've already added a key\n                    // to the aliases array, for example it might\n                    // exist in both 'opts.default' and 'opts.key'.\n                    if (flags.aliases[key])\n                        return;\n                    flags.aliases[key] = [].concat(aliases[key] || []);\n                    // For \"--option-name\", also set argv.optionName\n                    flags.aliases[key].concat(key).forEach(function (x) {\n                        if (/-/.test(x) && configuration['camel-case-expansion']) {\n                            const c = camelCase(x);\n                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {\n                                flags.aliases[key].push(c);\n                                newAliases[c] = true;\n                            }\n                        }\n                    });\n                    // For \"--optionName\", also set argv['option-name']\n                    flags.aliases[key].concat(key).forEach(function (x) {\n                        if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {\n                            const c = decamelize(x, '-');\n                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {\n                                flags.aliases[key].push(c);\n                                newAliases[c] = true;\n                            }\n                        }\n                    });\n                    flags.aliases[key].forEach(function (x) {\n                        flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {\n                            return x !== y;\n                        }));\n                    });\n                });\n            });\n        }\n        function checkAllAliases(key, flag) {\n            const toCheck = [].concat(flags.aliases[key] || [], key);\n            const keys = Object.keys(flag);\n            const setAlias = toCheck.find(key => keys.includes(key));\n            return setAlias ? flag[setAlias] : false;\n        }\n        function hasAnyFlag(key) {\n            const flagsKeys = Object.keys(flags);\n            const toCheck = [].concat(flagsKeys.map(k => flags[k]));\n            return toCheck.some(function (flag) {\n                return Array.isArray(flag) ? flag.includes(key) : flag[key];\n            });\n        }\n        function hasFlagsMatching(arg, ...patterns) {\n            const toCheck = [].concat(...patterns);\n            return toCheck.some(function (pattern) {\n                const match = arg.match(pattern);\n                return match && hasAnyFlag(match[1]);\n            });\n        }\n        // based on a simplified version of the short flag group parsing logic\n        function hasAllShortFlags(arg) {\n            // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group\n            if (arg.match(negative) || !arg.match(/^-[^-]+/)) {\n                return false;\n            }\n            let hasAllFlags = true;\n            let next;\n            const letters = arg.slice(1).split('');\n            for (let j = 0; j < letters.length; j++) {\n                next = arg.slice(j + 2);\n                if (!hasAnyFlag(letters[j])) {\n                    hasAllFlags = false;\n                    break;\n                }\n                if ((letters[j + 1] && letters[j + 1] === '=') ||\n                    next === '-' ||\n                    (/[A-Za-z]/.test(letters[j]) && /^-?\\d+(\\.\\d*)?(e-?\\d+)?$/.test(next)) ||\n                    (letters[j + 1] && letters[j + 1].match(/\\W/))) {\n                    break;\n                }\n            }\n            return hasAllFlags;\n        }\n        function isUnknownOptionAsArg(arg) {\n            return configuration['unknown-options-as-args'] && isUnknownOption(arg);\n        }\n        function isUnknownOption(arg) {\n            arg = arg.replace(/^-{3,}/, '--');\n            // ignore negative numbers\n            if (arg.match(negative)) {\n                return false;\n            }\n            // if this is a short option group and all of them are configured, it isn't unknown\n            if (hasAllShortFlags(arg)) {\n                return false;\n            }\n            // e.g. '--count=2'\n            const flagWithEquals = /^-+([^=]+?)=[\\s\\S]*$/;\n            // e.g. '-a' or '--arg'\n            const normalFlag = /^-+([^=]+?)$/;\n            // e.g. '-a-'\n            const flagEndingInHyphen = /^-+([^=]+?)-$/;\n            // e.g. '-abc123'\n            const flagEndingInDigits = /^-+([^=]+?\\d+)$/;\n            // e.g. '-a/usr/local'\n            const flagEndingInNonWordCharacters = /^-+([^=]+?)\\W+.*$/;\n            // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method\n            return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);\n        }\n        // make a best effort to pick a default value\n        // for an option based on name and type.\n        function defaultValue(key) {\n            if (!checkAllAliases(key, flags.bools) &&\n                !checkAllAliases(key, flags.counts) &&\n                `${key}` in defaults) {\n                return defaults[key];\n            }\n            else {\n                return defaultForType(guessType(key));\n            }\n        }\n        // return a default value, given the type of a flag.,\n        function defaultForType(type) {\n            const def = {\n                [DefaultValuesForTypeKey.BOOLEAN]: true,\n                [DefaultValuesForTypeKey.STRING]: '',\n                [DefaultValuesForTypeKey.NUMBER]: undefined,\n                [DefaultValuesForTypeKey.ARRAY]: []\n            };\n            return def[type];\n        }\n        // given a flag, enforce a default type.\n        function guessType(key) {\n            let type = DefaultValuesForTypeKey.BOOLEAN;\n            if (checkAllAliases(key, flags.strings))\n                type = DefaultValuesForTypeKey.STRING;\n            else if (checkAllAliases(key, flags.numbers))\n                type = DefaultValuesForTypeKey.NUMBER;\n            else if (checkAllAliases(key, flags.bools))\n                type = DefaultValuesForTypeKey.BOOLEAN;\n            else if (checkAllAliases(key, flags.arrays))\n                type = DefaultValuesForTypeKey.ARRAY;\n            return type;\n        }\n        function isUndefined(num) {\n            return num === undefined;\n        }\n        // check user configuration settings for inconsistencies\n        function checkConfiguration() {\n            // count keys should not be set as array/narg\n            Object.keys(flags.counts).find(key => {\n                if (checkAllAliases(key, flags.arrays)) {\n                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key));\n                    return true;\n                }\n                else if (checkAllAliases(key, flags.nargs)) {\n                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key));\n                    return true;\n                }\n                return false;\n            });\n        }\n        return {\n            aliases: Object.assign({}, flags.aliases),\n            argv: Object.assign(argvReturn, argv),\n            configuration: configuration,\n            defaulted: Object.assign({}, defaulted),\n            error: error,\n            newAliases: Object.assign({}, newAliases)\n        };\n    }\n}\n// if any aliases reference each other, we should\n// merge them together.\nfunction combineAliases(aliases) {\n    const aliasArrays = [];\n    const combined = Object.create(null);\n    let change = true;\n    // turn alias lookup hash {key: ['alias1', 'alias2']} into\n    // a simple array ['key', 'alias1', 'alias2']\n    Object.keys(aliases).forEach(function (key) {\n        aliasArrays.push([].concat(aliases[key], key));\n    });\n    // combine arrays until zero changes are\n    // made in an iteration.\n    while (change) {\n        change = false;\n        for (let i = 0; i < aliasArrays.length; i++) {\n            for (let ii = i + 1; ii < aliasArrays.length; ii++) {\n                const intersect = aliasArrays[i].filter(function (v) {\n                    return aliasArrays[ii].indexOf(v) !== -1;\n                });\n                if (intersect.length) {\n                    aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);\n                    aliasArrays.splice(ii, 1);\n                    change = true;\n                    break;\n                }\n            }\n        }\n    }\n    // map arrays back to the hash-lookup (de-dupe while\n    // we're at it).\n    aliasArrays.forEach(function (aliasArray) {\n        aliasArray = aliasArray.filter(function (v, i, self) {\n            return self.indexOf(v) === i;\n        });\n        const lastAlias = aliasArray.pop();\n        if (lastAlias !== undefined && typeof lastAlias === 'string') {\n            combined[lastAlias] = aliasArray;\n        }\n    });\n    return combined;\n}\n// this function should only be called when a count is given as an arg\n// it is NOT called to set a default value\n// thus we can start the count at 1 instead of 0\nfunction increment(orig) {\n    return orig !== undefined ? orig + 1 : 1;\n}\n// TODO(bcoe): in the next major version of yargs, switch to\n// Object.create(null) for dot notation:\nfunction sanitizeKey(key) {\n    if (key === '__proto__')\n        return '___proto___';\n    return key;\n}\nfunction stripQuotes(val) {\n    return (typeof val === 'string' &&\n        (val[0] === \"'\" || val[0] === '\"') &&\n        val[val.length - 1] === val[0])\n        ? val.substring(1, val.length - 1)\n        : val;\n}\n","/**\n * @license\n * Copyright (c) 2016, Contributors\n * SPDX-License-Identifier: ISC\n */\n// take an un-split argv string and tokenize it.\nexport function tokenizeArgString(argString) {\n    if (Array.isArray(argString)) {\n        return argString.map(e => typeof e !== 'string' ? e + '' : e);\n    }\n    argString = argString.trim();\n    let i = 0;\n    let prevC = null;\n    let c = null;\n    let opening = null;\n    const args = [];\n    for (let ii = 0; ii < argString.length; ii++) {\n        prevC = c;\n        c = argString.charAt(ii);\n        // split on spaces unless we're in quotes.\n        if (c === ' ' && !opening) {\n            if (!(prevC === ' ')) {\n                i++;\n            }\n            continue;\n        }\n        // don't split the string if we're in matching\n        // opening or closing single and double quotes.\n        if (c === opening) {\n            opening = null;\n        }\n        else if ((c === \"'\" || c === '\"') && !opening) {\n            opening = c;\n        }\n        if (!args[i])\n            args[i] = '';\n        args[i] += c;\n    }\n    return args;\n}\n","/**\n * @license\n * Copyright (c) 2016, Contributors\n * SPDX-License-Identifier: ISC\n */\nexport var DefaultValuesForTypeKey;\n(function (DefaultValuesForTypeKey) {\n    DefaultValuesForTypeKey[\"BOOLEAN\"] = \"boolean\";\n    DefaultValuesForTypeKey[\"STRING\"] = \"string\";\n    DefaultValuesForTypeKey[\"NUMBER\"] = \"number\";\n    DefaultValuesForTypeKey[\"ARRAY\"] = \"array\";\n})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));\n","function getProcessArgvBinIndex() {\n    if (isBundledElectronApp())\n        return 0;\n    return 1;\n}\nfunction isBundledElectronApp() {\n    return isElectronApp() && !process.defaultApp;\n}\nfunction isElectronApp() {\n    return !!process.versions.electron;\n}\nexport function hideBin(argv) {\n    return argv.slice(getProcessArgvBinIndex() + 1);\n}\nexport function getProcessArgvBin() {\n    return process.argv[getProcessArgvBinIndex()];\n}\n","export class YError extends Error {\n    constructor(msg) {\n        super(msg || 'yargs error');\n        this.name = 'YError';\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, YError);\n        }\n    }\n}\n","import shim from './build/lib/platform-shims/node.js'\nimport { y18n as _y18n } from './build/lib/index.js'\n\nconst y18n = (opts) => {\n  return _y18n(opts, shim)\n}\n\nexport default y18n\n","import { readFileSync, statSync, writeFile } from 'fs';\nimport { format } from 'util';\nimport { resolve } from 'path';\nexport default {\n    fs: {\n        readFileSync,\n        writeFile\n    },\n    format,\n    resolve,\n    exists: (file) => {\n        try {\n            return statSync(file).isFile();\n        }\n        catch (err) {\n            return false;\n        }\n    }\n};\n","let shim;\nclass Y18N {\n    constructor(opts) {\n        // configurable options.\n        opts = opts || {};\n        this.directory = opts.directory || './locales';\n        this.updateFiles = typeof opts.updateFiles === 'boolean' ? opts.updateFiles : true;\n        this.locale = opts.locale || 'en';\n        this.fallbackToLanguage = typeof opts.fallbackToLanguage === 'boolean' ? opts.fallbackToLanguage : true;\n        // internal stuff.\n        this.cache = Object.create(null);\n        this.writeQueue = [];\n    }\n    __(...args) {\n        if (typeof arguments[0] !== 'string') {\n            return this._taggedLiteral(arguments[0], ...arguments);\n        }\n        const str = args.shift();\n        let cb = function () { }; // start with noop.\n        if (typeof args[args.length - 1] === 'function')\n            cb = args.pop();\n        cb = cb || function () { }; // noop.\n        if (!this.cache[this.locale])\n            this._readLocaleFile();\n        // we've observed a new string, update the language file.\n        if (!this.cache[this.locale][str] && this.updateFiles) {\n            this.cache[this.locale][str] = str;\n            // include the current directory and locale,\n            // since these values could change before the\n            // write is performed.\n            this._enqueueWrite({\n                directory: this.directory,\n                locale: this.locale,\n                cb\n            });\n        }\n        else {\n            cb();\n        }\n        return shim.format.apply(shim.format, [this.cache[this.locale][str] || str].concat(args));\n    }\n    __n() {\n        const args = Array.prototype.slice.call(arguments);\n        const singular = args.shift();\n        const plural = args.shift();\n        const quantity = args.shift();\n        let cb = function () { }; // start with noop.\n        if (typeof args[args.length - 1] === 'function')\n            cb = args.pop();\n        if (!this.cache[this.locale])\n            this._readLocaleFile();\n        let str = quantity === 1 ? singular : plural;\n        if (this.cache[this.locale][singular]) {\n            const entry = this.cache[this.locale][singular];\n            str = entry[quantity === 1 ? 'one' : 'other'];\n        }\n        // we've observed a new string, update the language file.\n        if (!this.cache[this.locale][singular] && this.updateFiles) {\n            this.cache[this.locale][singular] = {\n                one: singular,\n                other: plural\n            };\n            // include the current directory and locale,\n            // since these values could change before the\n            // write is performed.\n            this._enqueueWrite({\n                directory: this.directory,\n                locale: this.locale,\n                cb\n            });\n        }\n        else {\n            cb();\n        }\n        // if a %d placeholder is provided, add quantity\n        // to the arguments expanded by util.format.\n        const values = [str];\n        if (~str.indexOf('%d'))\n            values.push(quantity);\n        return shim.format.apply(shim.format, values.concat(args));\n    }\n    setLocale(locale) {\n        this.locale = locale;\n    }\n    getLocale() {\n        return this.locale;\n    }\n    updateLocale(obj) {\n        if (!this.cache[this.locale])\n            this._readLocaleFile();\n        for (const key in obj) {\n            if (Object.prototype.hasOwnProperty.call(obj, key)) {\n                this.cache[this.locale][key] = obj[key];\n            }\n        }\n    }\n    _taggedLiteral(parts, ...args) {\n        let str = '';\n        parts.forEach(function (part, i) {\n            const arg = args[i + 1];\n            str += part;\n            if (typeof arg !== 'undefined') {\n                str += '%s';\n            }\n        });\n        return this.__.apply(this, [str].concat([].slice.call(args, 1)));\n    }\n    _enqueueWrite(work) {\n        this.writeQueue.push(work);\n        if (this.writeQueue.length === 1)\n            this._processWriteQueue();\n    }\n    _processWriteQueue() {\n        const _this = this;\n        const work = this.writeQueue[0];\n        // destructure the enqueued work.\n        const directory = work.directory;\n        const locale = work.locale;\n        const cb = work.cb;\n        const languageFile = this._resolveLocaleFile(directory, locale);\n        const serializedLocale = JSON.stringify(this.cache[locale], null, 2);\n        shim.fs.writeFile(languageFile, serializedLocale, 'utf-8', function (err) {\n            _this.writeQueue.shift();\n            if (_this.writeQueue.length > 0)\n                _this._processWriteQueue();\n            cb(err);\n        });\n    }\n    _readLocaleFile() {\n        let localeLookup = {};\n        const languageFile = this._resolveLocaleFile(this.directory, this.locale);\n        try {\n            // When using a bundler such as webpack, readFileSync may not be defined:\n            if (shim.fs.readFileSync) {\n                localeLookup = JSON.parse(shim.fs.readFileSync(languageFile, 'utf-8'));\n            }\n        }\n        catch (err) {\n            if (err instanceof SyntaxError) {\n                err.message = 'syntax error in ' + languageFile;\n            }\n            if (err.code === 'ENOENT')\n                localeLookup = {};\n            else\n                throw err;\n        }\n        this.cache[this.locale] = localeLookup;\n    }\n    _resolveLocaleFile(directory, locale) {\n        let file = shim.resolve(directory, './', locale + '.json');\n        if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf('_')) {\n            // attempt fallback to language only\n            const languageFile = shim.resolve(directory, './', locale.split('_')[0] + '.json');\n            if (this._fileExistsSync(languageFile))\n                file = languageFile;\n        }\n        return file;\n    }\n    _fileExistsSync(file) {\n        return shim.exists(file);\n    }\n}\nexport function y18n(opts, _shim) {\n    shim = _shim;\n    const y18n = new Y18N(opts);\n    return {\n        __: y18n.__.bind(y18n),\n        __n: y18n.__n.bind(y18n),\n        setLocale: y18n.setLocale.bind(y18n),\n        getLocale: y18n.getLocale.bind(y18n),\n        updateLocale: y18n.updateLocale.bind(y18n),\n        locale: y18n.locale\n    };\n}\n","var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _YargsInstance_command, _YargsInstance_cwd, _YargsInstance_context, _YargsInstance_completion, _YargsInstance_completionCommand, _YargsInstance_defaultShowHiddenOpt, _YargsInstance_exitError, _YargsInstance_detectLocale, _YargsInstance_emittedWarnings, _YargsInstance_exitProcess, _YargsInstance_frozens, _YargsInstance_globalMiddleware, _YargsInstance_groups, _YargsInstance_hasOutput, _YargsInstance_helpOpt, _YargsInstance_isGlobalContext, _YargsInstance_logger, _YargsInstance_output, _YargsInstance_options, _YargsInstance_parentRequire, _YargsInstance_parserConfig, _YargsInstance_parseFn, _YargsInstance_parseContext, _YargsInstance_pkgs, _YargsInstance_preservedGroups, _YargsInstance_processArgs, _YargsInstance_recommendCommands, _YargsInstance_shim, _YargsInstance_strict, _YargsInstance_strictCommands, _YargsInstance_strictOptions, _YargsInstance_usage, _YargsInstance_usageConfig, _YargsInstance_versionOpt, _YargsInstance_validation;\nimport { command as Command, } from './command.js';\nimport { assertNotStrictEqual, assertSingleKey, objectKeys, } from './typings/common-types.js';\nimport { YError } from './yerror.js';\nimport { usage as Usage } from './usage.js';\nimport { argsert } from './argsert.js';\nimport { completion as Completion, } from './completion.js';\nimport { validation as Validation, } from './validation.js';\nimport { objFilter } from './utils/obj-filter.js';\nimport { applyExtends } from './utils/apply-extends.js';\nimport { applyMiddleware, GlobalMiddleware, } from './middleware.js';\nimport { isPromise } from './utils/is-promise.js';\nimport { maybeAsyncResult } from './utils/maybe-async-result.js';\nimport setBlocking from './utils/set-blocking.js';\nexport function YargsFactory(_shim) {\n    return (processArgs = [], cwd = _shim.process.cwd(), parentRequire) => {\n        const yargs = new YargsInstance(processArgs, cwd, parentRequire, _shim);\n        Object.defineProperty(yargs, 'argv', {\n            get: () => {\n                return yargs.parse();\n            },\n            enumerable: true,\n        });\n        yargs.help();\n        yargs.version();\n        return yargs;\n    };\n}\nconst kCopyDoubleDash = Symbol('copyDoubleDash');\nconst kCreateLogger = Symbol('copyDoubleDash');\nconst kDeleteFromParserHintObject = Symbol('deleteFromParserHintObject');\nconst kEmitWarning = Symbol('emitWarning');\nconst kFreeze = Symbol('freeze');\nconst kGetDollarZero = Symbol('getDollarZero');\nconst kGetParserConfiguration = Symbol('getParserConfiguration');\nconst kGetUsageConfiguration = Symbol('getUsageConfiguration');\nconst kGuessLocale = Symbol('guessLocale');\nconst kGuessVersion = Symbol('guessVersion');\nconst kParsePositionalNumbers = Symbol('parsePositionalNumbers');\nconst kPkgUp = Symbol('pkgUp');\nconst kPopulateParserHintArray = Symbol('populateParserHintArray');\nconst kPopulateParserHintSingleValueDictionary = Symbol('populateParserHintSingleValueDictionary');\nconst kPopulateParserHintArrayDictionary = Symbol('populateParserHintArrayDictionary');\nconst kPopulateParserHintDictionary = Symbol('populateParserHintDictionary');\nconst kSanitizeKey = Symbol('sanitizeKey');\nconst kSetKey = Symbol('setKey');\nconst kUnfreeze = Symbol('unfreeze');\nconst kValidateAsync = Symbol('validateAsync');\nconst kGetCommandInstance = Symbol('getCommandInstance');\nconst kGetContext = Symbol('getContext');\nconst kGetHasOutput = Symbol('getHasOutput');\nconst kGetLoggerInstance = Symbol('getLoggerInstance');\nconst kGetParseContext = Symbol('getParseContext');\nconst kGetUsageInstance = Symbol('getUsageInstance');\nconst kGetValidationInstance = Symbol('getValidationInstance');\nconst kHasParseCallback = Symbol('hasParseCallback');\nconst kIsGlobalContext = Symbol('isGlobalContext');\nconst kPostProcess = Symbol('postProcess');\nconst kRebase = Symbol('rebase');\nconst kReset = Symbol('reset');\nconst kRunYargsParserAndExecuteCommands = Symbol('runYargsParserAndExecuteCommands');\nconst kRunValidation = Symbol('runValidation');\nconst kSetHasOutput = Symbol('setHasOutput');\nconst kTrackManuallySetKeys = Symbol('kTrackManuallySetKeys');\nexport class YargsInstance {\n    constructor(processArgs = [], cwd, parentRequire, shim) {\n        this.customScriptName = false;\n        this.parsed = false;\n        _YargsInstance_command.set(this, void 0);\n        _YargsInstance_cwd.set(this, void 0);\n        _YargsInstance_context.set(this, { commands: [], fullCommands: [] });\n        _YargsInstance_completion.set(this, null);\n        _YargsInstance_completionCommand.set(this, null);\n        _YargsInstance_defaultShowHiddenOpt.set(this, 'show-hidden');\n        _YargsInstance_exitError.set(this, null);\n        _YargsInstance_detectLocale.set(this, true);\n        _YargsInstance_emittedWarnings.set(this, {});\n        _YargsInstance_exitProcess.set(this, true);\n        _YargsInstance_frozens.set(this, []);\n        _YargsInstance_globalMiddleware.set(this, void 0);\n        _YargsInstance_groups.set(this, {});\n        _YargsInstance_hasOutput.set(this, false);\n        _YargsInstance_helpOpt.set(this, null);\n        _YargsInstance_isGlobalContext.set(this, true);\n        _YargsInstance_logger.set(this, void 0);\n        _YargsInstance_output.set(this, '');\n        _YargsInstance_options.set(this, void 0);\n        _YargsInstance_parentRequire.set(this, void 0);\n        _YargsInstance_parserConfig.set(this, {});\n        _YargsInstance_parseFn.set(this, null);\n        _YargsInstance_parseContext.set(this, null);\n        _YargsInstance_pkgs.set(this, {});\n        _YargsInstance_preservedGroups.set(this, {});\n        _YargsInstance_processArgs.set(this, void 0);\n        _YargsInstance_recommendCommands.set(this, false);\n        _YargsInstance_shim.set(this, void 0);\n        _YargsInstance_strict.set(this, false);\n        _YargsInstance_strictCommands.set(this, false);\n        _YargsInstance_strictOptions.set(this, false);\n        _YargsInstance_usage.set(this, void 0);\n        _YargsInstance_usageConfig.set(this, {});\n        _YargsInstance_versionOpt.set(this, null);\n        _YargsInstance_validation.set(this, void 0);\n        __classPrivateFieldSet(this, _YargsInstance_shim, shim, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_processArgs, processArgs, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_cwd, cwd, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_parentRequire, parentRequire, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_globalMiddleware, new GlobalMiddleware(this), \"f\");\n        this.$0 = this[kGetDollarZero]();\n        this[kReset]();\n        __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, \"f\"), \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, \"f\"), \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, \"f\"), \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, \"f\"), \"f\");\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").showHiddenOpt = __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_logger, this[kCreateLogger](), \"f\");\n    }\n    addHelpOpt(opt, msg) {\n        const defaultHelpOpt = 'help';\n        argsert('[string|boolean] [string]', [opt, msg], arguments.length);\n        if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\")) {\n            this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\"));\n            __classPrivateFieldSet(this, _YargsInstance_helpOpt, null, \"f\");\n        }\n        if (opt === false && msg === undefined)\n            return this;\n        __classPrivateFieldSet(this, _YargsInstance_helpOpt, typeof opt === 'string' ? opt : defaultHelpOpt, \"f\");\n        this.boolean(__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\"));\n        this.describe(__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\"), msg || __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").deferY18nLookup('Show help'));\n        return this;\n    }\n    help(opt, msg) {\n        return this.addHelpOpt(opt, msg);\n    }\n    addShowHiddenOpt(opt, msg) {\n        argsert('[string|boolean] [string]', [opt, msg], arguments.length);\n        if (opt === false && msg === undefined)\n            return this;\n        const showHiddenOpt = typeof opt === 'string' ? opt : __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, \"f\");\n        this.boolean(showHiddenOpt);\n        this.describe(showHiddenOpt, msg || __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").deferY18nLookup('Show hidden options'));\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").showHiddenOpt = showHiddenOpt;\n        return this;\n    }\n    showHidden(opt, msg) {\n        return this.addShowHiddenOpt(opt, msg);\n    }\n    alias(key, value) {\n        argsert('<object|string|array> [string|array]', [key, value], arguments.length);\n        this[kPopulateParserHintArrayDictionary](this.alias.bind(this), 'alias', key, value);\n        return this;\n    }\n    array(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('array', keys);\n        this[kTrackManuallySetKeys](keys);\n        return this;\n    }\n    boolean(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('boolean', keys);\n        this[kTrackManuallySetKeys](keys);\n        return this;\n    }\n    check(f, global) {\n        argsert('<function> [boolean]', [f, global], arguments.length);\n        this.middleware((argv, _yargs) => {\n            return maybeAsyncResult(() => {\n                return f(argv, _yargs.getOptions());\n            }, (result) => {\n                if (!result) {\n                    __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").fail(__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").y18n.__('Argument check failed: %s', f.toString()));\n                }\n                else if (typeof result === 'string' || result instanceof Error) {\n                    __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").fail(result.toString(), result);\n                }\n                return argv;\n            }, (err) => {\n                __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").fail(err.message ? err.message : err.toString(), err);\n                return argv;\n            });\n        }, false, global);\n        return this;\n    }\n    choices(key, value) {\n        argsert('<object|string|array> [string|array]', [key, value], arguments.length);\n        this[kPopulateParserHintArrayDictionary](this.choices.bind(this), 'choices', key, value);\n        return this;\n    }\n    coerce(keys, value) {\n        argsert('<object|string|array> [function]', [keys, value], arguments.length);\n        if (Array.isArray(keys)) {\n            if (!value) {\n                throw new YError('coerce callback must be provided');\n            }\n            for (const key of keys) {\n                this.coerce(key, value);\n            }\n            return this;\n        }\n        else if (typeof keys === 'object') {\n            for (const key of Object.keys(keys)) {\n                this.coerce(key, keys[key]);\n            }\n            return this;\n        }\n        if (!value) {\n            throw new YError('coerce callback must be provided');\n        }\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").key[keys] = true;\n        __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").addCoerceMiddleware((argv, yargs) => {\n            let aliases;\n            const shouldCoerce = Object.prototype.hasOwnProperty.call(argv, keys);\n            if (!shouldCoerce) {\n                return argv;\n            }\n            return maybeAsyncResult(() => {\n                aliases = yargs.getAliases();\n                return value(argv[keys]);\n            }, (result) => {\n                argv[keys] = result;\n                const stripAliased = yargs\n                    .getInternalMethods()\n                    .getParserConfiguration()['strip-aliased'];\n                if (aliases[keys] && stripAliased !== true) {\n                    for (const alias of aliases[keys]) {\n                        argv[alias] = result;\n                    }\n                }\n                return argv;\n            }, (err) => {\n                throw new YError(err.message);\n            });\n        }, keys);\n        return this;\n    }\n    conflicts(key1, key2) {\n        argsert('<string|object> [string|array]', [key1, key2], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").conflicts(key1, key2);\n        return this;\n    }\n    config(key = 'config', msg, parseFn) {\n        argsert('[object|string] [string|function] [function]', [key, msg, parseFn], arguments.length);\n        if (typeof key === 'object' && !Array.isArray(key)) {\n            key = applyExtends(key, __classPrivateFieldGet(this, _YargsInstance_cwd, \"f\"), this[kGetParserConfiguration]()['deep-merge-config'] || false, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects || []).concat(key);\n            return this;\n        }\n        if (typeof msg === 'function') {\n            parseFn = msg;\n            msg = undefined;\n        }\n        this.describe(key, msg || __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").deferY18nLookup('Path to JSON config file'));\n        (Array.isArray(key) ? key : [key]).forEach(k => {\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").config[k] = parseFn || true;\n        });\n        return this;\n    }\n    completion(cmd, desc, fn) {\n        argsert('[string] [string|boolean|function] [function]', [cmd, desc, fn], arguments.length);\n        if (typeof desc === 'function') {\n            fn = desc;\n            desc = undefined;\n        }\n        __classPrivateFieldSet(this, _YargsInstance_completionCommand, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\") || 'completion', \"f\");\n        if (!desc && desc !== false) {\n            desc = 'generate completion script';\n        }\n        this.command(__classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\"), desc);\n        if (fn)\n            __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").registerFunction(fn);\n        return this;\n    }\n    command(cmd, description, builder, handler, middlewares, deprecated) {\n        argsert('<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]', [cmd, description, builder, handler, middlewares, deprecated], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_command, \"f\").addHandler(cmd, description, builder, handler, middlewares, deprecated);\n        return this;\n    }\n    commands(cmd, description, builder, handler, middlewares, deprecated) {\n        return this.command(cmd, description, builder, handler, middlewares, deprecated);\n    }\n    commandDir(dir, opts) {\n        argsert('<string> [object]', [dir, opts], arguments.length);\n        const req = __classPrivateFieldGet(this, _YargsInstance_parentRequire, \"f\") || __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").require;\n        __classPrivateFieldGet(this, _YargsInstance_command, \"f\").addDirectory(dir, req, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getCallerFile(), opts);\n        return this;\n    }\n    count(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('count', keys);\n        this[kTrackManuallySetKeys](keys);\n        return this;\n    }\n    default(key, value, defaultDescription) {\n        argsert('<object|string|array> [*] [string]', [key, value, defaultDescription], arguments.length);\n        if (defaultDescription) {\n            assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").defaultDescription[key] = defaultDescription;\n        }\n        if (typeof value === 'function') {\n            assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            if (!__classPrivateFieldGet(this, _YargsInstance_options, \"f\").defaultDescription[key])\n                __classPrivateFieldGet(this, _YargsInstance_options, \"f\").defaultDescription[key] =\n                    __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").functionDescription(value);\n            value = value.call();\n        }\n        this[kPopulateParserHintSingleValueDictionary](this.default.bind(this), 'default', key, value);\n        return this;\n    }\n    defaults(key, value, defaultDescription) {\n        return this.default(key, value, defaultDescription);\n    }\n    demandCommand(min = 1, max, minMsg, maxMsg) {\n        argsert('[number] [number|string] [string|null|undefined] [string|null|undefined]', [min, max, minMsg, maxMsg], arguments.length);\n        if (typeof max !== 'number') {\n            minMsg = max;\n            max = Infinity;\n        }\n        this.global('_', false);\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").demandedCommands._ = {\n            min,\n            max,\n            minMsg,\n            maxMsg,\n        };\n        return this;\n    }\n    demand(keys, max, msg) {\n        if (Array.isArray(max)) {\n            max.forEach(key => {\n                assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n                this.demandOption(key, msg);\n            });\n            max = Infinity;\n        }\n        else if (typeof max !== 'number') {\n            msg = max;\n            max = Infinity;\n        }\n        if (typeof keys === 'number') {\n            assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            this.demandCommand(keys, max, msg, msg);\n        }\n        else if (Array.isArray(keys)) {\n            keys.forEach(key => {\n                assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n                this.demandOption(key, msg);\n            });\n        }\n        else {\n            if (typeof msg === 'string') {\n                this.demandOption(keys, msg);\n            }\n            else if (msg === true || typeof msg === 'undefined') {\n                this.demandOption(keys);\n            }\n        }\n        return this;\n    }\n    demandOption(keys, msg) {\n        argsert('<object|string|array> [string]', [keys, msg], arguments.length);\n        this[kPopulateParserHintSingleValueDictionary](this.demandOption.bind(this), 'demandedOptions', keys, msg);\n        return this;\n    }\n    deprecateOption(option, message) {\n        argsert('<string> [string|boolean]', [option, message], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").deprecatedOptions[option] = message;\n        return this;\n    }\n    describe(keys, description) {\n        argsert('<object|string|array> [string]', [keys, description], arguments.length);\n        this[kSetKey](keys, true);\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").describe(keys, description);\n        return this;\n    }\n    detectLocale(detect) {\n        argsert('<boolean>', [detect], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_detectLocale, detect, \"f\");\n        return this;\n    }\n    env(prefix) {\n        argsert('[string|boolean]', [prefix], arguments.length);\n        if (prefix === false)\n            delete __classPrivateFieldGet(this, _YargsInstance_options, \"f\").envPrefix;\n        else\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").envPrefix = prefix || '';\n        return this;\n    }\n    epilogue(msg) {\n        argsert('<string>', [msg], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").epilog(msg);\n        return this;\n    }\n    epilog(msg) {\n        return this.epilogue(msg);\n    }\n    example(cmd, description) {\n        argsert('<string|array> [string]', [cmd, description], arguments.length);\n        if (Array.isArray(cmd)) {\n            cmd.forEach(exampleParams => this.example(...exampleParams));\n        }\n        else {\n            __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").example(cmd, description);\n        }\n        return this;\n    }\n    exit(code, err) {\n        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_exitError, err, \"f\");\n        if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"))\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.exit(code);\n    }\n    exitProcess(enabled = true) {\n        argsert('[boolean]', [enabled], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_exitProcess, enabled, \"f\");\n        return this;\n    }\n    fail(f) {\n        argsert('<function|boolean>', [f], arguments.length);\n        if (typeof f === 'boolean' && f !== false) {\n            throw new YError(\"Invalid first argument. Expected function or boolean 'false'\");\n        }\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").failFn(f);\n        return this;\n    }\n    getAliases() {\n        return this.parsed ? this.parsed.aliases : {};\n    }\n    async getCompletion(args, done) {\n        argsert('<array> [function]', [args, done], arguments.length);\n        if (!done) {\n            return new Promise((resolve, reject) => {\n                __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").getCompletion(args, (err, completions) => {\n                    if (err)\n                        reject(err);\n                    else\n                        resolve(completions);\n                });\n            });\n        }\n        else {\n            return __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").getCompletion(args, done);\n        }\n    }\n    getDemandedOptions() {\n        argsert([], 0);\n        return __classPrivateFieldGet(this, _YargsInstance_options, \"f\").demandedOptions;\n    }\n    getDemandedCommands() {\n        argsert([], 0);\n        return __classPrivateFieldGet(this, _YargsInstance_options, \"f\").demandedCommands;\n    }\n    getDeprecatedOptions() {\n        argsert([], 0);\n        return __classPrivateFieldGet(this, _YargsInstance_options, \"f\").deprecatedOptions;\n    }\n    getDetectLocale() {\n        return __classPrivateFieldGet(this, _YargsInstance_detectLocale, \"f\");\n    }\n    getExitProcess() {\n        return __classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\");\n    }\n    getGroups() {\n        return Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_groups, \"f\"), __classPrivateFieldGet(this, _YargsInstance_preservedGroups, \"f\"));\n    }\n    getHelp() {\n        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n        if (!__classPrivateFieldGet(this, _YargsInstance_usage, \"f\").hasCachedHelpMessage()) {\n            if (!this.parsed) {\n                const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, \"f\"), undefined, undefined, 0, true);\n                if (isPromise(parse)) {\n                    return parse.then(() => {\n                        return __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").help();\n                    });\n                }\n            }\n            const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, \"f\").runDefaultBuilderOn(this);\n            if (isPromise(builderResponse)) {\n                return builderResponse.then(() => {\n                    return __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").help();\n                });\n            }\n        }\n        return Promise.resolve(__classPrivateFieldGet(this, _YargsInstance_usage, \"f\").help());\n    }\n    getOptions() {\n        return __classPrivateFieldGet(this, _YargsInstance_options, \"f\");\n    }\n    getStrict() {\n        return __classPrivateFieldGet(this, _YargsInstance_strict, \"f\");\n    }\n    getStrictCommands() {\n        return __classPrivateFieldGet(this, _YargsInstance_strictCommands, \"f\");\n    }\n    getStrictOptions() {\n        return __classPrivateFieldGet(this, _YargsInstance_strictOptions, \"f\");\n    }\n    global(globals, global) {\n        argsert('<string|array> [boolean]', [globals, global], arguments.length);\n        globals = [].concat(globals);\n        if (global !== false) {\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").local = __classPrivateFieldGet(this, _YargsInstance_options, \"f\").local.filter(l => globals.indexOf(l) === -1);\n        }\n        else {\n            globals.forEach(g => {\n                if (!__classPrivateFieldGet(this, _YargsInstance_options, \"f\").local.includes(g))\n                    __classPrivateFieldGet(this, _YargsInstance_options, \"f\").local.push(g);\n            });\n        }\n        return this;\n    }\n    group(opts, groupName) {\n        argsert('<string|array> <string>', [opts, groupName], arguments.length);\n        const existing = __classPrivateFieldGet(this, _YargsInstance_preservedGroups, \"f\")[groupName] || __classPrivateFieldGet(this, _YargsInstance_groups, \"f\")[groupName];\n        if (__classPrivateFieldGet(this, _YargsInstance_preservedGroups, \"f\")[groupName]) {\n            delete __classPrivateFieldGet(this, _YargsInstance_preservedGroups, \"f\")[groupName];\n        }\n        const seen = {};\n        __classPrivateFieldGet(this, _YargsInstance_groups, \"f\")[groupName] = (existing || []).concat(opts).filter(key => {\n            if (seen[key])\n                return false;\n            return (seen[key] = true);\n        });\n        return this;\n    }\n    hide(key) {\n        argsert('<string>', [key], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").hiddenOptions.push(key);\n        return this;\n    }\n    implies(key, value) {\n        argsert('<string|object> [number|string|array]', [key, value], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").implies(key, value);\n        return this;\n    }\n    locale(locale) {\n        argsert('[string]', [locale], arguments.length);\n        if (locale === undefined) {\n            this[kGuessLocale]();\n            return __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").y18n.getLocale();\n        }\n        __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, \"f\");\n        __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").y18n.setLocale(locale);\n        return this;\n    }\n    middleware(callback, applyBeforeValidation, global) {\n        return __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").addMiddleware(callback, !!applyBeforeValidation, global);\n    }\n    nargs(key, value) {\n        argsert('<string|object|array> [number]', [key, value], arguments.length);\n        this[kPopulateParserHintSingleValueDictionary](this.nargs.bind(this), 'narg', key, value);\n        return this;\n    }\n    normalize(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('normalize', keys);\n        return this;\n    }\n    number(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('number', keys);\n        this[kTrackManuallySetKeys](keys);\n        return this;\n    }\n    option(key, opt) {\n        argsert('<string|object> [object]', [key, opt], arguments.length);\n        if (typeof key === 'object') {\n            Object.keys(key).forEach(k => {\n                this.options(k, key[k]);\n            });\n        }\n        else {\n            if (typeof opt !== 'object') {\n                opt = {};\n            }\n            this[kTrackManuallySetKeys](key);\n            if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\") && (key === 'version' || (opt === null || opt === void 0 ? void 0 : opt.alias) === 'version')) {\n                this[kEmitWarning]([\n                    '\"version\" is a reserved word.',\n                    'Please do one of the following:',\n                    '- Disable version with `yargs.version(false)` if using \"version\" as an option',\n                    '- Use the built-in `yargs.version` method instead (if applicable)',\n                    '- Use a different option key',\n                    'https://yargs.js.org/docs/#api-reference-version',\n                ].join('\\n'), undefined, 'versionWarning');\n            }\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").key[key] = true;\n            if (opt.alias)\n                this.alias(key, opt.alias);\n            const deprecate = opt.deprecate || opt.deprecated;\n            if (deprecate) {\n                this.deprecateOption(key, deprecate);\n            }\n            const demand = opt.demand || opt.required || opt.require;\n            if (demand) {\n                this.demand(key, demand);\n            }\n            if (opt.demandOption) {\n                this.demandOption(key, typeof opt.demandOption === 'string' ? opt.demandOption : undefined);\n            }\n            if (opt.conflicts) {\n                this.conflicts(key, opt.conflicts);\n            }\n            if ('default' in opt) {\n                this.default(key, opt.default);\n            }\n            if (opt.implies !== undefined) {\n                this.implies(key, opt.implies);\n            }\n            if (opt.nargs !== undefined) {\n                this.nargs(key, opt.nargs);\n            }\n            if (opt.config) {\n                this.config(key, opt.configParser);\n            }\n            if (opt.normalize) {\n                this.normalize(key);\n            }\n            if (opt.choices) {\n                this.choices(key, opt.choices);\n            }\n            if (opt.coerce) {\n                this.coerce(key, opt.coerce);\n            }\n            if (opt.group) {\n                this.group(key, opt.group);\n            }\n            if (opt.boolean || opt.type === 'boolean') {\n                this.boolean(key);\n                if (opt.alias)\n                    this.boolean(opt.alias);\n            }\n            if (opt.array || opt.type === 'array') {\n                this.array(key);\n                if (opt.alias)\n                    this.array(opt.alias);\n            }\n            if (opt.number || opt.type === 'number') {\n                this.number(key);\n                if (opt.alias)\n                    this.number(opt.alias);\n            }\n            if (opt.string || opt.type === 'string') {\n                this.string(key);\n                if (opt.alias)\n                    this.string(opt.alias);\n            }\n            if (opt.count || opt.type === 'count') {\n                this.count(key);\n            }\n            if (typeof opt.global === 'boolean') {\n                this.global(key, opt.global);\n            }\n            if (opt.defaultDescription) {\n                __classPrivateFieldGet(this, _YargsInstance_options, \"f\").defaultDescription[key] = opt.defaultDescription;\n            }\n            if (opt.skipValidation) {\n                this.skipValidation(key);\n            }\n            const desc = opt.describe || opt.description || opt.desc;\n            const descriptions = __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").getDescriptions();\n            if (!Object.prototype.hasOwnProperty.call(descriptions, key) ||\n                typeof desc === 'string') {\n                this.describe(key, desc);\n            }\n            if (opt.hidden) {\n                this.hide(key);\n            }\n            if (opt.requiresArg) {\n                this.requiresArg(key);\n            }\n        }\n        return this;\n    }\n    options(key, opt) {\n        return this.option(key, opt);\n    }\n    parse(args, shortCircuit, _parseFn) {\n        argsert('[string|array] [function|boolean|object] [function]', [args, shortCircuit, _parseFn], arguments.length);\n        this[kFreeze]();\n        if (typeof args === 'undefined') {\n            args = __classPrivateFieldGet(this, _YargsInstance_processArgs, \"f\");\n        }\n        if (typeof shortCircuit === 'object') {\n            __classPrivateFieldSet(this, _YargsInstance_parseContext, shortCircuit, \"f\");\n            shortCircuit = _parseFn;\n        }\n        if (typeof shortCircuit === 'function') {\n            __classPrivateFieldSet(this, _YargsInstance_parseFn, shortCircuit, \"f\");\n            shortCircuit = false;\n        }\n        if (!shortCircuit)\n            __classPrivateFieldSet(this, _YargsInstance_processArgs, args, \"f\");\n        if (__classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\"))\n            __classPrivateFieldSet(this, _YargsInstance_exitProcess, false, \"f\");\n        const parsed = this[kRunYargsParserAndExecuteCommands](args, !!shortCircuit);\n        const tmpParsed = this.parsed;\n        __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").setParsed(this.parsed);\n        if (isPromise(parsed)) {\n            return parsed\n                .then(argv => {\n                if (__classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\"))\n                    __classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, \"f\"), argv, __classPrivateFieldGet(this, _YargsInstance_output, \"f\"));\n                return argv;\n            })\n                .catch(err => {\n                if (__classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\")) {\n                    __classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\")(err, this.parsed.argv, __classPrivateFieldGet(this, _YargsInstance_output, \"f\"));\n                }\n                throw err;\n            })\n                .finally(() => {\n                this[kUnfreeze]();\n                this.parsed = tmpParsed;\n            });\n        }\n        else {\n            if (__classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\"))\n                __classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, \"f\"), parsed, __classPrivateFieldGet(this, _YargsInstance_output, \"f\"));\n            this[kUnfreeze]();\n            this.parsed = tmpParsed;\n        }\n        return parsed;\n    }\n    parseAsync(args, shortCircuit, _parseFn) {\n        const maybePromise = this.parse(args, shortCircuit, _parseFn);\n        return !isPromise(maybePromise)\n            ? Promise.resolve(maybePromise)\n            : maybePromise;\n    }\n    parseSync(args, shortCircuit, _parseFn) {\n        const maybePromise = this.parse(args, shortCircuit, _parseFn);\n        if (isPromise(maybePromise)) {\n            throw new YError('.parseSync() must not be used with asynchronous builders, handlers, or middleware');\n        }\n        return maybePromise;\n    }\n    parserConfiguration(config) {\n        argsert('<object>', [config], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_parserConfig, config, \"f\");\n        return this;\n    }\n    pkgConf(key, rootPath) {\n        argsert('<string> [string]', [key, rootPath], arguments.length);\n        let conf = null;\n        const obj = this[kPkgUp](rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, \"f\"));\n        if (obj[key] && typeof obj[key] === 'object') {\n            conf = applyExtends(obj[key], rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, \"f\"), this[kGetParserConfiguration]()['deep-merge-config'] || false, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects || []).concat(conf);\n        }\n        return this;\n    }\n    positional(key, opts) {\n        argsert('<string> <object>', [key, opts], arguments.length);\n        const supportedOpts = [\n            'default',\n            'defaultDescription',\n            'implies',\n            'normalize',\n            'choices',\n            'conflicts',\n            'coerce',\n            'type',\n            'describe',\n            'desc',\n            'description',\n            'alias',\n        ];\n        opts = objFilter(opts, (k, v) => {\n            if (k === 'type' && !['string', 'number', 'boolean'].includes(v))\n                return false;\n            return supportedOpts.includes(k);\n        });\n        const fullCommand = __classPrivateFieldGet(this, _YargsInstance_context, \"f\").fullCommands[__classPrivateFieldGet(this, _YargsInstance_context, \"f\").fullCommands.length - 1];\n        const parseOptions = fullCommand\n            ? __classPrivateFieldGet(this, _YargsInstance_command, \"f\").cmdToParseOptions(fullCommand)\n            : {\n                array: [],\n                alias: {},\n                default: {},\n                demand: {},\n            };\n        objectKeys(parseOptions).forEach(pk => {\n            const parseOption = parseOptions[pk];\n            if (Array.isArray(parseOption)) {\n                if (parseOption.indexOf(key) !== -1)\n                    opts[pk] = true;\n            }\n            else {\n                if (parseOption[key] && !(pk in opts))\n                    opts[pk] = parseOption[key];\n            }\n        });\n        this.group(key, __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").getPositionalGroupName());\n        return this.option(key, opts);\n    }\n    recommendCommands(recommend = true) {\n        argsert('[boolean]', [recommend], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_recommendCommands, recommend, \"f\");\n        return this;\n    }\n    required(keys, max, msg) {\n        return this.demand(keys, max, msg);\n    }\n    require(keys, max, msg) {\n        return this.demand(keys, max, msg);\n    }\n    requiresArg(keys) {\n        argsert('<array|string|object> [number]', [keys], arguments.length);\n        if (typeof keys === 'string' && __classPrivateFieldGet(this, _YargsInstance_options, \"f\").narg[keys]) {\n            return this;\n        }\n        else {\n            this[kPopulateParserHintSingleValueDictionary](this.requiresArg.bind(this), 'narg', keys, NaN);\n        }\n        return this;\n    }\n    showCompletionScript($0, cmd) {\n        argsert('[string] [string]', [$0, cmd], arguments.length);\n        $0 = $0 || this.$0;\n        __classPrivateFieldGet(this, _YargsInstance_logger, \"f\").log(__classPrivateFieldGet(this, _YargsInstance_completion, \"f\").generateCompletionScript($0, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\") || 'completion'));\n        return this;\n    }\n    showHelp(level) {\n        argsert('[string|function]', [level], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n        if (!__classPrivateFieldGet(this, _YargsInstance_usage, \"f\").hasCachedHelpMessage()) {\n            if (!this.parsed) {\n                const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, \"f\"), undefined, undefined, 0, true);\n                if (isPromise(parse)) {\n                    parse.then(() => {\n                        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showHelp(level);\n                    });\n                    return this;\n                }\n            }\n            const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, \"f\").runDefaultBuilderOn(this);\n            if (isPromise(builderResponse)) {\n                builderResponse.then(() => {\n                    __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showHelp(level);\n                });\n                return this;\n            }\n        }\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showHelp(level);\n        return this;\n    }\n    scriptName(scriptName) {\n        this.customScriptName = true;\n        this.$0 = scriptName;\n        return this;\n    }\n    showHelpOnFail(enabled, message) {\n        argsert('[boolean|string] [string]', [enabled, message], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showHelpOnFail(enabled, message);\n        return this;\n    }\n    showVersion(level) {\n        argsert('[string|function]', [level], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showVersion(level);\n        return this;\n    }\n    skipValidation(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('skipValidation', keys);\n        return this;\n    }\n    strict(enabled) {\n        argsert('[boolean]', [enabled], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_strict, enabled !== false, \"f\");\n        return this;\n    }\n    strictCommands(enabled) {\n        argsert('[boolean]', [enabled], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_strictCommands, enabled !== false, \"f\");\n        return this;\n    }\n    strictOptions(enabled) {\n        argsert('[boolean]', [enabled], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_strictOptions, enabled !== false, \"f\");\n        return this;\n    }\n    string(keys) {\n        argsert('<array|string>', [keys], arguments.length);\n        this[kPopulateParserHintArray]('string', keys);\n        this[kTrackManuallySetKeys](keys);\n        return this;\n    }\n    terminalWidth() {\n        argsert([], 0);\n        return __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.stdColumns;\n    }\n    updateLocale(obj) {\n        return this.updateStrings(obj);\n    }\n    updateStrings(obj) {\n        argsert('<object>', [obj], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, \"f\");\n        __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").y18n.updateLocale(obj);\n        return this;\n    }\n    usage(msg, description, builder, handler) {\n        argsert('<string|null|undefined> [string|boolean] [function|object] [function]', [msg, description, builder, handler], arguments.length);\n        if (description !== undefined) {\n            assertNotStrictEqual(msg, null, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            if ((msg || '').match(/^\\$0( |$)/)) {\n                return this.command(msg, description, builder, handler);\n            }\n            else {\n                throw new YError('.usage() description must start with $0 if being used as alias for .command()');\n            }\n        }\n        else {\n            __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").usage(msg);\n            return this;\n        }\n    }\n    usageConfiguration(config) {\n        argsert('<object>', [config], arguments.length);\n        __classPrivateFieldSet(this, _YargsInstance_usageConfig, config, \"f\");\n        return this;\n    }\n    version(opt, msg, ver) {\n        const defaultVersionOpt = 'version';\n        argsert('[boolean|string] [string] [string]', [opt, msg, ver], arguments.length);\n        if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\")) {\n            this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\"));\n            __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").version(undefined);\n            __classPrivateFieldSet(this, _YargsInstance_versionOpt, null, \"f\");\n        }\n        if (arguments.length === 0) {\n            ver = this[kGuessVersion]();\n            opt = defaultVersionOpt;\n        }\n        else if (arguments.length === 1) {\n            if (opt === false) {\n                return this;\n            }\n            ver = opt;\n            opt = defaultVersionOpt;\n        }\n        else if (arguments.length === 2) {\n            ver = msg;\n            msg = undefined;\n        }\n        __classPrivateFieldSet(this, _YargsInstance_versionOpt, typeof opt === 'string' ? opt : defaultVersionOpt, \"f\");\n        msg = msg || __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").deferY18nLookup('Show version number');\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").version(ver || undefined);\n        this.boolean(__classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\"));\n        this.describe(__classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\"), msg);\n        return this;\n    }\n    wrap(cols) {\n        argsert('<number|null|undefined>', [cols], arguments.length);\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").wrap(cols);\n        return this;\n    }\n    [(_YargsInstance_command = new WeakMap(), _YargsInstance_cwd = new WeakMap(), _YargsInstance_context = new WeakMap(), _YargsInstance_completion = new WeakMap(), _YargsInstance_completionCommand = new WeakMap(), _YargsInstance_defaultShowHiddenOpt = new WeakMap(), _YargsInstance_exitError = new WeakMap(), _YargsInstance_detectLocale = new WeakMap(), _YargsInstance_emittedWarnings = new WeakMap(), _YargsInstance_exitProcess = new WeakMap(), _YargsInstance_frozens = new WeakMap(), _YargsInstance_globalMiddleware = new WeakMap(), _YargsInstance_groups = new WeakMap(), _YargsInstance_hasOutput = new WeakMap(), _YargsInstance_helpOpt = new WeakMap(), _YargsInstance_isGlobalContext = new WeakMap(), _YargsInstance_logger = new WeakMap(), _YargsInstance_output = new WeakMap(), _YargsInstance_options = new WeakMap(), _YargsInstance_parentRequire = new WeakMap(), _YargsInstance_parserConfig = new WeakMap(), _YargsInstance_parseFn = new WeakMap(), _YargsInstance_parseContext = new WeakMap(), _YargsInstance_pkgs = new WeakMap(), _YargsInstance_preservedGroups = new WeakMap(), _YargsInstance_processArgs = new WeakMap(), _YargsInstance_recommendCommands = new WeakMap(), _YargsInstance_shim = new WeakMap(), _YargsInstance_strict = new WeakMap(), _YargsInstance_strictCommands = new WeakMap(), _YargsInstance_strictOptions = new WeakMap(), _YargsInstance_usage = new WeakMap(), _YargsInstance_usageConfig = new WeakMap(), _YargsInstance_versionOpt = new WeakMap(), _YargsInstance_validation = new WeakMap(), kCopyDoubleDash)](argv) {\n        if (!argv._ || !argv['--'])\n            return argv;\n        argv._.push.apply(argv._, argv['--']);\n        try {\n            delete argv['--'];\n        }\n        catch (_err) { }\n        return argv;\n    }\n    [kCreateLogger]() {\n        return {\n            log: (...args) => {\n                if (!this[kHasParseCallback]())\n                    console.log(...args);\n                __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n                if (__classPrivateFieldGet(this, _YargsInstance_output, \"f\").length)\n                    __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, \"f\") + '\\n', \"f\");\n                __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, \"f\") + args.join(' '), \"f\");\n            },\n            error: (...args) => {\n                if (!this[kHasParseCallback]())\n                    console.error(...args);\n                __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n                if (__classPrivateFieldGet(this, _YargsInstance_output, \"f\").length)\n                    __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, \"f\") + '\\n', \"f\");\n                __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, \"f\") + args.join(' '), \"f\");\n            },\n        };\n    }\n    [kDeleteFromParserHintObject](optionKey) {\n        objectKeys(__classPrivateFieldGet(this, _YargsInstance_options, \"f\")).forEach((hintKey) => {\n            if (((key) => key === 'configObjects')(hintKey))\n                return;\n            const hint = __classPrivateFieldGet(this, _YargsInstance_options, \"f\")[hintKey];\n            if (Array.isArray(hint)) {\n                if (hint.includes(optionKey))\n                    hint.splice(hint.indexOf(optionKey), 1);\n            }\n            else if (typeof hint === 'object') {\n                delete hint[optionKey];\n            }\n        });\n        delete __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").getDescriptions()[optionKey];\n    }\n    [kEmitWarning](warning, type, deduplicationId) {\n        if (!__classPrivateFieldGet(this, _YargsInstance_emittedWarnings, \"f\")[deduplicationId]) {\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.emitWarning(warning, type);\n            __classPrivateFieldGet(this, _YargsInstance_emittedWarnings, \"f\")[deduplicationId] = true;\n        }\n    }\n    [kFreeze]() {\n        __classPrivateFieldGet(this, _YargsInstance_frozens, \"f\").push({\n            options: __classPrivateFieldGet(this, _YargsInstance_options, \"f\"),\n            configObjects: __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects.slice(0),\n            exitProcess: __classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"),\n            groups: __classPrivateFieldGet(this, _YargsInstance_groups, \"f\"),\n            strict: __classPrivateFieldGet(this, _YargsInstance_strict, \"f\"),\n            strictCommands: __classPrivateFieldGet(this, _YargsInstance_strictCommands, \"f\"),\n            strictOptions: __classPrivateFieldGet(this, _YargsInstance_strictOptions, \"f\"),\n            completionCommand: __classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\"),\n            output: __classPrivateFieldGet(this, _YargsInstance_output, \"f\"),\n            exitError: __classPrivateFieldGet(this, _YargsInstance_exitError, \"f\"),\n            hasOutput: __classPrivateFieldGet(this, _YargsInstance_hasOutput, \"f\"),\n            parsed: this.parsed,\n            parseFn: __classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\"),\n            parseContext: __classPrivateFieldGet(this, _YargsInstance_parseContext, \"f\"),\n        });\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").freeze();\n        __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").freeze();\n        __classPrivateFieldGet(this, _YargsInstance_command, \"f\").freeze();\n        __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").freeze();\n    }\n    [kGetDollarZero]() {\n        let $0 = '';\n        let default$0;\n        if (/\\b(node|iojs|electron)(\\.exe)?$/.test(__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.argv()[0])) {\n            default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.argv().slice(1, 2);\n        }\n        else {\n            default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.argv().slice(0, 1);\n        }\n        $0 = default$0\n            .map(x => {\n            const b = this[kRebase](__classPrivateFieldGet(this, _YargsInstance_cwd, \"f\"), x);\n            return x.match(/^(\\/|([a-zA-Z]:)?\\\\)/) && b.length < x.length ? b : x;\n        })\n            .join(' ')\n            .trim();\n        if (__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('_') &&\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getProcessArgvBin() === __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('_')) {\n            $0 = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\")\n                .getEnv('_')\n                .replace(`${__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").path.dirname(__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").process.execPath())}/`, '');\n        }\n        return $0;\n    }\n    [kGetParserConfiguration]() {\n        return __classPrivateFieldGet(this, _YargsInstance_parserConfig, \"f\");\n    }\n    [kGetUsageConfiguration]() {\n        return __classPrivateFieldGet(this, _YargsInstance_usageConfig, \"f\");\n    }\n    [kGuessLocale]() {\n        if (!__classPrivateFieldGet(this, _YargsInstance_detectLocale, \"f\"))\n            return;\n        const locale = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('LC_ALL') ||\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('LC_MESSAGES') ||\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('LANG') ||\n            __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").getEnv('LANGUAGE') ||\n            'en_US';\n        this.locale(locale.replace(/[.:].*/, ''));\n    }\n    [kGuessVersion]() {\n        const obj = this[kPkgUp]();\n        return obj.version || 'unknown';\n    }\n    [kParsePositionalNumbers](argv) {\n        const args = argv['--'] ? argv['--'] : argv._;\n        for (let i = 0, arg; (arg = args[i]) !== undefined; i++) {\n            if (__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").Parser.looksLikeNumber(arg) &&\n                Number.isSafeInteger(Math.floor(parseFloat(`${arg}`)))) {\n                args[i] = Number(arg);\n            }\n        }\n        return argv;\n    }\n    [kPkgUp](rootPath) {\n        const npath = rootPath || '*';\n        if (__classPrivateFieldGet(this, _YargsInstance_pkgs, \"f\")[npath])\n            return __classPrivateFieldGet(this, _YargsInstance_pkgs, \"f\")[npath];\n        let obj = {};\n        try {\n            let startDir = rootPath || __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").mainFilename;\n            if (!rootPath && __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").path.extname(startDir)) {\n                startDir = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").path.dirname(startDir);\n            }\n            const pkgJsonPath = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").findUp(startDir, (dir, names) => {\n                if (names.includes('package.json')) {\n                    return 'package.json';\n                }\n                else {\n                    return undefined;\n                }\n            });\n            assertNotStrictEqual(pkgJsonPath, undefined, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n            obj = JSON.parse(__classPrivateFieldGet(this, _YargsInstance_shim, \"f\").readFileSync(pkgJsonPath, 'utf8'));\n        }\n        catch (_noop) { }\n        __classPrivateFieldGet(this, _YargsInstance_pkgs, \"f\")[npath] = obj || {};\n        return __classPrivateFieldGet(this, _YargsInstance_pkgs, \"f\")[npath];\n    }\n    [kPopulateParserHintArray](type, keys) {\n        keys = [].concat(keys);\n        keys.forEach(key => {\n            key = this[kSanitizeKey](key);\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\")[type].push(key);\n        });\n    }\n    [kPopulateParserHintSingleValueDictionary](builder, type, key, value) {\n        this[kPopulateParserHintDictionary](builder, type, key, value, (type, key, value) => {\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\")[type][key] = value;\n        });\n    }\n    [kPopulateParserHintArrayDictionary](builder, type, key, value) {\n        this[kPopulateParserHintDictionary](builder, type, key, value, (type, key, value) => {\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\")[type][key] = (__classPrivateFieldGet(this, _YargsInstance_options, \"f\")[type][key] || []).concat(value);\n        });\n    }\n    [kPopulateParserHintDictionary](builder, type, key, value, singleKeyHandler) {\n        if (Array.isArray(key)) {\n            key.forEach(k => {\n                builder(k, value);\n            });\n        }\n        else if (((key) => typeof key === 'object')(key)) {\n            for (const k of objectKeys(key)) {\n                builder(k, key[k]);\n            }\n        }\n        else {\n            singleKeyHandler(type, this[kSanitizeKey](key), value);\n        }\n    }\n    [kSanitizeKey](key) {\n        if (key === '__proto__')\n            return '___proto___';\n        return key;\n    }\n    [kSetKey](key, set) {\n        this[kPopulateParserHintSingleValueDictionary](this[kSetKey].bind(this), 'key', key, set);\n        return this;\n    }\n    [kUnfreeze]() {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;\n        const frozen = __classPrivateFieldGet(this, _YargsInstance_frozens, \"f\").pop();\n        assertNotStrictEqual(frozen, undefined, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\"));\n        let configObjects;\n        (_a = this, _b = this, _c = this, _d = this, _e = this, _f = this, _g = this, _h = this, _j = this, _k = this, _l = this, _m = this, {\n            options: ({ set value(_o) { __classPrivateFieldSet(_a, _YargsInstance_options, _o, \"f\"); } }).value,\n            configObjects,\n            exitProcess: ({ set value(_o) { __classPrivateFieldSet(_b, _YargsInstance_exitProcess, _o, \"f\"); } }).value,\n            groups: ({ set value(_o) { __classPrivateFieldSet(_c, _YargsInstance_groups, _o, \"f\"); } }).value,\n            output: ({ set value(_o) { __classPrivateFieldSet(_d, _YargsInstance_output, _o, \"f\"); } }).value,\n            exitError: ({ set value(_o) { __classPrivateFieldSet(_e, _YargsInstance_exitError, _o, \"f\"); } }).value,\n            hasOutput: ({ set value(_o) { __classPrivateFieldSet(_f, _YargsInstance_hasOutput, _o, \"f\"); } }).value,\n            parsed: this.parsed,\n            strict: ({ set value(_o) { __classPrivateFieldSet(_g, _YargsInstance_strict, _o, \"f\"); } }).value,\n            strictCommands: ({ set value(_o) { __classPrivateFieldSet(_h, _YargsInstance_strictCommands, _o, \"f\"); } }).value,\n            strictOptions: ({ set value(_o) { __classPrivateFieldSet(_j, _YargsInstance_strictOptions, _o, \"f\"); } }).value,\n            completionCommand: ({ set value(_o) { __classPrivateFieldSet(_k, _YargsInstance_completionCommand, _o, \"f\"); } }).value,\n            parseFn: ({ set value(_o) { __classPrivateFieldSet(_l, _YargsInstance_parseFn, _o, \"f\"); } }).value,\n            parseContext: ({ set value(_o) { __classPrivateFieldSet(_m, _YargsInstance_parseContext, _o, \"f\"); } }).value,\n        } = frozen);\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects = configObjects;\n        __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").unfreeze();\n        __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").unfreeze();\n        __classPrivateFieldGet(this, _YargsInstance_command, \"f\").unfreeze();\n        __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").unfreeze();\n    }\n    [kValidateAsync](validation, argv) {\n        return maybeAsyncResult(argv, result => {\n            validation(result);\n            return result;\n        });\n    }\n    getInternalMethods() {\n        return {\n            getCommandInstance: this[kGetCommandInstance].bind(this),\n            getContext: this[kGetContext].bind(this),\n            getHasOutput: this[kGetHasOutput].bind(this),\n            getLoggerInstance: this[kGetLoggerInstance].bind(this),\n            getParseContext: this[kGetParseContext].bind(this),\n            getParserConfiguration: this[kGetParserConfiguration].bind(this),\n            getUsageConfiguration: this[kGetUsageConfiguration].bind(this),\n            getUsageInstance: this[kGetUsageInstance].bind(this),\n            getValidationInstance: this[kGetValidationInstance].bind(this),\n            hasParseCallback: this[kHasParseCallback].bind(this),\n            isGlobalContext: this[kIsGlobalContext].bind(this),\n            postProcess: this[kPostProcess].bind(this),\n            reset: this[kReset].bind(this),\n            runValidation: this[kRunValidation].bind(this),\n            runYargsParserAndExecuteCommands: this[kRunYargsParserAndExecuteCommands].bind(this),\n            setHasOutput: this[kSetHasOutput].bind(this),\n        };\n    }\n    [kGetCommandInstance]() {\n        return __classPrivateFieldGet(this, _YargsInstance_command, \"f\");\n    }\n    [kGetContext]() {\n        return __classPrivateFieldGet(this, _YargsInstance_context, \"f\");\n    }\n    [kGetHasOutput]() {\n        return __classPrivateFieldGet(this, _YargsInstance_hasOutput, \"f\");\n    }\n    [kGetLoggerInstance]() {\n        return __classPrivateFieldGet(this, _YargsInstance_logger, \"f\");\n    }\n    [kGetParseContext]() {\n        return __classPrivateFieldGet(this, _YargsInstance_parseContext, \"f\") || {};\n    }\n    [kGetUsageInstance]() {\n        return __classPrivateFieldGet(this, _YargsInstance_usage, \"f\");\n    }\n    [kGetValidationInstance]() {\n        return __classPrivateFieldGet(this, _YargsInstance_validation, \"f\");\n    }\n    [kHasParseCallback]() {\n        return !!__classPrivateFieldGet(this, _YargsInstance_parseFn, \"f\");\n    }\n    [kIsGlobalContext]() {\n        return __classPrivateFieldGet(this, _YargsInstance_isGlobalContext, \"f\");\n    }\n    [kPostProcess](argv, populateDoubleDash, calledFromCommand, runGlobalMiddleware) {\n        if (calledFromCommand)\n            return argv;\n        if (isPromise(argv))\n            return argv;\n        if (!populateDoubleDash) {\n            argv = this[kCopyDoubleDash](argv);\n        }\n        const parsePositionalNumbers = this[kGetParserConfiguration]()['parse-positional-numbers'] ||\n            this[kGetParserConfiguration]()['parse-positional-numbers'] === undefined;\n        if (parsePositionalNumbers) {\n            argv = this[kParsePositionalNumbers](argv);\n        }\n        if (runGlobalMiddleware) {\n            argv = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").getMiddleware(), false);\n        }\n        return argv;\n    }\n    [kReset](aliases = {}) {\n        __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, \"f\") || {}, \"f\");\n        const tmpOptions = {};\n        tmpOptions.local = __classPrivateFieldGet(this, _YargsInstance_options, \"f\").local || [];\n        tmpOptions.configObjects = __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configObjects || [];\n        const localLookup = {};\n        tmpOptions.local.forEach(l => {\n            localLookup[l] = true;\n            (aliases[l] || []).forEach(a => {\n                localLookup[a] = true;\n            });\n        });\n        Object.assign(__classPrivateFieldGet(this, _YargsInstance_preservedGroups, \"f\"), Object.keys(__classPrivateFieldGet(this, _YargsInstance_groups, \"f\")).reduce((acc, groupName) => {\n            const keys = __classPrivateFieldGet(this, _YargsInstance_groups, \"f\")[groupName].filter(key => !(key in localLookup));\n            if (keys.length > 0) {\n                acc[groupName] = keys;\n            }\n            return acc;\n        }, {}));\n        __classPrivateFieldSet(this, _YargsInstance_groups, {}, \"f\");\n        const arrayOptions = [\n            'array',\n            'boolean',\n            'string',\n            'skipValidation',\n            'count',\n            'normalize',\n            'number',\n            'hiddenOptions',\n        ];\n        const objectOptions = [\n            'narg',\n            'key',\n            'alias',\n            'default',\n            'defaultDescription',\n            'config',\n            'choices',\n            'demandedOptions',\n            'demandedCommands',\n            'deprecatedOptions',\n        ];\n        arrayOptions.forEach(k => {\n            tmpOptions[k] = (__classPrivateFieldGet(this, _YargsInstance_options, \"f\")[k] || []).filter((k) => !localLookup[k]);\n        });\n        objectOptions.forEach((k) => {\n            tmpOptions[k] = objFilter(__classPrivateFieldGet(this, _YargsInstance_options, \"f\")[k], k => !localLookup[k]);\n        });\n        tmpOptions.envPrefix = __classPrivateFieldGet(this, _YargsInstance_options, \"f\").envPrefix;\n        __classPrivateFieldSet(this, _YargsInstance_options, tmpOptions, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, \"f\")\n            ? __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").reset(localLookup)\n            : Usage(this, __classPrivateFieldGet(this, _YargsInstance_shim, \"f\")), \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, \"f\")\n            ? __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").reset(localLookup)\n            : Validation(this, __classPrivateFieldGet(this, _YargsInstance_usage, \"f\"), __classPrivateFieldGet(this, _YargsInstance_shim, \"f\")), \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, \"f\")\n            ? __classPrivateFieldGet(this, _YargsInstance_command, \"f\").reset()\n            : Command(__classPrivateFieldGet(this, _YargsInstance_usage, \"f\"), __classPrivateFieldGet(this, _YargsInstance_validation, \"f\"), __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\"), __classPrivateFieldGet(this, _YargsInstance_shim, \"f\")), \"f\");\n        if (!__classPrivateFieldGet(this, _YargsInstance_completion, \"f\"))\n            __classPrivateFieldSet(this, _YargsInstance_completion, Completion(this, __classPrivateFieldGet(this, _YargsInstance_usage, \"f\"), __classPrivateFieldGet(this, _YargsInstance_command, \"f\"), __classPrivateFieldGet(this, _YargsInstance_shim, \"f\")), \"f\");\n        __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").reset();\n        __classPrivateFieldSet(this, _YargsInstance_completionCommand, null, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_output, '', \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_exitError, null, \"f\");\n        __classPrivateFieldSet(this, _YargsInstance_hasOutput, false, \"f\");\n        this.parsed = false;\n        return this;\n    }\n    [kRebase](base, dir) {\n        return __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").path.relative(base, dir);\n    }\n    [kRunYargsParserAndExecuteCommands](args, shortCircuit, calledFromCommand, commandIndex = 0, helpOnly = false) {\n        let skipValidation = !!calledFromCommand || helpOnly;\n        args = args || __classPrivateFieldGet(this, _YargsInstance_processArgs, \"f\");\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").__ = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").y18n.__;\n        __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configuration = this[kGetParserConfiguration]();\n        const populateDoubleDash = !!__classPrivateFieldGet(this, _YargsInstance_options, \"f\").configuration['populate--'];\n        const config = Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, \"f\").configuration, {\n            'populate--': true,\n        });\n        const parsed = __classPrivateFieldGet(this, _YargsInstance_shim, \"f\").Parser.detailed(args, Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, \"f\"), {\n            configuration: { 'parse-positional-numbers': false, ...config },\n        }));\n        const argv = Object.assign(parsed.argv, __classPrivateFieldGet(this, _YargsInstance_parseContext, \"f\"));\n        let argvPromise = undefined;\n        const aliases = parsed.aliases;\n        let helpOptSet = false;\n        let versionOptSet = false;\n        Object.keys(argv).forEach(key => {\n            if (key === __classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\") && argv[key]) {\n                helpOptSet = true;\n            }\n            else if (key === __classPrivateFieldGet(this, _YargsInstance_versionOpt, \"f\") && argv[key]) {\n                versionOptSet = true;\n            }\n        });\n        argv.$0 = this.$0;\n        this.parsed = parsed;\n        if (commandIndex === 0) {\n            __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").clearCachedHelpMessage();\n        }\n        try {\n            this[kGuessLocale]();\n            if (shortCircuit) {\n                return this[kPostProcess](argv, populateDoubleDash, !!calledFromCommand, false);\n            }\n            if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\")) {\n                const helpCmds = [__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\")]\n                    .concat(aliases[__classPrivateFieldGet(this, _YargsInstance_helpOpt, \"f\")] || [])\n                    .filter(k => k.length > 1);\n                if (helpCmds.includes('' + argv._[argv._.length - 1])) {\n                    argv._.pop();\n                    helpOptSet = true;\n                }\n            }\n            __classPrivateFieldSet(this, _YargsInstance_isGlobalContext, false, \"f\");\n            const handlerKeys = __classPrivateFieldGet(this, _YargsInstance_command, \"f\").getCommands();\n            const requestCompletions = __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").completionKey in argv;\n            const skipRecommendation = helpOptSet || requestCompletions || helpOnly;\n            if (argv._.length) {\n                if (handlerKeys.length) {\n                    let firstUnknownCommand;\n                    for (let i = commandIndex || 0, cmd; argv._[i] !== undefined; i++) {\n                        cmd = String(argv._[i]);\n                        if (handlerKeys.includes(cmd) && cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\")) {\n                            const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, \"f\").runCommand(cmd, this, parsed, i + 1, helpOnly, helpOptSet || versionOptSet || helpOnly);\n                            return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);\n                        }\n                        else if (!firstUnknownCommand &&\n                            cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\")) {\n                            firstUnknownCommand = cmd;\n                            break;\n                        }\n                    }\n                    if (!__classPrivateFieldGet(this, _YargsInstance_command, \"f\").hasDefaultCommand() &&\n                        __classPrivateFieldGet(this, _YargsInstance_recommendCommands, \"f\") &&\n                        firstUnknownCommand &&\n                        !skipRecommendation) {\n                        __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").recommendCommands(firstUnknownCommand, handlerKeys);\n                    }\n                }\n                if (__classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\") &&\n                    argv._.includes(__classPrivateFieldGet(this, _YargsInstance_completionCommand, \"f\")) &&\n                    !requestCompletions) {\n                    if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"))\n                        setBlocking(true);\n                    this.showCompletionScript();\n                    this.exit(0);\n                }\n            }\n            if (__classPrivateFieldGet(this, _YargsInstance_command, \"f\").hasDefaultCommand() && !skipRecommendation) {\n                const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, \"f\").runCommand(null, this, parsed, 0, helpOnly, helpOptSet || versionOptSet || helpOnly);\n                return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);\n            }\n            if (requestCompletions) {\n                if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"))\n                    setBlocking(true);\n                args = [].concat(args);\n                const completionArgs = args.slice(args.indexOf(`--${__classPrivateFieldGet(this, _YargsInstance_completion, \"f\").completionKey}`) + 1);\n                __classPrivateFieldGet(this, _YargsInstance_completion, \"f\").getCompletion(completionArgs, (err, completions) => {\n                    if (err)\n                        throw new YError(err.message);\n                    (completions || []).forEach(completion => {\n                        __classPrivateFieldGet(this, _YargsInstance_logger, \"f\").log(completion);\n                    });\n                    this.exit(0);\n                });\n                return this[kPostProcess](argv, !populateDoubleDash, !!calledFromCommand, false);\n            }\n            if (!__classPrivateFieldGet(this, _YargsInstance_hasOutput, \"f\")) {\n                if (helpOptSet) {\n                    if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"))\n                        setBlocking(true);\n                    skipValidation = true;\n                    this.showHelp('log');\n                    this.exit(0);\n                }\n                else if (versionOptSet) {\n                    if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, \"f\"))\n                        setBlocking(true);\n                    skipValidation = true;\n                    __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").showVersion('log');\n                    this.exit(0);\n                }\n            }\n            if (!skipValidation && __classPrivateFieldGet(this, _YargsInstance_options, \"f\").skipValidation.length > 0) {\n                skipValidation = Object.keys(argv).some(key => __classPrivateFieldGet(this, _YargsInstance_options, \"f\").skipValidation.indexOf(key) >= 0 && argv[key] === true);\n            }\n            if (!skipValidation) {\n                if (parsed.error)\n                    throw new YError(parsed.error.message);\n                if (!requestCompletions) {\n                    const validation = this[kRunValidation](aliases, {}, parsed.error);\n                    if (!calledFromCommand) {\n                        argvPromise = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").getMiddleware(), true);\n                    }\n                    argvPromise = this[kValidateAsync](validation, argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv);\n                    if (isPromise(argvPromise) && !calledFromCommand) {\n                        argvPromise = argvPromise.then(() => {\n                            return applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, \"f\").getMiddleware(), false);\n                        });\n                    }\n                }\n            }\n        }\n        catch (err) {\n            if (err instanceof YError)\n                __classPrivateFieldGet(this, _YargsInstance_usage, \"f\").fail(err.message, err);\n            else\n                throw err;\n        }\n        return this[kPostProcess](argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv, populateDoubleDash, !!calledFromCommand, true);\n    }\n    [kRunValidation](aliases, positionalMap, parseErrors, isDefaultCommand) {\n        const demandedOptions = { ...this.getDemandedOptions() };\n        return (argv) => {\n            if (parseErrors)\n                throw new YError(parseErrors.message);\n            __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").nonOptionCount(argv);\n            __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").requiredArguments(argv, demandedOptions);\n            let failedStrictCommands = false;\n            if (__classPrivateFieldGet(this, _YargsInstance_strictCommands, \"f\")) {\n                failedStrictCommands = __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").unknownCommands(argv);\n            }\n            if (__classPrivateFieldGet(this, _YargsInstance_strict, \"f\") && !failedStrictCommands) {\n                __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").unknownArguments(argv, aliases, positionalMap, !!isDefaultCommand);\n            }\n            else if (__classPrivateFieldGet(this, _YargsInstance_strictOptions, \"f\")) {\n                __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").unknownArguments(argv, aliases, {}, false, false);\n            }\n            __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").limitedChoices(argv);\n            __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").implications(argv);\n            __classPrivateFieldGet(this, _YargsInstance_validation, \"f\").conflicting(argv);\n        };\n    }\n    [kSetHasOutput]() {\n        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, \"f\");\n    }\n    [kTrackManuallySetKeys](keys) {\n        if (typeof keys === 'string') {\n            __classPrivateFieldGet(this, _YargsInstance_options, \"f\").key[keys] = true;\n        }\n        else {\n            for (const k of keys) {\n                __classPrivateFieldGet(this, _YargsInstance_options, \"f\").key[k] = true;\n            }\n        }\n    }\n}\nexport function isYargsInstance(y) {\n    return !!y && typeof y.getInternalMethods === 'function';\n}\n","import { assertNotStrictEqual, } from './typings/common-types.js';\nimport { isPromise } from './utils/is-promise.js';\nimport { applyMiddleware, commandMiddlewareFactory, } from './middleware.js';\nimport { parseCommand } from './parse-command.js';\nimport { isYargsInstance, } from './yargs-factory.js';\nimport { maybeAsyncResult } from './utils/maybe-async-result.js';\nimport whichModule from './utils/which-module.js';\nconst DEFAULT_MARKER = /(^\\*)|(^\\$0)/;\nexport class CommandInstance {\n    constructor(usage, validation, globalMiddleware, shim) {\n        this.requireCache = new Set();\n        this.handlers = {};\n        this.aliasMap = {};\n        this.frozens = [];\n        this.shim = shim;\n        this.usage = usage;\n        this.globalMiddleware = globalMiddleware;\n        this.validation = validation;\n    }\n    addDirectory(dir, req, callerFile, opts) {\n        opts = opts || {};\n        if (typeof opts.recurse !== 'boolean')\n            opts.recurse = false;\n        if (!Array.isArray(opts.extensions))\n            opts.extensions = ['js'];\n        const parentVisit = typeof opts.visit === 'function' ? opts.visit : (o) => o;\n        opts.visit = (obj, joined, filename) => {\n            const visited = parentVisit(obj, joined, filename);\n            if (visited) {\n                if (this.requireCache.has(joined))\n                    return visited;\n                else\n                    this.requireCache.add(joined);\n                this.addHandler(visited);\n            }\n            return visited;\n        };\n        this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);\n    }\n    addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {\n        let aliases = [];\n        const middlewares = commandMiddlewareFactory(commandMiddleware);\n        handler = handler || (() => { });\n        if (Array.isArray(cmd)) {\n            if (isCommandAndAliases(cmd)) {\n                [cmd, ...aliases] = cmd;\n            }\n            else {\n                for (const command of cmd) {\n                    this.addHandler(command);\n                }\n            }\n        }\n        else if (isCommandHandlerDefinition(cmd)) {\n            let command = Array.isArray(cmd.command) || typeof cmd.command === 'string'\n                ? cmd.command\n                : this.moduleName(cmd);\n            if (cmd.aliases)\n                command = [].concat(command).concat(cmd.aliases);\n            this.addHandler(command, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);\n            return;\n        }\n        else if (isCommandBuilderDefinition(builder)) {\n            this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);\n            return;\n        }\n        if (typeof cmd === 'string') {\n            const parsedCommand = parseCommand(cmd);\n            aliases = aliases.map(alias => parseCommand(alias).cmd);\n            let isDefault = false;\n            const parsedAliases = [parsedCommand.cmd].concat(aliases).filter(c => {\n                if (DEFAULT_MARKER.test(c)) {\n                    isDefault = true;\n                    return false;\n                }\n                return true;\n            });\n            if (parsedAliases.length === 0 && isDefault)\n                parsedAliases.push('$0');\n            if (isDefault) {\n                parsedCommand.cmd = parsedAliases[0];\n                aliases = parsedAliases.slice(1);\n                cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);\n            }\n            aliases.forEach(alias => {\n                this.aliasMap[alias] = parsedCommand.cmd;\n            });\n            if (description !== false) {\n                this.usage.command(cmd, description, isDefault, aliases, deprecated);\n            }\n            this.handlers[parsedCommand.cmd] = {\n                original: cmd,\n                description,\n                handler,\n                builder: builder || {},\n                middlewares,\n                deprecated,\n                demanded: parsedCommand.demanded,\n                optional: parsedCommand.optional,\n            };\n            if (isDefault)\n                this.defaultCommand = this.handlers[parsedCommand.cmd];\n        }\n    }\n    getCommandHandlers() {\n        return this.handlers;\n    }\n    getCommands() {\n        return Object.keys(this.handlers).concat(Object.keys(this.aliasMap));\n    }\n    hasDefaultCommand() {\n        return !!this.defaultCommand;\n    }\n    runCommand(command, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {\n        const commandHandler = this.handlers[command] ||\n            this.handlers[this.aliasMap[command]] ||\n            this.defaultCommand;\n        const currentContext = yargs.getInternalMethods().getContext();\n        const parentCommands = currentContext.commands.slice();\n        const isDefaultCommand = !command;\n        if (command) {\n            currentContext.commands.push(command);\n            currentContext.fullCommands.push(commandHandler.original);\n        }\n        const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);\n        return isPromise(builderResult)\n            ? builderResult.then(result => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs))\n            : this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);\n    }\n    applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {\n        const builder = commandHandler.builder;\n        let innerYargs = yargs;\n        if (isCommandBuilderCallback(builder)) {\n            yargs.getInternalMethods().getUsageInstance().freeze();\n            const builderOutput = builder(yargs.getInternalMethods().reset(aliases), helpOrVersionSet);\n            if (isPromise(builderOutput)) {\n                return builderOutput.then(output => {\n                    innerYargs = isYargsInstance(output) ? output : yargs;\n                    return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);\n                });\n            }\n        }\n        else if (isCommandBuilderOptionDefinitions(builder)) {\n            yargs.getInternalMethods().getUsageInstance().freeze();\n            innerYargs = yargs.getInternalMethods().reset(aliases);\n            Object.keys(commandHandler.builder).forEach(key => {\n                innerYargs.option(key, builder[key]);\n            });\n        }\n        return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);\n    }\n    parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {\n        if (isDefaultCommand)\n            innerYargs.getInternalMethods().getUsageInstance().unfreeze(true);\n        if (this.shouldUpdateUsage(innerYargs)) {\n            innerYargs\n                .getInternalMethods()\n                .getUsageInstance()\n                .usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);\n        }\n        const innerArgv = innerYargs\n            .getInternalMethods()\n            .runYargsParserAndExecuteCommands(null, undefined, true, commandIndex, helpOnly);\n        return isPromise(innerArgv)\n            ? innerArgv.then(argv => ({\n                aliases: innerYargs.parsed.aliases,\n                innerArgv: argv,\n            }))\n            : {\n                aliases: innerYargs.parsed.aliases,\n                innerArgv: innerArgv,\n            };\n    }\n    shouldUpdateUsage(yargs) {\n        return (!yargs.getInternalMethods().getUsageInstance().getUsageDisabled() &&\n            yargs.getInternalMethods().getUsageInstance().getUsage().length === 0);\n    }\n    usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {\n        const c = DEFAULT_MARKER.test(commandHandler.original)\n            ? commandHandler.original.replace(DEFAULT_MARKER, '').trim()\n            : commandHandler.original;\n        const pc = parentCommands.filter(c => {\n            return !DEFAULT_MARKER.test(c);\n        });\n        pc.push(c);\n        return `$0 ${pc.join(' ')}`;\n    }\n    handleValidationAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, aliases, yargs, middlewares, positionalMap) {\n        if (!yargs.getInternalMethods().getHasOutput()) {\n            const validation = yargs\n                .getInternalMethods()\n                .runValidation(aliases, positionalMap, yargs.parsed.error, isDefaultCommand);\n            innerArgv = maybeAsyncResult(innerArgv, result => {\n                validation(result);\n                return result;\n            });\n        }\n        if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {\n            yargs.getInternalMethods().setHasOutput();\n            const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];\n            yargs\n                .getInternalMethods()\n                .postProcess(innerArgv, populateDoubleDash, false, false);\n            innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);\n            innerArgv = maybeAsyncResult(innerArgv, result => {\n                const handlerResult = commandHandler.handler(result);\n                return isPromise(handlerResult)\n                    ? handlerResult.then(() => result)\n                    : result;\n            });\n            if (!isDefaultCommand) {\n                yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();\n            }\n            if (isPromise(innerArgv) &&\n                !yargs.getInternalMethods().hasParseCallback()) {\n                innerArgv.catch(error => {\n                    try {\n                        yargs.getInternalMethods().getUsageInstance().fail(null, error);\n                    }\n                    catch (_err) {\n                    }\n                });\n            }\n        }\n        if (!isDefaultCommand) {\n            currentContext.commands.pop();\n            currentContext.fullCommands.pop();\n        }\n        return innerArgv;\n    }\n    applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) {\n        let positionalMap = {};\n        if (helpOnly)\n            return innerArgv;\n        if (!yargs.getInternalMethods().getHasOutput()) {\n            positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);\n        }\n        const middlewares = this.globalMiddleware\n            .getMiddleware()\n            .slice(0)\n            .concat(commandHandler.middlewares);\n        const maybePromiseArgv = applyMiddleware(innerArgv, yargs, middlewares, true);\n        return isPromise(maybePromiseArgv)\n            ? maybePromiseArgv.then(resolvedInnerArgv => this.handleValidationAndGetResult(isDefaultCommand, commandHandler, resolvedInnerArgv, currentContext, aliases, yargs, middlewares, positionalMap))\n            : this.handleValidationAndGetResult(isDefaultCommand, commandHandler, maybePromiseArgv, currentContext, aliases, yargs, middlewares, positionalMap);\n    }\n    populatePositionals(commandHandler, argv, context, yargs) {\n        argv._ = argv._.slice(context.commands.length);\n        const demanded = commandHandler.demanded.slice(0);\n        const optional = commandHandler.optional.slice(0);\n        const positionalMap = {};\n        this.validation.positionalCount(demanded.length, argv._.length);\n        while (demanded.length) {\n            const demand = demanded.shift();\n            this.populatePositional(demand, argv, positionalMap);\n        }\n        while (optional.length) {\n            const maybe = optional.shift();\n            this.populatePositional(maybe, argv, positionalMap);\n        }\n        argv._ = context.commands.concat(argv._.map(a => '' + a));\n        this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs);\n        return positionalMap;\n    }\n    populatePositional(positional, argv, positionalMap) {\n        const cmd = positional.cmd[0];\n        if (positional.variadic) {\n            positionalMap[cmd] = argv._.splice(0).map(String);\n        }\n        else {\n            if (argv._.length)\n                positionalMap[cmd] = [String(argv._.shift())];\n        }\n    }\n    cmdToParseOptions(cmdString) {\n        const parseOptions = {\n            array: [],\n            default: {},\n            alias: {},\n            demand: {},\n        };\n        const parsed = parseCommand(cmdString);\n        parsed.demanded.forEach(d => {\n            const [cmd, ...aliases] = d.cmd;\n            if (d.variadic) {\n                parseOptions.array.push(cmd);\n                parseOptions.default[cmd] = [];\n            }\n            parseOptions.alias[cmd] = aliases;\n            parseOptions.demand[cmd] = true;\n        });\n        parsed.optional.forEach(o => {\n            const [cmd, ...aliases] = o.cmd;\n            if (o.variadic) {\n                parseOptions.array.push(cmd);\n                parseOptions.default[cmd] = [];\n            }\n            parseOptions.alias[cmd] = aliases;\n        });\n        return parseOptions;\n    }\n    postProcessPositionals(argv, positionalMap, parseOptions, yargs) {\n        const options = Object.assign({}, yargs.getOptions());\n        options.default = Object.assign(parseOptions.default, options.default);\n        for (const key of Object.keys(parseOptions.alias)) {\n            options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);\n        }\n        options.array = options.array.concat(parseOptions.array);\n        options.config = {};\n        const unparsed = [];\n        Object.keys(positionalMap).forEach(key => {\n            positionalMap[key].map(value => {\n                if (options.configuration['unknown-options-as-args'])\n                    options.key[key] = true;\n                unparsed.push(`--${key}`);\n                unparsed.push(value);\n            });\n        });\n        if (!unparsed.length)\n            return;\n        const config = Object.assign({}, options.configuration, {\n            'populate--': false,\n        });\n        const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options, {\n            configuration: config,\n        }));\n        if (parsed.error) {\n            yargs\n                .getInternalMethods()\n                .getUsageInstance()\n                .fail(parsed.error.message, parsed.error);\n        }\n        else {\n            const positionalKeys = Object.keys(positionalMap);\n            Object.keys(positionalMap).forEach(key => {\n                positionalKeys.push(...parsed.aliases[key]);\n            });\n            Object.keys(parsed.argv).forEach(key => {\n                if (positionalKeys.includes(key)) {\n                    if (!positionalMap[key])\n                        positionalMap[key] = parsed.argv[key];\n                    if (!this.isInConfigs(yargs, key) &&\n                        !this.isDefaulted(yargs, key) &&\n                        Object.prototype.hasOwnProperty.call(argv, key) &&\n                        Object.prototype.hasOwnProperty.call(parsed.argv, key) &&\n                        (Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) {\n                        argv[key] = [].concat(argv[key], parsed.argv[key]);\n                    }\n                    else {\n                        argv[key] = parsed.argv[key];\n                    }\n                }\n            });\n        }\n    }\n    isDefaulted(yargs, key) {\n        const { default: defaults } = yargs.getOptions();\n        return (Object.prototype.hasOwnProperty.call(defaults, key) ||\n            Object.prototype.hasOwnProperty.call(defaults, this.shim.Parser.camelCase(key)));\n    }\n    isInConfigs(yargs, key) {\n        const { configObjects } = yargs.getOptions();\n        return (configObjects.some(c => Object.prototype.hasOwnProperty.call(c, key)) ||\n            configObjects.some(c => Object.prototype.hasOwnProperty.call(c, this.shim.Parser.camelCase(key))));\n    }\n    runDefaultBuilderOn(yargs) {\n        if (!this.defaultCommand)\n            return;\n        if (this.shouldUpdateUsage(yargs)) {\n            const commandString = DEFAULT_MARKER.test(this.defaultCommand.original)\n                ? this.defaultCommand.original\n                : this.defaultCommand.original.replace(/^[^[\\]<>]*/, '$0 ');\n            yargs\n                .getInternalMethods()\n                .getUsageInstance()\n                .usage(commandString, this.defaultCommand.description);\n        }\n        const builder = this.defaultCommand.builder;\n        if (isCommandBuilderCallback(builder)) {\n            return builder(yargs, true);\n        }\n        else if (!isCommandBuilderDefinition(builder)) {\n            Object.keys(builder).forEach(key => {\n                yargs.option(key, builder[key]);\n            });\n        }\n        return undefined;\n    }\n    moduleName(obj) {\n        const mod = whichModule(obj);\n        if (!mod)\n            throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`);\n        return this.commandFromFilename(mod.filename);\n    }\n    commandFromFilename(filename) {\n        return this.shim.path.basename(filename, this.shim.path.extname(filename));\n    }\n    extractDesc({ describe, description, desc }) {\n        for (const test of [describe, description, desc]) {\n            if (typeof test === 'string' || test === false)\n                return test;\n            assertNotStrictEqual(test, true, this.shim);\n        }\n        return false;\n    }\n    freeze() {\n        this.frozens.push({\n            handlers: this.handlers,\n            aliasMap: this.aliasMap,\n            defaultCommand: this.defaultCommand,\n        });\n    }\n    unfreeze() {\n        const frozen = this.frozens.pop();\n        assertNotStrictEqual(frozen, undefined, this.shim);\n        ({\n            handlers: this.handlers,\n            aliasMap: this.aliasMap,\n            defaultCommand: this.defaultCommand,\n        } = frozen);\n    }\n    reset() {\n        this.handlers = {};\n        this.aliasMap = {};\n        this.defaultCommand = undefined;\n        this.requireCache = new Set();\n        return this;\n    }\n}\nexport function command(usage, validation, globalMiddleware, shim) {\n    return new CommandInstance(usage, validation, globalMiddleware, shim);\n}\nexport function isCommandBuilderDefinition(builder) {\n    return (typeof builder === 'object' &&\n        !!builder.builder &&\n        typeof builder.handler === 'function');\n}\nfunction isCommandAndAliases(cmd) {\n    return cmd.every(c => typeof c === 'string');\n}\nexport function isCommandBuilderCallback(builder) {\n    return typeof builder === 'function';\n}\nfunction isCommandBuilderOptionDefinitions(builder) {\n    return typeof builder === 'object';\n}\nexport function isCommandHandlerDefinition(cmd) {\n    return typeof cmd === 'object' && !Array.isArray(cmd);\n}\n","export function assertNotStrictEqual(actual, expected, shim, message) {\n    shim.assert.notStrictEqual(actual, expected, message);\n}\nexport function assertSingleKey(actual, shim) {\n    shim.assert.strictEqual(typeof actual, 'string');\n}\nexport function objectKeys(object) {\n    return Object.keys(object);\n}\n","export function isPromise(maybePromise) {\n    return (!!maybePromise &&\n        !!maybePromise.then &&\n        typeof maybePromise.then === 'function');\n}\n","import { argsert } from './argsert.js';\nimport { isPromise } from './utils/is-promise.js';\nexport class GlobalMiddleware {\n    constructor(yargs) {\n        this.globalMiddleware = [];\n        this.frozens = [];\n        this.yargs = yargs;\n    }\n    addMiddleware(callback, applyBeforeValidation, global = true, mutates = false) {\n        argsert('<array|function> [boolean] [boolean] [boolean]', [callback, applyBeforeValidation, global], arguments.length);\n        if (Array.isArray(callback)) {\n            for (let i = 0; i < callback.length; i++) {\n                if (typeof callback[i] !== 'function') {\n                    throw Error('middleware must be a function');\n                }\n                const m = callback[i];\n                m.applyBeforeValidation = applyBeforeValidation;\n                m.global = global;\n            }\n            Array.prototype.push.apply(this.globalMiddleware, callback);\n        }\n        else if (typeof callback === 'function') {\n            const m = callback;\n            m.applyBeforeValidation = applyBeforeValidation;\n            m.global = global;\n            m.mutates = mutates;\n            this.globalMiddleware.push(callback);\n        }\n        return this.yargs;\n    }\n    addCoerceMiddleware(callback, option) {\n        const aliases = this.yargs.getAliases();\n        this.globalMiddleware = this.globalMiddleware.filter(m => {\n            const toCheck = [...(aliases[option] || []), option];\n            if (!m.option)\n                return true;\n            else\n                return !toCheck.includes(m.option);\n        });\n        callback.option = option;\n        return this.addMiddleware(callback, true, true, true);\n    }\n    getMiddleware() {\n        return this.globalMiddleware;\n    }\n    freeze() {\n        this.frozens.push([...this.globalMiddleware]);\n    }\n    unfreeze() {\n        const frozen = this.frozens.pop();\n        if (frozen !== undefined)\n            this.globalMiddleware = frozen;\n    }\n    reset() {\n        this.globalMiddleware = this.globalMiddleware.filter(m => m.global);\n    }\n}\nexport function commandMiddlewareFactory(commandMiddleware) {\n    if (!commandMiddleware)\n        return [];\n    return commandMiddleware.map(middleware => {\n        middleware.applyBeforeValidation = false;\n        return middleware;\n    });\n}\nexport function applyMiddleware(argv, yargs, middlewares, beforeValidation) {\n    return middlewares.reduce((acc, middleware) => {\n        if (middleware.applyBeforeValidation !== beforeValidation) {\n            return acc;\n        }\n        if (middleware.mutates) {\n            if (middleware.applied)\n                return acc;\n            middleware.applied = true;\n        }\n        if (isPromise(acc)) {\n            return acc\n                .then(initialObj => Promise.all([initialObj, middleware(initialObj, yargs)]))\n                .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));\n        }\n        else {\n            const result = middleware(acc, yargs);\n            return isPromise(result)\n                ? result.then(middlewareObj => Object.assign(acc, middlewareObj))\n                : Object.assign(acc, result);\n        }\n    }, argv);\n}\n","import { YError } from './yerror.js';\nimport { parseCommand } from './parse-command.js';\nconst positionName = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth'];\nexport function argsert(arg1, arg2, arg3) {\n    function parseArgs() {\n        return typeof arg1 === 'object'\n            ? [{ demanded: [], optional: [] }, arg1, arg2]\n            : [\n                parseCommand(`cmd ${arg1}`),\n                arg2,\n                arg3,\n            ];\n    }\n    try {\n        let position = 0;\n        const [parsed, callerArguments, _length] = parseArgs();\n        const args = [].slice.call(callerArguments);\n        while (args.length && args[args.length - 1] === undefined)\n            args.pop();\n        const length = _length || args.length;\n        if (length < parsed.demanded.length) {\n            throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);\n        }\n        const totalCommands = parsed.demanded.length + parsed.optional.length;\n        if (length > totalCommands) {\n            throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);\n        }\n        parsed.demanded.forEach(demanded => {\n            const arg = args.shift();\n            const observedType = guessType(arg);\n            const matchingTypes = demanded.cmd.filter(type => type === observedType || type === '*');\n            if (matchingTypes.length === 0)\n                argumentTypeError(observedType, demanded.cmd, position);\n            position += 1;\n        });\n        parsed.optional.forEach(optional => {\n            if (args.length === 0)\n                return;\n            const arg = args.shift();\n            const observedType = guessType(arg);\n            const matchingTypes = optional.cmd.filter(type => type === observedType || type === '*');\n            if (matchingTypes.length === 0)\n                argumentTypeError(observedType, optional.cmd, position);\n            position += 1;\n        });\n    }\n    catch (err) {\n        console.warn(err.stack);\n    }\n}\nfunction guessType(arg) {\n    if (Array.isArray(arg)) {\n        return 'array';\n    }\n    else if (arg === null) {\n        return 'null';\n    }\n    return typeof arg;\n}\nfunction argumentTypeError(observedType, allowedTypes, position) {\n    throw new YError(`Invalid ${positionName[position] || 'manyith'} argument. Expected ${allowedTypes.join(' or ')} but received ${observedType}.`);\n}\n","export function parseCommand(cmd) {\n    const extraSpacesStrippedCommand = cmd.replace(/\\s{2,}/g, ' ');\n    const splitCommand = extraSpacesStrippedCommand.split(/\\s+(?![^[]*]|[^<]*>)/);\n    const bregex = /\\.*[\\][<>]/g;\n    const firstCommand = splitCommand.shift();\n    if (!firstCommand)\n        throw new Error(`No command found in: ${cmd}`);\n    const parsedCommand = {\n        cmd: firstCommand.replace(bregex, ''),\n        demanded: [],\n        optional: [],\n    };\n    splitCommand.forEach((cmd, i) => {\n        let variadic = false;\n        cmd = cmd.replace(/\\s/g, '');\n        if (/\\.+[\\]>]/.test(cmd) && i === splitCommand.length - 1)\n            variadic = true;\n        if (/^\\[/.test(cmd)) {\n            parsedCommand.optional.push({\n                cmd: cmd.replace(bregex, '').split('|'),\n                variadic,\n            });\n        }\n        else {\n            parsedCommand.demanded.push({\n                cmd: cmd.replace(bregex, '').split('|'),\n                variadic,\n            });\n        }\n    });\n    return parsedCommand;\n}\n","import { isPromise } from './is-promise.js';\nexport function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {\n    throw err;\n}) {\n    try {\n        const result = isFunction(getResult) ? getResult() : getResult;\n        return isPromise(result)\n            ? result.then((result) => resultHandler(result))\n            : resultHandler(result);\n    }\n    catch (err) {\n        return errorHandler(err);\n    }\n}\nfunction isFunction(arg) {\n    return typeof arg === 'function';\n}\n","export default function whichModule(exported) {\n    if (typeof require === 'undefined')\n        return null;\n    for (let i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {\n        mod = require.cache[files[i]];\n        if (mod.exports === exported)\n            return mod;\n    }\n    return null;\n}\n","import { objFilter } from './utils/obj-filter.js';\nimport { YError } from './yerror.js';\nimport setBlocking from './utils/set-blocking.js';\nfunction isBoolean(fail) {\n    return typeof fail === 'boolean';\n}\nexport function usage(yargs, shim) {\n    const __ = shim.y18n.__;\n    const self = {};\n    const fails = [];\n    self.failFn = function failFn(f) {\n        fails.push(f);\n    };\n    let failMessage = null;\n    let globalFailMessage = null;\n    let showHelpOnFail = true;\n    self.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {\n        const [enabled, message] = typeof arg1 === 'string' ? [true, arg1] : [arg1, arg2];\n        if (yargs.getInternalMethods().isGlobalContext()) {\n            globalFailMessage = message;\n        }\n        failMessage = message;\n        showHelpOnFail = enabled;\n        return self;\n    };\n    let failureOutput = false;\n    self.fail = function fail(msg, err) {\n        const logger = yargs.getInternalMethods().getLoggerInstance();\n        if (fails.length) {\n            for (let i = fails.length - 1; i >= 0; --i) {\n                const fail = fails[i];\n                if (isBoolean(fail)) {\n                    if (err)\n                        throw err;\n                    else if (msg)\n                        throw Error(msg);\n                }\n                else {\n                    fail(msg, err, self);\n                }\n            }\n        }\n        else {\n            if (yargs.getExitProcess())\n                setBlocking(true);\n            if (!failureOutput) {\n                failureOutput = true;\n                if (showHelpOnFail) {\n                    yargs.showHelp('error');\n                    logger.error();\n                }\n                if (msg || err)\n                    logger.error(msg || err);\n                const globalOrCommandFailMessage = failMessage || globalFailMessage;\n                if (globalOrCommandFailMessage) {\n                    if (msg || err)\n                        logger.error('');\n                    logger.error(globalOrCommandFailMessage);\n                }\n            }\n            err = err || new YError(msg);\n            if (yargs.getExitProcess()) {\n                return yargs.exit(1);\n            }\n            else if (yargs.getInternalMethods().hasParseCallback()) {\n                return yargs.exit(1, err);\n            }\n            else {\n                throw err;\n            }\n        }\n    };\n    let usages = [];\n    let usageDisabled = false;\n    self.usage = (msg, description) => {\n        if (msg === null) {\n            usageDisabled = true;\n            usages = [];\n            return self;\n        }\n        usageDisabled = false;\n        usages.push([msg, description || '']);\n        return self;\n    };\n    self.getUsage = () => {\n        return usages;\n    };\n    self.getUsageDisabled = () => {\n        return usageDisabled;\n    };\n    self.getPositionalGroupName = () => {\n        return __('Positionals:');\n    };\n    let examples = [];\n    self.example = (cmd, description) => {\n        examples.push([cmd, description || '']);\n    };\n    let commands = [];\n    self.command = function command(cmd, description, isDefault, aliases, deprecated = false) {\n        if (isDefault) {\n            commands = commands.map(cmdArray => {\n                cmdArray[2] = false;\n                return cmdArray;\n            });\n        }\n        commands.push([cmd, description || '', isDefault, aliases, deprecated]);\n    };\n    self.getCommands = () => commands;\n    let descriptions = {};\n    self.describe = function describe(keyOrKeys, desc) {\n        if (Array.isArray(keyOrKeys)) {\n            keyOrKeys.forEach(k => {\n                self.describe(k, desc);\n            });\n        }\n        else if (typeof keyOrKeys === 'object') {\n            Object.keys(keyOrKeys).forEach(k => {\n                self.describe(k, keyOrKeys[k]);\n            });\n        }\n        else {\n            descriptions[keyOrKeys] = desc;\n        }\n    };\n    self.getDescriptions = () => descriptions;\n    let epilogs = [];\n    self.epilog = msg => {\n        epilogs.push(msg);\n    };\n    let wrapSet = false;\n    let wrap;\n    self.wrap = cols => {\n        wrapSet = true;\n        wrap = cols;\n    };\n    self.getWrap = () => {\n        if (shim.getEnv('YARGS_DISABLE_WRAP')) {\n            return null;\n        }\n        if (!wrapSet) {\n            wrap = windowWidth();\n            wrapSet = true;\n        }\n        return wrap;\n    };\n    const deferY18nLookupPrefix = '__yargsString__:';\n    self.deferY18nLookup = str => deferY18nLookupPrefix + str;\n    self.help = function help() {\n        if (cachedHelpMessage)\n            return cachedHelpMessage;\n        normalizeAliases();\n        const base$0 = yargs.customScriptName\n            ? yargs.$0\n            : shim.path.basename(yargs.$0);\n        const demandedOptions = yargs.getDemandedOptions();\n        const demandedCommands = yargs.getDemandedCommands();\n        const deprecatedOptions = yargs.getDeprecatedOptions();\n        const groups = yargs.getGroups();\n        const options = yargs.getOptions();\n        let keys = [];\n        keys = keys.concat(Object.keys(descriptions));\n        keys = keys.concat(Object.keys(demandedOptions));\n        keys = keys.concat(Object.keys(demandedCommands));\n        keys = keys.concat(Object.keys(options.default));\n        keys = keys.filter(filterHiddenOptions);\n        keys = Object.keys(keys.reduce((acc, key) => {\n            if (key !== '_')\n                acc[key] = true;\n            return acc;\n        }, {}));\n        const theWrap = self.getWrap();\n        const ui = shim.cliui({\n            width: theWrap,\n            wrap: !!theWrap,\n        });\n        if (!usageDisabled) {\n            if (usages.length) {\n                usages.forEach(usage => {\n                    ui.div({ text: `${usage[0].replace(/\\$0/g, base$0)}` });\n                    if (usage[1]) {\n                        ui.div({ text: `${usage[1]}`, padding: [1, 0, 0, 0] });\n                    }\n                });\n                ui.div();\n            }\n            else if (commands.length) {\n                let u = null;\n                if (demandedCommands._) {\n                    u = `${base$0} <${__('command')}>\\n`;\n                }\n                else {\n                    u = `${base$0} [${__('command')}]\\n`;\n                }\n                ui.div(`${u}`);\n            }\n        }\n        if (commands.length > 1 || (commands.length === 1 && !commands[0][2])) {\n            ui.div(__('Commands:'));\n            const context = yargs.getInternalMethods().getContext();\n            const parentCommands = context.commands.length\n                ? `${context.commands.join(' ')} `\n                : '';\n            if (yargs.getInternalMethods().getParserConfiguration()['sort-commands'] ===\n                true) {\n                commands = commands.sort((a, b) => a[0].localeCompare(b[0]));\n            }\n            const prefix = base$0 ? `${base$0} ` : '';\n            commands.forEach(command => {\n                const commandString = `${prefix}${parentCommands}${command[0].replace(/^\\$0 ?/, '')}`;\n                ui.span({\n                    text: commandString,\n                    padding: [0, 2, 0, 2],\n                    width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4,\n                }, { text: command[1] });\n                const hints = [];\n                if (command[2])\n                    hints.push(`[${__('default')}]`);\n                if (command[3] && command[3].length) {\n                    hints.push(`[${__('aliases:')} ${command[3].join(', ')}]`);\n                }\n                if (command[4]) {\n                    if (typeof command[4] === 'string') {\n                        hints.push(`[${__('deprecated: %s', command[4])}]`);\n                    }\n                    else {\n                        hints.push(`[${__('deprecated')}]`);\n                    }\n                }\n                if (hints.length) {\n                    ui.div({\n                        text: hints.join(' '),\n                        padding: [0, 0, 0, 2],\n                        align: 'right',\n                    });\n                }\n                else {\n                    ui.div();\n                }\n            });\n            ui.div();\n        }\n        const aliasKeys = (Object.keys(options.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []);\n        keys = keys.filter(key => !yargs.parsed.newAliases[key] &&\n            aliasKeys.every(alias => (options.alias[alias] || []).indexOf(key) === -1));\n        const defaultGroup = __('Options:');\n        if (!groups[defaultGroup])\n            groups[defaultGroup] = [];\n        addUngroupedKeys(keys, options.alias, groups, defaultGroup);\n        const isLongSwitch = (sw) => /^--/.test(getText(sw));\n        const displayedGroups = Object.keys(groups)\n            .filter(groupName => groups[groupName].length > 0)\n            .map(groupName => {\n            const normalizedKeys = groups[groupName]\n                .filter(filterHiddenOptions)\n                .map(key => {\n                if (aliasKeys.includes(key))\n                    return key;\n                for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {\n                    if ((options.alias[aliasKey] || []).includes(key))\n                        return aliasKey;\n                }\n                return key;\n            });\n            return { groupName, normalizedKeys };\n        })\n            .filter(({ normalizedKeys }) => normalizedKeys.length > 0)\n            .map(({ groupName, normalizedKeys }) => {\n            const switches = normalizedKeys.reduce((acc, key) => {\n                acc[key] = [key]\n                    .concat(options.alias[key] || [])\n                    .map(sw => {\n                    if (groupName === self.getPositionalGroupName())\n                        return sw;\n                    else {\n                        return ((/^[0-9]$/.test(sw)\n                            ? options.boolean.includes(key)\n                                ? '-'\n                                : '--'\n                            : sw.length > 1\n                                ? '--'\n                                : '-') + sw);\n                    }\n                })\n                    .sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2)\n                    ? 0\n                    : isLongSwitch(sw1)\n                        ? 1\n                        : -1)\n                    .join(', ');\n                return acc;\n            }, {});\n            return { groupName, normalizedKeys, switches };\n        });\n        const shortSwitchesUsed = displayedGroups\n            .filter(({ groupName }) => groupName !== self.getPositionalGroupName())\n            .some(({ normalizedKeys, switches }) => !normalizedKeys.every(key => isLongSwitch(switches[key])));\n        if (shortSwitchesUsed) {\n            displayedGroups\n                .filter(({ groupName }) => groupName !== self.getPositionalGroupName())\n                .forEach(({ normalizedKeys, switches }) => {\n                normalizedKeys.forEach(key => {\n                    if (isLongSwitch(switches[key])) {\n                        switches[key] = addIndentation(switches[key], '-x, '.length);\n                    }\n                });\n            });\n        }\n        displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => {\n            ui.div(groupName);\n            normalizedKeys.forEach(key => {\n                const kswitch = switches[key];\n                let desc = descriptions[key] || '';\n                let type = null;\n                if (desc.includes(deferY18nLookupPrefix))\n                    desc = __(desc.substring(deferY18nLookupPrefix.length));\n                if (options.boolean.includes(key))\n                    type = `[${__('boolean')}]`;\n                if (options.count.includes(key))\n                    type = `[${__('count')}]`;\n                if (options.string.includes(key))\n                    type = `[${__('string')}]`;\n                if (options.normalize.includes(key))\n                    type = `[${__('string')}]`;\n                if (options.array.includes(key))\n                    type = `[${__('array')}]`;\n                if (options.number.includes(key))\n                    type = `[${__('number')}]`;\n                const deprecatedExtra = (deprecated) => typeof deprecated === 'string'\n                    ? `[${__('deprecated: %s', deprecated)}]`\n                    : `[${__('deprecated')}]`;\n                const extra = [\n                    key in deprecatedOptions\n                        ? deprecatedExtra(deprecatedOptions[key])\n                        : null,\n                    type,\n                    key in demandedOptions ? `[${__('required')}]` : null,\n                    options.choices && options.choices[key]\n                        ? `[${__('choices:')} ${self.stringifiedValues(options.choices[key])}]`\n                        : null,\n                    defaultString(options.default[key], options.defaultDescription[key]),\n                ]\n                    .filter(Boolean)\n                    .join(' ');\n                ui.span({\n                    text: getText(kswitch),\n                    padding: [0, 2, 0, 2 + getIndentation(kswitch)],\n                    width: maxWidth(switches, theWrap) + 4,\n                }, desc);\n                const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()['hide-types'] ===\n                    true;\n                if (extra && !shouldHideOptionExtras)\n                    ui.div({ text: extra, padding: [0, 0, 0, 2], align: 'right' });\n                else\n                    ui.div();\n            });\n            ui.div();\n        });\n        if (examples.length) {\n            ui.div(__('Examples:'));\n            examples.forEach(example => {\n                example[0] = example[0].replace(/\\$0/g, base$0);\n            });\n            examples.forEach(example => {\n                if (example[1] === '') {\n                    ui.div({\n                        text: example[0],\n                        padding: [0, 2, 0, 2],\n                    });\n                }\n                else {\n                    ui.div({\n                        text: example[0],\n                        padding: [0, 2, 0, 2],\n                        width: maxWidth(examples, theWrap) + 4,\n                    }, {\n                        text: example[1],\n                    });\n                }\n            });\n            ui.div();\n        }\n        if (epilogs.length > 0) {\n            const e = epilogs\n                .map(epilog => epilog.replace(/\\$0/g, base$0))\n                .join('\\n');\n            ui.div(`${e}\\n`);\n        }\n        return ui.toString().replace(/\\s*$/, '');\n    };\n    function maxWidth(table, theWrap, modifier) {\n        let width = 0;\n        if (!Array.isArray(table)) {\n            table = Object.values(table).map(v => [v]);\n        }\n        table.forEach(v => {\n            width = Math.max(shim.stringWidth(modifier ? `${modifier} ${getText(v[0])}` : getText(v[0])) + getIndentation(v[0]), width);\n        });\n        if (theWrap)\n            width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10));\n        return width;\n    }\n    function normalizeAliases() {\n        const demandedOptions = yargs.getDemandedOptions();\n        const options = yargs.getOptions();\n        (Object.keys(options.alias) || []).forEach(key => {\n            options.alias[key].forEach(alias => {\n                if (descriptions[alias])\n                    self.describe(key, descriptions[alias]);\n                if (alias in demandedOptions)\n                    yargs.demandOption(key, demandedOptions[alias]);\n                if (options.boolean.includes(alias))\n                    yargs.boolean(key);\n                if (options.count.includes(alias))\n                    yargs.count(key);\n                if (options.string.includes(alias))\n                    yargs.string(key);\n                if (options.normalize.includes(alias))\n                    yargs.normalize(key);\n                if (options.array.includes(alias))\n                    yargs.array(key);\n                if (options.number.includes(alias))\n                    yargs.number(key);\n            });\n        });\n    }\n    let cachedHelpMessage;\n    self.cacheHelpMessage = function () {\n        cachedHelpMessage = this.help();\n    };\n    self.clearCachedHelpMessage = function () {\n        cachedHelpMessage = undefined;\n    };\n    self.hasCachedHelpMessage = function () {\n        return !!cachedHelpMessage;\n    };\n    function addUngroupedKeys(keys, aliases, groups, defaultGroup) {\n        let groupedKeys = [];\n        let toCheck = null;\n        Object.keys(groups).forEach(group => {\n            groupedKeys = groupedKeys.concat(groups[group]);\n        });\n        keys.forEach(key => {\n            toCheck = [key].concat(aliases[key]);\n            if (!toCheck.some(k => groupedKeys.indexOf(k) !== -1)) {\n                groups[defaultGroup].push(key);\n            }\n        });\n        return groupedKeys;\n    }\n    function filterHiddenOptions(key) {\n        return (yargs.getOptions().hiddenOptions.indexOf(key) < 0 ||\n            yargs.parsed.argv[yargs.getOptions().showHiddenOpt]);\n    }\n    self.showHelp = (level) => {\n        const logger = yargs.getInternalMethods().getLoggerInstance();\n        if (!level)\n            level = 'error';\n        const emit = typeof level === 'function' ? level : logger[level];\n        emit(self.help());\n    };\n    self.functionDescription = fn => {\n        const description = fn.name\n            ? shim.Parser.decamelize(fn.name, '-')\n            : __('generated-value');\n        return ['(', description, ')'].join('');\n    };\n    self.stringifiedValues = function stringifiedValues(values, separator) {\n        let string = '';\n        const sep = separator || ', ';\n        const array = [].concat(values);\n        if (!values || !array.length)\n            return string;\n        array.forEach(value => {\n            if (string.length)\n                string += sep;\n            string += JSON.stringify(value);\n        });\n        return string;\n    };\n    function defaultString(value, defaultDescription) {\n        let string = `[${__('default:')} `;\n        if (value === undefined && !defaultDescription)\n            return null;\n        if (defaultDescription) {\n            string += defaultDescription;\n        }\n        else {\n            switch (typeof value) {\n                case 'string':\n                    string += `\"${value}\"`;\n                    break;\n                case 'object':\n                    string += JSON.stringify(value);\n                    break;\n                default:\n                    string += value;\n            }\n        }\n        return `${string}]`;\n    }\n    function windowWidth() {\n        const maxWidth = 80;\n        if (shim.process.stdColumns) {\n            return Math.min(maxWidth, shim.process.stdColumns);\n        }\n        else {\n            return maxWidth;\n        }\n    }\n    let version = null;\n    self.version = ver => {\n        version = ver;\n    };\n    self.showVersion = level => {\n        const logger = yargs.getInternalMethods().getLoggerInstance();\n        if (!level)\n            level = 'error';\n        const emit = typeof level === 'function' ? level : logger[level];\n        emit(version);\n    };\n    self.reset = function reset(localLookup) {\n        failMessage = null;\n        failureOutput = false;\n        usages = [];\n        usageDisabled = false;\n        epilogs = [];\n        examples = [];\n        commands = [];\n        descriptions = objFilter(descriptions, k => !localLookup[k]);\n        return self;\n    };\n    const frozens = [];\n    self.freeze = function freeze() {\n        frozens.push({\n            failMessage,\n            failureOutput,\n            usages,\n            usageDisabled,\n            epilogs,\n            examples,\n            commands,\n            descriptions,\n        });\n    };\n    self.unfreeze = function unfreeze(defaultCommand = false) {\n        const frozen = frozens.pop();\n        if (!frozen)\n            return;\n        if (defaultCommand) {\n            descriptions = { ...frozen.descriptions, ...descriptions };\n            commands = [...frozen.commands, ...commands];\n            usages = [...frozen.usages, ...usages];\n            examples = [...frozen.examples, ...examples];\n            epilogs = [...frozen.epilogs, ...epilogs];\n        }\n        else {\n            ({\n                failMessage,\n                failureOutput,\n                usages,\n                usageDisabled,\n                epilogs,\n                examples,\n                commands,\n                descriptions,\n            } = frozen);\n        }\n    };\n    return self;\n}\nfunction isIndentedText(text) {\n    return typeof text === 'object';\n}\nfunction addIndentation(text, indent) {\n    return isIndentedText(text)\n        ? { text: text.text, indentation: text.indentation + indent }\n        : { text, indentation: indent };\n}\nfunction getIndentation(text) {\n    return isIndentedText(text) ? text.indentation : 0;\n}\nfunction getText(text) {\n    return isIndentedText(text) ? text.text : text;\n}\n","import { objectKeys } from '../typings/common-types.js';\nexport function objFilter(original = {}, filter = () => true) {\n    const obj = {};\n    objectKeys(original).forEach(key => {\n        if (filter(key, original[key])) {\n            obj[key] = original[key];\n        }\n    });\n    return obj;\n}\n","export default function setBlocking(blocking) {\n    if (typeof process === 'undefined')\n        return;\n    [process.stdout, process.stderr].forEach(_stream => {\n        const stream = _stream;\n        if (stream._handle &&\n            stream.isTTY &&\n            typeof stream._handle.setBlocking === 'function') {\n            stream._handle.setBlocking(blocking);\n        }\n    });\n}\n","import { isCommandBuilderCallback } from './command.js';\nimport { assertNotStrictEqual } from './typings/common-types.js';\nimport * as templates from './completion-templates.js';\nimport { isPromise } from './utils/is-promise.js';\nimport { parseCommand } from './parse-command.js';\nexport class Completion {\n    constructor(yargs, usage, command, shim) {\n        var _a, _b, _c;\n        this.yargs = yargs;\n        this.usage = usage;\n        this.command = command;\n        this.shim = shim;\n        this.completionKey = 'get-yargs-completions';\n        this.aliases = null;\n        this.customCompletionFunction = null;\n        this.indexAfterLastReset = 0;\n        this.zshShell =\n            (_c = (((_a = this.shim.getEnv('SHELL')) === null || _a === void 0 ? void 0 : _a.includes('zsh')) ||\n                ((_b = this.shim.getEnv('ZSH_NAME')) === null || _b === void 0 ? void 0 : _b.includes('zsh')))) !== null && _c !== void 0 ? _c : false;\n    }\n    defaultCompletion(args, argv, current, done) {\n        const handlers = this.command.getCommandHandlers();\n        for (let i = 0, ii = args.length; i < ii; ++i) {\n            if (handlers[args[i]] && handlers[args[i]].builder) {\n                const builder = handlers[args[i]].builder;\n                if (isCommandBuilderCallback(builder)) {\n                    this.indexAfterLastReset = i + 1;\n                    const y = this.yargs.getInternalMethods().reset();\n                    builder(y, true);\n                    return y.argv;\n                }\n            }\n        }\n        const completions = [];\n        this.commandCompletions(completions, args, current);\n        this.optionCompletions(completions, args, argv, current);\n        this.choicesFromOptionsCompletions(completions, args, argv, current);\n        this.choicesFromPositionalsCompletions(completions, args, argv, current);\n        done(null, completions);\n    }\n    commandCompletions(completions, args, current) {\n        const parentCommands = this.yargs\n            .getInternalMethods()\n            .getContext().commands;\n        if (!current.match(/^-/) &&\n            parentCommands[parentCommands.length - 1] !== current &&\n            !this.previousArgHasChoices(args)) {\n            this.usage.getCommands().forEach(usageCommand => {\n                const commandName = parseCommand(usageCommand[0]).cmd;\n                if (args.indexOf(commandName) === -1) {\n                    if (!this.zshShell) {\n                        completions.push(commandName);\n                    }\n                    else {\n                        const desc = usageCommand[1] || '';\n                        completions.push(commandName.replace(/:/g, '\\\\:') + ':' + desc);\n                    }\n                }\n            });\n        }\n    }\n    optionCompletions(completions, args, argv, current) {\n        if ((current.match(/^-/) || (current === '' && completions.length === 0)) &&\n            !this.previousArgHasChoices(args)) {\n            const options = this.yargs.getOptions();\n            const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];\n            Object.keys(options.key).forEach(key => {\n                const negable = !!options.configuration['boolean-negation'] &&\n                    options.boolean.includes(key);\n                const isPositionalKey = positionalKeys.includes(key);\n                if (!isPositionalKey &&\n                    !options.hiddenOptions.includes(key) &&\n                    !this.argsContainKey(args, key, negable)) {\n                    this.completeOptionKey(key, completions, current, negable && !!options.default[key]);\n                }\n            });\n        }\n    }\n    choicesFromOptionsCompletions(completions, args, argv, current) {\n        if (this.previousArgHasChoices(args)) {\n            const choices = this.getPreviousArgChoices(args);\n            if (choices && choices.length > 0) {\n                completions.push(...choices.map(c => c.replace(/:/g, '\\\\:')));\n            }\n        }\n    }\n    choicesFromPositionalsCompletions(completions, args, argv, current) {\n        if (current === '' &&\n            completions.length > 0 &&\n            this.previousArgHasChoices(args)) {\n            return;\n        }\n        const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];\n        const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length +\n            1);\n        const positionalKey = positionalKeys[argv._.length - offset - 1];\n        if (!positionalKey) {\n            return;\n        }\n        const choices = this.yargs.getOptions().choices[positionalKey] || [];\n        for (const choice of choices) {\n            if (choice.startsWith(current)) {\n                completions.push(choice.replace(/:/g, '\\\\:'));\n            }\n        }\n    }\n    getPreviousArgChoices(args) {\n        if (args.length < 1)\n            return;\n        let previousArg = args[args.length - 1];\n        let filter = '';\n        if (!previousArg.startsWith('-') && args.length > 1) {\n            filter = previousArg;\n            previousArg = args[args.length - 2];\n        }\n        if (!previousArg.startsWith('-'))\n            return;\n        const previousArgKey = previousArg.replace(/^-+/, '');\n        const options = this.yargs.getOptions();\n        const possibleAliases = [\n            previousArgKey,\n            ...(this.yargs.getAliases()[previousArgKey] || []),\n        ];\n        let choices;\n        for (const possibleAlias of possibleAliases) {\n            if (Object.prototype.hasOwnProperty.call(options.key, possibleAlias) &&\n                Array.isArray(options.choices[possibleAlias])) {\n                choices = options.choices[possibleAlias];\n                break;\n            }\n        }\n        if (choices) {\n            return choices.filter(choice => !filter || choice.startsWith(filter));\n        }\n    }\n    previousArgHasChoices(args) {\n        const choices = this.getPreviousArgChoices(args);\n        return choices !== undefined && choices.length > 0;\n    }\n    argsContainKey(args, key, negable) {\n        const argsContains = (s) => args.indexOf((/^[^0-9]$/.test(s) ? '-' : '--') + s) !== -1;\n        if (argsContains(key))\n            return true;\n        if (negable && argsContains(`no-${key}`))\n            return true;\n        if (this.aliases) {\n            for (const alias of this.aliases[key]) {\n                if (argsContains(alias))\n                    return true;\n            }\n        }\n        return false;\n    }\n    completeOptionKey(key, completions, current, negable) {\n        var _a, _b, _c, _d;\n        let keyWithDesc = key;\n        if (this.zshShell) {\n            const descs = this.usage.getDescriptions();\n            const aliasKey = (_b = (_a = this === null || this === void 0 ? void 0 : this.aliases) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.find(alias => {\n                const desc = descs[alias];\n                return typeof desc === 'string' && desc.length > 0;\n            });\n            const descFromAlias = aliasKey ? descs[aliasKey] : undefined;\n            const desc = (_d = (_c = descs[key]) !== null && _c !== void 0 ? _c : descFromAlias) !== null && _d !== void 0 ? _d : '';\n            keyWithDesc = `${key.replace(/:/g, '\\\\:')}:${desc\n                .replace('__yargsString__:', '')\n                .replace(/(\\r\\n|\\n|\\r)/gm, ' ')}`;\n        }\n        const startsByTwoDashes = (s) => /^--/.test(s);\n        const isShortOption = (s) => /^[^0-9]$/.test(s);\n        const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';\n        completions.push(dashes + keyWithDesc);\n        if (negable) {\n            completions.push(dashes + 'no-' + keyWithDesc);\n        }\n    }\n    customCompletion(args, argv, current, done) {\n        assertNotStrictEqual(this.customCompletionFunction, null, this.shim);\n        if (isSyncCompletionFunction(this.customCompletionFunction)) {\n            const result = this.customCompletionFunction(current, argv);\n            if (isPromise(result)) {\n                return result\n                    .then(list => {\n                    this.shim.process.nextTick(() => {\n                        done(null, list);\n                    });\n                })\n                    .catch(err => {\n                    this.shim.process.nextTick(() => {\n                        done(err, undefined);\n                    });\n                });\n            }\n            return done(null, result);\n        }\n        else if (isFallbackCompletionFunction(this.customCompletionFunction)) {\n            return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), completions => {\n                done(null, completions);\n            });\n        }\n        else {\n            return this.customCompletionFunction(current, argv, completions => {\n                done(null, completions);\n            });\n        }\n    }\n    getCompletion(args, done) {\n        const current = args.length ? args[args.length - 1] : '';\n        const argv = this.yargs.parse(args, true);\n        const completionFunction = this.customCompletionFunction\n            ? (argv) => this.customCompletion(args, argv, current, done)\n            : (argv) => this.defaultCompletion(args, argv, current, done);\n        return isPromise(argv)\n            ? argv.then(completionFunction)\n            : completionFunction(argv);\n    }\n    generateCompletionScript($0, cmd) {\n        let script = this.zshShell\n            ? templates.completionZshTemplate\n            : templates.completionShTemplate;\n        const name = this.shim.path.basename($0);\n        if ($0.match(/\\.js$/))\n            $0 = `./${$0}`;\n        script = script.replace(/{{app_name}}/g, name);\n        script = script.replace(/{{completion_command}}/g, cmd);\n        return script.replace(/{{app_path}}/g, $0);\n    }\n    registerFunction(fn) {\n        this.customCompletionFunction = fn;\n    }\n    setParsed(parsed) {\n        this.aliases = parsed.aliases;\n    }\n}\nexport function completion(yargs, usage, command, shim) {\n    return new Completion(yargs, usage, command, shim);\n}\nfunction isSyncCompletionFunction(completionFunction) {\n    return completionFunction.length < 3;\n}\nfunction isFallbackCompletionFunction(completionFunction) {\n    return completionFunction.length > 3;\n}\n","export 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_{{app_name}}_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 bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}}\n###-end-{{app_name}}-completions-###\n`;\nexport const completionZshTemplate = `#compdef {{app_name}}\n###-begin-{{app_name}}-completions-###\n#\n# yargs command completion script\n#\n# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc\n#    or {{app_path}} {{completion_command}} >> ~/.zprofile 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`;\n","import { argsert } from './argsert.js';\nimport { assertNotStrictEqual, } from './typings/common-types.js';\nimport { levenshtein as distance } from './utils/levenshtein.js';\nimport { objFilter } from './utils/obj-filter.js';\nconst specialKeys = ['$0', '--', '_'];\nexport function validation(yargs, usage, shim) {\n    const __ = shim.y18n.__;\n    const __n = shim.y18n.__n;\n    const self = {};\n    self.nonOptionCount = function nonOptionCount(argv) {\n        const demandedCommands = yargs.getDemandedCommands();\n        const positionalCount = argv._.length + (argv['--'] ? argv['--'].length : 0);\n        const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;\n        if (demandedCommands._ &&\n            (_s < demandedCommands._.min || _s > demandedCommands._.max)) {\n            if (_s < demandedCommands._.min) {\n                if (demandedCommands._.minMsg !== undefined) {\n                    usage.fail(demandedCommands._.minMsg\n                        ? demandedCommands._.minMsg\n                            .replace(/\\$0/g, _s.toString())\n                            .replace(/\\$1/, demandedCommands._.min.toString())\n                        : null);\n                }\n                else {\n                    usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', _s, _s.toString(), demandedCommands._.min.toString()));\n                }\n            }\n            else if (_s > demandedCommands._.max) {\n                if (demandedCommands._.maxMsg !== undefined) {\n                    usage.fail(demandedCommands._.maxMsg\n                        ? demandedCommands._.maxMsg\n                            .replace(/\\$0/g, _s.toString())\n                            .replace(/\\$1/, demandedCommands._.max.toString())\n                        : null);\n                }\n                else {\n                    usage.fail(__n('Too many non-option arguments: got %s, maximum of %s', 'Too many non-option arguments: got %s, maximum of %s', _s, _s.toString(), demandedCommands._.max.toString()));\n                }\n            }\n        }\n    };\n    self.positionalCount = function positionalCount(required, observed) {\n        if (observed < required) {\n            usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed + '', required + ''));\n        }\n    };\n    self.requiredArguments = function requiredArguments(argv, demandedOptions) {\n        let missing = null;\n        for (const key of Object.keys(demandedOptions)) {\n            if (!Object.prototype.hasOwnProperty.call(argv, key) ||\n                typeof argv[key] === 'undefined') {\n                missing = missing || {};\n                missing[key] = demandedOptions[key];\n            }\n        }\n        if (missing) {\n            const customMsgs = [];\n            for (const key of Object.keys(missing)) {\n                const msg = missing[key];\n                if (msg && customMsgs.indexOf(msg) < 0) {\n                    customMsgs.push(msg);\n                }\n            }\n            const customMsg = customMsgs.length ? `\\n${customMsgs.join('\\n')}` : '';\n            usage.fail(__n('Missing required argument: %s', 'Missing required arguments: %s', Object.keys(missing).length, Object.keys(missing).join(', ') + customMsg));\n        }\n    };\n    self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {\n        var _a;\n        const commandKeys = yargs\n            .getInternalMethods()\n            .getCommandInstance()\n            .getCommands();\n        const unknown = [];\n        const currentContext = yargs.getInternalMethods().getContext();\n        Object.keys(argv).forEach(key => {\n            if (!specialKeys.includes(key) &&\n                !Object.prototype.hasOwnProperty.call(positionalMap, key) &&\n                !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) &&\n                !self.isValidAndSomeAliasIsNotNew(key, aliases)) {\n                unknown.push(key);\n            }\n        });\n        if (checkPositionals &&\n            (currentContext.commands.length > 0 ||\n                commandKeys.length > 0 ||\n                isDefaultCommand)) {\n            argv._.slice(currentContext.commands.length).forEach(key => {\n                if (!commandKeys.includes('' + key)) {\n                    unknown.push('' + key);\n                }\n            });\n        }\n        if (checkPositionals) {\n            const demandedCommands = yargs.getDemandedCommands();\n            const maxNonOptDemanded = ((_a = demandedCommands._) === null || _a === void 0 ? void 0 : _a.max) || 0;\n            const expected = currentContext.commands.length + maxNonOptDemanded;\n            if (expected < argv._.length) {\n                argv._.slice(expected).forEach(key => {\n                    key = String(key);\n                    if (!currentContext.commands.includes(key) &&\n                        !unknown.includes(key)) {\n                        unknown.push(key);\n                    }\n                });\n            }\n        }\n        if (unknown.length) {\n            usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.map(s => (s.trim() ? s : `\"${s}\"`)).join(', ')));\n        }\n    };\n    self.unknownCommands = function unknownCommands(argv) {\n        const commandKeys = yargs\n            .getInternalMethods()\n            .getCommandInstance()\n            .getCommands();\n        const unknown = [];\n        const currentContext = yargs.getInternalMethods().getContext();\n        if (currentContext.commands.length > 0 || commandKeys.length > 0) {\n            argv._.slice(currentContext.commands.length).forEach(key => {\n                if (!commandKeys.includes('' + key)) {\n                    unknown.push('' + key);\n                }\n            });\n        }\n        if (unknown.length > 0) {\n            usage.fail(__n('Unknown command: %s', 'Unknown commands: %s', unknown.length, unknown.join(', ')));\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {\n        if (!Object.prototype.hasOwnProperty.call(aliases, key)) {\n            return false;\n        }\n        const newAliases = yargs.parsed.newAliases;\n        return [key, ...aliases[key]].some(a => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);\n    };\n    self.limitedChoices = function limitedChoices(argv) {\n        const options = yargs.getOptions();\n        const invalid = {};\n        if (!Object.keys(options.choices).length)\n            return;\n        Object.keys(argv).forEach(key => {\n            if (specialKeys.indexOf(key) === -1 &&\n                Object.prototype.hasOwnProperty.call(options.choices, key)) {\n                [].concat(argv[key]).forEach(value => {\n                    if (options.choices[key].indexOf(value) === -1 &&\n                        value !== undefined) {\n                        invalid[key] = (invalid[key] || []).concat(value);\n                    }\n                });\n            }\n        });\n        const invalidKeys = Object.keys(invalid);\n        if (!invalidKeys.length)\n            return;\n        let msg = __('Invalid values:');\n        invalidKeys.forEach(key => {\n            msg += `\\n  ${__('Argument: %s, Given: %s, Choices: %s', key, usage.stringifiedValues(invalid[key]), usage.stringifiedValues(options.choices[key]))}`;\n        });\n        usage.fail(msg);\n    };\n    let implied = {};\n    self.implies = function implies(key, value) {\n        argsert('<string|object> [array|number|string]', [key, value], arguments.length);\n        if (typeof key === 'object') {\n            Object.keys(key).forEach(k => {\n                self.implies(k, key[k]);\n            });\n        }\n        else {\n            yargs.global(key);\n            if (!implied[key]) {\n                implied[key] = [];\n            }\n            if (Array.isArray(value)) {\n                value.forEach(i => self.implies(key, i));\n            }\n            else {\n                assertNotStrictEqual(value, undefined, shim);\n                implied[key].push(value);\n            }\n        }\n    };\n    self.getImplied = function getImplied() {\n        return implied;\n    };\n    function keyExists(argv, val) {\n        const num = Number(val);\n        val = isNaN(num) ? val : num;\n        if (typeof val === 'number') {\n            val = argv._.length >= val;\n        }\n        else if (val.match(/^--no-.+/)) {\n            val = val.match(/^--no-(.+)/)[1];\n            val = !Object.prototype.hasOwnProperty.call(argv, val);\n        }\n        else {\n            val = Object.prototype.hasOwnProperty.call(argv, val);\n        }\n        return val;\n    }\n    self.implications = function implications(argv) {\n        const implyFail = [];\n        Object.keys(implied).forEach(key => {\n            const origKey = key;\n            (implied[key] || []).forEach(value => {\n                let key = origKey;\n                const origValue = value;\n                key = keyExists(argv, key);\n                value = keyExists(argv, value);\n                if (key && !value) {\n                    implyFail.push(` ${origKey} -> ${origValue}`);\n                }\n            });\n        });\n        if (implyFail.length) {\n            let msg = `${__('Implications failed:')}\\n`;\n            implyFail.forEach(value => {\n                msg += value;\n            });\n            usage.fail(msg);\n        }\n    };\n    let conflicting = {};\n    self.conflicts = function conflicts(key, value) {\n        argsert('<string|object> [array|string]', [key, value], arguments.length);\n        if (typeof key === 'object') {\n            Object.keys(key).forEach(k => {\n                self.conflicts(k, key[k]);\n            });\n        }\n        else {\n            yargs.global(key);\n            if (!conflicting[key]) {\n                conflicting[key] = [];\n            }\n            if (Array.isArray(value)) {\n                value.forEach(i => self.conflicts(key, i));\n            }\n            else {\n                conflicting[key].push(value);\n            }\n        }\n    };\n    self.getConflicting = () => conflicting;\n    self.conflicting = function conflictingFn(argv) {\n        Object.keys(argv).forEach(key => {\n            if (conflicting[key]) {\n                conflicting[key].forEach(value => {\n                    if (value && argv[key] !== undefined && argv[value] !== undefined) {\n                        usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));\n                    }\n                });\n            }\n        });\n        if (yargs.getInternalMethods().getParserConfiguration()['strip-dashed']) {\n            Object.keys(conflicting).forEach(key => {\n                conflicting[key].forEach(value => {\n                    if (value &&\n                        argv[shim.Parser.camelCase(key)] !== undefined &&\n                        argv[shim.Parser.camelCase(value)] !== undefined) {\n                        usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));\n                    }\n                });\n            });\n        }\n    };\n    self.recommendCommands = function recommendCommands(cmd, potentialCommands) {\n        const threshold = 3;\n        potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);\n        let recommended = null;\n        let bestDistance = Infinity;\n        for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {\n            const d = distance(cmd, candidate);\n            if (d <= threshold && d < bestDistance) {\n                bestDistance = d;\n                recommended = candidate;\n            }\n        }\n        if (recommended)\n            usage.fail(__('Did you mean %s?', recommended));\n    };\n    self.reset = function reset(localLookup) {\n        implied = objFilter(implied, k => !localLookup[k]);\n        conflicting = objFilter(conflicting, k => !localLookup[k]);\n        return self;\n    };\n    const frozens = [];\n    self.freeze = function freeze() {\n        frozens.push({\n            implied,\n            conflicting,\n        });\n    };\n    self.unfreeze = function unfreeze() {\n        const frozen = frozens.pop();\n        assertNotStrictEqual(frozen, undefined, shim);\n        ({ implied, conflicting } = frozen);\n    };\n    return self;\n}\n","export function levenshtein(a, b) {\n    if (a.length === 0)\n        return b.length;\n    if (b.length === 0)\n        return a.length;\n    const matrix = [];\n    let i;\n    for (i = 0; i <= b.length; i++) {\n        matrix[i] = [i];\n    }\n    let j;\n    for (j = 0; j <= a.length; j++) {\n        matrix[0][j] = j;\n    }\n    for (i = 1; i <= b.length; i++) {\n        for (j = 1; j <= a.length; j++) {\n            if (b.charAt(i - 1) === a.charAt(j - 1)) {\n                matrix[i][j] = matrix[i - 1][j - 1];\n            }\n            else {\n                if (i > 1 &&\n                    j > 1 &&\n                    b.charAt(i - 2) === a.charAt(j - 1) &&\n                    b.charAt(i - 1) === a.charAt(j - 2)) {\n                    matrix[i][j] = matrix[i - 2][j - 2] + 1;\n                }\n                else {\n                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));\n                }\n            }\n        }\n    }\n    return matrix[b.length][a.length];\n}\n","import { YError } from '../yerror.js';\nlet previouslyVisitedConfigs = [];\nlet shim;\nexport function applyExtends(config, cwd, mergeExtends, _shim) {\n    shim = _shim;\n    let defaultConfig = {};\n    if (Object.prototype.hasOwnProperty.call(config, 'extends')) {\n        if (typeof config.extends !== 'string')\n            return defaultConfig;\n        const isPath = /\\.json|\\..*rc$/.test(config.extends);\n        let pathToDefault = null;\n        if (!isPath) {\n            try {\n                pathToDefault = require.resolve(config.extends);\n            }\n            catch (_err) {\n                return config;\n            }\n        }\n        else {\n            pathToDefault = getPathToDefaultConfig(cwd, config.extends);\n        }\n        checkForCircularExtends(pathToDefault);\n        previouslyVisitedConfigs.push(pathToDefault);\n        defaultConfig = isPath\n            ? JSON.parse(shim.readFileSync(pathToDefault, 'utf8'))\n            : require(config.extends);\n        delete config.extends;\n        defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);\n    }\n    previouslyVisitedConfigs = [];\n    return mergeExtends\n        ? mergeDeep(defaultConfig, config)\n        : Object.assign({}, defaultConfig, config);\n}\nfunction checkForCircularExtends(cfgPath) {\n    if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {\n        throw new YError(`Circular extended configurations: '${cfgPath}'.`);\n    }\n}\nfunction getPathToDefaultConfig(cwd, pathToExtend) {\n    return shim.path.resolve(cwd, pathToExtend);\n}\nfunction mergeDeep(config1, config2) {\n    const target = {};\n    function isObject(obj) {\n        return obj && typeof obj === 'object' && !Array.isArray(obj);\n    }\n    Object.assign(target, config1);\n    for (const key of Object.keys(config2)) {\n        if (isObject(config2[key]) && isObject(target[key])) {\n            target[key] = mergeDeep(config1[key], config2[key]);\n        }\n        else {\n            target[key] = config2[key];\n        }\n    }\n    return target;\n}\n","import {applyExtends as _applyExtends} from '../build/lib/utils/apply-extends.js';\nimport {hideBin} from '../build/lib/utils/process-argv.js';\nimport Parser from 'yargs-parser';\nimport shim from '../lib/platform-shims/esm.mjs';\n\nconst applyExtends = (config, cwd, mergeExtends) => {\n  return _applyExtends(config, cwd, mergeExtends, shim);\n};\n\nexport {applyExtends, hideBin, Parser};\n"]}