@optique/core 0.2.0-dev.32 → 0.3.0-dev.34

package/dist/index.cjs

@@ -9,6 +9,7 @@ exports.RunError = require_facade.RunError;
 exports.argument = require_parser.argument;
 exports.choice = require_valueparser.choice;
 exports.command = require_parser.command;
+exports.concat = require_parser.concat;
 exports.constant = require_parser.constant;
 exports.float = require_valueparser.float;
 exports.formatDocPage = require_doc.formatDocPage;

package/dist/index.d.cts

@@ -2,6 +2,6 @@ import { Message, MessageFormatOptions, MessageTerm, formatMessage, message, met
 import { OptionName, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, formatUsage, formatUsageTerm, normalizeUsage } from "./usage.cjs";
 import { DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, formatDocPage } from "./doc.cjs";
 import { ChoiceOptions, FloatOptions, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.cjs";
-import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.cjs";
+import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.cjs";
 import { RunError, RunOptions, run } from "./facade.cjs";
-export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/index.d.ts

@@ -2,6 +2,6 @@ import { Message, MessageFormatOptions, MessageTerm, formatMessage, message, met
 import { OptionName, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, formatUsage, formatUsageTerm, normalizeUsage } from "./usage.js";
 import { DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, formatDocPage } from "./doc.js";
 import { ChoiceOptions, FloatOptions, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.js";
-import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
+import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
 import { RunError, RunOptions, run } from "./facade.js";
-export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/index.js

@@ -2,7 +2,7 @@ import { formatMessage, message, metavar, optionName, optionNames, text, value,
 import { formatUsage, formatUsageTerm, normalizeUsage } from "./usage.js";
 import { formatDocPage } from "./doc.js";
 import { choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.js";
-import { argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
+import { argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
 import { RunError, run } from "./facade.js";
 
-export { RunError, argument, choice, command, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { RunError, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/parser.cjs

@@ -897,6 +897,109 @@ function merge(...parsers) {
 		}
 	};
 }
+function concat(...parsers) {
+	const initialState = parsers.map((parser) => parser.initialState);
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
+		usage: parsers.flatMap((p) => p.usage),
+		initialState,
+		parse(context) {
+			let currentContext = context;
+			const allConsumed = [];
+			const matchedParsers = /* @__PURE__ */ new Set();
+			while (matchedParsers.size < parsers.length) {
+				let foundMatch = false;
+				let error = {
+					consumed: 0,
+					error: require_message.message`No remaining parsers could match the input.`
+				};
+				const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+				for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						allConsumed.push(...result.consumed);
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+				if (!foundMatch) for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length < 1) {
+						currentContext = {
+							...currentContext,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && result.consumed < 1) {
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					}
+				}
+				if (!foundMatch) return {
+					...error,
+					success: false
+				};
+			}
+			return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+		},
+		complete(state) {
+			const results = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = state[i];
+				const result = parser.complete(parserState);
+				if (!result.success) return result;
+				if (Array.isArray(result.value)) results.push(...result.value);
+				else results.push(result.value);
+			}
+			return {
+				success: true,
+				value: results
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			const fragments = parsers.flatMap((p, index) => p.getDocFragments(state[index], void 0).fragments);
+			const entries = fragments.filter((f) => f.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const result = [...sections.map((s) => ({
+				...s,
+				type: "section"
+			}))];
+			if (entries.length > 0) result.push({
+				type: "section",
+				entries
+			});
+			return { fragments: result };
+		}
+	};
+}
 /**
 * Creates a parser that matches a specific subcommand name and then applies
 * an inner parser to the remaining arguments.
@@ -1032,7 +1135,12 @@ function parse(parser, args) {
 			success: false,
 			error: result.error
 		};
+		const previousBuffer = context.buffer;
 		context = result.next;
+		if (context.buffer.length > 0 && context.buffer.length === previousBuffer.length && context.buffer[0] === previousBuffer[0]) return {
+			success: false,
+			error: require_message.message`Unexpected option or argument: ${context.buffer[0]}.`
+		};
 	} while (context.buffer.length > 0);
 	const endResult = parser.complete(context.state);
 	return endResult.success ? {
@@ -1121,6 +1229,7 @@ function getDocPage(parser, args = []) {
 //#endregion
 exports.argument = argument;
 exports.command = command;
+exports.concat = concat;
 exports.constant = constant;
 exports.getDocPage = getDocPage;
 exports.map = map;

package/dist/parser.d.cts

@@ -434,6 +434,166 @@ declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parse
  *         in order, returning the result of the first successful parser.
  */
 declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
+/**
+ * Creates a parser that combines six mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>): Parser<TA | TB | TC | TD | TE | TF, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>]>;
+/**
+ * Creates a parser that combines seven mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>): Parser<TA | TB | TC | TD | TE | TF | TG, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>]>;
+/**
+ * Creates a parser that combines eight mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>): Parser<TA | TB | TC | TD | TE | TF | TG | TH, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>]>;
+/**
+ * Creates a parser that combines nine mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>]>;
+/**
+ * Creates a parser that combines ten mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TJ The type of the value returned by the tenth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @template TStateJ The type of the state used by the tenth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @param j The tenth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>, j: Parser<TJ, TStateJ>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>] | [9, ParserResult<TStateJ>]>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -502,6 +662,107 @@ declare function merge<TA extends Parser<Record<string | symbol, unknown>, Recor
  *         of the two parsers into a single object.
  */
 declare function merge<TA extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TB extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TC extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TD extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TE extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>>(a: TA, b: TB, c: TC, d: TD, e: TE): Parser<{ readonly [K in keyof TA["$valueType"][number]]: TA["$valueType"][number][K] extends (infer U) ? U : never } & { readonly [K in keyof TB["$valueType"][number]]: TB["$valueType"][number][K] extends (infer U2) ? U2 : never } & { readonly [K in keyof TC["$valueType"][number]]: TC["$valueType"][number][K] extends (infer U3) ? U3 : never } & { readonly [K in keyof TD["$valueType"][number]]: TD["$valueType"][number][K] extends (infer U4) ? U4 : never } & { readonly [K in keyof TE["$valueType"][number]]: TE["$valueType"][number][K] extends (infer U5) ? U5 : never }, { readonly [K in keyof TA]: unknown } & { readonly [K in keyof TB]: unknown } & { readonly [K in keyof TC]: unknown } & { readonly [K in keyof TD]: unknown } & { readonly [K in keyof TE]: unknown }>;
+/**
+ * Concatenates two {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from both parsers in order.
+ *
+ * This is similar to {@link merge} for object parsers, but operates on tuple
+ * parsers and preserves the sequential, positional nature of tuples by
+ * flattening the results into a single tuple array.
+ *
+ * @example
+ * ```typescript
+ * const basicTuple = tuple([
+ *   option("-v", "--verbose"),
+ *   option("-p", "--port", integer()),
+ * ]);
+ *
+ * const serverTuple = tuple([
+ *   option("-h", "--host", string()),
+ *   option("-d", "--debug"),
+ * ]);
+ *
+ * const combined = concat(basicTuple, serverTuple);
+ * // Type: Parser<[boolean, number, string, boolean], [BasicState, ServerState]>
+ *
+ * const result = parse(combined, ["-v", "-p", "8080", "-h", "localhost", "-d"]);
+ * // result.value: [true, 8080, "localhost", true]
+ * ```
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of both parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<[...TA, ...TB], [TStateA, TStateB]>;
+/**
+ * Concatenates three {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<[...TA, ...TB, ...TC], [TStateA, TStateB, TStateC]>;
+/**
+ * Concatenates four {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TD The value type of the fourth tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @template TStateD The state type of the fourth tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @param d The fourth {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<[...TA, ...TB, ...TC, ...TD], [TStateA, TStateB, TStateC, TStateD]>;
+/**
+ * Concatenates five {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TD The value type of the fourth tuple parser.
+ * @template TE The value type of the fifth tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @template TStateD The state type of the fourth tuple parser.
+ * @template TStateE The state type of the fifth tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @param d The fourth {@link tuple} parser to concatenate.
+ * @param e The fifth {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TE extends readonly unknown[], TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<[...TA, ...TB, ...TC, ...TD, ...TE], [TStateA, TStateB, TStateC, TStateD, TStateE]>;
 /**
  * Options for the {@link command} parser.
  */
@@ -611,4 +872,4 @@ declare function parse<T>(parser: Parser<T, unknown>, args: readonly string[]):
  */
 declare function getDocPage(parser: Parser<unknown, unknown>, args?: readonly string[]): DocPage | undefined;
 //#endregion
-export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/dist/parser.d.ts

@@ -434,6 +434,166 @@ declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parse
  *         in order, returning the result of the first successful parser.
  */
 declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
+/**
+ * Creates a parser that combines six mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>): Parser<TA | TB | TC | TD | TE | TF, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>]>;
+/**
+ * Creates a parser that combines seven mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>): Parser<TA | TB | TC | TD | TE | TF | TG, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>]>;
+/**
+ * Creates a parser that combines eight mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>): Parser<TA | TB | TC | TD | TE | TF | TG | TH, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>]>;
+/**
+ * Creates a parser that combines nine mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>]>;
+/**
+ * Creates a parser that combines ten mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TJ The type of the value returned by the tenth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @template TStateJ The type of the state used by the tenth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @param j The tenth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>, j: Parser<TJ, TStateJ>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>] | [9, ParserResult<TStateJ>]>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -502,6 +662,107 @@ declare function merge<TA extends Parser<Record<string | symbol, unknown>, Recor
  *         of the two parsers into a single object.
  */
 declare function merge<TA extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TB extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TC extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TD extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>, TE extends Parser<Record<string | symbol, unknown>, Record<string | symbol, unknown>>>(a: TA, b: TB, c: TC, d: TD, e: TE): Parser<{ readonly [K in keyof TA["$valueType"][number]]: TA["$valueType"][number][K] extends (infer U) ? U : never } & { readonly [K in keyof TB["$valueType"][number]]: TB["$valueType"][number][K] extends (infer U2) ? U2 : never } & { readonly [K in keyof TC["$valueType"][number]]: TC["$valueType"][number][K] extends (infer U3) ? U3 : never } & { readonly [K in keyof TD["$valueType"][number]]: TD["$valueType"][number][K] extends (infer U4) ? U4 : never } & { readonly [K in keyof TE["$valueType"][number]]: TE["$valueType"][number][K] extends (infer U5) ? U5 : never }, { readonly [K in keyof TA]: unknown } & { readonly [K in keyof TB]: unknown } & { readonly [K in keyof TC]: unknown } & { readonly [K in keyof TD]: unknown } & { readonly [K in keyof TE]: unknown }>;
+/**
+ * Concatenates two {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from both parsers in order.
+ *
+ * This is similar to {@link merge} for object parsers, but operates on tuple
+ * parsers and preserves the sequential, positional nature of tuples by
+ * flattening the results into a single tuple array.
+ *
+ * @example
+ * ```typescript
+ * const basicTuple = tuple([
+ *   option("-v", "--verbose"),
+ *   option("-p", "--port", integer()),
+ * ]);
+ *
+ * const serverTuple = tuple([
+ *   option("-h", "--host", string()),
+ *   option("-d", "--debug"),
+ * ]);
+ *
+ * const combined = concat(basicTuple, serverTuple);
+ * // Type: Parser<[boolean, number, string, boolean], [BasicState, ServerState]>
+ *
+ * const result = parse(combined, ["-v", "-p", "8080", "-h", "localhost", "-d"]);
+ * // result.value: [true, 8080, "localhost", true]
+ * ```
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of both parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<[...TA, ...TB], [TStateA, TStateB]>;
+/**
+ * Concatenates three {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<[...TA, ...TB, ...TC], [TStateA, TStateB, TStateC]>;
+/**
+ * Concatenates four {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TD The value type of the fourth tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @template TStateD The state type of the fourth tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @param d The fourth {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<[...TA, ...TB, ...TC, ...TD], [TStateA, TStateB, TStateC, TStateD]>;
+/**
+ * Concatenates five {@link tuple} parsers into a single parser that produces
+ * a flattened tuple containing the values from all parsers in order.
+ *
+ * @template TA The value type of the first tuple parser.
+ * @template TB The value type of the second tuple parser.
+ * @template TC The value type of the third tuple parser.
+ * @template TD The value type of the fourth tuple parser.
+ * @template TE The value type of the fifth tuple parser.
+ * @template TStateA The state type of the first tuple parser.
+ * @template TStateB The state type of the second tuple parser.
+ * @template TStateC The state type of the third tuple parser.
+ * @template TStateD The state type of the fourth tuple parser.
+ * @template TStateE The state type of the fifth tuple parser.
+ * @param a The first {@link tuple} parser to concatenate.
+ * @param b The second {@link tuple} parser to concatenate.
+ * @param c The third {@link tuple} parser to concatenate.
+ * @param d The fourth {@link tuple} parser to concatenate.
+ * @param e The fifth {@link tuple} parser to concatenate.
+ * @return A new {@link tuple} parser that combines the values of all parsers
+ *         into a single flattened tuple.
+ * @since 0.2.0
+ */
+declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TE extends readonly unknown[], TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<[...TA, ...TB, ...TC, ...TD, ...TE], [TStateA, TStateB, TStateC, TStateD, TStateE]>;
 /**
  * Options for the {@link command} parser.
  */
@@ -611,4 +872,4 @@ declare function parse<T>(parser: Parser<T, unknown>, args: readonly string[]):
  */
 declare function getDocPage(parser: Parser<unknown, unknown>, args?: readonly string[]): DocPage | undefined;
 //#endregion
-export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/dist/parser.js

@@ -897,6 +897,109 @@ function merge(...parsers) {
 		}
 	};
 }
+function concat(...parsers) {
+	const initialState = parsers.map((parser) => parser.initialState);
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
+		usage: parsers.flatMap((p) => p.usage),
+		initialState,
+		parse(context) {
+			let currentContext = context;
+			const allConsumed = [];
+			const matchedParsers = /* @__PURE__ */ new Set();
+			while (matchedParsers.size < parsers.length) {
+				let foundMatch = false;
+				let error = {
+					consumed: 0,
+					error: message`No remaining parsers could match the input.`
+				};
+				const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+				for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						allConsumed.push(...result.consumed);
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+				if (!foundMatch) for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length < 1) {
+						currentContext = {
+							...currentContext,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && result.consumed < 1) {
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					}
+				}
+				if (!foundMatch) return {
+					...error,
+					success: false
+				};
+			}
+			return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+		},
+		complete(state) {
+			const results = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = state[i];
+				const result = parser.complete(parserState);
+				if (!result.success) return result;
+				if (Array.isArray(result.value)) results.push(...result.value);
+				else results.push(result.value);
+			}
+			return {
+				success: true,
+				value: results
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			const fragments = parsers.flatMap((p, index) => p.getDocFragments(state[index], void 0).fragments);
+			const entries = fragments.filter((f) => f.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const result = [...sections.map((s) => ({
+				...s,
+				type: "section"
+			}))];
+			if (entries.length > 0) result.push({
+				type: "section",
+				entries
+			});
+			return { fragments: result };
+		}
+	};
+}
 /**
 * Creates a parser that matches a specific subcommand name and then applies
 * an inner parser to the remaining arguments.
@@ -1032,7 +1135,12 @@ function parse(parser, args) {
 			success: false,
 			error: result.error
 		};
+		const previousBuffer = context.buffer;
 		context = result.next;
+		if (context.buffer.length > 0 && context.buffer.length === previousBuffer.length && context.buffer[0] === previousBuffer[0]) return {
+			success: false,
+			error: message`Unexpected option or argument: ${context.buffer[0]}.`
+		};
 	} while (context.buffer.length > 0);
 	const endResult = parser.complete(context.state);
 	return endResult.success ? {
@@ -1119,4 +1227,4 @@ function getDocPage(parser, args = []) {
 }
 
 //#endregion
-export { argument, command, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/core",
-  "version": "0.2.0-dev.32+58f16652",
+  "version": "0.3.0-dev.34+d4931ae5",
   "description": "Type-safe combinatorial command-line interface parser",
   "keywords": [
     "CLI",