args-tokens 0.22.6 → 0.23.1

package/lib/resolver.js

@@ -1,5 +1,288 @@
-import "./parser-M-ayhS1h.js";
-import "./utils-1LQrGCWG.js";
-import { ArgResolveError, resolveArgs } from "./resolver-DBvNkaE7.js";
+import { hasLongOptionPrefix, isShortOption } from "./parser.js";
+import { t as kebabnize } from "./utils-CxvkckUD.js";
 
+//#region src/resolver.ts
+/**
+* Entry point of argument options resolver.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const SKIP_POSITIONAL_DEFAULT = -1;
+/**
+* Resolve command line arguments.
+*
+* @typeParam A - {@link Args | Arguments}, which is an object that defines the command line arguments.
+*
+* @param args - An arguments that contains {@link ArgSchema | arguments schema}.
+* @param tokens - An array of {@link ArgToken | tokens}.
+* @param resolveArgs - An arguments that contains {@link ResolveArgs | resolve arguments}.
+* @returns An object that contains the values of the arguments, positional arguments, rest arguments, {@link AggregateError | validation errors}, and explicit provision status.
+*
+* @example
+* ```typescript
+* // passed tokens: --port 3000
+*
+* const { values, explicit } = resolveArgs({
+*   port: {
+*     type: 'number',
+*     default: 8080
+*   },
+*   host: {
+*     type: 'string',
+*     default: 'localhost'
+*   }
+* }, parsedTokens)
+*
+* values.port // 3000
+* values.host // 'localhost'
+*
+* explicit.port // true (explicitly provided)
+* explicit.host // false (not provided, fallback to default)
+* ```
+*/
+function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKIP_POSITIONAL_DEFAULT, toKebab = false } = {}) {
+	const skipPositionalIndex = typeof skipPositional === "number" ? Math.max(skipPositional, SKIP_POSITIONAL_DEFAULT) : SKIP_POSITIONAL_DEFAULT;
+	const rest = [];
+	const optionTokens = [];
+	const positionalTokens = [];
+	let currentLongOption;
+	let currentShortOption;
+	const expandableShortOptions = [];
+	function toShortValue() {
+		if (expandableShortOptions.length === 0) return;
+		else {
+			const value = expandableShortOptions.map((token) => token.name).join("");
+			expandableShortOptions.length = 0;
+			return value;
+		}
+	}
+	function applyLongOptionValue(value = void 0) {
+		if (currentLongOption) {
+			currentLongOption.value = value;
+			optionTokens.push({ ...currentLongOption });
+			currentLongOption = void 0;
+		}
+	}
+	function applyShortOptionValue(value = void 0) {
+		if (currentShortOption) {
+			currentShortOption.value = value || toShortValue();
+			optionTokens.push({ ...currentShortOption });
+			currentShortOption = void 0;
+		}
+	}
+	/**
+	* analyze phase to resolve value
+	* separate tokens into positionals, long and short options, after that resolve values
+	*/
+	const schemas = Object.values(args);
+	let terminated = false;
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.kind === "positional") {
+			if (terminated && token.value) {
+				rest.push(token.value);
+				continue;
+			}
+			if (currentShortOption) {
+				if (schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean")) positionalTokens.push({ ...token });
+			} else if (currentLongOption) {
+				if (args[currentLongOption.name]?.type === "boolean") positionalTokens.push({ ...token });
+			} else positionalTokens.push({ ...token });
+			applyLongOptionValue(token.value);
+			applyShortOptionValue(token.value);
+		} else if (token.kind === "option") if (token.rawName) {
+			if (hasLongOptionPrefix(token.rawName)) {
+				applyLongOptionValue();
+				if (token.inlineValue) optionTokens.push({ ...token });
+				else currentLongOption = { ...token };
+				applyShortOptionValue();
+			} else if (isShortOption(token.rawName)) if (currentShortOption) {
+				if (currentShortOption.index === token.index) if (shortGrouping) {
+					currentShortOption.value = token.value;
+					optionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				} else expandableShortOptions.push({ ...token });
+				else {
+					currentShortOption.value = toShortValue();
+					optionTokens.push({ ...currentShortOption });
+					currentShortOption = { ...token };
+				}
+				applyLongOptionValue();
+			} else {
+				currentShortOption = { ...token };
+				applyLongOptionValue();
+			}
+		} else {
+			if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
+				currentShortOption.value = token.value;
+				optionTokens.push({ ...currentShortOption });
+				currentShortOption = void 0;
+			}
+			applyLongOptionValue();
+		}
+		else {
+			if (token.kind === "option-terminator") terminated = true;
+			applyLongOptionValue();
+			applyShortOptionValue();
+		}
+	}
+	/**
+	* check if the last long or short option is not resolved
+	*/
+	applyLongOptionValue();
+	applyShortOptionValue();
+	/**
+	* resolve values
+	*/
+	const values = Object.create(null);
+	const errors = [];
+	const explicit = Object.create(null);
+	const actualInputNames = /* @__PURE__ */ new Map();
+	function checkTokenName(option, schema, token) {
+		return token.name === (schema.type === "boolean" ? schema.negatable && token.name?.startsWith("no-") ? `no-${option}` : option : option);
+	}
+	const positionalItemCount = tokens.filter((token) => token.kind === "positional").length;
+	function getPositionalSkipIndex() {
+		return Math.min(skipPositionalIndex, positionalItemCount);
+	}
+	let positionalsCount = 0;
+	for (const [rawArg, schema] of Object.entries(args)) {
+		const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+		explicit[rawArg] = false;
+		if (schema.type === "positional") {
+			if (skipPositionalIndex > SKIP_POSITIONAL_DEFAULT) while (positionalsCount <= getPositionalSkipIndex()) positionalsCount++;
+			if (schema.multiple) {
+				const remainingPositionals = positionalTokens.slice(positionalsCount);
+				if (remainingPositionals.length > 0) {
+					values[rawArg] = remainingPositionals.map((p) => p.value);
+					positionalsCount += remainingPositionals.length;
+					explicit[rawArg] = true;
+				} else if (schema.required) errors.push(createRequireError(arg, schema));
+			} else {
+				const positional = positionalTokens[positionalsCount];
+				if (positional != null) {
+					values[rawArg] = positional.value;
+					explicit[rawArg] = true;
+				} else errors.push(createRequireError(arg, schema));
+				positionalsCount++;
+			}
+			continue;
+		}
+		if (schema.required) {
+			if (!optionTokens.find((token) => {
+				return schema.short && token.name === schema.short || token.rawName && hasLongOptionPrefix(token.rawName) && token.name === arg;
+			})) {
+				errors.push(createRequireError(arg, schema));
+				continue;
+			}
+		}
+		for (let i = 0; i < optionTokens.length; i++) {
+			const token = optionTokens[i];
+			if (checkTokenName(arg, schema, token) && token.rawName != void 0 && hasLongOptionPrefix(token.rawName) || schema.short === token.name && token.rawName != void 0 && isShortOption(token.rawName)) {
+				const invalid = validateRequire(token, arg, schema);
+				if (invalid) {
+					errors.push(invalid);
+					continue;
+				}
+				explicit[rawArg] = true;
+				const actualInputName = isShortOption(token.rawName) ? `-${token.name}` : `--${arg}`;
+				actualInputNames.set(rawArg, actualInputName);
+				if (schema.type === "boolean") token.value = void 0;
+				const [parsedValue, error] = parse(token, arg, schema);
+				if (error) errors.push(error);
+				else if (schema.multiple) {
+					values[rawArg] ||= [];
+					values[rawArg].push(parsedValue);
+				} else values[rawArg] = parsedValue;
+			}
+		}
+		if (values[rawArg] == null && schema.default != null) values[rawArg] = schema.default;
+	}
+	const conflictErrors = checkConflicts(args, explicit, toKebab, actualInputNames);
+	errors.push(...conflictErrors);
+	return {
+		values,
+		positionals: positionalTokens.map((token) => token.value),
+		rest,
+		error: errors.length > 0 ? new AggregateError(errors) : void 0,
+		explicit
+	};
+}
+function parse(token, option, schema) {
+	switch (schema.type) {
+		case "string": return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(option, schema)];
+		case "boolean": return token.value ? [token.value || schema.default, void 0] : [!(schema.negatable && token.name.startsWith("no-")), void 0];
+		case "number":
+			if (!isNumeric(token.value)) return [void 0, createTypeError(option, schema)];
+			return token.value ? [+token.value, void 0] : [+(schema.default || ""), void 0];
+		case "enum":
+			if (schema.choices && !schema.choices.includes(token.value)) return [void 0, new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be chosen from '${schema.type}' [${schema.choices.map((c) => JSON.stringify(c)).join(", ")}] values`, option, "type", schema)];
+			return [token.value || schema.default, void 0];
+		case "custom":
+			if (typeof schema.parse !== "function") throw new TypeError(`argument '${option}' should have a 'parse' function`);
+			try {
+				return [schema.parse(token.value || String(schema.default || "")), void 0];
+			} catch (error) {
+				return [void 0, error];
+			}
+		default: throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
+	}
+}
+function createRequireError(option, schema) {
+	return new ArgResolveError(schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`, option, "required", schema);
+}
+/**
+* An error that occurs when resolving arguments.
+* This error is thrown when the argument is not valid.
+*/
+var ArgResolveError = class extends Error {
+	name;
+	schema;
+	type;
+	/**
+	* Create an `ArgResolveError` instance.
+	*
+	* @param message - the error message
+	* @param name - the name of the argument
+	* @param type - the type of the error, either 'type' or 'required'
+	* @param schema - the argument schema that caused the error
+	*/
+	constructor(message, name, type, schema) {
+		super(message);
+		this.name = name;
+		this.type = type;
+		this.schema = schema;
+	}
+};
+function validateRequire(token, option, schema) {
+	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(option, schema);
+}
+function isNumeric(str) {
+	return str.trim() !== "" && !isNaN(str);
+}
+function createTypeError(option, schema) {
+	return new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`, option, "type", schema);
+}
+function checkConflicts(args, explicit, toKebab, actualInputNames) {
+	for (const rawArg in args) {
+		const schema = args[rawArg];
+		if (!explicit[rawArg]) continue;
+		if (!schema.conflicts) continue;
+		const conflicts = Array.isArray(schema.conflicts) ? schema.conflicts : [schema.conflicts];
+		for (let i = 0; i < conflicts.length; i++) {
+			const conflictingArg = conflicts[i];
+			if (!explicit[conflictingArg]) continue;
+			const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+			const conflictingArgKebab = toKebab || args[conflictingArg]?.toKebab ? kebabnize(conflictingArg) : conflictingArg;
+			return [new ArgResolveError(`Optional argument '${actualInputNames.get(rawArg) || `--${arg}`}' conflicts with '${actualInputNames.get(conflictingArg) || `--${conflictingArgKebab}`}'`, rawArg, "conflict", schema)];
+		}
+	}
+	return [];
+}
+
+//#endregion
 export { ArgResolveError, resolveArgs };

package/lib/{utils-1LQrGCWG.js → utils-CxvkckUD.js}

@@ -21,4 +21,4 @@ function kebabnize(str) {
 }
 
 //#endregion
-export { kebabnize };
+export { kebabnize as t };

package/lib/utils.js

@@ -1,3 +1,3 @@
-import { kebabnize } from "./utils-1LQrGCWG.js";
+import { t as kebabnize } from "./utils-CxvkckUD.js";
 
 export { kebabnize };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.22.6",
+  "version": "0.23.1",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -71,35 +71,36 @@
     }
   },
   "devDependencies": {
-    "@eslint/markdown": "^6.6.0",
-    "@kazupon/eslint-config": "^0.33.3",
-    "@kazupon/prettier-config": "^0.1.1",
-    "@types/node": "^22.17.0",
-    "@typescript/native-preview": "7.0.0-dev.20250802.1",
-    "@vitest/eslint-plugin": "^1.3.4",
-    "bumpp": "^10.2.2",
-    "deno": "^2.4.3",
-    "eslint": "^9.32.0",
+    "@eslint/markdown": "^7.5.1",
+    "@kazupon/eslint-config": "^0.44.0",
+    "@kazupon/prettier-config": "^0.2.0",
+    "@types/node": "^24.10.9",
+    "@typescript/native-preview": "7.0.0-dev.20260131.1",
+    "@vitest/eslint-plugin": "^1.6.6",
+    "bumpp": "^10.4.0",
+    "deno": "^2.6.7",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-jsdoc": "^52.0.2",
-    "eslint-plugin-jsonc": "^2.20.1",
+    "eslint-plugin-jsdoc": "^52.0.4",
+    "eslint-plugin-jsonc": "^2.21.0",
+    "eslint-plugin-markdown-preferences": "^0.10.0",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-regexp": "^2.9.0",
+    "eslint-plugin-regexp": "^2.10.0",
     "eslint-plugin-unicorn": "^60.0.0",
-    "eslint-plugin-yml": "^1.18.0",
+    "eslint-plugin-yml": "^1.19.1",
     "gh-changelogen": "^0.2.8",
-    "jsr": "^0.13.5",
-    "jsr-exports-lint": "^0.4.1",
-    "knip": "^5.62.0",
-    "lint-staged": "^16.1.2",
+    "jsr": "^0.14.2",
+    "jsr-exports-lint": "^0.4.2",
+    "knip": "^5.82.1",
+    "lint-staged": "^16.2.7",
     "mitata": "^1.0.34",
-    "pkg-pr-new": "^0.0.54",
-    "prettier": "^3.6.2",
-    "tsdown": "^0.13.1",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.38.0",
-    "vitest": "^3.2.4",
-    "zod": "^4.0.14"
+    "pkg-pr-new": "^0.0.62",
+    "prettier": "^3.8.1",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^4.0.18",
+    "zod": "^4.3.6"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {

package/lib/parser-DEYiqyo1.d.ts

@@ -1,98 +0,0 @@
-//#region src/parser.d.ts
-/**
- * Entry point of argument parser.
- *
- * @module
- */
-/**
- * forked from `nodejs/node` (`pkgjs/parseargs`)
- * repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
- * code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
- *
- * @author kazuya kawaguchi (a.k.a. kazupon)
- * @license MIT
- */
-/**
- * Argument token Kind.
- *
- * - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
- * - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
- * - `positional`: positional token
- */
-type ArgTokenKind = 'option' | 'option-terminator' | 'positional';
-/**
- * Argument token.
- */
-interface ArgToken {
-  /**
-   * Argument token kind.
-   */
-  kind: ArgTokenKind;
-  /**
-   * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
-   */
-  index: number;
-  /**
-   * Option name, e.g. `--foo` => `foo`, `-x` => `x`.
-   */
-  name?: string;
-  /**
-   * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
-   */
-  rawName?: string;
-  /**
-   * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
-   * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
-   */
-  value?: string;
-  /**
-   * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
-   */
-  inlineValue?: boolean;
-}
-/**
- * Parser Options.
- */
-interface ParserOptions {
-  /**
-   * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode.
-   *
-   * @default false
-   */
-  allowCompatible?: boolean;
-}
-/**
- * Parse command line arguments.
- *
- * @param args - command line arguments
- * @param options - parse options, about details see {@link ParserOptions}
- * @returns Argument tokens.
- *
- * @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)
- * ```
- */
-declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
-/**
- * Check if `arg` is a short option (e.g. `-f`).
- *
- * @param arg - An argument to check
- * @returns Whether `arg` is a short option.
- */
-declare function isShortOption(arg: string): boolean;
-/**
- * Check if `arg` is a long option prefix (e.g. `--`).
- *
- * @param arg - An argument to check
- * @returns Whether `arg` is a long option prefix.
- */
-declare function hasLongOptionPrefix(arg: string): boolean;
-//#endregion
-export { ArgToken, ParserOptions, hasLongOptionPrefix as hasLongOptionPrefix$1, isShortOption as isShortOption$1, parseArgs as parseArgs$1 };

package/lib/parser-M-ayhS1h.js

@@ -1,199 +0,0 @@
-//#region src/parser.ts
-const HYPHEN_CHAR = "-";
-const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
-const EQUAL_CHAR = "=";
-const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
-const TERMINATOR = "--";
-const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
-const LONG_OPTION_PREFIX = "--";
-/**
-* Parse command line arguments.
-*
-* @param args - command line arguments
-* @param options - parse options, about details see {@link ParserOptions}
-* @returns Argument tokens.
-*
-* @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)
-* ```
-*/
-function parseArgs(args, options = {}) {
-	const { allowCompatible = false } = options;
-	const tokens = [];
-	const remainings = [...args];
-	let index = -1;
-	let groupCount = 0;
-	let hasShortValueSeparator = false;
-	while (remainings.length > 0) {
-		const arg = remainings.shift();
-		if (arg == void 0) break;
-		const nextArg = remainings[0];
-		if (groupCount > 0) groupCount--;
-		else index++;
-		if (arg === TERMINATOR) {
-			tokens.push({
-				kind: "option-terminator",
-				index
-			});
-			const mapped = remainings.map((arg$1) => {
-				return {
-					kind: "positional",
-					index: ++index,
-					value: arg$1
-				};
-			});
-			tokens.push(...mapped);
-			break;
-		}
-		if (isShortOption(arg)) {
-			const shortOption = arg.charAt(1);
-			let value;
-			let inlineValue;
-			if (groupCount) {
-				tokens.push({
-					kind: "option",
-					name: shortOption,
-					rawName: arg,
-					index,
-					value,
-					inlineValue
-				});
-				if (groupCount === 1 && hasOptionValue(nextArg)) {
-					value = remainings.shift();
-					if (hasShortValueSeparator) {
-						inlineValue = true;
-						hasShortValueSeparator = false;
-					}
-					tokens.push({
-						kind: "option",
-						index,
-						value,
-						inlineValue
-					});
-				}
-			} else tokens.push({
-				kind: "option",
-				name: shortOption,
-				rawName: arg,
-				index,
-				value,
-				inlineValue
-			});
-			if (value != null) ++index;
-			continue;
-		}
-		if (isShortOptionGroup(arg)) {
-			const expanded = [];
-			let shortValue = "";
-			for (let i = 1; i < arg.length; i++) {
-				const shortableOption = arg.charAt(i);
-				if (hasShortValueSeparator) shortValue += shortableOption;
-				else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) hasShortValueSeparator = true;
-				else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
-			}
-			if (shortValue) expanded.push(shortValue);
-			remainings.unshift(...expanded);
-			groupCount = expanded.length;
-			continue;
-		}
-		if (isLongOption(arg)) {
-			const longOption = arg.slice(2);
-			tokens.push({
-				kind: "option",
-				name: longOption,
-				rawName: arg,
-				index,
-				value: void 0,
-				inlineValue: void 0
-			});
-			continue;
-		}
-		if (isLongOptionAndValue(arg)) {
-			const equalIndex = arg.indexOf(EQUAL_CHAR);
-			const longOption = arg.slice(2, equalIndex);
-			const value = arg.slice(equalIndex + 1);
-			tokens.push({
-				kind: "option",
-				name: longOption,
-				rawName: `${LONG_OPTION_PREFIX}${longOption}`,
-				index,
-				value,
-				inlineValue: true
-			});
-			continue;
-		}
-		tokens.push({
-			kind: "positional",
-			index,
-			value: arg
-		});
-	}
-	return tokens;
-}
-/**
-* Check if `arg` is a short option (e.g. `-f`).
-*
-* @param arg - An 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 - An 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 - An 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 - An 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 - An argument to check
-* @returns Whether `arg` is a long option prefix.
-*/
-function hasLongOptionPrefix(arg) {
-	return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
-}
-/**
-* Check if a `value` is an option value.
-*
-* @param value - A value to check
-* @returns Whether a `value` is an option value.
-*/
-function hasOptionValue(value) {
-	return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
-}
-
-//#endregion
-export { hasLongOptionPrefix, isShortOption, parseArgs };