@guanghechen/commander 4.7.0 → 4.7.2

package/lib/cjs/index.cjs

@@ -0,0 +1,2089 @@
+'use strict';
+
+var env = require('@guanghechen/env');
+var reporter = require('@guanghechen/reporter');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var fs = require('node:fs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
+const TERMINAL_STYLE = {
+    bold: '\x1b[1m',
+    italic: '\x1b[3m',
+    underline: '\x1b[4m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m',
+    reset: '\x1b[0m',
+};
+function styleText(text, ...styles) {
+    return `${styles.join('')}${text}${TERMINAL_STYLE.reset}`;
+}
+
+const BUILTIN_LOG_LEVELS = ['debug', 'info', 'hint', 'warn', 'error'];
+function resolveReporterLogLevel(raw) {
+    const normalized = raw.trim().toLowerCase();
+    return BUILTIN_LOG_LEVELS.find(level => level === normalized);
+}
+function setReporterLevel(ctx, level) {
+    const reporter = ctx.reporter;
+    reporter?.setLevel?.(level);
+}
+function setReporterFlight(ctx, flight) {
+    const reporter = ctx.reporter;
+    reporter?.setFlight?.(flight);
+}
+const logLevelOption = {
+    long: 'logLevel',
+    type: 'string',
+    args: 'required',
+    desc: 'Set log level',
+    default: 'info',
+    choices: [...BUILTIN_LOG_LEVELS],
+    coerce: (raw) => {
+        const level = resolveReporterLogLevel(raw);
+        if (level === undefined) {
+            throw new Error(`Invalid log level: ${raw}`);
+        }
+        return level;
+    },
+    apply: (value, ctx) => {
+        setReporterLevel(ctx, value);
+    },
+};
+const logDateOption = {
+    long: 'logDate',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Enable log timestamp',
+    default: true,
+    apply: (value, ctx) => {
+        setReporterFlight(ctx, { date: Boolean(value) });
+    },
+};
+const logColorfulOption = {
+    long: 'logColorful',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Enable colorful log output',
+    default: true,
+    apply: (value, ctx) => {
+        setReporterFlight(ctx, { color: Boolean(value) });
+    },
+};
+const silentOption = {
+    long: 'silent',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Suppress non-error output',
+    default: false,
+    apply: (value, ctx) => {
+        if (value) {
+            setReporterLevel(ctx, 'error');
+        }
+    },
+};
+
+class CommanderError extends Error {
+    kind;
+    commandPath;
+    constructor(kind, message, commandPath) {
+        super(message);
+        this.name = 'CommanderError';
+        this.kind = kind;
+        this.commandPath = commandPath;
+    }
+    format() {
+        return `Error: ${this.message}\nRun "${this.commandPath} --help" for usage.`;
+    }
+}
+
+const LONG_OPTION_REGEX = /^--[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const NEGATIVE_OPTION_REGEX = /^--no-[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const PRESET_OPTS_FLAG = '--preset-opts';
+const PRESET_ENVS_FLAG = '--preset-envs';
+const PRESET_ROOT_FLAG = '--preset-root';
+const DEFAULT_PRESET_OPTS_FILENAME = '.opt.local';
+const DEFAULT_PRESET_ENVS_FILENAME = '.env.local';
+function kebabToCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelToKebabCase$1(str) {
+    return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+}
+function tokenizeLongOption(arg, commandPath) {
+    const eqIdx = arg.indexOf('=');
+    const namePart = eqIdx !== -1 ? arg.slice(0, eqIdx) : arg;
+    const valuePart = eqIdx !== -1 ? arg.slice(eqIdx) : '';
+    if (namePart.includes('_')) {
+        throw new CommanderError('InvalidOptionFormat', `invalid option "${arg}": use '-' instead of '_'`, commandPath);
+    }
+    const lowerName = namePart.toLowerCase();
+    if (lowerName === '--no' || lowerName === '--no-') {
+        throw new CommanderError('InvalidNegativeOption', `invalid negative option syntax "${arg}"`, commandPath);
+    }
+    if (lowerName.startsWith('--no-')) {
+        if (valuePart !== '') {
+            throw new CommanderError('NegativeOptionWithValue', `"${namePart}" does not accept a value`, commandPath);
+        }
+        if (!NEGATIVE_OPTION_REGEX.test(lowerName)) {
+            throw new CommanderError('InvalidOptionFormat', `invalid option format "${arg}"`, commandPath);
+        }
+        const camelName = kebabToCamelCase(lowerName.slice(5));
+        return {
+            original: arg,
+            resolved: `--${camelName}=false`,
+            name: camelName,
+            type: 'long',
+        };
+    }
+    if (!LONG_OPTION_REGEX.test(lowerName)) {
+        throw new CommanderError('InvalidOptionFormat', `invalid option format "${arg}"`, commandPath);
+    }
+    const camelName = kebabToCamelCase(lowerName.slice(2));
+    return {
+        original: arg,
+        resolved: `--${camelName}${valuePart}`,
+        name: camelName,
+        type: 'long',
+    };
+}
+function tokenizeShortOptions(arg, commandPath) {
+    if (arg.includes('=')) {
+        throw new CommanderError('UnsupportedShortSyntax', `"${arg}" is not supported. Use "-${arg[1]} ${arg.slice(3)}" instead`, commandPath);
+    }
+    const flags = arg.slice(1);
+    return flags.split('').map(flag => ({
+        original: `-${flag}`,
+        resolved: `-${flag}`,
+        name: flag,
+        type: 'short',
+    }));
+}
+function tokenize(argv, commandPath) {
+    const optionTokens = [];
+    const restArgs = [];
+    let passThrough = false;
+    for (const arg of argv) {
+        if (arg === '--') {
+            passThrough = true;
+            continue;
+        }
+        if (passThrough) {
+            restArgs.push(arg);
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            optionTokens.push(tokenizeLongOption(arg, commandPath));
+            continue;
+        }
+        if (arg.startsWith('-') && arg.length > 1) {
+            optionTokens.push(...tokenizeShortOptions(arg, commandPath));
+            continue;
+        }
+        optionTokens.push({
+            original: arg,
+            resolved: arg,
+            name: '',
+            type: 'none',
+        });
+    }
+    return { optionTokens, restArgs };
+}
+const BUILTIN_HELP_OPTION = {
+    long: 'help',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Show help information',
+};
+const BUILTIN_VERSION_OPTION = {
+    long: 'version',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Show version number',
+};
+const BUILTIN_COLOR_OPTION = {
+    long: 'color',
+    type: 'boolean',
+    args: 'none',
+    desc: 'Enable colored help output',
+    default: true,
+};
+function createBuiltinOptionState(enabled) {
+    return {
+        version: enabled,
+        color: enabled,
+        logLevel: enabled,
+        silent: enabled,
+        logDate: enabled,
+        logColorful: enabled,
+    };
+}
+function isNoColorEnabled(envs) {
+    return envs['NO_COLOR'] !== undefined;
+}
+function normalizeBuiltinConfig(builtin) {
+    const resolved = {
+        option: createBuiltinOptionState(true),
+    };
+    if (builtin === undefined) {
+        return resolved;
+    }
+    if (builtin === true) {
+        return {
+            option: createBuiltinOptionState(true),
+        };
+    }
+    if (builtin === false) {
+        return {
+            option: createBuiltinOptionState(false),
+        };
+    }
+    if (builtin.option !== undefined) {
+        if (builtin.option === false) {
+            resolved.option = createBuiltinOptionState(false);
+        }
+        else if (builtin.option === true) {
+            resolved.option = createBuiltinOptionState(true);
+        }
+        else {
+            if (builtin.option.version !== undefined)
+                resolved.option.version = builtin.option.version;
+            if (builtin.option.color !== undefined)
+                resolved.option.color = builtin.option.color;
+            if (builtin.option.logLevel !== undefined) {
+                resolved.option.logLevel = builtin.option.logLevel;
+            }
+            if (builtin.option.silent !== undefined)
+                resolved.option.silent = builtin.option.silent;
+            if (builtin.option.logDate !== undefined)
+                resolved.option.logDate = builtin.option.logDate;
+            if (builtin.option.logColorful !== undefined) {
+                resolved.option.logColorful = builtin.option.logColorful;
+            }
+        }
+    }
+    return resolved;
+}
+class Command {
+    #name;
+    #desc;
+    #version;
+    #builtinConfig;
+    #builtin;
+    #presetConfig;
+    #reporter;
+    #parent;
+    #options = [];
+    #arguments = [];
+    #examples = [];
+    #subcommandsList = [];
+    #subcommandsMap = new Map();
+    #action = undefined;
+    constructor(config) {
+        this.#name = config.name ?? '';
+        this.#desc = config.desc;
+        this.#version = config.version;
+        this.#builtinConfig = config.builtin;
+        this.#builtin = normalizeBuiltinConfig(config.builtin);
+        this.#presetConfig = config.preset;
+        this.#reporter = config.reporter;
+    }
+    get name() {
+        return this.#name || undefined;
+    }
+    get description() {
+        return this.#desc;
+    }
+    get version() {
+        return this.#version;
+    }
+    get builtin() {
+        return this.#builtinConfig;
+    }
+    get preset() {
+        return this.#presetConfig === undefined ? undefined : { ...this.#presetConfig };
+    }
+    get parent() {
+        return this.#parent;
+    }
+    get options() {
+        return [...this.#options];
+    }
+    get arguments() {
+        return [...this.#arguments];
+    }
+    get examples() {
+        return this.#examples.map(example => ({ ...example }));
+    }
+    get subcommands() {
+        return new Map(this.#subcommandsMap);
+    }
+    option(opt) {
+        this.#validateOptionConfig(opt);
+        this.#checkOptionUniqueness(opt);
+        this.#options.push(opt);
+        return this;
+    }
+    argument(arg) {
+        this.#validateArgumentConfig(arg);
+        this.#arguments.push(arg);
+        return this;
+    }
+    action(fn) {
+        this.#action = fn;
+        return this;
+    }
+    example(title, usage, desc) {
+        this.#examples.push(this.#normalizeExample({ title, usage, desc }));
+        return this;
+    }
+    subcommand(name, cmd) {
+        if (name === 'help') {
+            throw new CommanderError('ConfigurationError', '"help" is a reserved subcommand name', this.#getCommandPath());
+        }
+        if (cmd.#parent && cmd.#parent !== this) {
+            throw new CommanderError('ConfigurationError', `command "${cmd.#name}" already has a parent`, this.#getCommandPath());
+        }
+        const existing = this.#subcommandsList.find(e => e.command === cmd);
+        if (existing) {
+            if (existing.aliases.includes(name)) {
+                return this;
+            }
+            existing.aliases.push(name);
+            this.#subcommandsMap.set(name, cmd);
+        }
+        else {
+            cmd.#name = name;
+            cmd.#parent = this;
+            this.#subcommandsList.push({ name, aliases: [], command: cmd });
+            this.#subcommandsMap.set(name, cmd);
+        }
+        return this;
+    }
+    async run(params) {
+        const { argv, envs, reporter } = params;
+        try {
+            const routeResult = this.#route(argv);
+            const { chain } = routeResult;
+            const leafCommand = chain[chain.length - 1];
+            const ctx = this.#createContext({
+                chain,
+                cmds: routeResult.cmds,
+                envs,
+                reporter,
+            });
+            const controlScanResult = this.#controlScan(routeResult.remaining, leafCommand);
+            ctx.controls = controlScanResult.controls;
+            ctx.sources.user.argv = [...controlScanResult.remaining];
+            if (ctx.controls.help) {
+                const helpCommand = this.#resolveHelpCommand(leafCommand, controlScanResult.helpTarget);
+                const helpColor = helpCommand.#resolveHelpColorFromTailArgv(controlScanResult.remaining, ctx.envs);
+                console.log(helpCommand.#formatHelpForDisplay({ color: helpColor }));
+                return;
+            }
+            if (ctx.controls.version) {
+                console.log(leafCommand.#version);
+                return;
+            }
+            const optionPolicyMap = this.#buildOptionPolicyMap(chain);
+            const presetResult = await this.#preset(controlScanResult.remaining, ctx, optionPolicyMap);
+            ctx.sources = presetResult.sources;
+            ctx.envs = presetResult.envs;
+            const tokenizeResult = tokenize(presetResult.tailArgv, leafCommand.#getCommandPath());
+            const { optionTokens, restArgs } = tokenizeResult;
+            const resolveResult = this.#resolve(chain, optionTokens, optionPolicyMap);
+            const parseResult = this.#parse(chain, resolveResult, optionPolicyMap, ctx, restArgs);
+            const actionParams = {
+                ctx: parseResult.ctx,
+                opts: parseResult.opts,
+                args: parseResult.args,
+                rawArgs: parseResult.rawArgs,
+            };
+            if (leafCommand.#action) {
+                await leafCommand.#runAction(actionParams);
+            }
+            else if (leafCommand.#subcommandsList.length > 0) {
+                const helpColor = leafCommand.#resolveHelpColorFromTailArgv(presetResult.tailArgv, ctx.envs);
+                console.log(leafCommand.#formatHelpForDisplay({ color: helpColor }));
+            }
+            else {
+                throw new CommanderError('ConfigurationError', `no action defined for command "${leafCommand.#getCommandPath()}"`, leafCommand.#getCommandPath());
+            }
+        }
+        catch (err) {
+            if (err instanceof CommanderError) {
+                console.error(err.format());
+                process.exit(2);
+                return;
+            }
+            throw err;
+        }
+    }
+    async parse(params) {
+        const { argv, envs, reporter } = params;
+        const routeResult = this.#route(argv);
+        const { chain } = routeResult;
+        const leafCommand = chain[chain.length - 1];
+        const ctx = this.#createContext({
+            chain,
+            cmds: routeResult.cmds,
+            envs,
+            reporter,
+        });
+        const controlScanResult = this.#controlScan(routeResult.remaining, leafCommand);
+        ctx.controls = controlScanResult.controls;
+        ctx.sources.user.argv = [...controlScanResult.remaining];
+        const optionPolicyMap = this.#buildOptionPolicyMap(chain);
+        const presetResult = await this.#preset(controlScanResult.remaining, ctx, optionPolicyMap);
+        ctx.sources = presetResult.sources;
+        ctx.envs = presetResult.envs;
+        const tokenizeResult = tokenize(presetResult.tailArgv, leafCommand.#getCommandPath());
+        const { optionTokens, restArgs } = tokenizeResult;
+        const resolveResult = this.#resolve(chain, optionTokens, optionPolicyMap);
+        return this.#parse(chain, resolveResult, optionPolicyMap, ctx, restArgs);
+    }
+    formatHelp() {
+        return this.#renderHelpPlain(this.#buildHelpData());
+    }
+    #formatHelpForDisplay(params = {}) {
+        const { color = true } = params;
+        const helpData = this.#buildHelpData();
+        if (!this.#shouldRenderStyledHelp(color)) {
+            return this.#renderHelpPlain(helpData);
+        }
+        return this.#renderHelpTerminal(helpData);
+    }
+    #shouldRenderStyledHelp(color) {
+        return color && process.stdout.isTTY === true;
+    }
+    #buildHelpData() {
+        const parseOptions = this.#resolveOptionPolicy().mergedOptions;
+        const allOptions = [...parseOptions, BUILTIN_HELP_OPTION];
+        if (this.#supportsBuiltinVersion()) {
+            allOptions.push(BUILTIN_VERSION_OPTION);
+        }
+        const commandPath = this.#getCommandPath();
+        let usage = `Usage: ${commandPath}`;
+        if (allOptions.length > 0)
+            usage += ' [options]';
+        if (this.#subcommandsList.length > 0)
+            usage += ' [command]';
+        for (const arg of this.#arguments) {
+            if (arg.kind === 'required') {
+                usage += ` <${arg.name}>`;
+            }
+            else if (arg.kind === 'optional') {
+                usage += ` [${arg.name}]`;
+            }
+            else {
+                usage += ` [${arg.name}...]`;
+            }
+        }
+        const options = [];
+        for (const opt of allOptions) {
+            const kebabLong = camelToKebabCase$1(opt.long);
+            let sig = opt.short ? `-${opt.short}, ` : '    ';
+            sig += `--${kebabLong}`;
+            if (opt.args !== 'none') {
+                sig += ' <value>';
+            }
+            let desc = opt.desc;
+            if (opt.default !== undefined && opt.type !== 'boolean') {
+                desc += ` (default: ${JSON.stringify(opt.default)})`;
+            }
+            if (opt.choices) {
+                desc += ` [choices: ${opt.choices.join(', ')}]`;
+            }
+            options.push({ sig, desc });
+            if (opt.type === 'boolean' &&
+                opt.args === 'none' &&
+                opt.long !== 'help' &&
+                opt.long !== 'version') {
+                options.push({
+                    sig: `    --no-${kebabLong}`,
+                    desc: `Negate --${kebabLong}`,
+                });
+            }
+        }
+        const commands = [];
+        if (this.#subcommandsList.length > 0) {
+            commands.push({ name: 'help', desc: 'Show help for a command' });
+        }
+        for (const entry of this.#subcommandsList) {
+            let name = entry.name;
+            if (entry.aliases.length > 0) {
+                name += `, ${entry.aliases.join(', ')}`;
+            }
+            commands.push({ name, desc: entry.command.#desc });
+        }
+        const examples = this.#examples.map(example => ({
+            title: example.title,
+            usage: commandPath ? `${commandPath} ${example.usage}` : example.usage,
+            desc: example.desc,
+        }));
+        return {
+            desc: this.#desc,
+            usage,
+            options,
+            commands,
+            examples,
+        };
+    }
+    #renderHelpPlain(helpData) {
+        const lines = [];
+        lines.push(helpData.desc);
+        lines.push('');
+        lines.push(helpData.usage);
+        lines.push('');
+        if (helpData.options.length > 0) {
+            lines.push('Options:');
+            const maxSigLen = Math.max(...helpData.options.map(line => line.sig.length));
+            for (const { sig, desc } of helpData.options) {
+                const padding = ' '.repeat(maxSigLen - sig.length + 2);
+                lines.push(`  ${sig}${padding}${desc}`);
+            }
+            lines.push('');
+        }
+        if (helpData.commands.length > 0) {
+            lines.push('Commands:');
+            const maxNameLen = Math.max(...helpData.commands.map(line => line.name.length));
+            for (const { name, desc } of helpData.commands) {
+                const padding = ' '.repeat(maxNameLen - name.length + 2);
+                lines.push(`  ${name}${padding}${desc}`);
+            }
+            lines.push('');
+        }
+        if (helpData.examples.length > 0) {
+            lines.push('Examples:');
+            for (const example of helpData.examples) {
+                lines.push(`  - ${example.title}`);
+                lines.push(`    ${example.usage}`);
+                lines.push(`    ${example.desc}`);
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    #renderHelpTerminal(helpData) {
+        const lines = [];
+        lines.push(helpData.desc);
+        lines.push('');
+        lines.push(styleText(helpData.usage, TERMINAL_STYLE.bold));
+        lines.push('');
+        if (helpData.options.length > 0) {
+            lines.push(styleText('Options:', TERMINAL_STYLE.bold, TERMINAL_STYLE.underline));
+            const maxSigLen = Math.max(...helpData.options.map(line => line.sig.length));
+            for (const { sig, desc } of helpData.options) {
+                const padding = ' '.repeat(maxSigLen - sig.length + 2);
+                lines.push(`  ${styleText(sig, TERMINAL_STYLE.cyan)}${padding}${desc}`);
+            }
+            lines.push('');
+        }
+        if (helpData.commands.length > 0) {
+            lines.push(styleText('Commands:', TERMINAL_STYLE.bold, TERMINAL_STYLE.underline));
+            const maxNameLen = Math.max(...helpData.commands.map(line => line.name.length));
+            for (const { name, desc } of helpData.commands) {
+                const padding = ' '.repeat(maxNameLen - name.length + 2);
+                lines.push(`  ${styleText(name, TERMINAL_STYLE.cyan)}${padding}${desc}`);
+            }
+            lines.push('');
+        }
+        if (helpData.examples.length > 0) {
+            lines.push(styleText('Examples:', TERMINAL_STYLE.bold, TERMINAL_STYLE.underline));
+            for (const example of helpData.examples) {
+                lines.push(`  - ${styleText(example.title, TERMINAL_STYLE.bold)}`);
+                lines.push(`    ${styleText(example.usage, TERMINAL_STYLE.cyan)}`);
+                lines.push(`    ${styleText(example.desc, TERMINAL_STYLE.italic, TERMINAL_STYLE.dim)}`);
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    getCompletionMeta() {
+        const allOptions = this.#resolveOptionPolicy().mergedOptions;
+        const options = [];
+        for (const opt of allOptions) {
+            options.push({
+                long: opt.long,
+                short: opt.short,
+                desc: opt.desc,
+                takesValue: opt.args !== 'none',
+                choices: opt.choices,
+            });
+        }
+        return {
+            name: this.#name,
+            desc: this.#desc,
+            aliases: [],
+            options,
+            subcommands: this.#subcommandsList.map(entry => {
+                const subMeta = entry.command.getCompletionMeta();
+                return {
+                    ...subMeta,
+                    name: entry.name,
+                    aliases: entry.aliases,
+                };
+            }),
+        };
+    }
+    #findSubcommandEntry(token) {
+        return this.#subcommandsList.find(e => e.name === token || e.aliases.includes(token));
+    }
+    #route(argv) {
+        const chain = [this];
+        const cmds = [];
+        let current = this;
+        let idx = 0;
+        while (idx < argv.length) {
+            const token = argv[idx];
+            if (token.startsWith('-'))
+                break;
+            const entry = current.#findSubcommandEntry(token);
+            if (!entry)
+                break;
+            current = entry.command;
+            cmds.push(token);
+            chain.push(current);
+            idx += 1;
+        }
+        return { chain, remaining: argv.slice(idx), cmds };
+    }
+    #controlScan(tailArgv, leafCommand) {
+        const controls = { help: false, version: false };
+        const separatorIndex = tailArgv.indexOf('--');
+        const beforeSeparator = separatorIndex === -1 ? tailArgv : tailArgv.slice(0, separatorIndex);
+        const afterSeparator = separatorIndex === -1 ? [] : tailArgv.slice(separatorIndex + 1);
+        let helpTarget;
+        let scanStartIndex = 0;
+        if (beforeSeparator[0] === 'help') {
+            controls.help = true;
+            scanStartIndex = 1;
+            const candidate = beforeSeparator[1];
+            if (candidate !== undefined && !candidate.startsWith('-')) {
+                helpTarget = candidate;
+                scanStartIndex = 2;
+            }
+        }
+        const remainingBeforeSeparator = [];
+        for (let i = scanStartIndex; i < beforeSeparator.length; i += 1) {
+            const token = beforeSeparator[i];
+            if (token === '--help') {
+                controls.help = true;
+                continue;
+            }
+            if (token === '--version' && leafCommand.#supportsBuiltinVersion()) {
+                controls.version = true;
+                continue;
+            }
+            remainingBeforeSeparator.push(token);
+        }
+        const remaining = separatorIndex === -1
+            ? remainingBeforeSeparator
+            : [...remainingBeforeSeparator, '--', ...afterSeparator];
+        return {
+            controls,
+            remaining,
+            helpTarget,
+        };
+    }
+    #createContext(params) {
+        const { chain, cmds, envs, reporter: reporter$1 } = params;
+        const leafCommand = chain[chain.length - 1];
+        const envSnapshot = { ...envs };
+        return {
+            cmd: leafCommand,
+            chain,
+            envs: envSnapshot,
+            controls: { help: false, version: false },
+            sources: {
+                preset: {
+                    argv: [],
+                    envs: {},
+                },
+                user: {
+                    cmds: [...cmds],
+                    argv: [],
+                    envs: envSnapshot,
+                },
+            },
+            reporter: reporter$1 ?? this.#reporter ?? new reporter.Reporter(),
+        };
+    }
+    #resolveHelpCommand(leafCommand, helpTarget) {
+        if (helpTarget === undefined) {
+            return leafCommand;
+        }
+        const target = leafCommand.#findSubcommandEntry(helpTarget);
+        if (target === undefined) {
+            return leafCommand;
+        }
+        return target.command;
+    }
+    async #preset(controlTailArgv, ctx, optionPolicyMap) {
+        const commandPath = ctx.chain[ctx.chain.length - 1].#getCommandPath();
+        const separatorIndex = controlTailArgv.indexOf('--');
+        const beforeSeparator = separatorIndex === -1 ? controlTailArgv : controlTailArgv.slice(0, separatorIndex);
+        const afterSeparator = separatorIndex === -1 ? [] : controlTailArgv.slice(separatorIndex + 1);
+        const rootScanResult = this.#scanPresetRootDirectives(beforeSeparator, commandPath);
+        const commandPreset = this.#resolveCommandPresetFromChain(ctx.chain);
+        const presetRoot = await this.#resolveEffectivePresetRoot(rootScanResult.cliPresetRoots, commandPreset, commandPath);
+        const fileScanResult = this.#scanPresetFileDirectives(rootScanResult.cleanArgv, commandPath);
+        const cleanArgv = separatorIndex === -1
+            ? fileScanResult.cleanArgv
+            : [...fileScanResult.cleanArgv, '--', ...afterSeparator];
+        const presetOptsFiles = this.#resolvePresetFileSources({
+            cliFiles: fileScanResult.cliPresetOptsFiles,
+            commandPresetFile: this.#normalizeCommandPresetFile(commandPreset?.opt),
+            presetRoot,
+            defaultFilename: DEFAULT_PRESET_OPTS_FILENAME,
+        });
+        const presetEnvsFiles = this.#resolvePresetFileSources({
+            cliFiles: fileScanResult.cliPresetEnvsFiles,
+            commandPresetFile: this.#normalizeCommandPresetFile(commandPreset?.env),
+            presetRoot,
+            defaultFilename: DEFAULT_PRESET_ENVS_FILENAME,
+        });
+        const userSources = {
+            cmds: [...ctx.sources.user.cmds],
+            argv: [...cleanArgv],
+            envs: { ...ctx.sources.user.envs },
+        };
+        const presetArgv = [];
+        for (const file of presetOptsFiles) {
+            const content = await this.#readPresetFile(file, commandPath);
+            if (content === undefined) {
+                continue;
+            }
+            const tokens = this.#tokenizePresetOptions(content);
+            this.#validatePresetOptionTokens(tokens, file.displayPath, commandPath);
+            this.#assertPresetOptionFragments(tokens, file.displayPath, ctx.chain, optionPolicyMap);
+            presetArgv.push(...tokens);
+        }
+        const presetEnvs = {};
+        for (const file of presetEnvsFiles) {
+            const content = await this.#readPresetFile(file, commandPath);
+            if (content === undefined) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = env.parse(content);
+            }
+            catch (error) {
+                throw new CommanderError('ConfigurationError', `failed to parse preset envs file "${file.displayPath}": ${error.message}`, commandPath);
+            }
+            Object.assign(presetEnvs, parsed);
+        }
+        const sources = {
+            user: userSources,
+            preset: {
+                argv: presetArgv,
+                envs: presetEnvs,
+            },
+        };
+        const envs = { ...sources.user.envs, ...sources.preset.envs };
+        const tailArgv = [...sources.preset.argv, ...sources.user.argv];
+        return { tailArgv, envs, sources };
+    }
+    #resolveCommandPresetFromChain(chain) {
+        for (let index = chain.length - 1; index >= 0; index -= 1) {
+            const preset = chain[index].#presetConfig;
+            if (preset?.root !== undefined) {
+                return preset;
+            }
+        }
+        return undefined;
+    }
+    async #resolveEffectivePresetRoot(cliPresetRoots, commandPreset, commandPath) {
+        if (cliPresetRoots.length > 0) {
+            const root = cliPresetRoots[cliPresetRoots.length - 1];
+            return await this.#assertPresetRoot(root, PRESET_ROOT_FLAG, commandPath);
+        }
+        if (commandPreset?.root === undefined) {
+            return undefined;
+        }
+        return await this.#assertPresetRoot(commandPreset.root, 'command.preset.root', commandPath);
+    }
+    async #assertPresetRoot(root, sourceName, commandPath) {
+        if (!path.isAbsolute(root)) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" is not an absolute directory`, commandPath);
+        }
+        let stats;
+        try {
+            stats = await promises.stat(root);
+        }
+        catch (error) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" cannot be accessed (${error.message})`, commandPath);
+        }
+        if (!stats.isDirectory()) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" is not a directory`, commandPath);
+        }
+        return root;
+    }
+    #normalizeCommandPresetFile(filepath) {
+        if (filepath === undefined) {
+            return undefined;
+        }
+        if (!this.#isValidPresetFileValue(filepath)) {
+            return undefined;
+        }
+        return filepath;
+    }
+    #resolvePresetFileSources(params) {
+        const { cliFiles, commandPresetFile, presetRoot, defaultFilename } = params;
+        if (cliFiles.length > 0) {
+            return cliFiles.map(filepath => ({
+                displayPath: filepath,
+                absolutePath: this.#resolvePresetFileAbsolutePath(filepath, presetRoot),
+                explicit: true,
+            }));
+        }
+        if (presetRoot === undefined) {
+            return [];
+        }
+        if (commandPresetFile !== undefined) {
+            return [
+                {
+                    displayPath: commandPresetFile,
+                    absolutePath: this.#resolvePresetFileAbsolutePath(commandPresetFile, presetRoot),
+                    explicit: true,
+                },
+            ];
+        }
+        const absolutePath = path.resolve(presetRoot, defaultFilename);
+        return [
+            {
+                displayPath: absolutePath,
+                absolutePath,
+                explicit: false,
+            },
+        ];
+    }
+    #resolvePresetFileAbsolutePath(filepath, presetRoot) {
+        if (path.isAbsolute(filepath)) {
+            return filepath;
+        }
+        if (presetRoot !== undefined) {
+            return path.resolve(presetRoot, filepath);
+        }
+        return path.resolve(process.cwd(), filepath);
+    }
+    #assertPresetOptionFragments(tokens, filepath, chain, optionPolicyMap) {
+        if (tokens.length === 0) {
+            return;
+        }
+        const commandPath = chain[chain.length - 1].#getCommandPath();
+        try {
+            const { optionTokens, restArgs } = tokenize(tokens, commandPath);
+            void restArgs;
+            const { argTokens } = this.#resolve(chain, optionTokens, optionPolicyMap);
+            if (argTokens.length > 0) {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": token "${argTokens[0].original}" cannot be resolved as an option fragment`, commandPath);
+            }
+        }
+        catch (error) {
+            if (error instanceof CommanderError) {
+                if (error.kind === 'ConfigurationError') {
+                    throw error;
+                }
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": ${error.message}`, commandPath);
+            }
+            throw error;
+        }
+    }
+    #scanPresetRootDirectives(argv, commandPath) {
+        const cleanArgv = [];
+        const cliPresetRoots = [];
+        let index = 0;
+        while (index < argv.length) {
+            const token = argv[index];
+            if (token === PRESET_ROOT_FLAG) {
+                const value = argv[index + 1];
+                if (value === undefined || value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ROOT_FLAG}"`, commandPath);
+                }
+                cliPresetRoots.push(value);
+                index += 2;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_ROOT_FLAG}=`)) {
+                const value = token.slice(PRESET_ROOT_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ROOT_FLAG}"`, commandPath);
+                }
+                cliPresetRoots.push(value);
+                index += 1;
+                continue;
+            }
+            cleanArgv.push(token);
+            index += 1;
+        }
+        return { cleanArgv, cliPresetRoots };
+    }
+    #scanPresetFileDirectives(argv, commandPath) {
+        const cleanArgv = [];
+        const cliPresetOptsFiles = [];
+        const cliPresetEnvsFiles = [];
+        const assertAndPush = (flag, value) => {
+            this.#assertPresetFileValue(value, flag, commandPath);
+            if (flag === PRESET_OPTS_FLAG) {
+                cliPresetOptsFiles.push(value);
+            }
+            else {
+                cliPresetEnvsFiles.push(value);
+            }
+        };
+        let index = 0;
+        while (index < argv.length) {
+            const token = argv[index];
+            if (token === PRESET_OPTS_FLAG || token === PRESET_ENVS_FLAG) {
+                const value = argv[index + 1];
+                if (value === undefined || value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${token}"`, commandPath);
+                }
+                assertAndPush(token, value);
+                index += 2;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_OPTS_FLAG}=`)) {
+                const value = token.slice(PRESET_OPTS_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_OPTS_FLAG}"`, commandPath);
+                }
+                assertAndPush(PRESET_OPTS_FLAG, value);
+                index += 1;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_ENVS_FLAG}=`)) {
+                const value = token.slice(PRESET_ENVS_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ENVS_FLAG}"`, commandPath);
+                }
+                assertAndPush(PRESET_ENVS_FLAG, value);
+                index += 1;
+                continue;
+            }
+            cleanArgv.push(token);
+            index += 1;
+        }
+        return { cleanArgv, cliPresetOptsFiles, cliPresetEnvsFiles };
+    }
+    #isValidPresetFileValue(filepath) {
+        return filepath.length > 0 && !filepath.startsWith('..');
+    }
+    #assertPresetFileValue(filepath, directive, commandPath) {
+        if (this.#isValidPresetFileValue(filepath)) {
+            return;
+        }
+        throw new CommanderError('ConfigurationError', `invalid value for "${directive}": "${filepath}" (must be non-empty and must not start with "..")`, commandPath);
+    }
+    async #readPresetFile(file, commandPath) {
+        try {
+            return await promises.readFile(file.absolutePath, 'utf8');
+        }
+        catch (error) {
+            const ioError = error;
+            if (!file.explicit && ioError.code === 'ENOENT') {
+                return undefined;
+            }
+            throw new CommanderError('ConfigurationError', `failed to read preset file "${file.displayPath}": ${ioError.message}`, commandPath);
+        }
+    }
+    #tokenizePresetOptions(content) {
+        return content
+            .split(/\s+/)
+            .map(token => token.trim())
+            .filter(token => token.length > 0);
+    }
+    #validatePresetOptionTokens(tokens, filepath, commandPath) {
+        if (tokens.length === 0) {
+            return;
+        }
+        if (!tokens[0].startsWith('-')) {
+            throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": bare token "${tokens[0]}" cannot appear before any option token`, commandPath);
+        }
+        for (const token of tokens) {
+            if (token === '--') {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": "--" is not allowed`, commandPath);
+            }
+            if (token === 'help' || token === '--help' || token === '--version') {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": control token "${token}" is not allowed`, commandPath);
+            }
+            if (token === PRESET_ROOT_FLAG ||
+                token.startsWith(`${PRESET_ROOT_FLAG}=`) ||
+                token === PRESET_OPTS_FLAG ||
+                token.startsWith(`${PRESET_OPTS_FLAG}=`) ||
+                token === PRESET_ENVS_FLAG ||
+                token.startsWith(`${PRESET_ENVS_FLAG}=`)) {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": preset directive "${token}" is not allowed`, commandPath);
+            }
+        }
+    }
+    #resolve(chain, tokens, optionPolicyMap) {
+        const consumedTokens = new Map();
+        let remaining = [...tokens];
+        const shadowed = new Set();
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const cmd = chain[i];
+            const policy = this.#mustGetOptionPolicy(optionPolicyMap, cmd);
+            const result = cmd.#shift(remaining, shadowed, policy.mergedOptions);
+            consumedTokens.set(cmd, result.consumed);
+            remaining = result.remaining;
+            for (const opt of cmd.#options) {
+                shadowed.add(opt.long);
+            }
+        }
+        const argTokens = [];
+        for (const token of remaining) {
+            if (token.type !== 'none') {
+                const leafCommand = chain[chain.length - 1];
+                throw new CommanderError('UnknownOption', `unknown option "${token.original}" for command "${leafCommand.#getCommandPath()}"`, leafCommand.#getCommandPath());
+            }
+            argTokens.push(token);
+        }
+        return { consumedTokens, argTokens };
+    }
+    #shift(tokens, shadowed, allOptions) {
+        const effectiveOptions = allOptions.filter(o => !shadowed.has(o.long));
+        const optionByLong = new Map();
+        const optionByShort = new Map();
+        for (const opt of effectiveOptions) {
+            optionByLong.set(opt.long, opt);
+            if (opt.short) {
+                optionByShort.set(opt.short, opt);
+            }
+        }
+        const consumed = [];
+        const remaining = [];
+        let i = 0;
+        while (i < tokens.length) {
+            const token = tokens[i];
+            if (token.type === 'long') {
+                const opt = optionByLong.get(token.name);
+                if (opt) {
+                    consumed.push(token);
+                    if (opt.args === 'required') {
+                        if (!token.resolved.includes('=') && i + 1 < tokens.length) {
+                            i += 1;
+                            consumed.push(tokens[i]);
+                        }
+                    }
+                    else if (opt.args === 'variadic') {
+                        if (!token.resolved.includes('=')) {
+                            while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                                i += 1;
+                                consumed.push(tokens[i]);
+                            }
+                        }
+                    }
+                    i += 1;
+                    continue;
+                }
+                remaining.push(token);
+                i += 1;
+                continue;
+            }
+            if (token.type === 'short') {
+                const opt = optionByShort.get(token.name);
+                if (opt) {
+                    consumed.push(token);
+                    if (opt.args === 'required') {
+                        if (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                            i += 1;
+                            consumed.push(tokens[i]);
+                        }
+                    }
+                    else if (opt.args === 'variadic') {
+                        while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                            i += 1;
+                            consumed.push(tokens[i]);
+                        }
+                    }
+                    i += 1;
+                    continue;
+                }
+                remaining.push(token);
+                i += 1;
+                continue;
+            }
+            remaining.push(token);
+            i += 1;
+        }
+        return { consumed, remaining };
+    }
+    #parse(chain, resolveResult, optionPolicyMap, ctx, restArgs) {
+        const { consumedTokens, argTokens } = resolveResult;
+        const leafCommand = chain[chain.length - 1];
+        this.#validateMergedShortOptions(chain, optionPolicyMap);
+        const optsMap = new Map();
+        for (const cmd of chain) {
+            const policy = this.#mustGetOptionPolicy(optionPolicyMap, cmd);
+            const tokens = consumedTokens.get(cmd) ?? [];
+            const opts = cmd.#parseOptions(tokens, policy.mergedOptions, ctx.envs);
+            optsMap.set(cmd, opts);
+            for (const opt of policy.mergedOptions) {
+                if (opt.apply && opts[opt.long] !== undefined) {
+                    opt.apply(opts[opt.long], ctx);
+                }
+            }
+        }
+        const leafLocalOpts = {};
+        const leafParsedOpts = optsMap.get(leafCommand) ?? {};
+        for (const opt of leafCommand.#options) {
+            if (Object.prototype.hasOwnProperty.call(leafParsedOpts, opt.long)) {
+                leafLocalOpts[opt.long] = leafParsedOpts[opt.long];
+            }
+        }
+        const rawArgStrings = [...argTokens.map(t => t.original), ...restArgs];
+        const { args, rawArgs } = leafCommand.#parseArguments(rawArgStrings);
+        const parseCtx = {
+            ...ctx,
+            sources: this.#freezeInputSources(ctx.sources),
+        };
+        return { ctx: parseCtx, opts: leafLocalOpts, args, rawArgs };
+    }
+    #parseOptions(tokens, allOptions, envs) {
+        const opts = {};
+        let sawColorToken = false;
+        for (const opt of allOptions) {
+            if (opt.default !== undefined) {
+                opts[opt.long] = opt.default;
+            }
+            else if (opt.type === 'boolean' && opt.args === 'none') {
+                opts[opt.long] = false;
+            }
+            else if (opt.args === 'variadic') {
+                opts[opt.long] = [];
+            }
+        }
+        const optionByLong = new Map();
+        const optionByShort = new Map();
+        for (const opt of allOptions) {
+            optionByLong.set(opt.long, opt);
+            if (opt.short) {
+                optionByShort.set(opt.short, opt);
+            }
+        }
+        let i = 0;
+        while (i < tokens.length) {
+            const token = tokens[i];
+            const opt = token.type === 'long' ? optionByLong.get(token.name) : optionByShort.get(token.name);
+            if (!opt) {
+                i += 1;
+                continue;
+            }
+            if (opt.long === 'color') {
+                sawColorToken = true;
+            }
+            const isNegativeToken = token.original.toLowerCase().startsWith('--no-');
+            if (isNegativeToken && !(opt.type === 'boolean' && opt.args === 'none')) {
+                throw new CommanderError('NegativeOptionType', `"--no-${camelToKebabCase$1(opt.long)}" can only be used with boolean options`, this.#getCommandPath());
+            }
+            if (opt.type === 'boolean' && opt.args === 'none') {
+                const eqIdx = token.resolved.indexOf('=');
+                if (eqIdx !== -1) {
+                    const value = token.resolved.slice(eqIdx + 1);
+                    if (value === 'true') {
+                        opts[opt.long] = true;
+                    }
+                    else if (value === 'false') {
+                        opts[opt.long] = false;
+                    }
+                    else {
+                        throw new CommanderError('InvalidBooleanValue', `invalid value "${value}" for boolean option "--${camelToKebabCase$1(opt.long)}". Use "true" or "false"`, this.#getCommandPath());
+                    }
+                }
+                else {
+                    opts[opt.long] = true;
+                }
+                i += 1;
+                continue;
+            }
+            if (opt.args === 'required') {
+                const eqIdx = token.resolved.indexOf('=');
+                let rawValue;
+                if (eqIdx !== -1) {
+                    rawValue = token.resolved.slice(eqIdx + 1);
+                }
+                else if (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                    rawValue = tokens[i + 1].original;
+                    i += 1;
+                }
+                else {
+                    throw new CommanderError('MissingValue', `option "--${camelToKebabCase$1(opt.long)}" requires a value`, this.#getCommandPath());
+                }
+                opts[opt.long] = this.#convertValue(opt, rawValue);
+                i += 1;
+                continue;
+            }
+            if (opt.args === 'variadic') {
+                const values = Array.isArray(opts[opt.long]) ? opts[opt.long] : [];
+                const eqIdx = token.resolved.indexOf('=');
+                if (eqIdx !== -1) {
+                    values.push(this.#convertValue(opt, token.resolved.slice(eqIdx + 1)));
+                }
+                else {
+                    while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                        i += 1;
+                        values.push(this.#convertValue(opt, tokens[i].original));
+                    }
+                }
+                opts[opt.long] = values;
+                i += 1;
+                continue;
+            }
+            i += 1;
+        }
+        for (const opt of allOptions) {
+            if (opt.required && opts[opt.long] === undefined) {
+                throw new CommanderError('MissingRequired', `missing required option "--${camelToKebabCase$1(opt.long)}"`, this.#getCommandPath());
+            }
+        }
+        for (const opt of allOptions) {
+            if (opt.choices && opts[opt.long] !== undefined) {
+                const value = opts[opt.long];
+                const values = Array.isArray(value) ? value : [value];
+                const choices = opt.choices;
+                for (const v of values) {
+                    if (!choices.includes(v)) {
+                        throw new CommanderError('InvalidChoice', `invalid value "${v}" for option "--${camelToKebabCase$1(opt.long)}". Allowed: ${opt.choices.join(', ')}`, this.#getCommandPath());
+                    }
+                }
+            }
+        }
+        if (isNoColorEnabled(envs) && !sawColorToken && opts['color'] === true) {
+            opts['color'] = false;
+        }
+        return opts;
+    }
+    #convertValue(opt, rawValue) {
+        if (opt.coerce) {
+            return opt.coerce(rawValue);
+        }
+        if (opt.type === 'number') {
+            const num = Number(rawValue);
+            if (Number.isNaN(num)) {
+                throw new CommanderError('InvalidType', `invalid number "${rawValue}" for option "--${camelToKebabCase$1(opt.long)}"`, this.#getCommandPath());
+            }
+            return num;
+        }
+        return rawValue;
+    }
+    #parseArguments(rawArgs) {
+        const argumentDefs = this.#arguments;
+        const args = {};
+        const requiredCount = argumentDefs.filter(a => a.kind === 'required').length;
+        if (rawArgs.length < requiredCount) {
+            const missing = argumentDefs
+                .filter(a => a.kind === 'required')
+                .slice(rawArgs.length)
+                .map(a => a.name);
+            throw new CommanderError('MissingRequiredArgument', `missing required argument(s): ${missing.join(', ')}`, this.#getCommandPath());
+        }
+        let index = 0;
+        for (const def of argumentDefs) {
+            if (def.kind === 'variadic') {
+                const rest = rawArgs.slice(index);
+                args[def.name] = rest.map(raw => this.#convertArgument(def, raw));
+                index = rawArgs.length;
+                break;
+            }
+            const raw = rawArgs[index];
+            if (raw === undefined) {
+                if (def.kind === 'optional') {
+                    args[def.name] = def.default ?? undefined;
+                    continue;
+                }
+            }
+            else {
+                args[def.name] = this.#convertArgument(def, raw);
+                index += 1;
+            }
+        }
+        const hasVariadic = argumentDefs.some(a => a.kind === 'variadic');
+        if (!hasVariadic && index < rawArgs.length) {
+            throw new CommanderError('TooManyArguments', `too many arguments: expected ${argumentDefs.length}, got ${rawArgs.length}`, this.#getCommandPath());
+        }
+        return { args, rawArgs };
+    }
+    #convertArgument(def, raw) {
+        if (def.coerce) {
+            try {
+                return def.coerce(raw);
+            }
+            catch {
+                throw new CommanderError('InvalidType', `invalid value "${raw}" for argument "${def.name}"`, this.#getCommandPath());
+            }
+        }
+        if (def.type === 'number') {
+            const n = Number(raw);
+            if (Number.isNaN(n)) {
+                throw new CommanderError('InvalidType', `invalid number "${raw}" for argument "${def.name}"`, this.#getCommandPath());
+            }
+            return n;
+        }
+        return raw;
+    }
+    #hasUserOption(long) {
+        return this.#options.some(option => option.long === long);
+    }
+    #supportsBuiltinVersion() {
+        return this.#parent === undefined && this.#version !== undefined && this.#builtin.option.version;
+    }
+    #resolveOptionPolicy() {
+        const optionMap = new Map();
+        const hasUserColor = this.#hasUserOption('color');
+        const hasUserLogLevel = this.#hasUserOption('logLevel');
+        const hasUserSilent = this.#hasUserOption('silent');
+        const hasUserLogDate = this.#hasUserOption('logDate');
+        const hasUserLogColorful = this.#hasUserOption('logColorful');
+        if (this.#builtin.option.color && !hasUserColor) {
+            optionMap.set('color', BUILTIN_COLOR_OPTION);
+        }
+        if (this.#builtin.option.logLevel && !hasUserLogLevel) {
+            optionMap.set('logLevel', logLevelOption);
+        }
+        if (this.#builtin.option.silent && !hasUserSilent) {
+            optionMap.set('silent', silentOption);
+        }
+        if (this.#builtin.option.logDate && !hasUserLogDate) {
+            optionMap.set('logDate', logDateOption);
+        }
+        if (this.#builtin.option.logColorful && !hasUserLogColorful) {
+            optionMap.set('logColorful', logColorfulOption);
+        }
+        for (const opt of this.#options) {
+            optionMap.set(opt.long, opt);
+        }
+        return {
+            mergedOptions: Array.from(optionMap.values()),
+        };
+    }
+    #buildOptionPolicyMap(chain) {
+        const optionPolicyMap = new Map();
+        for (const cmd of chain) {
+            optionPolicyMap.set(cmd, cmd.#resolveOptionPolicy());
+        }
+        return optionPolicyMap;
+    }
+    #mustGetOptionPolicy(optionPolicyMap, cmd) {
+        const policy = optionPolicyMap.get(cmd);
+        if (policy !== undefined) {
+            return policy;
+        }
+        throw new CommanderError('ConfigurationError', `missing option policy for command "${cmd.#getCommandPath()}"`, this.#getCommandPath());
+    }
+    #validateMergedShortOptions(chain, optionPolicyMap) {
+        const mergedByLong = new Map();
+        for (const cmd of chain) {
+            const policy = this.#mustGetOptionPolicy(optionPolicyMap, cmd);
+            for (const opt of policy.mergedOptions) {
+                mergedByLong.set(opt.long, opt);
+            }
+        }
+        const shortMap = new Map();
+        for (const opt of mergedByLong.values()) {
+            if (!opt.short)
+                continue;
+            const existingLong = shortMap.get(opt.short);
+            if (existingLong && existingLong !== opt.long) {
+                throw new CommanderError('OptionConflict', `short option "-${opt.short}" conflicts with "--${existingLong}"`, this.#getCommandPath());
+            }
+            shortMap.set(opt.short, opt.long);
+        }
+    }
+    #validateOptionConfig(opt) {
+        if (opt.long === 'help' || opt.long === 'version') {
+            throw new CommanderError('ConfigurationError', `option long name "${opt.long}" is reserved`, this.#getCommandPath());
+        }
+        if (opt.type === 'boolean' && opt.args !== 'none') {
+            throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" must have args: 'none'`, this.#getCommandPath());
+        }
+        if ((opt.type === 'string' || opt.type === 'number') && opt.args === 'none') {
+            throw new CommanderError('ConfigurationError', `${opt.type} option "--${opt.long}" must have args: 'required' or 'variadic'`, this.#getCommandPath());
+        }
+        if (opt.long.startsWith('no')) {
+            throw new CommanderError('ConfigurationError', `option long name cannot start with "no": "${opt.long}"`, this.#getCommandPath());
+        }
+        if (!/^[a-z][a-zA-Z0-9]*$/.test(opt.long)) {
+            throw new CommanderError('ConfigurationError', `option long name must be camelCase: "${opt.long}"`, this.#getCommandPath());
+        }
+        if (opt.required && opt.default !== undefined) {
+            throw new CommanderError('ConfigurationError', `option "--${opt.long}" cannot be both required and have a default value`, this.#getCommandPath());
+        }
+        if (opt.type === 'boolean' && opt.required) {
+            throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" cannot be required`, this.#getCommandPath());
+        }
+    }
+    #checkOptionUniqueness(opt) {
+        if (this.#options.some(o => o.long === opt.long)) {
+            throw new CommanderError('OptionConflict', `option "--${opt.long}" is already defined`, this.#getCommandPath());
+        }
+        if (opt.short && this.#options.some(o => o.short === opt.short)) {
+            throw new CommanderError('OptionConflict', `short option "-${opt.short}" is already defined`, this.#getCommandPath());
+        }
+    }
+    #validateArgumentConfig(arg) {
+        if (arg.kind === 'required' && arg.default !== undefined) {
+            throw new CommanderError('ConfigurationError', `required argument "${arg.name}" cannot have a default value`, this.#getCommandPath());
+        }
+        if (arg.kind === 'variadic') {
+            if (this.#arguments.some(a => a.kind === 'variadic')) {
+                throw new CommanderError('ConfigurationError', 'only one variadic argument is allowed', this.#getCommandPath());
+            }
+        }
+        if (this.#arguments.length > 0) {
+            const last = this.#arguments[this.#arguments.length - 1];
+            if (last.kind === 'variadic') {
+                throw new CommanderError('ConfigurationError', 'variadic argument must be the last argument', this.#getCommandPath());
+            }
+        }
+        if (arg.kind === 'required') {
+            const hasOptional = this.#arguments.some(a => a.kind === 'optional' || a.kind === 'variadic');
+            if (hasOptional) {
+                throw new CommanderError('ConfigurationError', `required argument "${arg.name}" cannot come after optional/variadic arguments`, this.#getCommandPath());
+            }
+        }
+    }
+    #normalizeExample(example) {
+        const title = example.title.trim();
+        const usage = example.usage.trim();
+        const desc = example.desc.trim();
+        if (!title) {
+            throw new CommanderError('ConfigurationError', 'example title cannot be empty', this.#getCommandPath());
+        }
+        if (!usage) {
+            throw new CommanderError('ConfigurationError', 'example usage cannot be empty', this.#getCommandPath());
+        }
+        if (!desc) {
+            throw new CommanderError('ConfigurationError', 'example description cannot be empty', this.#getCommandPath());
+        }
+        return { title, usage, desc };
+    }
+    async #runAction(params) {
+        if (!this.#action)
+            return;
+        try {
+            await this.#action(params);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                console.error(`Error: ${err.message}`);
+            }
+            else {
+                console.error('Error: action failed');
+            }
+            process.exit(1);
+        }
+    }
+    #resolveHelpColorFromTailArgv(tailArgv, envs, policy = this.#resolveOptionPolicy()) {
+        const colorOption = policy.mergedOptions.find(opt => opt.long === 'color');
+        let color = !isNoColorEnabled(envs);
+        if (!colorOption || colorOption.type !== 'boolean' || colorOption.args !== 'none') {
+            return color;
+        }
+        const separatorIndex = tailArgv.indexOf('--');
+        const scanTokens = separatorIndex === -1 ? tailArgv : tailArgv.slice(0, separatorIndex);
+        for (const token of scanTokens) {
+            if (token === '--color') {
+                color = true;
+                continue;
+            }
+            if (token === '--no-color') {
+                color = false;
+                continue;
+            }
+            if (!token.startsWith('--color=')) {
+                continue;
+            }
+            const value = token.slice('--color='.length);
+            if (value === 'true') {
+                color = true;
+            }
+            else if (value === 'false') {
+                color = false;
+            }
+            else {
+                throw new CommanderError('InvalidBooleanValue', `invalid value "${value}" for boolean option "--color". Use "true" or "false"`, this.#getCommandPath());
+            }
+        }
+        return color;
+    }
+    #freezeInputSources(sources) {
+        return Object.freeze({
+            preset: Object.freeze({
+                argv: Object.freeze([...sources.preset.argv]),
+                envs: Object.freeze({ ...sources.preset.envs }),
+            }),
+            user: Object.freeze({
+                cmds: Object.freeze([...sources.user.cmds]),
+                argv: Object.freeze([...sources.user.argv]),
+                envs: Object.freeze({ ...sources.user.envs }),
+            }),
+        });
+    }
+    #getCommandPath() {
+        const parts = [];
+        let current = this;
+        while (current) {
+            if (current.#name) {
+                parts.unshift(current.#name);
+            }
+            current = current.#parent;
+        }
+        return parts.join(' ') || this.#name;
+    }
+}
+
+function isIpv4(rawValue) {
+    const parts = rawValue.split('.');
+    if (parts.length !== 4) {
+        return false;
+    }
+    for (const part of parts) {
+        if (part.length < 1 || !/^\d+$/.test(part)) {
+            return false;
+        }
+        if (part.length > 1 && part.startsWith('0')) {
+            return false;
+        }
+        const value = Number(part);
+        if (!Number.isInteger(value) || value < 0 || value > 255) {
+            return false;
+        }
+    }
+    return true;
+}
+function countIpv6Segments(part, allowIpv4Tail) {
+    if (!part) {
+        return { count: 0, hasIpv4Tail: false };
+    }
+    const segments = part.split(':');
+    let count = 0;
+    let hasIpv4Tail = false;
+    for (let i = 0; i < segments.length; ++i) {
+        const segment = segments[i];
+        const isLastSegment = i === segments.length - 1;
+        if (!segment) {
+            return null;
+        }
+        if (segment.includes('.')) {
+            if (!allowIpv4Tail || !isLastSegment || hasIpv4Tail || !isIpv4(segment)) {
+                return null;
+            }
+            hasIpv4Tail = true;
+            count += 2;
+            continue;
+        }
+        if (!/^[0-9A-Fa-f]{1,4}$/.test(segment)) {
+            return null;
+        }
+        count += 1;
+    }
+    return { count, hasIpv4Tail };
+}
+function isIpv6(rawValue) {
+    if (!rawValue || !/^[0-9A-Fa-f:.]+$/.test(rawValue)) {
+        return false;
+    }
+    const doubleColonCount = rawValue.split('::').length - 1;
+    if (doubleColonCount > 1) {
+        return false;
+    }
+    if (doubleColonCount === 0) {
+        const full = countIpv6Segments(rawValue, true);
+        return full !== null && full.count === 8;
+    }
+    const [left, right] = rawValue.split('::');
+    const leftPart = countIpv6Segments(left, right.length === 0);
+    const rightPart = countIpv6Segments(right, true);
+    if (!leftPart || !rightPart) {
+        return false;
+    }
+    const totalSegments = leftPart.count + rightPart.count;
+    return totalSegments < 8;
+}
+function isIp(rawValue) {
+    return isIpv4(rawValue) || isIpv6(rawValue);
+}
+function isDomain(rawValue) {
+    if (rawValue.length < 1 || rawValue.length > 253 || rawValue.endsWith('.')) {
+        return false;
+    }
+    const labels = rawValue.split('.');
+    if (labels.length < 2) {
+        return false;
+    }
+    if (labels.some(label => label.length < 1 || label.length > 63)) {
+        return false;
+    }
+    const labelPattern = /^[A-Za-z0-9-]+$/;
+    if (labels.some(label => !labelPattern.test(label) || label.startsWith('-') || label.endsWith('-'))) {
+        return false;
+    }
+    const topLevelLabel = labels[labels.length - 1];
+    return /[A-Za-z]/.test(topLevelLabel);
+}
+
+class Coerce {
+    constructor() { }
+    static create(name, expectedType, validator, errorMessage) {
+        return (rawValue) => {
+            const value = Number(rawValue);
+            if (!validator(value)) {
+                throw new Error(errorMessage ?? `${name} is expected as ${expectedType}, but got ${rawValue}`);
+            }
+            return value;
+        };
+    }
+    static choice(name, values, errorMessage) {
+        return (rawValue) => {
+            if (values.includes(rawValue)) {
+                return rawValue;
+            }
+            throw new Error(errorMessage ?? `${name} is expected as one of [${values.join(', ')}], but got ${rawValue}`);
+        };
+    }
+    static domain(name, errorMessage) {
+        return (rawValue) => {
+            if (isDomain(rawValue)) {
+                return rawValue;
+            }
+            throw new Error(errorMessage ?? `${name} is expected as a valid domain, but got ${rawValue}`);
+        };
+    }
+    static host(name, errorMessage) {
+        return (rawValue) => {
+            if (isIp(rawValue) || isDomain(rawValue)) {
+                return rawValue;
+            }
+            throw new Error(errorMessage ?? `${name} is expected as a valid host (IP or domain), but got ${rawValue}`);
+        };
+    }
+    static integer(name, errorMessage) {
+        return this.create(name, 'an integer', value => Number.isInteger(value), errorMessage);
+    }
+    static ip(name, errorMessage) {
+        return (rawValue) => {
+            if (isIp(rawValue)) {
+                return rawValue;
+            }
+            throw new Error(errorMessage ?? `${name} is expected as a valid IP address, but got ${rawValue}`);
+        };
+    }
+    static number(name, errorMessage) {
+        return this.create(name, 'a finite number', value => Number.isFinite(value), errorMessage);
+    }
+    static port(name, errorMessage) {
+        return this.create(name, 'a valid port number (0-65535)', value => Number.isInteger(value) && value >= 0 && value <= 65535, errorMessage);
+    }
+    static positiveInteger(name, errorMessage) {
+        return this.create(name, 'a positive integer', value => Number.isInteger(value) && value > 0, errorMessage);
+    }
+    static positiveNumber(name, errorMessage) {
+        return this.create(name, 'a positive number', value => Number.isFinite(value) && value > 0, errorMessage);
+    }
+}
+
+function camelToKebabCase(str) {
+    return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+}
+class CompletionCommand extends Command {
+    constructor(root, config = {}) {
+        const programName = config.programName ?? root.name ?? 'program';
+        const paths = {
+            ...createDefaultCompletionPaths(programName),
+            ...config.paths,
+        };
+        super({ desc: 'Generate shell completion script' });
+        this.option({
+            long: 'bash',
+            type: 'boolean',
+            args: 'none',
+            desc: 'Generate Bash completion script',
+        })
+            .option({
+            long: 'fish',
+            type: 'boolean',
+            args: 'none',
+            desc: 'Generate Fish completion script',
+        })
+            .option({
+            long: 'pwsh',
+            type: 'boolean',
+            args: 'none',
+            desc: 'Generate PowerShell completion script',
+        })
+            .option({
+            long: 'write',
+            short: 'w',
+            type: 'string',
+            args: 'required',
+            desc: 'Write to file (use shell default path if empty)',
+            default: undefined,
+        })
+            .action(({ opts }) => {
+            const meta = root.getCompletionMeta();
+            const selectedShells = [
+                opts['bash'] && 'bash',
+                opts['fish'] && 'fish',
+                opts['pwsh'] && 'pwsh',
+            ].filter(Boolean);
+            if (selectedShells.length === 0) {
+                console.error('Please specify a shell: --bash, --fish, or --pwsh');
+                process.exit(1);
+                return;
+            }
+            if (selectedShells.length > 1) {
+                console.error('Please specify only one shell option');
+                process.exit(1);
+                return;
+            }
+            const shell = selectedShells[0];
+            let script;
+            switch (shell) {
+                case 'bash':
+                    script = new BashCompletion(meta, programName).generate();
+                    break;
+                case 'fish':
+                    script = new FishCompletion(meta, programName).generate();
+                    break;
+                case 'pwsh':
+                    script = new PwshCompletion(meta, programName).generate();
+                    break;
+            }
+            const writeOpt = opts['write'];
+            if (writeOpt !== undefined) {
+                const filePath = typeof writeOpt === 'string' && writeOpt !== '' ? writeOpt : paths[shell];
+                const expandedPath = expandHome(filePath);
+                const dir = path__namespace.dirname(expandedPath);
+                if (!fs__namespace.existsSync(dir)) {
+                    fs__namespace.mkdirSync(dir, { recursive: true });
+                }
+                fs__namespace.writeFileSync(expandedPath, script, 'utf-8');
+                console.log(`Completion script written to: ${expandedPath}`);
+            }
+            else {
+                console.log(script);
+            }
+        });
+    }
+}
+function createDefaultCompletionPaths(programName) {
+    return {
+        bash: `~/.local/share/bash-completion/completions/${programName}`,
+        fish: `~/.config/fish/completions/${programName}.fish`,
+        pwsh: '~/.config/powershell/Microsoft.PowerShell_profile.ps1',
+    };
+}
+function expandHome(filepath) {
+    if (filepath.startsWith('~/') || filepath === '~') {
+        const home = process.env['HOME'] || process.env['USERPROFILE'] || '';
+        return filepath.replace(/^~/, home);
+    }
+    return filepath;
+}
+class BashCompletion {
+    #meta;
+    #programName;
+    constructor(meta, programName) {
+        this.#meta = meta;
+        this.#programName = programName;
+    }
+    generate() {
+        const funcName = `_${this.#sanitizeName(this.#programName)}_completions`;
+        const lines = [
+            `# Bash completion for ${this.#programName}`,
+            '# Generated by @guanghechen/commander',
+            '',
+            `${funcName}() {`,
+            '  local cur prev words cword',
+            '  _init_completion || return',
+            '',
+            ...this.#generateCommandCase(this.#meta, 1),
+            '',
+            '  COMPREPLY=($(compgen -W "$opts" -- "$cur"))',
+            '}',
+            '',
+            `complete -F ${funcName} ${this.#programName}`,
+            '',
+        ];
+        return lines.join('\n');
+    }
+    #generateCommandCase(cmd, depth) {
+        const indent = '  '.repeat(depth);
+        const lines = [];
+        const optParts = [];
+        for (const opt of cmd.options) {
+            const kebabLong = camelToKebabCase(opt.long);
+            if (opt.short)
+                optParts.push(`-${opt.short}`);
+            optParts.push(`--${kebabLong}`);
+            if (!opt.takesValue) {
+                optParts.push(`--no-${kebabLong}`);
+            }
+        }
+        const subParts = cmd.subcommands.flatMap(sub => [sub.name, ...sub.aliases]);
+        const allOpts = [...optParts, ...subParts].join(' ');
+        if (cmd.subcommands.length > 0) {
+            lines.push(`${indent}case "\${words[${depth}]}" in`);
+            for (const sub of cmd.subcommands) {
+                const pattern = [sub.name, ...sub.aliases].join('|');
+                lines.push(`${indent}  ${pattern})`);
+                lines.push(...this.#generateCommandCase(sub, depth + 1));
+                lines.push(`${indent}    ;;`);
+            }
+            lines.push(`${indent}  *)`);
+            lines.push(`${indent}    opts="${allOpts}"`);
+            lines.push(`${indent}    ;;`);
+            lines.push(`${indent}esac`);
+        }
+        else {
+            lines.push(`${indent}opts="${allOpts}"`);
+        }
+        return lines;
+    }
+    #sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9]/g, '_');
+    }
+}
+class FishCompletion {
+    #meta;
+    #programName;
+    constructor(meta, programName) {
+        this.#meta = meta;
+        this.#programName = programName;
+    }
+    generate() {
+        const lines = [
+            `# Fish completion for ${this.#programName}`,
+            '# Generated by @guanghechen/commander',
+            '',
+            ...this.#generateCommandCompletions(this.#meta, []),
+            '',
+        ];
+        return lines.join('\n');
+    }
+    #generateCommandCompletions(cmd, parentPath) {
+        const lines = [];
+        const isRoot = parentPath.length === 0;
+        const condition = this.#buildCondition(parentPath);
+        for (const opt of cmd.options) {
+            const kebabLong = camelToKebabCase(opt.long);
+            let line = `complete -c ${this.#programName}`;
+            if (condition)
+                line += ` -n '${condition}'`;
+            if (opt.short)
+                line += ` -s ${opt.short}`;
+            line += ` -l ${kebabLong}`;
+            line += ` -d '${this.#escape(opt.desc)}'`;
+            if (opt.choices && opt.choices.length > 0) {
+                line += ` -xa '${opt.choices.join(' ')}'`;
+            }
+            lines.push(line);
+            if (!opt.takesValue) {
+                let noLine = `complete -c ${this.#programName}`;
+                if (condition)
+                    noLine += ` -n '${condition}'`;
+                noLine += ` -l no-${kebabLong}`;
+                noLine += ` -d '${this.#escape(opt.desc)}'`;
+                lines.push(noLine);
+            }
+        }
+        for (const sub of cmd.subcommands) {
+            let line = `complete -c ${this.#programName}`;
+            if (isRoot) {
+                line += ' -n __fish_use_subcommand';
+            }
+            else if (condition) {
+                line += ` -n '${condition}; and not __fish_seen_subcommand_from ${this.#getSubcommandNames(cmd).join(' ')}'`;
+            }
+            line += ` -a ${sub.name}`;
+            line += ` -d '${this.#escape(sub.desc)}'`;
+            lines.push(line);
+            for (const alias of sub.aliases) {
+                let aliasLine = `complete -c ${this.#programName}`;
+                if (isRoot) {
+                    aliasLine += ' -n __fish_use_subcommand';
+                }
+                else if (condition) {
+                    aliasLine += ` -n '${condition}; and not __fish_seen_subcommand_from ${this.#getSubcommandNames(cmd).join(' ')}'`;
+                }
+                aliasLine += ` -a ${alias}`;
+                aliasLine += ` -d 'Alias for ${sub.name}'`;
+                lines.push(aliasLine);
+            }
+            const newPath = [...parentPath, sub.name];
+            lines.push(...this.#generateCommandCompletions(sub, newPath));
+        }
+        return lines;
+    }
+    #buildCondition(path) {
+        if (path.length === 0)
+            return '';
+        return `__fish_seen_subcommand_from ${path[path.length - 1]}`;
+    }
+    #getSubcommandNames(cmd) {
+        return cmd.subcommands.flatMap(sub => [sub.name, ...sub.aliases]);
+    }
+    #escape(s) {
+        return s.replace(/'/g, "\\'");
+    }
+}
+class PwshCompletion {
+    #meta;
+    #programName;
+    constructor(meta, programName) {
+        this.#meta = meta;
+        this.#programName = programName;
+    }
+    generate() {
+        const lines = [
+            `# PowerShell completion for ${this.#programName}`,
+            '# Generated by @guanghechen/commander',
+            '',
+            `Register-ArgumentCompleter -Native -CommandName ${this.#programName} -ScriptBlock {`,
+            '  param($wordToComplete, $commandAst, $cursorPosition)',
+            '',
+            '  $commands = @{',
+            this.#generateCommandHash(this.#meta, '    '),
+            '  }',
+            '',
+            '  $words = $commandAst.CommandElements | ForEach-Object { $_.ToString() }',
+            '  $current = $wordToComplete',
+            '',
+            '  # Find current command context',
+            '  $cmd = $commands',
+            '  foreach ($word in $words[1..($words.Count - 1)]) {',
+            '    if ($word.StartsWith("-")) { continue }',
+            '    if ($cmd.subcommands -and $cmd.subcommands.ContainsKey($word)) {',
+            '      $cmd = $cmd.subcommands[$word]',
+            '    }',
+            '  }',
+            '',
+            '  # Generate completions',
+            '  $completions = @()',
+            '',
+            '  # Options',
+            '  if ($current.StartsWith("-")) {',
+            '    foreach ($opt in $cmd.options) {',
+            '      if ("--$($opt.long)" -like "$current*") {',
+            '        $completions += [System.Management.Automation.CompletionResult]::new(',
+            '          "--$($opt.long)",',
+            '          $opt.long,',
+            '          "ParameterName",',
+            '          $opt.desc',
+            '        )',
+            '      }',
+            '      if ($opt.isBoolean -and "--no-$($opt.long)" -like "$current*") {',
+            '        $completions += [System.Management.Automation.CompletionResult]::new(',
+            '          "--no-$($opt.long)",',
+            '          "no-$($opt.long)",',
+            '          "ParameterName",',
+            '          $opt.desc',
+            '        )',
+            '      }',
+            '      if ($opt.short -and "-$($opt.short)" -like "$current*") {',
+            '        $completions += [System.Management.Automation.CompletionResult]::new(',
+            '          "-$($opt.short)",',
+            '          $opt.short,',
+            '          "ParameterName",',
+            '          $opt.desc',
+            '        )',
+            '      }',
+            '    }',
+            '  }',
+            '',
+            '  # Subcommands',
+            '  if ($cmd.subcommands) {',
+            '    foreach ($sub in $cmd.subcommands.Keys) {',
+            '      if ($sub -like "$current*") {',
+            '        $completions += [System.Management.Automation.CompletionResult]::new(',
+            '          $sub,',
+            '          $sub,',
+            '          "Command",',
+            '          $cmd.subcommands[$sub].desc',
+            '        )',
+            '      }',
+            '    }',
+            '  }',
+            '',
+            '  return $completions',
+            '}',
+            '',
+        ];
+        return lines.join('\n');
+    }
+    #generateCommandHash(cmd, indent) {
+        const lines = [];
+        lines.push(`${indent}description = '${this.#escape(cmd.desc)}'`);
+        lines.push(`${indent}options = @(`);
+        for (const opt of cmd.options) {
+            const kebabLong = camelToKebabCase(opt.long);
+            lines.push(`${indent}  @{`);
+            if (opt.short)
+                lines.push(`${indent}    short = '${opt.short}'`);
+            lines.push(`${indent}    long = '${kebabLong}'`);
+            lines.push(`${indent}    description = '${this.#escape(opt.desc)}'`);
+            lines.push(`${indent}    isBoolean = $${!opt.takesValue}`);
+            if (opt.choices) {
+                lines.push(`${indent}    choices = @('${opt.choices.join("', '")}')`);
+            }
+            lines.push(`${indent}  }`);
+        }
+        lines.push(`${indent})`);
+        if (cmd.subcommands.length > 0) {
+            lines.push(`${indent}subcommands = @{`);
+            for (const sub of cmd.subcommands) {
+                lines.push(`${indent}  '${sub.name}' = @{`);
+                lines.push(this.#generateCommandHash(sub, `${indent}    `));
+                lines.push(`${indent}  }`);
+                for (const alias of sub.aliases) {
+                    lines.push(`${indent}  '${alias}' = @{`);
+                    lines.push(this.#generateCommandHash(sub, `${indent}    `));
+                    lines.push(`${indent}  }`);
+                }
+            }
+            lines.push(`${indent}}`);
+        }
+        return lines.join('\n');
+    }
+    #escape(s) {
+        return s.replace(/'/g, "''");
+    }
+}
+
+exports.BashCompletion = BashCompletion;
+exports.Coerce = Coerce;
+exports.Command = Command;
+exports.CommanderError = CommanderError;
+exports.CompletionCommand = CompletionCommand;
+exports.FishCompletion = FishCompletion;
+exports.PwshCompletion = PwshCompletion;
+exports.isDomain = isDomain;
+exports.isIp = isIp;
+exports.isIpv4 = isIpv4;
+exports.isIpv6 = isIpv6;
+exports.logColorfulOption = logColorfulOption;
+exports.logDateOption = logDateOption;
+exports.logLevelOption = logLevelOption;
+exports.silentOption = silentOption;