gunshi 0.35.0 → 0.35.2

package/lib/{core-xgWIcbHL.js → resolver-UFOtObbe.js}

@@ -1,7 +1,5 @@
-import { n as CLI_OPTIONS_DEFAULT, r as NOOP } from "./constants-CQq1R_68.js";
-import { i as isLazyCommand, o as resolveLazyCommand, r as getCommandSubCommands, s as kebabnize, t as create } from "./utils-DNVHO9MQ.js";
-import { createCommandContext } from "./context.js";
-//#region ../../node_modules/.pnpm/args-tokens@0.27.0/node_modules/args-tokens/lib/parser.js
+import { n as kebabnize, t as formatChoices } from "./utils-BKhsrjPW.js";
+//#region ../../node_modules/.pnpm/args-tokens@0.28.0/node_modules/args-tokens/lib/parser.js
 /**
 * forked from `nodejs/node` (`pkgjs/parseargs`)
 * repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
@@ -206,7 +204,7 @@ function hasOptionValue(value) {
 	return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/args-tokens@0.27.0/node_modules/args-tokens/lib/resolver.js
+//#region ../../node_modules/.pnpm/args-tokens@0.28.0/node_modules/args-tokens/lib/resolver.js
 /**
 * Entry point of argument options resolver.
 *
@@ -216,6 +214,60 @@ function hasOptionValue(value) {
 * @author kazuya kawaguchi (a.k.a. kazupon)
 * @license MIT
 */
