@jakubmazanec/args 1.0.0-de51f16

package/dist/internals/expandArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/expandArguments.ts"],"sourcesContent":["import {type Argv} from '../types.js';\nimport {isShortOptionsGroup} from './isShortOptionsGroup.js';\n\n/**\n * A function that converts any argument that is a short options group into separate short options.\n *\n * @param argv Arguments.\n * @return Arguments that contain no short options group\n */\nexport function expandArguments(argv: Argv): Argv {\n  let expandedArguments = [];\n\n  for (let arg of argv) {\n    if (isShortOptionsGroup(arg)) {\n      expandedArguments.push(...[...arg].slice(1).map((value) => `-${value}`));\n    } else {\n      expandedArguments.push(arg);\n    }\n  }\n\n  return expandedArguments;\n}\n"],"names":["isShortOptionsGroup","expandArguments","argv","expandedArguments","arg","push","slice","map","value"],"mappings":"AACA,SAAQA,mBAAmB,QAAO,2BAA2B;AAE7D;;;;;CAKC,GACD,OAAO,SAASC,gBAAgBC,IAAU,EAAQ;IAChD,IAAIC,oBAAoB,EAAE;IAE1B,KAAK,IAAIC,OAAOF,KAAM;QACpB,IAAIF,oBAAoBI,MAAM;YAC5BD,kBAAkBE,IAAI,IAAI;mBAAID;aAAI,CAACE,KAAK,CAAC,GAAGC,GAAG,CAAC,CAACC,QAAU,CAAC,CAAC,EAAEA,MAAM,CAAC;QACxE,OAAO;YACLL,kBAAkBE,IAAI,CAACD;QACzB,CAAC;IACH;IAEA,OAAOD;AACT,CAAC"}

package/dist/internals/isCommand.d.ts

@@ -0,0 +1,8 @@
+export declare const COMMAND_REGEXP: RegExp;
+/**
+ * A function that checks if a value is an argument that looks like command, i.e. space-separated words consisting only of letters, numbers (but not at the start of the word) or dashes.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a command.
+ */
+export declare function isCommand(value: string): boolean;

package/dist/internals/isCommand.js

@@ -0,0 +1,11 @@
+export const COMMAND_REGEXP = /^(?:[a-z][-a-z0-9]*[a-z])+(?:\s(?:[a-z][-a-z0-9]*[a-z])+)*$/iu;
+/**
+ * A function that checks if a value is an argument that looks like command, i.e. space-separated words consisting only of letters, numbers (but not at the start of the word) or dashes.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a command.
+ */ export function isCommand(value) {
+    return COMMAND_REGEXP.test(value);
+}
+
+//# sourceMappingURL=isCommand.js.map

package/dist/internals/isCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isCommand.ts"],"sourcesContent":["export const COMMAND_REGEXP = /^(?:[a-z][-a-z0-9]*[a-z])+(?:\\s(?:[a-z][-a-z0-9]*[a-z])+)*$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like command, i.e. space-separated words consisting only of letters, numbers (but not at the start of the word) or dashes.\n *\n * @param value The value to check.\n * @return `true` if `value` is a command.\n */\nexport function isCommand(value: string): boolean {\n  return COMMAND_REGEXP.test(value);\n}\n"],"names":["COMMAND_REGEXP","isCommand","value","test"],"mappings":"AAAA,OAAO,MAAMA,iBAAiB,gEAAgE;AAE9F;;;;;CAKC,GACD,OAAO,SAASC,UAAUC,KAAa,EAAW;IAChD,OAAOF,eAAeG,IAAI,CAACD;AAC7B,CAAC"}

package/dist/internals/isFalseString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A function that checks if a string value is a false string. A false string is `'false'`, `'0'`, `'no'`, or `'off'` (case insensitive).
+ *
+ * @param value The value to be tested.
+ * @return `true` if string is a false string. */
+export declare function isFalseString(value: string): boolean;

package/dist/internals/isFalseString.js

@@ -0,0 +1,10 @@
+const FALSE_STRING_REGEXP = /^\s*(?:false|0|no|off)\s*$/iu;
+/**
+ * A function that checks if a string value is a false string. A false string is `'false'`, `'0'`, `'no'`, or `'off'` (case insensitive).
+ *
+ * @param value The value to be tested.
+ * @return `true` if string is a false string. */ export function isFalseString(value) {
+    return FALSE_STRING_REGEXP.test(value);
+}
+
+//# sourceMappingURL=isFalseString.js.map

package/dist/internals/isFalseString.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isFalseString.ts"],"sourcesContent":["const FALSE_STRING_REGEXP = /^\\s*(?:false|0|no|off)\\s*$/iu;\n\n/**\n * A function that checks if a string value is a false string. A false string is `'false'`, `'0'`, `'no'`, or `'off'` (case insensitive).\n *\n * @param value The value to be tested.\n * @return `true` if string is a false string. */\nexport function isFalseString(value: string) {\n  return FALSE_STRING_REGEXP.test(value);\n}\n"],"names":["FALSE_STRING_REGEXP","isFalseString","value","test"],"mappings":"AAAA,MAAMA,sBAAsB;AAE5B;;;;+CAI+C,GAC/C,OAAO,SAASC,cAAcC,KAAa,EAAE;IAC3C,OAAOF,oBAAoBG,IAAI,CAACD;AAClC,CAAC"}

package/dist/internals/isLongOption.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that checks if a value is an argument that looks like a long option, i.e. two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes; e.g. `'--some-option'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a long option.
+ */
+export declare function isLongOption(arg: string): boolean;

package/dist/internals/isLongOption.js

@@ -0,0 +1,11 @@
+const LONG_OPTION_REGEXP = /^--[a-z][-a-z0-9]+$/iu;
+/**
+ * A function that checks if a value is an argument that looks like a long option, i.e. two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes; e.g. `'--some-option'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a long option.
+ */ export function isLongOption(arg) {
+    return LONG_OPTION_REGEXP.test(arg);
+}
+
+//# sourceMappingURL=isLongOption.js.map

