@optique/core 0.9.0-dev.217 → 0.9.0-dev.224

package/dist/modifiers.d.cts

@@ -1,5 +1,5 @@
 import { Message } from "./message.cjs";
-import { Mode, Parser } from "./parser.cjs";
+import { Parser } from "./parser.cjs";
 
 //#region src/modifiers.d.ts
 
@@ -8,14 +8,13 @@ import { Mode, 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<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>): Parser<M, TValue | undefined, [TState] | undefined>;
+declare function optional<TValue, TState>(parser: Parser<TValue, TState>): Parser<TValue | undefined, [TState] | undefined>;
 /**
  * Options for the {@link withDefault} parser.
  */
@@ -71,7 +70,6 @@ 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.
@@ -83,13 +81,12 @@ 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<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<M, TValue | TDefault, [TState] | undefined>;
+declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<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.
@@ -103,7 +100,7 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  *          (union type {@link TValue} | {@link TDefault}).
  * @since 0.5.0
  */
-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>;
+declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<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
@@ -115,7 +112,6 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * - 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.
@@ -138,7 +134,7 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * const prefixedParser = map(option("-n", integer()), n => `value: ${n}`);
  * ```
  */
-declare function map<M extends Mode, T, U, TState>(parser: Parser<M, T, TState>, transform: (value: T) => U): Parser<M, U, TState>;
+declare function map<T, U, TState>(parser: Parser<T, TState>, transform: (value: T) => U): Parser<U, TState>;
 /**
  * Options for the {@link multiple} parser.
  */
@@ -181,7 +177,6 @@ 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.
@@ -192,6 +187,6 @@ interface MultipleErrorOptions {
  *          of type {@link TValue} and an array of states
  *          of type {@link TState}.
  */
-declare function multiple<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>, options?: MultipleOptions): Parser<M, readonly TValue[], readonly TState[]>;
+declare function multiple<TValue, TState>(parser: Parser<TValue, TState>, options?: MultipleOptions): Parser<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 { Mode, Parser } from "./parser.js";
+import { Parser } from "./parser.js";
 
 //#region src/modifiers.d.ts
 
@@ -8,14 +8,13 @@ import { Mode, 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<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>): Parser<M, TValue | undefined, [TState] | undefined>;
+declare function optional<TValue, TState>(parser: Parser<TValue, TState>): Parser<TValue | undefined, [TState] | undefined>;
 /**
  * Options for the {@link withDefault} parser.
  */
@@ -71,7 +70,6 @@ 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.
@@ -83,13 +81,12 @@ 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<M extends Mode, TValue, TState, const TDefault = TValue>(parser: Parser<M, TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<M, TValue | TDefault, [TState] | undefined>;
+declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<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.
@@ -103,7 +100,7 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  *          (union type {@link TValue} | {@link TDefault}).
  * @since 0.5.0
  */
-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>;
+declare function withDefault<TValue, TState, const TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<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
@@ -115,7 +112,6 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * - 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.
@@ -138,7 +134,7 @@ declare function withDefault<M extends Mode, TValue, TState, const TDefault = TV
  * const prefixedParser = map(option("-n", integer()), n => `value: ${n}`);
  * ```
  */
-declare function map<M extends Mode, T, U, TState>(parser: Parser<M, T, TState>, transform: (value: T) => U): Parser<M, U, TState>;
+declare function map<T, U, TState>(parser: Parser<T, TState>, transform: (value: T) => U): Parser<U, TState>;
 /**
  * Options for the {@link multiple} parser.
  */
