args-tokens 0.7.0 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -26,70 +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": {
@@ -108,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.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.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/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/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 {};

package/lib/esm/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 {};