package/dist/internals/isLongOption.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isLongOption.ts"],"sourcesContent":["const LONG_OPTION_REGEXP = /^--[a-z][-a-z0-9]+$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a long option, i.e. two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes; e.g. `'--some-option'`.\n *\n * @param value The value to check.\n * @return `true` if `value` is a long option.\n */\nexport function isLongOption(arg: string): boolean {\n  return LONG_OPTION_REGEXP.test(arg);\n}\n"],"names":["LONG_OPTION_REGEXP","isLongOption","arg","test"],"mappings":"AAAA,MAAMA,qBAAqB;AAE3B;;;;;CAKC,GACD,OAAO,SAASC,aAAaC,GAAW,EAAW;IACjD,OAAOF,mBAAmBG,IAAI,CAACD;AACjC,CAAC"}

package/dist/internals/isOptionLike.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that checks if a value is an argument that looks like a long option, short option, or a short options group i.e. one or two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes, optionally followed by `=`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is an option.
+ */
+export declare function isOptionLike(value: string): boolean;

package/dist/internals/isOptionLike.js

@@ -0,0 +1,11 @@
+const OPTION_LIKE = /^-{1,2}[a-z][-a-z0-9]*=?/iu;
+/**
+ * A function that checks if a value is an argument that looks like a long option, short option, or a short options group i.e. one or two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes, optionally followed by `=`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is an option.
+ */ export function isOptionLike(value) {
+    return OPTION_LIKE.test(value);
+}
+
+//# sourceMappingURL=isOptionLike.js.map

package/dist/internals/isOptionLike.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isOptionLike.ts"],"sourcesContent":["const OPTION_LIKE = /^-{1,2}[a-z][-a-z0-9]*=?/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a long option, short option, or a short options group i.e. one or two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes, optionally followed by `=`.\n *\n * @param value The value to check.\n * @return `true` if `value` is an option.\n */\nexport function isOptionLike(value: string): boolean {\n  return OPTION_LIKE.test(value);\n}\n"],"names":["OPTION_LIKE","isOptionLike","value","test"],"mappings":"AAAA,MAAMA,cAAc;AAEpB;;;;;CAKC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAW;IACnD,OAAOF,YAAYG,IAAI,CAACD;AAC1B,CAAC"}

package/dist/internals/isShortOption.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that checks if a value is an argument that looks like a short option, i.e. a dash and a single letter; e.g. `'-x'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a short option.
+ */
+export declare function isShortOption(arg: string): boolean;

package/dist/internals/isShortOption.js

@@ -0,0 +1,11 @@
+const SHORT_OPTION_REGEXP = /^-[a-z]{1}$/iu;
+/**
+ * A function that checks if a value is an argument that looks like a short option, i.e. a dash and a single letter; e.g. `'-x'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a short option.
+ */ export function isShortOption(arg) {
+    return SHORT_OPTION_REGEXP.test(arg);
+}
+
+//# sourceMappingURL=isShortOption.js.map

package/dist/internals/isShortOption.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isShortOption.ts"],"sourcesContent":["const SHORT_OPTION_REGEXP = /^-[a-z]{1}$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a short option, i.e. a dash and a single letter; e.g. `'-x'`.\n *\n * @param value The value to check.\n * @return `true` if `value` is a short option.\n */\nexport function isShortOption(arg: string): boolean {\n  return SHORT_OPTION_REGEXP.test(arg);\n}\n"],"names":["SHORT_OPTION_REGEXP","isShortOption","arg","test"],"mappings":"AAAA,MAAMA,sBAAsB;AAE5B;;;;;CAKC,GACD,OAAO,SAASC,cAAcC,GAAW,EAAW;IAClD,OAAOF,oBAAoBG,IAAI,CAACD;AAClC,CAAC"}

package/dist/internals/isShortOptionsGroup.d.ts

@@ -0,0 +1,8 @@
+export declare const SHORT_OPTIONS_GROUP_REGEXP: RegExp;
+/**
+ * A function that checks if a value is an argument that looks like a short options group, i.e. a dash and a single letter; e.g. `'-x'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a short option.
+ */
+export declare function isShortOptionsGroup(arg: string): boolean;

package/dist/internals/isShortOptionsGroup.js

@@ -0,0 +1,11 @@
+export const SHORT_OPTIONS_GROUP_REGEXP = /^-[a-z]{2,}$/iu;
+/**
+ * A function that checks if a value is an argument that looks like a short options group, i.e. a dash and a single letter; e.g. `'-x'`.
+ *
+ * @param value The value to check.
+ * @return `true` if `value` is a short option.
+ */ export function isShortOptionsGroup(arg) {
+    return SHORT_OPTIONS_GROUP_REGEXP.test(arg);
+}
+
+//# sourceMappingURL=isShortOptionsGroup.js.map

package/dist/internals/isShortOptionsGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isShortOptionsGroup.ts"],"sourcesContent":["export const SHORT_OPTIONS_GROUP_REGEXP = /^-[a-z]{2,}$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a short options group, i.e. a dash and a single letter; e.g. `'-x'`.\n *\n * @param value The value to check.\n * @return `true` if `value` is a short option.\n */\nexport function isShortOptionsGroup(arg: string): boolean {\n  return SHORT_OPTIONS_GROUP_REGEXP.test(arg);\n}\n"],"names":["SHORT_OPTIONS_GROUP_REGEXP","isShortOptionsGroup","arg","test"],"mappings":"AAAA,OAAO,MAAMA,6BAA6B,iBAAiB;AAE3D;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,GAAW,EAAW;IACxD,OAAOF,2BAA2BG,IAAI,CAACD;AACzC,CAAC"}

