args-tokens 0.15.1 → 0.16.0

package/lib/index.d.ts

@@ -1,57 +1,56 @@
-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";
+import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser.d-Cheh2e-O.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D6XfwWOY.js";
 
 //#region src/parse.d.ts
 /**
 * Parse options for {@link parse} function.
 */
 interface ParseOptions<O extends ArgOptions> extends ParserOptions, ResolveArgsOptions {
-	/**
-	* Command line options, about details see {@link ArgOptions}.
-	*/
-	options?: O;
+  /**
+  * 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[]
-	/**
-	* 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.
-* 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, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
-*/
-declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;
+  /**
+  * Parsed values, same as `values` in {@link resolveArgs}.
+  */
+  values: ArgValues<T>;
+  /**
+  * Positional arguments, same as `positionals` in {@link resolveArgs}.
+  */
+  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.
+   * 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, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
+   */
 
-//#endregion
+declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>; //#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-D4hvuBLP.js";
+import { parseArgs } from "./parser-Dr4iAGaX.js";
+import { OptionResolveError, resolveArgs } from "./resolver-B89Gv70Z.js";
 
 //#region src/parse.ts
 const DEFAULT_OPTIONS = {
@@ -12,10 +12,25 @@ const DEFAULT_OPTIONS = {
 		short: "v"
 	}
 };
+/**
+* Parse command line arguments.
+* 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, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
+*/
 function parse(args, options = {}) {
-	const { options: argOptions, allowCompatible = false, allowNegative = false } = options;
+	const { options: argOptions, allowCompatible = false } = options;
 	const tokens = parseArgs(args, { allowCompatible });
-	return Object.assign(Object.create(null), resolveArgs(argOptions || DEFAULT_OPTIONS, tokens, { allowNegative }), { tokens });
+	return Object.assign(Object.create(null), resolveArgs(argOptions || DEFAULT_OPTIONS, tokens), { tokens });
 }
 
 //#endregion

package/lib/{parser-DxH6Mf-o.js → parser-Dr4iAGaX.js}

@@ -1,4 +1,3 @@
-
 //#region src/parser.ts
 const HYPHEN_CHAR = "-";
 const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
@@ -7,6 +6,22 @@ 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.
+*/
 function parseArgs(args, options = {}) {
 	const { allowCompatible = false } = options;
 	const tokens = [];
@@ -120,6 +135,11 @@ function parseArgs(args, options = {}) {
 	}
 	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.
+*/
 function isShortOption(arg) {
 	return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
 }
@@ -150,6 +170,11 @@ function isLongOption(arg) {
 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.
+*/
 function hasLongOptionPrefix(arg) {
 	return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
 }

package/lib/parser.d-Cheh2e-O.d.ts

@@ -0,0 +1,90 @@
+//#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
+*/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,3 +1,2 @@
-import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser.d-nUUBO6hL.js";
-
+import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser.d-Cheh2e-O.js";
 export { ArgToken, ParserOptions, hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/parser.js

@@ -1,3 +1,3 @@
-import { hasLongOptionPrefix, isShortOption, parseArgs } from "./parser-DxH6Mf-o.js";
+import { hasLongOptionPrefix, isShortOption, parseArgs } from "./parser-Dr4iAGaX.js";
 
 export { hasLongOptionPrefix, isShortOption, parseArgs };

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

@@ -1,7 +1,14 @@
-import { hasLongOptionPrefix, isShortOption } from "./parser-DxH6Mf-o.js";
+import { hasLongOptionPrefix, isShortOption } from "./parser-Dr4iAGaX.js";
 
 //#region src/resolver.ts
-function resolveArgs(options, tokens, { optionGrouping = false, allowNegative = false } = {}) {
+/**
+* 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}.
+*/
+function resolveArgs(options, tokens, { optionGrouping = false } = {}) {
 	const positionals = [];
 	const rest = [];
 	const longOptionTokens = [];
@@ -100,7 +107,7 @@ function resolveArgs(options, tokens, { optionGrouping = false, allowNegative =
 	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);
+		return token.name === (schema.type === "boolean" ? schema.negatable && token.name?.startsWith("no-") ? `no-${option}` : option : option);
 	}
 	for (const [option, schema] of Object.entries(options)) {
 		if (schema.required) {
@@ -126,7 +133,7 @@ function resolveArgs(options, tokens, { optionGrouping = false, allowNegative =
 						continue;
 					}
 				}
-				values[option] = resolveOptionValue(token, schema, allowNegative);
+				values[option] = resolveOptionValue(token, schema);
 				continue;
 			}
 		}
@@ -162,6 +169,10 @@ function resolveArgs(options, tokens, { optionGrouping = false, allowNegative =
 function createRequireError(option, schema) {
 	return new OptionResolveError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`, option, "required", schema);
 }
+/**
+* An error that occurs when resolving options.
+* This error is thrown when the option is not valid.
+*/
 var OptionResolveError = class extends Error {
 	name;
 	schema;
@@ -198,9 +209,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, allowNegative = false) {
+function resolveOptionValue(token, schema) {
 	if (token.value) return schema.type === "number" ? +token.value : token.value;
-	if (schema.type === "boolean") return allowNegative && token.name.startsWith("no-") ? false : true;
+	if (schema.type === "boolean") return schema.negatable && token.name.startsWith("no-") ? false : true;
 	return schema.type === "number" ? +(schema.default || "") : schema.default;
 }
 

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

@@ -0,0 +1,115 @@
+import { ArgToken } from "./parser.d-Cheh2e-O.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;
+  /**
+  * Whether the negatable option for `boolean` type
+  */
+  negatable?: boolean;
+  /**
+  * 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;
+}
+
+/**
+* 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
+}?: 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,4 +1,3 @@
-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";
-
+import "./parser.d-Cheh2e-O.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, ExtractOptionValue, FilterArgs, OptionResolveError$1 as OptionResolveError, OptionResolveErrorType, ResolveArgValues, ResolveArgsOptions, resolveArgs$1 as resolveArgs } from "./resolver.d-D6XfwWOY.js";
 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-D4hvuBLP.js";
+import "./parser-Dr4iAGaX.js";
+import { OptionResolveError, resolveArgs } from "./resolver-B89Gv70Z.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.15.1",
+  "version": "0.16.0",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -68,29 +68,29 @@
     "@eslint/markdown": "^6.4.0",
     "@kazupon/eslint-config": "^0.29.0",
     "@kazupon/prettier-config": "^0.1.1",
-    "@types/node": "^22.14.1",
+    "@types/node": "^22.15.2",
     "@vitest/eslint-plugin": "^1.1.43",
     "bumpp": "^10.1.0",
-    "deno": "^2.2.11",
-    "eslint": "^9.25.0",
+    "deno": "^2.2.12",
+    "eslint": "^9.25.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-jsonc": "^2.20.0",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^2.7.0",
     "eslint-plugin-unicorn": "^58.0.0",
-    "eslint-plugin-yml": "^1.17.0",
+    "eslint-plugin-yml": "^1.18.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.4",
+    "jsr-exports-lint": "^0.2.0",
     "knip": "^5.50.5",
     "lint-staged": "^15.5.1",
     "mitata": "^1.0.34",
     "pkg-pr-new": "^0.0.43",
     "prettier": "^3.5.3",
-    "tsdown": "^0.9.1",
-    "tsdown-jsr-exports-lint": "^0.1.4",
+    "tsdown": "^0.10.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.30.1",
-    "vitest": "^3.1.1"
+    "typescript-eslint": "^8.31.0",
+    "vitest": "^3.1.2"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {

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

@@ -1,99 +0,0 @@
-
-//#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/resolver.d-D_30OItP.d.ts

@@ -1,116 +0,0 @@
-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 };