@bemoje/cli 2.1.3 → 2.1.5

package/index.mjs

@@ -1,47 +1,36 @@
+import C from 'ansi-colors';
+import { isFunction, isString, isPrimitive } from 'es-toolkit/predicate';
+import memoizee from 'memoizee';
+import { ms } from 'enhanced-ms';
+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 __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+var __name = (target, value) => {
+  return __defProp(target, 'name', { value, configurable: true });
 };
 
-// src/lib/Command.ts
-var Command_exports = {};
-__export(Command_exports, {
-  Command: () => Command
-});
-
-// src/lib/Help.ts
-var Help_exports = {};
-__export(Help_exports, {
-  Help: () => Help
-});
-import C from "ansi-colors";
-
 // ../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');
 
 // ../object/src/entriesOf.ts
 function entriesOf(obj) {
   return Object.entries(obj);
 }
+__name(entriesOf, 'entriesOf');
 
 // ../object/src/keysOf.ts
 function keysOf(obj) {
   return Object.keys(obj);
 }
+__name(keysOf, 'keysOf');
 
 // ../object/src/filterObject.ts
 function filterObject(obj, predicate) {
@@ -53,6 +42,7 @@ function filterObject(obj, predicate) {
   }
   return accum;
 }
+__name(filterObject, 'filterObject');
 
 // ../object/src/objSortKeys.ts
 function objSortKeys(o, compare) {
@@ -66,11 +56,13 @@ function objSortKeys(o, compare) {
   }
   return Object.fromEntries(entries);
 }
+__name(objSortKeys, 'objSortKeys');
 
 // ../object/src/valuesOf.ts
 function valuesOf(obj) {
   return Object.values(obj);
 }