package/dist/internals/isTrueString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A function that checks if a string value is a true string. A true string is `'true'`, `'1'`, `'yes'`, or `'on'` (case insensitive).
+ *
+ * @param value The value to be tested.
+ * @return `true` if string is a true string. */
+export declare function isTrueString(value: string): boolean;

package/dist/internals/isTrueString.js

@@ -0,0 +1,10 @@
+const TRUE_STRING_REGEXP = /^\s*(?:true|1|yes|on)\s*$/iu;
+/**
+ * A function that checks if a string value is a true string. A true string is `'true'`, `'1'`, `'yes'`, or `'on'` (case insensitive).
+ *
+ * @param value The value to be tested.
+ * @return `true` if string is a true string. */ export function isTrueString(value) {
+    return TRUE_STRING_REGEXP.test(value);
+}
+
+//# sourceMappingURL=isTrueString.js.map

package/dist/internals/isTrueString.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/isTrueString.ts"],"sourcesContent":["const TRUE_STRING_REGEXP = /^\\s*(?:true|1|yes|on)\\s*$/iu;\n\n/**\n * A function that checks if a string value is a true string. A true string is `'true'`, `'1'`, `'yes'`, or `'on'` (case insensitive).\n *\n * @param value The value to be tested.\n * @return `true` if string is a true string. */\nexport function isTrueString(value: string) {\n  return TRUE_STRING_REGEXP.test(value);\n}\n"],"names":["TRUE_STRING_REGEXP","isTrueString","value","test"],"mappings":"AAAA,MAAMA,qBAAqB;AAE3B;;;;8CAI8C,GAC9C,OAAO,SAASC,aAAaC,KAAa,EAAE;IAC1C,OAAOF,mBAAmBG,IAAI,CAACD;AACjC,CAAC"}

package/dist/internals.d.ts

@@ -0,0 +1,14 @@
+export * from './internals/castValue.js';
+export * from './internals/CommandScope.js';
+export * from './internals/commandToArguments.js';
+export * from './internals/createOptionShortNameMap.js';
+export * from './internals/expandArguments.js';
+export * from './internals/Checker.js';
+export * from './internals/isCommand.js';
+export * from './internals/isFalseString.js';
+export * from './internals/isLongOption.js';
+export * from './internals/isOptionLike.js';
+export * from './internals/isShortOption.js';
+export * from './internals/isShortOptionsGroup.js';
+export * from './internals/isTrueString.js';
+export * from './internals/OptionScope.js';

package/dist/internals.js

@@ -0,0 +1,16 @@
+export * from './internals/castValue.js';
+export * from './internals/CommandScope.js';
+export * from './internals/commandToArguments.js';
+export * from './internals/createOptionShortNameMap.js';
+export * from './internals/expandArguments.js';
+export * from './internals/Checker.js';
+export * from './internals/isCommand.js';
+export * from './internals/isFalseString.js';
+export * from './internals/isLongOption.js';
+export * from './internals/isOptionLike.js';
+export * from './internals/isShortOption.js';
+export * from './internals/isShortOptionsGroup.js';
+export * from './internals/isTrueString.js';
+export * from './internals/OptionScope.js';
+
+//# sourceMappingURL=internals.js.map

package/dist/internals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals.ts"],"sourcesContent":["export * from './internals/castValue.js';\nexport * from './internals/CommandScope.js';\nexport * from './internals/commandToArguments.js';\nexport * from './internals/createOptionShortNameMap.js';\nexport * from './internals/expandArguments.js';\nexport * from './internals/Checker.js';\nexport * from './internals/isCommand.js';\nexport * from './internals/isFalseString.js';\nexport * from './internals/isLongOption.js';\nexport * from './internals/isOptionLike.js';\nexport * from './internals/isShortOption.js';\nexport * from './internals/isShortOptionsGroup.js';\nexport * from './internals/isTrueString.js';\nexport * from './internals/OptionScope.js';\n"],"names":[],"mappings":"AAAA,cAAc,2BAA2B;AACzC,cAAc,8BAA8B;AAC5C,cAAc,oCAAoC;AAClD,cAAc,0CAA0C;AACxD,cAAc,iCAAiC;AAC/C,cAAc,yBAAyB;AACvC,cAAc,2BAA2B;AACzC,cAAc,+BAA+B;AAC7C,cAAc,8BAA8B;AAC5C,cAAc,8BAA8B;AAC5C,cAAc,+BAA+B;AAC7C,cAAc,qCAAqC;AACnD,cAAc,8BAA8B;AAC5C,cAAc,6BAA6B"}

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+export * from './parseArguments.js';
+export * from './ParsingError.js';
+export * from './types.js';
+export * from './ValidationError.js';

package/dist/main.js

@@ -0,0 +1,6 @@
+export * from './parseArguments.js';
+export * from './ParsingError.js';
+export * from './types.js';
+export * from './ValidationError.js';
+
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/main.ts"],"sourcesContent":["export * from './parseArguments.js';\nexport * from './ParsingError.js';\nexport * from './types.js';\nexport * from './ValidationError.js';\n"],"names":[],"mappings":"AAAA,cAAc,sBAAsB;AACpC,cAAc,oBAAoB;AAClC,cAAc,aAAa;AAC3B,cAAc,uBAAuB"}

package/dist/parseArguments.d.ts

@@ -0,0 +1,10 @@
+import { type Arguments, type Argv, type ParserConfig } from './types.js';
+/**
+ * Parse a list of command line arguments into an arguments object. Based on provided parser config, raw arguments can be parsed as commands, options and parameters.
+ *
+ * @param argv Raw arguments to be parsed.
+ * @param parserConfig Parser configuration.
+ * @return Parsed arguments.
+ *
+ */
+export declare function parseArguments<const O extends ParserConfig>(argv: Argv, parserConfig: O): Arguments<O>;

