@alcyone-labs/arg-parser 1.0.0 → 1.1.0

package/dist/index.min.mjs

@@ -1,43 +1,51 @@
-var ae = (g) => {
+var Ve = (g) => {
   throw TypeError(g);
 };
-var Q = (g, e, n) => e.has(g) || ae("Cannot " + n);
-var t = (g, e, n) => (Q(g, e, "read from private field"), n ? n.call(g) : e.get(g)), N = (g, e, n) => e.has(g) ? ae("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(g) : e.set(g, n), M = (g, e, n, a) => (Q(g, e, "write to private field"), a ? a.call(g, n) : e.set(g, n), n), A = (g, e, n) => (Q(g, e, "access private method"), n);
-import $ from "chalk";
-import { createRegExp as de, anyOf as ue, oneOrMore as me, char as fe } from "magic-regexp";
-import { z as f } from "zod";
-const U = {}, he = f.object({
-  name: f.string().min(1, "Flag name cannot be empty").describe(
+var be = (g, e, n) => e.has(g) || Ve("Cannot " + n);
+var c = (g, e, n) => (be(g, e, "read from private field"), n ? n.call(g) : e.get(g)), _ = (g, e, n) => e.has(g) ? Ve("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(g) : e.set(g, n), H = (g, e, n, s) => (be(g, e, "write to private field"), s ? s.call(g, n) : e.set(g, n), n), $ = (g, e, n) => (be(g, e, "access private method"), n);
+import * as G from "node:fs";
+import * as ce from "node:path";
+import S from "chalk";
+import { createRegExp as st, anyOf as at, oneOrMore as ot, char as it } from "magic-regexp";
+import * as De from "js-yaml";
+import * as He from "@iarna/toml";
+import * as lt from "dotenv";
+import { z as p } from "zod";
+const ct = p.object({
+  name: p.string().min(1, "Flag name cannot be empty").describe(
     "The output property name, used as a return key `{name: value}`. Must be unique."
   ),
-  allowLigature: f.boolean().default(!0).describe(
+  allowLigature: p.boolean().default(!0).describe(
     "Enable both forms of flag input, e.g., `./script.js -f=value` and `-f value`."
   ),
-  allowMultiple: f.boolean().default(!1).describe(
+  allowMultiple: p.boolean().default(!1).describe(
     "Allow passing the same flag multiple times, e.g., `-f val1 -f val2` results in an array."
   ),
-  description: f.union([f.string(), f.array(f.string())]).describe("Textual description for help messages."),
-  options: f.array(f.string().min(1)).min(1, "Flag must have at least one option (e.g., ['-f', '--flag'])").describe("Array of option strings, e.g., ['-f', '--flag']."),
-  defaultValue: f.any().optional().describe("Default value if the flag is not provided."),
-  type: f.union([
-    f.any().refine((g) => g === String, {
+  description: p.union([p.string(), p.array(p.string())]).describe("Textual description for help messages."),
+  options: p.array(p.string().min(1)).min(1, "Flag must have at least one option (e.g., ['-f', '--flag'])").describe("Array of option strings, e.g., ['-f', '--flag']."),
+  defaultValue: p.any().optional().describe("Default value if the flag is not provided."),
+  type: p.union([
+    p.any().refine((g) => g === String, {
       message: "Must be String constructor"
     }),
-    f.any().refine((g) => g === Number, {
+    p.any().refine((g) => g === Number, {
       message: "Must be Number constructor"
     }),
-    f.any().refine((g) => g === Boolean, {
+    p.any().refine((g) => g === Boolean, {
       message: "Must be Boolean constructor"
     }),
-    f.any().refine((g) => g === Array, {
+    p.any().refine((g) => g === Array, {
+      // Native Array constructor
       message: "Must be Array constructor"
     }),
-    f.any().refine((g) => g === Object, {
+    p.any().refine((g) => g === Object, {
+      // Native Object constructor
       message: "Must be Object constructor"
     }),
-    f.function().args(f.string()).returns(f.any()),
-    // Custom parser function
-    f.string().refine(
+    p.function().args(p.string()).returns(p.any()),
+    // Custom parser function (value: string) => any
+    p.string().refine(
+      // String literal types
       (g) => ["boolean", "string", "number", "array", "object"].includes(
         g.toLowerCase()
       ),
@@ -46,75 +54,75 @@ const U = {}, he = f.object({
       }
     )
   ]).default("string").describe(
-    "Expected data type or a custom parser function. Defaults to 'string'."
+    "Expected data type (constructor or string literal) or a custom parser function. Defaults to 'string'."
   ),
-  mandatory: f.union([f.boolean(), f.function().args(f.any()).returns(f.boolean())]).optional().describe(
+  mandatory: p.union([p.boolean(), p.function().args(p.any()).returns(p.boolean())]).optional().describe(
     "Makes the flag mandatory, can be a boolean or a function conditional on other args."
   ),
-  flagOnly: f.boolean().default(!1).describe(
+  flagOnly: p.boolean().default(!1).describe(
     "If true, the flag's presence is noted (true/false), and any subsequent value is not consumed by this flag."
   ),
-  validate: f.function().args(f.any().optional(), f.any().optional()).returns(
-    f.union([
-      f.boolean(),
-      f.string(),
-      f.void(),
-      f.promise(f.union([f.boolean(), f.string(), f.void()]))
+  validate: p.function().args(p.any().optional(), p.any().optional()).returns(
+    p.union([
+      p.boolean(),
+      p.string(),
+      p.void(),
+      p.promise(p.union([p.boolean(), p.string(), p.void()]))
     ])
   ).optional().describe(
     "Custom validation function for the flag's value (receives value, parsedArgs)."
   ),
-  enum: f.array(f.any()).optional().describe("Array of allowed values for the flag.")
+  enum: p.array(p.any()).optional().describe("Array of allowed values for the flag.")
 }).passthrough().transform((g) => {
   const e = { ...g };
   return "default" in e && e.default !== void 0 && !("defaultValue" in e) && (e.defaultValue = e.default), "required" in e && e.required !== void 0 && !("mandatory" in e) && (e.mandatory = e.required), e;
 });
-var L, Z;
-const oe = class oe {
+var J, me;
+const Me = class Me {
   constructor(e = {}, n = []) {
-    N(this, L, /* @__PURE__ */ new Map());
-    N(this, Z);
-    M(this, Z, e.throwForDuplicateFlags ?? !1), this.addFlags(n);
+    _(this, J, /* @__PURE__ */ new Map());
+    _(this, me);
+    H(this, me, e.throwForDuplicateFlags ?? !1), this.addFlags(n);
   }
   static _safeFlag(e) {
-    const n = he.parse(e);
-    let a;
-    const l = n.type;
-    if (typeof l == "string")
-      switch (l.toLowerCase()) {
+    const n = ct.parse(e);
+    let s;
+    const r = n.type;
+    if (typeof r == "string")
+      switch (r.toLowerCase()) {
         case "boolean":
-          a = Boolean;
+          s = Boolean;
           break;
         case "string":
-          a = String;
+          s = String;
           break;
         case "number":
-          a = Number;
+          s = Number;
           break;
         case "array":
-          a = Array;
+          s = Array;
           break;
         case "object":
-          a = Object;
+          s = Object;
           break;
         default:
-          throw new Error(`Invalid type string: ${l}`);
+          throw new Error(`Invalid type string: ${r}`);
       }
     else
-      a = l;
+      s = r;
     return {
       ...n,
       options: n.options,
-      type: a,
+      type: s,
       validate: n.validate,
       enum: n.enum,
       mandatory: n.mandatory
     };
   }
   addFlag(e) {
-    const n = oe._safeFlag(e);
-    if (t(this, L).has(n.name)) {
-      if (t(this, Z))
+    const n = Me._safeFlag(e);
+    if (c(this, J).has(n.name)) {
+      if (c(this, me))
         throw new Error(
           `FlagManager: Flag '${n.name}' already exists.`
         );
@@ -122,10 +130,10 @@ const oe = class oe {
         `Warning: FlagManager: Flag '${n.name}' already exists. Duplicate not added.`
       ), this;
     }
-    return t(this, L).set(n.name, n), this;
+    return c(this, J).set(n.name, n), this;
   }
   _setProcessedFlagForInheritance(e) {
-    return t(this, L).has(e.name) ? this : (t(this, L).set(e.name, e), this);
+    return c(this, J).has(e.name) ? this : (c(this, J).set(e.name, e), this);
   }
   addFlags(e) {
     for (const n of e)
@@ -133,54 +141,55 @@ const oe = class oe {
     return this;
   }
   hasFlag(e) {
-    return t(this, L).has(e);
+    return c(this, J).has(e);
   }
   getFlag(e) {
-    return t(this, L).get(e);
+    return c(this, J).get(e);
   }
   get flags() {
-    return Array.from(t(this, L).values());
+    return Array.from(c(this, J).values());
   }
   get flagNames() {
-    return Array.from(t(this, L).values()).map((e) => e.name);
+    return Array.from(c(this, J).values()).map((e) => e.name);
   }
 };
-L = new WeakMap(), Z = new WeakMap();
-let X = oe;
-class R extends Error {
+J = new WeakMap(), me = new WeakMap();
+let $e = Me;
+class Y extends Error {
   constructor(e, n = []) {
     super(e), this.cmdChain = n, this.name = "ArgParserError", this.commandChain = n;
   }
 }
-var S, k, P, E, D, H, I, T, _, K, B, F, w, y, z, re, ie, Y, le, G, ce, ee, ne, te;
-const W = class W {
+var P, V, R, z, W, ee, L, q, Q, ge, U, T, M, ne, m, oe, Re, Le, we, ze, ue, ve, Se, Ce, Ae, Fe, Ne, We, Je, Be, qe, Ue, Ze, Ge, Ye, Ke, Qe, Xe, et, tt, nt, de;
+const K = class K {
   constructor(e = {}, n) {
-    N(this, y);
-    N(this, S, "Argument Parser");
-    N(this, k);
-    N(this, P, "");
-    N(this, E, {
+    _(this, m);
+    _(this, P, "Argument Parser");
+    _(this, V);
+    _(this, R, "");
+    _(this, z, {
       extraNewLine: !0,
       wrapAtWidth: 50,
       blankSpaceWidth: 30,
       mandatoryCharacter: "*"
     });
-    N(this, D);
-    N(this, H, !1);
-    N(this, I);
-    N(this, T, !0);
-    N(this, _);
-    N(this, K, {});
-    N(this, B, !1);
-    N(this, F, /* @__PURE__ */ new Map());
-    N(this, w);
-    M(this, S, e.appName || "app"), e.blankSpaceWidth && !isNaN(Number(e.blankSpaceWidth)) && Number(e.blankSpaceWidth) > 20 && (t(this, E).blankSpaceWidth = Number(e.blankSpaceWidth)), e.wrapAtWidth && !isNaN(Number(e.wrapAtWidth)) && Number(e.wrapAtWidth) > 30 && (t(this, E).wrapAtWidth = Number(e.wrapAtWidth)), typeof e.extraNewLine == "boolean" && (t(this, E).extraNewLine = !!e.extraNewLine), typeof e.mandatoryCharacter == "string" && (t(this, E).mandatoryCharacter = e.mandatoryCharacter), typeof e.throwForDuplicateFlags == "boolean" && M(this, H, e.throwForDuplicateFlags), M(this, w, new X(
+    _(this, W);
+    _(this, ee, !1);
+    _(this, L);
+    _(this, q, !0);
+    _(this, Q);
+    _(this, ge, {});
+    _(this, U, !1);
+    _(this, T, /* @__PURE__ */ new Map());
+    _(this, M);
+    _(this, ne, !1);
+    H(this, P, e.appName || "app"), e.blankSpaceWidth && !isNaN(Number(e.blankSpaceWidth)) && Number(e.blankSpaceWidth) > 20 && (c(this, z).blankSpaceWidth = Number(e.blankSpaceWidth)), e.wrapAtWidth && !isNaN(Number(e.wrapAtWidth)) && Number(e.wrapAtWidth) > 30 && (c(this, z).wrapAtWidth = Number(e.wrapAtWidth)), typeof e.extraNewLine == "boolean" && (c(this, z).extraNewLine = !!e.extraNewLine), typeof e.mandatoryCharacter == "string" && (c(this, z).mandatoryCharacter = e.mandatoryCharacter), typeof e.throwForDuplicateFlags == "boolean" && H(this, ee, e.throwForDuplicateFlags), H(this, M, new $e(
       {
-        throwForDuplicateFlags: t(this, H)
+        throwForDuplicateFlags: c(this, ee)
       },
       n || []
-    )), M(this, T, e.handleErrors ?? !0), M(this, B, e.inheritParentFlags ?? !1), M(this, I, e.description), M(this, D, e.handler), M(this, k, e.appCommandName);
-    const a = {
+    )), H(this, q, e.handleErrors ?? !0), H(this, U, e.inheritParentFlags ?? !1), H(this, L, e.description), H(this, W, e.handler), H(this, V, e.appCommandName);
+    const s = {
       name: "help",
       description: "Display this help message and exits",
       mandatory: !1,
@@ -191,61 +200,79 @@ const W = class W {
       allowMultiple: !1,
       flagOnly: !0,
       enum: [],
-      validate: (l, i) => !0
+      validate: (r, a) => !0
       // Ensure signature matches Zod schema for .args()
     };
-    if (t(this, w).addFlag(a), e.subCommands)
-      for (const l of e.subCommands)
-        this.addSubCommand(l);
+    if (c(this, M).addFlag(s), e.subCommands)
+      for (const r of e.subCommands)
+        this.addSubCommand(r);
   }
   get flags() {
-    return t(this, w).flags;
+    return c(this, M).flags;
   }
   get flagNames() {
-    return t(this, w).flagNames;
-  }
-  _addToOutput(e, n, a, l) {
-    let i = n;
-    if (e.type === Boolean ? typeof n == "boolean" ? i = n : typeof n == "string" ? i = /(true|yes|1)/i.test(n) : i = new e.type(i) : typeof e.type == "function" ? i = e.type(i) : typeof e.type == "object" && (i = new e.type(i)), e.enum && e.enum.length > 0) {
-      const o = e.enum.map((c) => typeof c == "string" ? `'${c}'` : c).join(", ");
-      if (!e.enum.includes(i))
-        throw new R(
-          `Invalid value '${i}' for flag '${$.yellow(e.name)}'. Allowed values: ${o}`,
+    return c(this, M).flagNames;
+  }
+  getAppName() {
+    return c(this, P);
+  }
+  getAppCommandName() {
+    return c(this, V);
+  }
+  getSubCommandName() {
+    return c(this, R);
+  }
+  getDescription() {
+    return c(this, L);
+  }
+  getHandler() {
+    return c(this, W);
+  }
+  getSubCommands() {
+    return c(this, T);
+  }
+  _addToOutput(e, n, s, r) {
+    let a = n;
+    if (e.type === Boolean ? typeof n == "boolean" ? a = n : typeof n == "string" ? a = /(true|yes|1)/i.test(n) : a = new e.type(a) : typeof e.type == "function" ? a = e.type(a) : typeof e.type == "object" && (a = new e.type(a)), e.enum && e.enum.length > 0) {
+      const t = e.enum.map((i) => typeof i == "string" ? `'${i}'` : i).join(", ");
+      if (!e.enum.includes(a))
+        throw new Y(
+          `Invalid value '${a}' for flag '${S.yellow(e.name)}'. Allowed values: ${t}`,
           this.getCommandChain()
         );
     }
     if (e.validate) {
-      const o = e.validate(i, a);
-      if (o === !1)
-        throw new R(
-          `Validation failed for flag '${$.yellow(e.name)}' with value '${i}'`,
+      const t = e.validate(a, s);
+      if (t === !1)
+        throw new Y(
+          `Validation failed for flag '${S.yellow(e.name)}' with value '${a}'`,
           this.getCommandChain()
         );
-      if (typeof o == "string")
-        throw new R(o, this.getCommandChain());
+      if (typeof t == "string")
+        throw new Y(t, this.getCommandChain());
     }
-    return e.allowMultiple && !Array.isArray(a[e.name]) && (a[e.name] = []), e.allowMultiple ? a[e.name].push(i) : a[e.name] = i;
+    return e.allowMultiple && !Array.isArray(s[e.name]) && (s[e.name] = []), e.allowMultiple ? s[e.name].push(a) : s[e.name] = a;
   }
   addFlags(e) {
-    return t(this, w).addFlags(e), this;
+    return c(this, M).addFlags(e), this;
   }
   addFlag(e) {
-    return t(this, w).addFlag(e), this;
+    return c(this, M).addFlag(e), this;
   }
   addSubCommand(e) {
-    if (t(this, F).has(e.name))
+    if (c(this, T).has(e.name))
       throw new Error(`Sub-command '${e.name}' already exists`);
     const n = e.parser;
-    if (!(n instanceof W))
+    if (!(n instanceof K))
       throw new Error(
-        `Parser for subcommand '${e.name}' is not an instance of ArgParser. Please provide 'new ArgParser(...)' for the 'parser' property of an ISubCommand.`
+        `Parser for subcommand '${e.name}' is not an instance of ArgParserBase. Please provide 'new ArgParserBase(...)' for the 'parser' property of an ISubCommand.`
       );
-    if (M(n, _, this), M(n, P, e.name), !t(n, k) && t(this, k) && M(n, k, t(this, k)), t(n, B)) {
-      const a = t(this, w).flags;
-      for (const l of a)
-        t(n, w).hasFlag(l.name) || t(n, w)._setProcessedFlagForInheritance(l);
+    if (H(n, Q, this), H(n, R, e.name), !c(n, V) && c(this, V) && H(n, V, c(this, V)), c(n, U)) {
+      const s = c(this, M).flags;
+      for (const r of s)
+        c(n, M).hasFlag(r.name) || c(n, M)._setProcessedFlagForInheritance(r);
     }
-    return t(this, F).set(e.name, e), e.handler && n.setHandler(e.handler), this;
+    return c(this, T).set(e.name, e), e.handler && n.setHandler(e.handler), this;
   }
   /**
    * Sets the handler function for this specific parser instance.
@@ -256,21 +283,21 @@ const W = class W {
    * @returns The ArgParser instance for chaining.
    */
   setHandler(e) {
-    return M(this, D, e), this;
+    return H(this, W, e), this;
   }
   printAll(e) {
     if (e)
       try {
-        const n = U.dirname(e);
-        if (U.existsSync(n) || U.mkdirSync(n, { recursive: !0 }), e.toLowerCase().endsWith(".json")) {
-          const a = A(this, y, te).call(this, this), l = JSON.stringify(a, null, 2);
-          U.writeFileSync(e, l), console.log(`ArgParser configuration JSON dumped to: ${e}`);
+        const n = ce.dirname(e);
+        if (G.existsSync(n) || G.mkdirSync(n, { recursive: !0 }), e.toLowerCase().endsWith(".json")) {
+          const s = $(this, m, Fe).call(this, this), r = JSON.stringify(s, null, 2);
+          G.writeFileSync(e, r), console.log(`ArgParser configuration JSON dumped to: ${e}`);
         } else {
-          const l = A(this, y, ne).call(this, this, 0).replace(
+          const r = $(this, m, Ae).call(this, this, 0).replace(
             /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
             ""
           );
-          U.writeFileSync(e, l), console.log(`ArgParser configuration text dumped to: ${e}`);
+          G.writeFileSync(e, r), console.log(`ArgParser configuration text dumped to: ${e}`);
         }
       } catch (n) {
         console.error(
@@ -280,540 +307,1657 @@ const W = class W {
       }
     else
       console.log(`
---- ArgParser Configuration Dump ---`), A(this, y, ee).call(this, this, 0), console.log("--- End Configuration Dump ---\\n");
+--- ArgParser Configuration Dump ---`), $(this, m, Ce).call(this, this, 0), console.log("--- End Configuration Dump ---\\n");
   }
   parse(e, n) {
-    if (A(this, y, re).call(this, e, n))
+    var a;
+    const s = [...e];
+    if (typeof process < "u" && (process.env.ARGPARSER_FUZZY_MODE === "true" || process.argv && process.argv.includes("--s-enable-fuzzy") && !e.includes("--s-enable-fuzzy")) && !(n != null && n.skipHelpHandling))
+      return {
+        _fuzzyModePreventedExecution: !0,
+        _originalInputArgs: s
+      };
+    if ($(this, m, Re).call(this, e, n))
       return {};
     try {
       const {
-        finalParser: a,
-        commandChain: l,
-        parserChain: i
-      } = A(this, y, z).call(this, e, this, [], [this]), { finalArgs: o, handlerToExecute: c } = this._parseRecursive(
+        finalParser: t,
+        commandChain: i,
+        parserChain: o
+      } = $(this, m, oe).call(this, e, this, [], [this]);
+      if ($(a = t, m, We).call(a, e, o))
+        return {};
+      const { finalArgs: l, handlerToExecute: u } = this._parseRecursive(
         e,
         this,
         {},
         [],
-        n
+        n,
+        void 0
       );
-      return l.length > 0 && (o.$commandChain = l), A(this, y, ie).call(this, o, i, l), A(this, y, Y).call(this, o, a), A(this, y, le).call(this, c, o, (n == null ? void 0 : n.skipHandlers) ?? !1), o;
-    } catch (a) {
-      if (a instanceof R) {
-        if (t(this, T))
-          return A(this, y, ce).call(this, a), {};
-        throw a;
+      return i.length > 0 && (l.$commandChain = i), c(this, ne) && (l._originalInputArgs = s), c(this, ne) || $(this, m, Le).call(this, l, o, i), $(this, m, we).call(this, l, t), $(this, m, ze).call(this, u, l, (n == null ? void 0 : n.skipHandlers) ?? !1), l;
+    } catch (t) {
+      if (t instanceof Y) {
+        if (c(this, q))
+          return $(this, m, Se).call(this, t), {};
+        throw t;
       } else
-        throw a;
+        throw t;
     }
   }
   /**
    * Recursive helper for parsing arguments and handling sub-commands.
    * This method assumes the global help check has already been performed in `parse`.
    */
-  _parseRecursive(e, n, a, l, i) {
-    var j, p;
-    let o = -1, c = null;
-    for (let b = 0; b < e.length; b++) {
-      const O = e[b];
-      if (t(n, F).has(O)) {
-        o = b, c = O;
+  _parseRecursive(e, n, s, r, a, t) {
+    var y, j;
+    let i = -1, o = null;
+    for (let A = 0; A < e.length; A++) {
+      const F = e[A];
+      if (c(n, T).has(F)) {
+        i = A, o = F;
         break;
       }
     }
-    const s = o === -1 ? e : e.slice(0, o), { parsedArgs: r, firstUnconsumedIndex: m } = A(j = n, y, G).call(j, s, i);
-    A(p = n, y, Y).call(p, r, n);
-    const u = {
-      ...a,
-      ...r
+    const l = i === -1 ? e : e.slice(0, i), { parsedArgs: u, firstUnconsumedIndex: d } = $(y = n, m, ue).call(y, l, a);
+    $(j = n, m, we).call(j, u, n);
+    const f = {
+      ...s,
+      ...u
     };
-    if (o === -1 || c === null) {
-      if (m < s.length) {
-        const x = s[m];
-        throw new R(
-          `Unknown command: '${$.yellow(x)}'`,
-          l
+    if (i === -1 || o === null) {
+      if (d < l.length) {
+        const N = l[d];
+        throw new Y(
+          `Unknown command: '${S.yellow(N)}'`,
+          r
         );
       }
-      const b = { ...u };
-      l.length > 0 && (b.$commandChain = l);
-      let O;
-      return t(n, D) && (O = {
-        handler: t(n, D),
+      const A = { ...f };
+      r.length > 0 && (A.$commandChain = r);
+      let F;
+      return c(n, W) && (F = {
+        handler: c(n, W),
         context: {
-          args: r,
-          parentArgs: a,
-          commandChain: l,
-          parser: n
+          args: u,
+          parentArgs: s,
+          commandChain: r,
+          parser: n,
+          parentParser: t
         }
-      }), { finalArgs: b, handlerToExecute: O };
+      }), { finalArgs: A, handlerToExecute: F };
     }
-    if (m < s.length) {
-      const b = s[m];
-      throw new R(
-        `Unknown command: '${$.yellow(b)}'`,
-        l
+    if (d < l.length) {
+      const A = l[d];
+      throw new Y(
+        `Unknown command: '${S.yellow(A)}'`,
+        r
       );
     }
-    const d = t(n, F).get(c);
-    if (!d || !(d.parser instanceof W))
-      throw new R(
-        `Internal error: Subcommand '${c}' is misconfigured or its parser is not a valid ArgParser instance.`,
-        l
+    const b = c(n, T).get(o);
+    if (!b || !(b.parser instanceof K))
+      throw new Y(
+        `Internal error: Subcommand '${o}' is misconfigured or its parser is not a valid ArgParser instance.`,
+        r
       );
-    const h = d.parser, C = e.slice(o + 1), v = [...l, c], V = {
-      ...a,
-      ...r
+    const h = b.parser, v = e.slice(i + 1), O = [...r, o], C = {
+      ...s,
+      ...u
     };
     return this._parseRecursive(
-      C,
-      h,
-      V,
       v,
-      i
+      h,
+      C,
+      O,
+      a,
+      n
     );
   }
   helpText() {
-    const e = $.cyan, n = $.green, a = $.white, l = $.red, i = $.dim;
-    let o = t(this, S), c = this;
-    for (; t(c, _); )
-      c = t(c, _);
-    c && (o = t(c, S));
-    const s = t(this, P) ? `${o} ${t(this, P)}` : o;
-    let r = `${e(`${s} Help`)} (${t(this, E).mandatoryCharacter} = Mandatory fields):
+    const e = S.cyan, n = S.green, s = S.white, r = S.red, a = S.dim;
+    let t = c(this, P), i = this;
+    for (; c(i, Q); )
+      i = c(i, Q);
+    i && (t = c(i, P));
+    const o = c(this, R) ? `${t} ${c(this, R)}` : t;
+    let l = `${e(`${o} Help`)} (${c(this, z).mandatoryCharacter} = Mandatory fields):
 
 `;
-    t(this, I) && (r += `${a(t(this, I))}
+    c(this, L) && (l += `${s(c(this, L))}
 
 `);
-    const m = (d = 1) => "  ".repeat(d);
-    t(this, F).size > 0 && (r += `${e("Available sub-commands:")}
-`, r += Array.from(t(this, F).entries()).sort(([d], [h]) => d.localeCompare(h)).map(([d, h]) => {
-      const C = h.parser;
-      if (!(C instanceof W))
-        return `${m()}${n(d.padEnd(20))} [Error: Subcommand '${d}' has an invalid parser configuration]`;
-      let v = `${m()}${n(d.padEnd(20))} ${a(t(C, I) || "")}`;
-      const j = ((C && t(C, w) ? t(C, w).flags : void 0) || []).filter(
-        (b) => b.name !== "help"
+    const u = (f = 1) => "  ".repeat(f);
+    c(this, T).size > 0 && (l += `${e("Available sub-commands:")}
+`, l += Array.from(c(this, T).entries()).sort(([f], [b]) => f.localeCompare(b)).map(([f, b]) => {
+      const h = b.parser;
+      if (!(h instanceof K))
+        return `${u()}${n(f.padEnd(20))} [Error: Subcommand '${f}' has an invalid parser configuration]`;
+      let v = `${u()}${n(f.padEnd(20))} ${s(c(h, L) || "")}`;
+      const C = ((h && c(h, M) ? c(h, M).flags : void 0) || []).filter(
+        (j) => j.name !== "help"
       );
-      j.length > 0 ? (v += `
-${m(2)}${i("Flags:")}`, j.sort(
-        (b, O) => b.name.localeCompare(O.name)
-      ).forEach((b) => {
-        const O = b.options.map((J) => n(J)).join(", "), x = Array.isArray(b.description) ? b.description[0] : b.description;
+      C.length > 0 ? (v += `
+${u(2)}${a("Flags:")}`, C.sort(
+        (j, A) => j.name.localeCompare(A.name)
+      ).forEach((j) => {
+        const A = j.options.map((N) => n(N)).join(", "), F = Array.isArray(j.description) ? j.description[0] : j.description;
         v += `
-${m(3)}${O} - ${i(x)}`;
+${u(3)}${A} - ${a(F)}`;
       })) : v += `
-${m(2)}${i("Flags:")} none`;
-      const p = Array.from(
-        t(C, F).keys()
+${u(2)}${a("Flags:")} none`;
+      const y = Array.from(
+        c(h, T).keys()
       );
-      return p.length > 0 ? v += `
-${m(2)}${i("Sub-commands:")} ${p.join(", ")}` : v += `
-${m(2)}${i("Sub-commands:")} none`, v;
+      return y.length > 0 ? v += `
+${u(2)}${a("Sub-commands:")} ${y.join(", ")}` : v += `
+${u(2)}${a("Sub-commands:")} none`, v;
     }).join(`
 
-`), r += `
-`), r += `
+`), l += `
+`), l += `
 ${e("Flags:")}
 `;
-    const u = t(this, w).flags;
-    return u.length > 0 ? r += u.sort((d, h) => d.name.localeCompare(h.name)).map((d) => {
-      const h = d.options.toSorted((x, J) => x.length - J.length).map((x) => n(x)).join(", "), C = typeof d.mandatory == "function" ? "dynamic" : d.mandatory, v = C === !0 ? ` ${l(t(this, E).mandatoryCharacter)}` : C === "dynamic" ? ` ${i("(conditionally mandatory)")}` : "", V = Array.isArray(d.description) ? d.description : [d.description], j = [];
-      let p = "unknown";
-      typeof d.type == "function" ? (p = d.type.name || "custom function", p === "Boolean" && (p = "boolean"), p === "String" && (p = "string"), p === "Number" && (p = "number"), p === "Array" && (p = "array"), p === "Object" && (p = "object")) : typeof d.type == "string" && (p = d.type), j.push(`Type: ${p}`), d.flagOnly && j.push("Flag only (no value expected)"), d.defaultValue !== void 0 && d.defaultValue !== null && j.push(`Default: ${JSON.stringify(d.defaultValue)}`), d.enum && d.enum.length > 0 && j.push(
-        `Allowed values: ${d.enum.map((x) => `'${x}'`).join(", ")}`
+    const d = c(this, M).flags;
+    return d.length > 0 ? l += d.sort((f, b) => f.name.localeCompare(b.name)).map((f) => {
+      const b = f.options.slice().sort((F, N) => F.length - N.length).map((F) => n(F)).join(", "), h = typeof f.mandatory == "function" ? "dynamic" : f.mandatory, v = h === !0 ? ` ${r(c(this, z).mandatoryCharacter)}` : h === "dynamic" ? ` ${a("(conditionally mandatory)")}` : "", O = Array.isArray(f.description) ? f.description : [f.description], C = [];
+      let y = "unknown";
+      typeof f.type == "function" ? (y = f.type.name || "custom function", y === "Boolean" && (y = "boolean"), y === "String" && (y = "string"), y === "Number" && (y = "number"), y === "Array" && (y = "array"), y === "Object" && (y = "object")) : typeof f.type == "string" && (y = f.type), C.push(`Type: ${y}`), f.flagOnly && C.push("Flag only (no value expected)"), f.defaultValue !== void 0 && f.defaultValue !== null && C.push(`Default: ${JSON.stringify(f.defaultValue)}`), f.enum && f.enum.length > 0 && C.push(
+        `Allowed values: ${f.enum.map((F) => `'${F}'`).join(", ")}`
       );
-      const b = Math.max(
-        ...u.map(
-          (x) => x.options.join(", ").length
+      const j = Math.max(
+        ...d.map(
+          (F) => F.options.join(", ").length
         ),
         0
-      ), O = h.padEnd(b + 5) + v;
+      ), A = b.padEnd(j + 5) + v;
       return `
-${m()}${O}
-${m(2)}${a(V[0])}
-${j.map((x) => `${m(3)}${i(x)}`).join(`
+${u()}${A}
+${u(2)}${s(O[0])}
+${C.map((F) => `${u(3)}${a(F)}`).join(`
 `)}
-${V.slice(1).map((x) => `
-${m(2)}${a(x)}`).join("")}
+${O.slice(1).map((F) => `
+${u(2)}${s(F)}`).join("")}
   `.trim();
     }).join(`
 
-`) : r += `${m()}${i("none")}`, r;
+`) : l += `${u()}${a("none")}`, l;
   }
   getSubCommand(e) {
-    return t(this, F).get(e);
+    return c(this, T).get(e);
   }
   hasFlag(e) {
-    return t(this, w).hasFlag(e);
+    return c(this, M).hasFlag(e);
   }
   getCommandChain() {
     const e = [];
     let n = this;
-    for (; n && t(n, _); )
-      e.unshift(t(n, P)), n = t(n, _);
+    for (; n && c(n, Q); )
+      e.unshift(c(n, R)), n = c(n, Q);
     return e;
   }
   getLastParseResult() {
-    return t(this, K);
+    return c(this, ge);
   }
 };
-S = new WeakMap(), k = new WeakMap(), P = new WeakMap(), E = new WeakMap(), D = new WeakMap(), H = new WeakMap(), I = new WeakMap(), T = new WeakMap(), _ = new WeakMap(), K = new WeakMap(), B = new WeakMap(), F = new WeakMap(), w = new WeakMap(), y = new WeakSet(), z = function(e, n, a, l) {
-  let i = -1, o = null;
-  for (let d = 0; d < e.length; d++) {
-    const h = e[d];
-    if (t(n, F).has(h)) {
-      i = d, o = h;
+P = new WeakMap(), V = new WeakMap(), R = new WeakMap(), z = new WeakMap(), W = new WeakMap(), ee = new WeakMap(), L = new WeakMap(), q = new WeakMap(), Q = new WeakMap(), ge = new WeakMap(), U = new WeakMap(), T = new WeakMap(), M = new WeakMap(), ne = new WeakMap(), m = new WeakSet(), oe = function(e, n, s, r) {
+  let a = -1, t = null;
+  for (let f = 0; f < e.length; f++) {
+    const b = e[f];
+    if (c(n, T).has(b)) {
+      a = f, t = b;
       break;
     }
   }
-  if (i === -1 || o === null)
+  if (a === -1 || t === null)
     return {
       finalParser: n,
-      commandChain: a,
-      parserChain: l,
+      commandChain: s,
+      parserChain: r,
       remainingArgs: e
     };
-  const c = t(n, F).get(o);
-  if (!c || !(c.parser instanceof W))
+  const i = c(n, T).get(t);
+  if (!i || !(i.parser instanceof K))
     throw new Error(
-      `Internal error: Subcommand '${o}' configuration is invalid or parser is missing.`
+      `Internal error: Subcommand '${t}' configuration is invalid or parser is missing.`
     );
-  const s = c.parser, r = e.slice(i + 1), m = [...a, o], u = [...l, s];
-  return A(this, y, z).call(this, r, s, m, u);
-}, re = function(e, n) {
-  var o, c, s, r;
-  if (e.length === 0 && !t(this, _) && !t(this, D))
+  const o = i.parser, l = e.slice(a + 1), u = [...s, t], d = [...r, o];
+  return $(this, m, oe).call(this, l, o, u, d);
+}, Re = function(e, n) {
+  var o, l, u, d, f, b;
+  const s = !c(this, Q) && !!c(this, V);
+  if (e.length === 0 && s && !c(this, W))
     return console.log(this.helpText()), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
-  if (e.includes("--LIB-debug-print"))
+  if (e.includes("--s-debug-print"))
     return this.printAll("ArgParser.full.json"), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
-  const { finalParser: a } = A(this, y, z).call(this, e, this, [], [this]);
-  if (e.includes("--LIB-debug")) {
+  if (e.includes("--s-enable-fuzzy")) {
+    $(this, m, ve).call(this);
+    const h = e.indexOf("--s-enable-fuzzy");
+    e.splice(h, 1);
+  }
+  const r = e.findIndex((h) => h === "--s-with-env");
+  if (r !== -1) {
+    if (r + 1 >= e.length)
+      return console.error(S.red("Error: --s-with-env requires a file path argument")), typeof process == "object" && typeof process.exit == "function" && process.exit(1), !0;
+    const h = e[r + 1];
+    if (!h || h.startsWith("-"))
+      return console.error(S.red("Error: --s-with-env requires a file path argument")), typeof process == "object" && typeof process.exit == "function" && process.exit(1), !0;
+    try {
+      const { finalParser: v, parserChain: O } = $(this, m, oe).call(this, e, this, [], [this]), C = $(o = v, m, Be).call(o, h, O);
+      if (C) {
+        const y = $(l = v, m, Qe).call(l, C, e);
+        e.length = 0, e.push(...y);
+      }
+    } catch (v) {
+      return console.error(S.red(`Error loading environment file: ${v instanceof Error ? v.message : String(v)}`)), typeof process == "object" && typeof process.exit == "function" && process.exit(1), !0;
+    }
+  }
+  const { finalParser: a } = $(this, m, oe).call(this, e, this, [], [this]);
+  if (e.includes("--s-debug")) {
     console.log(
-      $.yellow.bold(`
---- ArgParser --LIB-debug Runtime Context ---`)
+      S.yellow.bold(`
+--- ArgParser --s-debug Runtime Context ---`)
     );
     const {
-      commandChain: m,
-      parserChain: u
-    } = A(this, y, z).call(this, e, this, [], [this]);
+      commandChain: h,
+      parserChain: v
+    } = $(this, m, oe).call(this, e, this, [], [this]);
     console.log(
-      `Identified Command Chain: ${$.cyan(m.join(" -> ") || "(root)")}`
+      `Identified Command Chain: ${S.cyan(h.join(" -> ") || "(root)")}`
     ), console.log(
-      `Identified Final Parser: ${$.cyan(t(a, P) || t(a, S))}`
+      `Identified Final Parser: ${S.cyan(c(a, R) || c(a, P))}`
     );
-    let d = this, h = [...e], C = {};
-    const v = [], V = h.findIndex(
-      (p) => t(d, F).has(p)
-    ), j = V === -1 ? h : h.slice(0, V);
-    v.push({ level: "(root)", argsSlice: j });
+    let O = this, C = [...e], y = {};
+    const j = [], A = C.findIndex(
+      (N) => c(O, T).has(N)
+    ), F = A === -1 ? C : C.slice(0, A);
+    j.push({ level: "(root)", argsSlice: F });
     try {
-      const { parsedArgs: p } = A(o = d, y, G).call(o, j, { skipHelpHandling: !0 });
-      v[0].parsed = p, C = { ...C, ...p };
-    } catch (p) {
-      v[0].error = p.message;
-    }
-    h = V === -1 ? [] : h.slice(V);
-    for (let p = 0; p < m.length; p++) {
-      const b = m[p];
-      if (!t(d, F).has(b)) {
-        v.push({
+      const { parsedArgs: N } = $(u = O, m, ue).call(u, F, { skipHelpHandling: !0 });
+      j[0].parsed = N, y = { ...y, ...N };
+    } catch (N) {
+      j[0].error = N.message;
+    }
+    C = A === -1 ? [] : C.slice(A);
+    for (let N = 0; N < h.length; N++) {
+      const re = h[N];
+      if (!c(O, T).has(re)) {
+        j.push({
           level: "Error",
           argsSlice: [],
-          error: `Could not find sub-command parser for '${b}'`
+          error: `Could not find sub-command parser for '${re}'`
         });
         break;
       }
-      d = (c = t(d, F).get(b)) == null ? void 0 : c.parser, h = h.slice(1);
-      const O = h.findIndex(
-        (q) => t(d, F).has(q)
-      ), x = O === -1 ? h : h.slice(0, O), J = {
-        level: b,
-        argsSlice: x
+      O = (d = c(O, T).get(re)) == null ? void 0 : d.parser, C = C.slice(1);
+      const X = C.findIndex(
+        (E) => c(O, T).has(E)
+      ), pe = X === -1 ? C : C.slice(0, X), k = {
+        level: re,
+        argsSlice: pe
       };
-      v.push(J);
+      j.push(k);
       try {
-        const { parsedArgs: q } = A(s = d, y, G).call(s, x, {
+        const { parsedArgs: E } = $(f = O, m, ue).call(f, pe, {
           skipHelpHandling: !0
         });
-        J.parsed = q, C = { ...C, ...q };
-      } catch (q) {
-        J.error = q.message;
+        k.parsed = E, y = { ...y, ...E };
+      } catch (E) {
+        k.error = E.message;
       }
-      h = O === -1 ? [] : h.slice(O);
-    }
-    return console.log($.yellow(`
-Parsing Simulation Steps:`)), v.forEach((p) => {
-      console.log(`  Level: ${$.cyan(p.level)}`), console.log(
-        `    Args Slice Considered: ${JSON.stringify(p.argsSlice)}`
-      ), p.parsed && console.log(
-        `    Parsed Args at this Level: ${JSON.stringify(p.parsed)}`
-      ), p.error && console.log(
-        `    ${$.red("Error during parse simulation:")} ${p.error}`
+      C = X === -1 ? [] : C.slice(X);
+    }
+    return console.log(S.yellow(`
+Parsing Simulation Steps:`)), j.forEach((N) => {
+      console.log(`  Level: ${S.cyan(N.level)}`), console.log(
+        `    Args Slice Considered: ${JSON.stringify(N.argsSlice)}`
+      ), N.parsed && console.log(
+        `    Parsed Args at this Level: ${JSON.stringify(N.parsed)}`
+      ), N.error && console.log(
+        `    ${S.red("Error during parse simulation:")} ${N.error}`
       );
     }), console.log(
-      $.yellow(
+      S.yellow(
         `
 Final Accumulated Args State (before final validation):`
       )
-    ), console.log(JSON.stringify(C, null, 2)), console.log($.yellow(`
-Arguments Remaining After Simulation:`)), console.log(JSON.stringify(h, null, 2)), console.log(
-      $.yellow.bold(
+    ), console.log(JSON.stringify(y, null, 2)), console.log(S.yellow(`
+Arguments Remaining After Simulation:`)), console.log(JSON.stringify(C, null, 2)), console.log(
+      S.yellow.bold(
         `
 --- ArgParser Static Configuration (Final Parser) ---`
       )
-    ), a.printAll(), console.log($.yellow.bold("--- End ArgParser --LIB-debug ---")), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
+    ), a.printAll(), console.log(S.yellow.bold("--- End ArgParser --s-debug ---")), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
   }
-  let l = "undefined_parser";
-  if (a instanceof W ? l = a["#subCommandName"] || a["#appName"] : a && (l = a.name || a.appName || "unknown_type"), !(a instanceof W))
+  let t = "undefined_parser";
+  if (a instanceof K ? t = a["#subCommandName"] || a["#appName"] : a && (t = a.name || a.appName || "unknown_type"), !(a instanceof K))
     return console.error(
-      `[ArgParser #_handleGlobalChecks Critical Error] identifiedFinalParser is not an instance of ArgParser. Cannot process help. Name: ${l}, Constructor: ${a ? (r = a.constructor) == null ? void 0 : r.name : "undefined"}`
+      `[ArgParser #_handleGlobalChecks Critical Error] identifiedFinalParser is not an instance of ArgParser. Cannot process help. Name: ${t}, Constructor: ${a ? (b = a.constructor) == null ? void 0 : b.name : "undefined"}`
     ), !1;
-  const i = t(a, w).getFlag("help");
+  const i = c(a, M).getFlag("help");
   if (i && !(n != null && n.skipHelpHandling)) {
-    const m = i.options;
+    const h = i.options;
     if (e.some(
-      (d) => m.includes(d)
+      (O) => h.includes(O)
     ))
       return console.log(a.helpText()), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
   }
   return !1;
-}, ie = function(e, n, a) {
-  const l = [], i = /* @__PURE__ */ new Set();
-  for (const o of n) {
-    const c = o.getCommandChain();
-    for (const s of t(o, w).flags) {
-      if (s.name === "help" || i.has(s.name) || !(typeof s.mandatory == "function" ? s.mandatory(e) : s.mandatory)) continue;
-      const m = e[s.name];
-      let u = !1;
-      s.allowMultiple ? (m === void 0 || Array.isArray(m) && m.length === 0) && (u = !0) : m === void 0 && (u = !0), u && (i.has(s.name) || (l.push({
-        name: s.name,
-        parserName: t(o, P) || t(o, S),
-        commandChain: c
-      }), i.add(s.name)));
-    }
-  }
-  if (l.length > 0)
-    throw new R(
-      `Missing mandatory flags: ${l.map((o) => $.yellow(o.name)).join(", ")}`,
-      a
+}, Le = function(e, n, s) {
+  const r = [], a = /* @__PURE__ */ new Set();
+  let t = [...n];
+  if (n.length > 1) {
+    const i = n[1];
+    c(i, U) || (t = t.slice(1));
+  }
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i], l = o.getCommandChain();
+    for (const u of c(o, M).flags) {
+      if (u.name === "help" || a.has(u.name))
+        continue;
+      let d = !1;
+      if (i < t.length - 1) {
+        const v = t[i + 1];
+        c(v, U) && c(v, M).hasFlag(u.name) && (d = !0);
+      }
+      if (d || !(typeof u.mandatory == "function" ? u.mandatory(e) : u.mandatory)) continue;
+      const b = e[u.name];
+      let h = !1;
+      u.allowMultiple ? (b === void 0 || Array.isArray(b) && b.length === 0) && (h = !0) : b === void 0 && (h = !0), h && (a.has(u.name) || (r.push({
+        name: u.name,
+        parserName: c(o, R) || c(o, P),
+        commandChain: l
+      }), a.add(u.name)));
+    }
+  }
+  if (r.length > 0)
+    throw new Y(
+      `Missing mandatory flags: ${r.map((i) => S.yellow(i.name)).join(", ")}`,
+      s
     );
-}, Y = function(e, n) {
-  for (const a of t(n, w).flags) {
-    const l = a.name;
-    e[l] === void 0 && a.defaultValue !== void 0 && (a.allowMultiple ? e[l] = Array.isArray(a.defaultValue) ? a.defaultValue : [a.defaultValue] : e[l] = a.defaultValue);
+}, we = function(e, n) {
+  for (const s of c(n, M).flags) {
+    const r = s.name;
+    e[r] === void 0 && s.defaultValue !== void 0 && (s.allowMultiple ? e[r] = Array.isArray(s.defaultValue) ? s.defaultValue : [s.defaultValue] : e[r] = s.defaultValue);
   }
-}, le = function(e, n, a) {
-  if (a || !e)
+}, ze = function(e, n, s) {
+  if (s || !e)
     return;
-  const l = e.context.parser, i = t(l, w).flags, o = e.context.args;
-  for (const c of i) {
-    const s = c.name;
-    n.hasOwnProperty(s) ? o[s] = n[s] : c.allowMultiple && !o.hasOwnProperty(s) && (o[s] = []);
-  }
-  e.context.args = o, e.handler(e.context);
-}, G = function(e, n) {
-  var c, s;
-  const a = t(this, w).flags, l = Object.fromEntries(
-    a.map((r) => [
-      r.name,
-      r.allowMultiple ? [] : void 0
+  if (c(this, ne)) {
+    const i = e.context.commandChain || [], o = e.context.args || {}, l = n._originalInputArgs || "unknown", u = Array.isArray(l) ? l.join(" ") : l;
+    console.log(`[--s-enable-fuzzy] handler() skipped for command chain: ${i.join(" ") || "(root)"}`), console.log(`  Input args: [${u}]`), console.log(`  Parsed args: ${JSON.stringify(o)}`);
+    return;
+  }
+  const r = e.context.parser, a = c(r, M).flags, t = e.context.args;
+  for (const i of a) {
+    const o = i.name;
+    n.hasOwnProperty(o) ? t[o] = n[o] : i.allowMultiple && !t.hasOwnProperty(o) && (t[o] = []);
+  }
+  e.context.args = t;
+  try {
+    const i = e.handler(e.context);
+    if (i && typeof i.then == "function") {
+      n._asyncHandlerPromise = i, n._asyncHandlerInfo = e, i.catch(() => {
+      });
+      return;
+    }
+    n.handlerResponse = i;
+  } catch (i) {
+    if (c(this, q))
+      $(this, m, Se).call(this, new Y(`Handler error: ${i}`, []));
+    else
+      throw i;
+  }
+}, ue = function(e, n) {
+  var i, o;
+  const s = c(this, M).flags, r = Object.fromEntries(
+    s.map((l) => [
+      l.name,
+      l.allowMultiple ? [] : void 0
     ])
   );
-  let i = /* @__PURE__ */ new Set();
-  for (const r of a)
-    if (r.allowLigature && !r.flagOnly) {
-      const m = de(
-        ue(
-          ...r.options.map((u) => `${u}=`)
+  let a = /* @__PURE__ */ new Set();
+  for (const l of s)
+    if (l.allowLigature && !l.flagOnly) {
+      const u = st(
+        at(
+          ...l.options.map((d) => `${d}=`)
         ),
-        me(fe).groupedAs("arg")
+        ot(it).groupedAs("arg")
       );
-      for (let u = 0; u < e.length; u++) {
-        if (i.has(u)) continue;
-        const d = e[u], h = m.exec(`${d}`);
-        if ((c = h == null ? void 0 : h.groups) != null && c.arg && (this._addToOutput(
-          r,
-          (s = h == null ? void 0 : h.groups) == null ? void 0 : s.arg,
+      for (let d = 0; d < e.length; d++) {
+        if (a.has(d)) continue;
+        const f = e[d], b = u.exec(`${f}`);
+        if ((i = b == null ? void 0 : b.groups) != null && i.arg && (this._addToOutput(
           l,
+          (o = b == null ? void 0 : b.groups) == null ? void 0 : o.arg,
+          r,
           n
-        ), i.add(u), !r.allowMultiple))
+        ), a.add(d), !l.allowMultiple))
           break;
       }
     }
-  for (const r of a)
-    for (let m = 0; m < e.length; m++) {
-      if (i.has(m)) continue;
-      const u = e[m], d = m + 1, h = d < e.length, C = h ? e[d] : void 0, v = typeof C == "string" && C.startsWith("-");
-      if (r.options.includes(u) && (i.add(m), r.flagOnly ? this._addToOutput(r, !0, l, n) : h && !v ? (this._addToOutput(r, C, l, n), i.add(d)) : r.type === Boolean && this._addToOutput(r, !0, l, n), !r.allowMultiple))
+  for (const l of s)
+    for (let u = 0; u < e.length; u++) {
+      if (a.has(u)) continue;
+      const d = e[u], f = u + 1, b = f < e.length, h = b ? e[f] : void 0, v = typeof h == "string" && h.startsWith("-");
+      if (l.options.includes(d) && (a.add(u), l.flagOnly ? this._addToOutput(l, !0, r, n) : b && !v ? (this._addToOutput(l, h, r, n), a.add(f)) : l.type === Boolean && this._addToOutput(l, !0, r, n), !l.allowMultiple))
         break;
     }
-  let o = e.length;
-  for (let r = 0; r < e.length; r++)
-    if (!i.has(r)) {
-      o = r;
+  let t = e.length;
+  for (let l = 0; l < e.length; l++)
+    if (!a.has(l)) {
+      t = l;
       break;
     }
-  return { parsedArgs: l, firstUnconsumedIndex: o };
-}, ce = function(e) {
+  return { parsedArgs: r, firstUnconsumedIndex: t };
+}, /**
+ * Enables fuzzy testing mode by disabling error handling and making flags optional
+ */
+ve = function() {
+  var e;
+  H(this, ne, !0), H(this, q, !1);
+  for (const [, n] of c(this, T))
+    n.parser instanceof K && $(e = n.parser, m, ve).call(e);
+}, Se = function(e) {
   let n = "your-script";
-  if (t(this, k))
-    n = t(this, k);
-  else if (t(this, S) && t(this, S) !== "Argument Parser")
-    n = t(this, S);
+  if (c(this, V))
+    n = c(this, V);
+  else if (c(this, P) && c(this, P) !== "Argument Parser")
+    n = c(this, P);
   else if (typeof process < "u" && process.argv && process.argv[1])
     try {
-      n = U.basename(process.argv[1]);
+      n = ce.basename(process.argv[1]);
     } catch {
     }
-  const a = [
-    n,
-    ...e.commandChain || []
-  ].join(" ");
   if (console.error(`
-${$.red.bold("Error:")} ${e.message}`), console.error(
+${S.red.bold("Error:")} ${e.message}`), console.error(
     `
-${$.dim(`Try '${a} --help' for usage details.`)}`
+${S.dim(`Try '${n} --help' for usage details.`)}`
   ), typeof process == "object" && typeof process.exit == "function")
     process.exit(1);
   else
     throw e;
-}, ee = function(e, n, a = /* @__PURE__ */ new Set()) {
-  const l = "  ".repeat(n), i = "  ".repeat(n + 1), o = "  ".repeat(n + 2);
+}, Ce = function(e, n, s = /* @__PURE__ */ new Set()) {
+  const r = "  ".repeat(n), a = "  ".repeat(n + 1), t = "  ".repeat(n + 2);
   console.log(
-    `${l}Parser: ${$.blueBright(t(e, P) || t(e, S))}`
-  ), t(e, I) && console.log(`${i}Description: ${t(e, I)}`), console.log(`${i}Options:`), console.log(`${o}appName: ${t(e, S)}`), console.log(
-    `${o}appCommandName: ${t(e, k) ?? $.dim("undefined")}`
-  ), console.log(`${o}handleErrors: ${t(e, T)}`), console.log(
-    `${o}throwForDuplicateFlags: ${t(e, H)}`
+    `${r}Parser: ${S.blueBright(c(e, R) || c(e, P))}`
+  ), c(e, L) && console.log(`${a}Description: ${c(e, L)}`), console.log(`${a}Options:`), console.log(`${t}appName: ${c(e, P)}`), console.log(
+    `${t}appCommandName: ${c(e, V) ?? S.dim("undefined")}`
+  ), console.log(`${t}handleErrors: ${c(e, q)}`), console.log(
+    `${t}throwForDuplicateFlags: ${c(e, ee)}`
   ), console.log(
-    `${o}inheritParentFlags: ${t(e, B)}`
-  ), console.log(`${o}Handler Defined: ${!!t(e, D)}`), console.log(
-    `${i}Internal Params: ${JSON.stringify(t(e, E))}`
+    `${t}inheritParentFlags: ${c(e, U)}`
+  ), console.log(`${t}Handler Defined: ${!!c(e, W)}`), console.log(
+    `${a}Internal Params: ${JSON.stringify(c(e, z))}`
   );
-  const c = t(e, w).flags;
-  c.length > 0 ? (console.log(`${i}Flags (${c.length}):`), c.forEach((r) => {
-    console.log(`${o}* ${$.green(r.name)}:`), console.log(`${o}  Options: ${r.options.join(", ")}`), console.log(
-      `${o}  Description: ${Array.isArray(r.description) ? r.description.join(" | ") : r.description}`
+  const i = c(e, M).flags;
+  i.length > 0 ? (console.log(`${a}Flags (${i.length}):`), i.forEach((l) => {
+    console.log(`${t}* ${S.green(l.name)}:`), console.log(`${t}  Options: ${l.options.join(", ")}`), console.log(
+      `${t}  Description: ${Array.isArray(l.description) ? l.description.join(" | ") : l.description}`
     ), console.log(
-      `${o}  Type: ${typeof r.type == "function" ? r.type.name || "custom function" : r.type}`
+      `${t}  Type: ${typeof l.type == "function" ? l.type.name || "custom function" : l.type}`
     ), console.log(
-      `${o}  Mandatory: ${typeof r.mandatory == "function" ? "dynamic" : r.mandatory ?? !1}`
+      `${t}  Mandatory: ${typeof l.mandatory == "function" ? "dynamic" : l.mandatory ?? !1}`
     ), console.log(
-      `${o}  Default: ${JSON.stringify(r.defaultValue)}`
-    ), console.log(`${o}  Flag Only: ${r.flagOnly}`), console.log(`${o}  Allow Multiple: ${r.allowMultiple}`), console.log(`${o}  Allow Ligature: ${r.allowLigature}`), console.log(
-      `${o}  Enum: ${r.enum && r.enum.length > 0 ? r.enum.join(", ") : "none"}`
-    ), console.log(`${o}  Validator Defined: ${!!r.validate}`);
-  })) : console.log(`${i}Flags: ${$.dim("none")}`);
-  const s = Array.from(t(e, F).values());
-  s.length > 0 ? (console.log(`${i}Sub-Commands (${s.length}):`), s.forEach((r) => {
-    A(this, y, ee).call(this, r.parser, n + 1, a);
-  })) : console.log(`${i}Sub-Commands: ${$.dim("none")}`);
-}, ne = function(e, n, a = /* @__PURE__ */ new Set()) {
-  if (a.has(e)) return "";
-  a.add(e);
-  let l = "";
-  const i = "  ".repeat(n), o = "  ".repeat(n + 1), c = "  ".repeat(n + 2), s = (u) => {
-    l += u + "\\n";
+      `${t}  Default: ${JSON.stringify(l.defaultValue)}`
+    ), console.log(`${t}  Flag Only: ${l.flagOnly}`), console.log(`${t}  Allow Multiple: ${l.allowMultiple}`), console.log(`${t}  Allow Ligature: ${l.allowLigature}`), console.log(
+      `${t}  Enum: ${l.enum && l.enum.length > 0 ? l.enum.join(", ") : "none"}`
+    ), console.log(`${t}  Validator Defined: ${!!l.validate}`);
+  })) : console.log(`${a}Flags: ${S.dim("none")}`);
+  const o = Array.from(c(e, T).values());
+  o.length > 0 ? (console.log(`${a}Sub-Commands (${o.length}):`), o.forEach((l) => {
+    $(this, m, Ce).call(this, l.parser, n + 1, s);
+  })) : console.log(`${a}Sub-Commands: ${S.dim("none")}`);
+}, Ae = function(e, n, s = /* @__PURE__ */ new Set()) {
+  if (s.has(e)) return "";
+  s.add(e);
+  let r = "";
+  const a = "  ".repeat(n), t = "  ".repeat(n + 1), i = "  ".repeat(n + 2), o = (d) => {
+    r += d + "\\n";
   };
-  s(
-    `${i}Parser: ${t(e, P) || t(e, S)}`
+  o(
+    `${a}Parser: ${c(e, R) || c(e, P)}`
     // #appName is guaranteed
-  ), t(e, I) && s(`${o}Description: ${t(e, I)}`), s(`${o}Options:`), s(`${c}appName: ${t(e, S)}`), s(
-    `${c}appCommandName: ${t(e, k) ?? "undefined"}`
-  ), s(`${c}handleErrors: ${t(e, T)}`), s(
-    `${c}throwForDuplicateFlags: ${t(e, H)}`
-  ), s(`${c}inheritParentFlags: ${t(e, B)}`), s(`${c}Handler Defined: ${!!t(e, D)}`), s(
-    `${o}Internal Params: ${JSON.stringify(t(e, E))}`
+  ), c(e, L) && o(`${t}Description: ${c(e, L)}`), o(`${t}Options:`), o(`${i}appName: ${c(e, P)}`), o(
+    `${i}appCommandName: ${c(e, V) ?? "undefined"}`
+  ), o(`${i}handleErrors: ${c(e, q)}`), o(
+    `${i}throwForDuplicateFlags: ${c(e, ee)}`
+  ), o(`${i}inheritParentFlags: ${c(e, U)}`), o(`${i}Handler Defined: ${!!c(e, W)}`), o(
+    `${t}Internal Params: ${JSON.stringify(c(e, z))}`
   );
-  const r = t(e, w).flags;
-  r.length > 0 ? (s(`${o}Flags (${r.length}):`), r.forEach((u) => {
-    var h;
-    s(`${c}* ${u.name}:`), s(`${c}  Options: ${u.options.join(", ")}`), s(
-      `${c}  Description: ${Array.isArray(u.description) ? u.description.join(" | ") : u.description}`
+  const l = c(e, M).flags;
+  l.length > 0 ? (o(`${t}Flags (${l.length}):`), l.forEach((d) => {
+    var b;
+    o(`${i}* ${d.name}:`), o(`${i}  Options: ${d.options.join(", ")}`), o(
+      `${i}  Description: ${Array.isArray(d.description) ? d.description.join(" | ") : d.description}`
     );
-    let d = "unknown";
-    if (typeof u.type == "function")
-      d = u.type.name || "custom function";
-    else if (typeof u.type == "string")
-      d = u.type;
-    else if (typeof u.type == "object" && u.type)
+    let f = "unknown";
+    if (typeof d.type == "function")
+      f = d.type.name || "custom function";
+    else if (typeof d.type == "string")
+      f = d.type;
+    else if (typeof d.type == "object" && d.type)
       try {
-        d = ((h = u.type.constructor) == null ? void 0 : h.name) || "object";
+        f = ((b = d.type.constructor) == null ? void 0 : b.name) || "object";
       } catch {
-        d = "object";
+        f = "object";
       }
-    s(`${c}  Type: ${d}`), s(
-      `${c}  Mandatory: ${typeof u.mandatory == "function" ? "dynamic" : u.mandatory ?? !1}`
-    ), s(
-      `${c}  Default: ${JSON.stringify(u.defaultValue)}`
-    ), s(`${c}  Flag Only: ${u.flagOnly}`), s(`${c}  Allow Multiple: ${u.allowMultiple}`), s(`${c}  Allow Ligature: ${u.allowLigature}`), s(
-      `${c}  Enum: ${u.enum && u.enum.length > 0 ? u.enum.join(", ") : "none"}`
-    ), s(`${c}  Validator Defined: ${!!u.validate}`);
-  })) : s(`${o}Flags: none`);
-  const m = Array.from(t(e, F).values());
-  return m.length > 0 ? (s(`${o}Sub-Commands (${m.length}):`), m.forEach((u) => {
-    l += A(this, y, ne).call(this, u.parser, n + 1, a);
-  })) : s(`${o}Sub-Commands: none`), l;
-}, te = function(e, n = /* @__PURE__ */ new Set()) {
+    o(`${i}  Type: ${f}`), o(
+      `${i}  Mandatory: ${typeof d.mandatory == "function" ? "dynamic" : d.mandatory ?? !1}`
+    ), o(
+      `${i}  Default: ${JSON.stringify(d.defaultValue)}`
+    ), o(`${i}  Flag Only: ${d.flagOnly}`), o(`${i}  Allow Multiple: ${d.allowMultiple}`), o(`${i}  Allow Ligature: ${d.allowLigature}`), o(
+      `${i}  Enum: ${d.enum && d.enum.length > 0 ? d.enum.join(", ") : "none"}`
+    ), o(`${i}  Validator Defined: ${!!d.validate}`);
+  })) : o(`${t}Flags: none`);
+  const u = Array.from(c(e, T).values());
+  return u.length > 0 ? (o(`${t}Sub-Commands (${u.length}):`), u.forEach((d) => {
+    r += $(this, m, Ae).call(this, d.parser, n + 1, s);
+  })) : o(`${t}Sub-Commands: none`), r;
+}, Fe = function(e, n = /* @__PURE__ */ new Set()) {
   if (n.has(e))
     return {
-      note: `Reference to already processed parser: ${t(e, P) || t(e, S)}`
+      note: `Reference to already processed parser: ${c(e, R) || c(e, P)}`
     };
   n.add(e);
-  const a = {
-    parserName: t(e, P) || t(e, S),
+  const s = {
+    parserName: c(e, R) || c(e, P),
     // #appName is guaranteed
-    description: t(e, I),
+    description: c(e, L),
     options: {
-      appName: t(e, S),
-      appCommandName: t(e, k) ?? void 0,
-      handleErrors: t(e, T),
-      throwForDuplicateFlags: t(e, H),
-      inheritParentFlags: t(e, B)
+      appName: c(e, P),
+      appCommandName: c(e, V) ?? void 0,
+      handleErrors: c(e, q),
+      throwForDuplicateFlags: c(e, ee),
+      inheritParentFlags: c(e, U)
     },
-    handlerDefined: !!t(e, D),
-    internalParams: t(e, E),
+    handlerDefined: !!c(e, W),
+    internalParams: c(e, z),
     flags: [],
     subCommands: {}
     // Will be an object where keys are sub-command names
-  }, l = t(e, w).flags;
-  a.flags = l.map((o) => {
-    var s;
-    let c = "unknown";
-    if (typeof o.type == "function")
-      c = o.type.name || "custom function";
-    else if (typeof o.type == "string")
-      c = o.type;
-    else if (typeof o.type == "object" && o.type)
+  }, r = c(e, M).flags;
+  s.flags = r.map((t) => {
+    var o;
+    let i = "unknown";
+    if (typeof t.type == "function")
+      i = t.type.name || "custom function";
+    else if (typeof t.type == "string")
+      i = t.type;
+    else if (typeof t.type == "object" && t.type)
       try {
-        c = ((s = o.type.constructor) == null ? void 0 : s.name) || "object";
+        i = ((o = t.type.constructor) == null ? void 0 : o.name) || "object";
       } catch {
-        c = "object";
+        i = "object";
       }
     return {
-      name: o.name,
-      options: o.options,
-      description: o.description,
-      type: c,
-      mandatory: typeof o.mandatory == "function" ? "dynamic" : o.mandatory ?? !1,
-      defaultValue: o.defaultValue,
-      flagOnly: o.flagOnly,
-      allowMultiple: o.allowMultiple,
-      allowLigature: o.allowLigature,
-      enum: o.enum,
-      validatorDefined: !!o.validate
+      name: t.name,
+      options: t.options,
+      description: t.description,
+      type: i,
+      mandatory: typeof t.mandatory == "function" ? "dynamic" : t.mandatory ?? !1,
+      defaultValue: t.defaultValue,
+      flagOnly: t.flagOnly,
+      allowMultiple: t.allowMultiple,
+      allowLigature: t.allowLigature,
+      enum: t.enum,
+      validatorDefined: !!t.validate
     };
   });
-  const i = Array.from(t(e, F).values());
-  return i.length > 0 && i.forEach((o) => {
-    a.subCommands[o.name] = A(this, y, te).call(this, o.parser, n);
-  }), a;
+  const a = Array.from(c(e, T).values());
+  return a.length > 0 && a.forEach((t) => {
+    s.subCommands[t.name] = $(this, m, Fe).call(this, t.parser, n);
+  }), s;
+}, /**
+ * Generates a default environment file name based on the app name
+ */
+Ne = function() {
+  let e = "config";
+  return c(this, V) ? e = c(this, V) : c(this, P) && c(this, P) !== "Argument Parser" && (e = c(this, P)), e = e.split(/[\s-_]+/).map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join(""), `${e}.env`;
+}, /**
+ * Handles the --s-save-to-env system flag at the final parser level
+ */
+We = function(e, n) {
+  const s = e.findIndex((r) => r === "--s-save-to-env");
+  if (s !== -1) {
+    let r;
+    if (s + 1 < e.length) {
+      const a = e[s + 1];
+      a && !a.startsWith("-") ? r = a : r = $(this, m, Ne).call(this);
+    } else
+      r = $(this, m, Ne).call(this);
+    try {
+      return $(this, m, Je).call(this, r, e, n), console.log(S.green(`Environment configuration saved to: ${r}`)), typeof process == "object" && typeof process.exit == "function" && process.exit(0), !0;
+    } catch (a) {
+      return console.error(S.red(`Error saving environment file: ${a instanceof Error ? a.message : String(a)}`)), typeof process == "object" && typeof process.exit == "function" && process.exit(1), !0;
+    }
+  }
+  return !1;
+}, /**
+ * Saves the current parser's flags and their values to an environment file
+ * in the specified format based on file extension.
+ */
+Je = function(e, n, s) {
+  const r = ce.extname(e).toLowerCase();
+  let a;
+  r === ".yaml" || r === ".yml" ? a = "yaml" : r === ".json" || r === ".jsonc" ? a = "json" : r === ".toml" || r === ".tml" ? a = "toml" : a = "env";
+  const t = [], i = /* @__PURE__ */ new Set();
+  for (let f = s.length - 1; f >= 0; f--) {
+    const b = s[f];
+    for (const h of c(b, M).flags)
+      i.has(h.name) || (t.push(h), i.add(h.name));
+  }
+  const o = t, { parsedArgs: l } = $(this, m, ue).call(this, n.filter(
+    (f) => f !== "--s-save-to-env" && f !== e
+  ));
+  let u;
+  switch (a) {
+    case "env":
+      u = $(this, m, Xe).call(this, o, l);
+      break;
+    case "yaml":
+      u = $(this, m, et).call(this, o, l);
+      break;
+    case "json":
+      u = $(this, m, tt).call(this, o, l);
+      break;
+    case "toml":
+      u = $(this, m, nt).call(this, o, l);
+      break;
+  }
+  const d = ce.dirname(e);
+  G.existsSync(d) || G.mkdirSync(d, { recursive: !0 }), G.writeFileSync(e, u, "utf8");
+}, /**
+ * Loads configuration from an environment file in various formats
+ */
+Be = function(e, n) {
+  if (!G.existsSync(e))
+    throw new Error(`Configuration file not found: ${e}`);
+  const s = ce.extname(e).toLowerCase();
+  let r;
+  s === ".yaml" || s === ".yml" ? r = "yaml" : s === ".json" || s === ".jsonc" ? r = "json" : s === ".toml" || s === ".tml" ? r = "toml" : r = "env";
+  const a = G.readFileSync(e, "utf8");
+  let t;
+  switch (r) {
+    case "env":
+      t = $(this, m, qe).call(this, a);
+      break;
+    case "yaml":
+      t = $(this, m, Ue).call(this, a);
+      break;
+    case "json":
+      t = $(this, m, Ze).call(this, a);
+      break;
+    case "toml":
+      t = $(this, m, Ge).call(this, a);
+      break;
+  }
+  return $(this, m, Ye).call(this, t, n);
+}, /**
+ * Parses .env file content using dotenv
+ */
+qe = function(e) {
+  const n = lt.parse(e), s = {};
+  for (const [r, a] of Object.entries(n)) {
+    const t = r.toLowerCase().replace(/_/g, "-");
+    a === "true" ? s[t] = !0 : a === "false" ? s[t] = !1 : /^-?\d+$/.test(a) ? s[t] = parseInt(a, 10) : /^-?\d*\.\d+$/.test(a) ? s[t] = parseFloat(a) : a.includes(",") ? s[t] = a.split(",").map((i) => i.trim()) : s[t] = a;
+  }
+  return s;
+}, /**
+ * Parses YAML file content
+ */
+Ue = function(e) {
+  const n = De.load(e);
+  if (typeof n != "object" || n === null)
+    throw new Error("YAML file must contain an object at the root level");
+  const { _meta: s, ...r } = n;
+  return r;
+}, /**
+ * Parses JSON file content
+ */
+Ze = function(e) {
+  const n = JSON.parse(e);
+  if (typeof n != "object" || n === null)
+    throw new Error("JSON file must contain an object at the root level");
+  const { _meta: s, ...r } = n;
+  return r;
+}, /**
+ * Parses TOML file content
+ */
+Ge = function(e) {
+  const n = He.parse(e);
+  if (typeof n != "object" || n === null)
+    throw new Error("TOML file must contain an object at the root level");
+  return n;
+}, /**
+ * Converts raw configuration values to match flag types and validates them
+ */
+Ye = function(e, n) {
+  const s = {}, r = [], a = /* @__PURE__ */ new Set();
+  for (let t = n.length - 1; t >= 0; t--) {
+    const i = n[t];
+    for (const o of c(i, M).flags)
+      a.has(o.name) || (r.push(o), a.add(o.name));
+  }
+  for (const [t, i] of Object.entries(e)) {
+    const o = r.find((l) => l.name === t);
+    if (!o) {
+      console.warn(S.yellow(`Warning: Configuration key '${t}' does not match any known flag. Ignoring.`));
+      continue;
+    }
+    try {
+      const l = $(this, m, Ke).call(this, i, o);
+      s[t] = l;
+    } catch (l) {
+      console.error(S.red(`Error converting configuration value for '${t}': ${l instanceof Error ? l.message : String(l)}`)), typeof process == "object" && typeof process.exit == "function" && process.exit(1);
+    }
+  }
+  return s;
+}, /**
+ * Converts a configuration value to match the expected flag type
+ */
+Ke = function(e, n) {
+  const s = n.type;
+  if (e == null)
+    return e;
+  if (s === Array || n.allowMultiple)
+    return Array.isArray(e) ? e : typeof e == "string" ? e.split(",").map((r) => r.trim()) : [e];
+  if (s === Boolean) {
+    if (typeof e == "boolean") return e;
+    if (typeof e == "string") {
+      const r = e.toLowerCase();
+      if (r === "true" || r === "1" || r === "yes") return !0;
+      if (r === "false" || r === "0" || r === "no") return !1;
+    }
+    throw new Error(`Cannot convert '${e}' to boolean for flag '${n.name}'`);
+  }
+  if (s === String)
+    return String(e);
+  if (s === Number) {
+    const r = Number(e);
+    if (isNaN(r))
+      throw new Error(`Cannot convert '${e}' to number for flag '${n.name}'`);
+    return r;
+  }
+  if (n.enum && n.enum.length > 0 && !n.enum.includes(e))
+    throw new Error(`Value '${e}' is not allowed for flag '${n.name}'. Allowed values: ${n.enum.join(", ")}`);
+  return e;
+}, /**
+ * Merges environment configuration with command line arguments
+ * CLI arguments take precedence over file configuration
+ */
+Qe = function(e, n) {
+  const s = [...n], r = s.findIndex((t) => t === "--s-with-env");
+  r !== -1 && s.splice(r, 2);
+  const a = /* @__PURE__ */ new Set();
+  for (let t = 0; t < s.length; t++) {
+    const i = s[t];
+    if (i.startsWith("-") && (a.add(i), i.includes("="))) {
+      const o = i.split("=")[0];
+      a.add(o);
+    }
+  }
+  for (const [t, i] of Object.entries(e)) {
+    const o = `--${t}`;
+    if (!a.has(o))
+      if (typeof i == "boolean")
+        i && s.push(o);
+      else if (Array.isArray(i))
+        for (const l of i)
+          s.push(o, String(l));
+      else
+        s.push(o, String(i));
+  }
+  return s;
+}, /**
+ * Generates environment file content in Bash .env format
+ */
+Xe = function(e, n) {
+  const s = [];
+  s.push("# Environment configuration generated by ArgParser"), s.push("# Format: Bash .env style"), s.push("");
+  for (const r of e) {
+    if (r.name === "help") continue;
+    const a = n[r.name], t = a != null, i = typeof r.mandatory == "function" ? !1 : r.mandatory ?? !1;
+    s.push(`# ${r.name}: ${Array.isArray(r.description) ? r.description.join(" | ") : r.description}`), s.push(`# Options: ${r.options.join(", ")}`), s.push(`# Type: ${$(this, m, de).call(this, r.type)}`), r.defaultValue !== void 0 && s.push(`# Default: ${JSON.stringify(r.defaultValue)}`), r.enum && r.enum.length > 0 && s.push(`# Allowed values: ${r.enum.join(", ")}`);
+    const o = r.name.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+    let l = "";
+    if (t)
+      Array.isArray(a) ? l = a.join(",") : typeof a == "boolean" ? l = a ? "true" : "false" : l = String(a), s.push(`${o}="${l}"`);
+    else {
+      const u = r.defaultValue !== void 0 ? String(r.defaultValue) : "", d = i ? "" : "# ";
+      s.push(`${d}${o}="${u}"`);
+    }
+    s.push("");
+  }
+  return s.join(`
+`);
+}, /**
+ * Generates environment file content in YAML format
+ */
+et = function(e, n) {
+  const s = {}, r = [];
+  r.push("# Environment configuration generated by ArgParser"), r.push("# Format: YAML"), r.push("");
+  for (const t of e) {
+    if (t.name === "help") continue;
+    const i = n[t.name], o = i != null, l = typeof t.mandatory == "function" ? !1 : t.mandatory ?? !1;
+    r.push(`# ${t.name}: ${Array.isArray(t.description) ? t.description.join(" | ") : t.description}`), r.push(`# Options: ${t.options.join(", ")}`), r.push(`# Type: ${$(this, m, de).call(this, t.type)}`), t.defaultValue !== void 0 && r.push(`# Default: ${JSON.stringify(t.defaultValue)}`), t.enum && t.enum.length > 0 && r.push(`# Allowed values: ${t.enum.join(", ")}`), o ? s[t.name] = i : l && (s[t.name] = t.defaultValue !== void 0 ? t.defaultValue : null), r.push("");
+  }
+  const a = De.dump(s, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: !0,
+    sortKeys: !0
+  });
+  return r.join(`
+`) + `
+` + a;
+}, /**
+ * Generates environment file content in JSON format
+ */
+tt = function(e, n) {
+  const s = {}, r = {
+    _meta: {
+      generated_by: "ArgParser",
+      format: "JSON",
+      flags_info: {}
+    }
+  };
+  for (const t of e) {
+    if (t.name === "help") continue;
+    const i = n[t.name], o = i != null, l = typeof t.mandatory == "function" ? !1 : t.mandatory ?? !1;
+    r._meta.flags_info[t.name] = {
+      description: Array.isArray(t.description) ? t.description.join(" | ") : t.description,
+      options: t.options,
+      type: $(this, m, de).call(this, t.type),
+      mandatory: l,
+      defaultValue: t.defaultValue,
+      enum: t.enum && t.enum.length > 0 ? t.enum : void 0
+    }, o ? s[t.name] = i : l && (s[t.name] = t.defaultValue !== void 0 ? t.defaultValue : null);
+  }
+  const a = { ...r, ...s };
+  return JSON.stringify(a, null, 2);
+}, /**
+ * Generates environment file content in TOML format
+ */
+nt = function(e, n) {
+  const s = {}, r = [];
+  r.push("# Environment configuration generated by ArgParser"), r.push("# Format: TOML"), r.push("");
+  for (const t of e) {
+    if (t.name === "help") continue;
+    const i = n[t.name], o = i != null, l = typeof t.mandatory == "function" ? !1 : t.mandatory ?? !1;
+    r.push(`# ${t.name}: ${Array.isArray(t.description) ? t.description.join(" | ") : t.description}`), r.push(`# Options: ${t.options.join(", ")}`), r.push(`# Type: ${$(this, m, de).call(this, t.type)}`), t.defaultValue !== void 0 && r.push(`# Default: ${JSON.stringify(t.defaultValue)}`), t.enum && t.enum.length > 0 && r.push(`# Allowed values: ${t.enum.join(", ")}`), o ? s[t.name] = i : l && (s[t.name] = t.defaultValue !== void 0 ? t.defaultValue : null), r.push("");
+  }
+  const a = He.stringify(s);
+  return r.join(`
+`) + `
+` + a;
+}, /**
+ * Helper method to get a string representation of a flag's type
+ */
+de = function(e) {
+  var n;
+  if (typeof e == "function")
+    return e.name || "custom function";
+  if (typeof e == "string")
+    return e;
+  if (typeof e == "object" && e)
+    try {
+      return ((n = e.constructor) == null ? void 0 : n.name) || "object";
+    } catch {
+      return "object";
+    }
+  return "unknown";
+};
+let he = K;
+function ut(g) {
+  let e;
+  const n = g.type;
+  let s;
+  typeof n == "function" ? s = n.name.toLowerCase().replace("constructor", "") : s = String(n).toLowerCase();
+  const r = g.enum;
+  if (g.allowMultiple) {
+    let o;
+    if (r && Array.isArray(r) && r.length > 0)
+      if (r.every((l) => typeof l == "string"))
+        o = p.enum(r);
+      else if (r.every((l) => typeof l == "number")) {
+        const l = r.map((u) => p.literal(u));
+        l.length === 1 ? o = l[0] : o = p.union(
+          l
+        );
+      } else
+        o = p.string();
+    else
+      switch (s) {
+        case "number":
+          o = p.number();
+          break;
+        case "boolean":
+          o = p.boolean();
+          break;
+        default:
+          o = p.string();
+          break;
+      }
+    e = p.array(o);
+  } else
+    switch (s) {
+      case "string":
+        e = r && Array.isArray(r) && r.length > 0 && r.every((l) => typeof l == "string") ? p.enum(r) : p.string();
+        break;
+      case "number":
+        if (r && Array.isArray(r) && r.length > 0 && r.every((l) => typeof l == "number")) {
+          const l = r.map((u) => p.literal(u));
+          l.length === 1 ? e = l[0] : l.length >= 2 ? e = p.union(
+            l
+          ) : e = p.number();
+        } else
+          e = p.number();
+        break;
+      case "boolean":
+        e = p.boolean();
+        break;
+      case "array":
+        const o = r && Array.isArray(r) && r.length > 0 && r.every((l) => typeof l == "string") ? p.enum(r) : p.string();
+        e = p.array(o);
+        break;
+      case "object":
+        e = p.record(p.string(), p.any());
+        break;
+      default:
+        console.warn(
+          `[MCP Integration] Flag '${g.name}' has an unknown type '${s}'. Defaulting to z.string().`
+        ), e = p.string();
+        break;
+    }
+  const t = g.description;
+  t && (e = e.describe(
+    Array.isArray(t) ? t.join(`
+`) : t
+  ));
+  const i = g.defaultValue;
+  return i !== void 0 ? e = e.default(i) : g.mandatory || (e = e.optional()), e;
+}
+function dt(g, e) {
+  const n = [], s = /* @__PURE__ */ new Set();
+  function r(a, t) {
+    if (s.has(a)) return;
+    s.add(a);
+    const i = g, o = a, l = i.getAppName ? i.getAppName() : i["#appName"], u = o.getDescription ? o.getDescription() : o["#description"], d = o.getHandler ? o.getHandler() : o["#handler"], f = o.flags, b = o.getSubCommands ? o.getSubCommands() : o["#subCommands"], h = b ? Array.from(b.values()) : [];
+    let v = o.getAppCommandName ? o.getAppCommandName() : o["#appCommandName"];
+    !v && a !== g && (v = o.getSubCommandName ? o.getSubCommandName() : o["#subCommandName"]), a !== g && t.length > 0 && (v = t[t.length - 1]);
+    const O = v || l, C = v || (t.length > 0 ? t[t.length - 1] : l);
+    let y;
+    if (e != null && e.generateToolName ? y = e.generateToolName(t, l) : (a === g ? y = O || l || "root_cmd" : y = C || "cmd", y = y.replace(/[^a-zA-Z0-9_-]/g, "_")), y || (y = a === g && l ? l : "cmd"), e != null && e.toolNamePrefix && (y = e.toolNamePrefix + y), e != null && e.toolNameSuffix && (y = y + e.toolNameSuffix), d) {
+      const A = f, F = {}, N = A.some((k) => k.name === "help");
+      for (const k of A) {
+        let E = ut(k);
+        N && k.name !== "help" && k.mandatory && (E = E.optional()), F[k.name] = E;
+      }
+      const re = p.object(F);
+      let X;
+      if (e != null && e.outputSchemaMap && e.outputSchemaMap[y]) {
+        const k = e.outputSchemaMap[y];
+        X = typeof k == "object" && !k._def ? p.object(k) : k;
+      } else e != null && e.defaultOutputSchema && (X = e.defaultOutputSchema);
+      const pe = {
+        name: y,
+        description: u || `Executes the ${y} command.`,
+        inputSchema: re,
+        outputSchema: X,
+        async execute(k) {
+          var je, Ee, Pe, Te, Oe, ke;
+          if (k.help === !0) {
+            let x = g;
+            const I = [...t];
+            for (const D of I) {
+              const B = x.getSubCommand ? x.getSubCommand(D) : void 0;
+              if (B && B.parser)
+                x = B.parser;
+              else
+                break;
+            }
+            const w = x.helpText ? x.helpText() : "Help not available";
+            return (je = e == null ? void 0 : e.outputSchemaMap) != null && je[y] ? {
+              success: !0,
+              help: w,
+              files: [],
+              commandExecuted: null,
+              stderrOutput: null
+            } : { success: !0, message: w };
+          }
+          const E = [...t], rt = f;
+          for (const x of rt) {
+            const I = x.name;
+            if (k.hasOwnProperty(I)) {
+              const w = k[I], D = x.type, B = x.options, se = x.flagOnly, ie = x.allowMultiple;
+              let le = typeof D == "function" ? D.name.toLowerCase().replace("constructor", "") : String(D).toLowerCase();
+              if (E.push(B[0]), le === "boolean")
+                (w === !0 && se === !1 || w === !1 && se === !1) && E.push(String(w));
+              else if (le === "array")
+                if (Array.isArray(w))
+                  if (ie) {
+                    const Z = E.length;
+                    w.forEach((te) => {
+                      E.push(B[0]), E.push(String(te));
+                    }), w.length > 0 && E[Z - 1] === B[0] && E.splice(Z - 1, 1);
+                  } else
+                    E.push(w.join(","));
+                else w != null && E.push(String(w));
+              else w != null && E.push(String(w));
+            }
+          }
+          try {
+            const x = await g.parse(
+              E
+            );
+            if (x.$error) {
+              const w = x.$error, D = {
+                message: `Cmd error: ${w.type} - ${w.message}`,
+                details: w.details
+              };
+              return (Ee = e == null ? void 0 : e.outputSchemaMap) != null && Ee[y] ? {
+                error: D.message,
+                files: [],
+                commandExecuted: null,
+                stderrOutput: ((Pe = D.details) == null ? void 0 : Pe.stderr) || null
+              } : {
+                success: !1,
+                message: D.message,
+                data: D.details
+              };
+            }
+            let I = x.handlerResponse;
+            if (I === void 0 && x.$commandChain) {
+              let w = g, D = { ...x }, B;
+              const se = x.$commandChain;
+              for (let Z = 0; Z < se.length; Z++) {
+                const te = se[Z], ae = w != null && w.getSubCommand ? w.getSubCommand(te) : void 0;
+                if (ae && ae.parser)
+                  B = { ...D }, D = D[te] || {}, w = ae.parser;
+                else if (Z === 0 && w && te === (w.getAppCommandName ? w.getAppCommandName() : w["#appCommandName"] || (w.getAppName ? w.getAppName() : w["#appName"]))) {
+                  D = { ...x };
+                  break;
+                } else {
+                  w = void 0;
+                  break;
+                }
+              }
+              const ie = w, le = ie.getHandler ? ie.getHandler() : ie["#handler"];
+              if (w && le) {
+                const Z = le, te = {
+                  args: D,
+                  commandChain: se,
+                  parser: w,
+                  parentArgs: B
+                };
+                try {
+                  I = await Z(te);
+                } catch (ae) {
+                  const _e = `Handler error: ${ae.message || String(ae)}`;
+                  return (Te = e == null ? void 0 : e.outputSchemaMap) != null && Te[y] ? {
+                    error: _e,
+                    files: [],
+                    commandExecuted: null,
+                    stderrOutput: null
+                  } : { success: !1, message: _e };
+                }
+              }
+            }
+            return (Oe = e == null ? void 0 : e.outputSchemaMap) != null && Oe[y] ? I : { success: !0, data: I };
+          } catch (x) {
+            let I, w = x;
+            return x instanceof Error && x.message ? (I = `Cmd error: handler_error - ${x.message}`, w = { details: x }) : I = `MCP tool exec failed: ${x.message || String(x)}`, (ke = e == null ? void 0 : e.outputSchemaMap) != null && ke[y] ? {
+              error: I,
+              files: [],
+              commandExecuted: null,
+              stderrOutput: (w == null ? void 0 : w.stderr) || null
+            } : {
+              success: !1,
+              message: I,
+              data: w
+            };
+          }
+        }
+      };
+      n.push(pe);
+    }
+    const j = h;
+    if (j && (e == null ? void 0 : e.includeSubCommands) !== !1)
+      for (const A of j) {
+        if (A.isMcp === !0)
+          continue;
+        const F = [...t, A.name];
+        r(
+          A.parser,
+          F.filter((N) => N)
+        );
+      }
+  }
+  return r(g, []), n;
+}
+var fe, xe;
+const ye = class ye extends he {
+  constructor() {
+    super(...arguments);
+    _(this, fe);
+  }
+  /**
+   * Generate MCP tools from this ArgParser instance
+   * @param options Optional configuration for MCP tool generation
+   * @returns Array of MCP tool structures ready for server registration
+   */
+  toMcpTools(n) {
+    return dt(this, n);
+  }
+  /**
+   * Create an MCP server with tools generated from this ArgParser
+   * @param serverInfo Server configuration
+   * @param toolOptions Optional MCP tool generation options
+   * @returns Configured MCP server instance
+   */
+  createMcpServer(n, s) {
+    const { McpServer: r } = require("@modelcontextprotocol/sdk/server/mcp.js"), a = new r({
+      id: n.name,
+      version: n.version,
+      name: n.name,
+      description: n.description
+    });
+    return this.toMcpTools(s).reduce((o, l) => (o.find((u) => u.name === l.name) || o.push(l), o), []).forEach((o) => {
+      const l = {
+        description: o.description || "No description provided.",
+        inputSchema: o.inputSchema.shape || o.inputSchema
+      };
+      o.outputSchema && (l.outputSchema = o.outputSchema.shape || o.outputSchema), a.registerTool(o.name, l, o.execute);
+    }), a;
+  }
+  /**
+   * Start an MCP server using stdio transport
+   * @param serverInfo Server configuration
+   * @param toolOptions Optional MCP tool generation options
+   * @returns Promise that resolves when server is connected
+   */
+  async startMcpServer(n, s) {
+    return this.startMcpServerWithTransport(n, "stdio", {}, s);
+  }
+  /**
+   * Start an MCP server with multiple transport types simultaneously
+   * @param serverInfo Server configuration
+   * @param transports Array of transport configurations
+   * @param toolOptions Optional MCP tool generation options
+   * @returns Promise that resolves when all servers are started
+   */
+  async startMcpServerWithMultipleTransports(n, s, r) {
+    const a = this.createMcpServer(n, r), t = [];
+    for (const i of s) {
+      const o = $(this, fe, xe).call(this, a, n, i);
+      t.push(o);
+    }
+    await Promise.all(t), console.error(`[${n.name}] All MCP transports started successfully`);
+  }
+  /**
+   * Start an MCP server with a specific transport type
+   * @param serverInfo Server configuration
+   * @param transportType Type of transport to use
+   * @param transportOptions Transport-specific options
+   * @param toolOptions Optional MCP tool generation options
+   * @returns Promise that resolves when server is connected
+   */
+  async startMcpServerWithTransport(n, s, r = {}, a) {
+    const t = this.createMcpServer(n, a);
+    await $(this, fe, xe).call(this, t, n, {
+      type: s,
+      ...r
+    });
+  }
+  /**
+   * Override parse() to handle async handlers properly
+   * This allows ArgParser to work with async handlers while keeping
+   * backwards compatibility for synchronous usage
+   */
+  parse(n, s) {
+    const r = super.parse(n, s), a = r;
+    return a._fuzzyModePreventedExecution ? r : a._asyncHandlerPromise ? this.parseAsync(n, s) : r;
+  }
+  /**
+   * Async version of parse for when async handlers are detected
+   */
+  async parseAsync(n, s) {
+    const r = super.parse(n, s), a = r;
+    if (a._fuzzyModePreventedExecution)
+      return r;
+    if (a._asyncHandlerPromise) {
+      try {
+        const t = await a._asyncHandlerPromise;
+        a.handlerResponse = t;
+      } catch (t) {
+        if (this["#handleErrors"])
+          a.$error = {
+            type: "handler_error",
+            message: t instanceof Error ? t.message : String(t),
+            details: t
+          };
+        else
+          throw t;
+      }
+      delete a._asyncHandlerPromise, delete a._asyncHandlerInfo;
+    }
+    return r;
+  }
+  addMcpSubCommand(n = "mcp-server", s, r) {
+    let a;
+    r && typeof r == "object" && ("includeSubCommands" in r || "toolNamePrefix" in r || "toolNameSuffix" in r) ? a = { toolOptions: r } : a = r || {};
+    const { defaultTransports: t, defaultTransport: i, toolOptions: o } = a, l = async (d) => {
+      d.parentParser || (console.error(
+        "[MCP Server] Critical: MCP server handler called without a parent parser context."
+      ), process.exit(1)), console.error(`[${s.name}] Starting MCP Server...`);
+      const f = d.parentParser, b = d.args.transports;
+      if (b)
+        try {
+          const h = JSON.parse(b);
+          await f.startMcpServerWithMultipleTransports(s, h, o);
+        } catch (h) {
+          console.error("❌ Error parsing transports configuration:", h.message), console.error(`Expected JSON format: '[{"type":"stdio"},{"type":"sse","port":3001}]'`), process.exit(1);
+        }
+      else if (t && t.length > 0)
+        await f.startMcpServerWithMultipleTransports(s, t, o);
+      else if (i)
+        await f.startMcpServerWithTransport(
+          s,
+          i.type,
+          {
+            port: i.port,
+            host: i.host,
+            path: i.path,
+            sessionIdGenerator: i.sessionIdGenerator
+          },
+          o
+        );
+      else {
+        const h = d.args.transport || "stdio", v = {
+          port: d.args.port,
+          host: d.args.host,
+          path: d.args.path
+        };
+        await f.startMcpServerWithTransport(s, h, v, o);
+      }
+      return new Promise(() => {
+      });
+    }, u = new he({}, [
+      {
+        name: "transport",
+        description: "Transport type for MCP server (single transport mode)",
+        options: ["--transport", "-t"],
+        type: "string",
+        enum: ["stdio", "sse", "streamable-http"],
+        defaultValue: "stdio"
+      },
+      {
+        name: "transports",
+        description: "Multiple transports configuration as JSON array (overrides single transport)",
+        options: ["--transports"],
+        type: "string"
+      },
+      {
+        name: "port",
+        description: "Port number for HTTP-based transports (single transport mode)",
+        options: ["--port", "-p"],
+        type: "number",
+        defaultValue: 3e3
+      },
+      {
+        name: "host",
+        description: "Host address for HTTP-based transports (single transport mode)",
+        options: ["--host"],
+        type: "string",
+        defaultValue: "localhost"
+      },
+      {
+        name: "path",
+        description: "Path for HTTP-based transports (single transport mode)",
+        options: ["--path"],
+        type: "string",
+        defaultValue: "/mcp"
+      }
+    ]);
+    return this.addSubCommand({
+      name: n,
+      description: `Start ${s.name} as an MCP server`,
+      handler: l,
+      parser: u,
+      isMcp: !0
+    }), this;
+  }
+  /**
+   * Factory method to create an ArgParser instance with MCP capabilities
+   * This provides a clean API for users who want MCP functionality from the start
+   */
+  static withMcp(n, s) {
+    return new ye(n, s);
+  }
+  /**
+   * Convert an existing ArgParserBase instance to ArgParser with MCP
+   * This allows upgrading existing parsers to support MCP
+   */
+  static fromArgParser(n) {
+    const s = n, r = new ye({
+      appName: s.getAppName(),
+      appCommandName: s.getAppCommandName(),
+      description: s.getDescription(),
+      handler: s.getHandler(),
+      handleErrors: s["#handleErrors"],
+      throwForDuplicateFlags: s["#throwForDuplicateFlags"]
+    }), a = s.flags.filter(
+      (i) => i.name !== "help"
+    );
+    a.length > 0 && r.addFlags(a);
+    const t = r;
+    return t["#subCommandName"] = s["#subCommandName"], t["#parameters"] = s["#parameters"], t["#parentParser"] = s["#parentParser"], t["#lastParseResult"] = s["#lastParseResult"], t["#inheritParentFlags"] = s["#inheritParentFlags"], t["#subCommands"] = s["#subCommands"], r;
+  }
+};
+fe = new WeakSet(), xe = async function(n, s, r) {
+  switch (r.type) {
+    case "stdio": {
+      const { StdioServerTransport: a } = await import("./stdio-Cf19UQO7.js"), t = new a();
+      await n.connect(t), console.error(`[${s.name}] MCP Server started with stdio transport`);
+      break;
+    }
+    case "sse": {
+      const { SSEServerTransport: a } = await import("./sse-DSjLfGFo.js"), t = (await import("express")).default, i = t();
+      i.use(t.json());
+      const o = r.port || 3e3, l = r.path || "/sse";
+      i.get(l, (u, d) => {
+        const f = new a(l, d);
+        n.connect(f);
+      }), await new Promise((u) => {
+        i.listen(o, r.host || "localhost", () => {
+          console.error(`[${s.name}] MCP Server listening on http://${r.host || "localhost"}:${o}${l} (SSE)`), u();
+        });
+      });
+      break;
+    }
+    case "streamable-http": {
+      const { StreamableHTTPServerTransport: a } = await import("./streamableHttp-DXIdDSbF.js"), t = (await import("express")).default, i = t();
+      i.use(t.json());
+      const o = r.port || 3e3, l = r.path || "/mcp", u = {};
+      i.all(l, async (d, f) => {
+        const b = d.headers["mcp-session-id"];
+        let h;
+        b && u[b] ? h = u[b] : (h = new a({
+          sessionIdGenerator: r.sessionIdGenerator || (() => Math.random().toString(36).substring(7)),
+          onsessioninitialized: (v) => {
+            u[v] = h;
+          }
+        }), h.onclose = () => {
+          h.sessionId && delete u[h.sessionId];
+        }, await n.connect(h)), await h.handleRequest(d, f, d.body);
+      }), await new Promise((d) => {
+        i.listen(o, r.host || "localhost", () => {
+          console.error(`[${s.name}] MCP Server listening on http://${r.host || "localhost"}:${o}${l} (HTTP)`), d();
+        });
+      });
+      break;
+    }
+    default:
+      throw new Error(`Unsupported transport type: ${r.type}`);
+  }
 };
-let se = W;
+let Ie = ye;
+class gt {
+  constructor(e, n = {}) {
+    this.parser = e, this.options = {
+      maxDepth: n.maxDepth ?? 5,
+      randomTestCases: n.randomTestCases ?? 10,
+      includePerformance: n.includePerformance ?? !0,
+      testErrorCases: n.testErrorCases ?? !0,
+      verbose: n.verbose ?? !1
+    };
+  }
+  /**
+   * Run comprehensive fuzzy testing on the ArgParser instance
+   */
+  async runFuzzyTest() {
+    const e = this.discoverCommandPaths(), n = [];
+    this.options.verbose && (console.log(`Discovered ${e.length} command paths:`), e.forEach((s) => console.log(`  ${s.join(" ") || "(root)"}`)));
+    for (const s of e) {
+      const r = await this.testCommandPath(s);
+      n.push(...r);
+    }
+    return this.generateReport(e, n);
+  }
+  /**
+   * Discover all possible command paths in the parser
+   */
+  discoverCommandPaths() {
+    const e = [];
+    return e.push([]), this.discoverSubCommandPaths(this.parser, [], e, 0), e;
+  }
+  /**
+   * Recursively discover subcommand paths
+   */
+  discoverSubCommandPaths(e, n, s, r) {
+    if (r >= this.options.maxDepth) return;
+    const a = this.getSubCommands(e);
+    for (const [t, i] of a) {
+      const o = [...n, t];
+      s.push(o), this.discoverSubCommandPaths(i.parser, o, s, r + 1);
+    }
+  }
+  /**
+   * Get subcommands from a parser instance
+   */
+  getSubCommands(e) {
+    return e.getSubCommands();
+  }
+  /**
+   * Get flags from a parser instance
+   */
+  getFlags(e) {
+    return e.flags;
+  }
+  /**
+   * Test a specific command path with various flag combinations
+   */
+  async testCommandPath(e) {
+    const n = [], s = this.getParserForPath(e), r = this.getFlags(s);
+    this.options.verbose && console.log(`Testing command path: ${e.join(" ") || "(root)"}`);
+    const a = this.generateValidFlagCombinations(r);
+    for (const t of a) {
+      const i = [...e, ...t], o = await this.executeTest(i, e);
+      n.push(o);
+    }
+    for (let t = 0; t < this.options.randomTestCases; t++) {
+      const i = this.generateRandomFlagCombination(r), o = [...e, ...i], l = await this.executeTest(o, e);
+      n.push(l);
+    }
+    if (this.options.testErrorCases) {
+      const t = this.generateErrorCases(r);
+      for (const i of t) {
+        const o = [...e, ...i], l = await this.executeTest(o, e, !0);
+        n.push(l);
+      }
+    }
+    return n;
+  }
+  /**
+   * Get the parser instance for a specific command path
+   */
+  getParserForPath(e) {
+    let n = this.parser;
+    for (const s of e) {
+      const a = this.getSubCommands(n).get(s);
+      if (!a)
+        throw new Error(`Command path not found: ${e.join(" ")}`);
+      n = a.parser;
+    }
+    return n;
+  }
+  /**
+   * Generate valid flag combinations for testing
+   */
+  generateValidFlagCombinations(e) {
+    const n = [], s = e.filter(
+      (t) => t.name !== "help" && (typeof t.mandatory == "boolean" ? t.mandatory : !1)
+    ), r = e.filter(
+      (t) => t.name !== "help" && (typeof t.mandatory == "boolean" ? !t.mandatory : !0)
+    ), a = [];
+    for (const t of s) {
+      const i = this.generateFlagArgs(t, "valid");
+      a.push(...i);
+    }
+    a.length > 0 ? n.push([...a]) : n.push([]);
+    for (const t of r) {
+      const i = this.generateFlagArgs(t, "valid");
+      i.length > 0 && n.push([...a, ...i]);
+    }
+    if (r.length > 1)
+      for (let t = 0; t < r.length - 1; t++)
+        for (let i = t + 1; i < r.length; i++) {
+          const o = this.generateFlagArgs(r[t], "valid"), l = this.generateFlagArgs(r[i], "valid");
+          o.length > 0 && l.length > 0 && n.push([...a, ...o, ...l]);
+        }
+    return n;
+  }
+  /**
+   * Generate random flag combination
+   */
+  generateRandomFlagCombination(e) {
+    const n = [], s = e.filter((r) => r.name !== "help");
+    for (const r of s)
+      if (Math.random() < 0.3) {
+        const a = this.generateFlagArgs(r, "random");
+        n.push(...a);
+      }
+    return n;
+  }
+  /**
+   * Generate error test cases
+   */
+  generateErrorCases(e) {
+    const n = [];
+    n.push(["--invalid-flag"]), n.push(["--nonexistent", "value"]);
+    for (const s of e) {
+      if (s.name === "help") continue;
+      const r = this.generateFlagArgs(s, "invalid");
+      r.length > 0 && n.push(r);
+    }
+    return n;
+  }
+  /**
+   * Generate arguments for a specific flag
+   */
+  generateFlagArgs(e, n) {
+    const s = e.options[0];
+    if (!s) return [];
+    if (e.flagOnly)
+      return [s];
+    const r = this.generateFlagValues(e, n), a = [];
+    for (const t of r)
+      e.allowLigature && Math.random() < 0.5 ? a.push(`${s}=${t}`) : a.push(s, t);
+    return a;
+  }
+  /**
+   * Generate values for a flag based on its type and constraints
+   */
+  generateFlagValues(e, n) {
+    const s = e.allowMultiple && n !== "invalid" ? Math.floor(Math.random() * 3) + 1 : 1, r = [];
+    for (let a = 0; a < s; a++)
+      r.push(this.generateSingleFlagValue(e, n));
+    return r;
+  }
+  /**
+   * Generate a single value for a flag
+   */
+  generateSingleFlagValue(e, n) {
+    if (n === "invalid")
+      return e.type === Number ? "not-a-number" : e.enum && e.enum.length > 0 ? "invalid-enum-value" : e.type === Boolean ? "not-boolean" : "invalid-value";
+    if (e.enum && e.enum.length > 0) {
+      const r = Math.floor(Math.random() * e.enum.length);
+      return String(e.enum[r]);
+    }
+    if (e.type === Number)
+      return String(Math.floor(Math.random() * 1e3));
+    if (e.type === Boolean)
+      return Math.random() < 0.5 ? "true" : "false";
+    const s = [
+      "test-value",
+      "hello-world",
+      "file.txt",
+      "/path/to/file",
+      "user@example.com",
+      "123",
+      "special-chars-!@#"
+    ];
+    return s[Math.floor(Math.random() * s.length)];
+  }
+  /**
+   * Execute a single test case
+   */
+  async executeTest(e, n, s = !1) {
+    const r = this.options.includePerformance ? Date.now() : 0;
+    try {
+      const a = [...e], t = this.parser.parse(e, {
+        skipHelpHandling: !0
+      });
+      t && typeof t == "object" && (t._originalInputArgs = a);
+      const i = this.options.includePerformance ? Date.now() - r : void 0;
+      return {
+        commandPath: n,
+        args: e,
+        success: !s,
+        parsedResult: t,
+        executionTime: i
+      };
+    } catch (a) {
+      const t = this.options.includePerformance ? Date.now() - r : void 0;
+      return {
+        commandPath: n,
+        args: e,
+        success: s,
+        error: a instanceof Error ? a.message : String(a),
+        executionTime: t
+      };
+    }
+  }
+  /**
+   * Generate comprehensive test report
+   */
+  generateReport(e, n) {
+    const s = n.length, r = n.filter((o) => o.success).length, a = s - r, t = {};
+    for (const o of e) {
+      const l = o.join(" ") || "(root)", u = n.filter(
+        (d) => JSON.stringify(d.commandPath) === JSON.stringify(o)
+      );
+      t[l] = {
+        total: u.length,
+        passed: u.filter((d) => d.success).length
+      };
+    }
+    const i = {};
+    for (const o of n)
+      if (o.error) {
+        const l = o.error.split(":")[0] || "Unknown";
+        i[l] = (i[l] || 0) + 1;
+      }
+    return {
+      totalTests: s,
+      successfulTests: r,
+      failedTests: a,
+      commandPaths: e,
+      results: n,
+      summary: {
+        coverageByPath: t,
+        errorTypes: i
+      }
+    };
+  }
+}
 export {
-  se as ArgParser,
-  R as ArgParserError
+  Ie as ArgParser,
+  he as ArgParserBase,
+  Y as ArgParserError,
+  gt as ArgParserFuzzyTester,
+  dt as generateMcpToolsFromArgParser,
+  ct as zodFlagSchema
 };
 //# sourceMappingURL=index.min.mjs.map