+__name(valuesOf, 'valuesOf');
 
 // ../map/src/mapGetOrDefault.ts
 function mapGetOrDefault(map, key, factory) {
@@ -82,16 +74,21 @@ function mapGetOrDefault(map, key, factory) {
   map.set(key, value);
   return value;
 }
+__name(mapGetOrDefault, 'mapGetOrDefault');
 
 // ../map/src/TimeoutWeakMap.ts
 var TimeoutWeakMap = class {
+  static {
+    __name(this, 'TimeoutWeakMap');
+  }
+  timeoutMs;
+  wmap = /* @__PURE__ */ new WeakMap();
   /**
    * @param timeoutMs Default timeout in milliseconds for entries
    */
   constructor(timeoutMs) {
     this.timeoutMs = timeoutMs;
   }
-  wmap = /* @__PURE__ */ new WeakMap();
   /**
    * Retrieves the value for the given key and refreshes its timeout.
    *
@@ -120,7 +117,7 @@ var TimeoutWeakMap = class {
       value,
       setTimeout(() => {
         this.delete(key);
-      }, timeoutMs ?? this.timeoutMs).unref()
+      }, timeoutMs ?? this.timeoutMs).unref(),
     ]);
     return this;
   }
@@ -194,28 +191,29 @@ var TimeoutWeakMap = class {
     }
   }
 };
-
-// ../decorators/src/lazyProp.ts
-import { isFunction } from "es-toolkit/predicate";
-
-// ../decorators/src/memoizeSync.ts
-import memoizee from "memoizee";
-import { ms } from "enhanced-ms";
 function memoizeSync(arg = {}) {
-  const opts = typeof arg === "object" ? arg : { maxAge: typeof arg === "number" ? arg : ms(arg) };
-  return function decorator(target, key, descriptor) {
+  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 };
+    const options = {
+      length: false,
+      ...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);
         });
@@ -223,25 +221,24 @@ function memoizeSync(arg = {}) {
       };
     }
     return descriptor;
-  };
+  }, 'decorator');
 }
-
-// ../decorators/src/lazyProp.ts
-import { ms as ms2 } from "enhanced-ms";
+__name(memoizeSync, 'memoizeSync');
 function lazyProp(targetOrTimeout, key, descriptor) {
-  if (typeof targetOrTimeout === "number" || typeof targetOrTimeout === "string") {
-    const maxAge = typeof targetOrTimeout === "number" ? targetOrTimeout : ms2(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');
 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,21 +251,52 @@ function createLazyPropDecorator(map) {
     throw new TypeError('neither "get" nor "value" are functions');
   };
 }
+__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);
+}
+__name(_ts_decorate, '_ts_decorate');
+function _ts_metadata(k, v) {
+  if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') {
+    return Reflect.metadata(k, v);
+  }
+}
+__name(_ts_metadata, '_ts_metadata');
 var Help = class {
+  static {
+    __name(this, 'Help');
+  }
   cmd;
   /** output helpWidth, long lines are wrapped to fit */
   helpWidth = process.stdout.isTTY ? process.stdout.columns : 80;
   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.
+   */
   visibleCommands() {
     const res = Object.values(this.cmd.commands).filter((c) => {
       return !c.hidden;
@@ -284,11 +312,14 @@ var Help = class {
    * Compare options for sort.
    */
   compareOptions(a, b) {
-    const getSortKey = (option) => {
-      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-    };
+    const getSortKey = /* @__PURE__ */ __name((option) => {
+      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.
+   */
   visibleOptions() {
     const res = this.cmd.options.filter((option) => {
       return !option.hidden;
@@ -298,6 +329,9 @@ var Help = class {
     }
     return res;
   }
+  /**
+   * Get an array of the arguments if any have a description.
+   */
   visibleArguments() {
     return this.cmd.arguments.slice();
   }
@@ -305,11 +339,17 @@ var Help = class {
    * 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.
@@ -323,24 +363,36 @@ var Help = class {
   argumentTerm(argument) {
     return argument.usage;
   }
+  /**
+   * Get the longest subcommand primary alias length.
+   */
   longestSubcommandAliasLength() {
     return Math.max(
       0,
       ...this.visibleCommands().map((c) => {
         return c.aliases[0]?.length || 0;
-      })
+      }),
     );
   }
+  /**
+   * 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.
+   */
   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.
+   */
   longestArgumentTermLength() {
     return this.visibleArguments().reduce((max, argument) => {
       return Math.max(max, this.displayWidth(this.styleArgumentTerm(this.argumentTerm(argument))));
@@ -350,26 +402,32 @@ var Help = class {
    * 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.
    */
   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;
@@ -379,7 +437,10 @@ var Help = class {
    * (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.
@@ -389,9 +450,11 @@ var Help = class {
     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)) {
@@ -401,13 +464,13 @@ 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.
@@ -417,22 +480,24 @@ var Help = class {
     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.
@@ -441,7 +506,7 @@ var Help = class {
     if (items.length === 0) {
       return [];
     }
-    return [this.styleTitle(heading), ...items, ""];
+    return [this.styleTitle(heading), ...items, ''];
   }
   /**
    * Group items by their help group heading.
@@ -468,7 +533,7 @@ var Help = class {
    */
   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.
@@ -480,24 +545,27 @@ var Help = class {
    * 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.
@@ -539,21 +607,24 @@ var Help = class {
    * 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.
@@ -585,11 +656,14 @@ var Help = class {
   styleCommandText(str) {
     return str;
   }
+  /**
+   * Calculate the pad width from the maximum term length.
+   */
   padWidth() {
     return Math.max(
       this.longestOptionTermLength(),
       this.longestSubcommandTermLength(),
-      this.longestArgumentTermLength()
+      this.longestArgumentTermLength(),
     );
   }
   /**
@@ -607,7 +681,7 @@ var Help = class {
    */
   formatItem(term, termWidth, description) {
     const itemIndent = 2;
-    const itemIndentStr = " ".repeat(itemIndent);
+    const itemIndentStr = ' '.repeat(itemIndent);
     if (!description) {
       return itemIndentStr + term;
     }
@@ -620,11 +694,22 @@ 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.
@@ -640,7 +725,7 @@ ${itemIndentStr}`);
     rawLines.forEach((line) => {
       const chunks = line.match(chunkPattern);
       if (chunks === null) {
-        wrappedLines.push("");
+        wrappedLines.push('');
         return;
       }
       let sumChunks = [chunks.shift()];
@@ -652,119 +737,181 @@ ${itemIndentStr}`);
           sumWidth += visibleWidth;
           return;
         }
-        wrappedLines.push(sumChunks.join(""));
+        wrappedLines.push(sumChunks.join(''));
         const nextChunk = chunk.trimStart();
         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.
    */
   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))
+        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))
+          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:";
-      }
-    );
+    const commandGroups = this.groupItems(Object.values(this.cmd.commands), this.visibleCommands(), (sub) => {
+      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))
+          this.styleSubcommandDescription(this.subcommandDescription(sub)),
         );
       });
       output = output.concat(this.formatItemList(group, commandList));
     });
-    return output.join("\n");
+    return output.join('\n');
   }
 };
-__decorateClass([
-  lazyProp
-], Help.prototype, "visibleCommands", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "visibleOptions", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "visibleArguments", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "longestSubcommandAliasLength", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "longestSubcommandTermLength", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "longestOptionTermLength", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "longestArgumentTermLength", 1);
-__decorateClass([
-  lazyProp
-], Help.prototype, "padWidth", 1);
+_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/arrLast.ts
+// ../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');
 
-// ../array/src/arrRemoveDuplicates.ts
+// ../array/src/lib/arrRemoveDuplicates.ts
 function arrRemoveDuplicates(array) {
   return Array.from(new Set(array));
 }
+__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];
     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);
@@ -778,51 +925,40 @@ function collectVariadicOptionValues(parsed, options) {
       token.name,
       values.filter((v) => {
         return v !== void 0;
-      })
+      }),
     );
   }
 }
-
-// src/lib/Command.ts
-import colors3 from "ansi-colors";
+__name(collectVariadicOptionValues, 'collectVariadicOptionValues');
 
 // src/lib/helpers/findCommand.ts
-var findCommand_exports = {};
-__export(findCommand_exports, {
-  findCommand: () => findCommand
-});
 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');
 
 // src/lib/helpers/findOption.ts
-var findOption_exports = {};
-__export(findOption_exports, {
-  findOption: () => findOption
-});
 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;
+        });
 }