package/dist/parseArguments.js

@@ -0,0 +1,244 @@
+import { castValue, Checker, CommandScope, commandToArguments, createOptionShortNameMap, expandArguments, isFalseString, isLongOption, isOptionLike, isShortOption, isTrueString, OptionScope } from './internals.js';
+import { ParsingError } from './ParsingError.js';
+/* eslint-disable no-param-reassign -- we need to add properties to the `parsedOption` object */ function commitOptionScope(optionScope, parsedOptions) {
+    let optionValue = optionScope.getValue();
+    parsedOptions[optionScope.name] = optionValue;
+    if (optionScope.config.validate) {
+        optionScope.config.validate(parsedOptions[optionScope.name]); // type assertion needed to make TypeScript happy
+    }
+}
+/* eslint-enable no-param-reassign */ /**
+ * Parse a list of command line arguments into an arguments object. Based on provided parser config, raw arguments can be parsed as commands, options and parameters.
+ *
+ * @param argv Raw arguments to be parsed.
+ * @param parserConfig Parser configuration.
+ * @return Parsed arguments.
+ *
+ */ // TODO: refactor
+// eslint-disable-next-line complexity -- TODO
+export function parseArguments(argv, parserConfig) {
+    // create separate configs for commands, parameters and options
+    let commandsConfig = parserConfig.commands ?? [];
+    let parametersConfig = parserConfig.parameters ?? [];
+    let optionsConfig = parserConfig.options ?? {};
+    // check if parser config is valid
+    let checker = new Checker();
+    checker.checkCommandsConfig(commandsConfig);
+    checker.checkParametersConfig(parametersConfig);
+    checker.checkOptionsConfig(optionsConfig);
+    // normalize some configs
+    let normalizedCommandsConfig = commandsConfig.map((command)=>({
+            command: command.toLowerCase(),
+            args: commandToArguments(command.toLowerCase())
+        }));
+    let commandFirstArguments = normalizedCommandsConfig.map((commandConfig)=>commandConfig.args[0]);
+    let optionShortNameMap = parserConfig.options ? createOptionShortNameMap(parserConfig.options) : {};
+    // variables for keeping track of the parsing
+    let parsedCommand;
+    let parsedParameters = [];
+    let parsedOptions = {};
+    let parsedUnknownOptions = {};
+    let restArgs = [];
+    let optionScope = null;
+    let commandScope = null;
+    //
+    let args = expandArguments(argv);
+    for (let [i, arg] of args.entries()){
+        // extract rest arguments
+        if (arg === '--') {
+            restArgs.push(...args.slice(i + 1));
+            break;
+        }
+        try {
+            if (isOptionLike(arg)) {
+                // first let's handle options
+                if (optionScope) {
+                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
+                }
+                // if there is still unhandled `commandScope`, let's handle its args as parameters...
+                if (commandScope) {
+                    let unhandledArgs = commandScope.getArgs();
+                    for (let unhandledArg of unhandledArgs){
+                        if (parserConfig.allowUnknownParameters) {
+                            // let's handle other parameter
+                            parsedParameters.push(unhandledArg);
+                        } else {
+                            checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
+                                messageParameters: [
+                                    unhandledArg
+                                ]
+                            }));
+                        }
+                    }
+                }
+                optionScope = null;
+                commandScope = null;
+                let optionName = arg;
+                let optionValue;
+                // Extract option name and value
+                if (optionName.includes('=')) {
+                    let result = optionName.split('=', 2);
+                    if (result[0] && result[1]) {
+                        [optionName, optionValue] = result;
+                    }
+                }
+                if (isShortOption(optionName)) {
+                    let fullOptionName = optionShortNameMap[optionName.slice(1)];
+                    if (typeof fullOptionName === 'string') {
+                        optionName = fullOptionName;
+                    }
+                } else if (isLongOption(optionName)) {
+                    optionName = optionName.slice(2);
+                }
+                let newOptionScope = new OptionScope(optionName, optionsConfig, parserConfig.allowUnknownOptions);
+                if (typeof parsedOptions[newOptionScope.name] !== 'undefined') {
+                    if (newOptionScope.config.multiple) {
+                        newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];
+                    } else if (newOptionScope.config.type === 'number' && newOptionScope.config.count) {
+                        newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];
+                    }
+                }
+                if (typeof optionValue !== 'undefined') {
+                    newOptionScope.captureArg(optionValue);
+                }
+                if (newOptionScope.isComplete()) {
+                    commitOptionScope(newOptionScope, optionsConfig[newOptionScope.name] ? parsedOptions : parsedUnknownOptions);
+                    optionScope = null;
+                } else {
+                    optionScope = newOptionScope;
+                }
+            } else if (optionScope && !(optionScope.config.type === 'boolean' && !optionScope.config.multiple)) {
+                // let's handle adding more values to previous option, but not if it's signle boolean option
+                optionScope.captureArg(arg);
+                if (optionScope.isComplete()) {
+                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
+                    optionScope = null;
+                }
+            } else if (optionScope && optionScope.config.type === 'boolean' && !optionScope.config.multiple && (isFalseString(arg) || isTrueString(arg))) {
+                // we're adding value to a single boolean option only if the value is "false" or "true" string
+                optionScope.captureArg(arg);
+                if (optionScope.isComplete()) {
+                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
+                    optionScope = null;
+                }
+            } else if (commandScope) {
+                // let's handle rest of the command
+                commandScope.captureArg(arg);
+                if (commandScope.isComplete()) {
+                    parsedCommand = commandScope.getValue();
+                    commandScope = null;
+                } else if (commandScope.isDone()) {
+                    let unhandledArgs = commandScope.getArgs();
+                    for (let unhandledArg of unhandledArgs){
+                        if (parserConfig.allowUnknownParameters) {
+                            // let's handle other parameter
+                            parsedParameters.push(unhandledArg);
+                        } else {
+                            checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
+                                messageParameters: [
+                                    unhandledArg
+                                ]
+                            }));
+                        }
+                    }
+                    commandScope = null;
+                }
+            } else if (typeof parsedCommand === 'undefined' && commandFirstArguments.includes(arg.toLowerCase())) {
+                // let's handle command
+                let newCommandScope = new CommandScope(arg, normalizedCommandsConfig);
+                if (newCommandScope.isComplete()) {
+                    parsedCommand = newCommandScope.getValue();
+                    commandScope = null;
+                } else {
+                    commandScope = newCommandScope;
+                }
+            } else if (parametersConfig[parsedParameters.length]) {
+                // let's handle configured parameter
+                let parameterConfig = parametersConfig[parsedParameters.length];
+                let parameterValue = castValue(arg, parameterConfig.type);
+                if (parameterConfig.type !== 'boolean' && typeof parameterConfig.choices !== 'undefined' && !parameterConfig.choices.includes(parameterValue) // during runtime `parameterValue` has correct type
+                ) {
+                    throw new ParsingError('INVALID_PARAMETER', {
+                        messageParameters: [
+                            parameterValue,
+                            parameterConfig.label ?? parsedParameters.length,
+                            parameterConfig.choices.map((choice)=>`"${choice}"`).join(', ')
+                        ]
+                    });
+                }
+                parsedParameters.push(parameterValue);
+                if (parameterConfig.validate) {
+                    parameterConfig.validate(parameterValue); // during runtime `parameterValue` has correct type
+                }
+            } else if (parserConfig.allowUnknownParameters) {
+                // let's handle other parameter
+                parsedParameters.push(arg);
+            } else {
+                throw new ParsingError('UNKNOWN_PARAMETER', {
+                    messageParameters: [
+                        arg
+                    ]
+                });
+            }
+        } catch (error) {
+            optionScope = null;
+            commandScope = null;
+            checker.addError(error);
+        }
+    }
+    try {
+        if (optionScope) {
+            commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
+        }
+        // if there is still unhandled `commandScope`, let's handle its args as parameters...
+        if (commandScope) {
+            let unhandledArgs = commandScope.getArgs();
+            for (let unhandledArg of unhandledArgs){
+                if (parserConfig.allowUnknownParameters) {
+                    // let's handle other parameter
+                    parsedParameters.push(unhandledArg);
+                } else {
+                    checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
+                        messageParameters: [
+                            unhandledArg
+                        ]
+                    }));
+                }
+            }
+        }
+        // if there are missing parsed parameters, add undefined
+        for (let [i] of parametersConfig.entries()){
+            if (typeof parsedParameters[i] === 'undefined') {
+                parsedParameters[i] = undefined;
+            }
+        }
+        // handle default option values...
+        for (let [optionName, optionConfig] of Object.entries(optionsConfig)){
+            if (typeof parsedOptions[optionName] === 'undefined' && typeof optionConfig.defaultValue !== 'undefined') {
+                parsedOptions[optionName] = optionConfig.defaultValue;
+            } else if (typeof parsedOptions[optionName] === 'undefined') {
+                parsedOptions[optionName] = undefined;
+            }
+        }
+        // handle default parameters values...
+        for (let [i, parameterConfig] of parametersConfig.entries()){
+            if (typeof parsedParameters[i] === 'undefined' && typeof parameterConfig.defaultValue !== 'undefined') {
+                parsedParameters[i] = parameterConfig.defaultValue;
+            }
+        }
+    } catch (error) {
+        checker.addError(error);
+    }
+    checker.checkParsedParameters(parametersConfig, parsedParameters);
+    checker.checkParsedOptions(optionsConfig, parsedOptions);
+    return {
+        command: normalizedCommandsConfig.length ? parsedCommand : null,
+        parameters: parametersConfig.length || parserConfig.allowUnknownParameters ? parsedParameters : null,
+        options: Object.keys(optionsConfig).length ? parsedOptions : null,
+        unknownOptions: parserConfig.allowUnknownOptions ? parsedUnknownOptions : null,
+        rest: restArgs,
+        errors: checker.errors
+    };
+}
+
+//# sourceMappingURL=parseArguments.js.map

