@bemoje/cli 2.1.4 → 2.1.6

package/index.mjs

@@ -1,39 +1,34 @@
 import C from 'ansi-colors';
-import humanizeDuration from 'humanize-duration';
-import { inspect } from 'util';
-import { isFunction } from 'es-toolkit/predicate';
-import { isPrimitive } from 'es-toolkit/predicate';
-import { isPromise } from 'util/types';
-import { isString } from 'es-toolkit/predicate';
-import { kebabCase } from 'es-toolkit/string';
+import { isFunction, isString, isPrimitive } from 'es-toolkit/predicate';
 import memoizee from 'memoizee';
 import { ms } from 'enhanced-ms';
-import { parseArgs } from 'util';
+import { inspect, parseArgs } from 'util';
+import { kebabCase } from 'es-toolkit/string';
+import humanizeDuration from 'humanize-duration';
+import { isPromise } from 'util/types';
 
 var __defProp = Object.defineProperty;
-var __name = (target, value) => {
-  return __defProp(target, 'name', { value, configurable: true });
-};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // ../decorators/src/assertDescriptorValueIsFunction.ts
 function assertDescriptorValueIsFunction(key, descriptor) {
-  if (!(typeof descriptor.value === 'function' && descriptor.value !== Function.prototype)) {
+  if (!(typeof descriptor.value === "function" && descriptor.value !== Function.prototype)) {
     throw new TypeError(`"value" not a function for ${key} with descriptor: ${JSON.stringify(descriptor)}.`);
   }
 }
-__name(assertDescriptorValueIsFunction, 'assertDescriptorValueIsFunction');
+__name(assertDescriptorValueIsFunction, "assertDescriptorValueIsFunction");
 
 // ../object/src/entriesOf.ts
 function entriesOf(obj) {
   return Object.entries(obj);
 }
-__name(entriesOf, 'entriesOf');
+__name(entriesOf, "entriesOf");
 
 // ../object/src/keysOf.ts
 function keysOf(obj) {
   return Object.keys(obj);
 }
-__name(keysOf, 'keysOf');
+__name(keysOf, "keysOf");
 
 // ../object/src/filterObject.ts
 function filterObject(obj, predicate) {
@@ -45,7 +40,7 @@ function filterObject(obj, predicate) {
   }
   return accum;
 }
-__name(filterObject, 'filterObject');
+__name(filterObject, "filterObject");
 
 // ../object/src/objSortKeys.ts
 function objSortKeys(o, compare) {
@@ -59,13 +54,13 @@ function objSortKeys(o, compare) {
   }
   return Object.fromEntries(entries);
 }
-__name(objSortKeys, 'objSortKeys');
+__name(objSortKeys, "objSortKeys");
 
 // ../object/src/valuesOf.ts
 function valuesOf(obj) {
   return Object.values(obj);
 }
-__name(valuesOf, 'valuesOf');
+__name(valuesOf, "valuesOf");
 
 // ../map/src/mapGetOrDefault.ts
 function mapGetOrDefault(map, key, factory) {
@@ -77,27 +72,27 @@ function mapGetOrDefault(map, key, factory) {
   map.set(key, value);
   return value;
 }
-__name(mapGetOrDefault, 'mapGetOrDefault');
+__name(mapGetOrDefault, "mapGetOrDefault");
 
 // ../map/src/TimeoutWeakMap.ts
 var TimeoutWeakMap = class {
   static {
-    __name(this, 'TimeoutWeakMap');
+    __name(this, "TimeoutWeakMap");
   }
   timeoutMs;
   wmap = /* @__PURE__ */ new WeakMap();
   /**
-   * @param timeoutMs Default timeout in milliseconds for entries
-   */
+  * @param timeoutMs Default timeout in milliseconds for entries
+  */
   constructor(timeoutMs) {
     this.timeoutMs = timeoutMs;
   }
   /**
-   * Retrieves the value for the given key and refreshes its timeout.
-   *
-   * @param key The key to retrieve
-   * @returns The value if found, undefined otherwise
-   */
+  * Retrieves the value for the given key and refreshes its timeout.
+  *
+  * @param key The key to retrieve
+  * @returns The value if found, undefined otherwise
+  */
   get(key) {
     const vt = this.wmap.get(key);
     if (!vt) {
@@ -108,28 +103,28 @@ var TimeoutWeakMap = class {
     return value;
   }
   /**
-   * Sets a key-value pair with an optional custom timeout.
-   *
-   * @param key The key to set
-   * @param value The value to associate with the key
-   * @param timeoutMs Optional timeout override for this entry
-   * @returns This instance for chaining
-   */
+  * Sets a key-value pair with an optional custom timeout.
+  *
+  * @param key The key to set
+  * @param value The value to associate with the key
+  * @param timeoutMs Optional timeout override for this entry
+  * @returns This instance for chaining
+  */
   set(key, value, timeoutMs) {
     this.wmap.set(key, [
       value,
       setTimeout(() => {
         this.delete(key);
-      }, timeoutMs ?? this.timeoutMs).unref(),
+      }, timeoutMs ?? this.timeoutMs).unref()
     ]);
     return this;
   }
   /**
-   * Removes a key-value pair and clears its timeout.
-   *
-   * @param key The key to delete
-   * @returns True if the key existed and was deleted, false otherwise
-   */
+  * Removes a key-value pair and clears its timeout.
+  *
+  * @param key The key to delete
+  * @returns True if the key existed and was deleted, false otherwise
+  */
   delete(key) {
     const vt = this.wmap.get(key);
     if (!vt) {
@@ -140,22 +135,22 @@ var TimeoutWeakMap = class {
     return this.wmap.delete(key);
   }
   /**
-   * Checks if a key exists in the map.
-   * Does not refresh the timeout.
-   *
-   * @param key The key to check
-   * @returns True if the key exists, false otherwise
-   */
+  * Checks if a key exists in the map.
+  * Does not refresh the timeout.
+  *
+  * @param key The key to check
+  * @returns True if the key exists, false otherwise
+  */
   has(key) {
     return this.wmap.has(key);
   }
   /**
-   * Loads multiple key-value pairs into the map.
-   *
-   * @param entries Iterable of key-value pairs to load
-   * @param timeoutMs Optional timeout override for all entries
-   * @returns This instance for chaining
-   */
+  * Loads multiple key-value pairs into the map.
+  *
+  * @param entries Iterable of key-value pairs to load
+  * @param timeoutMs Optional timeout override for all entries
+  * @returns This instance for chaining
+  */
   load(entries, timeoutMs) {
     for (const [key, value] of entries) {
       this.set(key, value, timeoutMs);
@@ -163,24 +158,24 @@ var TimeoutWeakMap = class {
     return this;
   }
   /**
-   * Updates an existing value or creates a new one using an update function.
-   *
-   * @param key The key to update
-   * @param update Function that receives the current value and returns the new value
-   * @returns This instance for chaining
-   */
+  * Updates an existing value or creates a new one using an update function.
+  *
+  * @param key The key to update
+  * @param update Function that receives the current value and returns the new value
+  * @returns This instance for chaining
+  */
   update(key, update) {
     return this.set(key, update(this.get(key), key, this));
   }
   /**
-   * Gets a value or creates it using a factory function if it doesn't exist.
-   * Refreshes timeout if the value exists.
-   *
-   * @param key The key to get or create
-   * @param factory Function to create the value if it doesn't exist
-   * @param timeoutMs Optional timeout override for new entries
-   * @returns The existing or newly created value
-   */
+  * Gets a value or creates it using a factory function if it doesn't exist.
+  * Refreshes timeout if the value exists.
+  *
+  * @param key The key to get or create
+  * @param factory Function to create the value if it doesn't exist
+  * @param timeoutMs Optional timeout override for new entries
+  * @returns The existing or newly created value
+  */
   getOrDefault(key, factory, timeoutMs) {
     const vt = this.wmap.get(key);
     if (vt) {
@@ -195,28 +190,25 @@ var TimeoutWeakMap = class {
   }
 };
 function memoizeSync(arg = {}) {
-  const opts =
-    typeof arg === 'object'
-      ? arg
-      : {
-          maxAge: typeof arg === 'number' ? arg : ms(arg),
-        };
+  const opts = typeof arg === "object" ? arg : {
+    maxAge: typeof arg === "number" ? arg : ms(arg)
+  };
   return /* @__PURE__ */ __name(function decorator(target, key, descriptor) {
     if (!descriptor) {
-      throw new TypeError('descriptor is undefined');
+      throw new TypeError("descriptor is undefined");
     }
     const orig = descriptor.value;
     assertDescriptorValueIsFunction(key, descriptor);
     const options = {
       length: false,
-      ...opts,
+      ...opts
     };
     if (opts.instancesShareCache) {
-      Reflect.deleteProperty(options, 'instancesShareCache');
+      Reflect.deleteProperty(options, "instancesShareCache");
       descriptor.value = memoizee(orig, options);
     } else {
       const wmap = /* @__PURE__ */ new WeakMap();
-      descriptor.value = function (...args) {
+      descriptor.value = function(...args) {
         const memoized = mapGetOrDefault(wmap, this, () => {
           return memoizee(orig, options);
         });
@@ -224,24 +216,24 @@ function memoizeSync(arg = {}) {
       };
     }
     return descriptor;
-  }, 'decorator');
+  }, "decorator");
 }
-__name(memoizeSync, 'memoizeSync');
+__name(memoizeSync, "memoizeSync");
 function lazyProp(targetOrTimeout, key, descriptor) {
-  if (typeof targetOrTimeout === 'number' || typeof targetOrTimeout === 'string') {
-    const maxAge = typeof targetOrTimeout === 'number' ? targetOrTimeout : ms(targetOrTimeout);
+  if (typeof targetOrTimeout === "number" || typeof targetOrTimeout === "string") {
+    const maxAge = typeof targetOrTimeout === "number" ? targetOrTimeout : ms(targetOrTimeout);
     return createLazyPropDecorator(new TimeoutWeakMap(maxAge));
   } else {
     const decorator = createLazyPropDecorator(/* @__PURE__ */ new WeakMap());
     return decorator(targetOrTimeout, key, descriptor);
   }
 }
-__name(lazyProp, 'lazyProp');
+__name(lazyProp, "lazyProp");
 function createLazyPropDecorator(map) {
-  return function (target, key, descriptor) {
+  return function(target, key, descriptor) {
     const { get, value } = descriptor;
     if (isFunction(get)) {
-      descriptor.get = function () {
+      descriptor.get = function() {
         return mapGetOrDefault(map, this, () => {
           return get.call(this);
         });
@@ -254,34 +246,23 @@ function createLazyPropDecorator(map) {
     throw new TypeError('neither "get" nor "value" are functions');
   };
 }
-__name(createLazyPropDecorator, 'createLazyPropDecorator');
+__name(createLazyPropDecorator, "createLazyPropDecorator");
 
 // src/lib/Help.ts
 function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length,
-    r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
-    d;
-  if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function') {
-    r = Reflect.decorate(decorators, target, key, desc);
-  } else {
-    for (var i = decorators.length - 1; i >= 0; i--) {
-      if ((d = decorators[i])) {
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      }
-    }
-  }
-  return (c > 3 && r && Object.defineProperty(target, key, r), r);
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate, '_ts_decorate');
+__name(_ts_decorate, "_ts_decorate");
 function _ts_metadata(k, v) {
-  if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') {
-    return Reflect.metadata(k, v);
-  }
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata, '_ts_metadata');
+__name(_ts_metadata, "_ts_metadata");
 var Help = class {
   static {
-    __name(this, 'Help');
+    __name(this, "Help");
   }
   cmd;
   /** output helpWidth, long lines are wrapped to fit */
@@ -289,17 +270,17 @@ var Help = class {
   minWidthToWrap = 40;
   sortSubcommands = true;
   sortOptions = true;
-  usageDisplayOptionsAs = '[opts]';
-  usageDisplaySubcommandAs = '[cmd]';
+  usageDisplayOptionsAs = "[opts]";
+  usageDisplaySubcommandAs = "[cmd]";
   constructor(cmd) {
     this.cmd = cmd;
-    Object.defineProperty(this, 'cmd', {
-      enumerable: false,
+    Object.defineProperty(this, "cmd", {
+      enumerable: false
     });
   }
   /**
-   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
-   */
+  * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+  */
   visibleCommands() {
     const res = Object.values(this.cmd.commands).filter((c) => {
       return !c.hidden;
@@ -312,17 +293,17 @@ var Help = class {
     return res;
   }
   /**
-   * Compare options for sort.
-   */
+  * Compare options for sort.
+  */
   compareOptions(a, b) {
     const getSortKey = /* @__PURE__ */ __name((option) => {
-      return option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
-    }, 'getSortKey');
+      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+    }, "getSortKey");
     return getSortKey(a).localeCompare(getSortKey(b));
   }
   /**
-   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
-   */
+  * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+  */
   visibleOptions() {
     const res = this.cmd.options.filter((option) => {
       return !option.hidden;
@@ -333,131 +314,115 @@ var Help = class {
     return res;
   }
   /**
-   * Get an array of the arguments if any have a description.
-   */
+  * Get an array of the arguments if any have a description.
+  */
   visibleArguments() {
     return this.cmd.arguments.slice();
   }
   /**
-   * Get the command term to show in the list of subcommands.
-   */
+  * Get the command term to show in the list of subcommands.
+  */
   subcommandTerm(sub) {
-    const args = sub.arguments
-      .map((arg) => {
-        return arg.usage;
-      })
-      .join(' ');
-    return (
-      (sub.aliases[0] ? `${sub.aliases[0].padEnd(this.longestSubcommandAliasLength(), ' ')} | ` : '') +
-      sub.name +
-      (sub.options.length ? ` ${this.usageDisplayOptionsAs}` : '') + // simplistic check for non-help option
-      (args ? ` ${args}` : '')
-    );
+    const args = sub.arguments.map((arg) => {
+      return arg.usage;
+    }).join(" ");
+    return (sub.aliases[0] ? `${sub.aliases[0].padEnd(this.longestSubcommandAliasLength(), " ")} | ` : "") + sub.name + (sub.options.length ? ` ${this.usageDisplayOptionsAs}` : "") + // simplistic check for non-help option
+    (args ? ` ${args}` : "");
   }
   /**
-   * Get the option term to show in the list of options.
-   */
+  * Get the option term to show in the list of options.
+  */
   optionTerm(option) {
     return option.flags;
   }
   /**
-   * Get the argument term to show in the list of arguments.
-   */
+  * Get the argument term to show in the list of arguments.
+  */
   argumentTerm(argument) {
     return argument.usage;
   }
   /**
-   * Get the longest subcommand primary alias length.
-   */
+  * Get the longest subcommand primary alias length.
+  */
   longestSubcommandAliasLength() {
-    return Math.max(
-      0,
-      ...this.visibleCommands().map((c) => {
-        return c.aliases[0]?.length || 0;
-      }),
-    );
+    return Math.max(0, ...this.visibleCommands().map((c) => {
+      return c.aliases[0]?.length || 0;
+    }));
   }
   /**
-   * Get the longest subcommand term length.
-   */
+  * Get the longest subcommand term length.
+  */
   longestSubcommandTermLength() {
     return this.visibleCommands().reduce((max, command) => {
       return Math.max(max, this.displayWidth(this.styleSubcommandTerm(this.subcommandTerm(command))));
     }, 0);
   }
   /**
-   * Get the longest option term length.
-   */
+  * Get the longest option term length.
+  */
   longestOptionTermLength() {
     return this.visibleOptions().reduce((max, option) => {
       return Math.max(max, this.displayWidth(this.styleOptionTerm(this.optionTerm(option))));
     }, 0);
   }
   /**
-   * Get the longest argument term length.
-   */
+  * Get the longest argument term length.
+  */
   longestArgumentTermLength() {
     return this.visibleArguments().reduce((max, argument) => {
       return Math.max(max, this.displayWidth(this.styleArgumentTerm(this.argumentTerm(argument))));
     }, 0);
   }
   /**
-   * Get the command usage to be displayed at the top of the built-in help.
-   */
+  * Get the command usage to be displayed at the top of the built-in help.
+  */
   commandUsage() {
-    let path = '';
+    let path = "";
     for (let ancestor = this.cmd.parent; ancestor; ancestor = ancestor.parent) {
       path = `${ancestor.name} ${path}`;
     }
     return `${path + this.cmd.name} ${[
-      ...(Object.keys(this.cmd.commands).length ? [this.usageDisplaySubcommandAs] : []),
-      ...(this.cmd.options.length ? [this.usageDisplayOptionsAs] : []),
+      ...Object.keys(this.cmd.commands).length ? [
+        this.usageDisplaySubcommandAs
+      ] : [],
+      ...this.cmd.options.length ? [
+        this.usageDisplayOptionsAs
+      ] : [],
       ...this.cmd.arguments.map((arg) => {
-        return arg.required
-          ? arg.variadic
-            ? `<${arg.name}...>`
-            : `<${arg.name}>`
-          : arg.variadic
-            ? `[${arg.name}...]`
-            : `[${arg.name}]`;
-      }),
-    ].join(' ')}`.trim();
+        return arg.required ? arg.variadic ? `<${arg.name}...>` : `<${arg.name}>` : arg.variadic ? `[${arg.name}...]` : `[${arg.name}]`;
+      })
+    ].join(" ")}`.trim();
   }
   /**
-   * Get the description for the command.
-   */
+  * Get the description for the command.
+  */
   commandDescription() {
-    let res = '';
+    let res = "";
     if (this.cmd.aliases.length) {
-      res += `Aliases: ${this.cmd.aliases.join(', ')}`;
-      res += '\n\n';
+      res += `Aliases: ${this.cmd.aliases.join(", ")}`;
+      res += "\n\n";
     }
     res += this.cmd.description;
     return res;
   }
   /**
-   * Get the subcommand summary to show in the list of subcommands.
-   * (Fallback to description for backwards compatibility.)
-   */
+  * Get the subcommand summary to show in the list of subcommands.
+  * (Fallback to description for backwards compatibility.)
+  */
   subcommandDescription(sub) {
-    return (
-      sub.summary ||
-      (sub.description?.includes('\n') ? sub.description.trim().split('\n')[0] : sub.description.trim())
-    );
+    return sub.summary || (sub.description?.includes("\n") ? sub.description.trim().split("\n")[0] : sub.description.trim());
   }
   /**
-   * Get the option description to show in the list of options.
-   */
+  * Get the option description to show in the list of options.
+  */
   optionDescription(option) {
     const extraInfo = [];
     if (option.choices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${option.choices
-          .map((choice) => {
-            return String(choice);
-          })
-          .join(', ')}`,
+        `choices: ${option.choices.map((choice) => {
+          return String(choice);
+        }).join(", ")}`
       );
     }
     if (option.defaultValue && !(Array.isArray(option.defaultValue) && option.defaultValue.length === 0)) {
@@ -467,53 +432,55 @@ var Help = class {
       extraInfo.push(`env: ${option.env}`);
     }
     if (extraInfo.length > 0) {
-      const extraDescription = `(${extraInfo.join(', ')})`;
+      const extraDescription = `(${extraInfo.join(", ")})`;
       if (option.description) {
         return `${option.description} ${extraDescription}`;
       }
       return extraDescription;
     }
-    return option.description ?? '';
+    return option.description ?? "";
   }
   /**
-   * Get the argument description to show in the list of arguments.
-   */
+  * Get the argument description to show in the list of arguments.
+  */
   argumentDescription(argument) {
     const extraInfo = [];
     if (argument.choices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${argument.choices
-          .map((choice) => {
-            return String(choice);
-          })
-          .join(', ')}`,
+        `choices: ${argument.choices.map((choice) => {
+          return String(choice);
+        }).join(", ")}`
       );
     }
     if (argument.defaultValue && !(Array.isArray(argument.defaultValue) && argument.defaultValue.length === 0)) {
       extraInfo.push(`default: ${argument.defaultValueDescription || String(argument.defaultValue)}`);
     }
     if (extraInfo.length > 0) {
-      const extraDescription = `(${extraInfo.join(', ')})`;
+      const extraDescription = `(${extraInfo.join(", ")})`;
       if (argument.description) {
         return `${argument.description} ${extraDescription}`;
       }
       return extraDescription;
     }
-    return argument.description ?? '';
+    return argument.description ?? "";
   }
   /**
-   * Format a list of items, given a heading and an array of formatted items.
-   */
+  * Format a list of items, given a heading and an array of formatted items.
+  */
   formatItemList(heading, items) {
     if (items.length === 0) {
       return [];
     }
-    return [this.styleTitle(heading), ...items, ''];
+    return [
+      this.styleTitle(heading),
+      ...items,
+      ""
+    ];
   }
   /**
-   * Group items by their help group heading.
-   */
+  * Group items by their help group heading.
+  */
   groupItems(unsortedItems, visibleItems, getGroup) {
     const result = /* @__PURE__ */ new Map();
     unsortedItems.forEach((item) => {
@@ -532,159 +499,149 @@ var Help = class {
     return result;
   }
   /**
-   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
-   */
+  * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+  */
   displayWidth(str) {
     const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, '').length;
+    return str.replace(sgrPattern, "").length;
   }
   /**
-   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
-   */
+  * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+  */
   styleTitle(str) {
     return C.yellow(str);
   }
   /**
-   * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
-   */
+  * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
+  */
   styleUsage(str) {
-    return str
-      .split(' ')
-      .map((word, index, arr) => {
-        if (word === this.usageDisplaySubcommandAs) {
-          return C.green(word);
-        }
-        if (word === this.usageDisplayOptionsAs) {
-          return C.blue(word);
-        }
-        if (word[0] === '<') {
-          return C.red(word);
-        }
-        if (word[0] === '[') {
-          return C.cyan(word);
-        }
-        if (arr[index + 1]?.startsWith('[')) {
-          return C.magenta(word);
-        }
-        return this.styleCommandText(word);
-      })
-      .join(' ');
+    return str.split(" ").map((word, index, arr) => {
+      if (word === this.usageDisplaySubcommandAs) {
+        return C.green(word);
+      }
+      if (word === this.usageDisplayOptionsAs) {
+        return C.blue(word);
+      }
+      if (word[0] === "<") {
+        return C.red(word);
+      }
+      if (word[0] === "[") {
+        return C.cyan(word);
+      }
+      if (arr[index + 1]?.startsWith("[")) {
+        return C.magenta(word);
+      }
+      return this.styleCommandText(word);
+    }).join(" ");
   }
   /**
-   * Style command descriptions for display in help output.
-   */
+  * Style command descriptions for display in help output.
+  */
   styleCommandDescription(str) {
     return this.styleDescriptionText(str);
   }
   /**
-   * Style option descriptions for display in help output.
-   */
+  * Style option descriptions for display in help output.
+  */
   styleOptionDescription(str) {
     return C.gray(this.styleDescriptionText(str));
   }
   /**
-   * Style subcommand descriptions for display in help output.
-   */
+  * Style subcommand descriptions for display in help output.
+  */
   styleSubcommandDescription(str) {
     return this.styleDescriptionText(str);
   }
   /**
-   * Style argument descriptions for display in help output.
-   */
+  * Style argument descriptions for display in help output.
+  */
   styleArgumentDescription(str) {
     return C.gray(this.styleDescriptionText(str));
   }
   /**
-   * Base style used by descriptions. Override in subclass to apply custom formatting.
-   */
+  * Base style used by descriptions. Override in subclass to apply custom formatting.
+  */
   styleDescriptionText(str) {
     return C.gray(str);
   }
   /**
-   * Style option terms (flags) for display in help output.
-   */
+  * Style option terms (flags) for display in help output.
+  */
   styleOptionTerm(str) {
     return this.styleOptionText(str);
   }
   /**
-   * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
-   */
+  * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
+  */
   styleSubcommandTerm(str) {
-    const res = str
-      .split(' ')
-      .map((word) => {
-        if (word === this.usageDisplayOptionsAs) {
-          return C.dim(word);
-        }
-        if (word[0] === '[' || word[0] === '<') {
-          return C.dim(word);
-        }
-        return this.styleSubcommandText(word);
-      })
-      .join(' ');
-    const split = res.split('|');
+    const res = str.split(" ").map((word) => {
+      if (word === this.usageDisplayOptionsAs) {
+        return C.dim(word);
+      }
+      if (word[0] === "[" || word[0] === "<") {
+        return C.dim(word);
+      }
+      return this.styleSubcommandText(word);
+    }).join(" ");
+    const split = res.split("|");
     if (split.length === 1) {
       return res;
     }
     split[0] = C.green(split[0]);
-    return split.join('|');
+    return split.join("|");
   }
   /**
-   * Style argument terms for display in help output.
-   */
+  * Style argument terms for display in help output.
+  */
   styleArgumentTerm(str) {
     return this.styleArgumentText(str);
   }
   /**
-   * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
-   */
+  * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
+  */
   styleOptionText(str) {
     return str;
   }
   /**
-   * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
-   */
+  * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
+  */
   styleArgumentText(str) {
     return str;
   }
   /**
-   * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
-   */
+  * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
+  */
   styleSubcommandText(str) {
     return str;
   }
   /**
-   * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
-   */
+  * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
+  */
   styleCommandText(str) {
     return str;
   }
   /**
-   * Calculate the pad width from the maximum term length.
-   */
+  * Calculate the pad width from the maximum term length.
+  */
   padWidth() {
-    return Math.max(
-      this.longestOptionTermLength(),
-      this.longestSubcommandTermLength(),
-      this.longestArgumentTermLength(),
-    );
+    return Math.max(this.longestOptionTermLength(), this.longestSubcommandTermLength(), this.longestArgumentTermLength());
   }
   /**
-   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
-   */
+  * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
+  */
   preformatted(str) {
     return /\n[^\S\r\n]/.test(str);
   }
   /**
-   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
-   *
-   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
-   *   TTT  DDD DDDD
-   *        DD DDD
-   */
+  * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+  *
+  * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+  *   TTT  DDD DDDD
+  *        DD DDD
+  */
   formatItem(term, termWidth, description) {
     const itemIndent = 2;
-    const itemIndentStr = ' '.repeat(itemIndent);
+    const itemIndentStr = " ".repeat(itemIndent);
     if (!description) {
       return itemIndentStr + term;
     }
@@ -697,27 +654,16 @@ var Help = class {
       formattedDescription = description;
     } else {
       const wrappedDescription = this.boxWrap(description, remainingWidth);
-      formattedDescription = wrappedDescription.replace(
-        /\n/g,
-        `
-${' '.repeat(termWidth + spacerWidth)}`,
-      );
+      formattedDescription = wrappedDescription.replace(/\n/g, `
+${" ".repeat(termWidth + spacerWidth)}`);
     }
-    return (
-      itemIndentStr +
-      paddedTerm +
-      ' '.repeat(spacerWidth) +
-      formattedDescription.replace(
-        /\n/g,
-        `
-${itemIndentStr}`,
-      )
-    );
+    return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
   }
   /**
-   * Wrap a string at whitespace, preserving existing line breaks.
-   * Wrapping is skipped if the width is less than `minWidthToWrap`.
-   */
+  * Wrap a string at whitespace, preserving existing line breaks.
+  * Wrapping is skipped if the width is less than `minWidthToWrap`.
+  */
   boxWrap(str, width) {
     if (width < this.minWidthToWrap) {
       return str;
@@ -728,10 +674,12 @@ ${itemIndentStr}`,
     rawLines.forEach((line) => {
       const chunks = line.match(chunkPattern);
       if (chunks === null) {
-        wrappedLines.push('');
+        wrappedLines.push("");
         return;
       }
-      let sumChunks = [chunks.shift()];
+      let sumChunks = [
+        chunks.shift()
+      ];
       let sumWidth = this.displayWidth(sumChunks[0]);
       chunks.forEach((chunk) => {
         const visibleWidth = this.displayWidth(chunk);
@@ -740,181 +688,139 @@ ${itemIndentStr}`,
           sumWidth += visibleWidth;
           return;
         }
-        wrappedLines.push(sumChunks.join(''));
+        wrappedLines.push(sumChunks.join(""));
         const nextChunk = chunk.trimStart();
-        sumChunks = [nextChunk];
+        sumChunks = [
+          nextChunk
+        ];
         sumWidth = this.displayWidth(nextChunk);
       });
-      wrappedLines.push(sumChunks.join(''));
+      wrappedLines.push(sumChunks.join(""));
     });
-    return wrappedLines.join('\n');
+    return wrappedLines.join("\n");
   }
   /**
-   * Generate the built-in help text.
-   */
+  * Generate the built-in help text.
+  */
   render() {
-    let output = [`${this.styleTitle('Usage:')} ${this.styleUsage(this.commandUsage())}`, ''];
+    let output = [
+      `${this.styleTitle("Usage:")} ${this.styleUsage(this.commandUsage())}`,
+      ""
+    ];
     const des = this.commandDescription();
     if (des.length > 0) {
-      output = output.concat([this.boxWrap(this.styleCommandDescription(des), this.helpWidth), '']);
+      output = output.concat([
+        this.boxWrap(this.styleCommandDescription(des), this.helpWidth),
+        ""
+      ]);
     }
     const argumentList = this.visibleArguments().map((argument) => {
-      return this.formatItem(
-        this.styleArgumentTerm(this.argumentTerm(argument)),
-        this.padWidth(),
-        this.styleArgumentDescription(this.argumentDescription(argument)),
-      );
+      return this.formatItem(this.styleArgumentTerm(this.argumentTerm(argument)), this.padWidth(), this.styleArgumentDescription(this.argumentDescription(argument)));
     });
-    output = output.concat(this.formatItemList('Arguments:', argumentList));
+    output = output.concat(this.formatItemList("Arguments:", argumentList));
     const optionGroups = this.groupItems(this.cmd.options, this.visibleOptions(), (option) => {
-      return option.group ?? 'Options:';
+      return option.group ?? "Options:";
     });
     optionGroups.forEach((options, group) => {
       const optionList = options.map((option) => {
-        return this.formatItem(
-          this.styleOptionTerm(this.optionTerm(option)),
-          this.padWidth(),
-          this.styleOptionDescription(this.optionDescription(option)),
-        );
+        return this.formatItem(this.styleOptionTerm(this.optionTerm(option)), this.padWidth(), this.styleOptionDescription(this.optionDescription(option)));
       });
       output = output.concat(this.formatItemList(group, optionList));
     });
     const commandGroups = this.groupItems(Object.values(this.cmd.commands), this.visibleCommands(), (sub) => {
-      return sub.group || 'Commands:';
+      return sub.group || "Commands:";
     });
     commandGroups.forEach((commands, group) => {
       const commandList = commands.map((sub) => {
-        return this.formatItem(
-          this.styleSubcommandTerm(this.subcommandTerm(sub)),
-          this.padWidth(),
-          this.styleSubcommandDescription(this.subcommandDescription(sub)),
-        );
+        return this.formatItem(this.styleSubcommandTerm(this.subcommandTerm(sub)), this.padWidth(), this.styleSubcommandDescription(this.subcommandDescription(sub)));
       });
       output = output.concat(this.formatItemList(group, commandList));
     });
-    return output.join('\n');
+    return output.join("\n");
   }
 };
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Array),
-  ],
-  Help.prototype,
-  'visibleCommands',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Array),
-  ],
-  Help.prototype,
-  'visibleOptions',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Array),
-  ],
-  Help.prototype,
-  'visibleArguments',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Number),
-  ],
-  Help.prototype,
-  'longestSubcommandAliasLength',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Number),
-  ],
-  Help.prototype,
-  'longestSubcommandTermLength',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Number),
-  ],
-  Help.prototype,
-  'longestOptionTermLength',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Number),
-  ],
-  Help.prototype,
-  'longestArgumentTermLength',
-  null,
-);
-_ts_decorate(
-  [
-    lazyProp,
-    _ts_metadata('design:type', Function),
-    _ts_metadata('design:paramtypes', []),
-    _ts_metadata('design:returntype', Number),
-  ],
-  Help.prototype,
-  'padWidth',
-  null,
-);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Array)
+], Help.prototype, "visibleCommands", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Array)
+], Help.prototype, "visibleOptions", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Array)
+], Help.prototype, "visibleArguments", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Number)
+], Help.prototype, "longestSubcommandAliasLength", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Number)
+], Help.prototype, "longestSubcommandTermLength", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Number)
+], Help.prototype, "longestOptionTermLength", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Number)
+], Help.prototype, "longestArgumentTermLength", null);
+_ts_decorate([
+  lazyProp,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", Number)
+], Help.prototype, "padWidth", null);
 
 // ../array/src/lib/arrLast.ts
 function arrLast(array) {
   if (!array.length) {
-    throw new Error('Cannot get last element of empty array.');
+    throw new Error("Cannot get last element of empty array.");
   }
   return array[array.length - 1];
 }
-__name(arrLast, 'arrLast');
+__name(arrLast, "arrLast");
 
 // ../array/src/lib/arrRemoveDuplicates.ts
 function arrRemoveDuplicates(array) {
   return Array.from(new Set(array));
 }
-__name(arrRemoveDuplicates, 'arrRemoveDuplicates');
+__name(arrRemoveDuplicates, "arrRemoveDuplicates");
 
 // src/lib/internal/collectVariadicOptionValues.ts
 function collectVariadicOptionValues(parsed, options) {
   for (let i = 0; i < parsed.tokens.length; i++) {
     const token = parsed.tokens[i];
-    if (token.kind !== 'option') {
+    if (token.kind !== "option") {
       continue;
     }
     const def = options.find((o) => {
       return o.name === token.name;
     });
-    if (!def?.variadic || def.type !== 'string') {
+    if (!def?.variadic || def.type !== "string") {
       continue;
     }
-    const values = [token.value];
+    const values = [
+      token.value
+    ];
     let j = i + 1;
-    while (j < parsed.tokens.length && parsed.tokens[j].kind === 'positional') {
+    while (j < parsed.tokens.length && parsed.tokens[j].kind === "positional") {
       const positionalToken = parsed.tokens[j];
       values.push(positionalToken.value);
       const posIndex = parsed.positionals.indexOf(positionalToken.value);
@@ -923,43 +829,32 @@ function collectVariadicOptionValues(parsed, options) {
       }
       j++;
     }
-    Reflect.set(
-      parsed.values,
-      token.name,
-      values.filter((v) => {
-        return v !== void 0;
-      }),
-    );
+    Reflect.set(parsed.values, token.name, values.filter((v) => {
+      return v !== void 0;
+    }));
   }
 }
-__name(collectVariadicOptionValues, 'collectVariadicOptionValues');
+__name(collectVariadicOptionValues, "collectVariadicOptionValues");
 
 // src/lib/helpers/findCommand.ts
 function findCommand(cmd, nameOrAlias) {
-  return (
-    cmd.commands[nameOrAlias] ??
-    valuesOf(cmd.commands).find((c) => {
-      return c.aliases.includes(nameOrAlias);
-    })
-  );
+  return cmd.commands[nameOrAlias] ?? valuesOf(cmd.commands).find((c) => {
+    return c.aliases.includes(nameOrAlias);
+  });
 }
-__name(findCommand, 'findCommand');
+__name(findCommand, "findCommand");
 
 // src/lib/helpers/findOption.ts
 function findOption(cmd, nameOrShortOrLong) {
-  return nameOrShortOrLong.startsWith('--')
-    ? cmd.options.find((o) => {
-        return o.long === nameOrShortOrLong.slice(2);
-      })
-    : nameOrShortOrLong.startsWith('-')
-      ? cmd.options.find((o) => {
-          return o.short === nameOrShortOrLong.slice(1);
-        })
-      : cmd.options.find((o) => {
-          return o.name === nameOrShortOrLong;
-        });
+  return nameOrShortOrLong.startsWith("--") ? cmd.options.find((o) => {
+    return o.long === nameOrShortOrLong.slice(2);
+  }) : nameOrShortOrLong.startsWith("-") ? cmd.options.find((o) => {
+    return o.short === nameOrShortOrLong.slice(1);
+  }) : cmd.options.find((o) => {
+    return o.name === nameOrShortOrLong;
+  });
 }
-__name(findOption, 'findOption');
+__name(findOption, "findOption");
 
 // src/lib/helpers/getCommandAndAncestors.ts
 function getCommandAndAncestors(cmd) {
@@ -970,13 +865,13 @@ function getCommandAndAncestors(cmd) {
   }
   return result;
 }
-__name(getCommandAndAncestors, 'getCommandAndAncestors');
+__name(getCommandAndAncestors, "getCommandAndAncestors");
 
 // src/lib/helpers/getCommandAncestors.ts
 function getCommandAncestors(cmd) {
   return getCommandAndAncestors(cmd).slice(1);
 }
-__name(getCommandAncestors, 'getCommandAncestors');
+__name(getCommandAncestors, "getCommandAncestors");
 
 // src/lib/internal/mergeOptionDefaults.ts
 function mergeOptionDefaults(values, options) {
@@ -986,7 +881,7 @@ function mergeOptionDefaults(values, options) {
     }
   }
 }
-__name(mergeOptionDefaults, 'mergeOptionDefaults');
+__name(mergeOptionDefaults, "mergeOptionDefaults");
 
 // src/lib/internal/normalizeArgv.ts
 function normalizeArgv(argv, options) {
@@ -1006,7 +901,7 @@ function normalizeArgv(argv, options) {
   }
   return argv;
 }
-__name(normalizeArgv, 'normalizeArgv');
+__name(normalizeArgv, "normalizeArgv");
 
 // src/lib/helpers/parseOptionFlags.ts
 function parseOptionFlags(flags) {
@@ -1019,18 +914,18 @@ function parseOptionFlags(flags) {
     throw new Error(`Expected short name to be a single character. Got: -${short}`);
   }
   const long = match[2];
-  const argName = (match[4] || match[5])?.replace(/\.\.\.$/, '') || void 0;
-  const name = long.split('-').reduce((str, word) => {
+  const argName = (match[4] || match[5])?.replace(/\.\.\.$/, "") || void 0;
+  const name = long.split("-").reduce((str, word) => {
     return str + word[0].toUpperCase() + word.slice(1);
   });
   return {
     short,
     long,
     name,
-    argName,
+    argName
   };
 }
-__name(parseOptionFlags, 'parseOptionFlags');
+__name(parseOptionFlags, "parseOptionFlags");
 
 // src/lib/internal/resolveArguments.ts
 function resolveArguments(positionals, args) {
@@ -1046,61 +941,82 @@ function resolveArguments(positionals, args) {
   }
   return result;
 }
-__name(resolveArguments, 'resolveArguments');
+__name(resolveArguments, "resolveArguments");
 
 // ../fn/src/setName.ts
 function setName(name, target) {
-  return Object.defineProperty(target, 'name', {
-    value: typeof name === 'string' ? name : name.name,
+  return Object.defineProperty(target, "name", {
+    value: typeof name === "string" ? name : name.name,
     configurable: true,
-    enumerable: false,
+    enumerable: false
   });
 }
-__name(setName, 'setName');
+__name(setName, "setName");
 
 // ../string/src/lib/strFirstCharToUpperCase.ts
 function strFirstCharToUpperCase(string) {
   return string.charAt(0).toUpperCase() + string.substring(1);
 }
-__name(strFirstCharToUpperCase, 'strFirstCharToUpperCase');
+__name(strFirstCharToUpperCase, "strFirstCharToUpperCase");
 function createLogger(name) {
   const NAME = name ? C.dim.cyan(name) : name;
-  const START = [NAME, C.dim.gray('[START]')].filter(Boolean);
-  const DEBUG = [NAME, C.dim.magenta('[DEBUG]')].filter(Boolean);
-  const INFO = [NAME, C.dim.gray('[INFO]')].filter(Boolean);
-  const DONE = [NAME, C.dim.green('[DONE] ')].filter(Boolean);
-  const WARN = [NAME, C.dim.yellow('[WARN] ')].filter(Boolean);
-  const ERROR = [NAME, C.dim.red('[ERROR]')].filter(Boolean);
+  const START = [
+    NAME,
+    C.dim.gray("[START]")
+  ].filter(Boolean);
+  const DEBUG = [
+    NAME,
+    C.dim.magenta("[DEBUG]")
+  ].filter(Boolean);
+  const INFO = [
+    NAME,
+    C.dim.gray("[INFO]")
+  ].filter(Boolean);
+  const DONE = [
+    NAME,
+    C.dim.green("[DONE] ")
+  ].filter(Boolean);
+  const WARN = [
+    NAME,
+    C.dim.yellow("[WARN] ")
+  ].filter(Boolean);
+  const ERROR = [
+    NAME,
+    C.dim.red("[ERROR]")
+  ].filter(Boolean);
   const grayArgs = createColoredArgs(C.gray);
   const cyanArgs = createColoredArgs(C.cyan);
   const yellowArgs = createColoredArgs(C.yellow);
   return {
     start: /* @__PURE__ */ __name((...args) => {
       return console.info(...START, ...args);
-    }, 'start'),
+    }, "start"),
     done: /* @__PURE__ */ __name((...args) => {
       return console.info(...DONE, ...args);
-    }, 'done'),
+    }, "done"),
     info: /* @__PURE__ */ __name((...args) => {
       return console.info(...INFO, ...grayArgs(args));
-    }, 'info'),
+    }, "info"),
     log: /* @__PURE__ */ __name((...args) => {
-      return console.log(...(NAME ? [NAME, ...args] : args));
-    }, 'log'),
+      return console.log(...NAME ? [
+        NAME,
+        ...args
+      ] : args);
+    }, "log"),
     warn: /* @__PURE__ */ __name((...args) => {
       return console.warn(...WARN, ...yellowArgs(args));
-    }, 'warn'),
+    }, "warn"),
     debug: /* @__PURE__ */ __name((...args) => {
       return console.debug(...DEBUG, ...cyanArgs(args));
-    }, 'debug'),
+    }, "debug"),
     error: /* @__PURE__ */ __name((...args) => {
       return args.forEach((arg) => {
         return console.error(...ERROR, arg);
       });
-    }, 'error'),
+    }, "error")
   };
 }
-__name(createLogger, 'createLogger');
+__name(createLogger, "createLogger");
 function createColoredArgs(colorFn) {
   return (args) => {
     return args.map((arg) => {
@@ -1118,10 +1034,13 @@ function createColoredArgs(colorFn) {
     });
   };
 }
-__name(createColoredArgs, 'createColoredArgs');
+__name(createColoredArgs, "createColoredArgs");
 function timer(arg, task) {
   const t0 = process.hrtime.bigint();
-  const [name, description] = Array.isArray(arg) ? arg : [arg, ''];
+  const [name, description] = Array.isArray(arg) ? arg : [
+    arg,
+    ""
+  ];
   const log = createLogger(name);
   if (name && description) {
     log.start(description);
@@ -1143,93 +1062,69 @@ function timer(arg, task) {
     return retval2;
   }
 }
-__name(timer, 'timer');
+__name(timer, "timer");
 
 // src/lib/internal/validateParsed.ts
 function validateParsed(args, optionValues, argDefs, optionDefs) {
-  return argDefs
-    .map((def, index) => {
-      const value = args[index];
-      if (def.required) {
-        if (def.variadic ? Array.isArray(value) && value.length === 0 : value === void 0) {
-          return `Missing argument [${index}] ${def.usage}`;
-        }
+  return argDefs.map((def, index) => {
+    const value = args[index];
+    if (def.required) {
+      if (def.variadic ? Array.isArray(value) && value.length === 0 : value === void 0) {
+        return `Missing argument [${index}] ${def.usage}`;
       }
-      if (def.choices && value !== void 0) {
-        if (
-          ![value].flat().every((v) => {
-            return def.choices.includes(v);
-          })
-        ) {
-          return `Invalid argument [${index}] ${def.usage}: Got \`${value}\`. Accepted values: [${def.choices
-            .map((c) => {
-              return `\`${c}\``;
-            })
-            .join(',')}]`;
-        }
+    }
+    if (def.choices && value !== void 0) {
+      if (![
+        value
+      ].flat().every((v) => {
+        return def.choices.includes(v);
+      })) {
+        return `Invalid argument [${index}] ${def.usage}: Got \`${value}\`. Accepted values: [${def.choices.map((c) => {
+          return `\`${c}\``;
+        }).join(",")}]`;
       }
-    })
-    .concat(
-      entriesOf(optionValues).map(([key, value]) => {
-        const def = optionDefs.find((o) => {
-          return o.name === key;
-        });
-        if (!def) {
-          return `Unknown option --${key}`;
-        }
-        if (def.choices && value !== void 0) {
-          if (
-            !(def.variadic ? value : [value]).every((v) => {
-              return def.choices.includes(v);
-            })
-          ) {
-            return `Invalid option value ${def.flags}: Got \`${value}\`. Accepted values: [${def.choices
-              .map((c) => {
-                return `\`${c}\``;
-              })
-              .join(',')}]`;
-          }
-        }
-      }),
-    )
-    .filter((s) => {
-      return s !== void 0;
-    })
-    .reduce(
-      (acc, curr) => {
-        return (acc ?? []).concat(curr);
-      },
-      void 0,
-    );
+    }
+  }).concat(entriesOf(optionValues).map(([key, value]) => {
+    const def = optionDefs.find((o) => {
+      return o.name === key;
+    });
+    if (!def) {
+      return `Unknown option --${key}`;
+    }
+    if (def.choices && value !== void 0) {
+      if (!(def.variadic ? value : [
+        value
+      ]).every((v) => {
+        return def.choices.includes(v);
+      })) {
+        return `Invalid option value ${def.flags}: Got \`${value}\`. Accepted values: [${def.choices.map((c) => {
+          return `\`${c}\``;
+        }).join(",")}]`;
+      }
+    }
+  })).filter((s) => {
+    return s !== void 0;
+  }).reduce((acc, curr) => {
+    return (acc ?? []).concat(curr);
+  }, void 0);
 }
-__name(validateParsed, 'validateParsed');
+__name(validateParsed, "validateParsed");
 
 // src/lib/Command.ts
 function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length,
-    r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
-    d;
-  if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function') {
-    r = Reflect.decorate(decorators, target, key, desc);
-  } else {
-    for (var i = decorators.length - 1; i >= 0; i--) {
-      if ((d = decorators[i])) {
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      }
-    }
-  }
-  return (c > 3 && r && Object.defineProperty(target, key, r), r);
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate2, '_ts_decorate');
+__name(_ts_decorate2, "_ts_decorate");
 function _ts_metadata2(k, v) {
-  if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') {
-    return Reflect.metadata(k, v);
-  }
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata2, '_ts_metadata');
+__name(_ts_metadata2, "_ts_metadata");
 var Command = class _Command {
   static {
-    __name(this, 'Command');
+    __name(this, "Command");
   }
   /** parent command in the hierarchy, undefined for root command */
   parent;
@@ -1260,35 +1155,31 @@ var Command = class _Command {
   constructor(name, parent) {
     this.name = name;
     this.aliases = [];
-    this.description = '';
+    this.description = "";
     this.arguments = [];
     this.options = [];
     this.commands = {};
     this.hooks = [];
-    Object.defineProperty(this, 'parent', {
+    Object.defineProperty(this, "parent", {
       value: parent,
-      enumerable: false,
+      enumerable: false
     });
     if (!parent) {
-      this.addOption('-D, --debug', {
-        description: 'Display debug information',
-      }).addOptionHook('debug', ({ cmd, ...data }) => {
-        console.debug(
-          inspect(cmd, {
-            depth: 1,
-            colors: true,
-          }),
-        );
-        console.debug(
-          inspect(data, {
-            depth: 3,
-            colors: true,
-          }),
-        );
+      this.addOption("-D, --debug", {
+        description: "Display debug information"
+      }).addOptionHook("debug", ({ cmd, ...data }) => {
+        console.debug(inspect(cmd, {
+          depth: 1,
+          colors: true
+        }));
+        console.debug(inspect(data, {
+          depth: 3,
+          colors: true
+        }));
       });
-      this.addOption('-h, --help', {
-        description: 'Display help information',
-      }).addOptionHook('help', ({ cmd }) => {
+      this.addOption("-h, --help", {
+        description: "Display help information"
+      }).addOptionHook("help", ({ cmd }) => {
         console.log(cmd.renderHelp());
         process.exitCode = 0;
       });
@@ -1320,23 +1211,20 @@ var Command = class _Command {
   }
   /** adds aliases to existing ones */
   addAliases(...aliases) {
-    const taken = this.parent
-      ? valuesOf(this.parent.commands).flatMap((c) => {
-          return [c.name, ...c.aliases];
-        })
-      : [];
-    arrRemoveDuplicates(aliases.flat())
-      .filter((a) => {
-        return !this.aliases.includes(a) && a !== this.name;
-      })
-      .forEach((a) => {
-        if (taken.includes(a)) {
-          throw new Error(
-            `Alias "${a}" is already used by a sibling command: ${findCommand(this.parent, a)?.name}`,
-          );
-        }
-        this.aliases.push(a);
-      });
+    const taken = this.parent ? valuesOf(this.parent.commands).flatMap((c) => {
+      return [
+        c.name,
+        ...c.aliases
+      ];
+    }) : [];
+    arrRemoveDuplicates(aliases.flat()).filter((a) => {
+      return !this.aliases.includes(a) && a !== this.name;
+    }).forEach((a) => {
+      if (taken.includes(a)) {
+        throw new Error(`Alias "${a}" is already used by a sibling command: ${findCommand(this.parent, a)?.name}`);
+      }
+      this.aliases.push(a);
+    });
     this.aliases.sort((a, b) => {
       return a.length - b.length;
     });
@@ -1345,17 +1233,15 @@ var Command = class _Command {
   /** sets the command version */
   setVersion(version) {
     this.version = version;
-    if (findOption(this, 'version')) {
+    if (findOption(this, "version")) {
       return this;
     }
-    return this.addOption('-V, --version', {
-      description: 'Display semver version',
-    }).addOptionHook('version', ({ cmd }) => {
-      console.log(
-        getCommandAndAncestors(cmd).find((c) => {
-          return c.version;
-        })?.version,
-      );
+    return this.addOption("-V, --version", {
+      description: "Display semver version"
+    }).addOptionHook("version", ({ cmd }) => {
+      console.log(getCommandAndAncestors(cmd).find((c) => {
+        return c.version;
+      })?.version);
       process.exitCode = 0;
     });
   }
@@ -1366,7 +1252,7 @@ var Command = class _Command {
   }
   /** sets command description, joining variadic lines */
   setDescription(...lines) {
-    this.description = lines.join('\n');
+    this.description = lines.join("\n");
     return this;
   }
   /** sets whether command is hidden from help */
@@ -1380,12 +1266,10 @@ var Command = class _Command {
     return this;
   }
   /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
-
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   command(name, cb) {
     if (this.arguments.length) {
-      throw new Error(
-        `Cannot add subcommand "${name}" to "${this.name}" because it already has arguments defined.`,
-      );
+      throw new Error(`Cannot add subcommand "${name}" to "${this.name}" because it already has arguments defined.`);
     }
     const sub = this.createSubcommand(name);
     const inherit = this.options;
@@ -1397,30 +1281,27 @@ var Command = class _Command {
     });
     sub.hooks.push(...inheritHooks);
     const taken = valuesOf(this.commands).flatMap((c) => {
-      return [c.name, ...c.aliases];
+      return [
+        c.name,
+        ...c.aliases
+      ];
     });
     if (taken.includes(name)) {
-      throw new Error(
-        `Command name "${getCommandAndAncestors(sub).map((c) => {
-          return c.name;
-        })}" is already used by this command or its aliases: ${taken.join(', ')}`,
-      );
+      throw new Error(`Command name "${getCommandAndAncestors(sub).map((c) => {
+        return c.name;
+      })}" is already used by this command or its aliases: ${taken.join(", ")}`);
     }
     const kebab = kebabCase(name);