-
-// src/lib/helpers/getCommandAncestors.ts
-var getCommandAncestors_exports = {};
-__export(getCommandAncestors_exports, {
-  getCommandAncestors: () => getCommandAncestors
-});
+__name(findOption, 'findOption');
 
 // src/lib/helpers/getCommandAndAncestors.ts
-var getCommandAndAncestors_exports = {};
-__export(getCommandAndAncestors_exports, {
-  getCommandAndAncestors: () => getCommandAndAncestors
-});
 function getCommandAndAncestors(cmd) {
   const result = [];
   let command = cmd;
@@ -831,15 +967,13 @@ function getCommandAndAncestors(cmd) {
   }
   return result;
 }
+__name(getCommandAndAncestors, 'getCommandAndAncestors');
 
 // src/lib/helpers/getCommandAncestors.ts
 function getCommandAncestors(cmd) {
   return getCommandAndAncestors(cmd).slice(1);
 }
-
-// src/lib/Command.ts
-import { inspect } from "node:util";
-import { kebabCase } from "es-toolkit/string";
+__name(getCommandAncestors, 'getCommandAncestors');
 
 // src/lib/internal/mergeOptionDefaults.ts
 function mergeOptionDefaults(values, options) {
@@ -849,6 +983,7 @@ function mergeOptionDefaults(values, options) {
     }
   }
 }
+__name(mergeOptionDefaults, 'mergeOptionDefaults');
 
 // src/lib/internal/normalizeArgv.ts
 function normalizeArgv(argv, options) {
@@ -868,15 +1003,9 @@ function normalizeArgv(argv, options) {
   }
   return argv;
 }
-
-// src/lib/Command.ts
-import { parseArgs } from "node:util";
+__name(normalizeArgv, 'normalizeArgv');
 
 // src/lib/helpers/parseOptionFlags.ts
-var parseOptionFlags_exports = {};
-__export(parseOptionFlags_exports, {
-  parseOptionFlags: () => parseOptionFlags
-});
 function parseOptionFlags(flags) {
   const match = flags.match(/^-(.+?), --([a-zA-Z][\w-]*)(?:\s*(<(.+?)>|\[(.+?)\]))?$/);
   if (!match) {
@@ -887,12 +1016,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 };
+  return {
+    short,
+    long,
+    name,
+    argName,
+  };
 }
+__name(parseOptionFlags, 'parseOptionFlags');
 
 // src/lib/internal/resolveArguments.ts
 function resolveArguments(positionals, args) {
@@ -908,67 +1043,66 @@ function resolveArguments(positionals, args) {
   }
   return result;
 }
+__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');
 
 // ../string/src/lib/strFirstCharToUpperCase.ts
 function strFirstCharToUpperCase(string) {
   return string.charAt(0).toUpperCase() + string.substring(1);
 }
