@bemoje/cli 2.0.0 → 2.0.2

package/index.mjs

@@ -20,18 +20,20 @@ __export(Command_exports, {
   Command: () => Command
 });
 
-// ../array/src/arrLast.ts
-function arrLast(array) {
-  if (!array.length) throw new Error("Cannot get last element of empty array.");
-  return array[array.length - 1];
-}
-__name(arrLast, "arrLast");
+// src/lib/Help.ts
+var Help_exports = {};
+__export(Help_exports, {
+  Help: () => Help
+});
+import C from "ansi-colors";
 
-// ../array/src/arrRemoveDuplicates.ts
-function arrRemoveDuplicates(array) {
-  return Array.from(new Set(array));
+// ../decorators/src/assertDescriptorValueIsFunction.ts
+function assertDescriptorValueIsFunction(key, descriptor) {
+  if (!(typeof descriptor.value === "function" && descriptor.value !== Function.prototype)) {
+    throw new TypeError(`"value" not a function for ${key} with descriptor: ${JSON.stringify(descriptor)}.`);
+  }
 }
-__name(arrRemoveDuplicates, "arrRemoveDuplicates");
+__name(assertDescriptorValueIsFunction, "assertDescriptorValueIsFunction");
 
 // ../object/src/entriesOf.ts
 function entriesOf(obj) {
@@ -68,10 +70,32 @@ function filterObject(obj, predicate) {
 }
 __name(filterObject, "filterObject");
 
+// ../object/src/objSortKeys.ts
+function objSortKeys(o, compare) {
+  const entries = Object.entries(o);
+  if (compare) {
+    entries.sort(compare);
+  } else {
+    entries.sort((a, b) => {
+      return a[0].localeCompare(b[0]);
+    });
+  }
+  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) {
   let value = map.get(key);
-  if (value !== void 0 || map.has(key)) return value;
+  if (value !== void 0 || map.has(key)) {
+    return value;
+  }
   value = factory(key, map);
   map.set(key, value);
   return value;
@@ -98,7 +122,9 @@ var TimeoutWeakMap = class {
    */
   get(key) {
     const vt = this.wmap.get(key);
-    if (!vt) return void 0;
+    if (!vt) {
+      return void 0;
+    }
     const [value, timeout] = vt;
     timeout.refresh();
     return value;
@@ -128,7 +154,9 @@ var TimeoutWeakMap = class {
    */
   delete(key) {
     const vt = this.wmap.get(key);
-    if (!vt) return false;
+    if (!vt) {
+      return false;
+    }
     const timeout = vt[1];
     clearTimeout(timeout);
     return this.wmap.delete(key);
@@ -189,150 +217,8 @@ var TimeoutWeakMap = class {
   }
 };
 
-// ../object/src/objSortKeys.ts
-function objSortKeys(o, compare) {
-  const entries = Object.entries(o);
-  if (compare) entries.sort(compare);
-  else entries.sort((a, b) => a[0].localeCompare(b[0]));
-  return Object.fromEntries(entries);
-}
-__name(objSortKeys, "objSortKeys");
-
-// ../object/src/valuesOf.ts
-function valuesOf(obj) {
-  return Object.values(obj);
-}
-__name(valuesOf, "valuesOf");
-
-// ../fn/src/setName.ts
-function setName(name, target) {
-  return defineValue(target, "name", typeof name === "string" ? name : name.name, { enumerable: false });
-}
-__name(setName, "setName");
-
-// 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") continue;
-    const def = options.find((o) => o.name === token.name);
-    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") {
-      const positionalToken = parsed.tokens[j];
-      values.push(positionalToken.value);
-      const posIndex = parsed.positionals.indexOf(positionalToken.value);
-      if (posIndex !== -1) parsed.positionals.splice(posIndex, 1);
-      j++;
-    }
-    Reflect.set(
-      parsed.values,
-      token.name,
-      values.filter((v) => v !== void 0)
-    );
-  }
-}
-__name(collectVariadicOptionValues, "collectVariadicOptionValues");
-
-// src/lib/internal/mergeOptionDefaults.ts
-function mergeOptionDefaults(values, options) {
-  for (const option of options) {
-    if (option.defaultValue !== void 0 && option.name in values) {
-      values[option.name] ??= option.defaultValue;
-    }
-  }
-}
-__name(mergeOptionDefaults, "mergeOptionDefaults");
-
-// src/lib/internal/normalizeArgv.ts
-function normalizeArgv(argv, options) {
-  for (const o of options) {
-    if (o.long === o.name) continue;
-    argv = argv.map((a) => {
-      if (a === `--${o.long}`) return `--${o.name}`;
-      if (a === `--no-${o.long}`) return `--no-${o.name}`;
-      return a;
-    });
-  }
-  return argv;
-}
-__name(normalizeArgv, "normalizeArgv");
-
-// src/lib/internal/resolveArguments.ts
-function resolveArguments(positionals, args) {
-  const result = args.map((arg, index) => {
-    if (arg.variadic) {
-      const remaining = positionals.slice(index);
-      return remaining.length > 0 ? remaining : arg.defaultValue;
-    }
-    return positionals[index] ?? arg.defaultValue;
-  });
-  while (result.length && arrLast(result) === void 0) result.pop();
-  return result;
-}
-__name(resolveArguments, "resolveArguments");
-
-// 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) => def.choices.includes(v))) {
-        return `Invalid argument [${index}] ${def.usage}: Got \`${value}\`. Accepted values: [${def.choices.map((c) => `\`${c}\``).join(",")}]`;
-      }
-    }
-  }).concat(
-    entriesOf(optionValues).map(([key, value]) => {
-      const def = optionDefs.find((o) => o.name === key);
-      if (!def) return `Unknown option --${key}`;
-      if (def.choices && value !== void 0) {
-        if (!(def.variadic ? value : [value]).every((v) => def.choices.includes(v))) {
-          return `Invalid option value ${def.flags}: Got \`${value}\`. Accepted values: [${def.choices.map((c) => `\`${c}\``).join(",")}]`;
-        }
-      }
-    })
-  ).filter((s) => s !== void 0).reduce(
-    (acc, curr) => {
-      return (acc ?? []).concat(curr);
-    },
-    void 0
-  );
-}
-__name(validateParsed, "validateParsed");
-
-// ../string/src/lib/strFirstCharToUpperCase.ts
-function strFirstCharToUpperCase(string) {
-  return string.charAt(0).toUpperCase() + string.substring(1);
-}
-__name(strFirstCharToUpperCase, "strFirstCharToUpperCase");
-
-// src/lib/Command.ts
-import colors3 from "ansi-colors";
-import { inspect, parseArgs } from "node:util";
-
-// src/lib/Help.ts
-var Help_exports = {};
-__export(Help_exports, {
-  Help: () => Help
-});
-
-// ../decorators/src/assertDescriptorValueIsFunction.ts
-function assertDescriptorValueIsFunction(key, descriptor) {
-  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");
-
 // ../decorators/src/lazyProp.ts
 import { isFunction } from "es-toolkit/predicate";
-import { ms as ms2 } from "enhanced-ms";
 
 // ../decorators/src/memoizeSync.ts
 import memoizee from "memoizee";
@@ -340,7 +226,9 @@ import { ms } from "enhanced-ms";
 function memoizeSync(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");
+    if (!descriptor) {
+      throw new TypeError("descriptor is undefined");
+    }
     const orig = descriptor.value;
     assertDescriptorValueIsFunction(key, descriptor);
     const options = { length: false, ...opts };
@@ -350,7 +238,9 @@ function memoizeSync(arg = {}) {
     } else {
       const wmap = /* @__PURE__ */ new WeakMap();
       descriptor.value = function(...args) {
-        const memoized = mapGetOrDefault(wmap, this, () => memoizee(orig, options));
+        const memoized = mapGetOrDefault(wmap, this, () => {
+          return memoizee(orig, options);
+        });
         return memoized.apply(this, args);
       };
     }
@@ -360,6 +250,7 @@ function memoizeSync(arg = {}) {
 __name(memoizeSync, "memoizeSync");
 
 // ../decorators/src/lazyProp.ts
+import { ms as ms2 } from "enhanced-ms";
 function lazyProp(targetOrTimeout, key, descriptor) {
   if (typeof targetOrTimeout === "number" || typeof targetOrTimeout === "string") {
     const maxAge = typeof targetOrTimeout === "number" ? targetOrTimeout : ms2(targetOrTimeout);
@@ -375,7 +266,9 @@ function createLazyPropDecorator(map) {
     const { get, value } = descriptor;
     if (isFunction(get)) {
       descriptor.get = function() {
-        return mapGetOrDefault(map, this, () => get.call(this));
+        return mapGetOrDefault(map, this, () => {
+          return get.call(this);
+        });
       };
       return descriptor;
     }
@@ -388,7 +281,6 @@ function createLazyPropDecorator(map) {
 __name(createLazyPropDecorator, "createLazyPropDecorator");
 
 // src/lib/Help.ts
-import C from "ansi-colors";
 var Help = class {
   static {
     __name(this, "Help");
@@ -406,7 +298,9 @@ var Help = class {
     Object.defineProperty(this, "cmd", { enumerable: false });
   }
   visibleCommands() {
-    const res = Object.values(this.cmd.commands).filter((c) => !c.hidden);
+    const res = Object.values(this.cmd.commands).filter((c) => {
+      return !c.hidden;
+    });
     if (this.sortSubcommands) {
       res.sort((a, b) => {
         return a.name.localeCompare(b.name);
@@ -424,12 +318,18 @@ var Help = class {
     return getSortKey(a).localeCompare(getSortKey(b));
   }
   visibleOptions() {
-    const res = this.cmd.options.filter((option) => !option.hidden);
-    if (this.sortOptions) res.sort(this.compareOptions);
+    const res = this.cmd.options.filter((option) => {
+      return !option.hidden;
+    });
+    if (this.sortOptions) {
+      res.sort(this.compareOptions);
+    }
     return res;
   }
   visibleArguments() {
-    if (this.cmd.arguments.find((argument) => !!argument.description)) {
+    if (this.cmd.arguments.find((argument) => {
+      return !!argument.description;
+    })) {
       return [...this.cmd.arguments];
     }
     return [];
@@ -438,9 +338,11 @@ var Help = class {
    * Get the command term to show in the list of subcommands.
    */
   subcommandTerm(sub) {
-    const args = sub.arguments.map((arg) => 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.
@@ -455,7 +357,12 @@ var Help = class {
     return argument.name;
   }
   longestSubcommandAliasLength() {
-    return Math.max(0, ...this.visibleCommands().map((c) => c.aliases[0]?.length || 0));
+    return Math.max(
+      0,
+      ...this.visibleCommands().map((c) => {
+        return c.aliases[0]?.length || 0;
+      })
+    );
   }
   longestSubcommandTermLength() {
     return this.visibleCommands().reduce((max, command) => {
@@ -478,15 +385,15 @@ var Help = class {
   commandUsage() {
     let path = "";
     for (let ancestor = this.cmd.parent; ancestor; ancestor = ancestor.parent) {
-      path = ancestor.name + " " + path;
+      path = `${ancestor.name} ${path}`;
     }
-    return (path + this.cmd.name + " " + [
+    return `${path + this.cmd.name} ${[
       ...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();
+    ].join(" ")}`.trim();
   }
   /**
    * Get the description for the command.
@@ -515,7 +422,9 @@ var Help = class {
     if (option.choices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${option.choices.map((choice) => String(choice)).join(", ")}`