-    const words = kebab.split('-');
-    const initials = words
-      .map((s) => {
-        return s[0];
-      })
-      .join('');
+    const words = kebab.split("-");
+    const initials = words.map((s) => {
+      return s[0];
+    }).join("");
     if (!taken.includes(initials)) {
       sub.addAliases(initials);
     } else {
-      const initials2 = words
-        .map((s) => {
-          return s[0] + s[1];
-        })
-        .join('');
+      const initials2 = words.map((s) => {
+        return s[0] + s[1];
+      }).join("");
       if (!taken.includes(initials2)) {
         sub.addAliases(initials2);
       }
@@ -1429,7 +1310,7 @@ var Command = class _Command {
     return cb ? cb(sub, this) : sub;
   }
   /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
-
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   addCommand(name, cb) {
     this.command(name, cb);
     return this;
@@ -1439,9 +1320,9 @@ var Command = class _Command {
     if (!/^<(.*?)>$|^\[(.*?)\]$/.test(usage)) {
       throw new Error(`Invalid argument format: ${usage}`);
     }
-    const name = usage.slice(1, -1).replace(/\.\.\.$/, '');
-    const required = usage.startsWith('<');
-    const variadic = usage.slice(0, -1).endsWith('...');
+    const name = usage.slice(1, -1).replace(/\.\.\.$/, "");
+    const required = usage.startsWith("<");
+    const variadic = usage.slice(0, -1).endsWith("...");
     const prevArg = this.arguments[this.arguments.length - 1];
     if (prevArg?.variadic) {
       throw new Error(`Cannot add argument ${usage} after variadic argument ${prevArg.usage}`);
@@ -1450,16 +1331,14 @@ var Command = class _Command {
       throw new Error(`Cannot add required argument ${usage} after optional argument ${prevArg?.usage}`);
     }
     if (required && prevArg?.defaultValue) {
-      throw new Error(
-        `Cannot add required argument ${usage} after optional argument with default value ${prevArg.usage}`,
-      );
+      throw new Error(`Cannot add required argument ${usage} after optional argument with default value ${prevArg.usage}`);
     }
     const arg = {
       usage,
       name,
       required,
       variadic,
-      ...options,
+      ...options
     };
     if (variadic && !arg.defaultValue) {
       arg.defaultValue = [];
@@ -1468,8 +1347,8 @@ var Command = class _Command {
     return this;
   }
   /**
-   * adds command-line option with type inference. Parses format: `-s, --long [<value>|[value]|<value...>|[value...]]`
-   */
+  * adds command-line option with type inference. Parses format: `-s, --long [<value>|[value]|<value...>|[value...]]`
+  */
   addOption(flags, opts = {}) {
     const ins = {};
     const { short, long, name, argName } = parseOptionFlags(flags);
@@ -1485,21 +1364,21 @@ var Command = class _Command {
     ins.short = short;
     ins.long = long;
     ins.name = name;
-    ins.description = '';
+    ins.description = "";
     if (!argName) {
-      ins.type = 'boolean';
+      ins.type = "boolean";
     } else {
-      ins.type = 'string';
+      ins.type = "string";
       ins.argName = argName;
-      if (flags.endsWith('>')) {
-        if (flags.endsWith('...>')) {
+      if (flags.endsWith(">")) {
+        if (flags.endsWith("...>")) {
           ins.required = true;
           ins.variadic = true;
         } else {
           ins.required = true;
         }
-      } else if (flags.endsWith(']')) {
-        if (flags.endsWith('...]')) {
+      } else if (flags.endsWith("]")) {
+        if (flags.endsWith("...]")) {
           ins.variadic = true;
           ins.defaultValue = opts.defaultValue ?? [];
         }
@@ -1510,18 +1389,15 @@ var Command = class _Command {
         Reflect.set(ins, key, value);
       }
     }
-    if (ins.env && ins.defaultValue === void 0 && typeof process.env[ins.env] === 'string') {
+    if (ins.env && ins.defaultValue === void 0 && typeof process.env[ins.env] === "string") {
       ins.required = false;
-      ins.flags = ins.flags.replace('<', '[').replace('>', ']');
-      if (ins.type === 'boolean') {
+      ins.flags = ins.flags.replace("<", "[").replace(">", "]");
+      if (ins.type === "boolean") {
         ins.defaultValue = /^(t(rue)?|y(es)?|1)$/i.test(process.env[ins.env]);
       } else if (ins.variadic) {
-        ins.defaultValue = process.env[ins.env]
-          .replace(/\]|\[/, '')
-          .split(',')
-          .map((v) => {
-            return v.trim();
-          });
+        ins.defaultValue = process.env[ins.env].replace(/\]|\[/, "").split(",").map((v) => {
+          return v.trim();
+        });
       } else {
         ins.defaultValue = process.env[ins.env];
       }
@@ -1530,27 +1406,23 @@ var Command = class _Command {
     return this;
   }
   /**
-   * register an action to be invoked when an option is set to true or string value.
-   *
-   * Hooks execute in addition to or instead of the main action handler,
-   * allowing for option-driven behavior. For example, `--help` and `--version`
-   * are implemented as hooks.
-   */
+  * register an action to be invoked when an option is set to true or string value.
+  *
+  * Hooks execute in addition to or instead of the main action handler,
+  * allowing for option-driven behavior. For example, `--help` and `--version`
+  * are implemented as hooks.
+  */
   addOptionHook(optionName, action) {
     const def = findOption(this, optionName);
     if (!def.group && /process\.exitCode ?= ?.+;?\s*\}$/.test(action.toString())) {
-      def.group = 'Command Options';
+      def.group = "Command Options";
     }
     this.hooks.push({
       name: optionName,
       predicate: setName(`has${strFirstCharToUpperCase(optionName)}`, ({ opts }) => {
-        return (
-          opts[optionName] !== void 0 &&
-          opts[optionName] !== false &&
-          !(Array.isArray(opts[optionName]) && opts[optionName].length === 0)
-        );
+        return opts[optionName] !== void 0 && opts[optionName] !== false && !(Array.isArray(opts[optionName]) && opts[optionName].length === 0);
       }),
-      action: setName(optionName, action),
+      action: setName(optionName, action)
     });
     return this;
   }
@@ -1563,23 +1435,21 @@ var Command = class _Command {
     argv = normalizeArgv(argv, this.options);
     const parsed = parseArgs({
       args: argv,
-      options: Object.fromEntries(
-        this.options.map((o) => {
-          return [
-            o.name,
-            {
-              type: o.type,
-              short: o.short,
-              default: o.defaultValue,
-              multiple: !!o.variadic,
-            },
-          ];
-        }),
-      ),
+      options: Object.fromEntries(this.options.map((o) => {
+        return [
+          o.name,
+          {
+            type: o.type,
+            short: o.short,
+            default: o.defaultValue,
+            multiple: !!o.variadic
+          }
+        ];
+      })),
       allowPositionals: true,
       tokens: true,
       strict: false,
-      allowNegative: true,
+      allowNegative: true
     });
     collectVariadicOptionValues(parsed, this.options);
     mergeOptionDefaults(parsed.values, this.options);
@@ -1601,7 +1471,7 @@ var Command = class _Command {
       args,
       opts,
       errors,
-      cmd: this,
+      cmd: this
     };
     const hooks = this.hooks.filter((t) => {
       return t.predicate(data);
@@ -1613,7 +1483,13 @@ var Command = class _Command {
           return;
         }
       }
-      await timer([[...path, this.name].join(' '), this.description], async (logger) => {
+      await timer([
+        [
+          ...path,
+          this.name
+        ].join(" "),
+        this.description
+      ], async (logger) => {
         if (errors) {
           errors.forEach((msg) => {
             return logger.error(C.red(msg));
@@ -1627,22 +1503,22 @@ var Command = class _Command {
             args,
             opts,
             cmd: this,
-            logger,
+            logger
           });
         }
         console.log(this.renderHelp());
       });
-    }, 'execute');
+    }, "execute");
     return {
       ...data,
       hooks,
-      execute,
+      execute
     };
   }
   /**
-   * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
-   * The handler receives parsed arguments and options with correct typings.
-   */
+  * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
+  * The handler receives parsed arguments and options with correct typings.
+  */
   setAction(fn) {
     this.action = setName(this.name, fn);
     return this;
@@ -1652,15 +1528,10 @@ var Command = class _Command {
     return new _Command(name, this);
   }
 };
-_ts_decorate2(
-  [
-    lazyProp,
-    _ts_metadata2('design:type', typeof Help === 'undefined' ? Object : Help),
-    _ts_metadata2('design:paramtypes', []),
-  ],
-  Command.prototype,
-  'help',
-  null,
-);
+_ts_decorate2([
+  lazyProp,
+  _ts_metadata2("design:type", typeof Help === "undefined" ? Object : Help),
+  _ts_metadata2("design:paramtypes", [])
+], Command.prototype, "help", null);
 
 export { Command, Help, findCommand, findOption, getCommandAncestors, getCommandAndAncestors, parseOptionFlags };