@optique/core 1.1.8 → 1.1.10

package/dist/internal/passthrough.js

@@ -0,0 +1,213 @@
+//#region src/internal/passthrough.ts
+/** Retains the deepest diagnostic and highest matching lane priority. @internal */
+function retainConsumingFailure(current, failure, priority) {
+	return {
+		failure: current != null && current.failure.consumed >= failure.consumed ? current.failure : failure,
+		priority: Math.max(current?.priority ?? -Infinity, priority)
+	};
+}
+const passThroughFailure = Symbol("passThroughFailure");
+/**
+* Gets the sibling failure that prevents pass-through capture at this cursor.
+* Stale hints inherited through a successful child do not block later input.
+* @param context The pass-through parser's context.
+* @returns The failure at this cursor, or undefined if capture is allowed.
+* @internal
+*/
+function getPassThroughFailure(context, capturePriority$1 = -Infinity) {
+	const hinted = context;
+	const hint = hinted[passThroughFailure];
+	return hint?.buffer === context.buffer && hint.optionsTerminated === context.optionsTerminated && hint.failure.priority >= capturePriority$1 ? hint.failure : void 0;
+}
+/**
+* Carries a sibling's consuming failure into a child parse call. Only
+* passThrough consults the hint; ordinary alternatives may still recover.
+* @param context The child context, without modifying the parent's context.
+* @param failure The deepest matching consuming failure at this input position.
+* @returns A context with a hint for active option-like input, or the original.
+* @internal
+*/
+function withPassThroughFailure(context, failure, capturePriority$1 = -Infinity) {
+	const token = context.buffer[0];
+	const existing = getPassThroughFailure(context);
+	if (existing != null && existing.priority < capturePriority$1) {
+		const hinted$1 = context;
+		const { [passThroughFailure]: _discarded,...rest } = hinted$1;
+		context = rest;
+	}
+	if (failure == null || failure.failure.consumed < 1 || failure.priority < capturePriority$1 || context.optionsTerminated || token == null || token === "--" || !/^[-/+]/.test(token)) return context;
+	const retained = getPassThroughFailure(context);
+	const combined = retainConsumingFailure(retained, failure.failure, failure.priority);
+	const hinted = {
+		...context,
+		[passThroughFailure]: {
+			buffer: context.buffer,
+			optionsTerminated: context.optionsTerminated,
+			failure: combined
+		}
+	};
+	return hinted;
+}
+/** Retains a child's rejected option failure only at the parent's cursor. @internal */
+function retainConsumingFailureHint(current, context, next) {
+	if (next.buffer !== context.buffer || next.optionsTerminated !== context.optionsTerminated) return current;
+	const hint = getPassThroughFailure(next);
+	return hint == null ? current : retainConsumingFailure(current, hint.failure, hint.priority);
+}
+const capturePriority = Symbol("capturePriority");
+/** Checks for capture through usage-preserving wrappers. @internal */
+function hasPassThroughUsage(usage) {
+	return usage.some((term) => term.type === "passthrough" || (term.type === "optional" || term.type === "multiple") && hasPassThroughUsage(term.terms) || term.type === "exclusive" && term.terms.some(hasPassThroughUsage));
+}
+/**
+* Gets the priority of reachable capture, respecting an explicit override.
+* @param parser The parser whose capture priority is needed.
+* @param state The current parser state.
+* @param token The current token, omitted for an unfiltered priority lookup.
+* @returns The capture priority, or undefined when capture is absent.
+* @internal
+*/
+function getPassThroughPriority(parser, state = parser.initialState, token) {
+	if (!hasPassThroughUsage(parser.usage)) return void 0;
+	const annotated = parser;
+	const hint = annotated[capturePriority];
+	if (hint == null) return parser.priority;
+	const priority = hint.getPriority == null ? hint.priority : hint.getPriority(state, token);
+	return priority == null ? void 0 : hint.ownerPriority === parser.priority ? priority : parser.priority;
+}
+/**
+* Records capture priority separately from unrelated children's priorities.
+* @param parser The newly constructed parser.
+* @param children Its transparent children.
+* @param getPriority Optional state-aware capture priority lookup.
+* @internal
+*/
+function definePassThroughPriority(parser, children, getPriority) {
+	const priorities = children.filter((child) => hasPassThroughUsage(child.usage)).map((child) => getPassThroughPriority(child) ?? child.priority);
+	if (priorities.length === 0) return;
+	Object.defineProperty(parser, capturePriority, {
+		value: {
+			ownerPriority: parser.priority,
+			priority: Math.max(...priorities),
+			getPriority
+		},
+		enumerable: true
+	});
+}
+/**
+* Copies only a cursor-valid hint when rebuilding a child context.
+* @param context The successful child's context.
+* @returns Private hint properties, or an empty object for stale hints.
+* @internal
+*/
+function getPassThroughFailureHint(context) {
+	const hinted = context;
+	const hint = hinted[passThroughFailure];
+	return hint != null && getPassThroughFailure(context) != null ? { [passThroughFailure]: hint } : {};
+}
+/** Finds a Boolean option through usage-preserving wrappers. */
+function hasFlagUsage(usage, name) {
+	return usage.some((term) => term.type === "option" && term.metavar == null && term.names.some((optionName) => optionName === name) || (term.type === "optional" || term.type === "multiple") && hasFlagUsage(term.terms, name) || term.type === "exclusive" && term.terms.some((terms) => hasFlagUsage(terms, name)));
+}
+/** Matches exact options, attached values, and leading bundled flags. */
+function matchesOptionToken(parser, token) {
+	if (token == null || token === "--" || !/^[-/+]/.test(token)) return false;
+	if (parser.leadingNames.has(token)) return true;
+	const slashOption = token.startsWith("/");
+	const separator = slashOption ? token.indexOf(":") : token.startsWith("-") ? token.indexOf("=") : -1;
+	if (separator > (slashOption ? 0 : 2) && parser.leadingNames.has(token.slice(0, separator))) return true;
+	const shortName = token.slice(0, 2);
+	return token.length > 2 && /^-[^-]$/.test(shortName) && parser.leadingNames.has(shortName) && hasFlagUsage(parser.usage, shortName);
+}
+const optionMatchKey = Symbol("optionMatch");
+/**
+* Records state-aware option matching without changing public leading names.
+* @param parser The newly constructed transparent parser.
+* @param match Finds a reachable known-option lane.
+* @internal
+*/
+function defineOptionMatch(parser, match) {
+	Object.defineProperty(parser, optionMatchKey, {
+		value: {
+			ownerPriority: parser.priority,
+			match
+		},
+		enumerable: true
+	});
+}
+/**
+* Finds a matching option's actual priority, including selected command children.
+* @param parser The parser to inspect.
+* @param state Its current state.
+* @param token The current token.
+* @returns A reachable option match, or undefined.
+* @internal
+*/
+function getOptionMatch(parser, state, token) {
+	if (token == null || token === "--" || !/^[-/+]/.test(token)) return void 0;
+	const annotated = parser;
+	const matcher = annotated[optionMatchKey];
+	if (matcher != null) {
+		const match = matcher.match(state, token);
+		return match == null || matcher.ownerPriority === parser.priority ? match : {
+			...match,
+			priority: parser.priority
+		};
+	}
+	return matchesOptionToken(parser, token) ? {
+		priority: parser.priority,
+		continuesCommand: false
+	} : void 0;
+}
+/**
+* Combines option matches while retaining active command continuation.
+* @param matches Matches from transparent children.
+* @returns Their highest priority and whether any matching command continues.
+* @internal
+*/
+function combineOptionMatches(matches) {
+	const found = matches.filter((match) => match != null);
+	return found.length === 0 ? void 0 : {
+		priority: Math.max(...found.map((match) => match.priority)),
+		continuesCommand: found.some((match) => match.continuesCommand)
+	};
+}
+const knownCompletionKey = Symbol("knownCompletion");
+/** Marks a completion value that can be inspected without running user code. @internal */
+function defineKnownCompletion(parser, value) {
+	defineKnownCompletionLookup(parser, (state) => ({ value: value(state) }));
+}
+/** Registers a known-value lookup that may decline unknown completion. @internal */
+function defineKnownCompletionLookup(parser, value) {
+	Object.defineProperty(parser, knownCompletionKey, {
+		value: {
+			complete: parser.complete,
+			value
+		},
+		enumerable: true
+	});
+}
+/** Looks up a known value only while the original completion is intact. @internal */
+function getKnownCompletion(parser, state) {
+	const annotated = parser;
+	const hint = annotated[knownCompletionKey];
+	return hint != null && hint.complete === parser.complete ? hint.value(state) : void 0;
+}
+/** Combines the priorities of currently reachable capture lanes. @internal */
+function combinePassThroughPriorities(priorities) {
+	const found = priorities.filter((priority) => priority != null);
+	return found.length === 0 ? void 0 : Math.max(...found);
+}
+/** Forwards known completion through a state-preserving wrapper. @internal */
+function delegateKnownCompletion(wrapper, inner) {
+	Object.defineProperty(wrapper, knownCompletionKey, {
+		value: {
+			complete: wrapper.complete,
+			value: (state) => getKnownCompletion(inner, state)
+		},
+		enumerable: true
+	});
+}
+
+//#endregion
+export { combineOptionMatches, combinePassThroughPriorities, defineKnownCompletion, defineKnownCompletionLookup, defineOptionMatch, definePassThroughPriority, delegateKnownCompletion, getKnownCompletion, getOptionMatch, getPassThroughFailure, getPassThroughFailureHint, getPassThroughPriority, hasPassThroughUsage, matchesOptionToken, retainConsumingFailure, retainConsumingFailureHint, withPassThroughFailure };