+        `choices: ${option.choices.map((choice) => {
+          return String(choice);
+        }).join(", ")}`
       );
     }
     if (option.defaultValue && !(Array.isArray(option.defaultValue) && option.defaultValue.length === 0)) {
@@ -541,7 +450,9 @@ var Help = class {
     if (argument.choices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${argument.choices.map((choice) => String(choice)).join(", ")}`
+        `choices: ${argument.choices.map((choice) => {
+          return String(choice);
+        }).join(", ")}`
       );
     }
     if (argument.defaultValue !== void 0) {
@@ -560,7 +471,9 @@ var Help = class {
    * Format a list of items, given a heading and an array of formatted items.
    */
   formatItemList(heading, items) {
-    if (items.length === 0) return [];
+    if (items.length === 0) {
+      return [];
+    }
     return [this.styleTitle(heading), ...items, ""];
   }
   /**
@@ -570,7 +483,9 @@ var Help = class {
     const result = /* @__PURE__ */ new Map();
     unsortedItems.forEach((item) => {
       const group = getGroup(item);
-      if (!result.has(group)) result.set(group, []);
+      if (!result.has(group)) {
+        result.set(group, []);
+      }
     });
     visibleItems.forEach((item) => {
       const group = getGroup(item);
@@ -599,11 +514,21 @@ var Help = class {
    */
   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);
+      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(" ");
   }
@@ -648,8 +573,12 @@ var Help = class {
    */
   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);
+      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("|");
@@ -712,7 +641,9 @@ var Help = class {
   formatItem(term, termWidth, description) {
     const itemIndent = 2;
     const itemIndentStr = " ".repeat(itemIndent);
-    if (!description) return itemIndentStr + term;
+    if (!description) {
+      return itemIndentStr + term;
+    }
     const paddedTerm = term.padEnd(termWidth + term.length - this.displayWidth(term));
     const spacerWidth = 2;
     const helpWidth = this.helpWidth;
@@ -722,7 +653,8 @@ var Help = class {
       formattedDescription = description;
     } else {
       const wrappedDescription = this.boxWrap(description, remainingWidth);
-      formattedDescription = wrappedDescription.replace(/\n/g, "\n" + " ".repeat(termWidth + spacerWidth));
+      formattedDescription = wrappedDescription.replace(/\n/g, `
+${" ".repeat(termWidth + spacerWidth)}`);
     }
     return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
 ${itemIndentStr}`);
@@ -732,7 +664,9 @@ ${itemIndentStr}`);
    * Wrapping is skipped if the width is less than `minWidthToWrap`.
    */
   boxWrap(str, width) {
-    if (width < this.minWidthToWrap) return str;
+    if (width < this.minWidthToWrap) {
+      return str;
+    }
     const rawLines = str.split(/\r\n|\n/);
     const chunkPattern = /[\s]*[^\s]+/g;
     const wrappedLines = [];
@@ -777,11 +711,9 @@ ${itemIndentStr}`);
       );
     });
     output = output.concat(this.formatItemList("Arguments:", argumentList));
