@bomb.sh/tab 0.0.1-pre.0

package/dist/citty-BJEnxM_0.js

@@ -0,0 +1,525 @@
+import { generate as generate$3, generate$1 as generate$2, generate$2 as generate$1, generate$3 as generate, t_default } from "./t-Zhhzaib1.js";
+import { assertDoubleDashes } from "./shared-BGWjvggn.js";
+import { colors, consola } from "./consola.36c0034f-CftISWio.js";
+
+//#region node_modules/.pnpm/citty@0.1.6/node_modules/citty/dist/index.mjs
+function toArray(val) {
+	if (Array.isArray(val)) return val;
+	return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+	const maxLengh = [];
+	for (const line of lines) for (const [i, element] of line.entries()) maxLengh[i] = Math.max(maxLengh[i] || 0, element.length);
+	return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLengh[i])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+	return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "CLIError";
+	}
+};
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = [
+	"-",
+	"_",
+	"/",
+	"."
+];
+function isUppercase(char = "") {
+	if (NUMBER_CHAR_RE.test(char)) return void 0;
+	return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+	const splitters = separators ?? STR_SPLITTERS;
+	const parts = [];
+	if (!str || typeof str !== "string") return parts;
+	let buff = "";
+	let previousUpper;
+	let previousSplitter;
+	for (const char of str) {
+		const isSplitter = splitters.includes(char);
+		if (isSplitter === true) {
+			parts.push(buff);
+			buff = "";
+			previousUpper = void 0;
+			continue;
+		}
+		const isUpper = isUppercase(char);
+		if (previousSplitter === false) {
+			if (previousUpper === false && isUpper === true) {
+				parts.push(buff);
+				buff = char;
+				previousUpper = isUpper;
+				continue;
+			}
+			if (previousUpper === true && isUpper === false && buff.length > 1) {
+				const lastChar = buff.at(-1);
+				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+				buff = lastChar + char;
+				previousUpper = isUpper;
+				continue;
+			}
+		}
+		buff += char;
+		previousUpper = isUpper;
+		previousSplitter = isSplitter;
+	}
+	parts.push(buff);
+	return parts;
+}
+function upperFirst(str) {
+	return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+	return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+	return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+function toArr(any) {
+	return any == void 0 ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+	let x$1;
+	const old = out[key];
+	const nxt = ~opts.string.indexOf(key) ? val == void 0 || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x$1 = +val, x$1 * 0 === 0) ? x$1 : val), !!val) : (x$1 = +val, x$1 * 0 === 0) ? x$1 : val;
+	out[key] = old == void 0 ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function parseRawArgs(args = [], opts = {}) {
+	let k;
+	let arr;
+	let arg;
+	let name;
+	let val;
+	const out = { _: [] };
+	let i = 0;
+	let j = 0;
+	let idx = 0;
+	const len = args.length;
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+	if (alibi) for (k in opts.alias) {
+		arr = opts.alias[k] = toArr(opts.alias[k]);
+		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+	}
+	for (i = opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+	for (i = opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+	if (defaults) for (k in opts.default) {
+		name = typeof opts.default[k];
+		arr = opts.alias[k] = opts.alias[k] || [];
+		if (opts[name] !== void 0) {
+			opts[name].push(k);
+			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+		}
+	}
+	const keys = strict ? Object.keys(opts.alias) : [];
+	for (i = 0; i < len; i++) {
+		arg = args[i];
+		if (arg === "--") {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
+		if (j === 0) out._.push(arg);
+		else if (arg.substring(j, j + 3) === "no-") {
+			name = arg.slice(Math.max(0, j + 3));
+			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+			out[name] = false;
+		} else {
+			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
+			name = arg.substring(j, idx);
+			val = arg.slice(Math.max(0, ++idx)) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+			arr = j === 2 ? [name] : name;
+			for (idx = 0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+				toVal(out, name, idx + 1 < arr.length || val, opts);
+			}
+		}
+	}
+	if (defaults) {
+		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	}
+	if (alibi) for (k in out) {
+		arr = opts.alias[k] || [];
+		while (arr.length > 0) out[arr.shift()] = out[k];
+	}
+	return out;
+}
+function parseArgs(rawArgs, argsDef) {
+	const parseOptions = {
+		boolean: [],
+		string: [],
+		mixed: [],
+		alias: {},
+		default: {}
+	};
+	const args = resolveArgs(argsDef);
+	for (const arg of args) {
+		if (arg.type === "positional") continue;
+		if (arg.type === "string") parseOptions.string.push(arg.name);
+		else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+		if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+		if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+	}
+	const parsed = parseRawArgs(rawArgs, parseOptions);
+	const [ ...positionalArguments] = parsed._;
+	const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+		return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+	} });
+	for (const [, arg] of args.entries()) if (arg.type === "positional") {
+		const nextPositionalArgument = positionalArguments.shift();
+		if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+		else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+		else parsedArgsProxy[arg.name] = arg.default;
+	} else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+	return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+	const args = [];
+	for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+		...argDef,
+		name,
+		alias: toArray(argDef.alias)
+	});
+	return args;
+}
+function defineCommand(def) {
+	return def;
+}
+async function runCommand(cmd, opts) {
+	const cmdArgs = await resolveValue(cmd.args || {});
+	const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+	const context = {
+		rawArgs: opts.rawArgs,
+		args: parsedArgs,
+		data: opts.data,
+		cmd
+	};
+	if (typeof cmd.setup === "function") await cmd.setup(context);
+	let result;
+	try {
+		const subCommands = await resolveValue(cmd.subCommands);
+		if (subCommands && Object.keys(subCommands).length > 0) {
+			const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
+			const subCommandName = opts.rawArgs[subCommandArgIndex];
+			if (subCommandName) {
+				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command \`${subCommandName}\``, "E_UNKNOWN_COMMAND");
+				const subCommand = await resolveValue(subCommands[subCommandName]);
+				if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+		}
+		if (typeof cmd.run === "function") result = await cmd.run(context);
+	} finally {
+		if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+	}
+	return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+	const subCommands = await resolveValue(cmd.subCommands);
+	if (subCommands && Object.keys(subCommands).length > 0) {
+		const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+		const subCommandName = rawArgs[subCommandArgIndex];
+		const subCommand = await resolveValue(subCommands[subCommandName]);
+		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+	}
+	return [cmd, parent];
+}
+async function showUsage(cmd, parent) {
+	try {
+		consola.log(await renderUsage(cmd, parent) + "\n");
+	} catch (error) {
+		consola.error(error);
+	}
+}
+async function renderUsage(cmd, parent) {
+	const cmdMeta = await resolveValue(cmd.meta || {});
+	const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+	const parentMeta = await resolveValue(parent?.meta || {});
+	const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+	const argLines = [];
+	const posLines = [];
+	const commandsLines = [];
+	const usageLine = [];
+	for (const arg of cmdArgs) if (arg.type === "positional") {
+		const name = arg.name.toUpperCase();
+		const isRequired = arg.required !== false && arg.default === void 0;
+		const defaultHint = arg.default ? `="${arg.default}"` : "";
+		posLines.push([
+			"`" + name + defaultHint + "`",
+			arg.description || "",
+			arg.valueHint ? `<${arg.valueHint}>` : ""
+		]);
+		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+	} else {
+		const isRequired = arg.required === true && arg.default === void 0;
+		const argStr = (arg.type === "boolean" && arg.default === true ? [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ") : [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ")) + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "");
+		argLines.push(["`" + argStr + (isRequired ? " (required)" : "") + "`", arg.description || ""]);
+		if (isRequired) usageLine.push(argStr);
+	}
+	if (cmd.subCommands) {
+		const commandNames = [];
+		const subCommands = await resolveValue(cmd.subCommands);
+		for (const [name, sub] of Object.entries(subCommands)) {
+			const subCmd = await resolveValue(sub);
+			const meta = await resolveValue(subCmd?.meta);
+			commandsLines.push([`\`${name}\``, meta?.description || ""]);
+			commandNames.push(name);
+		}
+		usageLine.push(commandNames.join("|"));
+	}
+	const usageLines = [];
+	const version = cmdMeta.version || parentMeta.version;
+	usageLines.push(colors.gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+	const hasOptions = argLines.length > 0 || posLines.length > 0;
+	usageLines.push(`${colors.underline(colors.bold("USAGE"))} \`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}\``, "");
+	if (posLines.length > 0) {
+		usageLines.push(colors.underline(colors.bold("ARGUMENTS")), "");
+		usageLines.push(formatLineColumns(posLines, "  "));
+		usageLines.push("");
+	}
+	if (argLines.length > 0) {
+		usageLines.push(colors.underline(colors.bold("OPTIONS")), "");
+		usageLines.push(formatLineColumns(argLines, "  "));
+		usageLines.push("");
+	}
+	if (commandsLines.length > 0) {
+		usageLines.push(colors.underline(colors.bold("COMMANDS")), "");
+		usageLines.push(formatLineColumns(commandsLines, "  "));
+		usageLines.push("", `Use \`${commandName} <command> --help\` for more information about a command.`);
+	}
+	return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+async function runMain(cmd, opts = {}) {
+	const rawArgs = opts.rawArgs || process.argv.slice(2);
+	const showUsage$1 = opts.showUsage || showUsage;
+	try {
+		if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+			process.exit(0);
+		} else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
+			consola.log(meta.version);
+		} else await runCommand(cmd, { rawArgs });
+	} catch (error) {
+		const isCLIError = error instanceof CLIError;
+		if (!isCLIError) consola.error(error, "\n");
+		if (isCLIError) await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+		consola.error(error.message);
+		process.exit(1);
+	}
+}
+function createMain(cmd) {
+	return (opts = {}) => runMain(cmd, opts);
+}
+
+//#endregion
+//#region src/fig.ts
+async function processArgs$1(args) {
+	const options = [];
+	const positionalArgs = [];
+	for (const [name, arg] of Object.entries(args)) if (arg.type === "positional") {
+		const positionalArg = arg;
+		positionalArgs.push({
+			name,
+			description: positionalArg.description,
+			isOptional: !positionalArg.required,
+			isVariadic: name.startsWith("[...") || name.startsWith("<...")
+		});
+	} else {
+		const option = {
+			name: `--${name}`,
+			description: arg.description || "",
+			isRequired: arg.required
+		};
+		if ("alias" in arg && arg.alias) {
+			const aliases = Array.isArray(arg.alias) ? arg.alias : [arg.alias];
+			aliases.forEach((alias) => {
+				options.push({
+					...option,
+					name: `-${alias}`
+				});
+			});
+		}
+		options.push(option);
+	}
+	return {
+		options,
+		args: positionalArgs
+	};
+}
+async function processCommand(command, parentName = "") {
+	const resolvedMeta = await Promise.resolve(command.meta);
+	const meta = resolvedMeta;
+	const subCommands = await Promise.resolve(command.subCommands);
+	if (!meta || !meta.name) throw new Error("Command meta or name is missing");
+	const spec = {
+		name: parentName ? `${parentName} ${meta.name}` : meta.name,
+		description: meta.description || ""
+	};
+	if (command.args) {
+		const resolvedArgs = await Promise.resolve(command.args);
+		const { options, args } = await processArgs$1(resolvedArgs);
+		if (options.length > 0) spec.options = options;
+		if (args.length > 0) spec.args = args;
+	}
+	if (subCommands) spec.subcommands = await Promise.all(Object.entries(subCommands).map(async ([_, subCmd]) => {
+		const resolved = await Promise.resolve(subCmd);
+		return processCommand(resolved, spec.name);
+	}));
+	return spec;
+}
+async function generateFigSpec(command) {
+	const spec = await processCommand(command);
+	return JSON.stringify(spec, null, 2);
+}
+
+//#endregion
+//#region src/citty.ts
+function quoteIfNeeded(path) {
+	return path.includes(" ") ? `'${path}'` : path;
+}
+const execPath = process.execPath;
+const processArgs = process.argv.slice(1);
+const quotedExecPath = quoteIfNeeded(execPath);
+const quotedProcessArgs = processArgs.map(quoteIfNeeded);
+const quotedProcessExecArgs = process.execArgv.map(quoteIfNeeded);
+const x = `${quotedExecPath} ${quotedProcessExecArgs.join(" ")} ${quotedProcessArgs[0]}`;
+function isConfigPositional(config) {
+	return config.args && Object.values(config.args).some((arg) => arg.type === "positional");
+}
+async function handleSubCommands(subCommands, parentCmd, completionConfig) {
+	for (const [cmd, resolvableConfig] of Object.entries(subCommands)) {
+		const config = await resolve(resolvableConfig);
+		const meta = await resolve(config.meta);
+		const subCommands$1 = await resolve(config.subCommands);
+		const subCompletionConfig = completionConfig?.[cmd];
+		if (!meta || typeof meta?.description !== "string") throw new Error("Invalid meta or missing description.");
+		const isPositional = isConfigPositional(config);
+		const commandName = parentCmd ? `${parentCmd} ${cmd}` : cmd;
+		const command = t_default.command(commandName, meta.description);
+		if (isPositional && config.args) for (const [argName, argConfig] of Object.entries(config.args)) {
+			const conf = argConfig;
+			if (conf.type === "positional") {
+				const isVariadic = conf.required === false;
+				const argHandler = subCompletionConfig?.args?.[argName];
+				if (argHandler) command.argument(argName, argHandler, isVariadic);
+				else command.argument(argName, void 0, isVariadic);
+			}
+		}
+		if (subCommands$1) await handleSubCommands(subCommands$1, commandName, subCompletionConfig?.subCommands);
+		if (config.args) for (const [argName, argConfig] of Object.entries(config.args)) {
+			const conf = argConfig;
+			const shortFlag = typeof conf === "object" && "alias" in conf ? Array.isArray(conf.alias) ? conf.alias[0] : conf.alias : void 0;
+			const handler = subCompletionConfig?.options?.[argName];
+			if (handler) if (shortFlag) command.option(argName, conf.description ?? "", handler, shortFlag);
+			else command.option(argName, conf.description ?? "", handler);
+			else if (shortFlag) command.option(argName, conf.description ?? "", shortFlag);
+			else command.option(argName, conf.description ?? "");
+		}
+	}
+}
+async function tab(instance, completionConfig) {
+	const meta = await resolve(instance.meta);
+	if (!meta) throw new Error("Invalid meta.");
+	const name = meta.name;
+	if (!name) throw new Error("Invalid meta or missing name.");
+	const subCommands = await resolve(instance.subCommands);
+	if (!subCommands) throw new Error("Invalid or missing subCommands.");
+	const isPositional = isConfigPositional(instance);
+	if (isPositional && instance.args) for (const [argName, argConfig] of Object.entries(instance.args)) {
+		const conf = argConfig;
+		if (conf.type === "positional") {
+			const isVariadic = conf.required === false;
+			const argHandler = completionConfig?.args?.[argName];
+			if (argHandler) t_default.argument(argName, argHandler, isVariadic);
+			else t_default.argument(argName, void 0, isVariadic);
+		}
+	}
+	await handleSubCommands(subCommands, void 0, completionConfig?.subCommands);
+	if (instance.args) for (const [argName, argConfig] of Object.entries(instance.args)) {
+		const conf = argConfig;
+		const shortFlag = typeof conf === "object" && "alias" in conf ? Array.isArray(conf.alias) ? conf.alias[0] : conf.alias : void 0;
+		const handler = completionConfig?.options?.[argName];
+		if (handler) if (shortFlag) t_default.option(argName, conf.description ?? "", handler, shortFlag);
+		else t_default.option(argName, conf.description ?? "", handler);
+		else if (shortFlag) t_default.option(argName, conf.description ?? "", shortFlag);
+		else t_default.option(argName, conf.description ?? "");
+	}
+	const completeCommand = defineCommand({
+		meta: {
+			name: "complete",
+			description: "Generate shell completion scripts"
+		},
+		args: { shell: {
+			type: "positional",
+			description: "Shell type (zsh, bash, fish, powershell, fig)",
+			required: false
+		} },
+		async run(ctx) {
+			let shell = ctx.rawArgs[0];
+			if (shell === "--") shell = void 0;
+			switch (shell) {
+				case "zsh": {
+					const script = generate(name, x);
+					console.log(script);
+					break;
+				}
+				case "bash": {
+					const script = generate$1(name, x);
+					console.log(script);
+					break;
+				}
+				case "fish": {
+					const script = generate$2(name, x);
+					console.log(script);
+					break;
+				}
+				case "powershell": {
+					const script = generate$3(name, x);
+					console.log(script);
+					break;
+				}
+				case "fig": {
+					const spec = await generateFigSpec(instance);
+					console.log(spec);
+					break;
+				}
+				default: {
+					assertDoubleDashes(name);
+					const extra = ctx.rawArgs.slice(ctx.rawArgs.indexOf("--") + 1);
+					return t_default.parse(extra);
+				}
+			}
+		}
+	});
+	subCommands.complete = completeCommand;
+	return t_default;
+}
+async function resolve(resolvable) {
+	return resolvable instanceof Function ? await resolvable() : await resolvable;
+}
+
+//#endregion
+export { createMain, defineCommand, tab as tab$1 };