package/dist/parseArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parseArguments.ts"],"sourcesContent":["import {\n  castValue,\n  Checker,\n  CommandScope,\n  commandToArguments,\n  createOptionShortNameMap,\n  expandArguments,\n  isFalseString,\n  isLongOption,\n  isOptionLike,\n  isShortOption,\n  isTrueString,\n  OptionScope,\n} from './internals.js';\nimport {ParsingError} from './ParsingError.js';\nimport {\n  type Arguments,\n  type ArgumentsCommand,\n  type ArgumentsOptions,\n  type ArgumentsParameters,\n  type ArgumentsUnknownOptions,\n  type Argv,\n  type NormalizedCommandsConfig,\n  type ParameterConfig,\n  type ParserConfig,\n} from './types.js';\n\n/* eslint-disable no-param-reassign -- we need to add properties to the `parsedOption` object */\nfunction commitOptionScope(optionScope: OptionScope, parsedOptions: Record<string, unknown>) {\n  let optionValue = optionScope.getValue();\n\n  parsedOptions[optionScope.name] = optionValue;\n\n  if (optionScope.config.validate) {\n    optionScope.config.validate(parsedOptions[optionScope.name] as never); // type assertion needed to make TypeScript happy\n  }\n}\n/* eslint-enable no-param-reassign */\n\n/**\n * Parse a list of command line arguments into an arguments object. Based on provided parser config, raw arguments can be parsed as commands, options and parameters.\n *\n * @param argv Raw arguments to be parsed.\n * @param parserConfig Parser configuration.\n * @return Parsed arguments.\n *\n */\n// TODO: refactor\n// eslint-disable-next-line complexity -- TODO\nexport function parseArguments<const O extends ParserConfig>(\n  argv: Argv,\n  parserConfig: O,\n): Arguments<O> {\n  // create separate configs for commands, parameters and options\n  let commandsConfig = parserConfig.commands ?? [];\n  let parametersConfig = parserConfig.parameters ?? [];\n  let optionsConfig = parserConfig.options ?? {};\n\n  // check if parser config is valid\n  let checker = new Checker();\n\n  checker.checkCommandsConfig(commandsConfig);\n  checker.checkParametersConfig(parametersConfig);\n  checker.checkOptionsConfig(optionsConfig);\n\n  // normalize some configs\n  let normalizedCommandsConfig: NormalizedCommandsConfig = commandsConfig.map((command) => ({\n    command: command.toLowerCase(),\n    args: commandToArguments(command.toLowerCase()),\n  }));\n  let commandFirstArguments = normalizedCommandsConfig.map(\n    (commandConfig) => commandConfig.args[0],\n  );\n  let optionShortNameMap = parserConfig.options\n    ? createOptionShortNameMap(parserConfig.options)\n    : {};\n\n  // variables for keeping track of the parsing\n  let parsedCommand: string | undefined;\n  let parsedParameters: unknown[] = [];\n  let parsedOptions: Record<string, unknown> = {};\n  let parsedUnknownOptions: Record<string, unknown> = {};\n  let restArgs: string[] = [];\n  let optionScope: OptionScope | null = null;\n  let commandScope: CommandScope | null = null;\n\n  //\n  let args = expandArguments(argv);\n\n  for (let [i, arg] of args.entries()) {\n    // extract rest arguments\n    if (arg === '--') {\n      restArgs.push(...args.slice(i + 1));\n\n      break;\n    }\n\n    try {\n      if (isOptionLike(arg)) {\n        // first let's handle options\n\n        if (optionScope) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n        }\n\n        // if there is still unhandled `commandScope`, let's handle its args as parameters...\n        if (commandScope) {\n          let unhandledArgs = commandScope.getArgs();\n\n          for (let unhandledArg of unhandledArgs) {\n            if (parserConfig.allowUnknownParameters) {\n              // let's handle other parameter\n              parsedParameters.push(unhandledArg);\n            } else {\n              checker.addError(\n                new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n              );\n            }\n          }\n        }\n\n        optionScope = null;\n        commandScope = null;\n\n        let optionName = arg;\n        let optionValue;\n\n        // Extract option name and value\n        if (optionName.includes('=')) {\n          let result = optionName.split('=', 2);\n\n          if (result[0] && result[1]) {\n            [optionName, optionValue] = result;\n          }\n        }\n\n        if (isShortOption(optionName)) {\n          let fullOptionName = optionShortNameMap[optionName.slice(1)];\n\n          if (typeof fullOptionName === 'string') {\n            optionName = fullOptionName;\n          }\n        } else if (isLongOption(optionName)) {\n          optionName = optionName.slice(2);\n        }\n\n        let newOptionScope = new OptionScope(\n          optionName,\n          optionsConfig,\n          parserConfig.allowUnknownOptions,\n        );\n\n        if (typeof parsedOptions[newOptionScope.name] !== 'undefined') {\n          if (newOptionScope.config.multiple) {\n            newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];\n          } else if (newOptionScope.config.type === 'number' && newOptionScope.config.count) {\n            newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];\n          }\n        }\n\n        if (typeof optionValue !== 'undefined') {\n          newOptionScope.captureArg(optionValue);\n        }\n\n        if (newOptionScope.isComplete()) {\n          commitOptionScope(\n            newOptionScope,\n            optionsConfig[newOptionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        } else {\n          optionScope = newOptionScope;\n        }\n      } else if (\n        optionScope &&\n        !(optionScope.config.type === 'boolean' && !optionScope.config.multiple)\n      ) {\n        // let's handle adding more values to previous option, but not if it's signle boolean option\n\n        optionScope.captureArg(arg);\n\n        if (optionScope.isComplete()) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        }\n      } else if (\n        optionScope &&\n        optionScope.config.type === 'boolean' &&\n        !optionScope.config.multiple &&\n        (isFalseString(arg) || isTrueString(arg))\n      ) {\n        // we're adding value to a single boolean option only if the value is \"false\" or \"true\" string\n        optionScope.captureArg(arg);\n\n        if (optionScope.isComplete()) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        }\n      } else if (commandScope) {\n        // let's handle rest of the command\n\n        commandScope.captureArg(arg);\n\n        if (commandScope.isComplete()) {\n          parsedCommand = commandScope.getValue();\n          commandScope = null;\n        } else if (commandScope.isDone()) {\n          let unhandledArgs = commandScope.getArgs();\n\n          for (let unhandledArg of unhandledArgs) {\n            if (parserConfig.allowUnknownParameters) {\n              // let's handle other parameter\n              parsedParameters.push(unhandledArg);\n            } else {\n              checker.addError(\n                new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n              );\n            }\n          }\n\n          commandScope = null;\n        }\n      } else if (\n        typeof parsedCommand === 'undefined' &&\n        commandFirstArguments.includes(arg.toLowerCase())\n      ) {\n        // let's handle command\n\n        let newCommandScope = new CommandScope(arg, normalizedCommandsConfig);\n\n        if (newCommandScope.isComplete()) {\n          parsedCommand = newCommandScope.getValue();\n          commandScope = null;\n        } else {\n          commandScope = newCommandScope;\n        }\n      } else if (parametersConfig[parsedParameters.length]) {\n        // let's handle configured parameter\n        let parameterConfig = parametersConfig[parsedParameters.length] as ParameterConfig;\n        let parameterValue = castValue(arg, parameterConfig.type);\n\n        if (\n          parameterConfig.type !== 'boolean' &&\n          typeof parameterConfig.choices !== 'undefined' &&\n          !parameterConfig.choices.includes(parameterValue as never) // during runtime `parameterValue` has correct type\n        ) {\n          throw new ParsingError('INVALID_PARAMETER', {\n            messageParameters: [\n              parameterValue,\n              parameterConfig.label ?? parsedParameters.length,\n              parameterConfig.choices.map((choice) => `\"${choice}\"`).join(', '),\n            ],\n          });\n        }\n\n        parsedParameters.push(parameterValue);\n\n        if (parameterConfig.validate) {\n          parameterConfig.validate(parameterValue as never); // during runtime `parameterValue` has correct type\n        }\n      } else if (parserConfig.allowUnknownParameters) {\n        // let's handle other parameter\n        parsedParameters.push(arg);\n      } else {\n        throw new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [arg]});\n      }\n    } catch (error: unknown) {\n      optionScope = null;\n      commandScope = null;\n\n      checker.addError(error as Error);\n    }\n  }\n\n  try {\n    if (optionScope) {\n      commitOptionScope(\n        optionScope,\n        optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n      );\n    }\n\n    // if there is still unhandled `commandScope`, let's handle its args as parameters...\n    if (commandScope) {\n      let unhandledArgs = commandScope.getArgs();\n\n      for (let unhandledArg of unhandledArgs) {\n        if (parserConfig.allowUnknownParameters) {\n          // let's handle other parameter\n          parsedParameters.push(unhandledArg);\n        } else {\n          checker.addError(\n            new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n          );\n        }\n      }\n    }\n\n    // if there are missing parsed parameters, add undefined\n    for (let [i] of parametersConfig.entries()) {\n      if (typeof parsedParameters[i] === 'undefined') {\n        parsedParameters[i] = undefined;\n      }\n    }\n\n    // handle default option values...\n    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {\n      if (\n        typeof parsedOptions[optionName] === 'undefined' &&\n        typeof optionConfig.defaultValue !== 'undefined'\n      ) {\n        parsedOptions[optionName] = optionConfig.defaultValue;\n      } else if (typeof parsedOptions[optionName] === 'undefined') {\n        parsedOptions[optionName] = undefined;\n      }\n    }\n\n    // handle default parameters values...\n    for (let [i, parameterConfig] of parametersConfig.entries()) {\n      if (\n        typeof parsedParameters[i] === 'undefined' &&\n        typeof parameterConfig.defaultValue !== 'undefined'\n      ) {\n        parsedParameters[i] = parameterConfig.defaultValue;\n      }\n    }\n  } catch (error: unknown) {\n    checker.addError(error as Error);\n  }\n\n  checker.checkParsedParameters(parametersConfig, parsedParameters);\n  checker.checkParsedOptions(optionsConfig, parsedOptions);\n\n  return {\n    command: (normalizedCommandsConfig.length ? parsedCommand : null) as ArgumentsCommand<O>,\n    parameters: (parametersConfig.length || parserConfig.allowUnknownParameters\n      ? parsedParameters\n      : null) as ArgumentsParameters<O>,\n    options: (Object.keys(optionsConfig).length ? parsedOptions : null) as ArgumentsOptions<O>,\n    unknownOptions: (parserConfig.allowUnknownOptions\n      ? parsedUnknownOptions\n      : null) as ArgumentsUnknownOptions<O>,\n    rest: restArgs,\n    errors: checker.errors,\n  };\n}\n"],"names":["castValue","Checker","CommandScope","commandToArguments","createOptionShortNameMap","expandArguments","isFalseString","isLongOption","isOptionLike","isShortOption","isTrueString","OptionScope","ParsingError","commitOptionScope","optionScope","parsedOptions","optionValue","getValue","name","config","validate","parseArguments","argv","parserConfig","commandsConfig","commands","parametersConfig","parameters","optionsConfig","options","checker","checkCommandsConfig","checkParametersConfig","checkOptionsConfig","normalizedCommandsConfig","map","command","toLowerCase","args","commandFirstArguments","commandConfig","optionShortNameMap","parsedCommand","parsedParameters","parsedUnknownOptions","restArgs","commandScope","i","arg","entries","push","slice","unhandledArgs","getArgs","unhandledArg","allowUnknownParameters","addError","messageParameters","optionName","includes","result","split","fullOptionName","newOptionScope","allowUnknownOptions","multiple","previousParsedValue","type","count","captureArg","isComplete","isDone","newCommandScope","length","parameterConfig","parameterValue","choices","label","choice","join","error","undefined","optionConfig","Object","defaultValue","checkParsedParameters","checkParsedOptions","keys","unknownOptions","rest","errors"],"mappings":"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"}

package/dist/types/Arguments.d.ts

@@ -0,0 +1,22 @@
+import { type ArgumentsCommand } from './ArgumentsCommand.js';
+import { type ArgumentsOptions } from './ArgumentsOptions.js';
+import { type ArgumentsParameters } from './ArgumentsParameters.js';
+import { type ArgumentsUnknownOptions } from './ArgumentsUnknownOptions.js';
+import { type ParserConfig } from './ParserConfig.js';
+/**
+ * Parsed arguments.
+ */
+export type Arguments<T extends ParserConfig> = {
+    /** Parsed command. */
+    readonly command: ArgumentsCommand<T>;
+    /** Parsed parameters. */
+    readonly parameters: ArgumentsParameters<T>;
+    /** Parsed options. */
+    readonly options: ArgumentsOptions<T>;
+    /** Unconfigured options. */
+    readonly unknownOptions: ArgumentsUnknownOptions<T>;
+    /** Arguments that appear after "--". */
+    readonly rest: string[];
+    /** Parsing and validation rrors */
+    readonly errors: Error[];
+};

package/dist/types/Arguments.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=Arguments.js.map

package/dist/types/Arguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Arguments.ts"],"sourcesContent":["import {type ArgumentsCommand} from './ArgumentsCommand.js';\nimport {type ArgumentsOptions} from './ArgumentsOptions.js';\nimport {type ArgumentsParameters} from './ArgumentsParameters.js';\nimport {type ArgumentsUnknownOptions} from './ArgumentsUnknownOptions.js';\nimport {type ParserConfig} from './ParserConfig.js';\n\n/**\n * Parsed arguments.\n */\nexport type Arguments<T extends ParserConfig> = {\n  /** Parsed command. */\n  readonly command: ArgumentsCommand<T>;\n\n  /** Parsed parameters. */\n  readonly parameters: ArgumentsParameters<T>;\n\n  /** Parsed options. */\n  readonly options: ArgumentsOptions<T>;\n\n  /** Unconfigured options. */\n  readonly unknownOptions: ArgumentsUnknownOptions<T>;\n\n  /** Arguments that appear after \"--\". */\n  readonly rest: string[];\n\n  /** Parsing and validation rrors */\n  readonly errors: Error[];\n};\n"],"names":[],"mappings":"AAAA,WA2BE"}

package/dist/types/ArgumentsCommand.d.ts

@@ -0,0 +1,3 @@
+import { type ParserConfig } from './ParserConfig.js';
+/** Parsed command. */
+export type ArgumentsCommand<O extends ParserConfig> = Omit<O, 'commands'> extends O ? null : O['commands'] extends undefined ? null : Lowercase<NonNullable<O['commands']>[number]> | undefined;

package/dist/types/ArgumentsCommand.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=ArgumentsCommand.js.map

package/dist/types/ArgumentsCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/ArgumentsCommand.ts"],"sourcesContent":["import {type ParserConfig} from './ParserConfig.js';\n\n/** Parsed command. */\nexport type ArgumentsCommand<O extends ParserConfig> = Omit<O, 'commands'> extends O\n  ? null\n  : O['commands'] extends undefined\n  ? null\n  : Lowercase<NonNullable<O['commands']>[number]> | undefined;\n"],"names":[],"mappings":"AAAA,WAO8D"}

package/dist/types/ArgumentsOptions.d.ts

@@ -0,0 +1,14 @@
+import { type TupleToUnion } from '@jakubmazanec/ts-utils';
+import { type CountOptionConfig, type BooleansOptionConfig, type NumbersOptionConfig, type StringsOptionConfig, type OptionConfig, type BooleanOptionConfig, type NumberOptionConfig, type StringOptionConfig } from './OptionConfig.js';
+import { type OptionsConfig } from './OptionsConfig.js';
+import { type ParserConfig } from './ParserConfig.js';
+type BooleanOptionConfigToArgumentsOption<O extends BooleanOptionConfig | BooleansOptionConfig> = O extends BooleanOptionConfig ? O['defaultValue'] extends boolean ? boolean : boolean | undefined : O extends BooleansOptionConfig ? O['defaultValue'] extends readonly boolean[] ? boolean[] : boolean[] | undefined : never;
+type NumberOptionConfigToArgumentsOption<O extends CountOptionConfig | NumberOptionConfig | NumbersOptionConfig> = O extends NumbersOptionConfig ? O['choices'] extends readonly number[] ? O['defaultValue'] extends readonly number[] ? Array<TupleToUnion<O['choices']>> : Array<TupleToUnion<O['choices']>> | undefined : O['defaultValue'] extends readonly number[] ? number[] : number[] | undefined : O extends NumberOptionConfig ? O['choices'] extends readonly number[] ? O['defaultValue'] extends number ? TupleToUnion<O['choices']> : TupleToUnion<O['choices']> | undefined : O['defaultValue'] extends number ? number : number | undefined : O extends CountOptionConfig ? O['defaultValue'] extends number ? number : number | undefined : never;
+type StringOptionConfigToArgumentsOption<O extends StringOptionConfig | StringsOptionConfig> = O extends StringsOptionConfig ? O['choices'] extends readonly string[] ? O['defaultValue'] extends readonly string[] ? Array<TupleToUnion<O['choices']>> : Array<TupleToUnion<O['choices']>> | undefined : O['defaultValue'] extends readonly string[] ? string[] : string[] | undefined : O extends StringOptionConfig ? O['choices'] extends readonly string[] ? O['defaultValue'] extends string ? TupleToUnion<O['choices']> : TupleToUnion<O['choices']> | undefined : O['defaultValue'] extends string ? string : string | undefined : never;
+type OptionConfigToArgumentOption<O extends OptionConfig> = O extends BooleanOptionConfig | BooleansOptionConfig ? BooleanOptionConfigToArgumentsOption<O> : O extends CountOptionConfig | NumberOptionConfig | NumbersOptionConfig ? NumberOptionConfigToArgumentsOption<O> : O extends StringOptionConfig | StringsOptionConfig ? StringOptionConfigToArgumentsOption<O> : never;
+type OptionsConfigToArgumentsOptions<O extends OptionsConfig> = {
+    [K in keyof O]: OptionConfigToArgumentOption<O[K]>;
+};
+/** Parsed options. */
+export type ArgumentsOptions<O extends ParserConfig> = Omit<O, 'options'> extends O ? null : O['options'] extends undefined ? null : OptionsConfigToArgumentsOptions<NonNullable<O['options']>>;
+export {};

package/dist/types/ArgumentsOptions.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=ArgumentsOptions.js.map