@optique/core 1.1.0-dev.1998 → 1.1.0-dev.2053

package/dist/facade.js

@@ -2,12 +2,12 @@ import { injectAnnotations, isInjectedAnnotationWrapper, unwrapInjectedAnnotatio
 import { commandLine, formatMessage, lineBreak, message, optionName, text, value } from "./message.js";
 import { bash, fish, nu, pwsh, zsh } from "./completion.js";
 import { validateCommandNames, validateContextIds, validateMetaNameCollisions, validateOptionNames, validateProgramName } from "./validate.js";
-import { formatUsage } from "./usage.js";
+import { formatUsage, isSuggestionHidden } from "./usage.js";
 import { formatDocPage } from "./doc.js";
 import { dispatchByMode } from "./internal/mode-dispatch.js";
-import { createDependencyRuntimeContext } from "./dependency-runtime.js";
+import { collectExplicitSourceValues, collectExplicitSourceValuesAsync, createDependencyRuntimeContext } from "./dependency-runtime.js";
 import { createInputTrace } from "./input-trace.js";
-import { createParserContext, getDocPage, suggest, suggestAsync } from "./internal/parser.js";
+import { createParserContext, getDocPage } from "./internal/parser.js";
 import { completeOrExtractPhase2Seed } from "./phase2-seed.js";
 import { group, longestMatch, object } from "./constructs.js";
 import { multiple, optional, withDefault } from "./modifiers.js";
@@ -384,162 +384,42 @@ function createCompletionParser(programName, availableShells, commandConfig, opt
 		completionOption
 	};
 }