-
-// ../node/src/createLogger.ts
-import colors from "ansi-colors";
-import { isPrimitive } from "es-toolkit/predicate";
-import { isString } from "es-toolkit/predicate";
+__name(strFirstCharToUpperCase, 'strFirstCharToUpperCase');
 function createLogger(name) {
-  const NAME = name ? colors.dim.cyan(name) : name;
-  const START = [NAME, colors.dim.gray("[START]")].filter(Boolean);
-  const DEBUG = [NAME, colors.dim.magenta("[DEBUG]")].filter(Boolean);
-  const INFO = [NAME, colors.dim.gray("[INFO]")].filter(Boolean);
-  const DONE = [NAME, colors.dim.green("[DONE] ")].filter(Boolean);
-  const WARN = [NAME, colors.dim.yellow("[WARN] ")].filter(Boolean);
-  const ERROR = [NAME, colors.dim.red("[ERROR]")].filter(Boolean);
-  const grayArgs = createColoredArgs(colors.gray);
-  const cyanArgs = createColoredArgs(colors.cyan);
-  const yellowArgs = createColoredArgs(colors.yellow);
+  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 grayArgs = createColoredArgs(C.gray);
+  const cyanArgs = createColoredArgs(C.cyan);
+  const yellowArgs = createColoredArgs(C.yellow);
   return {
-    start: (...args) => {
+    start: /* @__PURE__ */ __name((...args) => {
       return console.info(...START, ...args);
-    },
-    done: (...args) => {
+    }, 'start'),
+    done: /* @__PURE__ */ __name((...args) => {
       return console.info(...DONE, ...args);
-    },
-    info: (...args) => {
+    }, 'done'),
+    info: /* @__PURE__ */ __name((...args) => {
       return console.info(...INFO, ...grayArgs(args));
-    },
-    log: (...args) => {
-      return console.log(...NAME ? [NAME, ...args] : args);
-    },
-    warn: (...args) => {
+    }, 'info'),
+    log: /* @__PURE__ */ __name((...args) => {
+      return console.log(...(NAME ? [NAME, ...args] : args));
+    }, 'log'),
+    warn: /* @__PURE__ */ __name((...args) => {
       return console.warn(...WARN, ...yellowArgs(args));
-    },
-    debug: (...args) => {
+    }, 'warn'),
+    debug: /* @__PURE__ */ __name((...args) => {
       return console.debug(...DEBUG, ...cyanArgs(args));
-    },
-    error: (...args) => {
+    }, 'debug'),
+    error: /* @__PURE__ */ __name((...args) => {
       return args.forEach((arg) => {
         return console.error(...ERROR, arg);
       });
-    }
+    }, 'error'),
   };
 }
+__name(createLogger, 'createLogger');
 function createColoredArgs(colorFn) {
   return (args) => {
     return args.map((arg) => {
       if (isString(arg)) {
-        if (arg === colors.stripColor(arg)) {
+        if (arg === C.stripColor(arg)) {
           return colorFn(arg);
         } else {
           return arg;
@@ -981,14 +1115,10 @@ function createColoredArgs(colorFn) {
     });
   };
 }
-
-// ../node/src/timer.ts
-import colors2 from "ansi-colors";
-import humanizeDuration from "humanize-duration";
-import { isPromise } from "node:util/types";
+__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);
@@ -1006,59 +1136,98 @@ function timer(arg, task) {
     }
     const ns = process.hrtime.bigint() - t0;
     const ms3 = Math.floor(Number(ns) / 1e6);
-    log.done(colors2.dim(humanizeDuration(ms3)));
+    log.done(C.dim(humanizeDuration(ms3)));
     return retval2;
   }
 }
+__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}`;
-      }
-    }
-    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}`;
+  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 (!(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(",")}]`;
+        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(',')}]`;
         }
       }
     })
-  ).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');
 
 // src/lib/Command.ts
-var _Command = class _Command {
+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);
+}
+__name(_ts_decorate2, '_ts_decorate');
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') {
+    return Reflect.metadata(k, v);
+  }
+}
+__name(_ts_metadata2, '_ts_metadata');
+var Command = class _Command {
+  static {
+    __name(this, 'Command');
+  }
   /** parent command in the hierarchy, undefined for root command */
   parent;
   /** the command name used to invoke it */
@@ -1088,18 +1257,35 @@ 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", { value: parent, enumerable: false });
+    Object.defineProperty(this, 'parent', {
+      value: parent,
+      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;
       });
@@ -1117,7 +1303,7 @@ var _Command = class _Command {
   /** renders formatted help text using provided help definition */
   renderHelp(config = {}) {
     const result = this.help.render();
-    return config.noColor ? colors3.stripColor(result) : result;
+    return config.noColor ? C.stripColor(result) : result;
   }
   /** sets the command name */
   setName(name) {
@@ -1131,19 +1317,23 @@ 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;
     });
@@ -1152,14 +1342,16 @@ 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 }) => {
+    return this.addOption('-V, --version', {
+      description: 'Display semver version',
+    }).addOptionHook('version', ({ cmd }) => {
       console.log(
         getCommandAndAncestors(cmd).find((c) => {
           return c.version;
-        })?.version
+        })?.version,
       );
       process.exitCode = 0;
     });
