args-tokens 0.7.1 → 0.9.0

package/README.md

@@ -2,10 +2,19 @@
 
 [![Version][npm-version-src]][npm-version-href]
 [![JSR][jsr-src]][jsr-href]
+[![InstallSize][install-size-src]][install-size-src]
 [![CI][ci-src]][ci-href]
 
 > [`parseArgs` tokens](https://nodejs.org/api/util.html#parseargs-tokens) compatibility and more high-performance parser
 
+## ✨ Features
+
+- ✅ High performance parser and resolver
+- ✅ `util.parseArgs` token compatibility
+- ✅ Type safe argument values
+- ✅ ES Modules distribution library
+- ✅ Support multi runtime: Browser, Node.js, Deno, Bun
+
 ## 🐱 Motivation
 
 - Although Node.js [`parseArgs`](https://nodejs.org/api/util.html#utilparseargsconfig) can return tokens, that the short options are not in the format I expect. Of course, I recoginize the background of [this issue](https://github.com/pkgjs/parseargs/issues/78).
@@ -19,26 +28,36 @@ With [mitata](https://github.com/evanwashere/mitata):
 pnpm bench:mitata
 
 > args-tokens@0.0.0 bench:mitata /path/to/projects/args-tokens
-> node --expose-gc bench/index.mjs
+> node --expose-gc bench/mitata.js
 
 clk: ~2.87 GHz
 cpu: Apple M1 Max
 runtime: node 18.19.1 (arm64-darwin)
 
-benchmark                   avg (min … max) p75 / p99    (min … top 1%)
-------------------------------------------- -------------------------------
-node:util parseArgs            4.69 µs/iter   4.78 µs      █ █     ██
-                        (4.49 µs … 4.91 µs)   4.85 µs    █ █ ██ █  ██  ███
-                    (  1.32 kb …   1.49 kb)   1.33 kb █▁██▁██████▁█████████
-
-args-tokens parseArgs        842.98 ns/iter 882.65 ns     ▄▄▄▇▃ ▄▃ █
-                    (734.10 ns … 984.32 ns) 966.06 ns   ▂▄█████▄████▅▅▄
-                    (  3.11 kb …   3.41 kb)   3.12 kb █▂███████████████▆▆▆▂
-
-                             ┌                                            ┐
-         node:util parseArgs ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 4.69 µs
-       args-tokens parseArgs ┤ 842.98 ns
-                             └                                            ┘
+benchmark                                       avg (min … max) p75 / p99    (min … top 1%)
+--------------------------------------------------------------- -------------------------------
+util.parseArgs                                     4.16 µs/iter   4.20 µs █
+                                            (4.09 µs … 4.29 µs)   4.28 µs ██ ▅▅▅       ▅
+                                        (  1.36 kb …   1.52 kb)   1.37 kb ██▁████▅▅█▅▁██▁▁▅▁█▅█
+
+args-tokens parse (equivalent to util.parseArgs)   1.65 µs/iter   1.66 µs    █
+                                            (1.61 µs … 1.80 µs)   1.79 µs ▅▃ █▂ ▄
+                                        (  1.95 kb …   2.66 kb)   1.97 kb █████▆█▄▃▃▅▃▁▃▃▁▄▁▁▁▂
+
+args-tokens parseArgs                            729.56 ns/iter 734.11 ns         █
+                                        (697.43 ns … 797.08 ns) 774.93 ns        ▂█▅▂
+                                        (  2.87 kb …   3.54 kb)   3.11 kb ▂▂▃▇▆▅▆████▃▃▄▂▂▂▂▂▁▂
+
+args-tokens resolveArgs                          886.78 ns/iter 887.70 ns       █
+                                        (853.96 ns … 978.89 ns) 957.24 ns       █
+                                        (  2.51 kb …   2.87 kb)   2.79 kb ▂▃█▃▄▅█▄▃▂▂▃▃▂▂▂▂▂▁▁▁
+
+                                                 ┌                                            ┐
+                                  util.parseArgs ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 4.16 µs
+args-tokens parse (equivalent to util.parseArgs) ┤■■■■■■■■■ 1.65 µs
+                           args-tokens parseArgs ┤ 729.56 ns
+                         args-tokens resolveArgs ┤■■ 886.78 ns
+                                                 └                                            ┘
 ```
 
 With [vitest](https://vitest.dev/guide/features.html#benchmarking):
@@ -55,15 +74,24 @@ Breaking changes might not follow SemVer, please pin Vitest's version when using
  RUN  v3.0.5 /path/to/projects/args-tokens
 
 
- ✓ bench/vitest.bench.mjs > parseArgs 1466ms
+ ✓ bench/vitest.bench.js > parse and resolve 1350ms
+     name                       hz     min     max    mean     p75     p99    p995    p999     rme  samples
+   · util.parseArgs     221,285.36  0.0041  0.2700  0.0045  0.0044  0.0054  0.0063  0.0629  ±0.38%   110643
+   · args-tokens parse  527,127.11  0.0017  0.2153  0.0019  0.0019  0.0023  0.0027  0.0055  ±0.38%   263564   fastest
+
+ ✓ bench/vitest.bench.js > parseArgs 1434ms
      name                   hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · node:util      194,911.34  0.0042  0.6821  0.0051  0.0046  0.0151  0.0292  0.1079  ±0.82%    97456
-   · args-tokens  1,101,845.21  0.0007  0.1883  0.0009  0.0009  0.0012  0.0031  0.0140  ±0.32%   550923   fastest
+   · node:util      235,217.05  0.0039  0.2665  0.0043  0.0042  0.0048  0.0058  0.0139  ±0.43%   117609
+   · args-tokens  1,307,135.24  0.0006  0.1737  0.0008  0.0008  0.0009  0.0010  0.0016  ±0.43%   653568   fastest
 
  BENCH  Summary
 
-  args-tokens - bench/vitest.bench.mjs > parseArgs
-    5.65x faster than node:util
+  args-tokens parse - bench/vitest.bench.js > parse and resolve
+    2.38x faster than util.parseArgs
+
+  args-tokens - bench/vitest.bench.js > parseArgs
+    5.56x faster than node:util
+
 ```
 
 ## ❓ What's different about parseArgs tokens?
@@ -273,6 +301,10 @@ 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.
@@ -294,5 +326,7 @@ This project is inspired by:
 [npm-version-href]: https://npmjs.com/package/args-tokens
 [jsr-src]: https://jsr.io/badges/@kazupon/args-tokens
 [jsr-href]: https://jsr.io/@kazupon/args-tokens
+[install-size-src]: https://pkg-size.dev/badge/install/35082
+[install-size-href]: https://pkg-size.dev/args-tokens
 [ci-src]: https://github.com/kazupon/args-tokens/actions/workflows/ci.yml/badge.svg
 [ci-href]: https://github.com/kazupon/args-tokens/actions/workflows/ci.yml

package/lib/{esm/parse.d.ts → parse.d.ts}

@@ -33,8 +33,9 @@ export type ParsedArgs<T extends ArgOptions> = {
  * console.log('values', values)
  * console.log('positionals', positionals)
  * ```
- * @param args command line arguments
- * @param options parse options, about details see {@link ParseOptions}
+ * @param args - command line arguments
+ * @param options - parse options, about details see {@link ParseOptions}
+ * @throws if command line arguments are invalid, this function will cause {@link AggregateError | validation errors}.
  * @returns parsed values
  */
 export declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;

package/lib/{esm/parse.js → parse.js}

@@ -23,8 +23,9 @@ const DEFAULT_OPTIONS = {
  * console.log('values', values)
  * console.log('positionals', positionals)
  * ```
- * @param args command line arguments
- * @param options parse options, about details see {@link ParseOptions}
+ * @param args - command line arguments
+ * @param options - parse options, about details see {@link ParseOptions}
+ * @throws if command line arguments are invalid, this function will cause {@link AggregateError | validation errors}.
  * @returns parsed values
  */
 export function parse(args, options = {}) {

package/lib/{esm/resolver.d.ts → resolver.d.ts}

@@ -43,6 +43,13 @@ type ResolveArgValues<O extends ArgOptions, V extends Record<keyof O, unknown>>
 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}.
+ * @throws if command line arguments are invalid, this function will cause {@link AggregateError | validation errors}.
+ * @returns An object that contains the values of the arguments and positional arguments.
+ */
 export declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[]): {
     values: ArgValues<T>;
     positionals: string[];

package/lib/{esm/resolver.js → resolver.js}

@@ -1,6 +1,13 @@
 // 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}.
+ * @throws if command line arguments are invalid, this function will cause {@link AggregateError | validation errors}.
+ * @returns An object that contains the values of the arguments and positional arguments.
+ */
 export function resolveArgs(options, tokens) {
     const values = {};
     const positionals = [];
@@ -103,22 +110,36 @@ export function resolveArgs(options, tokens) {
     /**
      * resolve values
      */
+    const errors = [];
     for (const [option, schema] of Object.entries(options)) {
-        if (longOptionTokens.length === 0 && shortOptionTokens.length === 0 && schema.required) {
-            throw createRequireError(option, schema);
+        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)) {
-                validateRequire(token, option, schema);
+                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 {
-                    validateValue(token, option, schema);
+                    const invalid = validateValue(token, option, schema);
+                    if (invalid) {
+                        errors.push(invalid);
+                        continue;
+                    }
                 }
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
                 ;
@@ -131,13 +152,21 @@ export function resolveArgs(options, tokens) {
             const token = shortOptionTokens[i];
             // eslint-disable-next-line unicorn/no-null
             if (schema.short === token.name && token.rawName != null && isShortOption(token.rawName)) {
-                validateRequire(token, option, schema);
+                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 {
-                    validateValue(token, option, schema);
+                    const invalid = validateValue(token, option, schema);
+                    if (invalid) {
+                        errors.push(invalid);
+                        continue;
+                    }
                 }
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
                 ;
@@ -153,6 +182,10 @@ export function resolveArgs(options, tokens) {
             values[option] = schema.default;
         }
     }
+    if (errors.length > 0) {
+        // eslint-disable-next-line unicorn/error-message
+        throw new AggregateError(errors);
+    }
     return { values, positionals };
 }
 function createRequireError(option, schema) {
@@ -160,20 +193,20 @@ function createRequireError(option, schema) {
 }
 function validateRequire(token, option, schema) {
     if (schema.required && schema.type !== 'boolean' && !token.value) {
-        throw createRequireError(option, schema);
+        return createRequireError(option, schema);
     }
 }
 function validateValue(token, option, schema) {
     switch (schema.type) {
         case 'number': {
             if (!isNumeric(token.value)) {
-                throw createTypeError(option, schema);
+                return createTypeError(option, schema);
             }
             break;
         }
         case 'string': {
             if (typeof token.value !== 'string') {
-                throw createTypeError(option, schema);
+                return createTypeError(option, schema);
             }
             break;
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -26,69 +26,68 @@
     "access": "public"
   },
   "engines": {
-    "node": ">= 18.18"
+    "node": ">= 20"
   },
+  "type": "module",
   "files": [
     "lib"
   ],
-  "main": "lib/cjs/index.js",
-  "module": "lib/esm/index.js",
+  "module": "lib/index.js",
   "exports": {
     ".": {
-      "types": "./lib/cjs/index.d.ts",
-      "import": "./lib/esm/index.js",
-      "require": "./lib/cjs/index.js",
-      "default": "./lib/cjs/index.js"
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
     },
     "./parser": {
-      "types": "./lib/cjs/parser.d.ts",
-      "import": "./lib/esm/parser.js",
-      "require": "./lib/cjs/parser.js",
-      "default": "./lib/cjs/parser.js"
+      "types": "./lib/parser.d.ts",
+      "import": "./lib/parser.js",
+      "require": "./lib/parser.js",
+      "default": "./lib/parser.js"
     },
     "./resolver": {
-      "types": "./lib/cjs/resolver.d.ts",
-      "import": "./lib/esm/resolver.js",
-      "require": "./lib/cjs/resolver.js",
-      "default": "./lib/cjs/resolver.js"
+      "types": "./lib/resolver.d.ts",
+      "import": "./lib/resolver.js",
+      "require": "./lib/resolver.js",
+      "default": "./lib/resolver.js"
     },
     "./package.json": "./package.json",
     "./*": "./*"
   },
-  "types": "lib/cjs/index.d.ts",
+  "types": "lib/index.d.ts",
   "typesVersions": {
     "*": {
       "*": [
-        "./lib/cjs/*",
-        "./lib/esm/*",
+        "./lib/*",
         "./*"
       ]
     }
   },
   "devDependencies": {
     "@eslint/markdown": "^6.2.2",
-    "@kazupon/eslint-config": "^0.19.0",
+    "@kazupon/eslint-config": "^0.22.0",
     "@kazupon/prettier-config": "^0.1.1",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.5",
     "@vitest/eslint-plugin": "^1.1.31",
     "bumpp": "^10.0.3",
-    "eslint": "^9.20.1",
+    "eslint": "^9.21.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^2.7.0",
-    "eslint-plugin-unicorn": "^56.0.1",
-    "eslint-plugin-yml": "^1.16.0",
+    "eslint-plugin-unicorn": "^57.0.0",
+    "eslint-plugin-yml": "^1.17.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.3",
-    "knip": "^5.44.1",
+    "knip": "^5.44.4",
     "lint-staged": "^15.4.3",
     "mitata": "^1.0.34",
     "pkg-pr-new": "^0.0.39",
-    "prettier": "^3.5.1",
+    "prettier": "^3.5.2",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.24.0",
-    "vitest": "^3.0.5"
+    "typescript-eslint": "^8.24.1",
+    "vitest": "^3.0.6"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {
@@ -107,9 +106,7 @@
   "scripts": {
     "bench:mitata": "node --expose-gc bench/mitata.js",
     "bench:vitest": "vitest bench --run",
-    "build": "pnpm run --parallel --color \"/^build:/\"",
-    "build:cjs": "tsc -p ./tsconfig.cjs.json",
-    "build:esm": "tsc -p ./tsconfig.esm.json",
+    "build": "tsc -p ./tsconfig.build.json",
     "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",

package/lib/cjs/index.js

@@ -1,11 +0,0 @@
-"use strict";
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveArgs = exports.parseArgs = exports.parse = void 0;
-var parse_js_1 = require("./parse.js");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_js_1.parse; } });
-var parser_js_1 = require("./parser.js");
-Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return parser_js_1.parseArgs; } });
-var resolver_js_1 = require("./resolver.js");
-Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return resolver_js_1.resolveArgs; } });

package/lib/cjs/parse.d.ts

@@ -1,40 +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[];
-};
-/**
- * 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 parsed values
- */
-export declare function parse<O extends ArgOptions>(args: string[], options?: ParseOptions<O>): ParsedArgs<O>;

package/lib/cjs/parse.js

@@ -1,37 +0,0 @@
-"use strict";
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = parse;
-const parser_js_1 = require("./parser.js");
-const resolver_js_1 = require("./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 parsed values
- */
-function parse(args, options = {}) {
-    const { options: argOptions, allowCompatible = false } = options;
-    const tokens = (0, parser_js_1.parseArgs)(args, { allowCompatible });
-    return (0, resolver_js_1.resolveArgs)(argOptions || DEFAULT_OPTIONS, tokens);
-}

package/lib/cjs/parser.js

@@ -1,231 +0,0 @@
-"use strict";
-// 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
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-exports.isShortOption = isShortOption;
-exports.hasLongOptionPrefix = hasLongOptionPrefix;
-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
- */
-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
- */
-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
- */
-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;
-}

package/lib/cjs/resolver.d.ts

@@ -1,50 +0,0 @@
-import type { ArgToken } from './parser';
-/**
- * An option schema for an argument.
- */
-export interface ArgOptionSchema {
-    /**
-     * Type of argument.
-     */
-    type: 'string' | 'boolean' | 'number';
-    /**
-     * A single character alias for the option.
-     */
-    short?: 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 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];
-};
-export declare function resolveArgs<T extends ArgOptions>(options: T, tokens: ArgToken[]): {
-    values: ArgValues<T>;
-    positionals: string[];
-};
-export {};

package/lib/cjs/resolver.js

@@ -1,201 +0,0 @@
-"use strict";
-// SPDX-License-Identifier: MIT
-// Modifier: kazuya kawaguchi (a.k.a. kazupon)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveArgs = resolveArgs;
-const parser_js_1 = require("./parser.js");
-function resolveArgs(options, tokens) {
-    const values = {};
-    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 ((0, parser_js_1.hasLongOptionPrefix)(token.rawName)) {
-                    if (token.inlineValue) {
-                        longOptionTokens.push({ ...token });
-                    }
-                    else {
-                        currentLongOption = { ...token };
-                    }
-                    // check if previous short option is not resolved
-                    applyShortOptionValue();
-                }
-                else if ((0, parser_js_1.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
-     */
-    for (const [option, schema] of Object.entries(options)) {
-        if (longOptionTokens.length === 0 && shortOptionTokens.length === 0 && schema.required) {
-            throw createRequireError(option, schema);
-        }
-        // 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 && (0, parser_js_1.hasLongOptionPrefix)(token.rawName)) {
-                validateRequire(token, option, schema);
-                if (schema.type === 'boolean') {
-                    // NOTE: re-set value to undefined, because long boolean type option is set on analyze phase
-                    token.value = undefined;
-                }
-                else {
-                    validateValue(token, option, schema);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                ;
-                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 && (0, parser_js_1.isShortOption)(token.rawName)) {
-                validateRequire(token, option, schema);
-                if (schema.type === 'boolean') {
-                    // NOTE: re-set value to undefined, because short boolean type option is set on analyze phase
-                    token.value = undefined;
-                }
-                else {
-                    validateValue(token, option, schema);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                ;
-                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, @typescript-eslint/no-unsafe-member-access
-            ;
-            values[option] = schema.default;
-        }
-    }
-    return { values, positionals };
-}
-function createRequireError(option, schema) {
-    return new Error(`Option '--${option}' ${schema.short ? `or '-${schema.short}'` : ''} is required`);
-}
-function validateRequire(token, option, schema) {
-    if (schema.required && schema.type !== 'boolean' && !token.value) {
-        throw createRequireError(option, schema);
-    }
-}
-function validateValue(token, option, schema) {
-    switch (schema.type) {
-        case 'number': {
-            if (!isNumeric(token.value)) {
-                throw createTypeError(option, schema);
-            }
-            break;
-        }
-        case 'string': {
-            if (typeof token.value !== 'string') {
-                throw 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 TypeError(`Option '--${option}' ${schema.short ? `or '-${schema.short}'` : ''} should be '${schema.type}'`);
-}
-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;
-}

package/lib/esm/index.d.ts

@@ -1,6 +0,0 @@
-export { parse } from './parse.js';
-export { parseArgs } from './parser.js';
-export { resolveArgs } from './resolver.js';
-export type { ParsedArgs, ParseOptions } from './parse';
-export type { ArgToken, ParserOptions } from './parser';
-export type { ArgOptions, ArgOptionSchema, ArgValues } from './resolver';

package/lib/esm/parser.d.ts

@@ -1,77 +0,0 @@
-/**
- * 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;
-}
-/**
- * Parser Options
- */
-export 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[];
-/**
- * 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 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 {};