package/dist/message.cjs

@@ -324,7 +324,8 @@ function formatMessage(msg, options = {}) {
 							if (match == null) break;
 							yield {
 								text: match[0],
-								width: require_displaywidth.getDisplayWidth(match[0])
+								width: require_displaywidth.getDisplayWidth(match[0]),
+								trimOnWrap: true
 							};
 						}
 					}
@@ -332,7 +333,8 @@ function formatMessage(msg, options = {}) {
 					const normalizedText = rawText.replace(/\n/g, " ");
 					if (normalizedText.trim() === "" && normalizedText.length > 0) yield {
 						text: " ",
-						width: 1
+						width: 1,
+						trimOnWrap: true
 					};
 					else {
 						wordPattern.lastIndex = 0;
@@ -341,7 +343,8 @@ function formatMessage(msg, options = {}) {
 							if (match == null) break;
 							yield {
 								text: match[0],
-								width: require_displaywidth.getDisplayWidth(match[0])
+								width: require_displaywidth.getDisplayWidth(match[0]),
+								trimOnWrap: true
 							};
 						}
 					}
@@ -381,7 +384,8 @@ function formatMessage(msg, options = {}) {
 			} else if (term.type === "values") for (let i = 0; i < term.values.length; i++) {
 				if (i > 0) yield {
 					text: " ",
-					width: 1
+					width: 1,
+					trimOnWrap: true
 				};
 				const value$1 = useQuotes ? JSON.stringify(term.values[i]) : term.values[i];
 				yield {
@@ -425,18 +429,40 @@ function formatMessage(msg, options = {}) {
 	}
 	let output = "";
 	let totalWidth = options.startWidth ?? 0;
-	for (const { text: text$1, width } of stream()) {
+	let pendingWrap = false;
+	let atWrappedLineStart = false;
+	for (const token of stream()) {
+		let { text: text$1, width } = token;
 		if (width === -1) {
 			output += text$1;
 			totalWidth = 0;
+			pendingWrap = false;
+			atWrappedLineStart = false;
+			continue;
+		}
+		const wraps = pendingWrap || options.maxWidth != null && totalWidth > 0 && totalWidth + width > options.maxWidth;
+		if ((wraps || atWrappedLineStart) && token.trimOnWrap) {
+			const trimmed = text$1.trimStart();
+			width -= require_displaywidth.getDisplayWidth(text$1.slice(0, text$1.length - trimmed.length));
+			text$1 = trimmed;
+			if (text$1 === "") {
+				if (wraps) pendingWrap = true;
+				continue;
+			}
+		}
+		if (pendingWrap && require_displaywidth.stripAnsi(text$1) === "") {
+			output += text$1;
 			continue;
 		}
-		if (options.maxWidth != null && totalWidth > 0 && totalWidth + width > options.maxWidth) {
+		if (wraps) {
 			output += "\n";
 			totalWidth = 0;
+			pendingWrap = false;
+			atWrappedLineStart = true;
 		}
 		output += text$1;
 		totalWidth += width;
+		if (width > 0) atWrappedLineStart = false;
 	}
 	return output;
 }

package/dist/message.js

@@ -1,4 +1,4 @@
-import { getDisplayWidth } from "./displaywidth.js";
+import { getDisplayWidth, stripAnsi } from "./displaywidth.js";
 
 //#region src/message.ts
 /**
@@ -324,7 +324,8 @@ function formatMessage(msg, options = {}) {
 							if (match == null) break;
 							yield {
 								text: match[0],
-								width: getDisplayWidth(match[0])
+								width: getDisplayWidth(match[0]),
+								trimOnWrap: true
 							};
 						}
 					}
@@ -332,7 +333,8 @@ function formatMessage(msg, options = {}) {
 					const normalizedText = rawText.replace(/\n/g, " ");
 					if (normalizedText.trim() === "" && normalizedText.length > 0) yield {
 						text: " ",
-						width: 1
+						width: 1,
+						trimOnWrap: true
 					};
 					else {
 						wordPattern.lastIndex = 0;
@@ -341,7 +343,8 @@ function formatMessage(msg, options = {}) {
 							if (match == null) break;
 							yield {
 								text: match[0],
-								width: getDisplayWidth(match[0])
+								width: getDisplayWidth(match[0]),
+								trimOnWrap: true
 							};
 						}
 					}
@@ -381,7 +384,8 @@ function formatMessage(msg, options = {}) {
 			} else if (term.type === "values") for (let i = 0; i < term.values.length; i++) {
 				if (i > 0) yield {
 					text: " ",
-					width: 1
+					width: 1,
+					trimOnWrap: true
 				};
 				const value$1 = useQuotes ? JSON.stringify(term.values[i]) : term.values[i];
 				yield {
@@ -425,18 +429,40 @@ function formatMessage(msg, options = {}) {
 	}
 	let output = "";
 	let totalWidth = options.startWidth ?? 0;
-	for (const { text: text$1, width } of stream()) {
+	let pendingWrap = false;
+	let atWrappedLineStart = false;
+	for (const token of stream()) {
+		let { text: text$1, width } = token;
 		if (width === -1) {
 			output += text$1;
 			totalWidth = 0;
+			pendingWrap = false;
+			atWrappedLineStart = false;
+			continue;
+		}
+		const wraps = pendingWrap || options.maxWidth != null && totalWidth > 0 && totalWidth + width > options.maxWidth;
+		if ((wraps || atWrappedLineStart) && token.trimOnWrap) {
+			const trimmed = text$1.trimStart();
+			width -= getDisplayWidth(text$1.slice(0, text$1.length - trimmed.length));
+			text$1 = trimmed;
+			if (text$1 === "") {
+				if (wraps) pendingWrap = true;
+				continue;
+			}
+		}
+		if (pendingWrap && stripAnsi(text$1) === "") {
+			output += text$1;
 			continue;
 		}
-		if (options.maxWidth != null && totalWidth > 0 && totalWidth + width > options.maxWidth) {
+		if (wraps) {
 			output += "\n";
 			totalWidth = 0;
+			pendingWrap = false;
+			atWrappedLineStart = true;
 		}
 		output += text$1;
 		totalWidth += width;
+		if (width > 0) atWrappedLineStart = false;
 	}
 	return output;
 }

package/dist/modifiers.cjs

@@ -3,6 +3,7 @@ const require_message = require('./message.cjs');
 const require_mode_dispatch = require('./internal/mode-dispatch.cjs');
 const require_internal_parser = require('./internal/parser.cjs');
 const require_annotation_state = require('./annotation-state.cjs');
+const require_passthrough = require('./internal/passthrough.cjs');
 const require_execution_context = require('./execution-context.cjs');
 const require_phase2_seed = require('./phase2-seed.cjs');
 const require_dependency_metadata = require('./dependency-metadata.cjs');
@@ -461,6 +462,9 @@ function optional(parser) {
 	require_internal_parser.defineParseLanes(optionalParser, adaptOptionalStyleParseLanes(parser));
 	require_internal_parser.defineInheritedAnnotationParser(optionalParser);
 	require_internal_parser.defineSourceBindingOnlyAnnotationCompletionParser(optionalParser);
+	require_passthrough.defineOptionMatch(optionalParser, (state, token) => require_passthrough.getOptionMatch(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	require_passthrough.definePassThroughPriority(optionalParser, [parser], (state, token) => require_passthrough.getPassThroughPriority(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	require_passthrough.defineKnownCompletionLookup(optionalParser, (state) => require_passthrough.getKnownCompletion(parser, deriveOptionalInnerParseState(state, parser)));
 	return optionalParser;
 }
 /**
@@ -696,6 +700,9 @@ function withDefault(parser, defaultValue, options) {
 	require_internal_parser.defineParseLanes(withDefaultParser, adaptOptionalStyleParseLanes(parser));
 	require_internal_parser.defineInheritedAnnotationParser(withDefaultParser);
 	require_internal_parser.defineSourceBindingOnlyAnnotationCompletionParser(withDefaultParser);
+	require_passthrough.defineOptionMatch(withDefaultParser, (state, token) => require_passthrough.getOptionMatch(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	require_passthrough.definePassThroughPriority(withDefaultParser, [parser], (state, token) => require_passthrough.getPassThroughPriority(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	require_passthrough.defineKnownCompletionLookup(withDefaultParser, (state) => require_passthrough.getKnownCompletion(parser, deriveOptionalInnerParseState(state, parser)));
 	return withDefaultParser;
 }
 /**
@@ -1508,6 +1515,19 @@ function multiple(parser, options = {}) {
 			enumerable: false
 		});
 	}
+	const matchingItem = (state) => {
+		const current = state.at(-1);
+		if (current != null && !isTerminalMultipleItemState(current)) return { state: unwrapInjectedWrapper(current) };
+		return state.length < max ? { state: parser.initialState } : void 0;
+	};
+	require_passthrough.defineOptionMatch(resultParser, (state, token) => {
+		const item = matchingItem(state);
+		return item == null ? void 0 : require_passthrough.getOptionMatch(parser, item.state, token);
+	});
+	require_passthrough.definePassThroughPriority(resultParser, [parser], (state, token) => {
+		const item = matchingItem(state);
+		return item == null ? void 0 : require_passthrough.getPassThroughPriority(parser, item.state, token);
+	});
 	return resultParser;
 }
 /**
@@ -1638,6 +1658,8 @@ function nonEmpty(parser) {
 		configurable: true,
 		enumerable: false
 	});
+	require_passthrough.defineOptionMatch(nonEmptyParser, (state, token) => require_passthrough.getOptionMatch(parser, state, token));
+	require_passthrough.definePassThroughPriority(nonEmptyParser, [parser], (state, token) => require_passthrough.getPassThroughPriority(parser, state, token));
 	return nonEmptyParser;
 }
 

package/dist/modifiers.js

@@ -3,6 +3,7 @@ import { formatMessage, message, text } from "./message.js";
 import { dispatchByMode, dispatchIterableByMode, mapModeValue, wrapForMode } from "./internal/mode-dispatch.js";
 import { defineInheritedAnnotationParser, defineParseLanes, defineSourceBindingOnlyAnnotationCompletionParser, getOwnParseLanes, unmatchedNonCliDependencySourceStateMarker } from "./internal/parser.js";
 import { getDelegatedAnnotationState, hasDelegatedAnnotationCarrier, isAnnotationWrappedInitialState, normalizeDelegatedAnnotationState, normalizeNestedDelegatedAnnotationState } from "./annotation-state.js";
+import { defineKnownCompletionLookup, defineOptionMatch, definePassThroughPriority, getKnownCompletion, getOptionMatch, getPassThroughPriority } from "./internal/passthrough.js";
 import { mergeChildExec, withChildContext, withChildExecPath } from "./execution-context.js";
 import { completeOrExtractPhase2Seed, extractPhase2Seed, extractPhase2SeedKey, phase2SeedFromValueResult } from "./phase2-seed.js";
 import { composeDependencyMetadata } from "./dependency-metadata.js";
@@ -461,6 +462,9 @@ function optional(parser) {
 	defineParseLanes(optionalParser, adaptOptionalStyleParseLanes(parser));
 	defineInheritedAnnotationParser(optionalParser);
 	defineSourceBindingOnlyAnnotationCompletionParser(optionalParser);
+	defineOptionMatch(optionalParser, (state, token) => getOptionMatch(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	definePassThroughPriority(optionalParser, [parser], (state, token) => getPassThroughPriority(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	defineKnownCompletionLookup(optionalParser, (state) => getKnownCompletion(parser, deriveOptionalInnerParseState(state, parser)));
 	return optionalParser;
 }
 /**
@@ -696,6 +700,9 @@ function withDefault(parser, defaultValue, options) {
 	defineParseLanes(withDefaultParser, adaptOptionalStyleParseLanes(parser));
 	defineInheritedAnnotationParser(withDefaultParser);
 	defineSourceBindingOnlyAnnotationCompletionParser(withDefaultParser);
+	defineOptionMatch(withDefaultParser, (state, token) => getOptionMatch(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	definePassThroughPriority(withDefaultParser, [parser], (state, token) => getPassThroughPriority(parser, normalizeOptionalLikeSuggestState(state, parser.initialState, parser), token));
+	defineKnownCompletionLookup(withDefaultParser, (state) => getKnownCompletion(parser, deriveOptionalInnerParseState(state, parser)));
 	return withDefaultParser;
 }
 /**
@@ -1508,6 +1515,19 @@ function multiple(parser, options = {}) {
 			enumerable: false
 		});
 	}
+	const matchingItem = (state) => {
+		const current = state.at(-1);
+		if (current != null && !isTerminalMultipleItemState(current)) return { state: unwrapInjectedWrapper(current) };
+		return state.length < max ? { state: parser.initialState } : void 0;
+	};
+	defineOptionMatch(resultParser, (state, token) => {
+		const item = matchingItem(state);
+		return item == null ? void 0 : getOptionMatch(parser, item.state, token);
+	});
+	definePassThroughPriority(resultParser, [parser], (state, token) => {
+		const item = matchingItem(state);
+		return item == null ? void 0 : getPassThroughPriority(parser, item.state, token);
+	});
 	return resultParser;
 }
 /**
@@ -1638,6 +1658,8 @@ function nonEmpty(parser) {
 		configurable: true,
 		enumerable: false
 	});
+	defineOptionMatch(nonEmptyParser, (state, token) => getOptionMatch(parser, state, token));
+	definePassThroughPriority(nonEmptyParser, [parser], (state, token) => getPassThroughPriority(parser, state, token));
 	return nonEmptyParser;
 }
 

package/dist/primitives.cjs

@@ -6,6 +6,7 @@ const require_mode_dispatch = require('./internal/mode-dispatch.cjs');
 const require_internal_dependency = require('./internal/dependency.cjs');
 const require_dependency_runtime = require('./dependency-runtime.cjs');
 const require_annotation_state = require('./annotation-state.cjs');
+const require_passthrough = require('./internal/passthrough.cjs');
 const require_command_alias = require('./internal/command-alias.cjs');
 const require_execution_context = require('./execution-context.cjs');
 const require_phase2_seed = require('./phase2-seed.cjs');
@@ -144,6 +145,7 @@ function constant(value) {
 			return { fragments: [] };
 		}
 	};
+	require_passthrough.defineKnownCompletion(result, (state) => require_annotation_state.normalizeInjectedAnnotationState(state));
 	Object.defineProperty(result, "placeholder", {
 		value,
 		configurable: true,
@@ -583,10 +585,15 @@ function option(...args) {
 			}
 			const invalidOption = context.buffer[0];
 			if (options.errors?.noMatch) {
+				if (typeof options.errors.noMatch !== "function") return {
+					success: false,
+					consumed: 0,
+					error: options.errors.noMatch
+				};
 				const candidates = /* @__PURE__ */ new Set();
 				for (const name of require_usage.extractOptionNames(context.usage)) candidates.add(name);
 				const suggestions = require_suggestion.findSimilar(invalidOption, candidates, require_suggestion.DEFAULT_FIND_SIMILAR_OPTIONS);
-				const errorMessage = typeof options.errors.noMatch === "function" ? options.errors.noMatch(invalidOption, suggestions) : options.errors.noMatch;
+				const errorMessage = options.errors.noMatch(invalidOption, suggestions);
 				return {
 					success: false,
 					consumed: 0,
@@ -871,10 +878,15 @@ function flag(...args) {
 			}
 			const invalidOption = context.buffer[0];
 			if (options.errors?.noMatch) {
+				if (typeof options.errors.noMatch !== "function") return {
+					success: false,
+					consumed: 0,
+					error: options.errors.noMatch
+				};
 				const candidates = /* @__PURE__ */ new Set();
 				for (const name of require_usage.extractOptionNames(context.usage)) candidates.add(name);
 				const suggestions = require_suggestion.findSimilar(invalidOption, candidates, require_suggestion.DEFAULT_FIND_SIMILAR_OPTIONS);
-				const errorMessage = typeof options.errors.noMatch === "function" ? options.errors.noMatch(invalidOption, suggestions) : options.errors.noMatch;
+				const errorMessage = options.errors.noMatch(invalidOption, suggestions);
 				return {
 					success: false,
 					consumed: 0,
@@ -1183,7 +1195,7 @@ function argument(valueParser, options = {}) {
 	const syncValueParser = valueParser;
 	const dependencyMetadata = require_dependency_metadata.extractDependencyMetadata(valueParser);
 	const formatInvalidValueError = (error) => options.errors?.invalidValue ? typeof options.errors.invalidValue === "function" ? options.errors.invalidValue(error) : options.errors.invalidValue : require_message.message`${require_message.metavar(valueParser.metavar)}: ${error}`;
-	const optionPattern = /^--?[a-z0-9-]+$/i;
+	const optionPattern = /^(?!--=)(--?[a-z0-9-]+)(?:=|$)/i;
 	const term = {
 		type: "argument",
 		metavar: valueParser.metavar,
@@ -1210,14 +1222,15 @@ function argument(valueParser, options = {}) {
 			};
 			let i = 0;
 			let optionsTerminated = context.optionsTerminated;
-			if (!optionsTerminated) {
-				if (context.buffer[i] === "--") {
-					optionsTerminated = true;
-					i++;
-				} else if (context.buffer[i].match(optionPattern)) return {
+			if (!optionsTerminated) if (context.buffer[i] === "--") {
+				optionsTerminated = true;
+				i++;
+			} else {
+				const optionMatch = context.buffer[i].match(optionPattern);
+				if (optionMatch != null) return {
 					success: false,
 					consumed: i,
-					error: require_message.message`Expected an argument, but got an option: ${require_message.optionName(context.buffer[i])}.`
+					error: require_message.message`Expected an argument, but got an option: ${require_message.optionName(optionMatch[1])}.`
 				};
 			}
 			if (context.buffer.length < i + 1) return {
@@ -1703,6 +1716,22 @@ function command(name, parser, options = {}) {
 		configurable: true,
 		enumerable: false
 	});
+	require_passthrough.definePassThroughPriority(result, [parser], (state, token) => {
+		const active = normalizeCommandState(state);
+		if (active == null) return void 0;
+		const childState = active[0] === "matched" ? parser.initialState : active[1];
+		return require_passthrough.getPassThroughPriority(parser, getCommandParseChildState(state, childState, parser), token);
+	});
+	require_passthrough.defineOptionMatch(result, (state, token) => {
+		const active = normalizeCommandState(state);
+		if (active == null) return void 0;
+		const childState = active[0] === "matched" ? parser.initialState : active[1];
+		const match = require_passthrough.getOptionMatch(parser, getCommandParseChildState(state, childState, parser), token);
+		return match == null ? void 0 : {
+			...match,
+			continuesCommand: true
+		};
+	});
 	return result;
 }
 /**
@@ -1755,7 +1784,7 @@ function passThrough(options = {}) {
 	const format = options.format ?? "equalsOnly";
 	const optionPattern = /^-[a-z0-9-]|^--[a-z0-9-]+/i;
 	const equalsOptionPattern = /^--[a-z0-9-]+=/i;
-	return {
+	const result = {
 		$valueType: [],
 		$stateType: [],
 		mode: "sync",
@@ -1776,6 +1805,8 @@ function passThrough(options = {}) {
 				consumed: 0,
 				error: require_message.message`No input to pass through.`
 			};
+			const failure = require_passthrough.getPassThroughFailure(context, this?.priority ?? -10);
+			if (failure != null) return failure.failure;
 			const token = context.buffer[0];
 			if (format === "greedy") {
 				const captured = [...context.buffer];
@@ -1887,6 +1918,12 @@ function passThrough(options = {}) {
 			return `passThrough(${format})`;
 		}
 	};
+	require_passthrough.definePassThroughPriority(result, [result], (_state, token) => {
+		if (token == null || format === "greedy") return result.priority;
+		const accepts = format === "equalsOnly" ? equalsOptionPattern.test(token) : format === "nextToken" && optionPattern.test(token);
+		return accepts ? result.priority : void 0;
+	});
+	return result;
 }
 
 //#endregion