@@ -1171,7 +1363,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 */
@@ -1185,11 +1377,11 @@ 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.`
+        `Cannot add subcommand "${name}" to "${this.name}" because it already has arguments defined.`,
       );
     }
     const sub = this.createSubcommand(name);
@@ -1208,20 +1400,24 @@ var _Command = class _Command {
       throw new Error(
         `Command name "${getCommandAndAncestors(sub).map((c) => {
           return c.name;
-        })}" is already used by this command or its aliases: ${taken.join(", ")}`
+        })}" 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);
       }
@@ -1230,7 +1426,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;
@@ -1240,9 +1436,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}`);
@@ -1252,7 +1448,7 @@ var _Command = class _Command {
     }
     if (required && prevArg?.defaultValue) {
       throw new Error(
-        `Cannot add required argument ${usage} after optional argument with default value ${prevArg.usage}`
+        `Cannot add required argument ${usage} after optional argument with default value ${prevArg.usage}`,
       );
     }
     const arg = {
@@ -1260,7 +1456,7 @@ var _Command = class _Command {
       name,
       required,
       variadic,
-      ...options
+      ...options,
     };
     if (variadic && !arg.defaultValue) {
       arg.defaultValue = [];
@@ -1286,21 +1482,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 ?? [];
         }
@@ -1311,15 +1507,18 @@ 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];
       }
@@ -1337,14 +1536,18 @@ var _Command = class _Command {
   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;
   }
@@ -1359,13 +1562,21 @@ var _Command = class _Command {
       args: argv,
       options: Object.fromEntries(
         this.options.map((o) => {
-          return [o.name, { type: o.type, short: o.short, default: o.defaultValue, multiple: !!o.variadic }];
-        })
+          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);
@@ -1387,22 +1598,22 @@ var _Command = class _Command {
       args,
       opts,
       errors,
-      cmd: this
+      cmd: this,
     };
     const hooks = this.hooks.filter((t) => {
       return t.predicate(data);
     });
-    const execute = async () => {
+    const execute = /* @__PURE__ */ __name(async () => {
       for (const hook of hooks) {
         await hook.action(data);
         if (process.exitCode !== void 0) {
           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(colors3.red(msg));
+            return logger.error(C.red(msg));
           });
           process.exitCode = 1;
           return;
@@ -1413,13 +1624,17 @@ var _Command = class _Command {
             args,
             opts,
             cmd: this,
-            logger
+            logger,
           });
         }
         console.log(this.renderHelp());
       });
+    }, 'execute');
+    return {
+      ...data,
+      hooks,
+      execute,
     };
-    return { ...data, hooks, execute };
   }
   /**
    * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
@@ -1434,33 +1649,15 @@ var _Command = class _Command {
     return new _Command(name, this);
   }
 };
-__decorateClass([
-  lazyProp
-], _Command.prototype, "help", 1);
-var Command = _Command;
-
-// src/lib/types.ts
-var types_exports = {};
+_ts_decorate2(
+  [
+    lazyProp,
+    _ts_metadata2('design:type', typeof Help === 'undefined' ? Object : Help),
+    _ts_metadata2('design:paramtypes', []),
+  ],
+  Command.prototype,
+  'help',
+  null,
+);
 
-// src/index.ts
-var src_default = {
-  ...Command_exports,
-  //
-  ...Help_exports,
-  ...findCommand_exports,
-  ...findOption_exports,
-  ...getCommandAncestors_exports,
-  ...getCommandAndAncestors_exports,
-  ...parseOptionFlags_exports,
-  ...types_exports
-};
-export {
-  Command,
-  Help,
-  src_default as default,
-  findCommand,
-  findOption,
-  getCommandAncestors,
-  getCommandAndAncestors,
-  parseOptionFlags
-};
+export { Command, Help, findCommand, findOption, getCommandAncestors, getCommandAndAncestors, parseOptionFlags };