+/**
+* Machine-readable error codes for {@link ArgsValidationError}.
+*
+* Each code identifies a validation failure category and is also suitable as an
+* i18n resource key for localized rendering.
+*/
+const ArgsValidationErrorKeys = {
+	requiredOption: "err:arg:required-option",
+	requiredPositional: "err:arg:required-positional",
+	invalidType: "err:arg:invalid-type",
+	invalidChoice: "err:arg:invalid-choice",
+	customParse: "err:arg:custom-parse",
+	unknownOption: "err:arg:unknown-option"
+};
+/**
+* An error that contains structured metadata for argument validation failures.
+*
+* The `message` remains the English fallback message. Renderers can use `code`
+* and `values` to localize the error, falling back to `message` when localization
+* is unavailable.
+*/
+var ArgsValidationError = class extends Error {
+	/**
+	* Machine-readable error code for this validation failure.
+	*
+	* This code can also be used as an i18n resource key.
+	*/
+	code;
+	/**
+	* Interpolation values for `code`.
+	*/
+	values;
+	/**
+	* Create an `ArgsValidationError` instance.
+	*
+	* @param message - fallback error message
+	* @param options - structured validation metadata
+	*/
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "ArgsValidationError";
+		this.code = options.code;
+		this.values = options.values ?? {};
+	}
+};
+/**
+* Check whether the given value is an {@link ArgsValidationError}.
+*
+* @param error - value to check
+* @returns `true` when the value is an `ArgsValidationError`
+*/
+function isArgsValidationError(error) {
+	return error instanceof ArgsValidationError;
+}
 const SKIP_POSITIONAL_DEFAULT = -1;
 /**
 * Resolve command line arguments.
@@ -379,11 +431,9 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 							const parsed = [];
 							for (let i = positionalsCount; i < endPositionals; i++) {
 								const p = positionalTokens[i];
-								try {
-									parsed.push(schema.parse(p.value));
-								} catch (error) {
-									errors.push(error);
-								}
+								const [parsedValue, error] = parseSchemaValue(p.value, rawArg, arg, schema);
+								if (error) errors.push(error);
+								else parsed.push(parsedValue);
 							}
 							values[rawArg] = parsed;
 						} else {
@@ -393,22 +443,22 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 						}
 						positionalsCount = endPositionals;
 						explicit[rawArg] = true;
-					} else if (schema.required) errors.push(createRequireError(arg, schema));
-				} else if (schema.required) errors.push(createRequireError(arg, schema));
+					} else if (schema.required) errors.push(createRequireError(rawArg, arg, schema));
+				} else if (schema.required) errors.push(createRequireError(rawArg, arg, schema));
 			} else {
 				const positional = positionalTokens[positionalsCount];
 				if (shouldRequireMissingSinglePositional(schema)) {
 					if (positional != null) {
-						resolveSinglePositionalValue(values, errors, rawArg, schema, positional);
+						resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
 						explicit[rawArg] = true;
 						positionalsCount++;
-					} else errors.push(createRequireError(arg, schema));
+					} else errors.push(createRequireError(rawArg, arg, schema));
 					continue;
 				}
 				if (positional != null) {
 					const requiredPositionals = getRequiredPositionalsAfter(rawArg);
 					if (Math.max(positionalTokens.length - positionalsCount, 0) > requiredPositionals) {
-						resolveSinglePositionalValue(values, errors, rawArg, schema, positional);
+						resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
 						explicit[rawArg] = true;
 						positionalsCount++;
 						continue;
@@ -422,14 +472,14 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 			if (!optionTokens.find((token) => {
 				return schema.short && token.name === schema.short || token.rawName && hasLongOptionPrefix(token.rawName) && token.name === arg;
 			})) {
-				errors.push(createRequireError(arg, schema));
+				errors.push(createRequireError(rawArg, arg, schema));
 				continue;
 			}
 		}
 		for (let i = 0; i < optionTokens.length; i++) {
 			const token = optionTokens[i];
 			if (checkTokenName(arg, schema, token) && token.rawName != void 0 && hasLongOptionPrefix(token.rawName) || schema.short === token.name && token.rawName != void 0 && isShortOption(token.rawName)) {
-				const invalid = validateRequire(token, arg, schema);
+				const invalid = validateRequire(token, rawArg, arg, schema);
 				if (invalid) {
 					errors.push(invalid);
 					continue;
@@ -437,7 +487,7 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 				explicit[rawArg] = true;
 				const actualInputName = isShortOption(token.rawName) ? `-${token.name}` : `--${arg}`;
 				actualInputNames.set(rawArg, actualInputName);
-				const [parsedValue, error] = parse(token, arg, schema);
+				const [parsedValue, error] = parse(token, rawArg, arg, schema);
 				if (error) errors.push(error);
 				else if (schema.multiple) {
 					values[rawArg] ||= [];
@@ -457,39 +507,49 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 		explicit
 	};
 }
-function parse(token, option, schema) {
-	if (typeof schema.parse === "function") try {
+function parse(token, rawArg, option, schema) {
+	if (typeof schema.parse === "function") {
 		if (schema.type === "boolean") {
 			const boolValue = !(schema.negatable && token.name.startsWith("no-"));
-			return [schema.parse(String(boolValue)), void 0];
+			return parseSchemaValue(String(boolValue), rawArg, option, schema);
 		}
-		return [schema.parse(token.value ?? String(schema.default ?? "")), void 0];
-	} catch (error) {
-		return [void 0, error];
+		return parseSchemaValue(token.value ?? String(schema.default ?? ""), rawArg, option, schema);
 	}
 	switch (schema.type) {
-		case "string": return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(option, schema)];
+		case "string": return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(rawArg, option, schema, token.value)];
 		case "boolean": return [!(schema.negatable && token.name.startsWith("no-")), void 0];
 		case "number":
-			if (!isNumeric(token.value)) return [void 0, createTypeError(option, schema)];
+			if (!isNumeric(token.value)) return [void 0, createTypeError(rawArg, option, schema, token.value)];
 			return token.value ? [+token.value, void 0] : [+(schema.default || ""), void 0];
 		case "enum":
-			if (schema.choices && !schema.choices.includes(token.value)) return [void 0, new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be chosen from '${schema.type}' [${schema.choices.map((c) => JSON.stringify(c)).join(", ")}] values`, option, "type", schema)];
+			if (schema.choices && !schema.choices.includes(token.value)) return [void 0, createChoiceError(rawArg, option, schema, token.value)];
 			return [token.value || schema.default, void 0];
 		case "custom": throw new TypeError(`argument '${option}' should have a 'parse' function`);
 		default: throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
 	}
 }
-function createRequireError(option, schema) {
-	return new ArgResolveError(schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`, option, "required", schema);
-}
-function resolveSinglePositionalValue(values, errors, rawArg, schema, positional) {
-	if (typeof schema.parse === "function") try {
-		values[rawArg] = schema.parse(positional.value);
+function parseSchemaValue(value, rawArg, option, schema) {
+	try {
+		return [schema.parse(value), void 0];
 	} catch (error) {
-		errors.push(error);
+		return [void 0, createCustomParseError(error, rawArg, option, schema, value)];
 	}
-	else values[rawArg] = positional.value;
+}
+function createRequireError(rawArg, option, schema) {
+	return new ArgResolveError(schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument ${createOptionDisplayName(option, schema)} is required`, option, "required", schema, {
+		code: schema.type === "positional" ? ArgsValidationErrorKeys.requiredPositional : ArgsValidationErrorKeys.requiredOption,
+		values: schema.type === "positional" ? { name: rawArg } : {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg
+		}
+	});
+}
+function resolveSinglePositionalValue(values, errors, rawArg, option, schema, positional) {
+	if (typeof schema.parse === "function") {
+		const [parsedValue, error] = parseSchemaValue(positional.value, rawArg, option, schema);
+		if (error) errors.push(error);
+		else values[rawArg] = parsedValue;
+	} else values[rawArg] = positional.value;
 }
 function hasDefault(schema) {
 	return schema.default != null;
@@ -519,7 +579,7 @@ function createRequiredPositionalsAfter(argEntries) {
 * An error that occurs when resolving arguments.
 * This error is thrown when the argument is not valid.
 */
