@jakubmazanec/args 2.0.16-next.fac374fa → 2.0.16-unstable.2468857d

package/build/ParsingError.js

@@ -1,9 +1,15 @@
-"use strict";
 import { createCustomError } from "@jakubmazanec/error";
-export const ParsingError = createCustomError("ParsingError", {
-  INVALID_PARAMETER: 'Invalid parameter value "{0}" found. Allowed values for parameter "{1}" are: {2}.',
-  UNKNOWN_PARAMETER: 'Unknown parameter "{0}" found. Unknown parameters are not allowed.',
-  INVALID_OPTION: 'Invalid option value "{0}" found. Allowed values for option "{1}" are: {2}.',
-  UNKNOWN_OPTION: 'Unknown option "{0}" found. Unknown options are not allowed.'
+
+//#region source/ParsingError.ts
+/**
+* A subclass of `Error` that indicates a parsing failure.
+*/
+const ParsingError = createCustomError("ParsingError", {
+	INVALID_PARAMETER: "Invalid parameter value \"{0}\" found. Allowed values for parameter \"{1}\" are: {2}.",
+	UNKNOWN_PARAMETER: "Unknown parameter \"{0}\" found. Unknown parameters are not allowed.",
+	INVALID_OPTION: "Invalid option value \"{0}\" found. Allowed values for option \"{1}\" are: {2}.",
+	UNKNOWN_OPTION: "Unknown option \"{0}\" found. Unknown options are not allowed."
 });
-//# sourceMappingURL=ParsingError.js.map
+
+//#endregion
+export { ParsingError };

package/build/ValidationError.js

@@ -1,14 +1,20 @@
-"use strict";
 import { createCustomError } from "@jakubmazanec/error";
-export const ValidationError = createCustomError("ValidationError", {
-  INVALID_COMMAND: 'Command "{0}" has invalid format. Only words consisting of letters, numbers or dashes separated by single space are allowed.',
-  MISSING_PARAMETER: 'Parameter "{0}" is required but its value is undefined.',
-  INVALID_PARAMETER_DEFAULT_AND_CHOICES: 'Parameter "{0}" has invalid default value "{1}". Default value must be one of the `choices` elements.',
-  INVALID_PARAMETER_ORDER: 'Parameter "{0}" has invalid order. All parameters before must have a default value or be required too',
-  MISSING_OPTION: 'Option "{0}" is required but its value is undefined.',
-  INVALID_OPTION_DEFAULT_AND_CHOICES: 'Option "{0}" has invalid default value "{1}". Default value must be one of the `choices` elements.',
-  INVALID_OPTION_NAME: 'Option "{0}" has invalid name. Only names consisting of letters, numbers or dashes are allowed.',
-  REPEATED_OPTION_NAME: 'Option "{0}" has invalid short name "{1}". Short option names must be unique.',
-  INVALID_OPTION_ARITY: 'Option "{0}" has invalid number of values. Found "{1}", require "{2}".'
+
+//#region source/ValidationError.ts
+/**
+* A subclass of `Error` that indicates a validation issue.
+*/
+const ValidationError = createCustomError("ValidationError", {
+	INVALID_COMMAND: "Command \"{0}\" has invalid format. Only words consisting of letters, numbers or dashes separated by single space are allowed.",
+	MISSING_PARAMETER: "Parameter \"{0}\" is required but its value is undefined.",
+	INVALID_PARAMETER_DEFAULT_AND_CHOICES: "Parameter \"{0}\" has invalid default value \"{1}\". Default value must be one of the `choices` elements.",
+	INVALID_PARAMETER_ORDER: "Parameter \"{0}\" has invalid order. All parameters before must have a default value or be required too",
+	MISSING_OPTION: "Option \"{0}\" is required but its value is undefined.",
+	INVALID_OPTION_DEFAULT_AND_CHOICES: "Option \"{0}\" has invalid default value \"{1}\". Default value must be one of the `choices` elements.",
+	INVALID_OPTION_NAME: "Option \"{0}\" has invalid name. Only names consisting of letters, numbers or dashes are allowed.",
+	REPEATED_OPTION_NAME: "Option \"{0}\" has invalid short name \"{1}\". Short option names must be unique.",
+	INVALID_OPTION_ARITY: "Option \"{0}\" has invalid number of values. Found \"{1}\", require \"{2}\"."
 });
-//# sourceMappingURL=ValidationError.js.map
+
+//#endregion
+export { ValidationError };

package/build/internals/Checker.js

@@ -1,98 +1,52 @@
-"use strict";
 import { ValidationError } from "../ValidationError.js";
 import { isCommand } from "./isCommand.js";
 import { isLongOption } from "./isLongOption.js";
-export class Checker {
-  errors = [];
-  checkCommandsConfig(commandsConfig) {
-    for (let commandConfig of commandsConfig) {
-      if (!isCommand(commandConfig)) {
-        this.addError(new ValidationError("INVALID_COMMAND", { messageParameters: [commandConfig] }));
-      }
-    }
-  }
-  checkParametersConfig(parametersConfig) {
-    for (let [i, parameterConfig] of parametersConfig.entries()) {
-      if (parameterConfig.type !== "boolean" && parameterConfig.choices && // default values and chocies do not contradict each other
-      parameterConfig.defaultValue !== void 0 && !parameterConfig.choices.includes(parameterConfig.defaultValue)) {
-        this.addError(
-          new ValidationError("INVALID_PARAMETER_DEFAULT_AND_CHOICES", {
-            messageParameters: [parameterConfig.label ?? i, parameterConfig.defaultValue]
-          })
-        );
-      }
-      if (i >= 1 && parameterConfig.required === true && !parametersConfig.slice(0, i).every(
-        (previousParameterConfig) => previousParameterConfig.required === true || previousParameterConfig.defaultValue !== void 0
-      )) {
-        this.addError(
-          new ValidationError("INVALID_PARAMETER_ORDER", {
-            messageParameters: [parameterConfig.label ?? i]
-          })
-        );
-      }
-    }
-  }
-  checkOptionsConfig(optionsConfig) {
-    let usedShortOptionNames = /* @__PURE__ */ new Set([]);
-    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {
-      if (!isLongOption(`--${optionName}`)) {
-        this.addError(
-          new ValidationError("INVALID_OPTION_NAME", {
-            messageParameters: [optionName]
-          })
-        );
-      }
-      if (optionConfig.shortName && usedShortOptionNames.has(optionConfig.shortName)) {
-        this.addError(
-          new ValidationError("REPEATED_OPTION_NAME", {
-            messageParameters: [optionName, optionConfig.shortName]
-          })
-        );
-      } else if (optionConfig.shortName) {
-        usedShortOptionNames.add(optionConfig.shortName);
-      }
-      if ((optionConfig.type === "string" || optionConfig.type === "number" && !optionConfig.count) && optionConfig.choices && optionConfig.defaultValue !== void 0 && !optionConfig.choices.includes(optionConfig.defaultValue)) {
-        this.addError(
-          new ValidationError("INVALID_OPTION_DEFAULT_AND_CHOICES", {
-            messageParameters: [optionName, optionConfig.defaultValue]
-          })
-        );
-      }
-    }
-  }
-  checkParsedParameters(parametersConfig, parsedParameters) {
-    for (let [i, parameterConfig] of parametersConfig.entries()) {
-      let parsedParameter = parsedParameters[i];
-      if (parameterConfig.required === true && parsedParameter === void 0) {
-        this.addError(
-          new ValidationError("MISSING_PARAMETER", {
-            messageParameters: [parameterConfig.label ?? i]
-          })
-        );
-      }
-    }
-  }
-  checkParsedOptions(optionsConfig, parsedOptions) {
-    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {
-      let parsedOption = parsedOptions[optionName];
-      if (optionConfig.required && parsedOption === void 0) {
-        this.addError(
-          new ValidationError("MISSING_OPTION", {
-            messageParameters: [optionName]
-          })
-        );
-      }
-      if (parsedOption !== void 0 && (optionConfig.type === "string" && optionConfig.multiple || optionConfig.type === "number" && optionConfig.multiple) && typeof optionConfig.arity === "number" && Array.isArray(parsedOption) && parsedOption.length > 0 && parsedOption.length !== optionConfig.arity) {
-        this.addError(
-          new ValidationError("INVALID_OPTION_ARITY", {
-            messageParameters: [optionName, parsedOption.length, optionConfig.arity]
-          })
-        );
-      }
-    }
-  }
-  addError(error) {
-    this.errors.push(error);
-  }
-}
-//# sourceMappingURL=Checker.js.map
+
+//#region source/internals/Checker.ts
+/**
+* `Checker` is used for handling various checks before, during, and after parsing of the arguments.
+*/
+var Checker = class {
+	errors = [];
+	checkCommandsConfig(commandsConfig) {
+		for (let commandConfig of commandsConfig) if (!isCommand(commandConfig)) this.addError(new ValidationError("INVALID_COMMAND", { messageParameters: [commandConfig] }));
+	}
+	checkParametersConfig(parametersConfig) {
+		for (let [i, parameterConfig] of parametersConfig.entries()) {
+			if (parameterConfig.type !== "boolean" && parameterConfig.choices && parameterConfig.defaultValue !== void 0 && !parameterConfig.choices.includes(parameterConfig.defaultValue)) this.addError(new ValidationError("INVALID_PARAMETER_DEFAULT_AND_CHOICES", { messageParameters: [parameterConfig.label ?? i, parameterConfig.defaultValue] }));
+			if (i >= 1 && parameterConfig.required === true && !parametersConfig.slice(0, i).every((previousParameterConfig) => previousParameterConfig.required === true || previousParameterConfig.defaultValue !== void 0)) this.addError(new ValidationError("INVALID_PARAMETER_ORDER", { messageParameters: [parameterConfig.label ?? i] }));
+		}
+	}
+	checkOptionsConfig(optionsConfig) {
+		let usedShortOptionNames = /* @__PURE__ */ new Set([]);
+		for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {
+			if (!isLongOption(`--${optionName}`)) this.addError(new ValidationError("INVALID_OPTION_NAME", { messageParameters: [optionName] }));
+			if (optionConfig.shortName && usedShortOptionNames.has(optionConfig.shortName)) this.addError(new ValidationError("REPEATED_OPTION_NAME", { messageParameters: [optionName, optionConfig.shortName] }));
+			else if (optionConfig.shortName) usedShortOptionNames.add(optionConfig.shortName);
+			if ((optionConfig.type === "string" || optionConfig.type === "number" && !optionConfig.count) && optionConfig.choices && optionConfig.defaultValue !== void 0 && !optionConfig.choices.includes(optionConfig.defaultValue)) this.addError(new ValidationError("INVALID_OPTION_DEFAULT_AND_CHOICES", { messageParameters: [optionName, optionConfig.defaultValue] }));
+		}
+	}
+	checkParsedParameters(parametersConfig, parsedParameters) {
+		for (let [i, parameterConfig] of parametersConfig.entries()) {
+			let parsedParameter = parsedParameters[i];
+			if (parameterConfig.required === true && parsedParameter === void 0) this.addError(new ValidationError("MISSING_PARAMETER", { messageParameters: [parameterConfig.label ?? i] }));
+		}
+	}
+	checkParsedOptions(optionsConfig, parsedOptions) {
+		for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {
+			let parsedOption = parsedOptions[optionName];
+			if (optionConfig.required && parsedOption === void 0) this.addError(new ValidationError("MISSING_OPTION", { messageParameters: [optionName] }));
+			if (parsedOption !== void 0 && (optionConfig.type === "string" && optionConfig.multiple || optionConfig.type === "number" && optionConfig.multiple) && typeof optionConfig.arity === "number" && Array.isArray(parsedOption) && parsedOption.length > 0 && parsedOption.length !== optionConfig.arity) this.addError(new ValidationError("INVALID_OPTION_ARITY", { messageParameters: [
+				optionName,
+				parsedOption.length,
+				optionConfig.arity
+			] }));
+		}
+	}
+	addError(error) {
+		this.errors.push(error);
+	}
+};
+
+//#endregion
+export { Checker };

package/build/internals/CommandScope.js

@@ -1,44 +1,42 @@
-"use strict";
-export class CommandScope {
-  args;
-  config;
-  constructor(arg, normalizedCommandsConfig) {
-    let normalizedArgument = arg.toLowerCase();
-    let commandConfig = normalizedCommandsConfig.find(
-      (commandConfig2) => commandConfig2.args[0] === normalizedArgument
-    );
-    this.config = commandConfig ?? [];
-    this.args = [normalizedArgument];
-  }
-  captureArg(arg) {
-    this.args.push(arg.toLowerCase());
-    return this;
-  }
-  isComplete() {
-    let isComplete = true;
-    for (let [i, arg] of this.config.args.entries()) {
-      if (this.args[i] !== arg) {
-        isComplete = false;
-        break;
-      }
-    }
-    return isComplete;
-  }
-  isDone() {
-    let isDone = false;
-    for (let [i, arg] of this.config.args.entries()) {
-      if (this.args[i] !== arg) {
-        isDone = true;
-        break;
-      }
-    }
-    return isDone;
-  }
-  getValue() {
-    return this.config.command;
-  }
-  getArgs() {
-    return [...this.args];
-  }
-}
-//# sourceMappingURL=CommandScope.js.map
+//#region source/internals/CommandScope.ts
+/**
+* `CommandScope` handles storing information about parsing of a command.
+*/
+var CommandScope = class {
+	args;
+	config;
+	constructor(arg, normalizedCommandsConfig) {
+		let normalizedArgument = arg.toLowerCase();
+		this.config = normalizedCommandsConfig.find((commandConfig) => commandConfig.args[0] === normalizedArgument) ?? [];
+		this.args = [normalizedArgument];
+	}
+	captureArg(arg) {
+		this.args.push(arg.toLowerCase());
+		return this;
+	}
+	isComplete() {
+		let isComplete = true;
+		for (let [i, arg] of this.config.args.entries()) if (this.args[i] !== arg) {
+			isComplete = false;
+			break;
+		}
+		return isComplete;
+	}
+	isDone() {
+		let isDone = false;
+		for (let [i, arg] of this.config.args.entries()) if (this.args[i] !== arg) {
+			isDone = true;
+			break;
+		}
+		return isDone;
+	}
+	getValue() {
+		return this.config.command;
+	}
+	getArgs() {
+		return [...this.args];
+	}
+};
+
+//#endregion
+export { CommandScope };

package/build/internals/OptionScope.js

@@ -1,69 +1,51 @@
-"use strict";
-import _ from "lodash";
-import { ParsingError } from "../ParsingError.js";
 import { castValue } from "./castValue.js";
-export class OptionScope {
-  name;
-  values = [];
-  previousParsedValue;
-  config;
-  constructor(optionName, optionsConfig, allowUnknownOptions = false) {
-    this.name = optionName;
-    if (this.name.includes("-")) {
-      this.name = _.camelCase(this.name);
-    }
-    let optionConfig = optionsConfig[this.name];
-    if (!optionConfig) {
-      if (!allowUnknownOptions) {
-        throw new ParsingError("UNKNOWN_OPTION", { messageParameters: [this.name] });
-      }
-      optionConfig = {
-        type: "string"
-      };
-    }
-    this.config = optionConfig;
-  }
-  captureArg(arg) {
-    let value = castValue(arg, this.config.type);
-    if ((this.config.type === "number" && !this.config.count || this.config.type === "string") && this.config.choices !== void 0 && !this.config.choices.includes(value)) {
-      throw new ParsingError("INVALID_OPTION", {
-        messageParameters: [
-          value,
-          this.name,
-          this.config.choices.map((choice) => `"${choice}"`).join(", ")
-        ]
-      });
-    }
-    if (this.config.multiple) {
-      this.values.push(value);
-    } else {
-      this.values = [value];
-    }
-  }
-  isComplete() {
-    if (!this.config.multiple && this.values.length === 1) {
-      return true;
-    }
-    if (this.config.multiple && typeof this.config.arity === "number" && this.values.length + (this.previousParsedValue ?? []).length === this.config.arity) {
-      return true;
-    }
-    return false;
-  }
-  getValue() {
-    let { config, previousParsedValue } = this;
-    let { values } = this;
-    if (config.type === "boolean" && !config.multiple && !values.length) {
-      values = [true];
-    } else if (config.type === "number" && config.count && !values.length) {
-      values = [1];
-    }
-    if (config.multiple && previousParsedValue) {
-      values = [...previousParsedValue, ...values];
-    }
-    if (config.type === "number" && config.count && previousParsedValue) {
-      values = [values[0] + previousParsedValue];
-    }
-    return config.multiple ? values : values[0];
-  }
-}
-//# sourceMappingURL=OptionScope.js.map
+import { ParsingError } from "../ParsingError.js";
+import _ from "lodash";
+
+//#region source/internals/OptionScope.ts
+/**
+* `CommandScope` handles storing information about parsing of an option..
+*/
+var OptionScope = class {
+	name;
+	values = [];
+	previousParsedValue;
+	config;
+	constructor(optionName, optionsConfig, allowUnknownOptions = false) {
+		this.name = optionName;
+		if (this.name.includes("-")) this.name = _.camelCase(this.name);
+		let optionConfig = optionsConfig[this.name];
+		if (!optionConfig) {
+			if (!allowUnknownOptions) throw new ParsingError("UNKNOWN_OPTION", { messageParameters: [this.name] });
+			optionConfig = { type: "string" };
+		}
+		this.config = optionConfig;
+	}
+	captureArg(arg) {
+		let value = castValue(arg, this.config.type);
+		if ((this.config.type === "number" && !this.config.count || this.config.type === "string") && this.config.choices !== void 0 && !this.config.choices.includes(value)) throw new ParsingError("INVALID_OPTION", { messageParameters: [
+			value,
+			this.name,
+			this.config.choices.map((choice) => `"${choice}"`).join(", ")
+		] });
+		if (this.config.multiple) this.values.push(value);
+		else this.values = [value];
+	}
+	isComplete() {
+		if (!this.config.multiple && this.values.length === 1) return true;
+		if (this.config.multiple && typeof this.config.arity === "number" && this.values.length + (this.previousParsedValue ?? []).length === this.config.arity) return true;
+		return false;
+	}
+	getValue() {
+		let { config, previousParsedValue } = this;
+		let { values } = this;
+		if (config.type === "boolean" && !config.multiple && !values.length) values = [true];
+		else if (config.type === "number" && config.count && !values.length) values = [1];
+		if (config.multiple && previousParsedValue) values = [...previousParsedValue, ...values];
+		if (config.type === "number" && config.count && previousParsedValue) values = [values[0] + previousParsedValue];
+		return config.multiple ? values : values[0];
+	}
+};
+
+//#endregion
+export { OptionScope };

package/build/internals/castValue.js

@@ -1,24 +1,24 @@
-"use strict";
 import { isFalseString } from "./isFalseString.js";
-export function castValue(value, targetType) {
-  switch (targetType) {
-    case "boolean": {
-      let booleanString = String(value).toLowerCase();
-      return !(isFalseString(booleanString) || booleanString === "");
-    }
-    case "number": {
-      return Number.parseFloat(value);
-    }
-    case "string": {
-      return String(value);
-    }
-    case void 0: {
-      return String(value);
-    }
-    default: {
-      targetType;
-      return String(value);
-    }
-  }
+
+//#region source/internals/castValue.ts
+/**
+* A function that casts string value to a specified type.
+*
+* @param value The value to be converted.
+* @param type The type to convert the value into.
+* */
+function castValue(value, targetType) {
+	switch (targetType) {
+		case "boolean": {
+			let booleanString = String(value).toLowerCase();
+			return !(isFalseString(booleanString) || booleanString === "");
+		}
+		case "number": return Number.parseFloat(value);
+		case "string": return String(value);
+		case void 0: return String(value);
+		default: return String(value);
+	}
 }
-//# sourceMappingURL=castValue.js.map
+
+//#endregion
+export { castValue };

package/build/internals/commandToArguments.js

@@ -1,14 +1,17 @@
-"use strict";
-export function commandToArguments(value) {
-  let rawArgs = value.split(" ");
-  let args = [];
-  for (let [, rawValue] of rawArgs.entries()) {
-    if (rawValue === "" && args.at(-1)) {
-      args[args.length - 1] += " ";
-    } else {
-      args.push(rawValue);
-    }
-  }
-  return args;
+//#region source/internals/commandToArguments.ts
+/**
+* Converts a string representing a command into the arguments, i.e. array of strings.
+*
+* @param value The value to convert.
+* @return Arguments.
+*/
+function commandToArguments(value) {
+	let rawArgs = value.split(" ");
+	let args = [];
+	for (let [, rawValue] of rawArgs.entries()) if (rawValue === "" && args.at(-1)) args[args.length - 1] += " ";
+	else args.push(rawValue);
+	return args;
 }
-//# sourceMappingURL=commandToArguments.js.map
+
+//#endregion
+export { commandToArguments };

package/build/internals/createOptionShortNameMap.js

@@ -1,11 +1,15 @@
-"use strict";
-export function createOptionShortNameMap(optionsConfig) {
-  let map = {};
-  for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {
-    if (typeof optionConfig.shortName === "string") {
-      map[optionConfig.shortName] = optionName;
-    }
-  }
-  return map;
+//#region source/internals/createOptionShortNameMap.ts
+/**
+* Converts options config to a map (i.e. an object) of short option names (object keys) to long option names (values).
+*
+* @optionsConfig Options config to create the map from.
+* @return Resulting map.
+*/
+function createOptionShortNameMap(optionsConfig) {
+	let map = {};
+	for (let [optionName, optionConfig] of Object.entries(optionsConfig)) if (typeof optionConfig.shortName === "string") map[optionConfig.shortName] = optionName;
+	return map;
 }
-//# sourceMappingURL=createOptionShortNameMap.js.map
+
+//#endregion
+export { createOptionShortNameMap };

package/build/internals/expandArguments.js

@@ -1,14 +1,18 @@
-"use strict";
 import { isShortOptionsGroup } from "./isShortOptionsGroup.js";
-export function expandArguments(argv) {
-  let expandedArguments = [];
-  for (let arg of argv) {
-    if (isShortOptionsGroup(arg)) {
-      expandedArguments.push(...[...arg].slice(1).map((value) => `-${value}`));
-    } else {
-      expandedArguments.push(arg);
-    }
-  }
-  return expandedArguments;
+
+//#region source/internals/expandArguments.ts
+/**
+* Converts short options group in a provided list of arguments into separate short options.
+*
+* @param argv Arguments.
+* @return Arguments that contain no short options group
+*/
+function expandArguments(argv) {
+	let expandedArguments = [];
+	for (let arg of argv) if (isShortOptionsGroup(arg)) expandedArguments.push(...[...arg].slice(1).map((value) => `-${value}`));
+	else expandedArguments.push(arg);
+	return expandedArguments;
 }
-//# sourceMappingURL=expandArguments.js.map
+
+//#endregion
+export { expandArguments };

package/build/internals/isCommand.js

@@ -1,6 +1,14 @@
-"use strict";
-export const COMMAND_REGEXP = /^(?:[a-z][-a-z0-9]*[a-z])+(?:\s(?:[a-z][-a-z0-9]*[a-z])+)*$/iu;
-export function isCommand(value) {
-  return COMMAND_REGEXP.test(value);
+//#region source/internals/isCommand.ts
+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.
+*/
+function isCommand(value) {
+	return COMMAND_REGEXP.test(value);
 }
-//# sourceMappingURL=isCommand.js.map
+
+//#endregion
+export { isCommand };

package/build/internals/isFalseString.js

@@ -1,6 +1,13 @@
-"use strict";
+//#region source/internals/isFalseString.ts
 const FALSE_STRING_REGEXP = /^\s*(?:false|0|no|off)\s*$/iu;
-export function isFalseString(value) {
-  return FALSE_STRING_REGEXP.test(value);
+/**
+* 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. */
+function isFalseString(value) {
+	return FALSE_STRING_REGEXP.test(value);
 }
-//# sourceMappingURL=isFalseString.js.map
+
+//#endregion
+export { isFalseString };

package/build/internals/isLongOption.js

@@ -1,6 +1,14 @@
-"use strict";
+//#region source/internals/isLongOption.ts
 const LONG_OPTION_REGEXP = /^--[a-z][-a-z0-9]+$/iu;
-export function isLongOption(arg) {
-  return LONG_OPTION_REGEXP.test(arg);
+/**
+* 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.
+*/
+function isLongOption(arg) {
+	return LONG_OPTION_REGEXP.test(arg);
 }
-//# sourceMappingURL=isLongOption.js.map
+
+//#endregion
+export { isLongOption };

package/build/internals/isOptionLike.js

@@ -1,6 +1,14 @@
-"use strict";
+//#region source/internals/isOptionLike.ts
 const OPTION_LIKE = /^-{1,2}[a-z][-a-z0-9]*=?/iu;
-export function isOptionLike(value) {
-  return OPTION_LIKE.test(value);
+/**
+* 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.
+*/
+function isOptionLike(value) {
+	return OPTION_LIKE.test(value);
 }
-//# sourceMappingURL=isOptionLike.js.map
+
+//#endregion
+export { isOptionLike };