-    const optionGroups = this.groupItems(
-      this.cmd.options,
-      this.visibleOptions(),
-      (option) => option.group ?? "Options:"
-    );
+    const optionGroups = this.groupItems(this.cmd.options, this.visibleOptions(), (option) => {
+      return option.group ?? "Options:";
+    });
     optionGroups.forEach((options, group) => {
       const optionList = options.map((option) => {
         return this.formatItem(
@@ -795,7 +727,9 @@ ${itemIndentStr}`);
     const commandGroups = this.groupItems(
       Object.values(this.cmd.commands),
       this.visibleCommands(),
-      (sub) => sub.group || "Commands:"
+      (sub) => {
+        return sub.group || "Commands:";
+      }
     );
     commandGroups.forEach((commands, group) => {
       const commandList = commands.map((sub) => {
@@ -835,16 +769,87 @@ __decorateClass([
   lazyProp
 ], Help.prototype, "padWidth", 1);
 
+// ../array/src/arrLast.ts
+function arrLast(array) {
+  if (!array.length) {
+    throw new Error("Cannot get last element of empty array.");
+  }
+  return array[array.length - 1];
+}
+__name(arrLast, "arrLast");
+
+// ../array/src/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") {
+      continue;
+    }
+    const def = options.find((o) => {
+      return o.name === token.name;
+    });
+    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") {
+      const positionalToken = parsed.tokens[j];
+      values.push(positionalToken.value);
+      const posIndex = parsed.positionals.indexOf(positionalToken.value);
+      if (posIndex !== -1) {
+        parsed.positionals.splice(posIndex, 1);
+      }
+      j++;
+    }
+    Reflect.set(
+      parsed.values,
+      token.name,
+      values.filter((v) => {
+        return v !== void 0;
+      })
+    );
+  }
+}
+__name(collectVariadicOptionValues, "collectVariadicOptionValues");
+
+// src/lib/Command.ts
+import colors3 from "ansi-colors";
+
 // 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) => 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;
+  });
+}
+__name(findOption, "findOption");
+
 // src/lib/helpers/getCommandAncestors.ts
 var getCommandAncestors_exports = {};
 __export(getCommandAncestors_exports, {
@@ -872,9 +877,98 @@ function getCommandAncestors(cmd) {
 }
 __name(getCommandAncestors, "getCommandAncestors");
 
+// src/lib/Command.ts
+import { inspect } from "node:util";
+import { kebabCase } from "es-toolkit/string";
+
+// src/lib/internal/mergeOptionDefaults.ts
+function mergeOptionDefaults(values, options) {
+  for (const option of options) {
+    if (option.defaultValue !== void 0 && option.name in values) {
+      values[option.name] ??= option.defaultValue;
+    }
+  }
+}
+__name(mergeOptionDefaults, "mergeOptionDefaults");
+
+// src/lib/internal/normalizeArgv.ts
+function normalizeArgv(argv, options) {
+  for (const o of options) {
+    if (o.long === o.name) {
+      continue;
+    }
+    argv = argv.map((a) => {
+      if (a === `--${o.long}`) {
+        return `--${o.name}`;
+      }
+      if (a === `--no-${o.long}`) {
+        return `--no-${o.name}`;
+      }
+      return a;
+    });
+  }
+  return argv;
+}
+__name(normalizeArgv, "normalizeArgv");
+
+// src/lib/Command.ts
+import { parseArgs } from "node:util";
+
+// 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) {
+    throw new Error(`Invalid option format: ${flags}`);
+  }
+  const short = match[1];
+  if (short.length !== 1) {
+    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) => {
+    return str + word[0].toUpperCase() + word.slice(1);
+  });
+  return { short, long, name, argName };
+}
+__name(parseOptionFlags, "parseOptionFlags");
+
+// src/lib/internal/resolveArguments.ts
+function resolveArguments(positionals, args) {
+  const result = args.map((arg, index) => {
+    if (arg.variadic) {
+      const remaining = positionals.slice(index);
+      return remaining.length > 0 ? remaining : arg.defaultValue;
+    }
+    return positionals[index] ?? arg.defaultValue;
+  });
+  while (result.length && arrLast(result) === void 0) {
+    result.pop();
+  }
+  return result;
+}
+__name(resolveArguments, "resolveArguments");
+
+// ../fn/src/setName.ts
+function setName(name, target) {
+  return defineValue(target, "name", typeof name === "string" ? name : name.name, { enumerable: false });
+}
+__name(setName, "setName");
+
+// ../string/src/lib/strFirstCharToUpperCase.ts
+function strFirstCharToUpperCase(string) {
+  return string.charAt(0).toUpperCase() + string.substring(1);
+}
+__name(strFirstCharToUpperCase, "strFirstCharToUpperCase");
+
 // ../node/src/createLogger.ts
 import colors from "ansi-colors";
-import { isPrimitive, isString } from "es-toolkit/predicate";
+import { isPrimitive } from "es-toolkit/predicate";
+import { isString } from "es-toolkit/predicate";
 function createLogger(name) {
   const NAME = name ? colors.dim.cyan(name) : name;
   const START = [NAME, colors.dim.gray("[START]")].filter(Boolean);
@@ -887,13 +981,29 @@ function createLogger(name) {
   const cyanArgs = createColoredArgs(colors.cyan);
   const yellowArgs = createColoredArgs(colors.yellow);
   return {
-    start: /* @__PURE__ */ __name((...args) => console.info(...START, ...args), "start"),
-    done: /* @__PURE__ */ __name((...args) => console.info(...DONE, ...args), "done"),
-    info: /* @__PURE__ */ __name((...args) => console.info(...INFO, ...grayArgs(args)), "info"),
-    log: /* @__PURE__ */ __name((...args) => console.log(...NAME ? [NAME, ...args] : args), "log"),
-    warn: /* @__PURE__ */ __name((...args) => console.warn(...WARN, ...yellowArgs(args)), "warn"),
-    debug: /* @__PURE__ */ __name((...args) => console.debug(...DEBUG, ...cyanArgs(args)), "debug"),
-    error: /* @__PURE__ */ __name((...args) => args.forEach((arg) => console.error(...ERROR, arg)), "error")
+    start: /* @__PURE__ */ __name((...args) => {
+      return console.info(...START, ...args);
+    }, "start"),
+    done: /* @__PURE__ */ __name((...args) => {
+      return console.info(...DONE, ...args);
+    }, "done"),
+    info: /* @__PURE__ */ __name((...args) => {
+      return console.info(...INFO, ...grayArgs(args));
+    }, "info"),
+    log: /* @__PURE__ */ __name((...args) => {
+      return console.log(...NAME ? [NAME, ...args] : args);
+    }, "log"),
+    warn: /* @__PURE__ */ __name((...args) => {
+      return console.warn(...WARN, ...yellowArgs(args));
+    }, "warn"),
+    debug: /* @__PURE__ */ __name((...args) => {
+      return console.debug(...DEBUG, ...cyanArgs(args));
+    }, "debug"),
+    error: /* @__PURE__ */ __name((...args) => {
+      return args.forEach((arg) => {
+        return console.error(...ERROR, arg);
+      });
+    }, "error")
   };
 }
 __name(createLogger, "createLogger");
@@ -917,9 +1027,9 @@ function createColoredArgs(colorFn) {
 __name(createColoredArgs, "createColoredArgs");
 
 // ../node/src/timer.ts
-import { isPromise } from "node:util/types";
 import colors2 from "ansi-colors";
 import humanizeDuration from "humanize-duration";
+import { isPromise } from "node:util/types";
 function timer(arg, task) {
   const t0 = process.hrtime.bigint();
   const [name, description] = Array.isArray(arg) ? arg : [arg, ""];
@@ -935,7 +1045,9 @@ function timer(arg, task) {
     return done(result);
   });
   function done(retval2) {
-    if (process.exitCode) return retval2;
+    if (process.exitCode) {
+      return retval2;
+    }
     const ns = process.hrtime.bigint() - t0;
     const ms3 = Math.floor(Number(ns) / 1e6);
     log.done(colors2.dim(humanizeDuration(ms3)));
@@ -945,68 +1057,83 @@ function timer(arg, task) {
 }
 __name(timer, "timer");
 
-// src/lib/helpers/findOption.ts
-var findOption_exports = {};
-__export(findOption_exports, {
-  findOption: () => findOption
-});
-function findOption(cmd, nameOrShortOrLong) {
-  return nameOrShortOrLong.startsWith("--") ? cmd.options.find((o) => o.long === nameOrShortOrLong.slice(2)) : nameOrShortOrLong.startsWith("-") ? cmd.options.find((o) => o.short === nameOrShortOrLong.slice(1)) : cmd.options.find((o) => o.name === nameOrShortOrLong);
-}
-__name(findOption, "findOption");
-
-// 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) throw new Error(`Invalid option format: ${flags}`);
-  const short = match[1];
-  if (short.length !== 1) {
-    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) => {
-    return str + word[0].toUpperCase() + word.slice(1);
-  });
-  return { short, long, name, argName };
+// 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}`;
+      }
+      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(parseOptionFlags, "parseOptionFlags");
+__name(validateParsed, "validateParsed");
 
 // src/lib/Command.ts
-import { kebabCase } from "es-toolkit/string";
 var _Command = class _Command {
   static {
     __name(this, "Command");
   }
-  /** Parent command in the hierarchy, undefined for root command */
+  /** parent command in the hierarchy, undefined for root command */
   parent;
-  /** The command name used to invoke it */
+  /** the command name used to invoke it */
   name;
-  /** Semantic version string displayed by --version flag */
+  /** semantic version string displayed by --version flag */
   version;
-  /** Alternative names for invoking this command */
+  /** alternative names for invoking this command */
   aliases;
-  /** Brief one-line description shown in command lists */
+  /** brief one-line description shown in command lists */
   summary;
-  /** Full description displayed in help text */
+  /** full description displayed in help text */
   description;
-  /** Whether to exclude from help listings */
+  /** whether to exclude from help listings */
   hidden;
-  /** Category for organizing related commands in help output */
+  /** category for organizing related commands in help output */
   group;
-  /** Positional arguments this command accepts */
+  /** positional arguments this command accepts */
   arguments;
-  /** CLI options (flags) this command recognizes */
+  /** cLI options (flags) this command recognizes */
   options;
-  /** Subcommands registered with this command */
+  /** subcommands registered with this command */
   commands;
-  /** Main action handler executed when command is invoked */
+  /** main action handler executed when command is invoked */
   action;
-  /** Option-driven actions (e.g., --help, --version) executed when their conditions match */
+  /** option-driven actions (e.g., --help, --version) executed when their conditions match */
   hooks;
   constructor(name, parent) {
     this.name = name;
@@ -1031,31 +1158,35 @@ var _Command = class _Command {
   get help() {
     return new Help(this);
   }
-  /** Configure how the help is rendered */
+  /** configure how the help is rendered */
   helpConfiguration(cb) {
     const help = this.help;
     cb?.(help);
     return this;
   }
-  /** Renders formatted help text using provided help definition */
+  /** renders formatted help text using provided help definition */
   renderHelp(config = {}) {
     const result = this.help.render();
     return config.noColor ? colors3.stripColor(result) : result;
   }
-  /** Sets the command name */
+  /** sets the command name */
   setName(name) {
     this.name = name;
   }
-  /** Sets command aliases, flattening nested arrays */
+  /** sets command aliases, flattening nested arrays */
   setAliases(...aliases) {
     this.aliases = [];
     this.addAliases(...aliases);
     return this;
   }
-  /** Adds aliases to existing ones */
+  /** adds aliases to existing ones */
   addAliases(...aliases) {
-    const taken = this.parent ? valuesOf(this.parent.commands).flatMap((c) => [c.name, ...c.aliases]) : [];
-    arrRemoveDuplicates(aliases.flat()).filter((a) => !this.aliases.includes(a) && a !== this.name).forEach((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}`
@@ -1063,39 +1194,47 @@ var _Command = class _Command {
       }
       this.aliases.push(a);
     });
-    this.aliases.sort((a, b) => a.length - b.length);
+    this.aliases.sort((a, b) => {
+      return a.length - b.length;
+    });
     return this;
   }
-  /** Sets the command version */
+  /** sets the command version */
   setVersion(version) {
     this.version = version;
-    if (findOption(this, "version")) return this;
+    if (findOption(this, "version")) {
+      return this;
+    }
     return this.addOption("-V, --version", { description: "Display semver version" }).addOptionHook("version", ({ cmd }) => {
-      console.log(getCommandAndAncestors(cmd).find((c) => c.version)?.version);
+      console.log(
+        getCommandAndAncestors(cmd).find((c) => {
+          return c.version;
+        })?.version
+      );
       process.exitCode = 0;
     });
   }
-  /** Sets the command summary */
+  /** sets the command summary */
   setSummary(summary) {
     this.summary = summary;
     return this;
   }
-  /** Sets command description, joining variadic lines */
+  /** sets command description, joining variadic lines */
   setDescription(...lines) {
     this.description = lines.join("\n");
     return this;
   }
-  /** Sets whether command is hidden from help */
+  /** sets whether command is hidden from help */
   setHidden(hidden = true) {
     this.hidden = hidden;
     return this;
   }
-  /** Sets the command group for help organization */
+  /** sets the command group for help organization */
   setGroup(group) {
     this.group = group;
     return this;
   }
-  /** Add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+  /** 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) {
@@ -1106,21 +1245,33 @@ var _Command = class _Command {
     const sub = this.createSubcommand(name);
     const inherit = this.options;
     sub.options.push(...inherit);
-    const inheritHooks = this.hooks.filter((t) => inherit.some((i) => i.name === t.name));
+    const inheritHooks = this.hooks.filter((t) => {
+      return inherit.some((i) => {
+        return i.name === t.name;
+      });
+    });
     sub.hooks.push(...inheritHooks);
-    const taken = valuesOf(this.commands).flatMap((c) => [c.name, ...c.aliases]);
+    const taken = valuesOf(this.commands).flatMap((c) => {
+      return [c.name, ...c.aliases];
+    });
     if (taken.includes(name)) {
       throw new Error(
-        `Command name "${getCommandAndAncestors(sub).map((c) => c.name)}" is already used by this command or its aliases: ${taken.join(", ")}`
+        `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) => s[0]).join("");
+    const initials = words.map((s) => {
+      return s[0];
+    }).join("");
     if (!taken.includes(initials)) {
       sub.addAliases(initials);
     } else {
-      const initials2 = words.map((s) => s[0] + s[1]).join("");
+      const initials2 = words.map((s) => {
+        return s[0] + s[1];
+      }).join("");
       if (!taken.includes(initials2)) {
         sub.addAliases(initials2);
       }
@@ -1128,13 +1279,13 @@ var _Command = class _Command {
     this.commands[name] = sub;
     return cb ? cb(sub, this) : sub;
   }
-  /** Add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+  /** 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;
   }
-  // Implementation
+  // implementation
   addArgument(usage, options = {}) {
     if (!/^<(.*?)>$|^\[(.*?)\]$/.test(usage)) {
       throw new Error(`Invalid argument format: ${usage}`);
@@ -1168,7 +1319,7 @@ 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 = {};
@@ -1206,7 +1357,9 @@ var _Command = class _Command {
       }
     }
     for (const [key, value] of Object.entries(opts)) {
-      if (value !== void 0) Reflect.set(ins, key, value);
+      if (value !== void 0) {
+        Reflect.set(ins, key, value);
+      }
     }
     if (ins.env && ins.defaultValue === void 0 && typeof process.env[ins.env] === "string") {
       ins.required = false;
@@ -1214,7 +1367,9 @@ var _Command = class _Command {
       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) => v.trim());
+        ins.defaultValue = process.env[ins.env].replace(/\]|\[/, "").split(",").map((v) => {
+          return v.trim();
+        });
       } else {
         ins.defaultValue = process.env[ins.env];
       }
@@ -1223,7 +1378,7 @@ var _Command = class _Command {
     return this;
   }
   /**
-   * Register an action to be invoked when an option is set to true or string value.
+   * 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`
@@ -1236,25 +1391,26 @@ var _Command = class _Command {
     }
     this.hooks.push({
       name: optionName,
-      predicate: setName("has" + strFirstCharToUpperCase(optionName), ({ opts }) => {
+      predicate: setName(`has${strFirstCharToUpperCase(optionName)}`, ({ opts }) => {
         return opts[optionName] !== void 0 && opts[optionName] !== false && !(Array.isArray(opts[optionName]) && opts[optionName].length === 0);
       }),
       action: setName(optionName, action)
     });
     return this;
   }
-  /** Parses command-line arguments with subcommand support and type-safe validation. */
+  /** parses command-line arguments with subcommand support and type-safe validation. */
   parseArgv(argv = process.argv.slice(2)) {
     const sub = findCommand(this, argv[0]);
-    if (sub) return sub.parseArgv(argv.slice(1));
+    if (sub) {
+      return sub.parseArgv(argv.slice(1));
+    }
     argv = normalizeArgv(argv, this.options);
     const parsed = parseArgs({
       args: argv,
       options: Object.fromEntries(
-        this.options.map((o) => [
-          o.name,
-          { type: o.type, short: o.short, default: o.defaultValue, multiple: !!o.variadic }
-        ])
+        this.options.map((o) => {
+          return [o.name, { type: o.type, short: o.short, default: o.defaultValue, multiple: !!o.variadic }];
+        })
       ),
       allowPositionals: true,
       tokens: true,
@@ -1267,9 +1423,13 @@ var _Command = class _Command {
       return a[1] === false ? 1 : b[1] === false ? -1 : a[1] === true ? 1 : b[1] === true ? -1 : 0;
     });
     const args = resolveArguments(parsed.positionals, this.arguments);
-    const opts = filterObject(parsed.values, (value) => value !== void 0);
+    const opts = filterObject(parsed.values, (value) => {
+      return value !== void 0;
+    });
     const errors = validateParsed(args, parsed.values, this.arguments, this.options);
-    const path = getCommandAncestors(this).map((c) => c.name);
+    const path = getCommandAncestors(this).map((c) => {
+      return c.name;
+    });
     const data = {
       path,
       name: this.name,
@@ -1279,18 +1439,23 @@ var _Command = class _Command {
       errors,
       cmd: this
     };
-    const hooks = this.hooks.filter((t) => t.predicate(data));
+    const hooks = this.hooks.filter((t) => {
+      return t.predicate(data);
+    });
     const execute = /* @__PURE__ */ __name(async () => {
       for (const hook of hooks) {
         await hook.action(data);
-        if (process.exitCode) {
+        if (process.exitCode !== void 0) {
           return;
         }
       }
       await timer([[...path, this.name].join(" "), this.description], async (logger) => {
         if (errors) {
-          errors.forEach((msg) => logger.error(colors3.red(msg)));
+          errors.forEach((msg) => {
+            return logger.error(colors3.red(msg));
+          });
           process.exitCode = 1;
+          return;
         }
         if (this.action) {
           return await this.action(...args, opts, {
@@ -1307,14 +1472,14 @@ var _Command = class _Command {
     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.
+   * 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;
   }
-  /** Returns a new Command instance. Override this method in subclasses. */
+  /** returns a new Command instance. Override this method in subclasses. */
   createSubcommand(name) {
     return new _Command(name, this);
   }