@optique/core 1.0.5 → 1.0.7

package/dist/constructs.cjs

@@ -77,8 +77,8 @@ function unionLeadingNames(parsers) {
 * Computes `leadingNames` for shared-buffer compositions (`tuple()`,
 * `object()`, `merge()`, `concat()`).
 *
-* Children are processed in descending priority order (matching the
-* round-robin parse loop).  Once a child with `acceptingAnyToken` is
+* Sources are processed in descending priority order (matching the
+* round-robin parse loop).  Once a source with `acceptingAnyToken` is
 * encountered, no lower-priority children can match at position 0, so
 * their names are excluded.
 */
@@ -1448,6 +1448,33 @@ function longestMatch(...args) {
 	return multiResult;
 }
 /**
+* Creates the initial parse error shared by object-like combinators.
+* @param context The current parser context.
+* @param noMatchContext The kinds of input accepted by the combinator.
+* @param errors Optional custom error formatters.
+* @returns A zero-consumption parse error.
+*/
+function createObjectLikeInitialError(context, noMatchContext, errors) {
+	if (context.buffer.length < 1) {
+		const customEndOfInput = errors?.endOfInput;
+		return {
+			consumed: 0,
+			error: customEndOfInput ? typeof customEndOfInput === "function" ? customEndOfInput(noMatchContext) : customEndOfInput : generateNoMatchError(noMatchContext)
+		};
+	}
+	const token = context.buffer[0];
+	const customMessage = errors?.unexpectedInput;
+	if (customMessage) return {
+		consumed: 0,
+		error: typeof customMessage === "function" ? customMessage(token) : customMessage
+	};
+	const baseError = require_message.message`Unexpected option or argument: ${token}.`;
+	return {
+		consumed: 0,
+		error: require_suggestion.createErrorWithSuggestions(baseError, token, context.usage, "both", errors?.suggestions)
+	};
+}
+/**
 * Internal sync helper for object suggest functionality.
 * @internal
 */
@@ -1839,19 +1866,53 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	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 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 getInitialError = (context) => createObjectLikeInitialError(context, noMatchContext, options.errors);
+	const adaptFieldLaneResult = (context, field, parser, fieldState, result) => {
+		if (!result.success) return result;
+		if (result.consumed.length === 0 && result.next.state === fieldState) return {
+			success: true,
+			next: context,
+			consumed: []
+		};
+		const mergedExec = require_execution_context.mergeChildExec(context.exec, result.next.exec);
+		const nextState = result.next.state === fieldState ? context.state : {
+			...context.state,
+			[field]: require_annotation_state.getWrappedChildState(context.state, result.next.state, parser)
+		};
+		return {
+			success: true,
+			next: {
+				...context,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: nextState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			},
+			consumed: result.consumed
+		};
+	};
+	const objectZeroConsumptionGroup = {};
+	const objectParseLanes = parserPairs.map(([field, parser]) => ({
+		priority: parser.priority,
+		zeroConsumptionGroup: objectZeroConsumptionGroup,
+		settlesZeroConsumption: false,
+		leadingNames: parser.leadingNames,
+		acceptingAnyToken: parser.acceptingAnyToken,
+		parse(context) {
+			const fieldState = createFieldStateGetter(context.state, getObjectParseChildState)(field, parser);
+			return require_mode_dispatch.dispatchByMode(combinedMode, () => {
+				const result = parser.parse(withChildContext$1(context, field, fieldState, parser));
+				return adaptFieldLaneResult(context, field, parser, fieldState, result);
+			}, async () => {
+				const result = await parser.parse(withChildContext$1(context, field, fieldState, parser));
+				return adaptFieldLaneResult(context, field, parser, fieldState, result);
+			});
+		}
+	}));
 	const parseSync = (context) => {
 		let error = getInitialError(context);
 		let currentContext = context;
@@ -2345,6 +2406,7 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		configurable: true,
 		enumerable: false
 	});
+	require_parser.defineParseLanes(objectParser, objectParseLanes);
 	require_parser.defineInheritedAnnotationParser(objectParser);
 	return objectParser;
 }
