@optique/core 1.1.0-dev.2148 → 1.1.0-dev.2160

package/dist/valueparser.js

@@ -327,6 +327,323 @@ function string(options = {}) {
 		}
 	};
 }
+function keyValue(options = {}) {
+	const separator = options.separator ?? "=";
+	if (typeof separator !== "string") throw new TypeError(`Expected separator to be a string, but got ${typeof separator}: ${String(separator)}.`);
+	ensureNonEmptyString(separator);
+	checkBooleanOption(options, "allowEmptyKey");
+	checkBooleanOption(options, "allowEmptyValue");
+	checkEnumOption(options, "split", ["first", "last"]);
+	const split = options.split ?? "first";
+	const allowEmptyKey = options.allowEmptyKey ?? false;
+	const allowEmptyValue = options.allowEmptyValue ?? true;
+	const metavar$1 = options.metavar ?? `KEY${separator}VALUE`;
+	ensureNonEmptyString(metavar$1);
+	const rawKeyParser = options.key ?? string({ placeholder: "KEY" });
+	const rawValueParser = options.value ?? string({ placeholder: allowEmptyValue ? "" : "VALUE" });
+	checkKeyValueChildParser("key", rawKeyParser);
+	checkKeyValueChildParser("value", rawValueParser);
+	const keyParser = rawKeyParser;
+	const valueParser = rawValueParser;
+	const hasNormalize = typeof keyParser.normalize === "function" || typeof valueParser.normalize === "function";
+	const hasSuggest = typeof keyParser.suggest === "function" || typeof valueParser.suggest === "function";
+	function findSeparator(input) {
+		return split === "last" ? input.lastIndexOf(separator) : input.indexOf(separator);
+	}
+	function emptyKeyError(input) {
+		const custom = options.errors?.emptyKey;
+		if (custom != null) return typeof custom === "function" ? custom(input) : custom;
+		return message`Expected a non-empty key in ${input}.`;
+	}
+	function emptyValueError(input) {
+		const custom = options.errors?.emptyValue;
+		if (custom != null) return typeof custom === "function" ? custom(input) : custom;
+		return message`Expected a non-empty value in ${input}.`;
+	}
+	function missingSeparatorError(input) {
+		const custom = options.errors?.missingSeparator;
+		if (custom != null) return typeof custom === "function" ? custom(input, separator) : custom;
+		return message`Expected ${separator} in ${input}.`;
+	}
+	function invalidKeyError(error) {
+		const custom = options.errors?.invalidKey;
+		if (custom != null) return typeof custom === "function" ? custom(error) : custom;
+		return [text("Invalid key: "), ...cloneMessage(error)];
+	}
+	function invalidValueError(error) {
+		const custom = options.errors?.invalidValue;
+		if (custom != null) return typeof custom === "function" ? custom(error) : custom;
+		return [text("Invalid value: "), ...cloneMessage(error)];
+	}
+	function validateParts(input, key, value) {
+		if (!allowEmptyKey && key === "") return {
+			success: false,
+			error: emptyKeyError(input)
+		};
+		if (!allowEmptyValue && value === "") return {
+			success: false,
+			error: emptyValueError(input)
+		};
+		const keyResult = keyParser.parse(key);
+		if (!keyResult.success) return {
+			success: false,
+			error: invalidKeyError(keyResult.error)
+		};
+		const valueResult = valueParser.parse(value);
+		if (!valueResult.success) return {
+			success: false,
+			error: invalidValueError(valueResult.error)
+		};
+		return validateResultParts(input, keyResult, valueResult);
+	}
+	function validateKeyForSuggestion(key) {
+		if (!allowEmptyKey && key === "") return false;
+		if (!partsRoundTrip(key, "")) return false;
+		const keyResult = keyParser.parse(key);
+		if (!keyResult.success) return false;
+		if (!allowEmptyKey && keyResult.value === "") return false;
+		const formattedKeyResult = formatValueParserValue(keyParser, keyResult.value);
+		if (!formattedKeyResult.success) return false;
+		const formattedKey = formattedKeyResult.value;
+		return formattedKey == null || partsRoundTrip(formattedKey, "");
+	}
+	function validateKeyPatternForSuggestion(key) {
+		if (!allowEmptyKey && key === "") return false;
+		return partsRoundTrip(key, "");
+	}
+	function fallbackInput(key, value) {
+		return `${typeof key === "string" ? key : ""}${separator}${typeof value === "string" ? value : ""}`;
+	}
+	function partsRoundTrip(key, value) {
+		const input = `${key}${separator}${value}`;
+		const index = findSeparator(input);
+		if (index < 0) return false;
+		return input.slice(0, index) === key && input.slice(index + separator.length) === value;
+	}
+	function validateResultParts(input, keyResult, valueResult) {
+		if (!allowEmptyKey && keyResult.value === "") return {
+			success: false,
+			error: emptyKeyError(input)
+		};
+		if (!allowEmptyValue && valueResult.value === "") return {
+			success: false,
+			error: emptyValueError(input)
+		};
+		const formattedKeyResult = formatValueParserValue(keyParser, keyResult.value);
+		if (!formattedKeyResult.success) return {
+			success: false,
+			error: invalidKeyError(formattedKeyResult.error)
+		};
+		const formattedValueResult = formatValueParserValue(valueParser, valueResult.value);
+		if (!formattedValueResult.success) return {
+			success: false,
+			error: invalidValueError(formattedValueResult.error)
+		};
+		const formattedKey = formattedKeyResult.value;
+		const formattedValue = formattedValueResult.value;
+		if (!allowEmptyKey && formattedKey === "") return {
+			success: false,
+			error: emptyKeyError(input)
+		};
+		if (!allowEmptyValue && formattedValue === "") return {
+			success: false,
+			error: emptyValueError(input)
+		};
+		if (split === "first" && formattedKey != null && formattedKey.includes(separator)) return {
+			success: false,
+			error: invalidKeyError(message`Expected a key without ${separator}, but got ${formattedKey}.`)
+		};
+		if (split === "last" && formattedValue != null && formattedValue.includes(separator)) return {
+			success: false,
+			error: invalidValueError(message`Expected a value without ${separator}, but got ${formattedValue}.`)
+		};
+		if (formattedKey != null && formattedValue != null) {
+			if (!partsRoundTrip(formattedKey, formattedValue)) return split === "first" ? {
+				success: false,
+				error: invalidKeyError(message`Expected a key that round-trips with ${separator}, but got ${formattedKey}.`)
+			} : {
+				success: false,
+				error: invalidValueError(message`Expected a value that round-trips with ${separator}, but got ${formattedValue}.`)
+			};
+		}
+		return makeKeyValueSuccess(keyResult, valueResult);
+	}
+	function validateTuple(value) {
+		if (!allowEmptyKey && value[0] === "") return {
+			success: false,
+			error: emptyKeyError(fallbackInput(value[0], value[1]))
+		};
+		if (!allowEmptyValue && value[1] === "") return {
+			success: false,
+			error: emptyValueError(fallbackInput(value[0], value[1]))
+		};
+		const keyResult = validateValueParserValue(keyParser, value[0]);
+		if (!keyResult.success) return {
+			success: false,
+			error: invalidKeyError(keyResult.error)
+		};
+		const valueResult = validateValueParserValue(valueParser, value[1]);
+		if (!valueResult.success) return {
+			success: false,
+			error: invalidValueError(valueResult.error)
+		};
+		return validateResultParts(fallbackInput(value[0], value[1]), keyResult, valueResult);
+	}
+	return {
+		mode: "sync",
+		metavar: metavar$1,
+		placeholder: [keyParser.placeholder, valueParser.placeholder],
+		parse(input) {
+			const index = findSeparator(input);
+			if (index < 0) return {
+				success: false,
+				error: missingSeparatorError(input)
+			};
+			const key = input.slice(0, index);
+			const value = input.slice(index + separator.length);
+			return validateParts(input, key, value);
+		},
+		format(value) {
+			return `${keyParser.format(value[0])}${separator}${valueParser.format(value[1])}`;
+		},
+		validate(value) {
+			if (!isKeyValueTuple(value)) return {
+				success: false,
+				error: message`Expected a key-value tuple.`
+			};
+			return validateTuple(value);
+		},
+		...hasNormalize ? { normalize(value) {
+			if (!isKeyValueTuple(value)) return value;
+			const normalized = [typeof keyParser.normalize === "function" ? keyParser.normalize(value[0]) : value[0], typeof valueParser.normalize === "function" ? valueParser.normalize(value[1]) : value[1]];
+			return validateTuple(normalized).success ? normalized : value;
+		} } : {},
+		...hasSuggest ? { *suggest(prefix) {
+			const index = findSeparator(prefix);
+			const suggestions = [];
+			if (index < 0 || split === "last") {
+				if (typeof keyParser.suggest === "function") for (const suggestion of keyParser.suggest(prefix)) {
+					const key = suggestionTextValue(suggestion);
+					if (suggestion.kind === "literal" ? !validateKeyForSuggestion(key) : !validateKeyPatternForSuggestion(key)) continue;
+					suggestions.push(prefixKeyValueSuggestion(suggestion, "", separator));
+				}
+			}
+			if (index < 0) {
+				yield* deduplicateSuggestions(suggestions);
+				return;
+			}
+			if (typeof valueParser.suggest === "function") {
+				const key = prefix.slice(0, index);
+				if (!validateKeyForSuggestion(key)) {
+					yield* deduplicateSuggestions(suggestions);
+					return;
+				}
+				const valuePrefix = prefix.slice(index + separator.length);
+				for (const suggestion of valueParser.suggest(valuePrefix)) {
+					const value = suggestionTextValue(suggestion);
+					if (!partsRoundTrip(key, value)) continue;
+					if (suggestion.kind === "literal" && !validateParts(`${key}${separator}${value}`, key, value).success) continue;
+					suggestions.push(prefixKeyValueSuggestion(suggestion, `${key}${separator}`));
+				}
+			}
+			yield* deduplicateSuggestions(suggestions);
+		} } : {}
+	};
+}
+function checkKeyValueChildParser(role, parser) {
+	if (!isValueParser(parser)) throw new TypeError(`The ${role} option for keyValue() must be a value parser.`);
+	if (parser.mode !== "sync") throw new TypeError(`keyValue() only supports sync ${role} parsers, but an async one was given.`);
+	if (isDerivedValueParser(parser)) throw new TypeError(`keyValue() does not support dependency-derived ${role} parsers (created via deriveFrom() or dependency().derive()); pass the derived parser directly to option() or argument() instead.`);
+}
+function validateValueParserValue(parser, value) {
+	if (typeof parser.validate === "function") return parser.validate(value);
+	let formatted;
+	try {
+		formatted = parser.format(value);
+	} catch {
+		return {
+			success: true,
+			value
+		};
+	}
+	if (typeof formatted !== "string") return {
+		success: false,
+		error: stringFormatError()
+	};
+	return parser.parse(formatted);
+}
+function formatValueParserValue(parser, value) {
+	let formatted;
+	try {
+		formatted = parser.format(value);
+	} catch {
+		return {
+			success: true,
+			value: void 0
+		};
+	}
+	if (typeof formatted !== "string") return {
+		success: false,
+		error: stringFormatError()
+	};
+	return {
+		success: true,
+		value: formatted
+	};
+}
+function stringFormatError() {
+	return message`Expected a value formatted as a string.`;
+}
+function suggestionTextValue(suggestion) {
+	return suggestion.kind === "literal" ? suggestion.text : suggestion.pattern ?? "";
+}
+function prefixKeyValueSuggestion(suggestion, prefix, suffix = "") {
+	const textValue = suggestionTextValue(suggestion);
+	const text$1 = `${prefix}${textValue}${suffix}`;
+	if (suggestion.kind === "file" && suffix === "") return {
+		...suggestion,
+		pattern: text$1
+	};
+	return suggestion.description == null ? {
+		kind: "literal",
+		text: text$1
+	} : {
+		kind: "literal",
+		text: text$1,
+		description: suggestion.description
+	};
+}
+function isKeyValueTuple(value) {
+	return Array.isArray(value) && value.length === 2 && 0 in value && 1 in value;
+}
+function makeKeyValueSuccess(keyResult, valueResult) {
+	const deferredKeys = /* @__PURE__ */ new Map();
+	let hasDeferred = false;
+	collectKeyValueDeferredKeys(deferredKeys, 0, keyResult, () => {
+		hasDeferred = true;
+	});
+	collectKeyValueDeferredKeys(deferredKeys, 1, valueResult, () => {
+		hasDeferred = true;
+	});
+	return {
+		success: true,
+		value: [keyResult.value, valueResult.value],
+		...hasDeferred ? {
+			deferred: true,
+			...deferredKeys.size > 0 ? { deferredKeys } : {}
+		} : {}
+	};
+}
+function collectKeyValueDeferredKeys(deferredKeys, index, result, markDeferred) {
+	if (result.deferredKeys != null) {
+		markDeferred();
+		deferredKeys.set(index, result.deferredKeys);
+		return;
+	}
+	if (result.deferred !== true) return;
+	markDeferred();
+	deferredKeys.set(index, null);
+}
 /**
 * Creates a ValueParser for parsing integer values from strings.
 *
@@ -3088,7 +3405,7 @@ function email(options) {
 * Creates a value parser for socket addresses in "host:port" format.
 *
 * Validates socket addresses with support for:
-* - Hostnames and IPv4 addresses (IPv6 support coming in future versions)
+* - Hostnames, IPv4 addresses, and IPv6 addresses
 * - Configurable host:port separator
 * - Optional default port
 * - Host type filtering (hostname only, IP only, or both)
@@ -3099,6 +3416,8 @@ function email(options) {
 * @throws {TypeError} If `separator` is an empty string.
 * @throws {TypeError} If `separator` contains digit characters, since digits
 *   in the separator would cause ambiguous splitting of port input.
+* @throws {TypeError} If `host.version` is provided but is not `4`, `6`, or
+*   `"both"`.
 * @since 0.10.0
 *
 * @example
@@ -3128,12 +3447,25 @@ function socketAddress(options) {
 	const defaultPort = options?.defaultPort;
 	const requirePort = options?.requirePort ?? false;
 	const hostType = options?.host?.type ?? "both";
+	const rawHostVersion = options?.host?.version;
+	if (rawHostVersion !== void 0 && rawHostVersion !== 4 && rawHostVersion !== 6 && rawHostVersion !== "both") throw new TypeError(`Expected host.version to be 4, 6, or "both", but got ${Array.isArray(rawHostVersion) ? "array" : typeof rawHostVersion}: ${String(rawHostVersion)}.`);
+	const hasLegacyIpOptions = options?.host?.ip !== void 0;
+	const hasNewIpOptions = rawHostVersion !== void 0 || options?.host?.ipv4 !== void 0 || options?.host?.ipv6 !== void 0;
+	const hostVersion = rawHostVersion ?? (hasLegacyIpOptions && !hasNewIpOptions ? 4 : "both");
 	const hostnameParser = hostname({
 		...options?.host?.hostname,
 		metavar: "HOST"
 	});
-	const ipParser = ipv4({
+	const ipv4Options = {
 		...options?.host?.ip,
+		...options?.host?.ipv4
+	};
+	const ipv4Parser = ipv4({
+		...ipv4Options,
+		metavar: "HOST"
+	});
+	const ipv6Parser = ipv6({
+		...options?.host?.ipv6,
 		metavar: "HOST"
 	});
 	const disambiguationParser = hostType === "ip" ? hostname({
@@ -3151,6 +3483,15 @@ function socketAddress(options) {
 	function looksLikeIpv4(input) {
 		return /^\d+\.\d+\.\d+\.\d+$/.test(input);
 	}
+	function looksLikeIpv6(input) {
+		const colonCount = input.match(/:/g)?.length ?? 0;
+		return colonCount >= 2 && (input.includes("::") || /^[0-9a-fA-F:.]+$/.test(input));
+	}
+	function looksLikeBareIpv6(input) {
+		if (!looksLikeIpv6(input)) return false;
+		if (parseAndNormalizeIpv6(input) !== null) return true;
+		return input.includes("::") || !input.includes(".");
+	}
 	function looksLikeAltIpv4Literal(input) {
 		if (/^0[xX][0-9a-fA-F]+$/.test(input)) {
 			const n = parseInt(input.slice(2), 16);
@@ -3176,6 +3517,22 @@ function socketAddress(options) {
 		}
 		return false;
 	}
+	function parseIpHost(hostInput) {
+		if (hostVersion === 4) return ipv4Parser.parse(hostInput);
+		if (hostVersion === 6) return ipv6Parser.parse(hostInput);
+		if (looksLikeIpv6(hostInput)) {
+			const result = ipv6Parser.parse(hostInput);
+			if (result.success) {
+				const mappedOctets = extractIpv4FromMapped(result.value);
+				if (mappedOctets !== null) {
+					const restrictionError = checkIpv4MappedRestrictions(mappedOctets, result.value, ipv4Options, void 0);
+					if (restrictionError !== null) return restrictionError;
+				}
+			}
+			return result;
+		}
+		return ipv4Parser.parse(hostInput);
+	}
 	function parseHost(hostInput) {
 		if (hostType === "hostname") {
 			if (looksLikeAltIpv4Literal(hostInput)) return {
@@ -3187,22 +3544,106 @@ function socketAddress(options) {
 				error: message`Expected a valid hostname, but got ${hostInput}.`
 			};
 			return hostnameParser.parse(hostInput);
-		} else if (hostType === "ip") return ipParser.parse(hostInput);
+		} else if (hostType === "ip") return parseIpHost(hostInput);
 		else {
 			if (looksLikeAltIpv4Literal(hostInput)) return {
 				success: false,
 				error: message`${hostInput} appears to be a non-standard IPv4 address notation.`
 			};
-			if (looksLikeIpv4(hostInput)) return ipParser.parse(hostInput);
+			if (looksLikeIpv4(hostInput)) return parseIpHost(hostInput);
+			if (looksLikeIpv6(hostInput)) return parseIpHost(hostInput);
 			return hostnameParser.parse(hostInput);
 		}
 	}
-	return {
+	function makeInvalidFormatError(input) {
+		const errorMsg = options?.errors?.invalidFormat;
+		const msg = typeof errorMsg === "function" ? errorMsg(input) : errorMsg ?? message`Expected a socket address in format ${text(formatExample)}, but got ${input}.`;
+		return {
+			success: false,
+			error: msg
+		};
+	}
+	function makeMissingPortError(input) {
+		const errorMsg = options?.errors?.missingPort;
+		const msg = typeof errorMsg === "function" ? errorMsg(input) : errorMsg ?? message`Port number is required but was not specified.`;
+		return {
+			success: false,
+			error: msg
+		};
+	}
+	function parseBracketedHost(input, trimmed, canOmitPort) {
+		if (!trimmed.startsWith("[")) return void 0;
+		const closingBracket = trimmed.indexOf("]");
+		if (closingBracket === -1) return makeInvalidFormatError(input);
+		const hostInput = trimmed.slice(1, closingBracket);
+		if (!looksLikeBareIpv6(hostInput)) return makeInvalidFormatError(input);
+		const rest = trimmed.slice(closingBracket + 1).trimStart();
+		const hostResult = parseHost(hostInput);
+		if (rest === "") {
+			if (!hostResult.success) {
+				if (options?.errors?.invalidFormat) return makeInvalidFormatError(input);
+				return {
+					success: false,
+					error: hostResult.error
+				};
+			}
+			if (canOmitPort) return {
+				success: true,
+				value: {
+					host: hostResult.value,
+					port: defaultPort
+				}
+			};
+			return makeMissingPortError(input);
+		}
+		if (!rest.startsWith(separator)) return makeInvalidFormatError(input);
+		const portPart = rest.slice(separator.length).trim();
+		if (portPart === "") {
+			if (!hostResult.success) {
+				if (options?.errors?.invalidFormat) return makeInvalidFormatError(input);
+				return {
+					success: false,
+					error: hostResult.error
+				};
+			}
+			return makeMissingPortError(input);
+		}
+		const portResult = portParser.parse(portPart);
+		if (!hostResult.success) {
+			if (options?.errors?.invalidFormat) return makeInvalidFormatError(input);
+			return {
+				success: false,
+				error: hostResult.error
+			};
+		}
+		if (portResult.success) return {
+			success: true,
+			value: {
+				host: hostResult.value,
+				port: portResult.value
+			}
+		};
+		if (options?.errors?.invalidFormat) return makeInvalidFormatError(input);
+		if (/^[0-9]+$/.test(portPart)) return {
+			success: false,
+			error: portResult.error
+		};
+		return makeInvalidFormatError(input);
+	}
+	function isSocketAddressValue(value) {
+		return typeof value === "object" && value !== null && "host" in value && typeof value.host === "string" && "port" in value && typeof value.port === "number";
+	}
+	function formatSocketAddressValue(value) {
+		const ipv6Host = parseAndNormalizeIpv6(value.host);
+		if (separator === ":" && ipv6Host !== null) return `[${ipv6Host}]${separator}${value.port}`;
+		return `${value.host}${separator}${value.port}`;
+	}
+	const parser = {
 		mode: "sync",
 		metavar: metavar$1,
 		get placeholder() {
 			return {
-				host: hostType === "ip" ? ipParser.placeholder : hostnameParser.placeholder,
+				host: hostType === "ip" ? hostVersion === 6 ? ipv6Parser.placeholder : ipv4Parser.placeholder : hostnameParser.placeholder,
 				port: defaultPort ?? portParser.placeholder
 			};
 		},
@@ -3210,6 +3651,28 @@ function socketAddress(options) {
 			const trimmed = input.trim();
 			const searchInput = input.trimStart();
 			const canOmitPort = defaultPort !== void 0 && !requirePort;
+			if (separator === ":") {
+				const bracketedResult = parseBracketedHost(input, trimmed, canOmitPort);
+				if (bracketedResult !== void 0) return bracketedResult;
+				if (looksLikeBareIpv6(trimmed)) {
+					const hostResult = parseHost(trimmed);
+					if (hostResult.success) {
+						if (canOmitPort) return {
+							success: true,
+							value: {
+								host: hostResult.value,
+								port: defaultPort
+							}
+						};
+						return makeMissingPortError(input);
+					}
+					if (options?.errors?.invalidFormat) return makeInvalidFormatError(input);
+					return {
+						success: false,
+						error: hostResult.error
+					};
+				}
+			}
 			let firstHostError;
 			let validHostInvalidPortError;
 			let trailingSepHost;
@@ -3407,9 +3870,19 @@ function socketAddress(options) {
 			};
 		},
 		format(value) {
-			return `${value.host}${separator}${value.port}`;
+			return formatSocketAddressValue(value);
+		},
+		normalize(value) {
+			if (!isSocketAddressValue(value)) return value;
+			try {
+				const result = parser.parse(formatSocketAddressValue(value));
+				return result.success ? result.value : value;
+			} catch {
+				return value;
+			}
 		}
 	};
+	return parser;
 }
 function portRange(options) {
 	checkBooleanOption(options, "disallowWellKnown");
@@ -4323,7 +4796,7 @@ function parseAndNormalizeIpv6(input) {
 		const leftGroups = parts[0] ? parts[0].split(":") : [];
 		const rightGroups = parts[1] ? parts[1].split(":") : [];
 		const totalGroups = leftGroups.length + rightGroups.length;
-		if (totalGroups > 8) return null;
+		if (totalGroups >= 8) return null;
 		const zeroCount = 8 - totalGroups;
 		const zeros = Array(zeroCount).fill("0");
 		groups = [
@@ -4354,7 +4827,7 @@ function expandIpv6(input) {
 		const leftGroups = parts[0] ? parts[0].split(":").filter((g) => g) : [];
 		const rightGroups = parts[1] ? parts[1].split(":").filter((g) => g) : [];
 		const totalGroups = leftGroups.length + rightGroups.length;
-		if (totalGroups > 8) return null;
+		if (totalGroups >= 8) return null;
 		const zeroCount = 8 - totalGroups;
 		const zeros = Array(zeroCount).fill("0");
 		const groups = [
@@ -5624,4 +6097,4 @@ function plainObjectsEqual(a, b) {
 }
 
 //#endregion
-export { checkBooleanOption, checkEnumOption, choice, cidr, color, domain, email, ensureNonEmptyString, fileSize, firstOf, float, hostname, integer, ip, ipv4, ipv6, isNonEmptyString, isValueParser, json, locale, macAddress, port, portRange, semVer, socketAddress, string, url, uuid };
+export { checkBooleanOption, checkEnumOption, choice, cidr, color, domain, email, ensureNonEmptyString, fileSize, firstOf, float, hostname, integer, ip, ipv4, ipv6, isNonEmptyString, isValueParser, json, keyValue, locale, macAddress, port, portRange, semVer, socketAddress, string, url, uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/core",
-  "version": "1.1.0-dev.2148",
+  "version": "1.1.0-dev.2160",
   "description": "Type-safe combinatorial command-line interface parser",
   "keywords": [
     "CLI",
@@ -200,7 +200,7 @@
     "fast-check": "^4.7.0",
     "tsdown": "^0.13.0",
     "typescript": "^5.8.3",
-    "@optique/env": "1.1.0-dev.2148+ab56ac96"
+    "@optique/env": "1.1.0-dev.2160+4b3b85cc"
   },
   "scripts": {
     "build": "tsdown",