args-tokens 0.12.0 → 0.13.2

package/README.md

@@ -302,10 +302,6 @@ const tokens = parseArgs(['-a=1'], { allowCompatible: true }) // add `allowCompa
 deepStrictEqual(tokensNode, tokens)
 ```
 
-## 💁‍♀️ Showcases
-
-- [pnpmc](https://github.com/kazupon/pnpmc): PNPM Catalogs Tooling
-
 ## 🙌 Contributing guidelines
 
 If you are interested in contributing to `args-tokens`, I highly recommend checking out [the contributing guidelines](/CONTRIBUTING.md) here. You'll find all the relevant information such as [how to make a PR](/CONTRIBUTING.md#pull-request-guidelines), [how to setup development](/CONTRIBUTING.md#development-setup)) etc., there.

package/lib/index.d.ts

@@ -1,6 +1,50 @@
-export { parse } from './parse.js';
-export { parseArgs } from './parser.js';
-export { OptionResolveError, resolveArgs } from './resolver.js';
-export type { ParsedArgs, ParseOptions } from './parse';
-export type { ArgToken, ParserOptions } from './parser';
-export type { ArgOptions, ArgOptionSchema, ArgValues } from './resolver';
+import { ParserOptions } from './parser.js';
+export { ArgToken, parseArgs } from './parser.js';
+import { ArgOptions, ArgValues } from './resolver.js';
+export { ArgOptionSchema, OptionResolveError, resolveArgs } from './resolver.js';
+
+/**
+* Parse options for {@link parse} function
+*/
+interface ParseOptions<O extends ArgOptions> extends ParserOptions {
+	/**
+	* Command line options, about details see {@link ArgOptions}
+	*/
+	options?: O;
+}
+/**
+* Parsed command line arguments
+*/
+type ParsedArgs<T extends ArgOptions> = {
+	/**
+	* Parsed values, same as `values` in {@link resolveArgs}
+	*/
+	values: ArgValues<T>
+	/**
+	* Positional arguments, same as `positionals` in {@link resolveArgs}
+	*/
+	positionals: string[]
+	/**
+	* Validation errors, same as `errors` in {@link resolveArgs}
+	*/
+	error: AggregateError | undefined
+};
+/**
+* Parse command line arguments
+* @description This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
+* @example
+* ```js
+* import { parse } from 'args-tokens'
+*
+* const { values, positionals } = parse(process.argv.slice(2))
+* console.log('values', values)
+* console.log('positionals', positionals)
+* ```
+* @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}.
+*/
+declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;
+
+export { ArgOptions, ArgValues, ParserOptions, parse };
+export type { ParseOptions, ParsedArgs };

package/lib/index.js

@@ -1,5 +1,22 @@
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-export { parse } from './parse.js';
-export { parseArgs } from './parser.js';
-export { OptionResolveError, resolveArgs } from './resolver.js';
+import { parseArgs } from "./parser-DYj8MxIm.js";
+import { OptionResolveError, resolveArgs } from "./resolver-DcIzyGlA.js";
+
+//#region src/parse.ts
+const DEFAULT_OPTIONS = {
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: {
+		type: "boolean",
+		short: "v"
+	}
+};
+function parse(args, options = {}) {
+	const { options: argOptions, allowCompatible = false } = options;
+	const tokens = parseArgs(args, { allowCompatible });
+	return resolveArgs(argOptions || DEFAULT_OPTIONS, tokens);
+}
+
+//#endregion
+export { OptionResolveError, parse, parseArgs, resolveArgs };

package/lib/parser-DYj8MxIm.js

@@ -0,0 +1,166 @@
+
+//#region src/parser.ts
+const HYPHEN_CHAR = "-";
+const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+const EQUAL_CHAR = "=";
+const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+const TERMINATOR = "--";
+const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+const LONG_OPTION_PREFIX = "--";
+function parseArgs(args, options = {}) {
+	const { allowCompatible = false } = options;
+	const tokens = [];
+	const remainings = [...args];
+	let index = -1;
+	let groupCount = 0;
+	let hasShortValueSeparator = false;
+	while (remainings.length > 0) {
+		const arg = remainings.shift();
+		if (arg == void 0) break;
+		const nextArg = remainings[0];
+		if (groupCount > 0) groupCount--;
+		else index++;
+		if (arg === TERMINATOR) {
+			tokens.push({
+				kind: "option-terminator",
+				index
+			});
+			const mapped = remainings.map((arg$1) => {
+				return {
+					kind: "positional",
+					index: ++index,
+					value: arg$1
+				};
+			});
+			tokens.push(...mapped);
+			break;
+		}
+		if (isShortOption(arg)) {
+			const shortOption = arg.charAt(1);
+			let value;
+			let inlineValue;
+			if (groupCount) {
+				tokens.push({
+					kind: "option",
+					name: shortOption,
+					rawName: arg,
+					index,
+					value,
+					inlineValue
+				});
+				if (groupCount === 1 && hasOptionValue(nextArg)) {
+					value = remainings.shift();
+					if (hasShortValueSeparator) {
+						inlineValue = true;
+						hasShortValueSeparator = false;
+					}
+					tokens.push({
+						kind: "option",
+						index,
+						value,
+						inlineValue
+					});
+				}
+			} else tokens.push({
+				kind: "option",
+				name: shortOption,
+				rawName: arg,
+				index,
+				value,
+				inlineValue
+			});
+			if (value != null) ++index;
+			continue;
+		}
+		if (isShortOptionGroup(arg)) {
+			const expanded = [];
+			let shortValue = "";
+			for (let i = 1; i < arg.length; i++) {
+				const shortableOption = arg.charAt(i);
+				if (hasShortValueSeparator) shortValue += shortableOption;
+				else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) hasShortValueSeparator = true;
+				else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+			}
+			if (shortValue) expanded.push(shortValue);
+			remainings.unshift(...expanded);
+			groupCount = expanded.length;
+			continue;
+		}
+		if (isLongOption(arg)) {
+			const longOption = arg.slice(2);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: arg,
+				index,
+				value: void 0,
+				inlineValue: void 0
+			});
+			continue;
+		}
+		if (isLongOptionAndValue(arg)) {
+			const equalIndex = arg.indexOf(EQUAL_CHAR);
+			const longOption = arg.slice(2, equalIndex);
+			const value = arg.slice(equalIndex + 1);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+				index,
+				value,
+				inlineValue: true
+			});
+			continue;
+		}
+		tokens.push({
+			kind: "positional",
+			index,
+			value: arg
+		});
+	}
+	return tokens;
+}
+function isShortOption(arg) {
+	return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
+}
+/**
+* Check if `arg` is a short option group (e.g. `-abc`)
+* @param arg the argument to check
+* @returns whether `arg` is a short option group
+*/
+function isShortOptionGroup(arg) {
+	if (arg.length <= 2) return false;
+	if (arg.codePointAt(0) !== HYPHEN_CODE) return false;
+	if (arg.codePointAt(1) === HYPHEN_CODE) return false;
+	return true;
+}
+/**
+* Check if `arg` is a long option (e.g. `--foo`)
+* @param arg the argument to check
+* @returns whether `arg` is a long option
+*/
+function isLongOption(arg) {
+	return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+/**
+* Check if `arg` is a long option with value (e.g. `--foo=bar`)
+* @param arg the argument to check
+* @returns whether `arg` is a long option
+*/
+function isLongOptionAndValue(arg) {
+	return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+function hasLongOptionPrefix(arg) {
+	return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
+}
+/**
+* Check if a `value` is an option value
+* @param value a value to check
+* @returns whether a `value` is an option value
+*/
+function hasOptionValue(value) {
+	return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
+}
+
+//#endregion
+export { hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/parser.d.ts

@@ -1,77 +1,79 @@
 /**
- * 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 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
- */
-export 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;
+* 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
- */
-export interface ParserOptions {
-    /**
-     * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode
-     * @default false
-     */
-    allowCompatible?: 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
- */
-export declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
+* 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
- */
-export declare function isShortOption(arg: string): boolean;
+* 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
- */
-export declare function hasLongOptionPrefix(arg: string): boolean;
-export {};
+* 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;
+
+export { hasLongOptionPrefix, isShortOption, parseArgs };
+export type { ArgToken, ParserOptions };

package/lib/parser.js

@@ -1,226 +1,3 @@
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-// Forked from `nodejs/node` (`pkgjs/parseargs`)
-// Repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
-// Author: Node.js contributors
-// Code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
-const HYPHEN_CHAR = '-';
-const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
-const EQUAL_CHAR = '=';
-const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
-const TERMINATOR = '--';
-const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
-const LONG_OPTION_PREFIX = '--';
-/**
- * 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
- */
-export function parseArgs(args, options = {}) {
-    const { allowCompatible = false } = options;
-    const tokens = [];
-    const remainings = [...args];
-    let index = -1;
-    let groupCount = 0;
-    let hasShortValueSeparator = false;
-    while (remainings.length > 0) {
-        const arg = remainings.shift();
-        if (arg == undefined) {
-            break;
-        }
-        const nextArg = remainings[0];
-        if (groupCount > 0) {
-            groupCount--;
-        }
-        else {
-            index++;
-        }
-        // check if `arg` is an options terminator.
-        // guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
-        if (arg === TERMINATOR) {
-            tokens.push({
-                kind: 'option-terminator',
-                index
-            });
-            const mapped = remainings.map(arg => {
-                return { kind: 'positional', index: ++index, value: arg };
-            });
-            tokens.push(...mapped);
-            break;
-        }
-        if (isShortOption(arg)) {
-            const shortOption = arg.charAt(1);
-            let value;
-            let inlineValue;
-            if (groupCount) {
-                // e.g. `-abc`
-                tokens.push({
-                    kind: 'option',
-                    name: shortOption,
-                    rawName: arg,
-                    index,
-                    value,
-                    inlineValue
-                });
-                if (groupCount === 1 && hasOptionValue(nextArg)) {
-                    value = remainings.shift();
-                    if (hasShortValueSeparator) {
-                        inlineValue = true;
-                        hasShortValueSeparator = false;
-                    }
-                    tokens.push({
-                        kind: 'option',
-                        index,
-                        value,
-                        inlineValue
-                    });
-                }
-            }
-            else {
-                // e.g. `-a`
-                tokens.push({
-                    kind: 'option',
-                    name: shortOption,
-                    rawName: arg,
-                    index,
-                    value,
-                    inlineValue
-                });
-            }
-            // eslint-disable-next-line unicorn/no-null
-            if (value != null) {
-                ++index;
-            }
-            continue;
-        }
-        if (isShortOptionGroup(arg)) {
-            // expend short option group (e.g. `-abc` => `-a -b -c`, `-f=bar` => `-f bar`)
-            const expanded = [];
-            let shortValue = '';
-            for (let i = 1; i < arg.length; i++) {
-                const shortableOption = arg.charAt(i);
-                if (hasShortValueSeparator) {
-                    shortValue += shortableOption;
-                }
-                else {
-                    if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) {
-                        hasShortValueSeparator = true;
-                    }
-                    else {
-                        expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
-                    }
-                }
-            }
-            if (shortValue) {
-                expanded.push(shortValue);
-            }
-            remainings.unshift(...expanded);
-            groupCount = expanded.length;
-            continue;
-        }
-        if (isLongOption(arg)) {
-            // e.g. `--foo`
-            const longOption = arg.slice(2);
-            tokens.push({
-                kind: 'option',
-                name: longOption,
-                rawName: arg,
-                index,
-                value: undefined,
-                inlineValue: undefined
-            });
-            continue;
-        }
-        if (isLongOptionAndValue(arg)) {
-            // e.g. `--foo=bar`
-            const equalIndex = arg.indexOf(EQUAL_CHAR);
-            const longOption = arg.slice(2, equalIndex);
-            const value = arg.slice(equalIndex + 1);
-            tokens.push({
-                kind: 'option',
-                name: longOption,
-                rawName: `${LONG_OPTION_PREFIX}${longOption}`,
-                index,
-                value,
-                inlineValue: true
-            });
-            continue;
-        }
-        tokens.push({
-            kind: 'positional',
-            index,
-            value: arg
-        });
-    }
-    return tokens;
-}
-/**
- * Check if `arg` is a short option (e.g. `-f`)
- * @param arg the argument to check
- * @returns whether `arg` is a short option
- */
-export function isShortOption(arg) {
-    return (arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE);
-}
-/**
- * Check if `arg` is a short option group (e.g. `-abc`)
- * @param arg the argument to check
- * @returns whether `arg` is a short option group
- */
-function isShortOptionGroup(arg) {
-    if (arg.length <= 2) {
-        return false;
-    }
-    if (arg.codePointAt(0) !== HYPHEN_CODE) {
-        return false;
-    }
-    if (arg.codePointAt(1) === HYPHEN_CODE) {
-        return false;
-    }
-    return true;
-}
-/**
- * Check if `arg` is a long option (e.g. `--foo`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option
- */
-function isLongOption(arg) {
-    return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
-}
-/**
- * Check if `arg` is a long option with value (e.g. `--foo=bar`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option
- */
-function isLongOptionAndValue(arg) {
-    return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
-}
-/**
- * Check if `arg` is a long option prefix (e.g. `--`)
- * @param arg the argument to check
- * @returns whether `arg` is a long option prefix
- */
-export function hasLongOptionPrefix(arg) {
-    // @ts-ignore -- NOTE: `~` is a bitwise NOT operator
-    return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
-}
-/**
- * Check if a `value` is an option value
- * @param value a value to check
- * @returns whether a `value` is an option value
- */
-function hasOptionValue(value) {
-    // eslint-disable-next-line unicorn/no-null
-    return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
-}
+import { hasLongOptionPrefix, isShortOption, parseArgs } from "./parser-DYj8MxIm.js";
+
+export { hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/resolver-DcIzyGlA.js

@@ -0,0 +1,179 @@
+import { hasLongOptionPrefix, isShortOption } from "./parser-DYj8MxIm.js";
+
+//#region src/resolver.ts
+function resolveArgs(options, tokens) {
+	const positionals = [];
+	const longOptionTokens = [];
+	const shortOptionTokens = [];
+	let currentLongOption;
+	let currentShortOption;
+	const expandableShortOptions = [];
+	function toShortValue() {
+		if (expandableShortOptions.length === 0) return void 0;
+		else {
+			const value = expandableShortOptions.map((token) => token.name).join("");
+			expandableShortOptions.length = 0;
+			return value;
+		}
+	}
+	function applyLongOptionValue(value = void 0) {
+		if (currentLongOption) {
+			currentLongOption.value = value;
+			longOptionTokens.push({ ...currentLongOption });
+			currentLongOption = void 0;
+		}
+	}
+	function applyShortOptionValue(value = void 0) {
+		if (currentShortOption) {
+			currentShortOption.value = value || toShortValue();
+			shortOptionTokens.push({ ...currentShortOption });
+			currentShortOption = void 0;
+		}
+	}
+	/**
+	* analyze phase to resolve value
+	* separate tokens into positionals, long and short options, after that resolve values
+	*/
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.kind === "positional") {
+			positionals.push(token.value);
+			applyLongOptionValue(token.value);
+			applyShortOptionValue(token.value);
+		} else if (token.kind === "option") if (token.rawName) {
+			if (hasLongOptionPrefix(token.rawName)) {
+				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 });
+				else {
+					currentShortOption.value = toShortValue();
+					shortOptionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				}
+				applyLongOptionValue();
+			} else {
+				currentShortOption = { ...token };
+				applyLongOptionValue();
+			}
+		} else {
+			if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
+				currentShortOption.value = token.value;
+				shortOptionTokens.push({ ...currentShortOption });
+				currentShortOption = void 0;
+			}
+			applyLongOptionValue();
+		}
+		else {
+			applyLongOptionValue();
+			applyShortOptionValue();
+		}
+	}
+	/**
+	* check if the last long or short option is not resolved
+	*/
+	applyLongOptionValue();
+	applyShortOptionValue();
+	/**
+	* resolve values
+	*/
+	const values = Object.create(null);
+	const errors = [];
+	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);
+			if (!found) {
+				errors.push(createRequireError(option, schema));
+				continue;
+			}
+		}
+		for (let i = 0; i < longOptionTokens.length; i++) {
+			const token = longOptionTokens[i];
+			if (option === token.name && token.rawName != null && hasLongOptionPrefix(token.rawName)) {
+				const invalid = validateRequire(token, option, schema);
+				if (invalid) {
+					errors.push(invalid);
+					continue;
+				}
+				if (schema.type === "boolean") token.value = void 0;
+				else {
+					const invalid$1 = validateValue(token, option, schema);
+					if (invalid$1) {
+						errors.push(invalid$1);
+						continue;
+					}
+				}
+				values[option] = resolveOptionValue(token, schema);
+				continue;
+			}
+		}
+		for (let i = 0; i < shortOptionTokens.length; i++) {
+			const token = shortOptionTokens[i];
+			if (schema.short === token.name && token.rawName != null && isShortOption(token.rawName)) {
+				const invalid = validateRequire(token, option, schema);
+				if (invalid) {
+					errors.push(invalid);
+					continue;
+				}
+				if (schema.type === "boolean") token.value = void 0;
+				else {
+					const invalid$1 = validateValue(token, option, schema);
+					if (invalid$1) {
+						errors.push(invalid$1);
+						continue;
+					}
+				}
+				values[option] = resolveOptionValue(token, schema);
+				continue;
+			}
+		}
+		if (values[option] == null && schema.default != null) values[option] = schema.default;
+	}
+	return {
+		values,
+		positionals,
+		error: errors.length > 0 ? new AggregateError(errors) : void 0
+	};
+}
+function createRequireError(option, schema) {
+	return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`, option, schema);
+}
+var OptionResolveError = class extends Error {
+	name;
+	schema;
+	constructor(message, name, schema) {
+		super(message);
+		this.name = name;
+		this.schema = schema;
+	}
+};
+function validateRequire(token, option, schema) {
+	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(option, schema);
+}
+function validateValue(token, option, schema) {
+	switch (schema.type) {
+		case "number": {
+			if (!isNumeric(token.value)) return createTypeError(option, schema);
+			break;
+		}
+		case "string": {
+			if (typeof token.value !== "string") return createTypeError(option, schema);
+			break;
+		}
+	}
+}
+function isNumeric(str) {
+	return str.trim() !== "" && !isNaN(str);
+}
+function createTypeError(option, schema) {
+	return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`, option, schema);
+}
+function resolveOptionValue(token, schema) {
+	if (token.value) return schema.type === "number" ? +token.value : token.value;
+	if (schema.type === "boolean") return true;
+	return schema.type === "number" ? +(schema.default || "") : schema.default;
+}
+
+//#endregion
+export { OptionResolveError, resolveArgs };

package/lib/resolver.d.ts

@@ -1,72 +1,74 @@
-import type { ArgToken } from './parser';
+import { ArgToken } from './parser.js';
+
 /**
- * An option schema for an argument.
- *
- * @description 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
- */
-export 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 option schema for an argument.
+*
+* @description 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}.
- */
-export interface ArgOptions {
-    [option: string]: ArgOptionSchema;
+* An object that contains {@link ArgOptionSchema | options schema}.
+*/
+interface ArgOptions {
+	[option: string]: ArgOptionSchema;
 }
 /**
- * An object that contains the values of the arguments.
- */
-export 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];
+* 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}.
- */
-export declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[]): {
-    values: ArgValues<T>;
-    positionals: string[];
-    error: AggregateError | undefined;
+* 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
 };
-export declare class OptionResolveError extends Error {
-    name: string;
-    schema: ArgOptionSchema;
-    constructor(message: string, name: string, schema: ArgOptionSchema);
+declare class OptionResolveError extends Error {
+	name: string;
+	schema: ArgOptionSchema;
+	constructor(message: string, name: string, schema: ArgOptionSchema);
 }
-export {};
+
+export { OptionResolveError, resolveArgs };
+export type { ArgOptionSchema, ArgOptions, ArgValues };

package/lib/resolver.js

@@ -1,236 +1,4 @@
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-import { hasLongOptionPrefix, isShortOption } from './parser.js';
-/**
- * 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}.
- */
-export function resolveArgs(options, tokens) {
-    const positionals = [];
-    const longOptionTokens = [];
-    const shortOptionTokens = [];
-    let currentLongOption;
-    let currentShortOption;
-    const expandableShortOptions = [];
-    function toShortValue() {
-        if (expandableShortOptions.length === 0) {
-            return undefined;
-        }
-        else {
-            const value = expandableShortOptions.map(token => token.name).join('');
-            expandableShortOptions.length = 0;
-            return value;
-        }
-    }
-    function applyLongOptionValue(value = undefined) {
-        if (currentLongOption) {
-            currentLongOption.value = value;
-            longOptionTokens.push({ ...currentLongOption });
-            currentLongOption = undefined;
-        }
-    }
-    function applyShortOptionValue(value = undefined) {
-        if (currentShortOption) {
-            currentShortOption.value = value || toShortValue();
-            shortOptionTokens.push({ ...currentShortOption });
-            currentShortOption = undefined;
-        }
-    }
-    /**
-     * analyze phase to resolve value
-     * separate tokens into positionals, long and short options, after that resolve values
-     */
-    // eslint-disable-next-line unicorn/no-for-loop
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (token.kind === 'positional') {
-            positionals.push(token.value);
-            // check if previous option is not resolved
-            applyLongOptionValue(token.value);
-            applyShortOptionValue(token.value);
-        }
-        else if (token.kind === 'option') {
-            if (token.rawName) {
-                if (hasLongOptionPrefix(token.rawName)) {
-                    if (token.inlineValue) {
-                        longOptionTokens.push({ ...token });
-                    }
-                    else {
-                        currentLongOption = { ...token };
-                    }
-                    // check if previous short option is not resolved
-                    applyShortOptionValue();
-                }
-                else if (isShortOption(token.rawName)) {
-                    if (currentShortOption) {
-                        if (currentShortOption.index === token.index) {
-                            expandableShortOptions.push({ ...token });
-                        }
-                        else {
-                            currentShortOption.value = toShortValue();
-                            shortOptionTokens.push({ ...currentShortOption });
-                            currentShortOption = { ...token };
-                        }
-                        // check if previous long option is not resolved
-                        applyLongOptionValue();
-                    }
-                    else {
-                        currentShortOption = { ...token };
-                        // check if previous long option is not resolved
-                        applyLongOptionValue();
-                    }
-                }
-            }
-            else {
-                // short option value
-                if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
-                    currentShortOption.value = token.value;
-                    shortOptionTokens.push({ ...currentShortOption });
-                    currentShortOption = undefined;
-                }
-                // check if previous long option is not resolved
-                applyLongOptionValue();
-            }
-        }
-        else {
-            // check if previous option is not resolved
-            applyLongOptionValue();
-            applyShortOptionValue();
-        }
-    }
-    /**
-     * check if the last long or short option is not resolved
-     */
-    applyLongOptionValue();
-    applyShortOptionValue();
-    /**
-     * resolve values
-     */
-    const values = Object.create(null);
-    const errors = [];
-    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));
-            if (!found) {
-                errors.push(createRequireError(option, schema));
-                continue;
-            }
-        }
-        // eslint-disable-next-line unicorn/no-for-loop
-        for (let i = 0; i < longOptionTokens.length; i++) {
-            const token = longOptionTokens[i];
-            // eslint-disable-next-line unicorn/no-null
-            if (option === token.name && token.rawName != null && hasLongOptionPrefix(token.rawName)) {
-                const invalid = validateRequire(token, option, schema);
-                if (invalid) {
-                    errors.push(invalid);
-                    continue;
-                }
-                if (schema.type === 'boolean') {
-                    // NOTE: re-set value to undefined, because long boolean type option is set on analyze phase
-                    token.value = undefined;
-                }
-                else {
-                    const invalid = validateValue(token, option, schema);
-                    if (invalid) {
-                        errors.push(invalid);
-                        continue;
-                    }
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ;
-                values[option] = resolveOptionValue(token, schema);
-                continue;
-            }
-        }
-        // eslint-disable-next-line unicorn/no-for-loop
-        for (let i = 0; i < shortOptionTokens.length; i++) {
-            const token = shortOptionTokens[i];
-            // eslint-disable-next-line unicorn/no-null
-            if (schema.short === token.name && token.rawName != null && isShortOption(token.rawName)) {
-                const invalid = validateRequire(token, option, schema);
-                if (invalid) {
-                    errors.push(invalid);
-                    continue;
-                }
-                if (schema.type === 'boolean') {
-                    // NOTE: re-set value to undefined, because short boolean type option is set on analyze phase
-                    token.value = undefined;
-                }
-                else {
-                    const invalid = validateValue(token, option, schema);
-                    if (invalid) {
-                        errors.push(invalid);
-                        continue;
-                    }
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ;
-                values[option] = resolveOptionValue(token, schema);
-                continue;
-            }
-        }
-        // eslint-disable-next-line unicorn/no-null
-        if (values[option] == null && schema.default != null) {
-            // check if the default value is in values
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ;
-            values[option] = schema.default;
-        }
-    }
-    // eslint-disable-next-line unicorn/error-message
-    return { values, positionals, error: errors.length > 0 ? new AggregateError(errors) : undefined };
-}
-function createRequireError(option, schema) {
-    return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ''}is required`, option, schema);
-}
-export class OptionResolveError extends Error {
-    name;
-    schema;
-    constructor(message, name, schema) {
-        super(message);
-        this.name = name;
-        this.schema = schema;
-    }
-}
-function validateRequire(token, option, schema) {
-    if (schema.required && schema.type !== 'boolean' && !token.value) {
-        return createRequireError(option, schema);
-    }
-}
-function validateValue(token, option, schema) {
-    switch (schema.type) {
-        case 'number': {
-            if (!isNumeric(token.value)) {
-                return createTypeError(option, schema);
-            }
-            break;
-        }
-        case 'string': {
-            if (typeof token.value !== 'string') {
-                return createTypeError(option, schema);
-            }
-            break;
-        }
-    }
-}
-function isNumeric(str) {
-    // @ts-ignore
-    // eslint-disable-next-line unicorn/prefer-number-properties
-    return str.trim() !== '' && !isNaN(str);
-}
-function createTypeError(option, schema) {
-    return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ''}should be '${schema.type}'`, option, schema);
-}
-function resolveOptionValue(token, schema) {
-    if (token.value) {
-        return schema.type === 'number' ? +token.value : token.value;
-    }
-    if (schema.type === 'boolean') {
-        return true;
-    }
-    return schema.type === 'number' ? +(schema.default || '') : schema.default;
-}
+import "./parser-DYj8MxIm.js";
+import { OptionResolveError, resolveArgs } from "./resolver-DcIzyGlA.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.12.0",
+  "version": "0.13.2",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -66,11 +66,12 @@
   },
   "devDependencies": {
     "@eslint/markdown": "^6.3.0",
-    "@kazupon/eslint-config": "^0.26.0",
+    "@kazupon/eslint-config": "^0.26.1",
     "@kazupon/prettier-config": "^0.1.1",
     "@types/node": "^22.13.14",
     "@vitest/eslint-plugin": "^1.1.38",
     "bumpp": "^10.1.0",
+    "deno": "^2.2.6",
     "eslint": "^9.23.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-jsonc": "^2.20.0",
@@ -80,11 +81,12 @@
     "eslint-plugin-yml": "^1.17.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.4",
-    "knip": "^5.46.2",
+    "knip": "^5.46.3",
     "lint-staged": "^15.5.0",
     "mitata": "^1.0.34",
     "pkg-pr-new": "^0.0.41",
     "prettier": "^3.5.3",
+    "tsdown": "^0.6.10",
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.28.0",
     "vitest": "^3.0.9"
@@ -106,7 +108,7 @@
   "scripts": {
     "bench:mitata": "node --expose-gc bench/mitata.js",
     "bench:vitest": "vitest bench --run",
-    "build": "tsc -p ./tsconfig.build.json",
+    "build": "tsdown",
     "changelog": "gh-changelogen --repo=kazupon/eslint-config",
     "dev": "pnpx @eslint/config-inspector --config eslint.config.ts",
     "dev:eslint": "pnpx @eslint/config-inspector --config eslint.config.ts",
@@ -121,6 +123,8 @@
     "lint:prettier": "prettier . --check",
     "release": "bumpp --commit \"release: v%s\" --all --push --tag",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "pnpm run --parallel --color \"/^typecheck:/\"",
+    "typecheck:deno": "deno check src",
+    "typecheck:tsc": "tsc --noEmit"
   }
 }

package/lib/parse.d.ts

@@ -1,44 +0,0 @@
-import type { ParserOptions } from './parser';
-import type { ArgOptions, ArgValues } from './resolver';
-/**
- * Parse options for {@link parse} function
- */
-export interface ParseOptions<O extends ArgOptions> extends ParserOptions {
-    /**
-     * Command line options, about details see {@link ArgOptions}
-     */
-    options?: O;
-}
-/**
- * Parsed command line arguments
- */
-export type ParsedArgs<T extends ArgOptions> = {
-    /**
-     * Parsed values, same as `values` in {@link resolveArgs}
-     */
-    values: ArgValues<T>;
-    /**
-     * Positional arguments, same as `positionals` in {@link resolveArgs}
-     */
-    positionals: string[];
-    /**
-     * Validation errors, same as `errors` in {@link resolveArgs}
-     */
-    error: AggregateError | undefined;
-};
-/**
- * Parse command line arguments
- * @description This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
- * @example
- * ```js
- * import { parse } from 'args-tokens'
- *
- * const { values, positionals } = parse(process.argv.slice(2))
- * console.log('values', values)
- * console.log('positionals', positionals)
- * ```
- * @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}.
- */
-export declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;

package/lib/parse.js

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-import { parseArgs } from './parser.js';
-import { resolveArgs } from './resolver.js';
-const DEFAULT_OPTIONS = {
-    help: {
-        type: 'boolean',
-        short: 'h'
-    },
-    version: {
-        type: 'boolean',
-        short: 'v'
-    }
-};
-/**
- * Parse command line arguments
- * @description This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
- * @example
- * ```js
- * import { parse } from 'args-tokens'
- *
- * const { values, positionals } = parse(process.argv.slice(2))
- * console.log('values', values)
- * console.log('positionals', positionals)
- * ```
- * @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}.
- */
-export function parse(args, options = {}) {
-    const { options: argOptions, allowCompatible = false } = options;
-    const tokens = parseArgs(args, { allowCompatible });
-    return resolveArgs(argOptions || DEFAULT_OPTIONS, tokens);
-}