@optique/core 0.9.0-dev.196 → 0.9.0-dev.202

package/dist/constructs.cjs

@@ -116,45 +116,79 @@ function generateNoMatchError(context) {
 * Creates a complete() method shared by or() and longestMatch().
 * @internal
 */
-function createExclusiveComplete(parsers, options, noMatchContext) {
+function createExclusiveComplete(parsers, options, noMatchContext, isAsync) {
+	const syncParsers = parsers;
 	return (state) => {
 		if (state == null) return {
 			success: false,
 			error: getNoMatchError(options, noMatchContext)
 		};
 		const [i, result] = state;
-		if (result.success) return parsers[i].complete(result.next.state);
-		return {
+		if (!result.success) 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) {
+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);
+		}();
+	};
 	return (context, prefix) => {
-		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({
+		return function* () {
+			const suggestions = [];
+			if (context.state == null) for (const parser of syncParsers) {
+				const parserSuggestions = parser.suggest({
 					...context,
-					state: parserResult.next.state
+					state: parser.initialState
 				}, prefix);
 				suggestions.push(...parserSuggestions);
 			}
-		}
-		return require_suggestion.deduplicateSuggestions(suggestions);
+			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);
+		}();
 	};
 }
 /**
@@ -190,7 +224,80 @@ 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)),
@@ -199,43 +306,12 @@ function or(...args) {
 			terms: parsers.map((p) => p.usage)
 		}],
 		initialState: void 0,
-		complete: createExclusiveComplete(parsers, options, noMatchContext),
+		complete: createExclusiveComplete(parsers, options, noMatchContext, isAsync),
 		parse(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
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
-		suggest: createExclusiveSuggest(parsers),
+		suggest: createExclusiveSuggest(parsers, isAsync),
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let fragments;
@@ -284,7 +360,82 @@ 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)),
@@ -293,44 +444,12 @@ function longestMatch(...args) {
 			terms: parsers.map((p) => p.usage)
 		}],
 		initialState: void 0,
-		complete: createExclusiveComplete(parsers, options, noMatchContext),
+		complete: createExclusiveComplete(parsers, options, noMatchContext, isAsync),
 		parse(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
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
-		suggest: createExclusiveSuggest(parsers),
+		suggest: createExclusiveSuggest(parsers, isAsync),
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let footer;
@@ -356,6 +475,61 @@ 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;
@@ -371,117 +545,185 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	parserPairs.sort(([_, parserA], [__, parserB]) => parserB.priority - parserA.priority);
 	if (!options.allowDuplicates) checkDuplicateOptionNames(parserPairs.map(([field, parser]) => [field, parser.usage]));
 	const noMatchContext = analyzeNoMatchContext(Object.values(parsers));
-	return {
-		$valueType: [],
-		$stateType: [],
-		priority: Math.max(...Object.values(parsers).map((p) => p.priority)),
-		usage: parserPairs.flatMap(([_, p]) => p.usage),
-		initialState: Object.fromEntries(Object.entries(parsers).map(([key, parser]) => [key, parser.initialState])),
-		parse(context) {
-			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({
+	const combinedMode = Object.values(parsers).some((p) => p.$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,
-						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;
+						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 (anySuccess) return {
+			if (allCanComplete) return {
 				success: true,
-				next: currentContext,
-				consumed: allConsumed
+				next: context,
+				consumed: []
 			};
-			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;
-					}
+		}
+		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
+			if (allCanComplete) return {
+				success: true,
+				next: context,
+				consumed: []
 			};
+		}
+		return {
+			...error,
+			success: false
+		};
+	};
+	return {
+		$mode: combinedMode,
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...Object.values(parsers).map((p) => p.priority)),
+		usage: parserPairs.flatMap(([_, p]) => p.usage),
+		initialState: Object.fromEntries(Object.entries(parsers).map(([key, parser]) => [key, parser.initialState])),
+		parse(context) {
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
 		complete(state) {
-			const result = {};
-			for (const field in state) {
-				if (!(field in parsers)) continue;
-				const valueResult = parsers[field].complete(state[field]);
-				if (valueResult.success) result[field] = valueResult.value;
-				else return {
-					success: false,
-					error: valueResult.error
+			if (!isAsync) {
+				const result = {};
+				const stateRecord = state;
+				for (const field in stateRecord) {
+					if (!(field in parsers)) continue;
+					const valueResult = parsers[field].complete(stateRecord[field]);
+					if (valueResult.success) result[field] = valueResult.value;
+					else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return {
+					success: true,
+					value: result
 				};
 			}
-			return {
-				success: true,
-				value: result
-			};
+			return (async () => {
+				const result = {};
+				const stateRecord = state;
+				for (const field in stateRecord) {
+					if (!(field in parsers)) continue;
+					const valueResult = await parsers[field].complete(stateRecord[field]);
+					if (valueResult.success) result[field] = valueResult.value;
+					else return {
+						success: false,
+						error: valueResult.error
+					};
+				}
+				return {
+					success: true,
+					value: result
+				};
+			})();
 		},
 		suggest(context, prefix) {
-			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);
+			if (isAsync) return suggestObjectAsync(context, prefix, parserPairs);
+			const syncParserPairs = parserPairs;
+			return suggestObjectSync(context, prefix, syncParserPairs);
 		},
 		getDocFragments(state, defaultValue) {
 			const fragments = parserPairs.flatMap(([field, p]) => {
@@ -510,6 +752,35 @@ 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;
@@ -521,102 +792,187 @@ 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) {
-			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
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
 		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
+			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
+					};
+				}
+				return {
+					success: true,
+					value: result
 				};
 			}
-			return {
-				success: true,
-				value: result
-			};
+			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
+				};
+			})();
 		},
 		suggest(context, prefix) {
-			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);
+			if (isAsync) return suggestTupleAsync(context, prefix, parsers);
+			return suggestTupleSync(context, prefix, syncParsers);
 		},
 		getDocFragments(state, defaultValue) {
-			const fragments = parsers.flatMap((p, i) => {
+			const fragments = syncParsers.flatMap((p, i) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
 					kind: "available",
 					state: state.state[i]
@@ -653,131 +1009,247 @@ 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) {
-			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.`
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
 		complete(state) {
-			const object$1 = {};
-			for (let i = 0; i < parsers.length; i++) {
-				const parser = parsers[i];
-				let parserState;
+			const extractCompleteState = (parser, index) => {
 				if (parser.initialState === void 0) {
-					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 {
-				success: true,
-				value: object$1
+					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
+				};
+			}
+			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
+				};
+			})();
 		},
 		suggest(context, prefix) {
-			const suggestions = [];
-			for (let i = 0; i < parsers.length; i++) {
-				const parser = parsers[i];
-				let parserState;
-				if (parser.initialState === void 0) {
+			const extractState = (p, i) => {
+				if (p.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 parserSuggestions = parser.suggest({
-					...context,
-					state: parserState
-				}, prefix);
-				suggestions.push(...parserSuggestions);
-			}
-			return require_suggestion.deduplicateSuggestions(suggestions);
+					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);
+			}();
 		},
 		getDocFragments(state, _defaultValue) {
-			const fragments = parsers.flatMap((p) => {
-				const parserState = p.initialState === void 0 ? { kind: "unavailable" } : state.kind === "unavailable" ? { kind: "unavailable" } : {
+			const fragments = parsers.flatMap((p, i) => {
+				let parserState;
+				if (p.initialState === void 0) {
+					const key = `__parser_${i}`;
+					if (state.kind === "available" && state.state && typeof state.state === "object" && key in state.state) parserState = {
+						kind: "available",
+						state: state.state[key]
+					};
+					else parserState = { kind: "unavailable" };
+				} else parserState = state.kind === "unavailable" ? { kind: "unavailable" } : {
 					kind: "available",
 					state: state.state
 				};
@@ -812,102 +1284,213 @@ 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) {
-			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
-			};
+			if (isAsync) return parseAsync(context);
+			return parseSync(context);
 		},
 		complete(state) {
-			const results = [];
-			for (let i = 0; i < parsers.length; i++) {
-				const parser = parsers[i];
-				const parserState = state[i];
-				const result = parser.complete(parserState);
-				if (!result.success) return result;
-				if (Array.isArray(result.value)) results.push(...result.value);
-				else results.push(result.value);
-			}
-			return {
-				success: true,
-				value: results
-			};
+			if (isAsync) return completeAsync(state);
+			return completeSync(state);
 		},
 		suggest(context, prefix) {
-			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);
+			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);
+			}();
 		},
 		getDocFragments(state, _defaultValue) {
-			const fragments = parsers.flatMap((p, index) => {
+			const fragments = syncParsers.flatMap((p, index) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
 					kind: "available",
 					state: state.state[index]
@@ -977,6 +1560,7 @@ function concat(...parsers) {
 */
 function group(label, parser) {
 	return {
+		$mode: parser.$mode,
 		$valueType: parser.$valueType,
 		$stateType: parser.$stateType,
 		priority: parser.priority,
@@ -1042,6 +1626,8 @@ 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 = [];
@@ -1079,164 +1665,334 @@ function conditional(discriminator, branches, defaultBranch, options) {
 		selectedBranch: void 0,
 		branchState: void 0
 	};
-	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;
-			}
-			const discriminatorResult = discriminator.parse({
+	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.discriminatorState
+				state: state.branchState,
+				usage: branchParser.usage
 			});
-			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
-						};
+			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
+					};
 				}
 			}
-			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,
-					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,
-				consumed: 0,
-				error: errorMessage
+		}
+		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
 			};
-		},
-		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: 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({
+				...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 = 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,
-						value: [void 0, defaultResult.value]
+						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 {
-					success: false,
-					error: require_message.message`Missing required discriminator option.`
+					success: true,
+					value: [void 0, defaultResult.value]
 				};
 			}
-			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 {
+				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)
+			};
+			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;
+				return {
+					success: true,
+					value: [void 0, defaultResult.value]
 				};
-				return branchResult;
 			}
-			const discriminatorValue = state.selectedBranch.kind === "default" ? void 0 : state.selectedBranch.key;
 			return {
-				success: true,
-				value: [discriminatorValue, branchResult.value]
+				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)
+			};
+			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) {
-			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);
+			if (isAsync) return suggestAsync(context, prefix);
+			return suggestSync(context, prefix);
 		},
 		getDocFragments(_state, _defaultValue) {
 			const fragments = [];