package/dist/commander-gLSiUyHX.js

@@ -0,0 +1,103 @@
+import { generate as generate$3, generate$1 as generate$2, generate$2 as generate$1, generate$3 as generate, t_default } from "./t-Zhhzaib1.js";
+import { assertDoubleDashes } from "./shared-BGWjvggn.js";
+
+//#region src/commander.ts
+const execPath = process.execPath;
+const processArgs = process.argv.slice(1);
+const quotedExecPath = quoteIfNeeded(execPath);
+const quotedProcessArgs = processArgs.map(quoteIfNeeded);
+const quotedProcessExecArgs = process.execArgv.map(quoteIfNeeded);
+const x = `${quotedExecPath} ${quotedProcessExecArgs.join(" ")} ${quotedProcessArgs[0]}`;
+function quoteIfNeeded(path) {
+	return path.includes(" ") ? `'${path}'` : path;
+}
+function tab(instance) {
+	const programName = instance.name();
+	processRootCommand(instance, programName);
+	processSubcommands(instance, programName);
+	instance.command("complete [shell]").description("Generate shell completion scripts").action(async (shell) => {
+		switch (shell) {
+			case "zsh": {
+				const script = generate(programName, x);
+				console.log(script);
+				break;
+			}
+			case "bash": {
+				const script = generate$1(programName, x);
+				console.log(script);
+				break;
+			}
+			case "fish": {
+				const script = generate$2(programName, x);
+				console.log(script);
+				break;
+			}
+			case "powershell": {
+				const script = generate$3(programName, x);
+				console.log(script);
+				break;
+			}
+			case "debug": {
+				const commandMap = new Map();
+				collectCommands(instance, "", commandMap);
+				console.log("Collected commands:");
+				for (const [path, cmd] of commandMap.entries()) console.log(`- ${path || "<root>"}: ${cmd.description() || "No description"}`);
+				break;
+			}
+			default: {
+				console.error(`Unknown shell: ${shell}`);
+				console.error("Supported shells: zsh, bash, fish, powershell");
+				process.exit(1);
+			}
+		}
+	});
+	const originalParse = instance.parse.bind(instance);
+	instance.parse = function(argv, options) {
+		const args = argv || process.argv;
+		const completeIndex = args.findIndex((arg) => arg === "complete");
+		const dashDashIndex = args.findIndex((arg) => arg === "--");
+		if (completeIndex !== -1 && dashDashIndex !== -1 && dashDashIndex > completeIndex) {
+			const extra = args.slice(dashDashIndex + 1);
+			assertDoubleDashes(programName);
+			t_default.parse(extra);
+			return instance;
+		}
+		return originalParse(argv, options);
+	};
+	return t_default;
+}
+function processRootCommand(command, programName) {
+	for (const option of command.options) {
+		const flags = option.flags;
+		const shortFlag = flags.match(/^-([a-zA-Z]), --/)?.[1];
+		const longFlag = flags.match(/--([a-zA-Z0-9-]+)/)?.[1];
+		if (longFlag) if (shortFlag) t_default.option(longFlag, option.description || "", shortFlag);
+		else t_default.option(longFlag, option.description || "");
+	}
+}
+function processSubcommands(rootCommand, programName) {
+	const commandMap = new Map();
+	collectCommands(rootCommand, "", commandMap);
+	for (const [path, cmd] of commandMap.entries()) {
+		if (path === "") continue;
+		const command = t_default.command(path, cmd.description() || "");
+		for (const option of cmd.options) {
+			const flags = option.flags;
+			const shortFlag = flags.match(/^-([a-zA-Z]), --/)?.[1];
+			const longFlag = flags.match(/--([a-zA-Z0-9-]+)/)?.[1];
+			if (longFlag) if (shortFlag) command.option(longFlag, option.description || "", shortFlag);
+			else command.option(longFlag, option.description || "");
+		}
+	}
+}
+function collectCommands(command, parentPath, commandMap) {
+	commandMap.set(parentPath, command);
+	for (const subcommand of command.commands) {
+		if (subcommand.name() === "complete") continue;
+		const subcommandPath = parentPath ? `${parentPath} ${subcommand.name()}` : subcommand.name();
+		collectCommands(subcommand, subcommandPath, commandMap);
+	}
+}
+
+//#endregion
+export { tab as tab$2 };