-function combineWithHelpVersion(originalParser, helpParsers, versionParsers, completionParsers, groups, helpOptionNames, versionOptionNames) {
+function createMetaOptionDocParser(source) {
+	return {
+		mode: "sync",
+		$valueType: [],
+		$stateType: [],
+		priority: 200,
+		usage: source.usage,
+		leadingNames: source.leadingNames,
+		acceptingAnyToken: false,
+		initialState: null,
+		parse: () => ({
+			success: false,
+			error: message`Documentation-only meta option.`,
+			consumed: 0
+		}),
+		complete: (state) => ({
+			success: true,
+			value: state
+		}),
+		suggest: function* () {},
+		getDocFragments: (_state, defaultValue) => source.getDocFragments({
+			kind: "available",
+			state: source.initialState
+		}, defaultValue)
+	};
+}
+function combineWithHelpVersion(originalParser, helpParsers, versionParsers, completionParsers, groups) {
 	const parsers = [];
-	const effectiveHelpOptionNames = helpOptionNames ?? ["--help"];
-	const effectiveVersionOptionNames = versionOptionNames ?? ["--version"];
 	if (helpParsers.helpOption) {
-		const lenientHelpParser = {
-			mode: "sync",
-			$valueType: [],
-			$stateType: [],
-			priority: 200,
-			usage: helpParsers.helpOption.usage,
-			leadingNames: helpParsers.helpOption.leadingNames,
-			acceptingAnyToken: false,
-			initialState: null,
-			parse(context) {
-				const { buffer, optionsTerminated } = context;
-				if (optionsTerminated) return {
-					success: false,
-					error: message`Options terminated.`,
-					consumed: 0
-				};
-				let helpFound = false;
-				let helpIndex = -1;
-				let versionIndex = -1;
-				for (let i = 0; i < buffer.length; i++) {
-					if (buffer[i] === "--") break;
-					if (effectiveHelpOptionNames.includes(buffer[i])) {
-						helpFound = true;
-						helpIndex = i;
-					}
-					if (effectiveVersionOptionNames.includes(buffer[i])) versionIndex = i;
-				}
-				if (helpFound && versionIndex > helpIndex) return {
-					success: false,
-					error: message`Version option wins.`,
-					consumed: 0
-				};
-				if (helpFound) {
-					const commands = [];
-					for (let i = 0; i < helpIndex; i++) {
-						const arg = buffer[i];
-						if (!arg.startsWith("-")) commands.push(arg);
-					}
-					return {
-						success: true,
-						next: {
-							...context,
-							buffer: [],
-							state: {
-								[metaResultBrand]: true,
-								help: true,
-								version: false,
-								completion: false,
-								commands,
-								helpFlag: true
-							}
-						},
-						consumed: buffer.slice(0)
-					};
-				}
-				return {
-					success: false,
-					error: message`Flag ${optionName(effectiveHelpOptionNames[0])} not found.`,
-					consumed: 0
-				};
-			},
-			complete(state) {
-				return {
-					success: true,
-					value: state
-				};
-			},
-			*suggest(_context, prefix) {
-				for (const name of effectiveHelpOptionNames) if (name.startsWith(prefix)) yield {
-					kind: "literal",
-					text: name
-				};
-			},
-			getDocFragments(state) {
-				return helpParsers.helpOption?.getDocFragments(state) ?? { fragments: [] };
-			}
-		};
-		const wrappedHelp = groups?.helpOptionGroup ? group(groups.helpOptionGroup, lenientHelpParser) : lenientHelpParser;
+		const helpOptionDocParser = createMetaOptionDocParser(helpParsers.helpOption);
+		const wrappedHelp = groups?.helpOptionGroup ? group(groups.helpOptionGroup, helpOptionDocParser) : helpOptionDocParser;
 		parsers.push(wrappedHelp);
 	}
 	if (versionParsers.versionOption) {
-		const lenientVersionParser = {
-			mode: "sync",
-			$valueType: [],
-			$stateType: [],
-			priority: 200,
-			usage: versionParsers.versionOption.usage,
-			leadingNames: versionParsers.versionOption.leadingNames,
-			acceptingAnyToken: false,
-			initialState: null,
-			parse(context) {
-				const { buffer, optionsTerminated } = context;
-				if (optionsTerminated) return {
-					success: false,
-					error: message`Options terminated.`,
-					consumed: 0
-				};
-				let versionFound = false;
-				let versionIndex = -1;
-				let helpIndex = -1;
-				for (let i = 0; i < buffer.length; i++) {
-					if (buffer[i] === "--") break;
-					if (effectiveVersionOptionNames.includes(buffer[i])) {
-						versionFound = true;
-						versionIndex = i;
-					}
-					if (effectiveHelpOptionNames.includes(buffer[i])) helpIndex = i;
-				}
-				if (versionFound && helpIndex > versionIndex) return {
-					success: false,
-					error: message`Help option wins.`,
-					consumed: 0
-				};
-				if (versionFound) return {
-					success: true,
-					next: {
-						...context,
-						buffer: [],
-						state: {
-							[metaResultBrand]: true,
-							help: false,
-							version: true,
-							completion: false,
-							versionFlag: true
-						}
-					},
-					consumed: buffer.slice(0)
-				};
-				return {
-					success: false,
-					error: message`Flag ${optionName(effectiveVersionOptionNames[0])} not found.`,
-					consumed: 0
-				};
-			},
-			complete(state) {
-				return {
-					success: true,
-					value: state
-				};
-			},
-			*suggest(_context, prefix) {
-				for (const name of effectiveVersionOptionNames) if (name.startsWith(prefix)) yield {
-					kind: "literal",
-					text: name
-				};
-			},
-			getDocFragments(state) {
-				return versionParsers.versionOption?.getDocFragments(state) ?? { fragments: [] };
-			}
-		};
-		const wrappedVersion = groups?.versionOptionGroup ? group(groups.versionOptionGroup, lenientVersionParser) : lenientVersionParser;
+		const versionOptionDocParser = createMetaOptionDocParser(versionParsers.versionOption);
+		const wrappedVersion = groups?.versionOptionGroup ? group(groups.versionOptionGroup, versionOptionDocParser) : versionOptionDocParser;
 		parsers.push(wrappedVersion);
 	}
 	if (versionParsers.versionCommand) {
@@ -717,7 +597,7 @@ function classifyParseFailure(failure, helpOptionNames, helpCommandNames, versio
 * Handles shell completion requests.
 * @since 0.6.0
 */
-function handleCompletion(completionArgs, programName, parser, completionParser, stdout, stderr, onCompletion, onError, availableShells, colors, maxWidth, completionCommandDisplayName, completionOptionDisplayName, isOptionMode, sectionOrder) {
+function handleCompletion(completionArgs, programName, parser, completionParser, stdout, stderr, onCompletion, onError, availableShells, colors, maxWidth, completionCommandDisplayName, completionOptionDisplayName, isOptionMode, sectionOrder, rootOptionSuggestions = []) {
 	const shellName = completionArgs[0] || "";
 	const args = completionArgs.slice(1);
 	const callOnError = (code) => onError(code);
@@ -768,17 +648,248 @@ function handleCompletion(completionArgs, programName, parser, completionParser,
 	}
 	return dispatchByMode(parser.mode, () => {
 		const syncParser = parser;
-		const suggestions = suggest(syncParser, args);
+		const completionSuggestions = getSyncCompletionSuggestions(syncParser, args, rootOptionSuggestions);
+		const suggestions = withRootOptionSuggestions(completionSuggestions.suggestions, args, rootOptionSuggestions, completionSuggestions.argumentContext);
 		for (const chunk of shell.encodeSuggestions(suggestions)) stdout(chunk);
 		const result = callOnCompletion(0);
 		if (result instanceof Promise) throw new RunParserError("Synchronous parser returned async result.");
 		return result;
 	}, async () => {
-		const suggestions = await suggestAsync(parser, args);
-		for (const chunk of shell.encodeSuggestions(suggestions)) stdout(chunk);
+		const asyncParser = parser;
+		const completionSuggestions = await getAsyncCompletionSuggestions(asyncParser, args, rootOptionSuggestions);
+		for (const chunk of shell.encodeSuggestions(withRootOptionSuggestions(completionSuggestions.suggestions, args, rootOptionSuggestions, completionSuggestions.argumentContext))) stdout(chunk);
 		return callOnCompletion(0);
 	});
 }
+function withRootOptionSuggestions(suggestions, args, extraSuggestions, argumentContext) {
+	if (extraSuggestions.length === 0) return suggestions;
+	const prefix = args.at(-1) ?? "";
+	if (argumentContext.optionsTerminated) return suggestions;
+	if (argumentContext.completingOptionValue) return suggestions;
+	if (argumentContext.completedRootOption) return suggestions;
+	if (!(prefix === "" || prefix.startsWith("--") || prefix.startsWith("-") || prefix.startsWith("/") || prefix.startsWith("+"))) return suggestions;
+	const seen = new Set(suggestions.flatMap((suggestion) => suggestion.kind === "literal" ? [suggestion.text] : []));
+	const combined = [...suggestions];
+	for (const suggestion of extraSuggestions) {
+		if (prefix === "-" && suggestion.text.startsWith("--")) continue;
+		if (prefix !== "" && !suggestion.text.startsWith(prefix)) continue;
+		if (seen.has(suggestion.text)) continue;
+		combined.push(suggestion);
+		seen.add(suggestion.text);
+	}
+	return combined;
+}
+function getSyncCompletionSuggestions(parser, args, rootOptionSuggestions) {
+	const prefix = args.at(-1) ?? "";
+	let context = createCompletionArgumentParserContext(parser, args.slice(0, -1));
+	while (context.buffer.length > 0) {
+		const result = parser.parse(context);
+		if (result instanceof Promise) throw new RunParserError("Synchronous parser returned async result.");
+		if (!result.success) {
+			const argumentContext = getFailedCompletionArgumentContext(result, context, parser, rootOptionSuggestions);
+			return {
+				suggestions: Array.from(parser.suggest(withCompletionSuggestRuntime(parser, context), prefix)),
+				argumentContext
+			};
+		}
+		const previousBuffer = context.buffer;
+		context = result.next;
+		if (isCompletionBufferUnchanged(previousBuffer, context.buffer)) return {
+			suggestions: [],
+			argumentContext: getCompletedCompletionArgumentContext(context)
+		};
+	}
+	return {
+		suggestions: Array.from(parser.suggest(withCompletionSuggestRuntime(parser, context), prefix)),
+		argumentContext: getCompletedCompletionArgumentContext(context)
+	};
+}
+async function getAsyncCompletionSuggestions(parser, args, rootOptionSuggestions) {
+	const prefix = args.at(-1) ?? "";
+	let context = createCompletionArgumentParserContext(parser, args.slice(0, -1));
+	while (context.buffer.length > 0) {
+		const result = await parser.parse(context);
+		if (!result.success) {
+			const argumentContext = getFailedCompletionArgumentContext(result, context, parser, rootOptionSuggestions);
+			const suggestions$1 = [];
+			const suggestContext$1 = await withCompletionSuggestRuntimeAsync(parser, context);
+			for await (const suggestion of parser.suggest(suggestContext$1, prefix)) suggestions$1.push(suggestion);
+			return {
+				suggestions: suggestions$1,
+				argumentContext
+			};
+		}
+		const previousBuffer = context.buffer;
+		context = result.next;
+		if (isCompletionBufferUnchanged(previousBuffer, context.buffer)) return {
+			suggestions: [],
+			argumentContext: getCompletedCompletionArgumentContext(context)
+		};
+	}
+	const suggestions = [];
+	const suggestContext = await withCompletionSuggestRuntimeAsync(parser, context);
+	for await (const suggestion of parser.suggest(suggestContext, prefix)) suggestions.push(suggestion);
+	return {
+		suggestions,
+		argumentContext: getCompletedCompletionArgumentContext(context)
+	};
+}
+function getCompletedCompletionArgumentContext(context) {
+	return {
+		completingOptionValue: false,
+		completedRootOption: false,
+		optionsTerminated: context.optionsTerminated
+	};
+}
+function withCompletionSuggestRuntime(parser, context) {
+	const runtime = createDependencyRuntimeContext();
+	const nodes = getCompletionSuggestRuntimeNodes(parser, context.state, context.exec?.path ?? []);
+	if (nodes.length > 0) collectExplicitSourceValues(nodes, runtime);
+	return addCompletionSuggestRuntime(context, runtime);
+}
+async function withCompletionSuggestRuntimeAsync(parser, context) {
+	const runtime = createDependencyRuntimeContext();
+	const nodes = getCompletionSuggestRuntimeNodes(parser, context.state, context.exec?.path ?? []);
+	if (nodes.length > 0) await collectExplicitSourceValuesAsync(nodes, runtime);
+	return addCompletionSuggestRuntime(context, runtime);
+}
+function addCompletionSuggestRuntime(context, runtime) {
+	return {
+		...context,
+		dependencyRegistry: runtime.registry,
+		exec: context.exec ? {
+			...context.exec,
+			dependencyRuntime: runtime,
+			dependencyRegistry: runtime.registry
+		} : void 0
+	};
+}
+function getCompletionSuggestRuntimeNodes(parser, state, path) {
+	if (typeof parser.getSuggestRuntimeNodes === "function") return parser.getSuggestRuntimeNodes(state, path);
+	if (parser.dependencyMetadata?.source == null) return [];
+	return [{
+		path,
+		parser,
+		state
+	}];
+}
+function createCompletionArgumentParserContext(parser, args) {
+	return createParserContext({
+		buffer: args,
+		state: parser.initialState,
+		optionsTerminated: false
+	}, {
+		usage: parser.usage,
+		phase: "suggest",
+		path: [],
+		trace: createInputTrace()
+	});
+}
+function getFailedCompletionArgumentContext(result, context, parser, rootOptionSuggestions) {
+	const activeValueOptionNames = collectActiveValueOptionNames(parser.usage, context.exec?.commandPath ?? [], result.consumed > 0, parser.leadingNames);
+	const token = context.buffer[0];
+	return {
+		completingOptionValue: (result.consumed === 0 || result.consumed === 1) && activeValueOptionNames.has(token),
+		completedRootOption: result.consumed === 0 && isRootOptionToken(token, rootOptionSuggestions),
+		optionsTerminated: context.optionsTerminated
+	};
+}
+function isCompletionBufferUnchanged(before, after) {
+	return before.length === after.length && before.every((arg, index) => arg === after[index]);
+}
+function collectActiveValueOptionNames(usage, commandPath, includeDirectAfterCommandOptions, rootLeadingNames) {
+	const optionNames = {
+		value: /* @__PURE__ */ new Set(),
+		flag: /* @__PURE__ */ new Set()
+	};
+	if (commandPath.length === 0) {
+		collectRootOptionNames(usage, optionNames, rootLeadingNames);
+		return optionNames.value;
+	} else collectActiveOptionNames(usage, commandPath, optionNames, false, includeDirectAfterCommandOptions);
+	const names = new Set(optionNames.value);
+	for (const name of optionNames.flag) names.delete(name);
+	return names;
+}
+function collectRootOptionNames(usage, names, rootLeadingNames) {
+	for (const term of usage) collectRootOptionNamesFromTerm(term, names, rootLeadingNames);
+}
+function collectRootOptionNamesFromTerm(term, names, rootLeadingNames) {
+	switch (term.type) {
+		case "option":
+			for (const name of term.names) {
+				if (!rootLeadingNames.has(name)) continue;
+				if (term.metavar != null) names.value.add(name);
+				else names.flag.add(name);
+			}
+			return;
+		case "optional":
+		case "multiple":
+			collectRootOptionNames(term.terms, names, rootLeadingNames);
+			return;
+		case "exclusive":
+			for (const branch of term.terms) collectRootOptionNames(branch, names, rootLeadingNames);
+			return;
+		case "argument":
+		case "command":
+		case "literal":
+		case "passthrough":
+		case "ellipsis": return;
+	}
+}
+function collectActiveOptionNames(usage, commandPath, names, fromExclusive, includeDirectAfterCommandOptions) {
+	if (commandPath.length === 0) {
+		collectOptionNamesAtCurrentCommandDepth(usage, names, false);
+		return;
+	}
+	const [commandName, ...rest] = commandPath;
+	for (let i = 0; i < usage.length; i++) {
+		const term = usage[i];
+		if (term.type === "command" && term.name === commandName) {
+			const remainingUsage = usage.slice(i + 1);
+			if (rest.length === 0) collectOptionNamesAtCurrentCommandDepth(remainingUsage, names, !fromExclusive && includeDirectAfterCommandOptions);
+			else collectActiveOptionNames(remainingUsage, rest, names, fromExclusive, includeDirectAfterCommandOptions);
+		} else if (term.type === "exclusive") for (const branch of term.terms) collectActiveOptionNames(branch, commandPath, names, true, includeDirectAfterCommandOptions);
+		else if (term.type === "optional" || term.type === "multiple") collectActiveOptionNames(term.terms, commandPath, names, fromExclusive, includeDirectAfterCommandOptions);
+	}
+}
+function isRootOptionToken(token, rootOptionSuggestions) {
+	return token != null && rootOptionSuggestions.some((suggestion) => token === suggestion.text || token.startsWith(`${suggestion.text}=`));
+}
+function collectOptionNamesAtCurrentCommandDepth(usage, names, afterMatchedCommand) {
+	for (const term of usage) if (collectOptionNamesAtCurrentCommandDepthFromTerm(term, names, afterMatchedCommand)) return;
+}
+function collectOptionNamesAtCurrentCommandDepthFromTerm(term, names, afterMatchedCommand) {
+	switch (term.type) {
+		case "command": return !afterMatchedCommand;
+		case "option":
+			if (term.metavar != null) for (const name of term.names) names.value.add(name);
+			else for (const name of term.names) names.flag.add(name);
+			return false;
+		case "optional":
+		case "multiple":
+			collectOptionNamesAtCurrentCommandDepth(term.terms, names, afterMatchedCommand);
+			return false;
+		case "exclusive":
+			for (const branch of term.terms) collectOptionNamesAtCurrentCommandDepth(branch, names, false);
+			return false;
+		case "argument":
+		case "literal":
+		case "passthrough":
+		case "ellipsis": return false;
+	}
+}
+function getRootMetaOptionSuggestions(helpOptionConfig, helpOptionNames, versionOptionConfig, versionOptionNames) {
+	const suggestions = [];
+	if (helpOptionConfig != null && !isSuggestionHidden(helpOptionConfig.hidden)) suggestions.push(...helpOptionNames.map((name) => ({
+		kind: "literal",
+		text: name
+	})));
+	if (versionOptionConfig != null && !isSuggestionHidden(versionOptionConfig.hidden)) suggestions.push(...versionOptionNames.map((name) => ({
+		kind: "literal",
+		text: name
+	})));
+	return suggestions;
+}
 /**
 * Validates the configured version value.
 *
@@ -852,6 +963,7 @@ function runParser(parserOrProgram, programNameOrArgs, argsOrOptions, optionsPar
 	const versionCommandNames = versionCommandConfig?.names ?? ["version"];
 	const completionCommandNames = completionCommandConfig?.names ?? ["completion"];
 	const completionOptionNames = completionOptionConfig?.names ?? ["--completion"];
+	const rootOptionSuggestions = getRootMetaOptionSuggestions(helpOptionConfig, helpOptionNames, versionOptionConfig, versionOptionNames);
 	const activeMetaEntries = [];
 	if (options.help && helpOptionConfig) activeMetaEntries.push([
 		"option",
@@ -915,7 +1027,7 @@ function runParser(parserOrProgram, programNameOrArgs, argsOrOptions, optionsPar
 		versionOptionGroup: versionOptionConfig?.group,
 		completionCommandGroup: completionCommandConfig?.group,
 		completionOptionGroup: completionOptionConfig?.group
-	}, helpOptionConfig ? [...helpOptionNames] : void 0, versionOptionConfig ? [...versionOptionNames] : void 0);
+	});
 	const handleResult = (classified) => {
 		switch (classified.type) {
 			case "success": return classified.value;
@@ -926,7 +1038,7 @@ function runParser(parserOrProgram, programNameOrArgs, argsOrOptions, optionsPar
 				classified.shell,
 				...classified.commandPath ?? [],
 				...classified.args
-			], programName, parser, classified.source === "command" ? completionParsers.completionCommand : completionParsers.completionOption, stdout, stderr, onCompletionResult, onErrorResult, availableShells, colors, maxWidth, completionCommandNames[0], completionOptionNames[0], classified.source === "option", sectionOrder);
+			], programName, parser, classified.source === "command" ? completionParsers.completionCommand : completionParsers.completionOption, stdout, stderr, onCompletionResult, onErrorResult, availableShells, colors, maxWidth, completionCommandNames[0], completionOptionNames[0], classified.source === "option", sectionOrder, rootOptionSuggestions);
 			case "help": {
 				let helpGeneratorParser;
 				const helpAsCommand = helpCommandConfig != null;

package/dist/index.cjs

@@ -81,6 +81,7 @@ exports.mergeHidden = require_usage.mergeHidden;
 exports.message = require_message.message;
 exports.metavar = require_message.metavar;
 exports.multiple = require_modifiers.multiple;
+exports.negatableFlag = require_primitives.negatableFlag;
 exports.nonEmpty = require_modifiers.nonEmpty;
 exports.normalizeUsage = require_usage.normalizeUsage;
 exports.nu = require_completion.nu;

package/dist/index.d.cts

@@ -11,5 +11,5 @@ import { ParserValuePlaceholder, SourceContext, SourceContextRequest } from "./c
 import { AnyDependencySource, CombineMode, CombinedDependencyMode, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, dependency, deriveFrom, deriveFromAsync, deriveFromSync, isDependencySource, isDerivedValueParser } from "./internal/dependency.cjs";
 import { CommandSubConfig, ContextOptionsParam, ExtractRequiredOptions, OptionSubConfig, RunOptions, RunParserError, RunWithOptions, SubstituteParserValue, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync } from "./facade.cjs";
 import { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, nonEmpty, optional, withDefault } from "./modifiers.cjs";
-import { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, FlagErrorOptions, FlagOptions, OptionErrorOptions, OptionOptions, OptionState, PassThroughFormat, PassThroughOptions, argument, command, constant, fail, flag, option, passThrough } from "./primitives.cjs";
-export { type Annotations, AnyDependencySource, ArgumentErrorOptions, ArgumentOptions, ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, CombineMode, CombineModes, CombinedDependencyMode, CommandErrorOptions, CommandOptions, CommandSubConfig, ConditionalErrorOptions, ConditionalOptions, ContextOptionsParam, DeferredMap, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, DocState, DomainOptions, DuplicateOptionError, EmailOptions, ExecutionContext, ExecutionPhase, ExtractRequiredOptions, FlagErrorOptions, FlagOptions, FloatOptions, GroupOptions, HiddenVisibility, HostnameOptions, InferMode, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, LongestMatchErrorOptions, LongestMatchOptions, MacAddressOptions, MergeOptions, type Message, type MessageFormatOptions, type MessageTerm, Mode, ModeIterable, ModeValue, MultipleErrorOptions, MultipleOptions, NoMatchContext, NonEmptyString, ObjectErrorOptions, ObjectOptions, OptionErrorOptions, OptionName, OptionOptions, OptionState, OptionSubConfig, OrErrorOptions, OrOptions, ParseFrame, type ParseOptions, Parser, ParserContext, ParserResult, ParserValuePlaceholder, PassThroughFormat, PassThroughOptions, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, Result, RunOptions, RunParserError, RunWithOptions, ShellCompletion, ShowChoicesOptions, ShowDefaultOptions, SocketAddressOptions, SocketAddressValue, SourceContext, SourceContextRequest, StringOptions, SubstituteParserValue, Suggestion, TupleOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, type ValueSetOptions, WithDefaultError, WithDefaultOptions, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };
+import { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, FlagErrorOptions, FlagOptions, NegatableFlagErrorOptions, NegatableFlagNameList, NegatableFlagNames, NegatableFlagOptions, NegatableFlagState, OptionErrorOptions, OptionOptions, OptionState, PassThroughFormat, PassThroughOptions, argument, command, constant, fail, flag, negatableFlag, option, passThrough } from "./primitives.cjs";
+export { type Annotations, AnyDependencySource, ArgumentErrorOptions, ArgumentOptions, ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, CombineMode, CombineModes, CombinedDependencyMode, CommandErrorOptions, CommandOptions, CommandSubConfig, ConditionalErrorOptions, ConditionalOptions, ContextOptionsParam, DeferredMap, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, DocState, DomainOptions, DuplicateOptionError, EmailOptions, ExecutionContext, ExecutionPhase, ExtractRequiredOptions, FlagErrorOptions, FlagOptions, FloatOptions, GroupOptions, HiddenVisibility, HostnameOptions, InferMode, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, LongestMatchErrorOptions, LongestMatchOptions, MacAddressOptions, MergeOptions, type Message, type MessageFormatOptions, type MessageTerm, Mode, ModeIterable, ModeValue, MultipleErrorOptions, MultipleOptions, NegatableFlagErrorOptions, NegatableFlagNameList, NegatableFlagNames, NegatableFlagOptions, NegatableFlagState, NoMatchContext, NonEmptyString, ObjectErrorOptions, ObjectOptions, OptionErrorOptions, OptionName, OptionOptions, OptionState, OptionSubConfig, OrErrorOptions, OrOptions, ParseFrame, type ParseOptions, Parser, ParserContext, ParserResult, ParserValuePlaceholder, PassThroughFormat, PassThroughOptions, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, Result, RunOptions, RunParserError, RunWithOptions, ShellCompletion, ShowChoicesOptions, ShowDefaultOptions, SocketAddressOptions, SocketAddressValue, SourceContext, SourceContextRequest, StringOptions, SubstituteParserValue, Suggestion, TupleOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, type ValueSetOptions, WithDefaultError, WithDefaultOptions, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, negatableFlag, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };

package/dist/index.d.ts

@@ -11,5 +11,5 @@ import { ParserValuePlaceholder, SourceContext, SourceContextRequest } from "./c
 import { AnyDependencySource, CombineMode, CombinedDependencyMode, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, dependency, deriveFrom, deriveFromAsync, deriveFromSync, isDependencySource, isDerivedValueParser } from "./internal/dependency.js";
 import { CommandSubConfig, ContextOptionsParam, ExtractRequiredOptions, OptionSubConfig, RunOptions, RunParserError, RunWithOptions, SubstituteParserValue, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync } from "./facade.js";
 import { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, nonEmpty, optional, withDefault } from "./modifiers.js";
-import { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, FlagErrorOptions, FlagOptions, OptionErrorOptions, OptionOptions, OptionState, PassThroughFormat, PassThroughOptions, argument, command, constant, fail, flag, option, passThrough } from "./primitives.js";
-export { type Annotations, AnyDependencySource, ArgumentErrorOptions, ArgumentOptions, ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, CombineMode, CombineModes, CombinedDependencyMode, CommandErrorOptions, CommandOptions, CommandSubConfig, ConditionalErrorOptions, ConditionalOptions, ContextOptionsParam, DeferredMap, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, DocState, DomainOptions, DuplicateOptionError, EmailOptions, ExecutionContext, ExecutionPhase, ExtractRequiredOptions, FlagErrorOptions, FlagOptions, FloatOptions, GroupOptions, HiddenVisibility, HostnameOptions, InferMode, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, LongestMatchErrorOptions, LongestMatchOptions, MacAddressOptions, MergeOptions, type Message, type MessageFormatOptions, type MessageTerm, Mode, ModeIterable, ModeValue, MultipleErrorOptions, MultipleOptions, NoMatchContext, NonEmptyString, ObjectErrorOptions, ObjectOptions, OptionErrorOptions, OptionName, OptionOptions, OptionState, OptionSubConfig, OrErrorOptions, OrOptions, ParseFrame, type ParseOptions, Parser, ParserContext, ParserResult, ParserValuePlaceholder, PassThroughFormat, PassThroughOptions, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, Result, RunOptions, RunParserError, RunWithOptions, ShellCompletion, ShowChoicesOptions, ShowDefaultOptions, SocketAddressOptions, SocketAddressValue, SourceContext, SourceContextRequest, StringOptions, SubstituteParserValue, Suggestion, TupleOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, type ValueSetOptions, WithDefaultError, WithDefaultOptions, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };
+import { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, FlagErrorOptions, FlagOptions, NegatableFlagErrorOptions, NegatableFlagNameList, NegatableFlagNames, NegatableFlagOptions, NegatableFlagState, OptionErrorOptions, OptionOptions, OptionState, PassThroughFormat, PassThroughOptions, argument, command, constant, fail, flag, negatableFlag, option, passThrough } from "./primitives.js";
+export { type Annotations, AnyDependencySource, ArgumentErrorOptions, ArgumentOptions, ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, CombineMode, CombineModes, CombinedDependencyMode, CommandErrorOptions, CommandOptions, CommandSubConfig, ConditionalErrorOptions, ConditionalOptions, ContextOptionsParam, DeferredMap, DependencyMode, DependencySource, DependencyValue, DependencyValues, DeriveAsyncOptions, DeriveFromAsyncOptions, DeriveFromOptions, DeriveFromSyncOptions, DeriveOptions, DeriveSyncOptions, DerivedValueParser, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, DocState, DomainOptions, DuplicateOptionError, EmailOptions, ExecutionContext, ExecutionPhase, ExtractRequiredOptions, FlagErrorOptions, FlagOptions, FloatOptions, GroupOptions, HiddenVisibility, HostnameOptions, InferMode, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, LongestMatchErrorOptions, LongestMatchOptions, MacAddressOptions, MergeOptions, type Message, type MessageFormatOptions, type MessageTerm, Mode, ModeIterable, ModeValue, MultipleErrorOptions, MultipleOptions, NegatableFlagErrorOptions, NegatableFlagNameList, NegatableFlagNames, NegatableFlagOptions, NegatableFlagState, NoMatchContext, NonEmptyString, ObjectErrorOptions, ObjectOptions, OptionErrorOptions, OptionName, OptionOptions, OptionState, OptionSubConfig, OrErrorOptions, OrOptions, ParseFrame, type ParseOptions, Parser, ParserContext, ParserResult, ParserValuePlaceholder, PassThroughFormat, PassThroughOptions, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, Result, RunOptions, RunParserError, RunWithOptions, ShellCompletion, ShowChoicesOptions, ShowDefaultOptions, SocketAddressOptions, SocketAddressValue, SourceContext, SourceContextRequest, StringOptions, SubstituteParserValue, Suggestion, TupleOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, type ValueSetOptions, WithDefaultError, WithDefaultOptions, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, negatableFlag, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };

package/dist/index.js

@@ -9,7 +9,7 @@ import { DuplicateOptionError, concat, conditional, group, longestMatch, merge,
 import { WithDefaultError, map, multiple, nonEmpty, optional, withDefault } from "./modifiers.js";
 import { ensureNonEmptyString, isNonEmptyString } from "./nonempty.js";
 import { checkBooleanOption, checkEnumOption, choice, cidr, domain, email, float, hostname, integer, ip, ipv4, ipv6, isValueParser, locale, macAddress, port, portRange, socketAddress, string, url, uuid } from "./valueparser.js";
-import { argument, command, constant, fail, flag, option, passThrough } from "./primitives.js";
+import { argument, command, constant, fail, flag, negatableFlag, option, passThrough } from "./primitives.js";
 import { RunParserError, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync } from "./facade.js";
 
-export { DuplicateOptionError, RunParserError, WithDefaultError, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };
+export { DuplicateOptionError, RunParserError, WithDefaultError, argument, bash, checkBooleanOption, checkEnumOption, choice, cidr, cloneDocEntry, cloneUsage, cloneUsageTerm, command, commandLine, concat, conditional, constant, createParserContext, deduplicateDocEntries, deduplicateDocFragments, dependency, deriveFrom, deriveFromAsync, deriveFromSync, domain, email, ensureNonEmptyString, envVar, extractArgumentMetavars, extractCommandNames, extractLiteralValues, extractOptionNames, fail, fish, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getAnnotations, getDocPage, getDocPageAsync, getDocPageSync, group, hostname, integer, ip, ipv4, ipv6, isDependencySource, isDerivedValueParser, isDocEntryHidden, isDocHidden, isNonEmptyString, isSuggestionHidden, isUsageHidden, isValueParser, lineBreak, link, locale, longestMatch, macAddress, map, merge, mergeHidden, message, metavar, multiple, negatableFlag, nonEmpty, normalizeUsage, nu, object, option, optionName, optionNames, optional, or, parse, parseAsync, parseSync, passThrough, port, portRange, pwsh, runParser, runParserAsync, runParserSync, runWith, runWithAsync, runWithSync, socketAddress, string, suggest, suggestAsync, suggestSync, text, tuple, url, uuid, value, valueSet, values, withDefault, zsh };