@breadc/core 1.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,1045 @@
+//#region src/utils/string.ts
+function splitOnce(text, separator) {
+	const found = text.indexOf(separator);
+	if (found === -1) return [text, void 0];
+	return [text.slice(0, found), text.slice(found + separator.length)];
+}
+function camelCase(text) {
+	if (text.indexOf("-") === -1) return text;
+	return text.split("-").map((t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)).join("");
+}
+
+//#endregion
+//#region src/error.ts
+var BreadcError = class extends Error {};
+var RuntimeError = class extends BreadcError {};
+var BreadcAppError = class extends BreadcError {
+	static DUPLICATED_DEFAULT_COMMAND = `Find duplicated default commands`;
+	static DUPLICATED_COMMAND = `Find duplicated commands`;
+	static NO_ACTION_BOUND = `There is no action function bound in this command`;
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+	}
+};
+var ResolveGroupError = class extends BreadcError {
+	static EMPTY = "Group spec should not be empty";
+	static INVALID_ARG_IN_GROUP = "Resolving argument in group spec";
+	cause;
+	constructor(message, cause) {
+		super(`${message} at the command "${cause.spec}", position ${cause.position}`);
+		this.cause = cause;
+	}
+};
+var ResolveCommandError = class extends BreadcError {
+	static INVALID_ARG = "Resolving invalid argument";
+	static INVALID_EMPTY_ARG = "Resolving invalid empty argument";
+	static INVALID_REQUIRED_ARG = "Resolving invalid required argument";
+	static INVALID_OPTIONAL_ARG = "Resolving invalid optional argument";
+	static INVALID_SPREAD_ARG = "Resolving invalid spread argument";
+	static INVALID_ALIAS_FORMAT = "Alias command format should not have arguments";
+	static PIECE_BEFORE_REQUIRED = "Sub-command should be placed in the beginning";
+	static REQUIRED_BEFORE_OPTIONAL = "Required argument should be placed before optional arguments";
+	static OPTIONAL_BEFORE_SPREAD = "Optional argument should be placed before spread arguments";
+	static SPREAD_ONLY_ONCE = "Spread argument can only appear once";
+	cause;
+	constructor(message, cause) {
+		super(`${message} at the command "${cause.spec}", position ${cause.position}`);
+		this.cause = cause;
+	}
+};
+var ResolveOptionError = class extends BreadcError {
+	static INVALID_OPTION = "Resolving invalid option";
+	cause;
+	constructor(message, cause) {
+		super(`${message} at the option "${cause.spec}"`);
+		this.cause = cause;
+	}
+};
+
+//#endregion
+//#region src/breadc/option.ts
+function option(spec, description, init) {
+	return {
+		spec,
+		init: {
+			description,
+			...init
+		},
+		type: void 0,
+		long: ""
+	};
+}
+function rawOption(type, long, short, init) {
+	return {
+		spec: "",
+		init,
+		type,
+		long,
+		short
+	};
+}
+
+//#endregion
+//#region src/breadc/command.ts
+function command(spec, init) {
+	const run = (() => {});
+	const aliases = [];
+	const args = [];
+	const options = [];
+	run.spec = spec;
+	run.init = init;
+	run._aliases = aliases;
+	run._options = options;
+	run._arguments = args;
+	run.alias = (spec) => {
+		aliases.push(spec);
+		return run;
+	};
+	run.argument = (spec, init) => {
+		const arg = typeof spec === "string" ? argument(spec, init) : spec;
+		args.push(arg);
+		return run;
+	};
+	run.option = (spec, description, init) => {
+		const option$5 = typeof spec === "string" ? option(spec, description, init) : spec;
+		options.push(option$5);
+		return run;
+	};
+	run.use = (middleware) => {
+		if (!run._actionMiddlewares) run._actionMiddlewares = [];
+		run._actionMiddlewares.push(middleware);
+		return run;
+	};
+	run.allowUnknownOption = (middleware) => {
+		if (!run._unknownOptionMiddlewares) run._unknownOptionMiddlewares = [];
+		if (typeof middleware === "function") run._unknownOptionMiddlewares.push(middleware);
+		else run._unknownOptionMiddlewares.push((_ctx, key, value) => ({
+			name: key,
+			value
+		}));
+		return run;
+	};
+	run.action = (fn) => {
+		run._actionFn = fn;
+		return run;
+	};
+	return run;
+}
+function rawArgument(type, name) {
+	return {
+		spec: "",
+		type,
+		name,
+		init: {}
+	};
+}
+function argument(spec, init) {
+	let type;
+	let name;
+	if ("<" === spec[0] && ">" === spec[spec.length - 1]) {
+		type = "required";
+		name = spec.slice(1, spec.length - 1);
+	} else if ("[" === spec[0] && "]" === spec[spec.length - 1]) if (spec[1] === "." && spec[2] === ".") {
+		type = "spread";
+		for (let i = 1; i < spec.length; i++) if (spec[i] !== ".") {
+			name = spec.slice(i, spec.length - 1);
+			break;
+		}
+	} else {
+		type = "optional";
+		name = spec.slice(1, spec.length - 1);
+	}
+	else throw new ResolveCommandError(ResolveCommandError.INVALID_ARG, {
+		spec,
+		position: -1
+	});
+	return {
+		spec,
+		type,
+		name,
+		init
+	};
+}
+
+//#endregion
+//#region src/runtime/matched.ts
+var MatchedArgument = class {
+	argument;
+	token;
+	dirty = false;
+	raw;
+	constructor(argument) {
+		this.argument = argument;
+		if (argument.init?.initial !== void 0) this.raw = argument.init.initial;
+		else switch (argument.type) {
+			case "required":
+			case "optional":
+				this.raw = void 0;
+				break;
+			case "spread":
+				this.raw = [];
+				break;
+		}
+	}
+	value() {
+		if (this.dirty || this.argument.init?.default === void 0) {
+			const cast = this.argument.init?.cast;
+			return cast ? cast(this.raw) : this.raw;
+		} else return this.argument.init.default;
+	}
+	accept(_context, value) {
+		switch (this.argument.type) {
+			case "optional":
+				if (this.dirty) throw new RuntimeError();
+				this.raw = value ?? this.argument.init?.initial ?? void 0;
+				this.dirty = true;
+				return this;
+			case "required":
+				if (this.dirty) throw new RuntimeError();
+				this.raw = value ?? this.argument.init?.initial ?? "";
+				this.dirty = true;
+				return this;
+			case "spread":
+				this.raw.push(value ?? this.argument.init?.initial ?? "");
+				this.dirty = true;
+				return this;
+			default:
+ // c8 ignore
+			return this;
+		}
+	}
+};
+const FALSE_OPTION = [
+	"false",
+	"f",
+	"no",
+	"n",
+	"off"
+];
+var MatchedOption = class {
+	option;
+	dirty = false;
+	raw;
+	constructor(option) {
+		this.option = option;
+		if (option.init.initial !== void 0) this.raw = option.init.initial;
+		else switch (option.type) {
+			case "boolean":
+			case "optional":
+				this.raw = false;
+				break;
+			case "required":
+				this.raw = void 0;
+				break;
+			case "spread":
+				this.raw = [];
+				break;
+		}
+	}
+	value() {
+		if (this.dirty || this.option.init.default === void 0) {
+			const cast = this.option.init.cast;
+			return cast ? cast(this.raw) : this.raw;
+		} else return this.option.init.default;
+	}
+	accept(context, long, text) {
+		switch (this.option.type) {
+			case "boolean":
+				if (this.dirty) throw new RuntimeError();
+				if (text !== void 0) {
+					const value = text.toLowerCase();
+					if (!long.startsWith("no-")) this.raw = FALSE_OPTION.includes(value) ? false : true;
+					else this.raw = FALSE_OPTION.includes(value) ? true : false;
+				} else if (!long.startsWith("no-")) this.raw = true;
+				else this.raw = false;
+				this.dirty = true;
+				break;
+			case "optional": {
+				if (this.dirty) throw new RuntimeError();
+				let value = text;
+				if (value === void 0) {
+					const token = context.tokens.peek();
+					if (token && !token.isEscape && !token.isLong && (!token.isShort || token.isNegativeNumber)) {
+						value = token.toRaw();
+						context.tokens.next();
+					}
+				}
+				if (value !== void 0) this.raw = value;
+				else this.raw = this.option.init.initial ?? true;
+				this.dirty = true;
+				break;
+			}
+			case "required":
+			case "spread": {
+				let value = text;
+				if (value === void 0) {
+					const token = context.tokens.peek();
+					if (token && !token.isEscape) {
+						value = token.toRaw();
+						context.tokens.next();
+					}
+				}
+				if (this.option.type === "required") {
+					if (this.dirty) throw new Error("");
+					this.raw = value ?? this.option.init.initial;
+				} else this.raw.push(value ?? "");
+				this.dirty = true;
+				break;
+			}
+		}
+		return this;
+	}
+};
+
+//#endregion
+//#region src/runtime/lexer.ts
+var TokenStream = class {
+	args;
+	tokens = [];
+	cursor = 0;
+	constructor(args) {
+		this.args = args;
+	}
+	reset() {
+		this.cursor = 0;
+		return this;
+	}
+	/**
+	* Get the current arg token and advance the cursor
+	*
+	* @returns next arg
+	*/
+	next() {
+		const arg = this.args[this.cursor];
+		if (arg === void 0) return void 0;
+		const token = this.tokens[this.cursor] ?? (this.tokens[this.cursor] = new Token(arg));
+		this.cursor++;
+		return token;
+	}
+	/**
+	* Move the cursor to preivous position
+	*/
+	prev() {
+		this.cursor--;
+	}
+	/**
+	* Peek the next arg and does not advance the cursor
+	*
+	* @returns next arg
+	*/
+	peek() {
+		const arg = this.args[this.cursor];
+		if (arg === void 0) return void 0;
+		const token = this.tokens[this.cursor];
+		if (token !== void 0) return token;
+		return this.tokens[this.cursor] = new Token(arg);
+	}
+	/**
+	* Return all remaining raw arguments, advancing the cursor to the end
+	*
+	* @returns all remaining raw arguments
+	*/
+	remaining() {
+		const remaining = this.args.slice(this.cursor).map((t) => new Token(t));
+		this.cursor = this.args.length;
+		return remaining;
+	}
+	/**
+	* Return whether has consumed all the args
+	*
+	* @returns whether has consumed all the args
+	*/
+	get isEnd() {
+		return this.args[this.cursor] === void 0;
+	}
+	*[Symbol.iterator]() {
+		for (; this.cursor < this.args.length; this.cursor++) yield new Token(this.args[this.cursor]);
+	}
+};
+var Token = class {
+	text;
+	constructor(arg) {
+		this.text = arg;
+	}
+	/**
+	* @returns raw arg string
+	*/
+	toRaw() {
+		return this.text;
+	}
+	/**
+	* @returns whether arg is empty
+	*/
+	get isEmpty() {
+		return this.text.length === 0;
+	}
+	/**
+	* @returns whether arg looks like a stdio argument (`-`)
+	*/
+	get isStdio() {
+		return this.text === "-";
+	}
+	/**
+	* @returns whether arg looks like an argument escape (`--`)
+	*/
+	get isEscape() {
+		return this.text === "--";
+	}
+	/**
+	* @returns whether arg looks like a negative number (`-123`)
+	*/
+	get isNegativeNumber() {
+		return this.text.startsWith("-") && !Number.isNaN(Number.parseFloat(this.text));
+	}
+	/**
+	* @returns whether arg looks like a number (`123`, `-123`)
+	*/
+	get isNumber() {
+		return !Number.isNaN(Number.parseFloat(this.text));
+	}
+	/**
+	* @returns whether arg can treat as a long-flag
+	*/
+	get isLong() {
+		return this.text[0] === "-" && this.text[1] === "-" && this.text.length > 2;
+	}
+	/**
+	* Treat as a long-flag, un-checked version
+	*
+	* @returns a long flag and its argument
+	*/
+	toLong() {
+		const result = splitOnce(this.text, "=");
+		return [result[0].slice(2), result[1]];
+	}
+	/**
+	* Treat as a long-flag, checked version
+	*
+	* @returns a long flag and its argument
+	*/
+	checkToLong() {
+		if (this.text[0] !== "-") return void 0;
+		if (this.text[1] !== "-") return void 0;
+		if (this.text.length <= 2) return void 0;
+		const result = splitOnce(this.text, "=");
+		return [result[0].slice(2), result[1]];
+	}
+	/**
+	* @returns whether arg can treat as a long-flag
+	*/
+	get isShort() {
+		return this.text[0] === "-" && this.text[1] !== "-" && this.text.length > 1;
+	}
+	/**
+	* Treat as a short-flag, un-checked version
+	*
+	* @returns a short flag and its argument
+	*/
+	toShort() {
+		const result = splitOnce(this.text, "=");
+		return [result[0].slice(1), result[1]];
+	}
+	/**
+	* Treat as a short-flag, checked version
+	*
+	* @returns a short flag and its argument
+	*/
+	checkToShort() {
+		if (this.text[0] !== "-") return void 0;
+		if (this.text.length <= 1) return void 0;
+		if (this.text[1] === "-") return void 0;
+		const result = splitOnce(this.text, "=");
+		return [result[0].slice(1), result[1]];
+	}
+	get length() {
+		return this.text.length;
+	}
+	toString() {
+		return this.text;
+	}
+	[Symbol.iterator]() {
+		return this.text[Symbol.iterator]();
+	}
+};
+
+//#endregion
+//#region src/runtime/context.ts
+function context(breadc, args) {
+	return {
+		data: {},
+		output: void 0,
+		group: void 0,
+		command: void 0,
+		pieces: [],
+		options: /* @__PURE__ */ new Map(),
+		arguments: [],
+		remaining: [],
+		breadc,
+		tokens: new TokenStream(args)
+	};
+}
+function reset(context) {
+	context.data = {};
+	context.group = void 0;
+	context.command = void 0;
+	context.pieces.length = 0;
+	context.options.clear();
+	context.arguments.length = 0;
+	context.remaining.length = 0;
+	context.tokens.reset();
+	return context;
+}
+
+//#endregion
+//#region src/runtime/builder.ts
+function isGroup(command) {
+	return !!command._commands;
+}
+function resolveGroup(group) {
+	if (group._pieces) return;
+	const { spec } = group;
+	const pieces = [];
+	for (let i = 0; i < spec.length;) if (spec[i] === "<" || spec[i] === "[") throw new ResolveGroupError(ResolveGroupError.INVALID_ARG_IN_GROUP, {
+		spec,
+		position: i
+	});
+	else if (spec[i] === " ") while (i < spec.length && spec[i] === " ") i++;
+	else {
+		let j = i;
+		while (j < spec.length && spec[j] !== " ") j++;
+		pieces.push(spec.slice(i, j));
+		i = j;
+	}
+	group._pieces = [pieces];
+}
+function resolveCommand(command) {
+	if (command._pieces) return;
+	const { spec, _aliases: aliases } = command;
+	let i = 0;
+	const parent = command._group?._pieces[0] ?? [];
+	const pieces = [...parent];
+	for (; i < spec.length;) if (spec[i] === "<" || spec[i] === "[") break;
+	else if (spec[i] === " ") while (i < spec.length && spec[i] === " ") i++;
+	else {
+		let j = i;
+		while (j < spec.length && spec[j] !== " ") j++;
+		pieces.push(spec.slice(i, j));
+		i = j;
+	}
+	/**
+	* States:
+	*
+	* 0 := aaa bbb  (0 -> 0, 0 -> 1, 0 -> 2, 0 -> 3)
+	* 1 := aaa bbb <xxx> <yyy>  (1 -> 1, 1 -> 2, 1 -> 3)
+	* 2 := aaa bbb <xxx> <yyy> [zzz]  (2 -> 2, 2 -> 3)
+	* 3 := aaa bbb <xxx> <yyy> [zzz] [...www]  (3 -> empty)
+	*/
+	let state = 1;
+	const resolvedArguments = [];
+	let spread;
+	for (; i < spec.length;) if (spec[i] === "<") {
+		if (i + 1 >= spec.length || spec[i + 1] === " ") throw new ResolveCommandError(ResolveCommandError.INVALID_REQUIRED_ARG, {
+			spec,
+			position: i
+		});
+		else i++;
+		if (state >= 2) throw new ResolveCommandError(ResolveCommandError.REQUIRED_BEFORE_OPTIONAL, {
+			spec,
+			position: i
+		});
+		let piece = "";
+		while (i < spec.length && spec[i] !== ">") piece += spec[i++];
+		if (i === spec.length || spec[i] !== ">") throw new ResolveCommandError(ResolveCommandError.INVALID_REQUIRED_ARG, {
+			spec,
+			position: i
+		});
+		else i++;
+		if (i < spec.length && spec[i] !== " ") throw new ResolveCommandError(ResolveCommandError.INVALID_REQUIRED_ARG, {
+			spec,
+			position: i
+		});
+		if (piece === "") throw new ResolveCommandError(ResolveCommandError.INVALID_EMPTY_ARG, {
+			spec,
+			position: i
+		});
+		state = 1;
+		resolvedArguments.push(rawArgument("required", piece));
+	} else if (spec[i] === "[") {
+		if (i + 1 >= spec.length || spec[i + 1] === " ") throw new ResolveCommandError(ResolveCommandError.INVALID_OPTIONAL_ARG, {
+			spec,
+			position: i
+		});
+		else i++;
+		if (spec[i] === ".") {
+			if (state >= 3) throw new ResolveCommandError(ResolveCommandError.SPREAD_ONLY_ONCE, {
+				spec,
+				position: i
+			});
+			while (i < spec.length && spec[i] === ".") i++;
+			let piece = "";
+			while (i < spec.length && spec[i] !== "]") piece += spec[i++];
+			if (i === spec.length || spec[i] !== "]") throw new ResolveCommandError(ResolveCommandError.INVALID_SPREAD_ARG, {
+				spec,
+				position: i
+			});
+			else i++;
+			if (i < spec.length && spec[i] !== " ") throw new ResolveCommandError(ResolveCommandError.INVALID_SPREAD_ARG, {
+				spec,
+				position: i
+			});
+			if (piece === "") throw new ResolveCommandError(ResolveCommandError.INVALID_EMPTY_ARG, {
+				spec,
+				position: i
+			});
+			state = 3;
+			spread = rawArgument("spread", piece);
+			resolvedArguments.push(spread);
+		} else {
+			if (state >= 3) throw new ResolveCommandError(ResolveCommandError.OPTIONAL_BEFORE_SPREAD, {
+				spec,
+				position: i
+			});
+			let piece = "";
+			while (i < spec.length && spec[i] !== "]") piece += spec[i++];
+			if (i === spec.length || spec[i] !== "]") throw new ResolveCommandError(ResolveCommandError.INVALID_OPTIONAL_ARG, {
+				spec,
+				position: i
+			});
+			else i++;
+			if (i < spec.length && spec[i] !== " ") throw new ResolveCommandError(ResolveCommandError.INVALID_OPTIONAL_ARG, {
+				spec,
+				position: i
+			});
+			if (piece === "") throw new ResolveCommandError(ResolveCommandError.INVALID_EMPTY_ARG, {
+				spec,
+				position: i
+			});
+			state = 2;
+			resolvedArguments.push(rawArgument("optional", piece));
+		}
+	} else if (spec[i] === " ") while (i < spec.length && spec[i] === " ") i++;
+	else throw new ResolveCommandError(ResolveCommandError.PIECE_BEFORE_REQUIRED, {
+		spec,
+		position: i
+	});
+	if (pieces.length === 0) command._default = true;
+	for (const argument of command._arguments) switch (argument.type) {
+		case "required":
+			if (state === 1) resolvedArguments.push(argument);
+			else throw new ResolveCommandError(ResolveCommandError.REQUIRED_BEFORE_OPTIONAL, {
+				spec,
+				position: i
+			});
+			break;
+		case "optional":
+			if (state <= 2) {
+				state = 2;
+				resolvedArguments.push(argument);
+			} else throw new ResolveCommandError(ResolveCommandError.OPTIONAL_BEFORE_SPREAD, {
+				spec,
+				position: i
+			});
+			break;
+		case "spread":
+			if (spread) throw new ResolveCommandError(ResolveCommandError.SPREAD_ONLY_ONCE, {
+				spec,
+				position: i
+			});
+			state = 3;
+			spread = argument;
+			resolvedArguments.push(argument);
+			break;
+	}
+	command._arguments = resolvedArguments;
+	if (aliases.length > 0) {
+		const resolvedAliases = [pieces];
+		for (const spec of aliases) {
+			const aliasPieces = [...parent];
+			for (let i = 0; i < spec.length;) if (spec[i] === "<" || spec[i] === "[") throw new ResolveCommandError(ResolveCommandError.INVALID_ALIAS_FORMAT, {
+				spec,
+				position: i
+			});
+			else if (spec[i] === " ") while (i < spec.length && spec[i] === " ") i++;
+			else {
+				let j = i;
+				while (j < spec.length && spec[j] !== " ") j++;
+				aliasPieces.push(spec.slice(i, j));
+				i = j;
+			}
+			if (aliasPieces.length === 0) command._default = true;
+			resolvedAliases.push(aliasPieces);
+		}
+		command._pieces = resolvedAliases;
+	} else command._pieces = [pieces];
+	return command;
+}
+const OptionRE = /^(?:-([a-zA-Z]), )?--(no-)?([a-zA-Z0-9\-]+)(?: (<[a-zA-Z0-9\-]+>|\[\.*[a-zA-Z0-9\-]+\]))?$/;
+function resolveOption(option) {
+	if (option.type) return option;
+	const { spec } = option;
+	const match = OptionRE.exec(spec);
+	if (match) {
+		option.long = match[3];
+		if (match[1]) option.short = match[1];
+		if (match[4]) {
+			const arg = match[4];
+			option.argument = arg;
+			if (arg[0] === "<") option.type = "required";
+			else if (arg[1] === ".") option.type = "spread";
+			else option.type = "optional";
+			if (match[2]) throw new ResolveOptionError(ResolveOptionError.INVALID_OPTION, { spec });
+		} else {
+			option.type = "boolean";
+			if (match[2] && option.init.negated === void 0 && option.init.initial === void 0 && option.init.default === void 0) {
+				option.init.negated = true;
+				option.init.initial = true;
+			}
+		}
+		return option;
+	} else throw new ResolveOptionError(ResolveOptionError.INVALID_OPTION, { spec });
+}
+function buildApp(instance) {
+	for (const option of instance._options) resolveOption(option);
+	for (const command of instance._commands) {
+		if (isGroup(command)) resolveGroup(command);
+		else resolveCommand(command);
+		if (command._default) for (const option of instance._options) resolveOption(option);
+	}
+}
+function buildCommand(command) {
+	for (const option of command._options) resolveOption(option);
+}
+function buildGroup(group) {
+	for (const option of group._options) resolveOption(option);
+	for (const command of group._commands) resolveCommand(command);
+}
+
+//#endregion
+//#region src/runtime/parser.ts
+function parse(app, argv) {
+	const context$1 = context(app, argv);
+	buildApp(context$1.breadc);
+	const defaultCommands = context$1.breadc._commands.filter((c) => c._default);
+	if (defaultCommands.length >= 2) throw new BreadcAppError(BreadcAppError.DUPLICATED_DEFAULT_COMMAND, { commands: defaultCommands });
+	const defaultCommand = defaultCommands[0];
+	doParse(context$1, defaultCommand !== void 0 && context$1.breadc._commands.length === 1 ? defaultCommand : void 0);
+	if (context$1.command) {} else if (defaultCommand) {
+		reset(context$1);
+		doParse(context$1, defaultCommand);
+	}
+	return context$1;
+}
+function resolveArgs(context) {
+	return context.arguments.map((arg) => arg.value());
+}
+function resolveOptions(context) {
+	return Object.fromEntries([...context.options.values()].map((opt) => [camelCase(opt.option.long), opt.value()]));
+}
+function doParse(context, defaultCommand) {
+	const { breadc, tokens, options: matchedOptions } = context;
+	let index = 0;
+	let matchedGroup = void 0;
+	let matchedCommand = defaultCommand;
+	const pendingCommands = /* @__PURE__ */ new Map();
+	const pendingLongOptions = /* @__PURE__ */ new Map();
+	const pendingNegateOptions = /* @__PURE__ */ new Map();
+	const pendingShortOptions = /* @__PURE__ */ new Map();
+	const args = [];
+	const unknown = [];
+	const addPendingOptions = (options) => {
+		for (const option of options) {
+			pendingLongOptions.set(option.long, option);
+			if (option.type === "boolean") pendingNegateOptions.set("no-" + option.long, option);
+			if (option.short) pendingShortOptions.set(option.short, option);
+			matchedOptions.set(option.long, new MatchedOption(option));
+		}
+	};
+	const addPendingCommand = (command, alias) => {
+		const piece = command._pieces[alias][index];
+		if (!pendingCommands.has(piece)) pendingCommands.set(piece, []);
+		pendingCommands.get(piece).push([command, alias]);
+	};
+	addPendingOptions(breadc._options);
+	if (breadc._init.builtin?.version !== false) {
+		const spec = typeof breadc._init.builtin?.version === "object" ? breadc._init.builtin.version.spec : void 0;
+		const option$3 = spec ? resolveOption(option(spec)) : rawOption("boolean", "version", "v", { description: "" });
+		breadc._version = option$3;
+		pendingLongOptions.set(option$3.long, option$3);
+		if (option$3.short) pendingShortOptions.set(option$3.short, option$3);
+	}
+	if (breadc._init.builtin?.help !== false) {
+		const spec = typeof breadc._init.builtin?.help === "object" ? breadc._init.builtin.help.spec : void 0;
+		const option$4 = spec ? resolveOption(option(spec)) : rawOption("boolean", "help", "h", { description: "" });
+		breadc._help = option$4;
+		pendingLongOptions.set(option$4.long, option$4);
+		if (option$4.short) pendingShortOptions.set(option$4.short, option$4);
+	}
+	if (defaultCommand) {
+		matchedCommand = defaultCommand;
+		for (const command of breadc._commands) if (command._default) {
+			buildCommand(command);
+			addPendingOptions(command._options);
+		}
+	} else for (const command of breadc._commands) if (!command._default) for (let alias = 0; alias < command._pieces.length; alias++) addPendingCommand(command, alias);
+	while (!tokens.isEnd) {
+		const token = tokens.next();
+		const rawToken = token.toRaw();
+		if (token.isEscape) context.remaining.push(...tokens.remaining().map((t) => t.toRaw()));
+		else if (!matchedCommand && pendingCommands.has(rawToken)) {
+			index += 1;
+			context.pieces.push(rawToken);
+			const nextCommands = pendingCommands.get(rawToken);
+			pendingCommands.clear();
+			for (const [command, alias] of nextCommands) {
+				const pieces = command._pieces[alias];
+				if (index === pieces.length) if (isGroup(command)) {
+					const group = command;
+					if (!matchedGroup || matchedGroup === group) matchedGroup = group;
+					else throw new RuntimeError();
+					buildGroup(group);
+					addPendingOptions(group._options);
+					for (const command of group._commands) for (let alias = 0; alias < command._pieces.length; alias++) addPendingCommand(command, alias);
+				} else {
+					if (!matchedCommand || matchedCommand === command) matchedCommand = command;
+					else throw new RuntimeError();
+					buildCommand(command);
+					addPendingOptions(command._options);
+				}
+				else addPendingCommand(command, alias);
+			}
+		} else if (token.isLong || token.isShort && !token.isNegativeNumber) {
+			const isLong = token.isLong;
+			const [key, value] = isLong ? token.toLong() : token.toShort();
+			const option = isLong ? pendingLongOptions.get(key) || pendingNegateOptions.get(key) : pendingShortOptions.get(key);
+			if (option) {
+				if (!matchedOptions.has(option.long) || matchedOptions.get(option.long)?.option !== option) matchedOptions.set(option.long, new MatchedOption(option));
+				matchedOptions.get(option.long).accept(context, key, value);
+			} else {
+				const unknownOptionMiddlewares = [
+					...breadc._unknownOptionMiddlewares,
+					...matchedGroup?._unknownOptionMiddlewares ?? [],
+					...matchedCommand?._unknownOptionMiddlewares ?? []
+				];
+				for (const middleware of unknownOptionMiddlewares) {
+					const result = middleware(context, key, value);
+					if (result) {
+						const matched = new MatchedOption(rawOption(result.type ?? "optional", key, void 0, {})).accept(context, key, value);
+						matchedOptions.set(key, matched);
+						break;
+					}
+				}
+			}
+		} else if (matchedCommand) args.push(rawToken);
+		else unknown.push(rawToken);
+	}
+	context.group = matchedGroup;
+	context.command = matchedCommand;
+	if (matchedCommand) {
+		let i = 0;
+		for (; i < matchedCommand._arguments.length; i++) {
+			const argument = matchedCommand._arguments[i];
+			const matchedArgument = new MatchedArgument(argument);
+			const value = args[i];
+			if (argument.type === "required") {
+				if (value === void 0) throw new RuntimeError();
+				matchedArgument.accept(context, value);
+				context.arguments.push(matchedArgument);
+			} else if (argument.type === "optional") {
+				matchedArgument.accept(context, value);
+				context.arguments.push(matchedArgument);
+			} else {
+				for (; i < args.length; i++) matchedArgument.accept(context, args[i]);
+				context.arguments.push(matchedArgument);
+			}
+		}
+		if (i < args.length) context.remaining.unshift(...args.slice(i));
+	} else context.arguments.push(...unknown.map((arg, idx) => new MatchedArgument(rawArgument("required", `arg_${idx}`)).accept(context, arg)));
+	return matchedCommand;
+}
+
+//#endregion
+//#region src/breadc/builtin/help.ts
+function printHelp(context) {
+	const { breadc } = context;
+	const text = `${breadc.name}/${breadc._init.version ?? "unknown"}`;
+	console.log(text);
+	return text;
+}
+
+//#endregion
+//#region src/breadc/builtin/version.ts
+function printVersion(context) {
+	const { breadc } = context;
+	const text = `${breadc.name}/${breadc._init.version ?? "unknown"}`;
+	console.log(text);
+	return text;
+}
+
+//#endregion
+//#region src/runtime/run.ts
+async function run(app, argv) {
+	const context = parse(app, argv);
+	if (!context.command) {
+		const { breadc } = context;
+		const version = breadc._version;
+		if (version && context.options.get(version.long)?.value()) return printVersion(context);
+		const help = breadc._help;
+		if (help && context.options.get(help.long)?.value()) return printHelp(context);
+		if (breadc._unknownCommandMiddlewares.length > 0) {
+			let res;
+			for (const middleware of breadc._unknownCommandMiddlewares) res = await middleware(context);
+			return res;
+		} else return printHelp(context);
+	}
+	const actionMiddlewares = [
+		...context.breadc._actionMiddlewares,
+		...context.group?._actionMiddlewares ?? [],
+		...context.command?._actionMiddlewares ?? []
+	];
+	const args = resolveArgs(context);
+	const options = resolveOptions(context);
+	options["--"] = context.remaining;
+	if (context.command._actionFn) {
+		const actionFn = context.command._actionFn;
+		if (actionMiddlewares.length === 0) return await actionFn(...args, options);
+		else {
+			const invoked = [];
+			const makeNextFn = (index) => {
+				return (async (nextContext) => {
+					if (nextContext?.data) context.data = {
+						...context.data,
+						...nextContext?.data
+					};
+					invoked[index] = true;
+					if (index === actionMiddlewares.length) context.output = await actionFn(...args, options);
+					else {
+						const next = makeNextFn(index + 1);
+						await actionMiddlewares[index](context, next);
+						if (!invoked[index + 1]) await next();
+					}
+					return context;
+				});
+			};
+			await makeNextFn(0)(void 0);
+			return context.output;
+		}
+	} else throw new RuntimeError("");
+}
+
+//#endregion
+//#region src/breadc/group.ts
+function group(spec, init) {
+	if (!spec) throw new ResolveGroupError(ResolveGroupError.EMPTY, {
+		spec,
+		position: 0
+	});
+	const commands = [];
+	const options = [];
+	const actionMiddlewares = [];
+	const unknownOptionMiddlewares = [];
+	const group = {
+		spec,
+		init,
+		_pieces: void 0,
+		_commands: commands,
+		_options: options,
+		_actionMiddlewares: actionMiddlewares,
+		_unknownOptionMiddlewares: unknownOptionMiddlewares,
+		option(spec, description, init) {
+			const option$2 = typeof spec === "string" ? option(spec, description, init) : spec;
+			options.push(option$2);
+			return group;
+		},
+		command(spec, init) {
+			const command$2 = typeof spec === "string" ? command(spec, init) : spec;
+			command$2._group = group;
+			commands.push(command$2);
+			return command$2;
+		},
+		use(middleware) {
+			actionMiddlewares.push(middleware);
+			return group;
+		},
+		allowUnknownOption(middleware) {
+			if (typeof middleware === "function") unknownOptionMiddlewares.push(middleware);
+			else unknownOptionMiddlewares.push((_ctx, key, value) => ({
+				name: key,
+				value
+			}));
+			return group;
+		}
+	};
+	return group;
+}
+
+//#endregion
+//#region src/breadc/app.ts
+function breadc(name, init = {}) {
+	const commands = [];
+	const options = [];
+	const actionMiddlewares = [];
+	const unknownCommandMiddlewares = [];
+	const unknownOptionMiddlewares = [];
+	const app = {
+		name,
+		version: init.version,
+		_init: init,
+		_commands: commands,
+		_options: options,
+		_actionMiddlewares: actionMiddlewares,
+		_unknownOptionMiddlewares: unknownOptionMiddlewares,
+		_unknownCommandMiddlewares: unknownCommandMiddlewares,
+		option(spec, description, init) {
+			const option$1 = typeof spec === "string" ? option(spec, description, init) : spec;
+			options.push(option$1);
+			return app;
+		},
+		group(spec, init) {
+			const group$1 = typeof spec === "string" ? group(spec, init) : spec;
+			commands.push(group$1);
+			return group$1;
+		},
+		command(spec, description, init) {
+			const command$1 = typeof spec === "string" ? command(spec, description || init ? {
+				description,
+				...init
+			} : void 0) : spec;
+			commands.push(command$1);
+			return command$1;
+		},
+		use(middleware) {
+			actionMiddlewares.push(middleware);
+			return app;
+		},
+		onUnknownCommand(middleware) {
+			unknownCommandMiddlewares.push(middleware);
+			return app;
+		},
+		allowUnknownOption(middleware) {
+			if (typeof middleware === "function") unknownOptionMiddlewares.push(middleware);
+			else unknownOptionMiddlewares.push((_ctx, key, value) => ({
+				name: key,
+				value
+			}));
+			return app;
+		},
+		parse(argv) {
+			const context = parse(app, argv);
+			return {
+				args: resolveArgs(context),
+				options: resolveOptions(context),
+				"--": context.remaining,
+				context
+			};
+		},
+		async run(argv) {
+			return run(app, argv);
+		}
+	};
+	return app;
+}
+
+//#endregion
+export { BreadcAppError, BreadcError, MatchedArgument, MatchedOption, ResolveCommandError, ResolveGroupError, ResolveOptionError, argument, breadc, command, group, option };