@@ -181,7 +177,6 @@ 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.
@@ -192,6 +187,6 @@ interface MultipleErrorOptions {
  *          of type {@link TValue} and an array of states
  *          of type {@link TState}.
  */
-declare function multiple<M extends Mode, TValue, TState>(parser: Parser<M, TValue, TState>, options?: MultipleOptions): Parser<M, readonly TValue[], readonly TState[]>;
+declare function multiple<TValue, TState>(parser: Parser<TValue, TState>, options?: MultipleOptions): Parser<readonly TValue[], readonly TState[]>;
 //#endregion
 export { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, optional, withDefault };

package/dist/modifiers.js

@@ -9,31 +9,12 @@ import { formatMessage, message, text } from "./message.js";
 * - Returning success with undefined state when inner parser fails without consuming
 * @internal
 */
-function parseOptionalStyleSync(context, parser) {
+function parseOptionalStyle(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,
@@ -64,7 +45,6 @@ function processOptionalStyleResult(result, innerState, context) {
 * 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.
@@ -72,25 +52,7 @@ function processOptionalStyleResult(result, innerState, context) {
 *          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,
@@ -100,27 +62,28 @@ function optional(parser) {
 		}],
 		initialState: void 0,
 		parse(context) {
-			if (isAsync) return parseOptionalStyleAsync(context, parser);
-			return parseOptionalStyleSync(context, syncParser);
+			return parseOptionalStyle(context, parser);
 		},
 		complete(state) {
 			if (typeof state === "undefined") return {
 				success: true,
 				value: void 0
 			};
-			if (!isAsync) return syncParser.complete(state[0]);
-			return (async () => await parser.complete(state[0]))();
+			return parser.complete(state[0]);
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestAsync(context, prefix);
-			return suggestSync(context, prefix);
+			const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
+			return parser.suggest({
+				...context,
+				state: innerState
+			}, prefix);
 		},
 		getDocFragments(state, defaultValue) {
 			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state === void 0 ? { kind: "unavailable" } : {
 				kind: "available",
 				state: state.state[0]
 			};
-			return syncParser.getDocFragments(innerState, defaultValue);
+			return parser.getDocFragments(innerState, defaultValue);
 		}
 	};
 }
@@ -159,25 +122,7 @@ 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,
@@ -187,8 +132,7 @@ function withDefault(parser, defaultValue, options) {
 		}],
 		initialState: void 0,
 		parse(context) {
-			if (isAsync) return parseOptionalStyleAsync(context, parser);
-			return parseOptionalStyleSync(context, syncParser);
+			return parseOptionalStyle(context, parser);
 		},
 		complete(state) {
 			if (typeof state === "undefined") try {
@@ -203,12 +147,14 @@ function withDefault(parser, defaultValue, options) {
 					error: error instanceof WithDefaultError ? error.errorMessage : message`${text(String(error))}`
 				};
 			}
-			if (!isAsync) return syncParser.complete(state[0]);
-			return (async () => await parser.complete(state[0]))();
+			return parser.complete(state[0]);
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestAsync(context, prefix);
-			return suggestSync(context, prefix);
+			const innerState = typeof context.state === "undefined" ? parser.initialState : context.state[0];
+			return parser.suggest({
+				...context,
+				state: innerState
+			}, prefix);
 		},
 		getDocFragments(state, upperDefaultValue) {
 			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state === void 0 ? { kind: "unavailable" } : {
@@ -216,7 +162,7 @@ function withDefault(parser, defaultValue, options) {
 				state: state.state[0]
 			};
 			const actualDefaultValue = upperDefaultValue != null ? upperDefaultValue : typeof defaultValue === "function" ? defaultValue() : defaultValue;
-			const fragments = syncParser.getDocFragments(innerState, actualDefaultValue);
+			const fragments = parser.getDocFragments(innerState, actualDefaultValue);
 			if (options?.message) {
 				const modifiedFragments = fragments.fragments.map((fragment) => {
 					if (fragment.type === "entry") return {
@@ -245,7 +191,6 @@ 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.
@@ -269,68 +214,33 @@ function withDefault(parser, defaultValue, options) {
 * ```
 */
 function map(parser, transform) {
-	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",
+	return {
 		$valueType: [],
 		$stateType: parser.$stateType,
 		priority: parser.priority,
 		usage: parser.usage,
 		initialState: parser.initialState,
-		parse(context) {
-			if (isAsync) return parser.parse(context);
-			return syncParser.parse(context);
-		},
+		parse: parser.parse.bind(parser),
 		complete(state) {
-			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
-				};
-			})();
+			const result = parser.complete(state);
+			if (result.success) return {
+				success: true,
+				value: transform(result.value)
+			};
+			return result;
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestAsync(context, prefix);
-			return suggestSync(context, prefix);
+			return parser.suggest(context, prefix);
 		},
 		getDocFragments(state, _defaultValue) {
-			return syncParser.getDocFragments(state, void 0);
+			return parser.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.
@@ -342,59 +252,8 @@ 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;
-	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,
+	return {
 		$valueType: [],
 		$stateType: [],
 		priority: parser.priority,
@@ -405,79 +264,71 @@ function multiple(parser, options = {}) {
 		}],
 		initialState: [],
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(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
+			};
 		},
 		complete(state) {
-			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);
+			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
+				};
 			}
-			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);
-			})();
+			if (result.length < min) {
+				const customMessage = options.errors?.tooFew;
+				return {
+					success: false,
+					error: customMessage ? typeof customMessage === "function" ? customMessage(min, result.length) : customMessage : message`Expected at least ${text(min.toLocaleString("en"))} values, but got only ${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 : message`Expected at most ${text(max.toLocaleString("en"))} values, but got ${text(result.length.toLocaleString("en"))}.`
+				};
+			}
+			return {
+				success: true,
+				value: result
+			};
 		},
 		suggest(context, prefix) {
 			const innerState = context.state.length > 0 ? context.state.at(-1) : parser.initialState;
-			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);
-			}();
+			return parser.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 syncParser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
+			return parser.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 : message`Expected at least ${text(min.toLocaleString("en"))} values, but got only ${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 : message`Expected at most ${text(max.toLocaleString("en"))} values, but got ${text(result.length.toLocaleString("en"))}.`
-			};
-		}
-		return {
-			success: true,
-			value: result
-		};
-	}
-	return resultParser;
 }
 
 //#endregion