-var ArgResolveError = class extends Error {
+var ArgResolveError = class extends ArgsValidationError {
 	name;
 	schema;
 	type;
@@ -528,24 +588,78 @@ var ArgResolveError = class extends Error {
 	*
 	* @param message - the error message
 	* @param name - the name of the argument
-	* @param type - the type of the error, either 'type' or 'required'
+	* @param type - the type of the error: 'type', 'required', or 'conflict'
 	* @param schema - the argument schema that caused the error
+	* @param options - structured validation metadata
 	*/
-	constructor(message, name, type, schema) {
-		super(message);
+	constructor(message, name, type, schema, options = {}) {
+		super(message, options);
 		this.name = name;
 		this.type = type;
 		this.schema = schema;
 	}
 };
-function validateRequire(token, option, schema) {
-	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(option, schema);
+function validateRequire(token, rawArg, option, schema) {
+	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(rawArg, option, schema);
 }
 function isNumeric(str) {
 	return str.trim() !== "" && !isNaN(str);
 }
-function createTypeError(option, schema) {
-	return new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`, option, "type", schema);
+function createTypeError(rawArg, option, schema, actual) {
+	return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be '${schema.type}'`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.invalidType,
+		values: {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg,
+			expected: schema.type,
+			...actual != null ? { actual } : {}
+		}
+	});
+}
+function createChoiceError(rawArg, option, schema, actual) {
+	const choices = schema.choices ?? [];
+	return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be chosen from '${schema.type}' [${formatChoices(choices)}] values`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.invalidChoice,
+		values: {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg,
+			expected: schema.type,
+			choices: formatChoices(choices),
+			choiceValues: [...choices],
+			...actual != null ? { actual } : {}
+		}
+	});
+}
+function createCustomParseError(error, rawArg, option, schema, value) {
+	if (isArgsValidationError(error)) {
+		augmentValidationError(error, rawArg, option, schema, value);
+		return error;
+	}
+	const reason = getErrorReason(error);
+	return new ArgsValidationError(reason, {
+		code: ArgsValidationErrorKeys.customParse,
+		values: {
+			displayName: createArgumentDisplayName(option, schema),
+			name: rawArg,
+			reason
+		},
+		cause: error
+	});
+}
+function augmentValidationError(error, rawArg, option, schema, value) {
+	const values = error.values;
+	values.name ??= rawArg;
+	values.displayName ??= createArgumentDisplayName(option, schema);
+	if ((error.code === ArgsValidationErrorKeys.invalidType || error.code === ArgsValidationErrorKeys.invalidChoice) && values.actual == null) values.actual = value;
+}
+function getErrorReason(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function createArgumentDisplayName(option, schema) {
+	return schema.type === "positional" ? `'${option}'` : createOptionDisplayName(option, schema);
+}
+function createOptionDisplayName(option, schema) {
+	return `'--${option}'${schema.short ? ` or '-${schema.short}'` : ""}`;
 }
 function checkConflicts(args, explicit, toKebab, actualInputNames) {
 	for (const rawArg in args) {
@@ -564,416 +678,4 @@ function checkConflicts(args, explicit, toKebab, actualInputNames) {
 	return [];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/args-tokens@0.27.0/node_modules/args-tokens/lib/index.js
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-//#endregion
-//#region src/decorators.ts
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-const EMPTY_RENDERER = () => Promise.resolve("");
-/**
-* Factory function for creating a decorators manager.
-*
-* @returns A new decorators manager instance
-*/
-function createDecorators() {
-	/**
-	* private states
-	*/
-	const headerDecorators = [];
-	const usageDecorators = [];
-	const validationDecorators = [];
-	const commandDecorators = [];
-	/**
-	* helper function for building renderers
-	*/
-	function buildRenderer(decorators, defaultRenderer) {
-		if (decorators.length === 0) return defaultRenderer;
-		let renderer = defaultRenderer;
-		for (const decorator of decorators) {
-			const previousRenderer = renderer;
-			renderer = (ctx) => decorator(previousRenderer, ctx);
-		}
-		return renderer;
-	}
-	/**
-	* public interfaces
-	*/
-	return Object.freeze({
-		addHeaderDecorator(decorator) {
-			headerDecorators.push(decorator);
-		},
-		addUsageDecorator(decorator) {
-			usageDecorators.push(decorator);
-		},
-		addValidationErrorsDecorator(decorator) {
-			validationDecorators.push(decorator);
-		},
-		addCommandDecorator(decorator) {
-			commandDecorators.push(decorator);
-		},
-		get commandDecorators() {
-			return [...commandDecorators];
-		},
-		getHeaderRenderer() {
-			return buildRenderer(headerDecorators, EMPTY_RENDERER);
-		},
-		getUsageRenderer() {
-			return buildRenderer(usageDecorators, EMPTY_RENDERER);
-		},
-		getValidationErrorsRenderer() {
-			if (validationDecorators.length === 0) return EMPTY_RENDERER;
-			let renderer = EMPTY_RENDERER;
-			for (const decorator of validationDecorators) {
-				const previousRenderer = renderer;
-				renderer = (ctx, error) => decorator(previousRenderer, ctx, error);
-			}
-			return renderer;
-		}
-	});
-}
-//#endregion
-//#region src/plugin/context.ts
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-/**
-* Factory function for creating a plugin context.
-*
-* @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command parameters.
-*
-* @param decorators - A {@linkcode Decorators} instance.
-* @param initialSubCommands - Initial sub commands map.
-* @returns A new {@linkcode PluginContext} instance.
-*/
-function createPluginContext(decorators, initialSubCommands) {
-	/**
-	* private states
-	*/
-	const globalOptions = /* @__PURE__ */ new Map();
-	const subCommands = new Map(initialSubCommands || []);
-	/**
-	* public interfaces
-	*/
-	return Object.freeze({
-		get globalOptions() {
-			return new Map(globalOptions);
-		},
-		addGlobalOption(name, schema) {
-			if (!name) throw new Error("Option name must be a non-empty string");
-			if (globalOptions.has(name)) throw new Error(`Global option '${name}' is already registered`);
-			globalOptions.set(name, schema);
-		},
-		get subCommands() {
-			return new Map(subCommands);
-		},
-		addCommand(name, command) {
-			if (!name) throw new Error("Command name must be a non-empty string");
-			if (subCommands.has(name)) throw new Error(`Command '${name}' is already registered`);
-			subCommands.set(name, command);
-		},
-		hasCommand(name) {
-			return subCommands.has(name);
-		},
-		decorateHeaderRenderer(decorator) {
-			decorators.addHeaderDecorator(decorator);
-		},
-		decorateUsageRenderer(decorator) {
-			decorators.addUsageDecorator(decorator);
-		},
-		decorateValidationErrorsRenderer(decorator) {
-			decorators.addValidationErrorsDecorator(decorator);
-		},
-		decorateCommand(decorator) {
-			decorators.addCommandDecorator(decorator);
-		}
-	});
-}
-//#endregion
-//#region src/plugin/dependency.ts
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-/**
-* Resolve plugin dependencies using topological sort
-*
-* @param plugins - Array of plugins to resolve
-* @returns Array of plugins sorted by dependencies
-*/
-function resolveDependencies(plugins) {
-	const sorted = [];
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const pluginMap = /* @__PURE__ */ new Map();
-	for (const plugin of plugins) if (plugin.id) {
-		if (pluginMap.has(plugin.id)) console.warn(`Duplicate plugin id detected: \`${plugin.id}\``);
-		pluginMap.set(plugin.id, plugin);
-	}
-	function visit(plugin) {
-		if (!plugin.id) return;
-		if (visited.has(plugin.id)) return;
-		if (visiting.has(plugin.id)) throw new Error(`Circular dependency detected: \`${[...visiting].join(` -> `) + " -> " + plugin.id}\``);
-		visiting.add(plugin.id);
-		const deps = plugin.dependencies || [];
-		for (const dep of deps) {
-			const depId = typeof dep === "string" ? dep : dep.id;
-			const isOptional = typeof dep === "string" ? false : dep.optional || false;
-			const depPlugin = pluginMap.get(depId);
-			if (!depPlugin && !isOptional) throw new Error(`Missing required dependency: \`${depId}\` on \`${plugin.id}\``);
-			if (depPlugin) visit(depPlugin);
-		}
-		visiting.delete(plugin.id);
-		visited.add(plugin.id);
-		sorted.push(plugin);
-	}
-	for (const plugin of plugins) visit(plugin);
-	return sorted;
-}
-//#endregion
-//#region src/cli/core.ts
-/**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-/**
-* Run the command.
-*
-* @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
-*
-* @param argv - Command line arguments
-* @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
-* @param options - A {@link CliOptions | CLI options}
-* @param plugins - An array of {@link Plugin | plugins} to be applied
-* @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
-*/
-async function cliCore(argv, entry, options, plugins) {
-	const decorators = createDecorators();
-	const pluginContext = createPluginContext(decorators, createInitialSubCommands(options, entry));
-	const resolvedPlugins = await applyPlugins(pluginContext, [...plugins, ...options.plugins || []]);
-	const cliOptions = normalizeCliOptions(options, decorators, pluginContext);
-	const tokens = parseArgs(argv);
-	const resolved = resolveCommandTree(tokens, entry, cliOptions);
-	const { commandName: name, command, callMode, commandPath, depth, levelSubCommands } = resolved;
-	if (!command) throw new Error(`Command not found: ${name || ""}`);
-	if (levelSubCommands) cliOptions.subCommands = levelSubCommands;
-	const resolvedCommand = isLazyCommand(command) ? await resolveLazyCommand(command, name, true) : command;
-	const args = resolveArguments(pluginContext, getCommandArgs(resolvedCommand));
-	const skipPositional = depth > 0 ? depth - 1 : -1;
-	const { explicit, values, positionals, rest, error } = resolveArgs(args, tokens, {
-		shortGrouping: true,
-		toKebab: resolvedCommand.toKebab,
-		skipPositional
-	});
-	const omitted = resolved.omitted;
-	return await executeCommand(resolvedCommand, await createCommandContext({
-		args,
-		explicit,
-		values,
-		positionals,
-		rest,
-		argv,
-		tokens,
-		omitted,
-		callMode,
-		commandPath,
-		command: resolvedCommand,
-		extensions: getPluginExtensions(resolvedPlugins),
-		validationError: error,
-		cliOptions
-	}), decorators.commandDecorators);
-}
-async function applyPlugins(pluginContext, plugins) {
-	const sortedPlugins = resolveDependencies(plugins);
-	try {
-		for (const plugin of sortedPlugins)
- /**
-		* NOTE(kazupon):
-		* strictly `Args` are not required for plugin installation.
-		* because the strictly `Args` required by each plugin are unknown,
-		* and the plugin side can not know what the user will specify.
-		*/
-		await plugin(pluginContext);
-	} catch (error) {
-		console.error("Error loading plugin:", error.message);
-	}
-	return sortedPlugins;
-}
-function getCommandArgs(cmd) {
-	if (isLazyCommand(cmd)) return cmd.args || create();
-	else if (typeof cmd === "object") return cmd.args || create();
-	else return create();
-}
-function resolveArguments(pluginContext, args) {
-	return Object.assign(create(), Object.fromEntries(pluginContext.globalOptions), args);
-}
-const isObject = (val) => val !== null && typeof val === "object";
-function createInitialSubCommands(options, entryCmd) {
-	const hasSubCommands = options.subCommands ? options.subCommands instanceof Map ? options.subCommands.size > 0 : isObject(options.subCommands) && Object.keys(options.subCommands).length > 0 : false;
-	const subCommands = new Map(options.subCommands instanceof Map ? options.subCommands : []);
-	if (!(options.subCommands instanceof Map) && isObject(options.subCommands)) for (const [name, cmd] of Object.entries(options.subCommands)) subCommands.set(name, cmd);
-	if (hasSubCommands) {
-		if (isLazyCommand(entryCmd)) {
-			const entryCopy = Object.assign((...args) => entryCmd(...args), entryCmd, { entry: true });
-			subCommands.set(resolveEntryName(entryCopy), entryCopy);
-		} else if (typeof entryCmd === "object") {
-			const entryCopy = Object.assign(create(), entryCmd, { entry: true });
-			subCommands.set(resolveEntryName(entryCopy), entryCopy);
-		} else if (typeof entryCmd === "function") {
-			const name = entryCmd.name || "(anonymous)";
-			subCommands.set(name, {
-				run: entryCmd,
-				name,
-				entry: true
-			});
-		}
-	}
-	return subCommands;
-}
-function normalizeCliOptions(options, decorators, pluginContext) {
-	const subCommands = new Map(pluginContext.subCommands);
-	const resolvedOptions = Object.assign(create(), CLI_OPTIONS_DEFAULT, options, { subCommands });
-	if (resolvedOptions.renderHeader === void 0) resolvedOptions.renderHeader = decorators.getHeaderRenderer();
-	if (resolvedOptions.renderUsage === void 0) resolvedOptions.renderUsage = decorators.getUsageRenderer();
-	if (resolvedOptions.renderValidationErrors === void 0) resolvedOptions.renderValidationErrors = decorators.getValidationErrorsRenderer();
-	return resolvedOptions;
-}
-function getPositionalTokens(tokens) {
-	return tokens.filter((t) => t.kind === "positional").map((t) => t.value).filter((v) => !!v);
-}
-function resolveCommandTree(tokens, entry, options) {
-	const positionals = getPositionalTokens(tokens);
-	function resolveAsEntry() {
-		if (typeof entry === "function") if ("commandName" in entry && entry.commandName) return {
-			commandName: entry.commandName,
-			command: entry,
-			callMode: "entry",
-			commandPath: [],
-			depth: 0,
-			omitted: options.subCommands.size > 0 && !positionals[0],
-			levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
-		};
-		else return {
-			command: {
-				run: entry,
-				entry: true
-			},
-			callMode: "entry",
-			commandPath: [],
-			depth: 0,
-			omitted: options.subCommands.size > 0 && !positionals[0],
-			levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
-		};
-		else if (typeof entry === "object") return {
-			commandName: resolveEntryName(entry),
-			command: entry,
-			callMode: "entry",
-			commandPath: [],
-			depth: 0,
-			omitted: options.subCommands.size > 0 && !positionals[0],
-			levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
-		};
-		else return {
-			callMode: "unexpected",
-			commandPath: [],
-			depth: 0,
-			omitted: false,
-			levelSubCommands: void 0
-		};
-	}
-	if (positionals.length === 0 || options.subCommands.size === 0) return resolveAsEntry();
-	let currentSubCommands = options.subCommands;
-	let resolvedCommand;
-	let resolvedName;
-	const commandPath = [];
-	let depth = 0;
-	for (let i = 0; i < positionals.length; i++) {
-		const token = positionals[i];
-		const cmd = currentSubCommands.get(token);
-		if (cmd == null) {
-			if (depth === 0) {
-				if (options.fallbackToEntry) return resolveAsEntry();
-				return {
-					commandName: token,
-					callMode: "unexpected",
-					commandPath: [],
-					depth: 0,
-					omitted: false,
-					levelSubCommands: void 0
-				};
-			}
-			break;
-		}
-		let resolved = cmd;
-		if (typeof cmd === "function" && cmd.commandName == null) resolved = Object.assign((...args) => cmd(...args), cmd, { commandName: token });
-		else if (typeof cmd === "object" && cmd.name == null) resolved = Object.assign(create(), cmd, { name: token });
-		resolvedCommand = resolved;
-		resolvedName = token;
-		commandPath.push(token);
-		depth++;
-		const nestedSubCommands = getCommandSubCommands(cmd);
-		if (nestedSubCommands && nestedSubCommands.size > 0) currentSubCommands = nestedSubCommands;
-		else break;
-	}
-	if (!resolvedCommand) return resolveAsEntry();
-	const resolvedSubCommands = getCommandSubCommands(resolvedCommand);
-	const omitted = resolvedSubCommands != null && resolvedSubCommands.size > 0;
-	let levelSubCommands;
-	if (omitted && resolvedSubCommands) {
-		levelSubCommands = new Map(resolvedSubCommands);
-		let entryCopy;
-		if (typeof resolvedCommand === "function") entryCopy = Object.assign((...args) => resolvedCommand(...args), resolvedCommand, { entry: true });
-		else entryCopy = Object.assign(create(), resolvedCommand, { entry: true });
-		levelSubCommands.set(resolvedName || resolveEntryName(entryCopy), entryCopy);
-	}
-	return {
-		commandName: resolvedName,
-		command: resolvedCommand,
-		callMode: depth > 0 ? "subCommand" : "entry",
-		commandPath,
-		depth,
-		omitted,
-		levelSubCommands
-	};
-}
-function resolveEntryName(entry) {
-	return isLazyCommand(entry) ? entry.commandName || "(anonymous)" : entry.name || "(anonymous)";
-}
-function getPluginExtensions(plugins) {
-	const extensions = create();
-	for (const plugin of plugins) if (plugin.extension) {
-		const key = plugin.id;
-		if (extensions[key]) console.warn(`Plugin "${key}" is already installed. Ignore it for command context extending.`);
-		else extensions[key] = plugin.extension;
-	}
-	return extensions;
-}
-async function executeCommand(cmd, ctx, decorators) {
-	const baseRunner = cmd.run || NOOP;
-	const decoratedRunner = decorators.reduceRight((runner, decorator) => decorator(runner), baseRunner);
-	try {
-		if (ctx.env.onBeforeCommand) await ctx.env.onBeforeCommand(ctx);
-		const result = await decoratedRunner(ctx);
-		if (ctx.env.onAfterCommand) await ctx.env.onAfterCommand(ctx, result);
-		return typeof result === "string" ? result : void 0;
-	} catch (error) {
-		if (ctx.env.onErrorCommand) try {
-			await ctx.env.onErrorCommand(ctx, error);
-		} catch (hookError) {
-			console.error("Error in onErrorCommand hook:", hookError);
-		}
-		throw error;
-	}
-}
-//#endregion
-export { resolveArgs as n, parseArgs as r, cliCore as t };
+export { parseArgs as a, resolveArgs as i, ArgsValidationErrorKeys as n, isArgsValidationError as r, ArgsValidationError as t };