@optique/core 0.9.0-dev.211 → 0.9.0-dev.212

package/dist/modifiers.cjs

@@ -9,12 +9,31 @@ const require_message = require('./message.cjs');
 * - Returning success with undefined state when inner parser fails without consuming
 * @internal
 */
-function parseOptionalStyle(context, parser) {
+function parseOptionalStyleSync(context, parser) {
 	const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
 	const result = parser.parse({
 		...context,
 		state: innerState
 	});
+	return processOptionalStyleResult(result, innerState, context);
+}
+/**
+* Internal async helper for optional-style parsing logic.
+* @internal
+*/
+async function parseOptionalStyleAsync(context, parser) {
+	const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
+	const result = await parser.parse({
+		...context,
+		state: innerState
+	});
+	return processOptionalStyleResult(result, innerState, context);
+}
+/**
+* Internal helper to process optional-style parse results.
+* @internal
+*/
+function processOptionalStyleResult(result, innerState, context) {
 	if (result.success) {
 		if (result.next.state !== innerState || result.consumed.length === 0) return {
 			success: true,
@@ -45,6 +64,7 @@ function parseOptionalStyle(context, parser) {
 * without consuming input if the wrapped parser fails to match.
 * If the wrapped parser succeeds, this returns its value.
 * If the wrapped parser fails, this returns `undefined` without consuming input.
+* @template M The execution mode of the parser.
 * @template TValue The type of the value returned by the wrapped parser.
 * @template TState The type of the state used by the wrapped parser.
 * @param parser The {@link Parser} to make optional.
@@ -52,7 +72,25 @@ function parseOptionalStyle(context, parser) {
 *          or `undefined` if the wrapped parser fails to match.
 */
 function optional(parser) {
+	const syncParser = parser;
+	const isAsync = parser.$mode === "async";
+	function* suggestSync(context, prefix) {
+		const innerState = typeof context.state === "undefined" ? syncParser.initialState : context.state[0];
+		yield* syncParser.suggest({
+			...context,
+			state: innerState
+		}, prefix);
+	}
+	async function* suggestAsync(context, prefix) {
+		const innerState = typeof context.state === "undefined" ? syncParser.initialState : context.state[0];
+		const suggestions = parser.suggest({
+			...context,
+			state: innerState
+		}, prefix);
+		for await (const s of suggestions) yield s;
+	}
 	return {
+		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
 		priority: parser.priority,
@@ -62,28 +100,27 @@ function optional(parser) {
 		}],
 		initialState: void 0,
 		parse(context) {
-			return parseOptionalStyle(context, parser);
+			if (isAsync) return parseOptionalStyleAsync(context, parser);
+			return parseOptionalStyleSync(context, syncParser);
 		},
 		complete(state) {
 			if (typeof state === "undefined") return {
 				success: true,
 				value: void 0
 			};
-			return parser.complete(state[0]);
+			if (!isAsync) return syncParser.complete(state[0]);
+			return (async () => await parser.complete(state[0]))();
 		},
 		suggest(context, prefix) {
-			const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
-			return parser.suggest({
-				...context,
-				state: innerState
-			}, prefix);
+			if (isAsync) return suggestAsync(context, prefix);
+			return suggestSync(context, prefix);
 		},
 		getDocFragments(state, defaultValue) {
 			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state === void 0 ? { kind: "unavailable" } : {
 				kind: "available",
 				state: state.state[0]
 			};
-			return parser.getDocFragments(innerState, defaultValue);
+			return syncParser.getDocFragments(innerState, defaultValue);
 		}
 	};
 }
@@ -122,7 +159,25 @@ var WithDefaultError = class extends Error {
 	}
 };
 function withDefault(parser, defaultValue, options) {
+	const syncParser = parser;
+	const isAsync = parser.$mode === "async";
+	function* suggestSync(context, prefix) {
+		const innerState = typeof context.state === "undefined" ? syncParser.initialState : context.state[0];
+		yield* syncParser.suggest({
+			...context,
+			state: innerState
+		}, prefix);
+	}
+	async function* suggestAsync(context, prefix) {
+		const innerState = typeof context.state === "undefined" ? syncParser.initialState : context.state[0];
+		const suggestions = parser.suggest({
+			...context,
+			state: innerState
+		}, prefix);
+		for await (const s of suggestions) yield s;
+	}
 	return {
+		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
 		priority: parser.priority,
@@ -132,7 +187,8 @@ function withDefault(parser, defaultValue, options) {
 		}],
 		initialState: void 0,
 		parse(context) {
-			return parseOptionalStyle(context, parser);
+			if (isAsync) return parseOptionalStyleAsync(context, parser);
+			return parseOptionalStyleSync(context, syncParser);
 		},
 		complete(state) {
 			if (typeof state === "undefined") try {
@@ -147,14 +203,12 @@ function withDefault(parser, defaultValue, options) {
 					error: error instanceof WithDefaultError ? error.errorMessage : require_message.message`${require_message.text(String(error))}`
 				};
 			}
-			return parser.complete(state[0]);
+			if (!isAsync) return syncParser.complete(state[0]);
+			return (async () => await parser.complete(state[0]))();
 		},
 		suggest(context, prefix) {
-			const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
-			return parser.suggest({
-				...context,
-				state: innerState
-			}, prefix);
+			if (isAsync) return suggestAsync(context, prefix);
+			return suggestSync(context, prefix);
 		},
 		getDocFragments(state, upperDefaultValue) {
 			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state === void 0 ? { kind: "unavailable" } : {
@@ -162,7 +216,7 @@ function withDefault(parser, defaultValue, options) {
 				state: state.state[0]
 			};
 			const actualDefaultValue = upperDefaultValue != null ? upperDefaultValue : typeof defaultValue === "function" ? defaultValue() : defaultValue;
-			const fragments = parser.getDocFragments(innerState, actualDefaultValue);
+			const fragments = syncParser.getDocFragments(innerState, actualDefaultValue);
 			if (options?.message) {
 				const modifiedFragments = fragments.fragments.map((fragment) => {
 					if (fragment.type === "entry") return {
@@ -191,6 +245,7 @@ function withDefault(parser, defaultValue, options) {
 * - Computing derived values from parsed input
 * - Creating reusable transformations that can be applied to any parser
 *
+* @template M The execution mode of the parser.
 * @template T The type of the value produced by the original parser.
 * @template U The type of the value produced by the mapping function.
 * @template TState The type of the state used by the original parser.
@@ -214,33 +269,68 @@ function withDefault(parser, defaultValue, options) {
 * ```
 */
 function map(parser, transform) {
-	return {
+	const syncParser = parser;
+	const isAsync = parser.$mode === "async";
+	function* suggestSync(context, prefix) {
+		yield* syncParser.suggest(context, prefix);
+	}
+	async function* suggestAsync(context, prefix) {
+		const suggestions = parser.suggest(context, prefix);
+		for await (const s of suggestions) yield s;
+	}
+	const result = {
+		$mode: "sync",
 		$valueType: [],
 		$stateType: parser.$stateType,
 		priority: parser.priority,
 		usage: parser.usage,
 		initialState: parser.initialState,
-		parse: parser.parse.bind(parser),
+		parse(context) {
+			if (isAsync) return parser.parse(context);
+			return syncParser.parse(context);
+		},
 		complete(state) {
-			const result = parser.complete(state);
-			if (result.success) return {
-				success: true,
-				value: transform(result.value)
-			};
-			return result;
+			if (!isAsync) {
+				const innerResult = syncParser.complete(state);
+				if (innerResult.success) return {
+					success: true,
+					value: transform(innerResult.value)
+				};
+				return {
+					success: false,
+					error: innerResult.error
+				};
+			}
+			return (async () => {
+				const innerResult = await parser.complete(state);
+				if (innerResult.success) return {
+					success: true,
+					value: transform(innerResult.value)
+				};
+				return {
+					success: false,
+					error: innerResult.error
+				};
+			})();
 		},
 		suggest(context, prefix) {
-			return parser.suggest(context, prefix);
+			if (isAsync) return suggestAsync(context, prefix);
+			return suggestSync(context, prefix);
 		},
 		getDocFragments(state, _defaultValue) {
-			return parser.getDocFragments(state, void 0);
+			return syncParser.getDocFragments(state, void 0);
 		}
 	};
+	return {
+		...result,
+		$mode: parser.$mode
+	};
 }
 /**
 * Creates a parser that allows multiple occurrences of a given parser.
 * This parser can be used to parse multiple values of the same type,
 * such as multiple command-line arguments or options.
+* @template M The execution mode of the parser.
 * @template TValue The type of the value that the parser produces.
 * @template TState The type of the state used by the parser.
 * @param parser The {@link Parser} to apply multiple times.
@@ -252,8 +342,59 @@ function map(parser, transform) {
 *          of type {@link TState}.
 */
 function multiple(parser, options = {}) {
+	const syncParser = parser;
+	const isAsync = parser.$mode === "async";
 	const { min = 0, max = Infinity } = options;
-	return {
+	const parseSync = (context) => {
+		let added = context.state.length < 1;
+		let result = syncParser.parse({
+			...context,
+			state: context.state.at(-1) ?? syncParser.initialState
+		});
+		if (!result.success) if (!added) {
+			result = syncParser.parse({
+				...context,
+				state: syncParser.initialState
+			});
+			if (!result.success) return result;
+			added = true;
+		} else return result;
+		return {
+			success: true,
+			next: {
+				...result.next,
+				state: [...added ? context.state : context.state.slice(0, -1), result.next.state]
+			},
+			consumed: result.consumed
+		};
+	};
+	const parseAsync = async (context) => {
+		let added = context.state.length < 1;
+		let resultOrPromise = parser.parse({
+			...context,
+			state: context.state.at(-1) ?? parser.initialState
+		});
+		let result = await resultOrPromise;
+		if (!result.success) if (!added) {
+			resultOrPromise = parser.parse({
+				...context,
+				state: parser.initialState
+			});
+			result = await resultOrPromise;
+			if (!result.success) return result;
+			added = true;
+		} else return result;
+		return {
+			success: true,
+			next: {
+				...result.next,
+				state: [...added ? context.state : context.state.slice(0, -1), result.next.state]
+			},
+			consumed: result.consumed
+		};
+	};
+	const resultParser = {
+		$mode: parser.$mode,
 		$valueType: [],
 		$stateType: [],
 		priority: parser.priority,
@@ -264,71 +405,79 @@ function multiple(parser, options = {}) {
 		}],
 		initialState: [],
 		parse(context) {
-			let added = context.state.length < 1;
-			let result = parser.parse({
-				...context,
-				state: context.state.at(-1) ?? parser.initialState
-			});
-			if (!result.success) if (!added) {
-				result = parser.parse({
-					...context,
-					state: parser.initialState
-				});
-				if (!result.success) return result;
-				added = true;
-			} else return result;
-			return {
-				success: true,
-				next: {
-					...result.next,
-					state: [...added ? context.state : context.state.slice(0, -1), result.next.state]
-				},
-				consumed: result.consumed
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
 		complete(state) {
-			const result = [];
-			for (const s of state) {
-				const valueResult = parser.complete(s);
-				if (valueResult.success) result.push(valueResult.value);
-				else return {
-					success: false,
-					error: valueResult.error
-				};
-			}
-			if (result.length < min) {
-				const customMessage = options.errors?.tooFew;
-				return {
-					success: false,
-					error: customMessage ? typeof customMessage === "function" ? customMessage(min, result.length) : customMessage : require_message.message`Expected at least ${require_message.text(min.toLocaleString("en"))} values, but got only ${require_message.text(result.length.toLocaleString("en"))}.`
-				};
-			} else if (result.length > max) {
-				const customMessage = options.errors?.tooMany;
-				return {
-					success: false,
-					error: customMessage ? typeof customMessage === "function" ? customMessage(max, result.length) : customMessage : require_message.message`Expected at most ${require_message.text(max.toLocaleString("en"))} values, but got ${require_message.text(result.length.toLocaleString("en"))}.`
-				};
+			if (!isAsync) {
+				const result = [];
+				for (const s of state) {
+					const valueResult = syncParser.complete(s);
+					if (valueResult.success) result.push(valueResult.value);
+					else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return validateMultipleResult(result);
 			}
-			return {
-				success: true,
-				value: result
-			};
+			return (async () => {
+				const result = [];
+				for (const s of state) {
+					const valueResult = await parser.complete(s);
+					if (valueResult.success) result.push(valueResult.value);
+					else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return validateMultipleResult(result);
+			})();
 		},
 		suggest(context, prefix) {
 			const innerState = context.state.length > 0 ? context.state.at(-1) : parser.initialState;
-			return parser.suggest({
-				...context,
-				state: innerState
-			}, prefix);
+			if (isAsync) return async function* () {
+				const suggestions = parser.suggest({
+					...context,
+					state: innerState
+				}, prefix);
+				for await (const s of suggestions) yield s;
+			}();
+			return function* () {
+				yield* syncParser.suggest({
+					...context,
+					state: innerState
+				}, prefix);
+			}();
 		},
 		getDocFragments(state, defaultValue) {
 			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state.length > 0 ? {
 				kind: "available",
 				state: state.state.at(-1)
 			} : { kind: "unavailable" };
-			return parser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
+			return syncParser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
 		}
 	};
+	function validateMultipleResult(result) {
+		if (result.length < min) {
+			const customMessage = options.errors?.tooFew;
+			return {
+				success: false,
+				error: customMessage ? typeof customMessage === "function" ? customMessage(min, result.length) : customMessage : require_message.message`Expected at least ${require_message.text(min.toLocaleString("en"))} values, but got only ${require_message.text(result.length.toLocaleString("en"))}.`
+			};
+		} else if (result.length > max) {
+			const customMessage = options.errors?.tooMany;
+			return {
+				success: false,
+				error: customMessage ? typeof customMessage === "function" ? customMessage(max, result.length) : customMessage : require_message.message`Expected at most ${require_message.text(max.toLocaleString("en"))} values, but got ${require_message.text(result.length.toLocaleString("en"))}.`
+			};
+		}
+		return {
+			success: true,
+			value: result
+		};
+	}
+	return resultParser;
 }
 
 //#endregion

package/dist/modifiers.d.cts

@@ -1,5 +1,5 @@
 import { Message } from "./message.cjs";
-import { Parser } from "./parser.cjs";
+import { Mode, Parser } from "./parser.cjs";
 
 //#region src/modifiers.d.ts
 
@@ -8,13 +8,14 @@ import { Parser } from "./parser.cjs";
  * without consuming input if the wrapped parser fails to match.
  * If the wrapped parser succeeds, this returns its value.
  * If the wrapped parser fails, this returns `undefined` without consuming input.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @param parser The {@link Parser} to make optional.
  * @returns A {@link Parser} that produces either the result of the wrapped parser
  *          or `undefined` if the wrapped parser fails to match.
  */
-declare function optional<TValue, TState>(parser: Parser<TValue, TState>): Parser<TValue | undefined, [TState] | undefined>;
+declare function optional<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>): Parser<M, TValue | undefined, [TState] | undefined>;
 /**
  * Options for the {@link withDefault} parser.
  */
@@ -70,6 +71,7 @@ declare class WithDefaultError extends Error {
  * to match or consume input. This is similar to {@link optional}, but instead
  * of returning `undefined` when the wrapped parser doesn't match, it returns
  * a specified default value.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @template TDefault The type of the default value.
@@ -81,12 +83,13 @@ declare class WithDefaultError extends Error {
  *          or the default value if the wrapped parser fails to match
  *          (union type {@link TValue} | {@link TDefault}).
  */
-declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<TValue | TDefault, [TState] | undefined>;
+declare function withDefault<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<M, TValue | TDefault, [TState] | undefined>;
 /**
  * Creates a parser that makes another parser use a default value when it fails
  * to match or consume input. This is similar to {@link optional}, but instead
  * of returning `undefined` when the wrapped parser doesn't match, it returns
  * a specified default value.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @template TDefault The type of the default value.
@@ -100,7 +103,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  *          (union type {@link TValue} | {@link TDefault}).
  * @since 0.5.0
  */
-declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<TValue | TDefault, [TState] | undefined>;
+declare function withDefault<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<M, TValue | TDefault, [TState] | undefined>;
 /**
  * Creates a parser that transforms the result value of another parser using
  * a mapping function. This enables value transformation while preserving
@@ -112,6 +115,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  * - Computing derived values from parsed input
  * - Creating reusable transformations that can be applied to any parser
  *
+ * @template M The execution mode of the parser.
  * @template T The type of the value produced by the original parser.
  * @template U The type of the value produced by the mapping function.
  * @template TState The type of the state used by the original parser.
@@ -134,7 +138,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  * const prefixedParser = map(option("-n", integer()), n => `value: ${n}`);
  * ```
  */
-declare function map<T, U, TState>(parser: Parser<T, TState>, transform: (value: T) => U): Parser<U, TState>;
+declare function map<M extends Mode, T, U, TState>(parser: Parser<M, T, TState>, transform: (value: T) => U): Parser<M, U, TState>;
 /**
  * Options for the {@link multiple} parser.
  */
@@ -177,6 +181,7 @@ interface MultipleErrorOptions {
  * Creates a parser that allows multiple occurrences of a given parser.
  * This parser can be used to parse multiple values of the same type,
  * such as multiple command-line arguments or options.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value that the parser produces.
  * @template TState The type of the state used by the parser.
  * @param parser The {@link Parser} to apply multiple times.
@@ -187,6 +192,6 @@ interface MultipleErrorOptions {
  *          of type {@link TValue} and an array of states
  *          of type {@link TState}.
  */
-declare function multiple<TValue, TState>(parser: Parser<TValue, TState>, options?: MultipleOptions): Parser<readonly TValue[], readonly TState[]>;
+declare function multiple<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>, options?: MultipleOptions): Parser<M, readonly TValue[], readonly TState[]>;
 //#endregion
 export { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, optional, withDefault };

package/dist/modifiers.d.ts

@@ -1,5 +1,5 @@
 import { Message } from "./message.js";
-import { Parser } from "./parser.js";
+import { Mode, Parser } from "./parser.js";
 
 //#region src/modifiers.d.ts
 
@@ -8,13 +8,14 @@ import { Parser } from "./parser.js";
  * without consuming input if the wrapped parser fails to match.
  * If the wrapped parser succeeds, this returns its value.
  * If the wrapped parser fails, this returns `undefined` without consuming input.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @param parser The {@link Parser} to make optional.
  * @returns A {@link Parser} that produces either the result of the wrapped parser
  *          or `undefined` if the wrapped parser fails to match.
  */
-declare function optional<TValue, TState>(parser: Parser<TValue, TState>): Parser<TValue | undefined, [TState] | undefined>;
+declare function optional<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>): Parser<M, TValue | undefined, [TState] | undefined>;
 /**
  * Options for the {@link withDefault} parser.
  */
@@ -70,6 +71,7 @@ declare class WithDefaultError extends Error {
  * to match or consume input. This is similar to {@link optional}, but instead
  * of returning `undefined` when the wrapped parser doesn't match, it returns
  * a specified default value.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @template TDefault The type of the default value.
@@ -81,12 +83,13 @@ declare class WithDefaultError extends Error {
  *          or the default value if the wrapped parser fails to match
  *          (union type {@link TValue} | {@link TDefault}).
  */
-declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<TValue | TDefault, [TState] | undefined>;
+declare function withDefault<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<M, TValue | TDefault, [TState] | undefined>;
 /**
  * Creates a parser that makes another parser use a default value when it fails
  * to match or consume input. This is similar to {@link optional}, but instead
  * of returning `undefined` when the wrapped parser doesn't match, it returns
  * a specified default value.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value returned by the wrapped parser.
  * @template TState The type of the state used by the wrapped parser.
  * @template TDefault The type of the default value.
@@ -100,7 +103,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  *          (union type {@link TValue} | {@link TDefault}).
  * @since 0.5.0
  */
-declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<TValue | TDefault, [TState] | undefined>;
+declare function withDefault<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<M, TValue | TDefault, [TState] | undefined>;
 /**
  * Creates a parser that transforms the result value of another parser using
  * a mapping function. This enables value transformation while preserving
@@ -112,6 +115,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  * - Computing derived values from parsed input
  * - Creating reusable transformations that can be applied to any parser
  *
+ * @template M The execution mode of the parser.
  * @template T The type of the value produced by the original parser.
  * @template U The type of the value produced by the mapping function.
  * @template TState The type of the state used by the original parser.
@@ -134,7 +138,7 @@ declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Pa
  * const prefixedParser = map(option("-n", integer()), n => `value: ${n}`);
  * ```
  */
-declare function map<T, U, TState>(parser: Parser<T, TState>, transform: (value: T) => U): Parser<U, TState>;
+declare function map<M extends Mode, T, U, TState>(parser: Parser<M, T, TState>, transform: (value: T) => U): Parser<M, U, TState>;
 /**
  * Options for the {@link multiple} parser.
  */
@@ -177,6 +181,7 @@ interface MultipleErrorOptions {
  * Creates a parser that allows multiple occurrences of a given parser.
  * This parser can be used to parse multiple values of the same type,
  * such as multiple command-line arguments or options.
+ * @template M The execution mode of the parser.
  * @template TValue The type of the value that the parser produces.
  * @template TState The type of the state used by the parser.
  * @param parser The {@link Parser} to apply multiple times.
@@ -187,6 +192,6 @@ interface MultipleErrorOptions {
  *          of type {@link TValue} and an array of states
  *          of type {@link TState}.
  */
-declare function multiple<TValue, TState>(parser: Parser<TValue, TState>, options?: MultipleOptions): Parser<readonly TValue[], readonly TState[]>;
+declare function multiple<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>, options?: MultipleOptions): Parser<M, readonly TValue[], readonly TState[]>;
 //#endregion
 export { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, optional, withDefault };