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

package/dist/constructs.cjs

@@ -117,79 +117,45 @@ function generateNoMatchError(context) {
 * Creates a complete() method shared by or() and longestMatch().
 * @internal
 */
-function createExclusiveComplete(parsers, options, noMatchContext, isAsync) {
-	const syncParsers = parsers;
+function createExclusiveComplete(parsers, options, noMatchContext) {
 	return (state) => {
 		if (state == null) return {
 			success: false,
 			error: getNoMatchError(options, noMatchContext)
 		};
 		const [i, result] = state;
-		if (!result.success) return {
+		if (result.success) return parsers[i].complete(result.next.state);
+		return {
 			success: false,
 			error: result.error
 		};
-		if (isAsync) return (async () => {
-			const completeResult = await parsers[i].complete(result.next.state);
-			return completeResult;
-		})();
-		return syncParsers[i].complete(result.next.state);
 	};
 }
 /**
 * Creates a suggest() method shared by or() and longestMatch().
 * @internal
 */
-function createExclusiveSuggest(parsers, isAsync) {
-	const syncParsers = parsers;
-	if (isAsync) return (context, prefix) => {
-		return async function* () {
-			const suggestions = [];
-			if (context.state == null) for (const parser of parsers) {
-				const parserSuggestions = parser.suggest({
-					...context,
-					state: parser.initialState
-				}, prefix);
-				if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
-				else suggestions.push(...parserSuggestions);
-			}
-			else {
-				const [index, parserResult] = context.state;
-				if (parserResult.success) {
-					const parser = parsers[index];
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserResult.next.state
-					}, prefix);
-					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
-					else suggestions.push(...parserSuggestions);
-				}
-			}
-			yield* require_suggestion.deduplicateSuggestions(suggestions);
-		}();
-	};
+function createExclusiveSuggest(parsers) {
 	return (context, prefix) => {
-		return function* () {
-			const suggestions = [];
-			if (context.state == null) for (const parser of syncParsers) {
-				const parserSuggestions = parser.suggest({
+		const suggestions = [];
+		if (context.state == null) for (const parser of parsers) {
+			const parserSuggestions = parser.suggest({
+				...context,
+				state: parser.initialState
+			}, prefix);
+			suggestions.push(...parserSuggestions);
+		}
+		else {
+			const [index, parserResult] = context.state;
+			if (parserResult.success) {
+				const parserSuggestions = parsers[index].suggest({
 					...context,
-					state: parser.initialState
+					state: parserResult.next.state
 				}, prefix);
 				suggestions.push(...parserSuggestions);
 			}
-			else {
-				const [index, parserResult] = context.state;
-				if (parserResult.success) {
-					const parserSuggestions = syncParsers[index].suggest({
-						...context,
-						state: parserResult.next.state
-					}, prefix);
-					suggestions.push(...parserSuggestions);
-				}
-			}
-			yield* require_suggestion.deduplicateSuggestions(suggestions);
-		}();
+		}
+		return require_suggestion.deduplicateSuggestions(suggestions);
 	};
 }
 /**
@@ -225,80 +191,7 @@ function or(...args) {
 		options = void 0;
 	}
 	const noMatchContext = analyzeNoMatchContext(parsers);
-	const combinedMode = parsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const syncParsers = parsers;
-	const getInitialError = (context) => ({
-		consumed: 0,
-		error: context.buffer.length < 1 ? getNoMatchError(options, noMatchContext) : createUnexpectedInputError(context.buffer[0], context.usage, options)
-	});
-	const parseSync = (context) => {
-		let error = getInitialError(context);
-		const orderedParsers = syncParsers.map((p, i) => [p, i]);
-		orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
-		for (const [parser, i] of orderedParsers) {
-			const result = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
-			if (result.success && result.consumed.length > 0) {
-				if (context.state?.[0] !== i && context.state?.[1].success) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
-				};
-				return {
-					success: true,
-					next: {
-						...context,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: [i, result]
-					},
-					consumed: result.consumed
-				};
-			} else if (!result.success && error.consumed < result.consumed) error = result;
-		}
-		return {
-			...error,
-			success: false
-		};
-	};
-	const parseAsync = async (context) => {
-		let error = getInitialError(context);
-		const orderedParsers = parsers.map((p, i) => [p, i]);
-		orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
-		for (const [parser, i] of orderedParsers) {
-			const resultOrPromise = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
-			const result = await resultOrPromise;
-			if (result.success && result.consumed.length > 0) {
-				if (context.state?.[0] !== i && context.state?.[1].success) return {
-					success: false,
-					consumed: context.buffer.length - result.next.buffer.length,
-					error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
-				};
-				return {
-					success: true,
-					next: {
-						...context,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: [i, result]
-					},
-					consumed: result.consumed
-				};
-			} else if (!result.success && error.consumed < result.consumed) error = result;
-		}
-		return {
-			...error,
-			success: false
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
@@ -307,12 +200,43 @@ function or(...args) {
 			terms: parsers.map((p) => p.usage)
 		}],
 		initialState: void 0,
-		complete: createExclusiveComplete(parsers, options, noMatchContext, isAsync),
+		complete: createExclusiveComplete(parsers, options, noMatchContext),
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
+			let error = {
+				consumed: 0,
+				error: context.buffer.length < 1 ? getNoMatchError(options, noMatchContext) : createUnexpectedInputError(context.buffer[0], context.usage, options)
+			};
+			const orderedParsers = parsers.map((p, i) => [p, i]);
+			orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
+			for (const [parser, i] of orderedParsers) {
+				const result = parser.parse({
+					...context,
+					state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
+				});
+				if (result.success && result.consumed.length > 0) {
+					if (context.state?.[0] !== i && context.state?.[1].success) return {
+						success: false,
+						consumed: context.buffer.length - result.next.buffer.length,
+						error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
+					};
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: [i, result]
+						},
+						consumed: result.consumed
+					};
+				} else if (!result.success && error.consumed < result.consumed) error = result;
+			}
+			return {
+				...error,
+				success: false
+			};
 		},
-		suggest: createExclusiveSuggest(parsers, isAsync),
+		suggest: createExclusiveSuggest(parsers),
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let fragments;
@@ -361,82 +285,7 @@ function longestMatch(...args) {
 		options = void 0;
 	}
 	const noMatchContext = analyzeNoMatchContext(parsers);
-	const combinedMode = parsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const syncParsers = parsers;
-	const getInitialError = (context) => ({
-		consumed: 0,
-		error: context.buffer.length < 1 ? getNoMatchError(options, noMatchContext) : createUnexpectedInputError(context.buffer[0], context.usage, options)
-	});
-	const parseSync = (context) => {
-		let bestMatch = null;
-		let error = getInitialError(context);
-		for (let i = 0; i < syncParsers.length; i++) {
-			const parser = syncParsers[i];
-			const result = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
-			if (result.success) {
-				const consumed = context.buffer.length - result.next.buffer.length;
-				if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
-					index: i,
-					result,
-					consumed
-				};
-			} else if (error.consumed < result.consumed) error = result;
-		}
-		if (bestMatch && bestMatch.result.success) return {
-			success: true,
-			next: {
-				...context,
-				buffer: bestMatch.result.next.buffer,
-				optionsTerminated: bestMatch.result.next.optionsTerminated,
-				state: [bestMatch.index, bestMatch.result]
-			},
-			consumed: bestMatch.result.consumed
-		};
-		return {
-			...error,
-			success: false
-		};
-	};
-	const parseAsync = async (context) => {
-		let bestMatch = null;
-		let error = getInitialError(context);
-		for (let i = 0; i < parsers.length; i++) {
-			const parser = parsers[i];
-			const resultOrPromise = parser.parse({
-				...context,
-				state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
-			});
-			const result = await resultOrPromise;
-			if (result.success) {
-				const consumed = context.buffer.length - result.next.buffer.length;
-				if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
-					index: i,
-					result,
-					consumed
-				};
-			} else if (error.consumed < result.consumed) error = result;
-		}
-		if (bestMatch && bestMatch.result.success) return {
-			success: true,
-			next: {
-				...context,
-				buffer: bestMatch.result.next.buffer,
-				optionsTerminated: bestMatch.result.next.optionsTerminated,
-				state: [bestMatch.index, bestMatch.result]
-			},
-			consumed: bestMatch.result.consumed
-		};
-		return {
-			...error,
-			success: false
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
@@ -445,12 +294,44 @@ function longestMatch(...args) {
 			terms: parsers.map((p) => p.usage)
 		}],
 		initialState: void 0,
-		complete: createExclusiveComplete(parsers, options, noMatchContext, isAsync),
+		complete: createExclusiveComplete(parsers, options, noMatchContext),
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
+			let bestMatch = null;
+			let error = {
+				consumed: 0,
+				error: context.buffer.length < 1 ? getNoMatchError(options, noMatchContext) : createUnexpectedInputError(context.buffer[0], context.usage, options)
+			};
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const result = parser.parse({
+					...context,
+					state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
+				});
+				if (result.success) {
+					const consumed = context.buffer.length - result.next.buffer.length;
+					if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
+						index: i,
+						result,
+						consumed
+					};
+				} else if (error.consumed < result.consumed) error = result;
+			}
+			if (bestMatch && bestMatch.result.success) return {
+				success: true,
+				next: {
+					...context,
+					buffer: bestMatch.result.next.buffer,
+					optionsTerminated: bestMatch.result.next.optionsTerminated,
+					state: [bestMatch.index, bestMatch.result]
+				},
+				consumed: bestMatch.result.consumed
+			};
+			return {
+				...error,
+				success: false
+			};
 		},
-		suggest: createExclusiveSuggest(parsers, isAsync),
+		suggest: createExclusiveSuggest(parsers),
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let footer;
@@ -476,61 +357,6 @@ function longestMatch(...args) {
 		}
 	};
 }
-/**
-* Internal sync helper for object suggest functionality.
-* @internal
-*/
-function* suggestObjectSync(context, prefix, parserPairs) {
-	if (context.buffer.length > 0) {
-		const lastToken = context.buffer[context.buffer.length - 1];
-		for (const [field, parser] of parserPairs) if (isOptionRequiringValue(parser.usage, lastToken)) {
-			const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-			yield* parser.suggest({
-				...context,
-				state: fieldState
-			}, prefix);
-			return;
-		}
-	}
-	const suggestions = [];
-	for (const [field, parser] of parserPairs) {
-		const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-		const fieldSuggestions = parser.suggest({
-			...context,
-			state: fieldState
-		}, prefix);
-		suggestions.push(...fieldSuggestions);
-	}
-	yield* require_suggestion.deduplicateSuggestions(suggestions);
-}
-/**
-* Internal async helper for object suggest functionality.
-* @internal
-*/
-async function* suggestObjectAsync(context, prefix, parserPairs) {
-	if (context.buffer.length > 0) {
-		const lastToken = context.buffer[context.buffer.length - 1];
-		for (const [field, parser] of parserPairs) if (isOptionRequiringValue(parser.usage, lastToken)) {
-			const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-			const suggestions$1 = parser.suggest({
-				...context,
-				state: fieldState
-			}, prefix);
-			for await (const s of suggestions$1) yield s;
-			return;
-		}
-	}
-	const suggestions = [];
-	for (const [field, parser] of parserPairs) {
-		const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-		const fieldSuggestions = parser.suggest({
-			...context,
-			state: fieldState
-		}, prefix);
-		for await (const s of fieldSuggestions) suggestions.push(s);
-	}
-	yield* require_suggestion.deduplicateSuggestions(suggestions);
-}
 function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
 	let parsers;
@@ -549,181 +375,131 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	for (const key of parserKeys) initialState[key] = parsers[key].initialState;
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parserPairs.map(([field, parser]) => [field, parser.usage]));
 	const noMatchContext = analyzeNoMatchContext(parserKeys.map((k) => parsers[k]));
-	const combinedMode = parserKeys.some((k) => parsers[k].$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const getInitialError = (context) => ({
-		consumed: 0,
-		error: context.buffer.length > 0 ? (() => {
-			const token = context.buffer[0];
-			const customMessage = options.errors?.unexpectedInput;
-			if (customMessage) return typeof customMessage === "function" ? customMessage(token) : customMessage;
-			const baseError = require_message.message`Unexpected option or argument: ${token}.`;
-			return require_suggestion.createErrorWithSuggestions(baseError, token, context.usage, "both", options.errors?.suggestions);
-		})() : (() => {
-			const customEndOfInput = options.errors?.endOfInput;
-			return customEndOfInput ? typeof customEndOfInput === "function" ? customEndOfInput(noMatchContext) : customEndOfInput : generateNoMatchError(noMatchContext);
-		})()
-	});
-	const parseSync = (context) => {
-		let error = getInitialError(context);
-		let currentContext = context;
-		let anySuccess = false;
-		const allConsumed = [];
-		let madeProgress = true;
-		while (madeProgress && currentContext.buffer.length > 0) {
-			madeProgress = false;
-			for (const [field, parser] of parserPairs) {
-				const result = parser.parse({
-					...currentContext,
-					state: currentContext.state && typeof currentContext.state === "object" && field in currentContext.state ? currentContext.state[field] : parser.initialState
-				});
-				if (result.success && result.consumed.length > 0) {
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: {
-							...currentContext.state,
-							[field]: result.next.state
-						}
-					};
-					allConsumed.push(...result.consumed);
-					anySuccess = true;
-					madeProgress = true;
-					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
-			}
-		}
-		if (anySuccess) return {
-			success: true,
-			next: currentContext,
-			consumed: allConsumed
-		};
-		if (context.buffer.length === 0) {
-			let allCanComplete = true;
-			for (const [field, parser] of parserPairs) {
-				const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-				const completeResult = parser.complete(fieldState);
-				if (!completeResult.success) {
-					allCanComplete = false;
-					break;
-				}
-			}
-			if (allCanComplete) return {
-				success: true,
-				next: context,
-				consumed: []
-			};
-		}
-		return {
-			...error,
-			success: false
-		};
-	};
-	const parseAsync = async (context) => {
-		let error = getInitialError(context);
-		let currentContext = context;
-		let anySuccess = false;
-		const allConsumed = [];
-		let madeProgress = true;
-		while (madeProgress && currentContext.buffer.length > 0) {
-			madeProgress = false;
-			for (const [field, parser] of parserPairs) {
-				const resultOrPromise = parser.parse({
-					...currentContext,
-					state: currentContext.state && typeof currentContext.state === "object" && field in currentContext.state ? currentContext.state[field] : parser.initialState
-				});
-				const result = await resultOrPromise;
-				if (result.success && result.consumed.length > 0) {
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: {
-							...currentContext.state,
-							[field]: result.next.state
-						}
-					};
-					allConsumed.push(...result.consumed);
-					anySuccess = true;
-					madeProgress = true;
-					break;
-				} else if (!result.success && error.consumed < result.consumed) error = result;
-			}
-		}
-		if (anySuccess) return {
-			success: true,
-			next: currentContext,
-			consumed: allConsumed
-		};
-		if (context.buffer.length === 0) {
-			let allCanComplete = true;
-			for (const [field, parser] of parserPairs) {
-				const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
-				const completeResult = await parser.complete(fieldState);
-				if (!completeResult.success) {
-					allCanComplete = false;
-					break;
-				}
-			}
-			if (allCanComplete) return {
-				success: true,
-				next: context,
-				consumed: []
-			};
-		}
-		return {
-			...error,
-			success: false
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parserKeys.map((k) => parsers[k].priority)),
 		usage: parserPairs.flatMap(([_, p]) => p.usage),
 		initialState,
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
-		},
-		complete(state) {
-			if (!isAsync) {
-				const result = {};
-				for (const field of parserKeys) {
-					const valueResult = parsers[field].complete(state[field]);
-					if (valueResult.success) result[field] = valueResult.value;
-					else return {
-						success: false,
-						error: valueResult.error
-					};
+			if (!options.allowDuplicates) {
+				const optionNameSources = /* @__PURE__ */ new Map();
+				for (const [field, parser] of parserPairs) {
+					const names = require_usage.extractOptionNames(parser.usage);
+					for (const name of names) {
+						if (!optionNameSources.has(name)) optionNameSources.set(name, []);
+						optionNameSources.get(name).push(field);
+					}
 				}
-				return {
-					success: true,
-					value: result
+				for (const [name, sources] of optionNameSources) if (sources.length > 1) return {
+					success: false,
+					consumed: 0,
+					error: require_message.message`Duplicate option name ${require_message.optionName(name)} found in fields: ${require_message.values(sources.map((s) => typeof s === "symbol" ? s.description ?? s.toString() : s))}. Each option name must be unique within a parser combinator.`
 				};
 			}
-			return (async () => {
-				const result = {};
-				for (const field of parserKeys) {
-					const valueResult = await parsers[field].complete(state[field]);
-					if (valueResult.success) result[field] = valueResult.value;
-					else return {
-						success: false,
-						error: valueResult.error
-					};
+			let error = {
+				consumed: 0,
+				error: context.buffer.length > 0 ? (() => {
+					const token = context.buffer[0];
+					const customMessage = options.errors?.unexpectedInput;
+					if (customMessage) return typeof customMessage === "function" ? customMessage(token) : customMessage;
+					const baseError = require_message.message`Unexpected option or argument: ${token}.`;
+					return require_suggestion.createErrorWithSuggestions(baseError, token, context.usage, "both", options.errors?.suggestions);
+				})() : (() => {
+					const customEndOfInput = options.errors?.endOfInput;
+					return customEndOfInput ? typeof customEndOfInput === "function" ? customEndOfInput(noMatchContext) : customEndOfInput : generateNoMatchError(noMatchContext);
+				})()
+			};
+			let currentContext = context;
+			let anySuccess = false;
+			const allConsumed = [];
+			let madeProgress = true;
+			while (madeProgress && currentContext.buffer.length > 0) {
+				madeProgress = false;
+				for (const [field, parser] of parserPairs) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state && typeof currentContext.state === "object" && field in currentContext.state ? currentContext.state[field] : parser.initialState
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: {
+								...currentContext.state,
+								[field]: result.next.state
+							}
+						};
+						allConsumed.push(...result.consumed);
+						anySuccess = true;
+						madeProgress = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
 				}
-				return {
+			}
+			if (anySuccess) return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+			if (context.buffer.length === 0) {
+				let allCanComplete = true;
+				for (const [field, parser] of parserPairs) {
+					const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+					const completeResult = parser.complete(fieldState);
+					if (!completeResult.success) {
+						allCanComplete = false;
+						break;
+					}
+				}
+				if (allCanComplete) return {
 					success: true,
-					value: result
+					next: context,
+					consumed: []
+				};
+			}
+			return {
+				...error,
+				success: false
+			};
+		},
+		complete(state) {
+			const result = {};
+			for (const field of parserKeys) {
+				const valueResult = parsers[field].complete(state[field]);
+				if (valueResult.success) result[field] = valueResult.value;
+				else return {
+					success: false,
+					error: valueResult.error
 				};
-			})();
+			}
+			return {
+				success: true,
+				value: result
+			};
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestObjectAsync(context, prefix, parserPairs);
-			const syncParserPairs = parserPairs;
-			return suggestObjectSync(context, prefix, syncParserPairs);
+			const suggestions = [];
+			if (context.buffer.length > 0) {
+				const lastToken = context.buffer[context.buffer.length - 1];
+				for (const [field, parser] of parserPairs) if (isOptionRequiringValue(parser.usage, lastToken)) {
+					const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+					return Array.from(parser.suggest({
+						...context,
+						state: fieldState
+					}, prefix));
+				}
+			}
+			for (const [field, parser] of parserPairs) {
+				const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+				const fieldSuggestions = parser.suggest({
+					...context,
+					state: fieldState
+				}, prefix);
+				suggestions.push(...fieldSuggestions);
+			}
+			return require_suggestion.deduplicateSuggestions(suggestions);
 		},
 		getDocFragments(state, defaultValue) {
 			const fragments = parserPairs.flatMap(([field, p]) => {
@@ -752,35 +528,6 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		}
 	};
 }
-function suggestTupleSync(context, prefix, parsers) {
-	const suggestions = [];
-	const stateArray = context.state;
-	for (let i = 0; i < parsers.length; i++) {
-		const parser = parsers[i];
-		const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-		const parserSuggestions = parser.suggest({
-			...context,
-			state: parserState
-		}, prefix);
-		suggestions.push(...parserSuggestions);
-	}
-	return require_suggestion.deduplicateSuggestions(suggestions);
-}
-async function* suggestTupleAsync(context, prefix, parsers) {
-	const suggestions = [];
-	const stateArray = context.state;
-	for (let i = 0; i < parsers.length; i++) {
-		const parser = parsers[i];
-		const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-		const parserSuggestions = parser.suggest({
-			...context,
-			state: parserState
-		}, prefix);
-		if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
-		else suggestions.push(...parserSuggestions);
-	}
-	yield* require_suggestion.deduplicateSuggestions(suggestions);
-}
 function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
 	let parsers;
@@ -792,187 +539,102 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		parsers = labelOrParsers;
 		options = maybeParsersOrOptions ?? {};
 	}
-	const combinedMode = parsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const syncParsers = parsers;
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parsers.map((parser, index) => [String(index), parser.usage]));
-	const parseSync = (context) => {
-		let currentContext = context;
-		const allConsumed = [];
-		const matchedParsers = /* @__PURE__ */ new Set();
-		while (matchedParsers.size < syncParsers.length) {
-			let foundMatch = false;
-			let error = {
-				consumed: 0,
-				error: require_message.message`No remaining parsers could match the input.`
-			};
-			const stateArray = currentContext.state;
-			const remainingParsers = syncParsers.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: stateArray[index]
-				});
-				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
-					};
-					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: stateArray[index]
-				});
-				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						state: newStateArray
-					};
-					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
-		};
-	};
-	const parseAsync = async (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 stateArray = currentContext.state;
-			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 resultOrPromise = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
-				const result = await resultOrPromise;
-				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
-					};
-					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 resultOrPromise = parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
-				const result = await resultOrPromise;
-				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						state: newStateArray
-					};
-					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
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		usage: parsers.toSorted((a, b) => b.priority - a.priority).flatMap((p) => p.usage),
 		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
 		initialState: parsers.map((parser) => parser.initialState),
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
-		},
-		complete(state) {
-			if (!isAsync) {
-				const result = [];
-				const stateArray = state;
-				for (let i = 0; i < syncParsers.length; i++) {
-					const valueResult = syncParsers[i].complete(stateArray[i]);
-					if (valueResult.success) result[i] = valueResult.value;
-					else return {
-						success: false,
-						error: valueResult.error
-					};
+			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;
 				}
-				return {
-					success: true,
-					value: 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 (async () => {
-				const result = [];
-				const stateArray = state;
-				for (let i = 0; i < parsers.length; i++) {
-					const valueResult = await parsers[i].complete(stateArray[i]);
-					if (valueResult.success) result[i] = valueResult.value;
-					else return {
-						success: false,
-						error: valueResult.error
-					};
-				}
-				return {
-					success: true,
-					value: result
+			return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+		},
+		complete(state) {
+			const result = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const valueResult = parsers[i].complete(state[i]);
+				if (valueResult.success) result[i] = valueResult.value;
+				else return {
+					success: false,
+					error: valueResult.error
 				};
-			})();
+			}
+			return {
+				success: true,
+				value: result
+			};
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestTupleAsync(context, prefix, parsers);
-			return suggestTupleSync(context, prefix, syncParsers);
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = context.state && Array.isArray(context.state) ? context.state[i] : parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			return require_suggestion.deduplicateSuggestions(suggestions);
 		},
 		getDocFragments(state, defaultValue) {
-			const fragments = syncParsers.flatMap((p, i) => {
+			const fragments = parsers.flatMap((p, i) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
 					kind: "available",
 					state: state.state[i]
@@ -1009,235 +671,127 @@ function merge(...args) {
 	const startIndex = typeof args[0] === "string" ? 1 : 0;
 	const endIndex = lastArg && typeof lastArg === "object" && !("parse" in lastArg) && !("complete" in lastArg) ? args.length - 1 : args.length;
 	const rawParsers = args.slice(startIndex, endIndex);
-	const combinedMode = rawParsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const syncRawParsers = rawParsers;
 	const withIndex = rawParsers.map((p, i) => [p, i]);
 	const sorted = withIndex.toSorted(([a], [b]) => b.priority - a.priority);
 	const parsers = sorted.map(([p]) => p);
-	const syncWithIndex = syncRawParsers.map((p, i) => [p, i]);
-	const syncSorted = syncWithIndex.toSorted(([a], [b]) => b.priority - a.priority);
-	const syncParsers = syncSorted.map(([p]) => p);
 	if (!options.allowDuplicates) checkDuplicateOptionNames(sorted.map(([parser, originalIndex]) => [String(originalIndex), parser.usage]));
 	const initialState = {};
 	for (const parser of parsers) if (parser.initialState && typeof parser.initialState === "object") for (const field in parser.initialState) initialState[field] = parser.initialState[field];
-	const extractParserState = (parser, context, index) => {
-		if (parser.initialState === void 0) {
-			const key = `__parser_${index}`;
-			if (context.state && typeof context.state === "object" && key in context.state) return context.state[key];
-			return void 0;
-		} else if (parser.initialState && typeof parser.initialState === "object") {
-			if (context.state && typeof context.state === "object") {
-				const extractedState = {};
-				for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
-				return extractedState;
-			}
-			return parser.initialState;
-		}
-		return parser.initialState;
-	};
-	const mergeResultState = (parser, context, result, index) => {
-		if (parser.initialState === void 0) {
-			const key = `__parser_${index}`;
-			if (result.success) {
-				if (result.consumed.length > 0 || result.next.state !== void 0) return {
-					...context.state,
-					[key]: result.next.state
-				};
-			}
-			return { ...context.state };
-		}
-		return result.success ? {
-			...context.state,
-			...result.next.state
-		} : { ...context.state };
-	};
-	const parseSync = (context) => {
-		let currentContext = context;
-		let zeroConsumedSuccess = null;
-		for (let i = 0; i < syncParsers.length; i++) {
-			const parser = syncParsers[i];
-			const parserState = extractParserState(parser, currentContext, i);
-			const result = parser.parse({
-				...currentContext,
-				state: parserState
-			});
-			if (result.success) {
-				const newState = mergeResultState(parser, currentContext, result, i);
-				const newContext = {
-					...currentContext,
-					buffer: result.next.buffer,
-					optionsTerminated: result.next.optionsTerminated,
-					state: newState
-				};
-				if (result.consumed.length > 0) return {
-					success: true,
-					next: newContext,
-					consumed: result.consumed
-				};
-				currentContext = newContext;
-				if (zeroConsumedSuccess === null) zeroConsumedSuccess = {
-					context: newContext,
-					consumed: []
-				};
-				else zeroConsumedSuccess.context = newContext;
-			} else if (result.consumed < 1) continue;
-			else return result;
-		}
-		if (zeroConsumedSuccess !== null) return {
-			success: true,
-			next: zeroConsumedSuccess.context,
-			consumed: zeroConsumedSuccess.consumed
-		};
-		return {
-			success: false,
-			consumed: 0,
-			error: require_message.message`No matching option or argument found.`
-		};
-	};
-	const parseAsync = async (context) => {
-		let currentContext = context;
-		let zeroConsumedSuccess = null;
-		for (let i = 0; i < parsers.length; i++) {
-			const parser = parsers[i];
-			const parserState = extractParserState(parser, currentContext, i);
-			const resultOrPromise = parser.parse({
-				...currentContext,
-				state: parserState
-			});
-			const result = await resultOrPromise;
-			if (result.success) {
-				const newState = mergeResultState(parser, currentContext, result, i);
-				const newContext = {
-					...currentContext,
-					buffer: result.next.buffer,
-					optionsTerminated: result.next.optionsTerminated,
-					state: newState
-				};
-				if (result.consumed.length > 0) return {
-					success: true,
-					next: newContext,
-					consumed: result.consumed
-				};
-				currentContext = newContext;
-				if (zeroConsumedSuccess === null) zeroConsumedSuccess = {
-					context: newContext,
-					consumed: []
-				};
-				else zeroConsumedSuccess.context = newContext;
-			} else if (result.consumed < 1) continue;
-			else return result;
-		}
-		if (zeroConsumedSuccess !== null) return {
-			success: true,
-			next: zeroConsumedSuccess.context,
-			consumed: zeroConsumedSuccess.consumed
-		};
-		return {
-			success: false,
-			consumed: 0,
-			error: require_message.message`No matching option or argument found.`
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
 		usage: parsers.flatMap((p) => p.usage),
 		initialState,
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
+			let zeroConsumedSuccess = null;
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
+				if (parser.initialState === void 0) {
+					const key = `__parser_${i}`;
+					if (context.state && typeof context.state === "object" && key in context.state) parserState = context.state[key];
+					else parserState = void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") if (context.state && typeof context.state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const result = parser.parse({
+					...context,
+					state: parserState
+				});
+				if (result.success) {
+					let newState;
+					if (parser.initialState === void 0) {
+						const key = `__parser_${i}`;
+						if (result.consumed.length > 0 || result.next.state !== void 0) newState = {
+							...context.state,
+							[key]: result.next.state
+						};
+						else newState = { ...context.state };
+					} else newState = {
+						...context.state,
+						...result.next.state
+					};
+					const newContext = {
+						...context,
+						buffer: result.next.buffer,
+						optionsTerminated: result.next.optionsTerminated,
+						state: newState
+					};
+					if (result.consumed.length > 0) return {
+						success: true,
+						next: newContext,
+						consumed: result.consumed
+					};
+					context = newContext;
+					if (zeroConsumedSuccess === null) zeroConsumedSuccess = {
+						context: newContext,
+						consumed: []
+					};
+					else zeroConsumedSuccess.context = newContext;
+				} else if (result.consumed < 1) continue;
+				else return result;
+			}
+			if (zeroConsumedSuccess !== null) return {
+				success: true,
+				next: zeroConsumedSuccess.context,
+				consumed: zeroConsumedSuccess.consumed
+			};
+			return {
+				success: false,
+				consumed: 0,
+				error: require_message.message`No matching option or argument found.`
+			};
 		},
 		complete(state) {
-			const extractCompleteState = (parser, index) => {
+			const object$1 = {};
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
 				if (parser.initialState === void 0) {
-					const key = `__parser_${index}`;
-					if (state && typeof state === "object" && key in state) return state[key];
-					return void 0;
-				} else if (parser.initialState && typeof parser.initialState === "object") {
-					if (state && typeof state === "object") {
-						const extractedState = {};
-						for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
-						return extractedState;
-					}
-					return parser.initialState;
-				}
-				return parser.initialState;
-			};
-			if (!isAsync) {
-				const object$1 = {};
-				for (let i = 0; i < syncParsers.length; i++) {
-					const parser = syncParsers[i];
-					const parserState = extractCompleteState(parser, i);
-					const result = parser.complete(parserState);
-					if (!result.success) return result;
-					for (const field in result.value) object$1[field] = result.value[field];
-				}
-				return {
-					success: true,
-					value: object$1
-				};
+					const key = `__parser_${i}`;
+					if (state && typeof state === "object" && key in state) parserState = state[key];
+					else parserState = void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") if (state && typeof state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const result = parser.complete(parserState);
+				if (!result.success) return result;
+				for (const field in result.value) object$1[field] = result.value[field];
 			}
-			return (async () => {
-				const object$1 = {};
-				for (let i = 0; i < parsers.length; i++) {
-					const parser = parsers[i];
-					const parserState = extractCompleteState(parser, i);
-					const result = await parser.complete(parserState);
-					if (!result.success) return result;
-					for (const field in result.value) object$1[field] = result.value[field];
-				}
-				return {
-					success: true,
-					value: object$1
-				};
-			})();
+			return {
+				success: true,
+				value: object$1
+			};
 		},
 		suggest(context, prefix) {
-			const extractState = (p, i) => {
-				if (p.initialState === void 0) {
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
+				if (parser.initialState === void 0) {
 					const key = `__parser_${i}`;
-					if (context.state && typeof context.state === "object" && key in context.state) return context.state[key];
-					return void 0;
-				} else if (p.initialState && typeof p.initialState === "object") {
-					if (context.state && typeof context.state === "object") {
-						const extractedState = {};
-						for (const field in p.initialState) extractedState[field] = field in context.state ? context.state[field] : p.initialState[field];
-						return extractedState;
-					}
-					return p.initialState;
-				}
-				return p.initialState;
-			};
-			if (isAsync) return async function* () {
-				const suggestions = [];
-				for (let i = 0; i < parsers.length; i++) {
-					const parser = parsers[i];
-					const parserState = extractState(parser, i);
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserState
-					}, prefix);
-					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
-					else suggestions.push(...parserSuggestions);
-				}
-				yield* require_suggestion.deduplicateSuggestions(suggestions);
-			}();
-			return function* () {
-				const suggestions = [];
-				for (let i = 0; i < syncParsers.length; i++) {
-					const parser = syncParsers[i];
-					const parserState = extractState(parser, i);
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserState
-					}, prefix);
-					suggestions.push(...parserSuggestions);
-				}
-				yield* require_suggestion.deduplicateSuggestions(suggestions);
-			}();
+					if (context.state && typeof context.state === "object" && key in context.state) parserState = context.state[key];
+					else parserState = void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") if (context.state && typeof context.state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			return require_suggestion.deduplicateSuggestions(suggestions);
 		},
 		getDocFragments(state, _defaultValue) {
 			const fragments = parsers.flatMap((p, i) => {
@@ -1284,213 +838,102 @@ function merge(...args) {
 	};
 }
 function concat(...parsers) {
-	const combinedMode = parsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
-	const syncParsers = parsers;
 	const initialState = parsers.map((parser) => parser.initialState);
-	const parseSync = (context) => {
-		let currentContext = context;
-		const allConsumed = [];
-		const matchedParsers = /* @__PURE__ */ new Set();
-		while (matchedParsers.size < syncParsers.length) {
-			let foundMatch = false;
-			let error = {
-				consumed: 0,
-				error: require_message.message`No remaining parsers could match the input.`
-			};
-			const stateArray = currentContext.state;
-			const remainingParsers = syncParsers.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: stateArray[index]
-				});
-				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
-					};
-					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: stateArray[index]
-				});
-				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						state: newStateArray
-					};
-					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
-		};
-	};
-	const parseAsync = async (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 stateArray = currentContext.state;
-			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 = await parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
-				if (result.success && result.consumed.length > 0) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						buffer: result.next.buffer,
-						optionsTerminated: result.next.optionsTerminated,
-						state: newStateArray
-					};
-					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 = await parser.parse({
-					...currentContext,
-					state: stateArray[index]
-				});
-				if (result.success && result.consumed.length < 1) {
-					const newStateArray = stateArray.map((s, idx) => idx === index ? result.next.state : s);
-					currentContext = {
-						...currentContext,
-						state: newStateArray
-					};
-					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
-		};
-	};
-	const completeSync = (state) => {
-		const results = [];
-		const stateArray = state;
-		for (let i = 0; i < syncParsers.length; i++) {
-			const parser = syncParsers[i];
-			const parserState = stateArray[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
-		};
-	};
-	const completeAsync = async (state) => {
-		const results = [];
-		const stateArray = state;
-		for (let i = 0; i < parsers.length; i++) {
-			const parser = parsers[i];
-			const parserState = stateArray[i];
-			const result = await 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
-		};
-	};
 	return {
-		$mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
 		usage: parsers.flatMap((p) => p.usage),
 		initialState,
 		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(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) {
-			if (isAsync) return completeAsync(state);
-			return completeSync(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
+			};
 		},
 		suggest(context, prefix) {
-			const stateArray = context.state;
-			if (isAsync) return async function* () {
-				const suggestions = [];
-				for (let i = 0; i < parsers.length; i++) {
-					const parser = parsers[i];
-					const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserState
-					}, prefix);
-					if (parser.$mode === "async") for await (const s of parserSuggestions) suggestions.push(s);
-					else suggestions.push(...parserSuggestions);
-				}
-				yield* require_suggestion.deduplicateSuggestions(suggestions);
-			}();
-			return function* () {
-				const suggestions = [];
-				for (let i = 0; i < syncParsers.length; i++) {
-					const parser = syncParsers[i];
-					const parserState = stateArray && Array.isArray(stateArray) ? stateArray[i] : parser.initialState;
-					const parserSuggestions = parser.suggest({
-						...context,
-						state: parserState
-					}, prefix);
-					suggestions.push(...parserSuggestions);
-				}
-				yield* require_suggestion.deduplicateSuggestions(suggestions);
-			}();
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = context.state && Array.isArray(context.state) ? context.state[i] : parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			return require_suggestion.deduplicateSuggestions(suggestions);
 		},
 		getDocFragments(state, _defaultValue) {
-			const fragments = syncParsers.flatMap((p, index) => {
+			const fragments = parsers.flatMap((p, index) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
 					kind: "available",
 					state: state.state[index]
@@ -1560,7 +1003,6 @@ function concat(...parsers) {
 */
 function group(label, parser) {
 	return {
-		$mode: parser.$mode,
 		$valueType: parser.$valueType,
 		$stateType: parser.$stateType,
 		priority: parser.priority,
@@ -1626,8 +1068,6 @@ function group(label, parser) {
 function conditional(discriminator, branches, defaultBranch, options) {
 	const branchParsers = Object.entries(branches);
 	const allBranchParsers = defaultBranch ? [...branchParsers.map(([_, p]) => p), defaultBranch] : branchParsers.map(([_, p]) => p);
-	const combinedMode = discriminator.$mode === "async" || allBranchParsers.some((p) => p.$mode === "async") ? "async" : "sync";
-	const isAsync = combinedMode === "async";
 	const maxPriority = Math.max(discriminator.priority, ...allBranchParsers.map((p) => p.priority));
 	function appendLiteralToUsage(usage$1, literalValue) {
 		const result = [];
@@ -1665,334 +1105,164 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		selectedBranch: void 0,
 		branchState: void 0
 	};
-	const getNoMatchError$1 = () => {
-		const noMatchContext = analyzeNoMatchContext([discriminator, ...allBranchParsers]);
-		return options?.errors?.noMatch ? typeof options.errors.noMatch === "function" ? options.errors.noMatch(noMatchContext) : options.errors.noMatch : generateNoMatchError(noMatchContext);
-	};
-	const parseSync = (context) => {
-		const state = context.state ?? initialState;
-		const syncDiscriminator = discriminator;
-		const syncBranches = branches;
-		const syncDefaultBranch = defaultBranch;
-		if (state.selectedBranch !== void 0) {
-			const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-			const branchResult = branchParser.parse({
-				...context,
-				state: state.branchState,
-				usage: branchParser.usage
-			});
-			if (branchResult.success) return {
-				success: true,
-				next: {
-					...branchResult.next,
-					state: {
-						...state,
-						branchState: branchResult.next.state
-					}
-				},
-				consumed: branchResult.consumed
-			};
-			return branchResult;
-		}
-		const discriminatorResult = syncDiscriminator.parse({
-			...context,
-			state: state.discriminatorState
-		});
-		if (discriminatorResult.success && discriminatorResult.consumed.length > 0) {
-			const completionResult = syncDiscriminator.complete(discriminatorResult.next.state);
-			if (completionResult.success) {
-				const value = completionResult.value;
-				const branchParser = syncBranches[value];
-				if (branchParser) {
-					const branchParseResult = branchParser.parse({
-						...context,
-						buffer: discriminatorResult.next.buffer,
-						optionsTerminated: discriminatorResult.next.optionsTerminated,
-						state: branchParser.initialState,
-						usage: branchParser.usage
-					});
-					if (branchParseResult.success) return {
-						success: true,
-						next: {
-							...branchParseResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
-								},
-								branchState: branchParseResult.next.state
-							}
-						},
-						consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
-					};
-					return {
-						success: true,
-						next: {
-							...discriminatorResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
-								},
-								branchState: branchParser.initialState
-							}
-						},
-						consumed: discriminatorResult.consumed
-					};
-				}
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: maxPriority,
+		usage,
+		initialState,
+		parse(context) {
+			const state = context.state ?? initialState;
+			if (state.selectedBranch !== void 0) {
+				const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+				const branchResult = branchParser.parse({
+					...context,
+					state: state.branchState,
+					usage: branchParser.usage
+				});
+				if (branchResult.success) return {
+					success: true,
+					next: {
+						...branchResult.next,
+						state: {
+							...state,
+							branchState: branchResult.next.state
+						}
+					},
+					consumed: branchResult.consumed
+				};
+				return branchResult;
 			}
-		}
-		if (syncDefaultBranch !== void 0) {
-			const defaultResult = syncDefaultBranch.parse({
-				...context,
-				state: state.branchState ?? syncDefaultBranch.initialState,
-				usage: syncDefaultBranch.usage
-			});
-			if (defaultResult.success && defaultResult.consumed.length > 0) return {
-				success: true,
-				next: {
-					...defaultResult.next,
-					state: {
-						...state,
-						selectedBranch: { kind: "default" },
-						branchState: defaultResult.next.state
-					}
-				},
-				consumed: defaultResult.consumed
-			};
-		}
-		return {
-			success: false,
-			consumed: 0,
-			error: getNoMatchError$1()
-		};
-	};
-	const parseAsync = async (context) => {
-		const state = context.state ?? initialState;
-		if (state.selectedBranch !== void 0) {
-			const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-			const branchResult = await branchParser.parse({
+			const discriminatorResult = discriminator.parse({
 				...context,
-				state: state.branchState,
-				usage: branchParser.usage
+				state: state.discriminatorState
 			});
-			if (branchResult.success) return {
-				success: true,
-				next: {
-					...branchResult.next,
-					state: {
-						...state,
-						branchState: branchResult.next.state
+			if (discriminatorResult.success && discriminatorResult.consumed.length > 0) {
+				const completionResult = discriminator.complete(discriminatorResult.next.state);
+				if (completionResult.success) {
+					const value = completionResult.value;
+					const branchParser = branches[value];
+					if (branchParser) {
+						const branchParseResult = branchParser.parse({
+							...context,
+							buffer: discriminatorResult.next.buffer,
+							optionsTerminated: discriminatorResult.next.optionsTerminated,
+							state: branchParser.initialState,
+							usage: branchParser.usage
+						});
+						if (branchParseResult.success) return {
+							success: true,
+							next: {
+								...branchParseResult.next,
+								state: {
+									discriminatorState: discriminatorResult.next.state,
+									discriminatorValue: value,
+									selectedBranch: {
+										kind: "branch",
+										key: value
+									},
+									branchState: branchParseResult.next.state
+								}
+							},
+							consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
+						};
+						return {
+							success: true,
+							next: {
+								...discriminatorResult.next,
+								state: {
+									discriminatorState: discriminatorResult.next.state,
+									discriminatorValue: value,
+									selectedBranch: {
+										kind: "branch",
+										key: value
+									},
+									branchState: branchParser.initialState
+								}
+							},
+							consumed: discriminatorResult.consumed
+						};
 					}
-				},
-				consumed: branchResult.consumed
-			};
-			return branchResult;
-		}
-		const discriminatorResult = await discriminator.parse({
-			...context,
-			state: state.discriminatorState
-		});
-		if (discriminatorResult.success && discriminatorResult.consumed.length > 0) {
-			const completionResult = await discriminator.complete(discriminatorResult.next.state);
-			if (completionResult.success) {
-				const value = completionResult.value;
-				const branchParser = branches[value];
-				if (branchParser) {
-					const branchParseResult = await branchParser.parse({
-						...context,
-						buffer: discriminatorResult.next.buffer,
-						optionsTerminated: discriminatorResult.next.optionsTerminated,
-						state: branchParser.initialState,
-						usage: branchParser.usage
-					});
-					if (branchParseResult.success) return {
-						success: true,
-						next: {
-							...branchParseResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
-								},
-								branchState: branchParseResult.next.state
-							}
-						},
-						consumed: [...discriminatorResult.consumed, ...branchParseResult.consumed]
-					};
-					return {
-						success: true,
-						next: {
-							...discriminatorResult.next,
-							state: {
-								discriminatorState: discriminatorResult.next.state,
-								discriminatorValue: value,
-								selectedBranch: {
-									kind: "branch",
-									key: value
-								},
-								branchState: branchParser.initialState
-							}
-						},
-						consumed: discriminatorResult.consumed
-					};
 				}
 			}
-		}
-		if (defaultBranch !== void 0) {
-			const defaultResult = await defaultBranch.parse({
-				...context,
-				state: state.branchState ?? defaultBranch.initialState,
-				usage: defaultBranch.usage
-			});
-			if (defaultResult.success && defaultResult.consumed.length > 0) return {
-				success: true,
-				next: {
-					...defaultResult.next,
-					state: {
-						...state,
-						selectedBranch: { kind: "default" },
-						branchState: defaultResult.next.state
-					}
-				},
-				consumed: defaultResult.consumed
-			};
-		}
-		return {
-			success: false,
-			consumed: 0,
-			error: getNoMatchError$1()
-		};
-	};
-	const completeSync = (state) => {
-		const syncDefaultBranch = defaultBranch;
-		const syncBranches = branches;
-		if (state.selectedBranch === void 0) {
-			if (syncDefaultBranch !== void 0) {
-				const branchState = state.branchState ?? syncDefaultBranch.initialState;
-				const defaultResult = syncDefaultBranch.complete(branchState);
-				if (!defaultResult.success) return defaultResult;
-				return {
+			if (defaultBranch !== void 0) {
+				const defaultResult = defaultBranch.parse({
+					...context,
+					state: state.branchState ?? defaultBranch.initialState,
+					usage: defaultBranch.usage
+				});
+				if (defaultResult.success && defaultResult.consumed.length > 0) return {
 					success: true,
-					value: [void 0, defaultResult.value]
+					next: {
+						...defaultResult.next,
+						state: {
+							...state,
+							selectedBranch: { kind: "default" },
+							branchState: defaultResult.next.state
+						}
+					},
+					consumed: defaultResult.consumed
 				};
 			}
+			const noMatchContext = analyzeNoMatchContext([discriminator, ...allBranchParsers]);
+			const errorMessage = options?.errors?.noMatch ? typeof options.errors.noMatch === "function" ? options.errors.noMatch(noMatchContext) : options.errors.noMatch : generateNoMatchError(noMatchContext);
 			return {
 				success: false,
-				error: require_message.message`Missing required discriminator option.`
-			};
-		}
-		const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-		const branchResult = branchParser.complete(state.branchState);
-		if (!branchResult.success) {
-			if (state.discriminatorValue !== void 0 && options?.errors?.branchError) return {
-				success: false,
-				error: options.errors.branchError(state.discriminatorValue, branchResult.error)
+				consumed: 0,
+				error: errorMessage
 			};
-			return branchResult;
-		}
-		const discriminatorValue = state.selectedBranch.kind === "default" ? void 0 : state.selectedBranch.key;
-		return {
-			success: true,
-			value: [discriminatorValue, branchResult.value]
-		};
-	};
-	const completeAsync = async (state) => {
-		if (state.selectedBranch === void 0) {
-			if (defaultBranch !== void 0) {
-				const branchState = state.branchState ?? defaultBranch.initialState;
-				const defaultResult = await defaultBranch.complete(branchState);
-				if (!defaultResult.success) return defaultResult;
+		},
+		complete(state) {
+			if (state.selectedBranch === void 0) {
+				if (defaultBranch !== void 0) {
+					const branchState = state.branchState ?? defaultBranch.initialState;
+					const defaultResult = defaultBranch.complete(branchState);
+					if (!defaultResult.success) return defaultResult;
+					return {
+						success: true,
+						value: [void 0, defaultResult.value]
+					};
+				}
 				return {
-					success: true,
-					value: [void 0, defaultResult.value]
+					success: false,
+					error: require_message.message`Missing required discriminator option.`
+				};
+			}
+			const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+			const branchResult = branchParser.complete(state.branchState);
+			if (!branchResult.success) {
+				if (state.discriminatorValue !== void 0 && options?.errors?.branchError) return {
+					success: false,
+					error: options.errors.branchError(state.discriminatorValue, branchResult.error)
 				};
+				return branchResult;
 			}
+			const discriminatorValue = state.selectedBranch.kind === "default" ? void 0 : state.selectedBranch.key;
 			return {
-				success: false,
-				error: require_message.message`Missing required discriminator option.`
-			};
-		}
-		const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-		const branchResult = await branchParser.complete(state.branchState);
-		if (!branchResult.success) {
-			if (state.discriminatorValue !== void 0 && options?.errors?.branchError) return {
-				success: false,
-				error: options.errors.branchError(state.discriminatorValue, branchResult.error)
+				success: true,
+				value: [discriminatorValue, branchResult.value]
 			};
-			return branchResult;
-		}
-		const discriminatorValue = state.selectedBranch.kind === "default" ? void 0 : state.selectedBranch.key;
-		return {
-			success: true,
-			value: [discriminatorValue, branchResult.value]
-		};
-	};
-	function* suggestSync(context, prefix) {
-		const state = context.state ?? initialState;
-		const syncDiscriminator = discriminator;
-		const syncBranches = branches;
-		const syncDefaultBranch = defaultBranch;
-		if (state.selectedBranch === void 0) {
-			yield* syncDiscriminator.suggest({
-				...context,
-				state: state.discriminatorState
-			}, prefix);
-			if (syncDefaultBranch !== void 0) yield* syncDefaultBranch.suggest({
-				...context,
-				state: state.branchState ?? syncDefaultBranch.initialState
-			}, prefix);
-		} else {
-			const branchParser = state.selectedBranch.kind === "default" ? syncDefaultBranch : syncBranches[state.selectedBranch.key];
-			yield* branchParser.suggest({
-				...context,
-				state: state.branchState
-			}, prefix);
-		}
-	}
-	async function* suggestAsync(context, prefix) {
-		const state = context.state ?? initialState;
-		if (state.selectedBranch === void 0) {
-			yield* discriminator.suggest({
-				...context,
-				state: state.discriminatorState
-			}, prefix);
-			if (defaultBranch !== void 0) yield* defaultBranch.suggest({
-				...context,
-				state: state.branchState ?? defaultBranch.initialState
-			}, prefix);
-		} else {
-			const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
-			yield* branchParser.suggest({
-				...context,
-				state: state.branchState
-			}, prefix);
-		}
-	}
-	return {
-		$mode: combinedMode,
-		$valueType: [],
-		$stateType: [],
-		priority: maxPriority,
-		usage,
-		initialState,
-		parse(context) {
-			if (isAsync) return parseAsync(context);
-			return parseSync(context);
-		},
-		complete(state) {
-			if (isAsync) return completeAsync(state);
-			return completeSync(state);
 		},
 		suggest(context, prefix) {
-			if (isAsync) return suggestAsync(context, prefix);
-			return suggestSync(context, prefix);
+			const state = context.state ?? initialState;
+			const suggestions = [];
+			if (state.selectedBranch === void 0) {
+				suggestions.push(...discriminator.suggest({
+					...context,
+					state: state.discriminatorState
+				}, prefix));
+				if (defaultBranch !== void 0) suggestions.push(...defaultBranch.suggest({
+					...context,
+					state: state.branchState ?? defaultBranch.initialState
+				}, prefix));
+			} else {
+				const branchParser = state.selectedBranch.kind === "default" ? defaultBranch : branches[state.selectedBranch.key];
+				suggestions.push(...branchParser.suggest({
+					...context,
+					state: state.branchState
+				}, prefix));
+			}
+			return require_suggestion.deduplicateSuggestions(suggestions);
 		},
 		getDocFragments(_state, _defaultValue) {
 			const fragments = [];