@@ -3000,6 +3062,7 @@ function merge(...args) {
 	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 noMatchContext = analyzeNoMatchContext(rawParsers);
 	const mergedFieldParsers = collectChildFieldParsers(parsers);
 	const duplicateOutputFieldNames = collectDuplicateFieldNames(mergedFieldParsers);
 	const parserStateKey = (index) => `__parser_${index}`;
@@ -3011,17 +3074,17 @@ function merge(...args) {
 		if (parser.initialState === void 0) initialState[parserStateKey(i)] = void 0;
 		else if (parser.initialState && typeof parser.initialState === "object") for (const field in parser.initialState) initialState[field] = parser.initialState[field];
 	}
-	const extractParserState = (parser, context, index) => {
+	const extractParserState = (parser, state, index) => {
 		if (parser.initialState === void 0) {
 			const key = parserStateKey(index);
-			if (context.state && typeof context.state === "object" && key in context.state) return context.state[key];
+			if (state && typeof state === "object" && key in state) return state[key];
 			return void 0;
 		} else if (parser.initialState && typeof parser.initialState === "object") {
 			const localStateKey = localObjectStateKey(index);
-			if (shouldPreserveLocalChildState(parser) && context.state && typeof context.state === "object" && localStateKey in context.state) return context.state[localStateKey];
-			if (context.state && typeof context.state === "object") {
+			if (shouldPreserveLocalChildState(parser) && state && typeof state === "object" && localStateKey in state) return state[localStateKey];
+			if (state && typeof state === "object") {
 				const extractedState = {};
-				for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+				for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
 				return extractedState;
 			}
 			return parser.initialState;
@@ -3051,12 +3114,145 @@ function merge(...args) {
 			[localObjectStateKey(index)]: result.next.state
 		};
 	};
-	const parseSync = (context) => {
+	const adaptMergeLaneResult = (parser, context, parserState, parsedState, result, index) => {
+		if (!result.success) return result;
+		const mergedExec = require_execution_context.mergeChildExec(context.exec, result.next.exec);
+		const newState = result.next.state === parsedState ? context.state : mergeResultState(parser, context, parserState, result, index);
+		return {
+			success: true,
+			next: {
+				...context,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: newState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			},
+			consumed: result.consumed
+		};
+	};
+	const childrenInDeclarationOrder = sorted.map(([parser, originalIndex], sortedIndex) => ({
+		parser,
+		originalIndex,
+		sortedIndex
+	})).toSorted((a, b) => a.originalIndex - b.originalIndex);
+	const mergeParseLanes = childrenInDeclarationOrder.flatMap(({ parser, sortedIndex }) => {
+		const occurrenceConsumptionGroups = /* @__PURE__ */ new WeakMap();
+		const occurrenceZeroConsumptionGroups = /* @__PURE__ */ new WeakMap();
+		const scopeConsumptionGroup = (group$1) => {
+			const existing = occurrenceConsumptionGroups.get(group$1);
+			if (existing != null) return existing;
+			const scoped = {};
+			occurrenceConsumptionGroups.set(group$1, scoped);
+			return scoped;
+		};
+		const childLanes = require_parser.getOwnParseLanes(parser);
+		const lanes = childLanes ?? [{
+			priority: parser.priority,
+			leadingNames: parser.leadingNames,
+			acceptingAnyToken: parser.acceptingAnyToken,
+			parse(context) {
+				return parser.parse(context);
+			}
+		}];
+		return lanes.map((lane) => ({
+			priority: lane.priority,
+			zeroConsumptionGroup: (() => {
+				const group$1 = lane.zeroConsumptionGroup ?? lane;
+				const existing = occurrenceZeroConsumptionGroups.get(group$1);
+				if (existing != null) return existing;
+				const scoped = {};
+				occurrenceZeroConsumptionGroups.set(group$1, scoped);
+				return scoped;
+			})(),
+			settlesZeroConsumption: lane.settlesZeroConsumption,
+			leadingNames: lane.leadingNames,
+			acceptingAnyToken: lane.acceptingAnyToken,
+			requiredConsumptionGroups: lane.requiredConsumptionGroups?.map((group$1) => ({
+				id: scopeConsumptionGroup(group$1.id),
+				...group$1.isActive == null ? {} : { isActive(state) {
+					if (state == null || typeof state !== "object") return false;
+					const parserState = extractParserState(parser, state, sortedIndex);
+					return group$1.isActive?.(parserState) ?? true;
+				} }
+			})),
+			parse(context) {
+				const parserState = extractParserState(parser, context.state, sortedIndex);
+				const childContext = withChildContext$1(context, sortedIndex, parserState, parser);
+				return require_mode_dispatch.dispatchByMode(combinedMode, () => {
+					const result = lane.parse(childContext);
+					return adaptMergeLaneResult(parser, context, parserState, childContext.state, result, sortedIndex);
+				}, async () => {
+					const result = await lane.parse(childContext);
+					return adaptMergeLaneResult(parser, context, parserState, childContext.state, result, sortedIndex);
+				});
+			}
+		}));
+	}).toSorted((a, b) => b.priority - a.priority);
+	const settleZeroConsumptionLanes = (context, laneResults) => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const lane of mergeParseLanes) {
+			const group$1 = lane.zeroConsumptionGroup ?? lane;
+			const groupedLanes = groups.get(group$1);
+			if (groupedLanes == null) groups.set(group$1, [lane]);
+			else groupedLanes.push(lane);
+		}
+		const settledGroups = [];
+		for (const groupedLanes of groups.values()) {
+			const groupSucceeded = groupedLanes.every((lane) => {
+				const result = laneResults.get(lane);
+				return lane.settlesZeroConsumption !== false && result?.success === true && result.consumed.length === 0 && (lane.requiredConsumptionGroups?.length ?? 0) === 0;
+			});
+			if (!groupSucceeded) return null;
+			settledGroups.push(groupedLanes);
+		}
+		let settledContext = context;
+		for (const groupedLanes of settledGroups) for (const lane of groupedLanes) {
+			const result = laneResults.get(lane);
+			if (result?.success !== true) continue;
+			const originalState = context.state;
+			const resultState = result.next.state;
+			const nextState = { ...settledContext.state };
+			const stateKeys = new Set([...Reflect.ownKeys(originalState), ...Reflect.ownKeys(resultState)]);
+			for (const key of stateKeys) {
+				const originalHasKey = Object.hasOwn(originalState, key);
+				const resultHasKey = Object.hasOwn(resultState, key);
+				if (originalHasKey === resultHasKey && originalState[key] === resultState[key]) continue;
+				if (resultHasKey) nextState[key] = resultState[key];
+				else delete nextState[key];
+			}
+			const mergedExec = require_execution_context.mergeChildExec(settledContext.exec, result.next.exec);
+			settledContext = {
+				...settledContext,
+				buffer: result.next.buffer,
+				optionsTerminated: result.next.optionsTerminated,
+				state: nextState,
+				...mergedExec != null ? {
+					trace: mergedExec.trace,
+					exec: mergedExec,
+					dependencyRegistry: mergedExec.dependencyRegistry
+				} : {}
+			};
+		}
+		return {
+			success: true,
+			next: settledContext,
+			consumed: []
+		};
+	};
+	const canTryPositionalLaneAfterFailure = (lane, context) => {
+		const token = context.buffer[0];
+		return token != null && (context.optionsTerminated || !token.startsWith("-")) && (lane.acceptingAnyToken || lane.leadingNames.has(token));
+	};
+	const parseChildrenSync = (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 parserState = extractParserState(parser, currentContext.state, i);
 			const result = parser.parse(withChildContext$1(currentContext, i, parserState, parser));
 			if (result.success) {
 				const mergedExec = require_execution_context.mergeChildExec(currentContext.exec, result.next.exec);
@@ -3092,16 +3288,15 @@ function merge(...args) {
 		};
 		return {
 			success: false,
-			consumed: 0,
-			error: require_message.message`No matching option or argument found.`
+			...createObjectLikeInitialError(context, noMatchContext)
 		};
 	};
-	const parseAsync = async (context) => {
+	const parseChildrenAsync = 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 parserState = extractParserState(parser, currentContext.state, i);
 			const resultOrPromise = parser.parse(withChildContext$1(currentContext, i, parserState, parser));
 			const result = await resultOrPromise;
 			if (result.success) {
@@ -3138,8 +3333,133 @@ function merge(...args) {
 		};
 		return {
 			success: false,
-			consumed: 0,
-			error: require_message.message`No matching option or argument found.`
+			...createObjectLikeInitialError(context, noMatchContext)
+		};
+	};
+	const parseSync = (context) => {
+		let currentContext = context;
+		let error = createObjectLikeInitialError(context, noMatchContext);
+		const allConsumed = [];
+		const consumedLanes = /* @__PURE__ */ new Set();
+		const consumedGroups = /* @__PURE__ */ new Set();
+		const laneResults = /* @__PURE__ */ new Map();
+		let attemptedLane = false;
+		let madeProgress = true;
+		while (madeProgress && currentContext.buffer.length > 0) {
+			madeProgress = false;
+			let consumingError = null;
+			for (const lane of mergeParseLanes) {
+				if (consumingError != null && lane.priority < consumingError.priority) {
+					if (!canTryPositionalLaneAfterFailure(lane, currentContext)) continue;
+				}
+				attemptedLane = true;
+				const result = lane.parse(currentContext);
+				laneResults.set(lane, result);
+				if (result.success && result.consumed.length > 0) {
+					currentContext = result.next;
+					allConsumed.push(...result.consumed);
+					consumedLanes.add(lane);
+					for (const group$1 of lane.requiredConsumptionGroups ?? []) if (group$1.isActive?.(result.next.state) !== false) consumedGroups.add(group$1.id);
+					madeProgress = true;
+					break;
+				}
+				if (!result.success) {
+					if (result.consumed > 0 && consumingError == null) consumingError = {
+						priority: lane.priority,
+						result
+					};
+					if (error.consumed < result.consumed) error = result;
+				}
+			}
+			if (!madeProgress && consumingError != null && allConsumed.length === 0) return consumingError.result;
+		}
+		if (allConsumed.length === 0) {
+			if (attemptedLane) {
+				const settled = settleZeroConsumptionLanes(context, laneResults);
+				return settled ?? {
+					...error,
+					success: false
+				};
+			}
+			const fallback = parseChildrenSync(context);
+			if (!fallback.success && fallback.consumed < error.consumed) return {
+				...error,
+				success: false
+			};
+			return fallback;
+		}
+		for (const lane of mergeParseLanes) {
+			if (consumedLanes.has(lane) || lane.leadingNames.size > 0 || lane.acceptingAnyToken || lane.requiredConsumptionGroups?.some((group$1) => !consumedGroups.has(group$1.id)) === true) continue;
+			const result = lane.parse(currentContext);
+			if (result.success && result.consumed.length === 0 && result.next.state !== currentContext.state) currentContext = result.next;
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
+		};
+	};
+	const parseAsync = async (context) => {
+		let currentContext = context;
+		let error = createObjectLikeInitialError(context, noMatchContext);
+		const allConsumed = [];
+		const consumedLanes = /* @__PURE__ */ new Set();
+		const consumedGroups = /* @__PURE__ */ new Set();
+		const laneResults = /* @__PURE__ */ new Map();
+		let attemptedLane = false;
+		let madeProgress = true;
+		while (madeProgress && currentContext.buffer.length > 0) {
+			madeProgress = false;
+			let consumingError = null;
+			for (const lane of mergeParseLanes) {
+				if (consumingError != null && lane.priority < consumingError.priority) {
+					if (!canTryPositionalLaneAfterFailure(lane, currentContext)) continue;
+				}
+				attemptedLane = true;
+				const result = await lane.parse(currentContext);
+				laneResults.set(lane, result);
+				if (result.success && result.consumed.length > 0) {
+					currentContext = result.next;
+					allConsumed.push(...result.consumed);
+					consumedLanes.add(lane);
+					for (const group$1 of lane.requiredConsumptionGroups ?? []) if (group$1.isActive?.(result.next.state) !== false) consumedGroups.add(group$1.id);
+					madeProgress = true;
+					break;
+				}
+				if (!result.success) {
+					if (result.consumed > 0 && consumingError == null) consumingError = {
+						priority: lane.priority,
+						result
+					};
+					if (error.consumed < result.consumed) error = result;
+				}
+			}
+			if (!madeProgress && consumingError != null && allConsumed.length === 0) return consumingError.result;
+		}
+		if (allConsumed.length === 0) {
+			if (attemptedLane) {
+				const settled = settleZeroConsumptionLanes(context, laneResults);
+				return settled ?? {
+					...error,
+					success: false
+				};
+			}
+			const fallback = await parseChildrenAsync(context);
+			if (!fallback.success && fallback.consumed < error.consumed) return {
+				...error,
+				success: false
+			};
+			return fallback;
+		}
+		for (const lane of mergeParseLanes) {
+			if (consumedLanes.has(lane) || lane.leadingNames.size > 0 || lane.acceptingAnyToken || lane.requiredConsumptionGroups?.some((group$1) => !consumedGroups.has(group$1.id)) === true) continue;
+			const result = await lane.parse(currentContext);
+			if (result.success && result.consumed.length === 0 && result.next.state !== currentContext.state) currentContext = result.next;
+		}
+		return {
+			success: true,
+			next: currentContext,
+			consumed: allConsumed
 		};
 	};
 	const mergeParser = {
@@ -3147,10 +3467,10 @@ function merge(...args) {
 		$valueType: [],
 		$stateType: [],
 		[fieldParsersKey]: mergedFieldParsers,
-		priority: Math.max(...parsers.map((p) => p.priority)),
+		priority: Math.max(...mergeParseLanes.map((lane) => lane.priority)),
 		usage: applyHiddenToUsage(parsers.flatMap((p) => p.usage), options.hidden),
-		leadingNames: sharedBufferLeadingNames(parsers),
-		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
+		leadingNames: sharedBufferLeadingNames(mergeParseLanes),
+		acceptingAnyToken: mergeParseLanes.some((lane) => lane.acceptingAnyToken),
 		initialState,
 		parse(context) {
 			if (isAsync) return parseAsync(context);
@@ -3619,6 +3939,7 @@ function merge(...args) {
 			};
 		}
 	};
+	require_parser.defineParseLanes(mergeParser, mergeParseLanes);
 	require_parser.defineInheritedAnnotationParser(mergeParser);
 	return mergeParser;
 }
@@ -4296,6 +4617,7 @@ function group(label, parser, options = {}) {
 			};
 		}
 	};
+	require_parser.defineParseLanes(groupParser, require_parser.getOwnParseLanes(parser));
 	Object.defineProperty(groupParser, require_phase2_seed.extractPhase2SeedKey, {
 		value(state, exec) {
 			return require_phase2_seed.extractPhase2Seed(parser, state, exec);