@gunshi/bone 0.26.3

package/lib/index.js

@@ -0,0 +1,847 @@
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/parser-Dr4iAGaX.js
+const HYPHEN_CHAR = "-";
+const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+const EQUAL_CHAR = "=";
+const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+const TERMINATOR = "--";
+const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+const LONG_OPTION_PREFIX = "--";
+/**
+* Parse command line arguments.
+* @example
+* ```js
+* import { parseArgs } from 'args-tokens' // for Node.js and Bun
+* // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+*
+* const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+* // do something with using tokens
+* // ...
+* console.log('tokens:', tokens)
+* ```
+* @param args command line arguments
+* @param options parse options
+* @returns Argument tokens.
+*/
+function parseArgs(args, options = {}) {
+	const { allowCompatible = false } = options;
+	const tokens = [];
+	const remainings = [...args];
+	let index = -1;
+	let groupCount = 0;
+	let hasShortValueSeparator = false;
+	while (remainings.length > 0) {
+		const arg = remainings.shift();
+		if (arg == void 0) break;
+		const nextArg = remainings[0];
+		if (groupCount > 0) groupCount--;
+		else index++;
+		if (arg === TERMINATOR) {
+			tokens.push({
+				kind: "option-terminator",
+				index
+			});
+			const mapped = remainings.map((arg$1) => {
+				return {
+					kind: "positional",
+					index: ++index,
+					value: arg$1
+				};
+			});
+			tokens.push(...mapped);
+			break;
+		}
+		if (isShortOption(arg)) {
+			const shortOption = arg.charAt(1);
+			let value;
+			let inlineValue;
+			if (groupCount) {
+				tokens.push({
+					kind: "option",
+					name: shortOption,
+					rawName: arg,
+					index,
+					value,
+					inlineValue
+				});
+				if (groupCount === 1 && hasOptionValue(nextArg)) {
+					value = remainings.shift();
+					if (hasShortValueSeparator) {
+						inlineValue = true;
+						hasShortValueSeparator = false;
+					}
+					tokens.push({
+						kind: "option",
+						index,
+						value,
+						inlineValue
+					});
+				}
+			} else tokens.push({
+				kind: "option",
+				name: shortOption,
+				rawName: arg,
+				index,
+				value,
+				inlineValue
+			});
+			if (value != null) ++index;
+			continue;
+		}
+		if (isShortOptionGroup(arg)) {
+			const expanded = [];
+			let shortValue = "";
+			for (let i = 1; i < arg.length; i++) {
+				const shortableOption = arg.charAt(i);
+				if (hasShortValueSeparator) shortValue += shortableOption;
+				else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) hasShortValueSeparator = true;
+				else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+			}
+			if (shortValue) expanded.push(shortValue);
+			remainings.unshift(...expanded);
+			groupCount = expanded.length;
+			continue;
+		}
+		if (isLongOption(arg)) {
+			const longOption = arg.slice(2);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: arg,
+				index,
+				value: void 0,
+				inlineValue: void 0
+			});
+			continue;
+		}
+		if (isLongOptionAndValue(arg)) {
+			const equalIndex = arg.indexOf(EQUAL_CHAR);
+			const longOption = arg.slice(2, equalIndex);
+			const value = arg.slice(equalIndex + 1);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+				index,
+				value,
+				inlineValue: true
+			});
+			continue;
+		}
+		tokens.push({
+			kind: "positional",
+			index,
+			value: arg
+		});
+	}
+	return tokens;
+}
+/**
+* Check if `arg` is a short option (e.g. `-f`).
+* @param arg the argument to check
+* @returns whether `arg` is a short option.
+*/
+function isShortOption(arg) {
+	return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
+}
+/**
+* Check if `arg` is a short option group (e.g. `-abc`).
+* @param arg the argument to check
+* @returns whether `arg` is a short option group.
+*/
+function isShortOptionGroup(arg) {
+	if (arg.length <= 2) return false;
+	if (arg.codePointAt(0) !== HYPHEN_CODE) return false;
+	if (arg.codePointAt(1) === HYPHEN_CODE) return false;
+	return true;
+}
+/**
+* Check if `arg` is a long option (e.g. `--foo`).
+* @param arg the argument to check
+* @returns whether `arg` is a long option.
+*/
+function isLongOption(arg) {
+	return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+/**
+* Check if `arg` is a long option with value (e.g. `--foo=bar`).
+* @param arg the argument to check
+* @returns whether `arg` is a long option.
+*/
+function isLongOptionAndValue(arg) {
+	return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+/**
+* Check if `arg` is a long option prefix (e.g. `--`).
+* @param arg the argument to check
+* @returns whether `arg` is a long option prefix.
+*/
+function hasLongOptionPrefix(arg) {
+	return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
+}
+/**
+* Check if a `value` is an option value.
+* @param value a value to check
+* @returns whether a `value` is an option value.
+*/
+function hasOptionValue(value) {
+	return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/utils-N7UlhLbz.js
+/**
+* Entry point of utils.
+*
+* Note that this entry point is used by gunshi to import utility functions.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+function kebabnize(str) {
+	return str.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/resolver-Q4k2fgTW.js
+const SKIP_POSITIONAL_DEFAULT = -1;
+/**
+* Resolve command line arguments.
+* @param args - An arguments that contains {@link ArgSchema | arguments schema}.
+* @param tokens - An array of {@link ArgToken | tokens}.
+* @param resolveArgs - An arguments that contains {@link ResolveArgs | resolve arguments}.
+* @returns An object that contains the values of the arguments, positional arguments, rest arguments, and {@link AggregateError | validation errors}.
+*/
+function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKIP_POSITIONAL_DEFAULT, toKebab = false } = {}) {
+	const skipPositionalIndex = typeof skipPositional === "number" ? Math.max(skipPositional, SKIP_POSITIONAL_DEFAULT) : SKIP_POSITIONAL_DEFAULT;
+	const rest = [];
+	const optionTokens = [];
+	const positionalTokens = [];
+	let currentLongOption;
+	let currentShortOption;
+	const expandableShortOptions = [];
+	function toShortValue() {
+		if (expandableShortOptions.length === 0) return void 0;
+		else {
+			const value = expandableShortOptions.map((token) => token.name).join("");
+			expandableShortOptions.length = 0;
+			return value;
+		}
+	}
+	function applyLongOptionValue(value = void 0) {
+		if (currentLongOption) {
+			currentLongOption.value = value;
+			optionTokens.push({ ...currentLongOption });
+			currentLongOption = void 0;
+		}
+	}
+	function applyShortOptionValue(value = void 0) {
+		if (currentShortOption) {
+			currentShortOption.value = value || toShortValue();
+			optionTokens.push({ ...currentShortOption });
+			currentShortOption = void 0;
+		}
+	}
+	/**
+	* analyze phase to resolve value
+	* separate tokens into positionals, long and short options, after that resolve values
+	*/
+	const schemas = Object.values(args);
+	let terminated = false;
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.kind === "positional") {
+			if (terminated && token.value) {
+				rest.push(token.value);
+				continue;
+			}
+			if (currentShortOption) {
+				const found = schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean");
+				if (found) positionalTokens.push({ ...token });
+			} else if (currentLongOption) {
+				const found = args[currentLongOption.name]?.type === "boolean";
+				if (found) positionalTokens.push({ ...token });
+			} else positionalTokens.push({ ...token });
+			applyLongOptionValue(token.value);
+			applyShortOptionValue(token.value);
+		} else if (token.kind === "option") if (token.rawName) {
+			if (hasLongOptionPrefix(token.rawName)) {
+				applyLongOptionValue();
+				if (token.inlineValue) optionTokens.push({ ...token });
+				else currentLongOption = { ...token };
+				applyShortOptionValue();
+			} else if (isShortOption(token.rawName)) if (currentShortOption) {
+				if (currentShortOption.index === token.index) if (shortGrouping) {
+					currentShortOption.value = token.value;
+					optionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				} else expandableShortOptions.push({ ...token });
+				else {
+					currentShortOption.value = toShortValue();
+					optionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				}
+				applyLongOptionValue();
+			} else {
+				currentShortOption = { ...token };
+				applyLongOptionValue();
+			}
+		} else {
+			if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
+				currentShortOption.value = token.value;
+				optionTokens.push({ ...currentShortOption });
+				currentShortOption = void 0;
+			}
+			applyLongOptionValue();
+		}
+		else {
+			if (token.kind === "option-terminator") terminated = true;
+			applyLongOptionValue();
+			applyShortOptionValue();
+		}
+	}
+	/**
+	* check if the last long or short option is not resolved
+	*/
+	applyLongOptionValue();
+	applyShortOptionValue();
+	/**
+	* resolve values
+	*/
+	const values = Object.create(null);
+	const errors = [];
+	function checkTokenName(option, schema, token) {
+		return token.name === (schema.type === "boolean" ? schema.negatable && token.name?.startsWith("no-") ? `no-${option}` : option : option);
+	}
+	const positionalItemCount = tokens.filter((token) => token.kind === "positional").length;
+	function getPositionalSkipIndex() {
+		return Math.min(skipPositionalIndex, positionalItemCount);
+	}
+	let positionalsCount = 0;
+	for (const [rawArg, schema] of Object.entries(args)) {
+		const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+		if (schema.required) {
+			const found = optionTokens.find((token) => {
+				return schema.short && token.name === schema.short || token.rawName && hasLongOptionPrefix(token.rawName) && token.name === arg;
+			});
+			if (!found) {
+				errors.push(createRequireError(arg, schema));
+				continue;
+			}
+		}
+		if (schema.type === "positional") {
+			if (skipPositionalIndex > SKIP_POSITIONAL_DEFAULT) while (positionalsCount <= getPositionalSkipIndex()) positionalsCount++;
+			const positional = positionalTokens[positionalsCount];
+			if (positional != null) values[rawArg] = positional.value;
+			else errors.push(createRequireError(arg, schema));
+			positionalsCount++;
+			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);
+				if (invalid) {
+					errors.push(invalid);
+					continue;
+				}
+				if (schema.type === "boolean") token.value = void 0;
+				const [parsedValue, error] = parse(token, arg, schema);
+				if (error) errors.push(error);
+				else if (schema.multiple) {
+					values[rawArg] ||= [];
+					values[rawArg].push(parsedValue);
+				} else values[rawArg] = parsedValue;
+			}
+		}
+		if (values[rawArg] == null && schema.default != null) values[rawArg] = schema.default;
+	}
+	return {
+		values,
+		positionals: positionalTokens.map((token) => token.value),
+		rest,
+		error: errors.length > 0 ? new AggregateError(errors) : void 0
+	};
+}
+function parse(token, option, schema) {
+	switch (schema.type) {
+		case "string": return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(option, schema)];
+		case "boolean": return token.value ? [token.value || schema.default, void 0] : [!(schema.negatable && token.name.startsWith("no-")), void 0];
+		case "number": {
+			if (!isNumeric(token.value)) return [void 0, createTypeError(option, schema)];
+			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)];
+			return [token.value || schema.default, void 0];
+		}
+		case "custom": {
+			if (typeof schema.parse !== "function") throw new TypeError(`argument '${option}' should have a 'parse' function`);
+			try {
+				return [schema.parse(token.value || String(schema.default || "")), void 0];
+			} catch (error) {
+				return [void 0, error];
+			}
+		}
+		default: throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
+	}
+}
+function createRequireError(option, schema) {
+	const message = schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`;
+	return new ArgResolveError(message, option, "required", schema);
+}
+/**
+* An error that occurs when resolving arguments.
+* This error is thrown when the argument is not valid.
+*/
+var ArgResolveError = class extends Error {
+	name;
+	schema;
+	type;
+	constructor(message, name, type, schema) {
+		super(message);
+		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 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);
+}
+
+//#endregion
+//#region ../gunshi/src/constants.ts
+const ANONYMOUS_COMMAND_NAME = "(anonymous)";
+const NOOP = () => {};
+const COMMAND_OPTIONS_DEFAULT = {
+	name: void 0,
+	description: void 0,
+	version: void 0,
+	cwd: void 0,
+	usageSilent: false,
+	subCommands: void 0,
+	leftMargin: 2,
+	middleMargin: 10,
+	usageOptionType: false,
+	usageOptionValue: true,
+	renderHeader: void 0,
+	renderUsage: void 0,
+	renderValidationErrors: void 0,
+	plugins: void 0
+};
+
+//#endregion
+//#region ../gunshi/src/utils.ts
+function isLazyCommand(cmd) {
+	return typeof cmd === "function" && "commandName" in cmd && !!cmd.commandName;
+}
+async function resolveLazyCommand(cmd, name, needRunResolving = false) {
+	let command;
+	if (isLazyCommand(cmd)) {
+		const baseCommand = {
+			name: cmd.commandName,
+			description: cmd.description,
+			args: cmd.args,
+			examples: cmd.examples
+		};
+		if ("resource" in cmd && cmd.resource) baseCommand.resource = cmd.resource;
+		command = Object.assign(create(), baseCommand);
+		if (needRunResolving) {
+			const loaded = await cmd();
+			if (typeof loaded === "function") command.run = loaded;
+			else if (typeof loaded === "object") {
+				if (loaded.run == null) throw new TypeError(`'run' is required in command: ${cmd.name || name}`);
+				command.run = loaded.run;
+				command.name = loaded.name;
+				command.description = loaded.description;
+				command.args = loaded.args;
+				command.examples = loaded.examples;
+				if ("resource" in loaded && loaded.resource) command.resource = loaded.resource;
+			} else throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
+		}
+	} else command = Object.assign(create(), cmd);
+	if (command.name == null && name) command.name = name;
+	return deepFreeze(command);
+}
+function create(obj = null) {
+	return Object.create(obj);
+}
+function log(...args) {
+	console.log(...args);
+}
+function deepFreeze(obj, ignores = []) {
+	if (obj === null || typeof obj !== "object") return obj;
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (ignores.includes(key)) continue;
+		if (typeof value === "object" && value !== null) deepFreeze(value, ignores);
+	}
+	return Object.freeze(obj);
+}
+
+//#endregion
+//#region ../gunshi/src/context.ts
+/**
+* Create a {@link CommandContext | command context}
+* @param param A {@link CommandContextParams | parameters} to create a {@link CommandContext | command context}
+* @returns A {@link CommandContext | command context}, which is readonly
+*/
+async function createCommandContext({ args, values, positionals, rest, argv, tokens, command, extensions = {}, cliOptions, callMode = "entry", omitted = false, validationError }) {
+	/**
+	* normailize the options schema and values, to avoid prototype pollution
+	*/
+	const _args = Object.entries(args).reduce((acc, [key, value]) => {
+		acc[key] = Object.assign(create(), value);
+		return acc;
+	}, create());
+	/**
+	* setup the environment
+	*/
+	const env = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, cliOptions);
+	/**
+	* create the command context
+	*/
+	const core = Object.assign(create(), {
+		name: getCommandName(command),
+		description: command.description,
+		omitted,
+		callMode,
+		env,
+		args: _args,
+		values,
+		positionals,
+		rest,
+		_: argv,
+		tokens,
+		toKebab: command.toKebab,
+		log: cliOptions.usageSilent ? NOOP : log,
+		validationError
+	});
+	/**
+	* extend the command context with extensions
+	*/
+	if (Object.keys(extensions).length > 0) {
+		const ext = create(null);
+		Object.defineProperty(core, "extensions", {
+			value: ext,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		});
+		for (const [key, extension] of Object.entries(extensions)) {
+			ext[key] = await extension.factory(core, command);
+			if (extension.onFactory) await extension.onFactory(core, command);
+		}
+	}
+	const ctx = deepFreeze(core, ["extensions"]);
+	return ctx;
+}
+function getCommandName(cmd) {
+	if (isLazyCommand(cmd)) return cmd.commandName || cmd.name || ANONYMOUS_COMMAND_NAME;
+	else if (typeof cmd === "object") return cmd.name || ANONYMOUS_COMMAND_NAME;
+	else return ANONYMOUS_COMMAND_NAME;
+}
+
+//#endregion
+//#region ../gunshi/src/decorators.ts
+const EMPTY_RENDERER = async () => "";
+/**
+* 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 ../gunshi/src/plugin/context.ts
+/**
+* Factory function for creating a plugin context.
+* @param decorators - A {@link Decorators} instance.
+* @returns A new {@link PluginContext} instance.
+*/
+function createPluginContext(decorators) {
+	/**
+	* private states
+	*/
+	const globalOptions = new Map();
+	/**
+	* 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);
+		},
+		decorateHeaderRenderer(decorator) {
+			decorators.addHeaderDecorator(decorator);
+		},
+		decorateUsageRenderer(decorator) {
+			decorators.addUsageDecorator(decorator);
+		},
+		decorateValidationErrorsRenderer(decorator) {
+			decorators.addValidationErrorsDecorator(decorator);
+		},
+		decorateCommand(decorator) {
+			decorators.addCommandDecorator(decorator);
+		}
+	});
+}
+
+//#endregion
+//#region ../gunshi/src/plugin/dependency.ts
+/**
+* Resolve plugin dependencies using topological sort
+* @param plugins - Array of plugins to resolve
+* @returns Array of plugins sorted by dependencies
+* @throws Error if circular dependency is detected or required dependency is missing
+*/
+function resolveDependencies(plugins) {
+	const sorted = [];
+	const visited = new Set();
+	const visiting = new Set();
+	const pluginMap = 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 ../gunshi/src/cli/core.ts
+async function cliCore(argv, entry, options, plugins) {
+	const decorators = createDecorators();
+	const pluginContext = createPluginContext(decorators);
+	const resolvedPlugins = await applyPlugins(pluginContext, [...plugins, ...options.plugins || []]);
+	const cliOptions = normalizeCliOptions(options, entry, decorators);
+	const tokens = parseArgs(argv);
+	const subCommand = getSubCommand(tokens);
+	const { commandName: name, command, callMode } = await resolveCommand(subCommand, entry, cliOptions);
+	if (!command) throw new Error(`Command not found: ${name || ""}`);
+	const args = resolveArguments(pluginContext, getCommandArgs(command));
+	const { values, positionals, rest, error } = resolveArgs(args, tokens, {
+		shortGrouping: true,
+		toKebab: command.toKebab,
+		skipPositional: cliOptions.subCommands.size > 0 ? 0 : -1
+	});
+	const omitted = !subCommand;
+	const commandContext = await createCommandContext({
+		args,
+		values,
+		positionals,
+		rest,
+		argv,
+		tokens,
+		omitted,
+		callMode,
+		command,
+		extensions: getPluginExtensions(resolvedPlugins),
+		validationError: error,
+		cliOptions
+	});
+	return await executeCommand(command, commandContext, name || "", 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);
+}
+function normalizeCliOptions(options, entry, decorators) {
+	const subCommands = new Map(options.subCommands);
+	if (options.subCommands) {
+		if (isLazyCommand(entry)) subCommands.set(entry.commandName, entry);
+		else if (typeof entry === "object" && entry.name) subCommands.set(entry.name, entry);
+	}
+	const resolvedOptions = Object.assign(create(), COMMAND_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 getSubCommand(tokens) {
+	const firstToken = tokens[0];
+	return firstToken && firstToken.kind === "positional" && firstToken.index === 0 && firstToken.value ? firstToken.value : "";
+}
+const CANNOT_RESOLVE_COMMAND = { callMode: "unexpected" };
+async function resolveCommand(sub, entry, options) {
+	const omitted = !sub;
+	async function doResolveCommand() {
+		if (typeof entry === "function") if ("commandName" in entry && entry.commandName) return {
+			commandName: entry.commandName,
+			command: entry,
+			callMode: "entry"
+		};
+		else return {
+			command: { run: entry },
+			callMode: "entry"
+		};
+		else if (typeof entry === "object") return {
+			commandName: resolveEntryName(entry),
+			command: entry,
+			callMode: "entry"
+		};
+		else return CANNOT_RESOLVE_COMMAND;
+	}
+	if (omitted || options.subCommands?.size === 0) return doResolveCommand();
+	const cmd = options.subCommands?.get(sub);
+	if (cmd == null) return {
+		commandName: sub,
+		callMode: "unexpected"
+	};
+	if (isLazyCommand(cmd) && cmd.commandName == null) cmd.commandName = sub;
+	else if (typeof cmd === "object" && cmd.name == null) cmd.name = sub;
+	return {
+		commandName: sub,
+		command: cmd,
+		callMode: "subCommand"
+	};
+}
+function resolveEntryName(entry) {
+	return entry.name || ANONYMOUS_COMMAND_NAME;
+}
+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, name, decorators) {
+	const resolved = isLazyCommand(cmd) ? await resolveLazyCommand(cmd, name, true) : cmd;
+	const baseRunner = resolved.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
+//#region ../gunshi/src/cli/bone.ts
+/**
+* Run the command.
+* @param args 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}
+* @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+*/
+async function cli(argv, entry, options = {}) {
+	return cliCore(argv, entry, options, []);
+}
+
+//#endregion
+export { cli };