args-tokens 0.14.0 → 0.15.1

package/README.md

@@ -313,6 +313,16 @@ This project is inspired by:
 - [`util.parseArgs`](https://nodejs.org/api/util.html#utilparseargsconfig), created by Node.js contributors and [OpenJS Foundation](https://openjsf.org/)
 - [`pkgjs/parseargs`](https://github.com/pkgjs/parseargs), created by Node.js CLI package maintainers and Node.js community.
 
+## 🤝 Sponsors
+
+The development of Gunish is supported by my OSS sponsors!
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/kazupon/sponsors/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/kazupon/sponsors/sponsors.svg'/>
+  </a>
+</p>
+
 ## ©️ License
 
 [MIT](http://opensource.org/licenses/MIT)

package/lib/index.d.ts

@@ -1,12 +1,11 @@
-import { ParserOptions } from './parser.js';
-export { ArgToken, parseArgs } from './parser.js';
-import { ArgOptions, ArgValues } from './resolver.js';
-export { ArgOptionSchema, OptionResolveError, OptionResolveErrorType, resolveArgs } from './resolver.js';
+import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser.d-nUUBO6hL.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D_30OItP.js";
 
+//#region src/parse.d.ts
 /**
 * Parse options for {@link parse} function.
 */
-interface ParseOptions<O extends ArgOptions> extends ParserOptions {
+interface ParseOptions<O extends ArgOptions> extends ParserOptions, ResolveArgsOptions {
 	/**
 	* Command line options, about details see {@link ArgOptions}.
 	*/
@@ -25,9 +24,17 @@ type ParsedArgs<T extends ArgOptions> = {
 	*/
 	positionals: string[]
 	/**
+	* Rest arguments, same as `rest` in {@link resolveArgs}.
+	*/
+	rest: string[]
+	/**
 	* Validation errors, same as `errors` in {@link resolveArgs}.
 	*/
 	error: AggregateError | undefined
+	/**
+	* Argument tokens, same as `tokens` which is parsed by {@link parseArgs}.
+	*/
+	tokens: ArgToken[]
 };
 /**
 * Parse command line arguments.
@@ -42,9 +49,9 @@ type ParsedArgs<T extends ArgOptions> = {
 * ```
 * @param args - command line arguments
 * @param options - parse options, about details see {@link ParseOptions}
-* @returns An object that contains the values of the arguments, positional arguments, and {@link AggregateError | validation errors}.
+* @returns An object that contains the values of the arguments, positional arguments, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
 */
 declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;
 
-export { ArgOptions, ArgValues, ParserOptions, parse };
-export type { ParseOptions, ParsedArgs };
+//#endregion
+export { ArgOptionSchema, ArgOptions, ArgToken, ArgValues, OptionResolveError, OptionResolveErrorType, ParseOptions, ParsedArgs, ParserOptions, ResolveArgsOptions, parse, parseArgs, resolveArgs };

package/lib/index.js

@@ -1,5 +1,5 @@
 import { parseArgs } from "./parser-DxH6Mf-o.js";
-import { OptionResolveError, resolveArgs } from "./resolver-BFy1oVrL.js";
+import { OptionResolveError, resolveArgs } from "./resolver-D4hvuBLP.js";
 
 //#region src/parse.ts
 const DEFAULT_OPTIONS = {
@@ -13,9 +13,9 @@ const DEFAULT_OPTIONS = {
 	}
 };
 function parse(args, options = {}) {
-	const { options: argOptions, allowCompatible = false } = options;
+	const { options: argOptions, allowCompatible = false, allowNegative = false } = options;
 	const tokens = parseArgs(args, { allowCompatible });
-	return resolveArgs(argOptions || DEFAULT_OPTIONS, tokens);
+	return Object.assign(Object.create(null), resolveArgs(argOptions || DEFAULT_OPTIONS, tokens, { allowNegative }), { tokens });
 }
 
 //#endregion

package/lib/parser.d-nUUBO6hL.d.ts

@@ -0,0 +1,99 @@
+
+//#region src/parser.d.ts
+/**
+* Entry point of argument parser.
+* @module
+*/
+/**
+* forked from `nodejs/node` (`pkgjs/parseargs`)
+* repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
+* code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
+*
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Argument token Kind.
+* - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
+* - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+* - `positional`: positional token
+*/
+/**
+* Argument token Kind.
+* - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
+* - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+* - `positional`: positional token
+*/
+type ArgTokenKind = "option" | "option-terminator" | "positional";
+/**
+* Argument token.
+*/
+interface ArgToken {
+	/**
+	* Argument token kind.
+	*/
+	kind: ArgTokenKind;
+	/**
+	* Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
+	*/
+	index: number;
+	/**
+	* Option name, e.g. `--foo` => `foo`, `-x` => `x`.
+	*/
+	name?: string;
+	/**
+	* Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
+	*/
+	rawName?: string;
+	/**
+	* Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
+	* If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
+	*/
+	value?: string;
+	/**
+	* Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
+	*/
+	inlineValue?: boolean;
+}
+/**
+* Parser Options.
+*/
+interface ParserOptions {
+	/**
+	* [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode.
+	* @default false
+	*/
+	allowCompatible?: boolean;
+}
+/**
+* Parse command line arguments.
+* @example
+* ```js
+* import { parseArgs } from 'args-tokens' // for Node.js and Bun
+* // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+*
+* const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+* // do something with using tokens
+* // ...
+* console.log('tokens:', tokens)
+* ```
+* @param args command line arguments
+* @param options parse options
+* @returns Argument tokens.
+*/
+declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
+/**
+* Check if `arg` is a short option (e.g. `-f`).
+* @param arg the argument to check
+* @returns whether `arg` is a short option.
+*/
+declare function isShortOption(arg: string): boolean;
+/**
+* Check if `arg` is a long option prefix (e.g. `--`).
+* @param arg the argument to check
+* @returns whether `arg` is a long option prefix.
+*/
+declare function hasLongOptionPrefix(arg: string): boolean;
+
+//#endregion
+export { ArgToken, ParserOptions, hasLongOptionPrefix as hasLongOptionPrefix$1, isShortOption as isShortOption$1, parseArgs as parseArgs$1 };

package/lib/parser.d.ts

@@ -1,83 +1,3 @@
-/**
-* Entry point of argument parser.
-* @module
-*/
-/**
-* Argument token Kind.
-* - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
-* - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
-* - `positional`: positional token
-*/
-type ArgTokenKind = "option" | "option-terminator" | "positional";
-/**
-* Argument token.
-*/
-interface ArgToken {
-	/**
-	* Argument token kind.
-	*/
-	kind: ArgTokenKind;
-	/**
-	* Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
-	*/
-	index: number;
-	/**
-	* Option name, e.g. `--foo` => `foo`, `-x` => `x`.
-	*/
-	name?: string;
-	/**
-	* Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
-	*/
-	rawName?: string;
-	/**
-	* Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
-	* If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
-	*/
-	value?: string;
-	/**
-	* Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
-	*/
-	inlineValue?: boolean;
-}
-/**
-* Parser Options.
-*/
-interface ParserOptions {
-	/**
-	* [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode.
-	* @default false
-	*/
-	allowCompatible?: boolean;
-}
-/**
-* Parse command line arguments.
-* @example
-* ```js
-* import { parseArgs } from 'args-tokens' // for Node.js and Bun
-* // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
-*
-* const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
-* // do something with using tokens
-* // ...
-* console.log('tokens:', tokens)
-* ```
-* @param args command line arguments
-* @param options parse options
-* @returns Argument tokens.
-*/
-declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
-/**
-* Check if `arg` is a short option (e.g. `-f`).
-* @param arg the argument to check
-* @returns whether `arg` is a short option.
-*/
-declare function isShortOption(arg: string): boolean;
-/**
-* Check if `arg` is a long option prefix (e.g. `--`).
-* @param arg the argument to check
-* @returns whether `arg` is a long option prefix.
-*/
-declare function hasLongOptionPrefix(arg: string): boolean;
+import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser.d-nUUBO6hL.js";
 
-export { hasLongOptionPrefix, isShortOption, parseArgs };
-export type { ArgToken, ParserOptions };
+export { ArgToken, ParserOptions, hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/{resolver-BFy1oVrL.js → resolver-D4hvuBLP.js}

@@ -1,8 +1,9 @@
 import { hasLongOptionPrefix, isShortOption } from "./parser-DxH6Mf-o.js";
 
 //#region src/resolver.ts
-function resolveArgs(options, tokens) {
+function resolveArgs(options, tokens, { optionGrouping = false, allowNegative = false } = {}) {
 	const positionals = [];
+	const rest = [];
 	const longOptionTokens = [];
 	const shortOptionTokens = [];
 	let currentLongOption;
@@ -34,19 +35,36 @@ function resolveArgs(options, tokens) {
 	* analyze phase to resolve value
 	* separate tokens into positionals, long and short options, after that resolve values
 	*/
+	const schemas = Object.values(options);
+	let terminated = false;
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
 		if (token.kind === "positional") {
-			positionals.push(token.value);
+			if (terminated && token.value) {
+				rest.push(token.value);
+				continue;
+			}
+			if (currentShortOption) {
+				const found = schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean");
+				if (found) positionals.push(token.value);
+			} else if (currentLongOption) {
+				const found = options[currentLongOption.name]?.type === "boolean";
+				if (found) positionals.push(token.value);
+			} else positionals.push(token.value);
 			applyLongOptionValue(token.value);
 			applyShortOptionValue(token.value);
 		} else if (token.kind === "option") if (token.rawName) {
 			if (hasLongOptionPrefix(token.rawName)) {
+				applyLongOptionValue();
 				if (token.inlineValue) longOptionTokens.push({ ...token });
 				else currentLongOption = { ...token };
 				applyShortOptionValue();
 			} else if (isShortOption(token.rawName)) if (currentShortOption) {
-				if (currentShortOption.index === token.index) expandableShortOptions.push({ ...token });
+				if (currentShortOption.index === token.index) if (optionGrouping) {
+					currentShortOption.value = token.value;
+					shortOptionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				} else expandableShortOptions.push({ ...token });
 				else {
 					currentShortOption.value = toShortValue();
 					shortOptionTokens.push({ ...currentShortOption });
@@ -66,6 +84,7 @@ function resolveArgs(options, tokens) {
 			applyLongOptionValue();
 		}
 		else {
+			if (token.kind === "option-terminator") terminated = true;
 			applyLongOptionValue();
 			applyShortOptionValue();
 		}
@@ -80,6 +99,9 @@ function resolveArgs(options, tokens) {
 	*/
 	const values = Object.create(null);
 	const errors = [];
+	function checkTokenName(option, schema, token) {
+		return token.name === (schema.type === "boolean" ? allowNegative && token.name?.startsWith("no-") ? `no-${option}` : option : option);
+	}
 	for (const [option, schema] of Object.entries(options)) {
 		if (schema.required) {
 			const found = longOptionTokens.find((token) => token.name === option) || schema.short && shortOptionTokens.find((token) => token.name === schema.short);
@@ -90,7 +112,7 @@ function resolveArgs(options, tokens) {
 		}
 		for (let i = 0; i < longOptionTokens.length; i++) {
 			const token = longOptionTokens[i];
-			if (option === token.name && token.rawName != null && hasLongOptionPrefix(token.rawName)) {
+			if (checkTokenName(option, schema, token) && token.rawName != void 0 && hasLongOptionPrefix(token.rawName)) {
 				const invalid = validateRequire(token, option, schema);
 				if (invalid) {
 					errors.push(invalid);
@@ -104,7 +126,7 @@ function resolveArgs(options, tokens) {
 						continue;
 					}
 				}
-				values[option] = resolveOptionValue(token, schema);
+				values[option] = resolveOptionValue(token, schema, allowNegative);
 				continue;
 			}
 		}
@@ -133,6 +155,7 @@ function resolveArgs(options, tokens) {
 	return {
 		values,
 		positionals,
+		rest,
 		error: errors.length > 0 ? new AggregateError(errors) : void 0
 	};
 }
@@ -163,6 +186,10 @@ function validateValue(token, option, schema) {
 			if (typeof token.value !== "string") return createTypeError(option, schema);
 			break;
 		}
+		case "enum": {
+			if (schema.choices && !schema.choices.includes(token.value)) return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be chosen from '${schema.type}' [${schema.choices.map((c) => JSON.stringify(c)).join(", ")}] values`, option, "type", schema);
+			break;
+		}
 	}
 }
 function isNumeric(str) {
@@ -171,9 +198,9 @@ function isNumeric(str) {
 function createTypeError(option, schema) {
 	return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`, option, "type", schema);
 }
-function resolveOptionValue(token, schema) {
+function resolveOptionValue(token, schema, allowNegative = false) {
 	if (token.value) return schema.type === "number" ? +token.value : token.value;
-	if (schema.type === "boolean") return true;
+	if (schema.type === "boolean") return allowNegative && token.name.startsWith("no-") ? false : true;
 	return schema.type === "number" ? +(schema.default || "") : schema.default;
 }
 

package/lib/resolver.d-D_30OItP.d.ts

@@ -0,0 +1,116 @@
+import { ArgToken } from "./parser.d-nUUBO6hL.js";
+
+//#region src/resolver.d.ts
+/**
+* An option schema for an argument.
+* This schema is similar to the schema of the `node:utils`.
+* difference is that:
+* - `multiple` property is not supported
+* - `required` property and `description` property are added
+* - `type` is not only 'string' and 'boolean', but also 'number' and 'enum' too.
+* - `default` property type, not support multiple types
+*/
+interface ArgOptionSchema {
+	/**
+	* Type of argument.
+	*/
+	type: "string" | "boolean" | "number" | "enum";
+	/**
+	* A single character alias for the option.
+	*/
+	short?: string;
+	/**
+	* A description of the argument.
+	*/
+	description?: string;
+	/**
+	* Whether the argument is required or not.
+	*/
+	required?: true;
+	/**
+	* The allowed values of the argument, and string only. This property is only used when the type is 'enum'.
+	*/
+	choices?: string[];
+	/**
+	* The default value of the argument.
+	* if the type is 'enum', the default value must be one of the allowed values.
+	*/
+	default?: string | boolean | number;
+}
+/**
+* An object that contains {@link ArgOptionSchema | options schema}.
+*/
+interface ArgOptions {
+	[option: string]: ArgOptionSchema;
+}
+/**
+* An object that contains the values of the arguments.
+*/
+type ArgValues<T> = T extends ArgOptions ? ResolveArgValues<T, { [Option in keyof T] : ExtractOptionValue<T[Option]> }> : {
+	[option: string]: string | boolean | number | undefined
+};
+/**
+* @internal
+*/
+type ExtractOptionValue<O extends ArgOptionSchema> = O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : O["type"] extends "number" ? number : O["type"] extends "enum" ? O["choices"] extends string[] ? O["choices"][number] : never : string | boolean | number;
+/**
+* @internal
+*/
+type ResolveArgValues<
+	O extends ArgOptions,
+	V extends Record<keyof O, unknown>
+> = { -readonly [Option in keyof O]? : V[Option] } & FilterArgs<O, V, "default"> & FilterArgs<O, V, "required"> extends infer P ? { [K in keyof P] : P[K] } : never;
+/**
+* @internal
+*/
+type FilterArgs<
+	O extends ArgOptions,
+	V extends Record<keyof O, unknown>,
+	K extends keyof ArgOptionSchema
+> = { [Option in keyof O as O[Option][K] extends {} ? Option : never] : V[Option] };
+/**
+* An options for {@link resolveArgs | resolve arguments}.
+*/
+interface ResolveArgsOptions {
+	/**
+	* Whether to group short options.
+	* @default false
+	* @see guideline 5 in https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap12.html
+	*/
+	optionGrouping?: boolean;
+	/**
+	* Whether to set the flag value of options prefixed with `--no-` to negative.
+	* @default false
+	*/
+	allowNegative?: boolean;
+}
+/**
+* Resolve command line arguments.
+* @param options - An options that contains {@link ArgOptionSchema | options schema}.
+* @param tokens - An array of {@link ArgToken | tokens}.
+* @param resolveArgsOptions - An options that contains {@link resolveArgsOptions | resolve arguments options}.
+* @returns An object that contains the values of the arguments, positional arguments, rest arguments, and {@link AggregateError | validation errors}.
+*/
+declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[], { optionGrouping, allowNegative }?: ResolveArgsOptions): {
+	values: ArgValues<T>
+	positionals: string[]
+	rest: string[]
+	error: AggregateError | undefined
+};
+/**
+* An error type for {@link OptionResolveError}.
+*/
+type OptionResolveErrorType = "type" | "required";
+/**
+* An error that occurs when resolving options.
+* This error is thrown when the option is not valid.
+*/
+declare class OptionResolveError extends Error {
+	name: string;
+	schema: ArgOptionSchema;
+	type: OptionResolveErrorType;
+	constructor(message: string, name: string, type: OptionResolveErrorType, schema: ArgOptionSchema);
+}
+
+//#endregion
+export { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError as OptionResolveError$1, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs as resolveArgs$1 };

package/lib/resolver.d.ts

@@ -1,82 +1,4 @@
-import { ArgToken } from './parser.js';
+import "./parser.d-nUUBO6hL.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D_30OItP.js";
 
-/**
-* An option schema for an argument.
-* This schema is similar to the schema of the `node:utils`.
-* difference is that:
-* - `multiple` property is not supported
-* - `required` property and `description` property are added
-* - `default` property type, not support multiple types
-*/
-interface ArgOptionSchema {
-	/**
-	* Type of argument.
-	*/
-	type: "string" | "boolean" | "number";
-	/**
-	* A single character alias for the option.
-	*/
-	short?: string;
-	/**
-	* A description of the argument.
-	*/
-	description?: string;
-	/**
-	* Whether the argument is required or not.
-	*/
-	required?: true;
-	/**
-	* The default value of the argument.
-	*/
-	default?: string | boolean | number;
-}
-/**
-* An object that contains {@link ArgOptionSchema | options schema}.
-*/
-interface ArgOptions {
-	[option: string]: ArgOptionSchema;
-}
-/**
-* An object that contains the values of the arguments.
-*/
-type ArgValues<T> = T extends ArgOptions ? ResolveArgValues<T, { [Option in keyof T] : ExtractOptionValue<T[Option]> }> : {
-	[option: string]: string | boolean | number | undefined
-};
-type ExtractOptionValue<O extends ArgOptionSchema> = O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : O["type"] extends "number" ? number : string | boolean | number;
-type ResolveArgValues<
-	O extends ArgOptions,
-	V extends Record<keyof O, unknown>
-> = { -readonly [Option in keyof O]? : V[Option] } & FilterArgs<O, V, "default"> & FilterArgs<O, V, "required"> extends infer P ? { [K in keyof P] : P[K] } : never;
-type FilterArgs<
-	O extends ArgOptions,
-	V extends Record<keyof O, unknown>,
-	K extends keyof ArgOptionSchema
-> = { [Option in keyof O as O[Option][K] extends {} ? Option : never] : V[Option] };
-/**
-* Resolve command line arguments.
-* @param options - An options that contains {@link ArgOptionSchema | options schema}.
-* @param tokens - An array of {@link ArgToken | tokens}.
-* @returns An object that contains the values of the arguments, positional arguments, and {@link AggregateError | validation errors}.
-*/
-declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[]): {
-	values: ArgValues<T>
-	positionals: string[]
-	error: AggregateError | undefined
-};
-/**
-* An error type for {@link OptionResolveError}.
-*/
-type OptionResolveErrorType = "type" | "required";
-/**
-* An error that occurs when resolving options.
-* This error is thrown when the option is not valid.
-*/
-declare class OptionResolveError extends Error {
-	name: string;
-	schema: ArgOptionSchema;
-	type: OptionResolveErrorType;
-	constructor(message: string, name: string, type: OptionResolveErrorType, schema: ArgOptionSchema);
-}
-
-export { OptionResolveError, resolveArgs };
-export type { ArgOptionSchema, ArgOptions, ArgValues, OptionResolveErrorType };
+export { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs };

package/lib/resolver.js

@@ -1,4 +1,4 @@
 import "./parser-DxH6Mf-o.js";
-import { OptionResolveError, resolveArgs } from "./resolver-BFy1oVrL.js";
+import { OptionResolveError, resolveArgs } from "./resolver-D4hvuBLP.js";
 
 export { OptionResolveError, resolveArgs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -65,15 +65,15 @@
     }
   },
   "devDependencies": {
-    "@eslint/markdown": "^6.3.0",
-    "@kazupon/eslint-config": "^0.26.1",
+    "@eslint/markdown": "^6.4.0",
+    "@kazupon/eslint-config": "^0.29.0",
     "@kazupon/prettier-config": "^0.1.1",
-    "@types/node": "^22.13.14",
-    "@vitest/eslint-plugin": "^1.1.38",
+    "@types/node": "^22.14.1",
+    "@vitest/eslint-plugin": "^1.1.43",
     "bumpp": "^10.1.0",
-    "deno": "^2.2.6",
-    "eslint": "^9.23.0",
-    "eslint-config-prettier": "^10.1.1",
+    "deno": "^2.2.11",
+    "eslint": "^9.25.0",
+    "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-jsonc": "^2.20.0",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^2.7.0",
@@ -81,15 +81,16 @@
     "eslint-plugin-yml": "^1.17.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.4",
-    "knip": "^5.46.3",
-    "lint-staged": "^15.5.0",
+    "knip": "^5.50.5",
+    "lint-staged": "^15.5.1",
     "mitata": "^1.0.34",
-    "pkg-pr-new": "^0.0.41",
+    "pkg-pr-new": "^0.0.43",
     "prettier": "^3.5.3",
-    "tsdown": "^0.6.10",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.28.0",
-    "vitest": "^3.0.9"
+    "tsdown": "^0.9.1",
+    "tsdown-jsr-exports-lint": "^0.1.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vitest": "^3.1.1"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {