@modern-js/create 2.10.0 → 2.12.0

package/dist/index.js

@@ -33111,55 +33111,58 @@ var require_recursive_readdir = __commonJS({
 var require_commander = __commonJS({
   "../utils/compiled/commander/index.js"(exports, module2) {
     (() => {
-      var e = { 81: (e2) => {
+      var t = { 81: (t2) => {
         "use strict";
-        e2.exports = require("child_process");
-      }, 361: (e2) => {
+        t2.exports = require("child_process");
+      }, 361: (t2) => {
         "use strict";
-        e2.exports = require("events");
-      }, 147: (e2) => {
+        t2.exports = require("events");
+      }, 147: (t2) => {
         "use strict";
-        e2.exports = require("fs");
-      }, 17: (e2) => {
+        t2.exports = require("fs");
+      }, 17: (t2) => {
         "use strict";
-        e2.exports = require("path");
-      }, 922: (e2, t2, i2) => {
-        const { Argument: n } = i2(969);
-        const { Command: s } = i2(694);
-        const { CommanderError: r, InvalidArgumentError: o } = i2(967);
-        const { Help: a } = i2(34);
-        const { Option: h } = i2(278);
-        t2 = e2.exports = new s();
-        t2.program = t2;
-        t2.Argument = n;
-        t2.Command = s;
-        t2.CommanderError = r;
-        t2.Help = a;
-        t2.InvalidArgumentError = o;
-        t2.InvalidOptionArgumentError = o;
-        t2.Option = h;
-      }, 969: (e2, t2, i2) => {
-        const { InvalidArgumentError: n } = i2(967);
+        t2.exports = require("path");
+      }, 282: (t2) => {
+        "use strict";
+        t2.exports = require("process");
+      }, 632: (t2, e2, i2) => {
+        const { Argument: n } = i2(535);
+        const { Command: s } = i2(302);
+        const { CommanderError: r, InvalidArgumentError: o } = i2(796);
+        const { Help: a } = i2(519);
+        const { Option: l } = i2(437);
+        e2 = t2.exports = new s();
+        e2.program = e2;
+        e2.Argument = n;
+        e2.Command = s;
+        e2.CommanderError = r;
+        e2.Help = a;
+        e2.InvalidArgumentError = o;
+        e2.InvalidOptionArgumentError = o;
+        e2.Option = l;
+      }, 535: (t2, e2, i2) => {
+        const { InvalidArgumentError: n } = i2(796);
         class Argument {
-          constructor(e3, t3) {
-            this.description = t3 || "";
+          constructor(t3, e3) {
+            this.description = e3 || "";
             this.variadic = false;
             this.parseArg = void 0;
             this.defaultValue = void 0;
             this.defaultValueDescription = void 0;
             this.argChoices = void 0;
-            switch (e3[0]) {
+            switch (t3[0]) {
               case "<":
                 this.required = true;
-                this._name = e3.slice(1, -1);
+                this._name = t3.slice(1, -1);
                 break;
               case "[":
                 this.required = false;
-                this._name = e3.slice(1, -1);
+                this._name = t3.slice(1, -1);
                 break;
               default:
                 this.required = true;
-                this._name = e3;
+                this._name = t3;
                 break;
             }
             if (this._name.length > 3 && this._name.slice(-3) === "...") {
@@ -33170,31 +33173,31 @@ var require_commander = __commonJS({
           name() {
             return this._name;
           }
-          _concatValue(e3, t3) {
-            if (t3 === this.defaultValue || !Array.isArray(t3)) {
-              return [e3];
+          _concatValue(t3, e3) {
+            if (e3 === this.defaultValue || !Array.isArray(e3)) {
+              return [t3];
             }
-            return t3.concat(e3);
+            return e3.concat(t3);
           }
-          default(e3, t3) {
-            this.defaultValue = e3;
-            this.defaultValueDescription = t3;
+          default(t3, e3) {
+            this.defaultValue = t3;
+            this.defaultValueDescription = e3;
             return this;
           }
-          argParser(e3) {
-            this.parseArg = e3;
+          argParser(t3) {
+            this.parseArg = t3;
             return this;
           }
-          choices(e3) {
-            this.argChoices = e3;
-            this.parseArg = (t3, i3) => {
-              if (!e3.includes(t3)) {
-                throw new n(`Allowed choices are ${e3.join(", ")}.`);
+          choices(t3) {
+            this.argChoices = t3.slice();
+            this.parseArg = (t4, e3) => {
+              if (!this.argChoices.includes(t4)) {
+                throw new n(`Allowed choices are ${this.argChoices.join(", ")}.`);
               }
               if (this.variadic) {
-                return this._concatValue(t3, i3);
+                return this._concatValue(t4, e3);
               }
-              return t3;
+              return t4;
             };
             return this;
           }
@@ -33207,24 +33210,25 @@ var require_commander = __commonJS({
             return this;
           }
         }
-        function humanReadableArgName(e3) {
-          const t3 = e3.name() + (e3.variadic === true ? "..." : "");
-          return e3.required ? "<" + t3 + ">" : "[" + t3 + "]";
+        function humanReadableArgName(t3) {
+          const e3 = t3.name() + (t3.variadic === true ? "..." : "");
+          return t3.required ? "<" + e3 + ">" : "[" + e3 + "]";
         }
-        t2.Argument = Argument;
-        t2.humanReadableArgName = humanReadableArgName;
-      }, 694: (e2, t2, i2) => {
+        e2.Argument = Argument;
+        e2.humanReadableArgName = humanReadableArgName;
+      }, 302: (t2, e2, i2) => {
         const n = i2(361).EventEmitter;
         const s = i2(81);
         const r = i2(17);
         const o = i2(147);
-        const { Argument: a, humanReadableArgName: h } = i2(969);
-        const { CommanderError: l } = i2(967);
-        const { Help: u } = i2(34);
-        const { Option: c, splitOptionFlags: p } = i2(278);
-        const { suggestSimilar: m } = i2(461);
+        const a = i2(282);
+        const { Argument: l, humanReadableArgName: h } = i2(535);
+        const { CommanderError: u } = i2(796);
+        const { Help: c } = i2(519);
+        const { Option: p, splitOptionFlags: m, DualOptions: d } = i2(437);
+        const { suggestSimilar: f } = i2(860);
         class Command3 extends n {
-          constructor(e3) {
+          constructor(t3) {
             super();
             this.commands = [];
             this.options = [];
@@ -33236,25 +33240,27 @@ var require_commander = __commonJS({
             this.rawArgs = [];
             this.processedArgs = [];
             this._scriptPath = null;
-            this._name = e3 || "";
+            this._name = t3 || "";
             this._optionValues = {};
             this._optionValueSources = {};
             this._storeOptionsAsProperties = false;
             this._actionHandler = null;
             this._executableHandler = false;
             this._executableFile = null;
+            this._executableDir = null;
             this._defaultCommandName = null;
             this._exitCallback = null;
             this._aliases = [];
             this._combineFlagAndOptionalValue = true;
             this._description = "";
+            this._summary = "";
             this._argsDescription = void 0;
             this._enablePositionalOptions = false;
             this._passThroughOptions = false;
             this._lifeCycleHooks = {};
             this._showHelpAfterError = false;
-            this._showSuggestionAfterError = false;
-            this._outputConfiguration = { writeOut: (e4) => process.stdout.write(e4), writeErr: (e4) => process.stderr.write(e4), getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : void 0, getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : void 0, outputError: (e4, t3) => t3(e4) };
+            this._showSuggestionAfterError = true;
+            this._outputConfiguration = { writeOut: (t4) => a.stdout.write(t4), writeErr: (t4) => a.stderr.write(t4), getOutHelpWidth: () => a.stdout.isTTY ? a.stdout.columns : void 0, getErrHelpWidth: () => a.stderr.isTTY ? a.stderr.columns : void 0, outputError: (t4, e3) => e3(t4) };
             this._hidden = false;
             this._hasHelpOption = true;
             this._helpFlags = "-h, --help";
@@ -33267,35 +33273,35 @@ var require_commander = __commonJS({
             this._helpCommandDescription = "display help for command";
             this._helpConfiguration = {};
           }
-          copyInheritedSettings(e3) {
-            this._outputConfiguration = e3._outputConfiguration;
-            this._hasHelpOption = e3._hasHelpOption;
-            this._helpFlags = e3._helpFlags;
-            this._helpDescription = e3._helpDescription;
-            this._helpShortFlag = e3._helpShortFlag;
-            this._helpLongFlag = e3._helpLongFlag;
-            this._helpCommandName = e3._helpCommandName;
-            this._helpCommandnameAndArgs = e3._helpCommandnameAndArgs;
-            this._helpCommandDescription = e3._helpCommandDescription;
-            this._helpConfiguration = e3._helpConfiguration;
-            this._exitCallback = e3._exitCallback;
-            this._storeOptionsAsProperties = e3._storeOptionsAsProperties;
-            this._combineFlagAndOptionalValue = e3._combineFlagAndOptionalValue;
-            this._allowExcessArguments = e3._allowExcessArguments;
-            this._enablePositionalOptions = e3._enablePositionalOptions;
-            this._showHelpAfterError = e3._showHelpAfterError;
-            this._showSuggestionAfterError = e3._showSuggestionAfterError;
+          copyInheritedSettings(t3) {
+            this._outputConfiguration = t3._outputConfiguration;
+            this._hasHelpOption = t3._hasHelpOption;
+            this._helpFlags = t3._helpFlags;
+            this._helpDescription = t3._helpDescription;
+            this._helpShortFlag = t3._helpShortFlag;
+            this._helpLongFlag = t3._helpLongFlag;
+            this._helpCommandName = t3._helpCommandName;
+            this._helpCommandnameAndArgs = t3._helpCommandnameAndArgs;
+            this._helpCommandDescription = t3._helpCommandDescription;
+            this._helpConfiguration = t3._helpConfiguration;
+            this._exitCallback = t3._exitCallback;
+            this._storeOptionsAsProperties = t3._storeOptionsAsProperties;
+            this._combineFlagAndOptionalValue = t3._combineFlagAndOptionalValue;
+            this._allowExcessArguments = t3._allowExcessArguments;
+            this._enablePositionalOptions = t3._enablePositionalOptions;
+            this._showHelpAfterError = t3._showHelpAfterError;
+            this._showSuggestionAfterError = t3._showSuggestionAfterError;
             return this;
           }
-          command(e3, t3, i3) {
-            let n2 = t3;
+          command(t3, e3, i3) {
+            let n2 = e3;
             let s2 = i3;
             if (typeof n2 === "object" && n2 !== null) {
               s2 = n2;
               n2 = null;
             }
             s2 = s2 || {};
-            const [, r2, o2] = e3.match(/([^ ]+) *(.*)/);
+            const [, r2, o2] = t3.match(/([^ ]+) *(.*)/);
             const a2 = this.createCommand(r2);
             if (n2) {
               a2.description(n2);
@@ -33314,60 +33320,53 @@ var require_commander = __commonJS({
               return this;
             return a2;
           }
-          createCommand(e3) {
-            return new Command3(e3);
+          createCommand(t3) {
+            return new Command3(t3);
           }
           createHelp() {
-            return Object.assign(new u(), this.configureHelp());
+            return Object.assign(new c(), this.configureHelp());
           }
-          configureHelp(e3) {
-            if (e3 === void 0)
+          configureHelp(t3) {
+            if (t3 === void 0)
               return this._helpConfiguration;
-            this._helpConfiguration = e3;
+            this._helpConfiguration = t3;
             return this;
           }
-          configureOutput(e3) {
-            if (e3 === void 0)
+          configureOutput(t3) {
+            if (t3 === void 0)
               return this._outputConfiguration;
-            Object.assign(this._outputConfiguration, e3);
+            Object.assign(this._outputConfiguration, t3);
             return this;
           }
-          showHelpAfterError(e3 = true) {
-            if (typeof e3 !== "string")
-              e3 = !!e3;
-            this._showHelpAfterError = e3;
+          showHelpAfterError(t3 = true) {
+            if (typeof t3 !== "string")
+              t3 = !!t3;
+            this._showHelpAfterError = t3;
             return this;
           }
-          showSuggestionAfterError(e3 = true) {
-            this._showSuggestionAfterError = !!e3;
+          showSuggestionAfterError(t3 = true) {
+            this._showSuggestionAfterError = !!t3;
             return this;
           }
-          addCommand(e3, t3) {
-            if (!e3._name)
-              throw new Error("Command passed to .addCommand() must have a name");
-            function checkExplicitNames(e4) {
-              e4.forEach((e5) => {
-                if (e5._executableHandler && !e5._executableFile) {
-                  throw new Error(`Must specify executableFile for deeply nested executable: ${e5.name()}`);
-                }
-                checkExplicitNames(e5.commands);
-              });
+          addCommand(t3, e3) {
+            if (!t3._name) {
+              throw new Error(`Command passed to .addCommand() must have a name
+- specify the name in Command constructor or using .name()`);
             }
-            checkExplicitNames(e3.commands);
-            t3 = t3 || {};
-            if (t3.isDefault)
-              this._defaultCommandName = e3._name;
-            if (t3.noHelp || t3.hidden)
-              e3._hidden = true;
-            this.commands.push(e3);
-            e3.parent = this;
+            e3 = e3 || {};
+            if (e3.isDefault)
+              this._defaultCommandName = t3._name;
+            if (e3.noHelp || e3.hidden)
+              t3._hidden = true;
+            this.commands.push(t3);
+            t3.parent = this;
             return this;
           }
-          createArgument(e3, t3) {
-            return new a(e3, t3);
+          createArgument(t3, e3) {
+            return new l(t3, e3);
           }
-          argument(e3, t3, i3, n2) {
-            const s2 = this.createArgument(e3, t3);
+          argument(t3, e3, i3, n2) {
+            const s2 = this.createArgument(t3, e3);
             if (typeof i3 === "function") {
               s2.default(n2).argParser(i3);
             } else {
@@ -33376,33 +33375,33 @@ var require_commander = __commonJS({
             this.addArgument(s2);
             return this;
           }
-          arguments(e3) {
-            e3.split(/ +/).forEach((e4) => {
-              this.argument(e4);
+          arguments(t3) {
+            t3.split(/ +/).forEach((t4) => {
+              this.argument(t4);
             });
             return this;
           }
-          addArgument(e3) {
-            const t3 = this._args.slice(-1)[0];
-            if (t3 && t3.variadic) {
-              throw new Error(`only the last argument can be variadic '${t3.name()}'`);
+          addArgument(t3) {
+            const e3 = this._args.slice(-1)[0];
+            if (e3 && e3.variadic) {
+              throw new Error(`only the last argument can be variadic '${e3.name()}'`);
             }
-            if (e3.required && e3.defaultValue !== void 0 && e3.parseArg === void 0) {
-              throw new Error(`a default value for a required argument is never used: '${e3.name()}'`);
+            if (t3.required && t3.defaultValue !== void 0 && t3.parseArg === void 0) {
+              throw new Error(`a default value for a required argument is never used: '${t3.name()}'`);
             }
-            this._args.push(e3);
+            this._args.push(t3);
             return this;
           }
-          addHelpCommand(e3, t3) {
-            if (e3 === false) {
+          addHelpCommand(t3, e3) {
+            if (t3 === false) {
               this._addImplicitHelpCommand = false;
             } else {
               this._addImplicitHelpCommand = true;
-              if (typeof e3 === "string") {
-                this._helpCommandName = e3.split(" ")[0];
-                this._helpCommandnameAndArgs = e3;
+              if (typeof t3 === "string") {
+                this._helpCommandName = t3.split(" ")[0];
+                this._helpCommandnameAndArgs = t3;
               }
-              this._helpCommandDescription = t3 || this._helpCommandDescription;
+              this._helpCommandDescription = e3 || this._helpCommandDescription;
             }
             return this;
           }
@@ -33412,116 +33411,121 @@ var require_commander = __commonJS({
             }
             return this._addImplicitHelpCommand;
           }
-          hook(e3, t3) {
-            const i3 = ["preAction", "postAction"];
-            if (!i3.includes(e3)) {
-              throw new Error(`Unexpected value for event passed to hook : '${e3}'.
+          hook(t3, e3) {
+            const i3 = ["preSubcommand", "preAction", "postAction"];
+            if (!i3.includes(t3)) {
+              throw new Error(`Unexpected value for event passed to hook : '${t3}'.
 Expecting one of '${i3.join("', '")}'`);
             }
-            if (this._lifeCycleHooks[e3]) {
-              this._lifeCycleHooks[e3].push(t3);
+            if (this._lifeCycleHooks[t3]) {
+              this._lifeCycleHooks[t3].push(e3);
             } else {
-              this._lifeCycleHooks[e3] = [t3];
+              this._lifeCycleHooks[t3] = [e3];
             }
             return this;
           }
-          exitOverride(e3) {
-            if (e3) {
-              this._exitCallback = e3;
+          exitOverride(t3) {
+            if (t3) {
+              this._exitCallback = t3;
             } else {
-              this._exitCallback = (e4) => {
-                if (e4.code !== "commander.executeSubCommandAsync") {
-                  throw e4;
+              this._exitCallback = (t4) => {
+                if (t4.code !== "commander.executeSubCommandAsync") {
+                  throw t4;
                 } else {
                 }
               };
             }
             return this;
           }
-          _exit(e3, t3, i3) {
+          _exit(t3, e3, i3) {
             if (this._exitCallback) {
-              this._exitCallback(new l(e3, t3, i3));
+              this._exitCallback(new u(t3, e3, i3));
             }
-            process.exit(e3);
+            a.exit(t3);
           }
-          action(e3) {
-            const listener = (t3) => {
+          action(t3) {
+            const listener = (e3) => {
               const i3 = this._args.length;
-              const n2 = t3.slice(0, i3);
+              const n2 = e3.slice(0, i3);
               if (this._storeOptionsAsProperties) {
                 n2[i3] = this;
               } else {
                 n2[i3] = this.opts();
               }
               n2.push(this);
-              return e3.apply(this, n2);
+              return t3.apply(this, n2);
             };
             this._actionHandler = listener;
             return this;
           }
-          createOption(e3, t3) {
-            return new c(e3, t3);
+          createOption(t3, e3) {
+            return new p(t3, e3);
           }
-          addOption(e3) {
-            const t3 = e3.name();
-            const i3 = e3.attributeName();
-            let n2 = e3.defaultValue;
-            if (e3.negate || e3.optional || e3.required || typeof n2 === "boolean") {
-              if (e3.negate) {
-                const t4 = e3.long.replace(/^--no-/, "--");
-                n2 = this._findOption(t4) ? this.getOptionValue(i3) : true;
-              }
-              if (n2 !== void 0) {
-                this.setOptionValueWithSource(i3, n2, "default");
+          addOption(t3) {
+            const e3 = t3.name();
+            const i3 = t3.attributeName();
+            if (t3.negate) {
+              const e4 = t3.long.replace(/^--no-/, "--");
+              if (!this._findOption(e4)) {
+                this.setOptionValueWithSource(i3, t3.defaultValue === void 0 ? true : t3.defaultValue, "default");
               }
+            } else if (t3.defaultValue !== void 0) {
+              this.setOptionValueWithSource(i3, t3.defaultValue, "default");
             }
-            this.options.push(e3);
-            const handleOptionValue = (t4, s2, r2) => {
-              const o2 = this.getOptionValue(i3);
-              if (t4 !== null && e3.parseArg) {
+            this.options.push(t3);
+            const handleOptionValue = (e4, n2, s2) => {
+              if (e4 == null && t3.presetArg !== void 0) {
+                e4 = t3.presetArg;
+              }
+              const r2 = this.getOptionValue(i3);
+              if (e4 !== null && t3.parseArg) {
                 try {
-                  t4 = e3.parseArg(t4, o2 === void 0 ? n2 : o2);
-                } catch (e4) {
-                  if (e4.code === "commander.invalidArgument") {
-                    const t5 = `${s2} ${e4.message}`;
-                    this._displayError(e4.exitCode, e4.code, t5);
+                  e4 = t3.parseArg(e4, r2);
+                } catch (t4) {
+                  if (t4.code === "commander.invalidArgument") {
+                    const e5 = `${n2} ${t4.message}`;
+                    this.error(e5, { exitCode: t4.exitCode, code: t4.code });
                   }
-                  throw e4;
+                  throw t4;
                 }
-              } else if (t4 !== null && e3.variadic) {
-                t4 = e3._concatValue(t4, o2);
-              }
-              if (typeof o2 === "boolean" || typeof o2 === "undefined") {
-                if (t4 == null) {
-                  this.setOptionValueWithSource(i3, e3.negate ? false : n2 || true, r2);
+              } else if (e4 !== null && t3.variadic) {
+                e4 = t3._concatValue(e4, r2);
+              }
+              if (e4 == null) {
+                if (t3.negate) {
+                  e4 = false;
+                } else if (t3.isBoolean() || t3.optional) {
+                  e4 = true;
                 } else {
-                  this.setOptionValueWithSource(i3, t4, r2);
+                  e4 = "";
                 }
-              } else if (t4 !== null) {
-                this.setOptionValueWithSource(i3, e3.negate ? false : t4, r2);
               }
+              this.setOptionValueWithSource(i3, e4, s2);
             };
-            this.on("option:" + t3, (t4) => {
-              const i4 = `error: option '${e3.flags}' argument '${t4}' is invalid.`;
-              handleOptionValue(t4, i4, "cli");
+            this.on("option:" + e3, (e4) => {
+              const i4 = `error: option '${t3.flags}' argument '${e4}' is invalid.`;
+              handleOptionValue(e4, i4, "cli");
             });
-            if (e3.envVar) {
-              this.on("optionEnv:" + t3, (t4) => {
-                const i4 = `error: option '${e3.flags}' value '${t4}' from env '${e3.envVar}' is invalid.`;
-                handleOptionValue(t4, i4, "env");
+            if (t3.envVar) {
+              this.on("optionEnv:" + e3, (e4) => {
+                const i4 = `error: option '${t3.flags}' value '${e4}' from env '${t3.envVar}' is invalid.`;
+                handleOptionValue(e4, i4, "env");
               });
             }
             return this;
           }
-          _optionEx(e3, t3, i3, n2, s2) {
-            const r2 = this.createOption(t3, i3);
-            r2.makeOptionMandatory(!!e3.mandatory);
+          _optionEx(t3, e3, i3, n2, s2) {
+            if (typeof e3 === "object" && e3 instanceof p) {
+              throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
+            }
+            const r2 = this.createOption(e3, i3);
+            r2.makeOptionMandatory(!!t3.mandatory);
             if (typeof n2 === "function") {
               r2.default(s2).argParser(n2);
             } else if (n2 instanceof RegExp) {
-              const e4 = n2;
-              n2 = (t4, i4) => {
-                const n3 = e4.exec(t4);
+              const t4 = n2;
+              n2 = (e4, i4) => {
+                const n3 = t4.exec(e4);
                 return n3 ? n3[0] : i4;
               };
               r2.default(s2).argParser(n2);
@@ -33530,209 +33534,233 @@ Expecting one of '${i3.join("', '")}'`);
             }
             return this.addOption(r2);
           }
-          option(e3, t3, i3, n2) {
-            return this._optionEx({}, e3, t3, i3, n2);
+          option(t3, e3, i3, n2) {
+            return this._optionEx({}, t3, e3, i3, n2);
           }
-          requiredOption(e3, t3, i3, n2) {
-            return this._optionEx({ mandatory: true }, e3, t3, i3, n2);
+          requiredOption(t3, e3, i3, n2) {
+            return this._optionEx({ mandatory: true }, t3, e3, i3, n2);
           }
-          combineFlagAndOptionalValue(e3 = true) {
-            this._combineFlagAndOptionalValue = !!e3;
+          combineFlagAndOptionalValue(t3 = true) {
+            this._combineFlagAndOptionalValue = !!t3;
             return this;
           }
-          allowUnknownOption(e3 = true) {
-            this._allowUnknownOption = !!e3;
+          allowUnknownOption(t3 = true) {
+            this._allowUnknownOption = !!t3;
             return this;
           }
-          allowExcessArguments(e3 = true) {
-            this._allowExcessArguments = !!e3;
+          allowExcessArguments(t3 = true) {
+            this._allowExcessArguments = !!t3;
             return this;
           }
-          enablePositionalOptions(e3 = true) {
-            this._enablePositionalOptions = !!e3;
+          enablePositionalOptions(t3 = true) {
+            this._enablePositionalOptions = !!t3;
             return this;
           }
-          passThroughOptions(e3 = true) {
-            this._passThroughOptions = !!e3;
-            if (!!this.parent && e3 && !this.parent._enablePositionalOptions) {
+          passThroughOptions(t3 = true) {
+            this._passThroughOptions = !!t3;
+            if (!!this.parent && t3 && !this.parent._enablePositionalOptions) {
               throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
             }
             return this;
           }
-          storeOptionsAsProperties(e3 = true) {
-            this._storeOptionsAsProperties = !!e3;
+          storeOptionsAsProperties(t3 = true) {
+            this._storeOptionsAsProperties = !!t3;
             if (this.options.length) {
               throw new Error("call .storeOptionsAsProperties() before adding options");
             }
             return this;
           }
-          getOptionValue(e3) {
+          getOptionValue(t3) {
             if (this._storeOptionsAsProperties) {
-              return this[e3];
+              return this[t3];
             }
-            return this._optionValues[e3];
+            return this._optionValues[t3];
           }
-          setOptionValue(e3, t3) {
+          setOptionValue(t3, e3) {
+            return this.setOptionValueWithSource(t3, e3, void 0);
+          }
+          setOptionValueWithSource(t3, e3, i3) {
             if (this._storeOptionsAsProperties) {
-              this[e3] = t3;
+              this[t3] = e3;
             } else {
-              this._optionValues[e3] = t3;
+              this._optionValues[t3] = e3;
             }
+            this._optionValueSources[t3] = i3;
             return this;
           }
-          setOptionValueWithSource(e3, t3, i3) {
-            this.setOptionValue(e3, t3);
-            this._optionValueSources[e3] = i3;
-            return this;
+          getOptionValueSource(t3) {
+            return this._optionValueSources[t3];
           }
-          getOptionValueSource(e3) {
-            return this._optionValueSources[e3];
+          getOptionValueSourceWithGlobals(t3) {
+            let e3;
+            getCommandAndParents(this).forEach((i3) => {
+              if (i3.getOptionValueSource(t3) !== void 0) {
+                e3 = i3.getOptionValueSource(t3);
+              }
+            });
+            return e3;
           }
-          _prepareUserArgs(e3, t3) {
-            if (e3 !== void 0 && !Array.isArray(e3)) {
+          _prepareUserArgs(t3, e3) {
+            if (t3 !== void 0 && !Array.isArray(t3)) {
               throw new Error("first parameter to parse must be array or undefined");
             }
-            t3 = t3 || {};
-            if (e3 === void 0) {
-              e3 = process.argv;
-              if (process.versions && process.versions.electron) {
-                t3.from = "electron";
+            e3 = e3 || {};
+            if (t3 === void 0) {
+              t3 = a.argv;
+              if (a.versions && a.versions.electron) {
+                e3.from = "electron";
               }
             }
-            this.rawArgs = e3.slice();
+            this.rawArgs = t3.slice();
             let i3;
-            switch (t3.from) {
+            switch (e3.from) {
               case void 0:
               case "node":
-                this._scriptPath = e3[1];
-                i3 = e3.slice(2);
+                this._scriptPath = t3[1];
+                i3 = t3.slice(2);
                 break;
               case "electron":
-                if (process.defaultApp) {
-                  this._scriptPath = e3[1];
-                  i3 = e3.slice(2);
+                if (a.defaultApp) {
+                  this._scriptPath = t3[1];
+                  i3 = t3.slice(2);
                 } else {
-                  i3 = e3.slice(1);
+                  i3 = t3.slice(1);
                 }
                 break;
               case "user":
-                i3 = e3.slice(0);
+                i3 = t3.slice(0);
                 break;
               default:
-                throw new Error(`unexpected parse option { from: '${t3.from}' }`);
-            }
-            if (!this._scriptPath && require.main) {
-              this._scriptPath = require.main.filename;
+                throw new Error(`unexpected parse option { from: '${e3.from}' }`);
             }
-            this._name = this._name || this._scriptPath && r.basename(this._scriptPath, r.extname(this._scriptPath));
+            if (!this._name && this._scriptPath)
+              this.nameFromFilename(this._scriptPath);
+            this._name = this._name || "program";
             return i3;
           }
-          parse(e3, t3) {
-            const i3 = this._prepareUserArgs(e3, t3);
+          parse(t3, e3) {
+            const i3 = this._prepareUserArgs(t3, e3);
             this._parseCommand([], i3);
             return this;
           }
-          parseAsync(e3, t3) {
+          parseAsync(t3, e3) {
             return __async(this, null, function* () {
-              const i3 = this._prepareUserArgs(e3, t3);
+              const i3 = this._prepareUserArgs(t3, e3);
               yield this._parseCommand([], i3);
               return this;
             });
           }
-          _executeSubCommand(e3, t3) {
-            t3 = t3.slice();
+          _executeSubCommand(t3, e3) {
+            e3 = e3.slice();
             let i3 = false;
             const n2 = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-            this._checkForMissingMandatoryOptions();
-            let a2 = this._scriptPath;
-            if (!a2 && require.main) {
-              a2 = require.main.filename;
-            }
-            let h2;
-            try {
-              const e4 = o.realpathSync(a2);
-              h2 = r.dirname(e4);
-            } catch (e4) {
-              h2 = ".";
+            function findFile(t4, e4) {
+              const i4 = r.resolve(t4, e4);
+              if (o.existsSync(i4))
+                return i4;
+              if (n2.includes(r.extname(e4)))
+                return void 0;
+              const s2 = n2.find((t5) => o.existsSync(`${i4}${t5}`));
+              if (s2)
+                return `${i4}${s2}`;
+              return void 0;
             }
-            let u2 = r.basename(a2, r.extname(a2)) + "-" + e3._name;
-            if (e3._executableFile) {
-              u2 = e3._executableFile;
+            this._checkForMissingMandatoryOptions();
+            this._checkForConflictingOptions();
+            let l2 = t3._executableFile || `${this._name}-${t3._name}`;
+            let h2 = this._executableDir || "";
+            if (this._scriptPath) {
+              let t4;
+              try {
+                t4 = o.realpathSync(this._scriptPath);
+              } catch (e4) {
+                t4 = this._scriptPath;
+              }
+              h2 = r.resolve(r.dirname(t4), h2);
             }
-            const c2 = r.join(h2, u2);
-            if (o.existsSync(c2)) {
-              u2 = c2;
-            } else {
-              n2.forEach((e4) => {
-                if (o.existsSync(`${c2}${e4}`)) {
-                  u2 = `${c2}${e4}`;
+            if (h2) {
+              let e4 = findFile(h2, l2);
+              if (!e4 && !t3._executableFile && this._scriptPath) {
+                const i4 = r.basename(this._scriptPath, r.extname(this._scriptPath));
+                if (i4 !== this._name) {
+                  e4 = findFile(h2, `${i4}-${t3._name}`);
                 }
-              });
+              }
+              l2 = e4 || l2;
             }
-            i3 = n2.includes(r.extname(u2));
-            let p2;
-            if (process.platform !== "win32") {
+            i3 = n2.includes(r.extname(l2));
+            let c2;
+            if (a.platform !== "win32") {
               if (i3) {
-                t3.unshift(u2);
-                t3 = incrementNodeInspectorPort(process.execArgv).concat(t3);
-                p2 = s.spawn(process.argv[0], t3, { stdio: "inherit" });
+                e3.unshift(l2);
+                e3 = incrementNodeInspectorPort(a.execArgv).concat(e3);
+                c2 = s.spawn(a.argv[0], e3, { stdio: "inherit" });
               } else {
-                p2 = s.spawn(u2, t3, { stdio: "inherit" });
+                c2 = s.spawn(l2, e3, { stdio: "inherit" });
               }
             } else {
-              t3.unshift(u2);
-              t3 = incrementNodeInspectorPort(process.execArgv).concat(t3);
-              p2 = s.spawn(process.execPath, t3, { stdio: "inherit" });
-            }
-            const m2 = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-            m2.forEach((e4) => {
-              process.on(e4, () => {
-                if (p2.killed === false && p2.exitCode === null) {
-                  p2.kill(e4);
-                }
+              e3.unshift(l2);
+              e3 = incrementNodeInspectorPort(a.execArgv).concat(e3);
+              c2 = s.spawn(a.execPath, e3, { stdio: "inherit" });
+            }
+            if (!c2.killed) {
+              const t4 = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+              t4.forEach((t5) => {
+                a.on(t5, () => {
+                  if (c2.killed === false && c2.exitCode === null) {
+                    c2.kill(t5);
+                  }
+                });
               });
-            });
-            const d = this._exitCallback;
-            if (!d) {
-              p2.on("close", process.exit.bind(process));
+            }
+            const p2 = this._exitCallback;
+            if (!p2) {
+              c2.on("close", a.exit.bind(a));
             } else {
-              p2.on("close", () => {
-                d(new l(process.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+              c2.on("close", () => {
+                p2(new u(a.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
               });
             }
-            p2.on("error", (t4) => {
-              if (t4.code === "ENOENT") {
-                const t5 = `'${u2}' does not exist
- - if '${e3._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name`;
-                throw new Error(t5);
-              } else if (t4.code === "EACCES") {
-                throw new Error(`'${u2}' not executable`);
-              }
-              if (!d) {
-                process.exit(1);
+            c2.on("error", (e4) => {
+              if (e4.code === "ENOENT") {
+                const e5 = h2 ? `searched for local subcommand relative to directory '${h2}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+                const i4 = `'${l2}' does not exist
+ - if '${t3._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${e5}`;
+                throw new Error(i4);
+              } else if (e4.code === "EACCES") {
+                throw new Error(`'${l2}' not executable`);
+              }
+              if (!p2) {
+                a.exit(1);
               } else {
-                const e4 = new l(1, "commander.executeSubCommandAsync", "(error)");
-                e4.nestedError = t4;
-                d(e4);
+                const t4 = new u(1, "commander.executeSubCommandAsync", "(error)");
+                t4.nestedError = e4;
+                p2(t4);
               }
             });
-            this.runningCommand = p2;
+            this.runningCommand = c2;
           }
-          _dispatchSubcommand(e3, t3, i3) {
-            const n2 = this._findCommand(e3);
+          _dispatchSubcommand(t3, e3, i3) {
+            const n2 = this._findCommand(t3);
             if (!n2)
               this.help({ error: true });
-            if (n2._executableHandler) {
-              this._executeSubCommand(n2, t3.concat(i3));
-            } else {
-              return n2._parseCommand(t3, i3);
-            }
+            let s2;
+            s2 = this._chainOrCallSubCommandHook(s2, n2, "preSubcommand");
+            s2 = this._chainOrCall(s2, () => {
+              if (n2._executableHandler) {
+                this._executeSubCommand(n2, e3.concat(i3));
+              } else {
+                return n2._parseCommand(e3, i3);
+              }
+            });
+            return s2;
           }
           _checkNumberOfArguments() {
-            this._args.forEach((e3, t3) => {
-              if (e3.required && this.args[t3] == null) {
-                this.missingArgument(e3.name());
+            this._args.forEach((t3, e3) => {
+              if (t3.required && this.args[e3] == null) {
+                this.missingArgument(t3.name());
               }
             });
             if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
@@ -33743,15 +33771,15 @@ Expecting one of '${i3.join("', '")}'`);
             }
           }
           _processArguments() {
-            const myParseArg = (e4, t3, i3) => {
-              let n2 = t3;
-              if (t3 !== null && e4.parseArg) {
+            const myParseArg = (t4, e3, i3) => {
+              let n2 = e3;
+              if (e3 !== null && t4.parseArg) {
                 try {
-                  n2 = e4.parseArg(t3, i3);
+                  n2 = t4.parseArg(e3, i3);
                 } catch (i4) {
                   if (i4.code === "commander.invalidArgument") {
-                    const n3 = `error: command-argument value '${t3}' is invalid for argument '${e4.name()}'. ${i4.message}`;
-                    this._displayError(i4.exitCode, i4.code, n3);
+                    const n3 = `error: command-argument value '${e3}' is invalid for argument '${t4.name()}'. ${i4.message}`;
+                    this.error(n3, { exitCode: i4.exitCode, code: i4.code });
                   }
                   throw i4;
                 }
@@ -33759,74 +33787,85 @@ Expecting one of '${i3.join("', '")}'`);
               return n2;
             };
             this._checkNumberOfArguments();
-            const e3 = [];
-            this._args.forEach((t3, i3) => {
-              let n2 = t3.defaultValue;
-              if (t3.variadic) {
+            const t3 = [];
+            this._args.forEach((e3, i3) => {
+              let n2 = e3.defaultValue;
+              if (e3.variadic) {
                 if (i3 < this.args.length) {
                   n2 = this.args.slice(i3);
-                  if (t3.parseArg) {
-                    n2 = n2.reduce((e4, i4) => myParseArg(t3, i4, e4), t3.defaultValue);
+                  if (e3.parseArg) {
+                    n2 = n2.reduce((t4, i4) => myParseArg(e3, i4, t4), e3.defaultValue);
                   }
                 } else if (n2 === void 0) {
                   n2 = [];
                 }
               } else if (i3 < this.args.length) {
                 n2 = this.args[i3];
-                if (t3.parseArg) {
-                  n2 = myParseArg(t3, n2, t3.defaultValue);
+                if (e3.parseArg) {
+                  n2 = myParseArg(e3, n2, e3.defaultValue);
                 }
               }
-              e3[i3] = n2;
+              t3[i3] = n2;
             });
-            this.processedArgs = e3;
+            this.processedArgs = t3;
           }
-          _chainOrCall(e3, t3) {
-            if (e3 && e3.then && typeof e3.then === "function") {
-              return e3.then(() => t3());
+          _chainOrCall(t3, e3) {
+            if (t3 && t3.then && typeof t3.then === "function") {
+              return t3.then(() => e3());
             }
-            return t3();
+            return e3();
           }
-          _chainOrCallHooks(e3, t3) {
-            let i3 = e3;
+          _chainOrCallHooks(t3, e3) {
+            let i3 = t3;
             const n2 = [];
-            getCommandAndParents(this).reverse().filter((e4) => e4._lifeCycleHooks[t3] !== void 0).forEach((e4) => {
-              e4._lifeCycleHooks[t3].forEach((t4) => {
-                n2.push({ hookedCommand: e4, callback: t4 });
+            getCommandAndParents(this).reverse().filter((t4) => t4._lifeCycleHooks[e3] !== void 0).forEach((t4) => {
+              t4._lifeCycleHooks[e3].forEach((e4) => {
+                n2.push({ hookedCommand: t4, callback: e4 });
               });
             });
-            if (t3 === "postAction") {
+            if (e3 === "postAction") {
               n2.reverse();
             }
-            n2.forEach((e4) => {
-              i3 = this._chainOrCall(i3, () => e4.callback(e4.hookedCommand, this));
+            n2.forEach((t4) => {
+              i3 = this._chainOrCall(i3, () => t4.callback(t4.hookedCommand, this));
             });
             return i3;
           }
-          _parseCommand(e3, t3) {
-            const i3 = this.parseOptions(t3);
-            this._parseOptionsEnv();
-            e3 = e3.concat(i3.operands);
-            t3 = i3.unknown;
-            this.args = e3.concat(t3);
-            if (e3 && this._findCommand(e3[0])) {
-              return this._dispatchSubcommand(e3[0], e3.slice(1), t3);
+          _chainOrCallSubCommandHook(t3, e3, i3) {
+            let n2 = t3;
+            if (this._lifeCycleHooks[i3] !== void 0) {
+              this._lifeCycleHooks[i3].forEach((t4) => {
+                n2 = this._chainOrCall(n2, () => t4(this, e3));
+              });
             }
-            if (this._hasImplicitHelpCommand() && e3[0] === this._helpCommandName) {
-              if (e3.length === 1) {
+            return n2;
+          }
+          _parseCommand(t3, e3) {
+            const i3 = this.parseOptions(e3);
+            this._parseOptionsEnv();
+            this._parseOptionsImplied();
+            t3 = t3.concat(i3.operands);
+            e3 = i3.unknown;
+            this.args = t3.concat(e3);
+            if (t3 && this._findCommand(t3[0])) {
+              return this._dispatchSubcommand(t3[0], t3.slice(1), e3);
+            }
+            if (this._hasImplicitHelpCommand() && t3[0] === this._helpCommandName) {
+              if (t3.length === 1) {
                 this.help();
               }
-              return this._dispatchSubcommand(e3[1], [], [this._helpLongFlag]);
+              return this._dispatchSubcommand(t3[1], [], [this._helpLongFlag]);
             }
             if (this._defaultCommandName) {
-              outputHelpIfRequested(this, t3);
-              return this._dispatchSubcommand(this._defaultCommandName, e3, t3);
+              outputHelpIfRequested(this, e3);
+              return this._dispatchSubcommand(this._defaultCommandName, t3, e3);
             }
             if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
               this.help({ error: true });
             }
             outputHelpIfRequested(this, i3.unknown);
             this._checkForMissingMandatoryOptions();
+            this._checkForConflictingOptions();
             const checkForUnknownOptions = () => {
               if (i3.unknown.length > 0) {
                 this.unknownOption(i3.unknown[0]);
@@ -33839,21 +33878,24 @@ Expecting one of '${i3.join("', '")}'`);
               let i4;
               i4 = this._chainOrCallHooks(i4, "preAction");
               i4 = this._chainOrCall(i4, () => this._actionHandler(this.processedArgs));
-              if (this.parent)
-                this.parent.emit(n2, e3, t3);
+              if (this.parent) {
+                i4 = this._chainOrCall(i4, () => {
+                  this.parent.emit(n2, t3, e3);
+                });
+              }
               i4 = this._chainOrCallHooks(i4, "postAction");
               return i4;
             }
             if (this.parent && this.parent.listenerCount(n2)) {
               checkForUnknownOptions();
               this._processArguments();
-              this.parent.emit(n2, e3, t3);
-            } else if (e3.length) {
+              this.parent.emit(n2, t3, e3);
+            } else if (t3.length) {
               if (this._findCommand("*")) {
-                return this._dispatchSubcommand("*", e3, t3);
+                return this._dispatchSubcommand("*", t3, e3);
               }
               if (this.listenerCount("command:*")) {
-                this.emit("command:*", e3, t3);
+                this.emit("command:*", t3, e3);
               } else if (this.commands.length) {
                 this.unknownCommand();
               } else {
@@ -33868,131 +33910,155 @@ Expecting one of '${i3.join("', '")}'`);
               this._processArguments();
             }
           }
-          _findCommand(e3) {
-            if (!e3)
+          _findCommand(t3) {
+            if (!t3)
               return void 0;
-            return this.commands.find((t3) => t3._name === e3 || t3._aliases.includes(e3));
+            return this.commands.find((e3) => e3._name === t3 || e3._aliases.includes(t3));
           }
-          _findOption(e3) {
-            return this.options.find((t3) => t3.is(e3));
+          _findOption(t3) {
+            return this.options.find((e3) => e3.is(t3));
           }
           _checkForMissingMandatoryOptions() {
-            for (let e3 = this; e3; e3 = e3.parent) {
-              e3.options.forEach((t3) => {
-                if (t3.mandatory && e3.getOptionValue(t3.attributeName()) === void 0) {
-                  e3.missingMandatoryOptionValue(t3);
+            for (let t3 = this; t3; t3 = t3.parent) {
+              t3.options.forEach((e3) => {
+                if (e3.mandatory && t3.getOptionValue(e3.attributeName()) === void 0) {
+                  t3.missingMandatoryOptionValue(e3);
                 }
               });
             }
           }
-          parseOptions(e3) {
-            const t3 = [];
+          _checkForConflictingLocalOptions() {
+            const t3 = this.options.filter((t4) => {
+              const e4 = t4.attributeName();
+              if (this.getOptionValue(e4) === void 0) {
+                return false;
+              }
+              return this.getOptionValueSource(e4) !== "default";
+            });
+            const e3 = t3.filter((t4) => t4.conflictsWith.length > 0);
+            e3.forEach((e4) => {
+              const i3 = t3.find((t4) => e4.conflictsWith.includes(t4.attributeName()));
+              if (i3) {
+                this._conflictingOption(e4, i3);
+              }
+            });
+          }
+          _checkForConflictingOptions() {
+            for (let t3 = this; t3; t3 = t3.parent) {
+              t3._checkForConflictingLocalOptions();
+            }
+          }
+          parseOptions(t3) {
+            const e3 = [];
             const i3 = [];
-            let n2 = t3;
-            const s2 = e3.slice();
-            function maybeOption(e4) {
-              return e4.length > 1 && e4[0] === "-";
+            let n2 = e3;
+            const s2 = t3.slice();
+            function maybeOption(t4) {
+              return t4.length > 1 && t4[0] === "-";
             }
             let r2 = null;
             while (s2.length) {
-              const e4 = s2.shift();
-              if (e4 === "--") {
+              const t4 = s2.shift();
+              if (t4 === "--") {
                 if (n2 === i3)
-                  n2.push(e4);
+                  n2.push(t4);
                 n2.push(...s2);
                 break;
               }
-              if (r2 && !maybeOption(e4)) {
-                this.emit(`option:${r2.name()}`, e4);
+              if (r2 && !maybeOption(t4)) {
+                this.emit(`option:${r2.name()}`, t4);
                 continue;
               }
               r2 = null;
-              if (maybeOption(e4)) {
-                const t4 = this._findOption(e4);
-                if (t4) {
-                  if (t4.required) {
-                    const e5 = s2.shift();
-                    if (e5 === void 0)
-                      this.optionMissingArgument(t4);
-                    this.emit(`option:${t4.name()}`, e5);
-                  } else if (t4.optional) {
-                    let e5 = null;
+              if (maybeOption(t4)) {
+                const e4 = this._findOption(t4);
+                if (e4) {
+                  if (e4.required) {
+                    const t5 = s2.shift();
+                    if (t5 === void 0)
+                      this.optionMissingArgument(e4);
+                    this.emit(`option:${e4.name()}`, t5);
+                  } else if (e4.optional) {
+                    let t5 = null;
                     if (s2.length > 0 && !maybeOption(s2[0])) {
-                      e5 = s2.shift();
+                      t5 = s2.shift();
                     }
-                    this.emit(`option:${t4.name()}`, e5);
+                    this.emit(`option:${e4.name()}`, t5);
                   } else {
-                    this.emit(`option:${t4.name()}`);
+                    this.emit(`option:${e4.name()}`);
                   }
-                  r2 = t4.variadic ? t4 : null;
+                  r2 = e4.variadic ? e4 : null;
                   continue;
                 }
               }
-              if (e4.length > 2 && e4[0] === "-" && e4[1] !== "-") {
-                const t4 = this._findOption(`-${e4[1]}`);
-                if (t4) {
-                  if (t4.required || t4.optional && this._combineFlagAndOptionalValue) {
-                    this.emit(`option:${t4.name()}`, e4.slice(2));
+              if (t4.length > 2 && t4[0] === "-" && t4[1] !== "-") {
+                const e4 = this._findOption(`-${t4[1]}`);
+                if (e4) {
+                  if (e4.required || e4.optional && this._combineFlagAndOptionalValue) {
+                    this.emit(`option:${e4.name()}`, t4.slice(2));
                   } else {
-                    this.emit(`option:${t4.name()}`);
-                    s2.unshift(`-${e4.slice(2)}`);
+                    this.emit(`option:${e4.name()}`);
+                    s2.unshift(`-${t4.slice(2)}`);
                   }
                   continue;
                 }
               }
-              if (/^--[^=]+=/.test(e4)) {
-                const t4 = e4.indexOf("=");
-                const i4 = this._findOption(e4.slice(0, t4));
+              if (/^--[^=]+=/.test(t4)) {
+                const e4 = t4.indexOf("=");
+                const i4 = this._findOption(t4.slice(0, e4));
                 if (i4 && (i4.required || i4.optional)) {
-                  this.emit(`option:${i4.name()}`, e4.slice(t4 + 1));
+                  this.emit(`option:${i4.name()}`, t4.slice(e4 + 1));
                   continue;
                 }
               }
-              if (maybeOption(e4)) {
+              if (maybeOption(t4)) {
                 n2 = i3;
               }
-              if ((this._enablePositionalOptions || this._passThroughOptions) && t3.length === 0 && i3.length === 0) {
-                if (this._findCommand(e4)) {
-                  t3.push(e4);
+              if ((this._enablePositionalOptions || this._passThroughOptions) && e3.length === 0 && i3.length === 0) {
+                if (this._findCommand(t4)) {
+                  e3.push(t4);
                   if (s2.length > 0)
                     i3.push(...s2);
                   break;
-                } else if (e4 === this._helpCommandName && this._hasImplicitHelpCommand()) {
-                  t3.push(e4);
+                } else if (t4 === this._helpCommandName && this._hasImplicitHelpCommand()) {
+                  e3.push(t4);
                   if (s2.length > 0)
-                    t3.push(...s2);
+                    e3.push(...s2);
                   break;
                 } else if (this._defaultCommandName) {
-                  i3.push(e4);
+                  i3.push(t4);
                   if (s2.length > 0)
                     i3.push(...s2);
                   break;
                 }
               }
               if (this._passThroughOptions) {
-                n2.push(e4);
+                n2.push(t4);
                 if (s2.length > 0)
                   n2.push(...s2);
                 break;
               }
-              n2.push(e4);
+              n2.push(t4);
             }
-            return { operands: t3, unknown: i3 };
+            return { operands: e3, unknown: i3 };
           }
           opts() {
             if (this._storeOptionsAsProperties) {
-              const e3 = {};
-              const t3 = this.options.length;
-              for (let i3 = 0; i3 < t3; i3++) {
-                const t4 = this.options[i3].attributeName();
-                e3[t4] = t4 === this._versionOptionName ? this._version : this[t4];
+              const t3 = {};
+              const e3 = this.options.length;
+              for (let i3 = 0; i3 < e3; i3++) {
+                const e4 = this.options[i3].attributeName();
+                t3[e4] = e4 === this._versionOptionName ? this._version : this[e4];
               }
-              return e3;
+              return t3;
             }
             return this._optionValues;
           }
-          _displayError(e3, t3, i3) {
-            this._outputConfiguration.outputError(`${i3}
+          optsWithGlobals() {
+            return getCommandAndParents(this).reduce((t3, e3) => Object.assign(t3, e3.opts()), {});
+          }
+          error(t3, e3) {
+            this._outputConfiguration.outputError(`${t3}
 `, this._outputConfiguration.writeErr);
             if (typeof this._showHelpAfterError === "string") {
               this._outputConfiguration.writeErr(`${this._showHelpAfterError}
@@ -34001,166 +34067,217 @@ Expecting one of '${i3.join("', '")}'`);
               this._outputConfiguration.writeErr("\n");
               this.outputHelp({ error: true });
             }
-            this._exit(e3, t3, i3);
+            const i3 = e3 || {};
+            const n2 = i3.exitCode || 1;
+            const s2 = i3.code || "commander.error";
+            this._exit(n2, s2, t3);
           }
           _parseOptionsEnv() {
-            this.options.forEach((e3) => {
-              if (e3.envVar && e3.envVar in process.env) {
-                const t3 = e3.attributeName();
-                if (this.getOptionValue(t3) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(t3))) {
-                  if (e3.required || e3.optional) {
-                    this.emit(`optionEnv:${e3.name()}`, process.env[e3.envVar]);
+            this.options.forEach((t3) => {
+              if (t3.envVar && t3.envVar in a.env) {
+                const e3 = t3.attributeName();
+                if (this.getOptionValue(e3) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(e3))) {
+                  if (t3.required || t3.optional) {
+                    this.emit(`optionEnv:${t3.name()}`, a.env[t3.envVar]);
                   } else {
-                    this.emit(`optionEnv:${e3.name()}`);
+                    this.emit(`optionEnv:${t3.name()}`);
                   }
                 }
               }
             });
           }
-          missingArgument(e3) {
-            const t3 = `error: missing required argument '${e3}'`;
-            this._displayError(1, "commander.missingArgument", t3);
-          }
-          optionMissingArgument(e3) {
-            const t3 = `error: option '${e3.flags}' argument missing`;
-            this._displayError(1, "commander.optionMissingArgument", t3);
+          _parseOptionsImplied() {
+            const t3 = new d(this.options);
+            const hasCustomOptionValue = (t4) => this.getOptionValue(t4) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(t4));
+            this.options.filter((e3) => e3.implied !== void 0 && hasCustomOptionValue(e3.attributeName()) && t3.valueFromOption(this.getOptionValue(e3.attributeName()), e3)).forEach((t4) => {
+              Object.keys(t4.implied).filter((t5) => !hasCustomOptionValue(t5)).forEach((e3) => {
+                this.setOptionValueWithSource(e3, t4.implied[e3], "implied");
+              });
+            });
           }
-          missingMandatoryOptionValue(e3) {
-            const t3 = `error: required option '${e3.flags}' not specified`;
-            this._displayError(1, "commander.missingMandatoryOptionValue", t3);
+          missingArgument(t3) {
+            const e3 = `error: missing required argument '${t3}'`;
+            this.error(e3, { code: "commander.missingArgument" });
+          }
+          optionMissingArgument(t3) {
+            const e3 = `error: option '${t3.flags}' argument missing`;
+            this.error(e3, { code: "commander.optionMissingArgument" });
+          }
+          missingMandatoryOptionValue(t3) {
+            const e3 = `error: required option '${t3.flags}' not specified`;
+            this.error(e3, { code: "commander.missingMandatoryOptionValue" });
+          }
+          _conflictingOption(t3, e3) {
+            const findBestOptionFromValue = (t4) => {
+              const e4 = t4.attributeName();
+              const i4 = this.getOptionValue(e4);
+              const n2 = this.options.find((t5) => t5.negate && e4 === t5.attributeName());
+              const s2 = this.options.find((t5) => !t5.negate && e4 === t5.attributeName());
+              if (n2 && (n2.presetArg === void 0 && i4 === false || n2.presetArg !== void 0 && i4 === n2.presetArg)) {
+                return n2;
+              }
+              return s2 || t4;
+            };
+            const getErrorMessage = (t4) => {
+              const e4 = findBestOptionFromValue(t4);
+              const i4 = e4.attributeName();
+              const n2 = this.getOptionValueSource(i4);
+              if (n2 === "env") {
+                return `environment variable '${e4.envVar}'`;
+              }
+              return `option '${e4.flags}'`;
+            };
+            const i3 = `error: ${getErrorMessage(t3)} cannot be used with ${getErrorMessage(e3)}`;
+            this.error(i3, { code: "commander.conflictingOption" });
           }
-          unknownOption(e3) {
+          unknownOption(t3) {
             if (this._allowUnknownOption)
               return;
-            let t3 = "";
-            if (e3.startsWith("--") && this._showSuggestionAfterError) {
+            let e3 = "";
+            if (t3.startsWith("--") && this._showSuggestionAfterError) {
               let i4 = [];
               let n2 = this;
               do {
-                const e4 = n2.createHelp().visibleOptions(n2).filter((e5) => e5.long).map((e5) => e5.long);
-                i4 = i4.concat(e4);
+                const t4 = n2.createHelp().visibleOptions(n2).filter((t5) => t5.long).map((t5) => t5.long);
+                i4 = i4.concat(t4);
                 n2 = n2.parent;
               } while (n2 && !n2._enablePositionalOptions);
-              t3 = m(e3, i4);
+              e3 = f(t3, i4);
             }
-            const i3 = `error: unknown option '${e3}'${t3}`;
-            this._displayError(1, "commander.unknownOption", i3);
+            const i3 = `error: unknown option '${t3}'${e3}`;
+            this.error(i3, { code: "commander.unknownOption" });
           }
-          _excessArguments(e3) {
+          _excessArguments(t3) {
             if (this._allowExcessArguments)
               return;
-            const t3 = this._args.length;
-            const i3 = t3 === 1 ? "" : "s";
+            const e3 = this._args.length;
+            const i3 = e3 === 1 ? "" : "s";
             const n2 = this.parent ? ` for '${this.name()}'` : "";
-            const s2 = `error: too many arguments${n2}. Expected ${t3} argument${i3} but got ${e3.length}.`;
-            this._displayError(1, "commander.excessArguments", s2);
+            const s2 = `error: too many arguments${n2}. Expected ${e3} argument${i3} but got ${t3.length}.`;
+            this.error(s2, { code: "commander.excessArguments" });
           }
           unknownCommand() {
-            const e3 = this.args[0];
-            let t3 = "";
+            const t3 = this.args[0];
+            let e3 = "";
             if (this._showSuggestionAfterError) {
               const i4 = [];
-              this.createHelp().visibleCommands(this).forEach((e4) => {
-                i4.push(e4.name());
-                if (e4.alias())
-                  i4.push(e4.alias());
+              this.createHelp().visibleCommands(this).forEach((t4) => {
+                i4.push(t4.name());
+                if (t4.alias())
+                  i4.push(t4.alias());
               });
-              t3 = m(e3, i4);
+              e3 = f(t3, i4);
             }
-            const i3 = `error: unknown command '${e3}'${t3}`;
-            this._displayError(1, "commander.unknownCommand", i3);
+            const i3 = `error: unknown command '${t3}'${e3}`;
+            this.error(i3, { code: "commander.unknownCommand" });
           }
-          version(e3, t3, i3) {
-            if (e3 === void 0)
+          version(t3, e3, i3) {
+            if (t3 === void 0)
               return this._version;
-            this._version = e3;
-            t3 = t3 || "-V, --version";
+            this._version = t3;
+            e3 = e3 || "-V, --version";
             i3 = i3 || "output the version number";
-            const n2 = this.createOption(t3, i3);
+            const n2 = this.createOption(e3, i3);
             this._versionOptionName = n2.attributeName();
             this.options.push(n2);
             this.on("option:" + n2.name(), () => {
-              this._outputConfiguration.writeOut(`${e3}
+              this._outputConfiguration.writeOut(`${t3}
 `);
-              this._exit(0, "commander.version", e3);
+              this._exit(0, "commander.version", t3);
             });
             return this;
           }
-          description(e3, t3) {
-            if (e3 === void 0 && t3 === void 0)
+          description(t3, e3) {
+            if (t3 === void 0 && e3 === void 0)
               return this._description;
-            this._description = e3;
-            if (t3) {
-              this._argsDescription = t3;
+            this._description = t3;
+            if (e3) {
+              this._argsDescription = e3;
             }
             return this;
           }
-          alias(e3) {
-            if (e3 === void 0)
+          summary(t3) {
+            if (t3 === void 0)
+              return this._summary;
+            this._summary = t3;
+            return this;
+          }
+          alias(t3) {
+            if (t3 === void 0)
               return this._aliases[0];
-            let t3 = this;
+            let e3 = this;
             if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-              t3 = this.commands[this.commands.length - 1];
+              e3 = this.commands[this.commands.length - 1];
             }
-            if (e3 === t3._name)
+            if (t3 === e3._name)
               throw new Error("Command alias can't be the same as its name");
-            t3._aliases.push(e3);
+            e3._aliases.push(t3);
             return this;
           }
-          aliases(e3) {
-            if (e3 === void 0)
+          aliases(t3) {
+            if (t3 === void 0)
               return this._aliases;
-            e3.forEach((e4) => this.alias(e4));
+            t3.forEach((t4) => this.alias(t4));
             return this;
           }
-          usage(e3) {
-            if (e3 === void 0) {
+          usage(t3) {
+            if (t3 === void 0) {
               if (this._usage)
                 return this._usage;
-              const e4 = this._args.map((e5) => h(e5));
-              return [].concat(this.options.length || this._hasHelpOption ? "[options]" : [], this.commands.length ? "[command]" : [], this._args.length ? e4 : []).join(" ");
+              const t4 = this._args.map((t5) => h(t5));
+              return [].concat(this.options.length || this._hasHelpOption ? "[options]" : [], this.commands.length ? "[command]" : [], this._args.length ? t4 : []).join(" ");
             }
-            this._usage = e3;
+            this._usage = t3;
             return this;
           }
-          name(e3) {
-            if (e3 === void 0)
+          name(t3) {
+            if (t3 === void 0)
               return this._name;
-            this._name = e3;
+            this._name = t3;
             return this;
           }
-          helpInformation(e3) {
-            const t3 = this.createHelp();
-            if (t3.helpWidth === void 0) {
-              t3.helpWidth = e3 && e3.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+          nameFromFilename(t3) {
+            this._name = r.basename(t3, r.extname(t3));
+            return this;
+          }
+          executableDir(t3) {
+            if (t3 === void 0)
+              return this._executableDir;
+            this._executableDir = t3;
+            return this;
+          }
+          helpInformation(t3) {
+            const e3 = this.createHelp();
+            if (e3.helpWidth === void 0) {
+              e3.helpWidth = t3 && t3.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
             }
-            return t3.formatHelp(this, t3);
+            return e3.formatHelp(this, e3);
           }
-          _getHelpContext(e3) {
-            e3 = e3 || {};
-            const t3 = { error: !!e3.error };
+          _getHelpContext(t3) {
+            t3 = t3 || {};
+            const e3 = { error: !!t3.error };
             let i3;
-            if (t3.error) {
-              i3 = (e4) => this._outputConfiguration.writeErr(e4);
+            if (e3.error) {
+              i3 = (t4) => this._outputConfiguration.writeErr(t4);
             } else {
-              i3 = (e4) => this._outputConfiguration.writeOut(e4);
-            }
-            t3.write = e3.write || i3;
-            t3.command = this;
-            return t3;
+              i3 = (t4) => this._outputConfiguration.writeOut(t4);
+            }
+            e3.write = t3.write || i3;
+            e3.command = this;
+            return e3;
           }
-          outputHelp(e3) {
-            let t3;
-            if (typeof e3 === "function") {
-              t3 = e3;
-              e3 = void 0;
+          outputHelp(t3) {
+            let e3;
+            if (typeof t3 === "function") {
+              e3 = t3;
+              t3 = void 0;
             }
-            const i3 = this._getHelpContext(e3);
-            getCommandAndParents(this).reverse().forEach((e4) => e4.emit("beforeAllHelp", i3));
+            const i3 = this._getHelpContext(t3);
+            getCommandAndParents(this).reverse().forEach((t4) => t4.emit("beforeAllHelp", i3));
             this.emit("beforeHelp", i3);
             let n2 = this.helpInformation(i3);
-            if (t3) {
-              n2 = t3(n2);
+            if (e3) {
+              n2 = e3(n2);
               if (typeof n2 !== "string" && !Buffer.isBuffer(n2)) {
                 throw new Error("outputHelp callback must return a string or a Buffer");
               }
@@ -34168,306 +34285,342 @@ Expecting one of '${i3.join("', '")}'`);
             i3.write(n2);
             this.emit(this._helpLongFlag);
             this.emit("afterHelp", i3);
-            getCommandAndParents(this).forEach((e4) => e4.emit("afterAllHelp", i3));
+            getCommandAndParents(this).forEach((t4) => t4.emit("afterAllHelp", i3));
           }
-          helpOption(e3, t3) {
-            if (typeof e3 === "boolean") {
-              this._hasHelpOption = e3;
+          helpOption(t3, e3) {
+            if (typeof t3 === "boolean") {
+              this._hasHelpOption = t3;
               return this;
             }
-            this._helpFlags = e3 || this._helpFlags;
-            this._helpDescription = t3 || this._helpDescription;
-            const i3 = p(this._helpFlags);
+            this._helpFlags = t3 || this._helpFlags;
+            this._helpDescription = e3 || this._helpDescription;
+            const i3 = m(this._helpFlags);
             this._helpShortFlag = i3.shortFlag;
             this._helpLongFlag = i3.longFlag;
             return this;
           }
-          help(e3) {
-            this.outputHelp(e3);
-            let t3 = process.exitCode || 0;
-            if (t3 === 0 && e3 && typeof e3 !== "function" && e3.error) {
-              t3 = 1;
+          help(t3) {
+            this.outputHelp(t3);
+            let e3 = a.exitCode || 0;
+            if (e3 === 0 && t3 && typeof t3 !== "function" && t3.error) {
+              e3 = 1;
             }
-            this._exit(t3, "commander.help", "(outputHelp)");
+            this._exit(e3, "commander.help", "(outputHelp)");
           }
-          addHelpText(e3, t3) {
+          addHelpText(t3, e3) {
             const i3 = ["beforeAll", "before", "after", "afterAll"];
-            if (!i3.includes(e3)) {
+            if (!i3.includes(t3)) {
               throw new Error(`Unexpected value for position to addHelpText.
 Expecting one of '${i3.join("', '")}'`);
             }
-            const n2 = `${e3}Help`;
-            this.on(n2, (e4) => {
+            const n2 = `${t3}Help`;
+            this.on(n2, (t4) => {
               let i4;
-              if (typeof t3 === "function") {
-                i4 = t3({ error: e4.error, command: e4.command });
+              if (typeof e3 === "function") {
+                i4 = e3({ error: t4.error, command: t4.command });
               } else {
-                i4 = t3;
+                i4 = e3;
               }
               if (i4) {
-                e4.write(`${i4}
+                t4.write(`${i4}
 `);
               }
             });
             return this;
           }
         }
-        function outputHelpIfRequested(e3, t3) {
-          const i3 = e3._hasHelpOption && t3.find((t4) => t4 === e3._helpLongFlag || t4 === e3._helpShortFlag);
+        function outputHelpIfRequested(t3, e3) {
+          const i3 = t3._hasHelpOption && e3.find((e4) => e4 === t3._helpLongFlag || e4 === t3._helpShortFlag);
           if (i3) {
-            e3.outputHelp();
-            e3._exit(0, "commander.helpDisplayed", "(outputHelp)");
+            t3.outputHelp();
+            t3._exit(0, "commander.helpDisplayed", "(outputHelp)");
           }
         }
-        function incrementNodeInspectorPort(e3) {
-          return e3.map((e4) => {
-            if (!e4.startsWith("--inspect")) {
-              return e4;
+        function incrementNodeInspectorPort(t3) {
+          return t3.map((t4) => {
+            if (!t4.startsWith("--inspect")) {
+              return t4;
             }
-            let t3;
+            let e3;
             let i3 = "127.0.0.1";
             let n2 = "9229";
             let s2;
-            if ((s2 = e4.match(/^(--inspect(-brk)?)$/)) !== null) {
-              t3 = s2[1];
-            } else if ((s2 = e4.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-              t3 = s2[1];
+            if ((s2 = t4.match(/^(--inspect(-brk)?)$/)) !== null) {
+              e3 = s2[1];
+            } else if ((s2 = t4.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+              e3 = s2[1];
               if (/^\d+$/.test(s2[3])) {
                 n2 = s2[3];
               } else {
                 i3 = s2[3];
               }
-            } else if ((s2 = e4.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-              t3 = s2[1];
+            } else if ((s2 = t4.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+              e3 = s2[1];
               i3 = s2[3];
               n2 = s2[4];
             }
-            if (t3 && n2 !== "0") {
-              return `${t3}=${i3}:${parseInt(n2) + 1}`;
+            if (e3 && n2 !== "0") {
+              return `${e3}=${i3}:${parseInt(n2) + 1}`;
             }
-            return e4;
+            return t4;
           });
         }
-        function getCommandAndParents(e3) {
-          const t3 = [];
-          for (let i3 = e3; i3; i3 = i3.parent) {
-            t3.push(i3);
+        function getCommandAndParents(t3) {
+          const e3 = [];
+          for (let i3 = t3; i3; i3 = i3.parent) {
+            e3.push(i3);
           }
-          return t3;
+          return e3;
         }
-        t2.Command = Command3;
-      }, 967: (e2, t2) => {
+        e2.Command = Command3;
+      }, 796: (t2, e2) => {
         class CommanderError extends Error {
-          constructor(e3, t3, i2) {
+          constructor(t3, e3, i2) {
             super(i2);
             Error.captureStackTrace(this, this.constructor);
             this.name = this.constructor.name;
-            this.code = t3;
-            this.exitCode = e3;
+            this.code = e3;
+            this.exitCode = t3;
             this.nestedError = void 0;
           }
         }
         class InvalidArgumentError extends CommanderError {
-          constructor(e3) {
-            super(1, "commander.invalidArgument", e3);
+          constructor(t3) {
+            super(1, "commander.invalidArgument", t3);
             Error.captureStackTrace(this, this.constructor);
             this.name = this.constructor.name;
           }
         }
-        t2.CommanderError = CommanderError;
-        t2.InvalidArgumentError = InvalidArgumentError;
-      }, 34: (e2, t2, i2) => {
-        const { humanReadableArgName: n } = i2(969);
+        e2.CommanderError = CommanderError;
+        e2.InvalidArgumentError = InvalidArgumentError;
+      }, 519: (t2, e2, i2) => {
+        const { humanReadableArgName: n } = i2(535);
         class Help {
           constructor() {
             this.helpWidth = void 0;
             this.sortSubcommands = false;
             this.sortOptions = false;
-          }
-          visibleCommands(e3) {
-            const t3 = e3.commands.filter((e4) => !e4._hidden);
-            if (e3._hasImplicitHelpCommand()) {
-              const [, i3, n2] = e3._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
-              const s = e3.createCommand(i3).helpOption(false);
-              s.description(e3._helpCommandDescription);
+            this.showGlobalOptions = false;
+          }
+          visibleCommands(t3) {
+            const e3 = t3.commands.filter((t4) => !t4._hidden);
+            if (t3._hasImplicitHelpCommand()) {
+              const [, i3, n2] = t3._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
+              const s = t3.createCommand(i3).helpOption(false);
+              s.description(t3._helpCommandDescription);
               if (n2)
                 s.arguments(n2);
-              t3.push(s);
+              e3.push(s);
             }
             if (this.sortSubcommands) {
-              t3.sort((e4, t4) => e4.name().localeCompare(t4.name()));
+              e3.sort((t4, e4) => t4.name().localeCompare(e4.name()));
             }
-            return t3;
+            return e3;
           }
-          visibleOptions(e3) {
-            const t3 = e3.options.filter((e4) => !e4.hidden);
-            const i3 = e3._hasHelpOption && e3._helpShortFlag && !e3._findOption(e3._helpShortFlag);
-            const n2 = e3._hasHelpOption && !e3._findOption(e3._helpLongFlag);
+          compareOptions(t3, e3) {
+            const getSortKey = (t4) => t4.short ? t4.short.replace(/^-/, "") : t4.long.replace(/^--/, "");
+            return getSortKey(t3).localeCompare(getSortKey(e3));
+          }
+          visibleOptions(t3) {
+            const e3 = t3.options.filter((t4) => !t4.hidden);
+            const i3 = t3._hasHelpOption && t3._helpShortFlag && !t3._findOption(t3._helpShortFlag);
+            const n2 = t3._hasHelpOption && !t3._findOption(t3._helpLongFlag);
             if (i3 || n2) {
               let s;
               if (!i3) {
-                s = e3.createOption(e3._helpLongFlag, e3._helpDescription);
+                s = t3.createOption(t3._helpLongFlag, t3._helpDescription);
               } else if (!n2) {
-                s = e3.createOption(e3._helpShortFlag, e3._helpDescription);
+                s = t3.createOption(t3._helpShortFlag, t3._helpDescription);
               } else {
-                s = e3.createOption(e3._helpFlags, e3._helpDescription);
+                s = t3.createOption(t3._helpFlags, t3._helpDescription);
               }
-              t3.push(s);
+              e3.push(s);
             }
             if (this.sortOptions) {
-              const getSortKey = (e4) => e4.short ? e4.short.replace(/^-/, "") : e4.long.replace(/^--/, "");
-              t3.sort((e4, t4) => getSortKey(e4).localeCompare(getSortKey(t4)));
+              e3.sort(this.compareOptions);
             }
-            return t3;
+            return e3;
           }
-          visibleArguments(e3) {
-            if (e3._argsDescription) {
-              e3._args.forEach((t3) => {
-                t3.description = t3.description || e3._argsDescription[t3.name()] || "";
+          visibleGlobalOptions(t3) {
+            if (!this.showGlobalOptions)
+              return [];
+            const e3 = [];
+            for (let i3 = t3.parent; i3; i3 = i3.parent) {
+              const t4 = i3.options.filter((t5) => !t5.hidden);
+              e3.push(...t4);
+            }
+            if (this.sortOptions) {
+              e3.sort(this.compareOptions);
+            }
+            return e3;
+          }
+          visibleArguments(t3) {
+            if (t3._argsDescription) {
+              t3._args.forEach((e3) => {
+                e3.description = e3.description || t3._argsDescription[e3.name()] || "";
               });
             }
-            if (e3._args.find((e4) => e4.description)) {
-              return e3._args;
+            if (t3._args.find((t4) => t4.description)) {
+              return t3._args;
             }
             return [];
           }
-          subcommandTerm(e3) {
-            const t3 = e3._args.map((e4) => n(e4)).join(" ");
-            return e3._name + (e3._aliases[0] ? "|" + e3._aliases[0] : "") + (e3.options.length ? " [options]" : "") + (t3 ? " " + t3 : "");
+          subcommandTerm(t3) {
+            const e3 = t3._args.map((t4) => n(t4)).join(" ");
+            return t3._name + (t3._aliases[0] ? "|" + t3._aliases[0] : "") + (t3.options.length ? " [options]" : "") + (e3 ? " " + e3 : "");
           }
-          optionTerm(e3) {
-            return e3.flags;
+          optionTerm(t3) {
+            return t3.flags;
           }
-          argumentTerm(e3) {
-            return e3.name();
+          argumentTerm(t3) {
+            return t3.name();
           }
-          longestSubcommandTermLength(e3, t3) {
-            return t3.visibleCommands(e3).reduce((e4, i3) => Math.max(e4, t3.subcommandTerm(i3).length), 0);
+          longestSubcommandTermLength(t3, e3) {
+            return e3.visibleCommands(t3).reduce((t4, i3) => Math.max(t4, e3.subcommandTerm(i3).length), 0);
           }
-          longestOptionTermLength(e3, t3) {
-            return t3.visibleOptions(e3).reduce((e4, i3) => Math.max(e4, t3.optionTerm(i3).length), 0);
+          longestOptionTermLength(t3, e3) {
+            return e3.visibleOptions(t3).reduce((t4, i3) => Math.max(t4, e3.optionTerm(i3).length), 0);
           }
-          longestArgumentTermLength(e3, t3) {
-            return t3.visibleArguments(e3).reduce((e4, i3) => Math.max(e4, t3.argumentTerm(i3).length), 0);
+          longestGlobalOptionTermLength(t3, e3) {
+            return e3.visibleGlobalOptions(t3).reduce((t4, i3) => Math.max(t4, e3.optionTerm(i3).length), 0);
           }
-          commandUsage(e3) {
-            let t3 = e3._name;
-            if (e3._aliases[0]) {
-              t3 = t3 + "|" + e3._aliases[0];
+          longestArgumentTermLength(t3, e3) {
+            return e3.visibleArguments(t3).reduce((t4, i3) => Math.max(t4, e3.argumentTerm(i3).length), 0);
+          }
+          commandUsage(t3) {
+            let e3 = t3._name;
+            if (t3._aliases[0]) {
+              e3 = e3 + "|" + t3._aliases[0];
             }
             let i3 = "";
-            for (let t4 = e3.parent; t4; t4 = t4.parent) {
-              i3 = t4.name() + " " + i3;
+            for (let e4 = t3.parent; e4; e4 = e4.parent) {
+              i3 = e4.name() + " " + i3;
             }
-            return i3 + t3 + " " + e3.usage();
+            return i3 + e3 + " " + t3.usage();
           }
-          commandDescription(e3) {
-            return e3.description();
+          commandDescription(t3) {
+            return t3.description();
           }
-          subcommandDescription(e3) {
-            return e3.description();
+          subcommandDescription(t3) {
+            return t3.summary() || t3.description();
           }
-          optionDescription(e3) {
-            const t3 = [];
-            if (e3.argChoices && !e3.negate) {
-              t3.push(`choices: ${e3.argChoices.map((e4) => JSON.stringify(e4)).join(", ")}`);
+          optionDescription(t3) {
+            const e3 = [];
+            if (t3.argChoices) {
+              e3.push(`choices: ${t3.argChoices.map((t4) => JSON.stringify(t4)).join(", ")}`);
             }
-            if (e3.defaultValue !== void 0 && !e3.negate) {
-              t3.push(`default: ${e3.defaultValueDescription || JSON.stringify(e3.defaultValue)}`);
+            if (t3.defaultValue !== void 0) {
+              const i3 = t3.required || t3.optional || t3.isBoolean() && typeof t3.defaultValue === "boolean";
+              if (i3) {
+                e3.push(`default: ${t3.defaultValueDescription || JSON.stringify(t3.defaultValue)}`);
+              }
             }
-            if (e3.envVar !== void 0) {
-              t3.push(`env: ${e3.envVar}`);
+            if (t3.presetArg !== void 0 && t3.optional) {
+              e3.push(`preset: ${JSON.stringify(t3.presetArg)}`);
             }
-            if (t3.length > 0) {
-              return `${e3.description} (${t3.join(", ")})`;
+            if (t3.envVar !== void 0) {
+              e3.push(`env: ${t3.envVar}`);
             }
-            return e3.description;
+            if (e3.length > 0) {
+              return `${t3.description} (${e3.join(", ")})`;
+            }
+            return t3.description;
           }
-          argumentDescription(e3) {
-            const t3 = [];
-            if (e3.argChoices) {
-              t3.push(`choices: ${e3.argChoices.map((e4) => JSON.stringify(e4)).join(", ")}`);
+          argumentDescription(t3) {
+            const e3 = [];
+            if (t3.argChoices) {
+              e3.push(`choices: ${t3.argChoices.map((t4) => JSON.stringify(t4)).join(", ")}`);
             }
-            if (e3.defaultValue !== void 0) {
-              t3.push(`default: ${e3.defaultValueDescription || JSON.stringify(e3.defaultValue)}`);
+            if (t3.defaultValue !== void 0) {
+              e3.push(`default: ${t3.defaultValueDescription || JSON.stringify(t3.defaultValue)}`);
             }
-            if (t3.length > 0) {
-              const i3 = `(${t3.join(", ")})`;
-              if (e3.description) {
-                return `${e3.description} ${i3}`;
+            if (e3.length > 0) {
+              const i3 = `(${e3.join(", ")})`;
+              if (t3.description) {
+                return `${t3.description} ${i3}`;
               }
               return i3;
             }
-            return e3.description;
+            return t3.description;
           }
-          formatHelp(e3, t3) {
-            const i3 = t3.padWidth(e3, t3);
-            const n2 = t3.helpWidth || 80;
+          formatHelp(t3, e3) {
+            const i3 = e3.padWidth(t3, e3);
+            const n2 = e3.helpWidth || 80;
             const s = 2;
             const r = 2;
-            function formatItem(e4, o2) {
+            function formatItem(t4, o2) {
               if (o2) {
-                const a2 = `${e4.padEnd(i3 + r)}${o2}`;
-                return t3.wrap(a2, n2 - s, i3 + r);
+                const a2 = `${t4.padEnd(i3 + r)}${o2}`;
+                return e3.wrap(a2, n2 - s, i3 + r);
               }
-              return e4;
+              return t4;
             }
-            function formatList(e4) {
-              return e4.join("\n").replace(/^/gm, " ".repeat(s));
+            function formatList(t4) {
+              return t4.join("\n").replace(/^/gm, " ".repeat(s));
             }
-            let o = [`Usage: ${t3.commandUsage(e3)}`, ""];
-            const a = t3.commandDescription(e3);
+            let o = [`Usage: ${e3.commandUsage(t3)}`, ""];
+            const a = e3.commandDescription(t3);
             if (a.length > 0) {
-              o = o.concat([a, ""]);
+              o = o.concat([e3.wrap(a, n2, 0), ""]);
             }
-            const h = t3.visibleArguments(e3).map((e4) => formatItem(t3.argumentTerm(e4), t3.argumentDescription(e4)));
+            const l = e3.visibleArguments(t3).map((t4) => formatItem(e3.argumentTerm(t4), e3.argumentDescription(t4)));
+            if (l.length > 0) {
+              o = o.concat(["Arguments:", formatList(l), ""]);
+            }
+            const h = e3.visibleOptions(t3).map((t4) => formatItem(e3.optionTerm(t4), e3.optionDescription(t4)));
             if (h.length > 0) {
-              o = o.concat(["Arguments:", formatList(h), ""]);
+              o = o.concat(["Options:", formatList(h), ""]);
             }
-            const l = t3.visibleOptions(e3).map((e4) => formatItem(t3.optionTerm(e4), t3.optionDescription(e4)));
-            if (l.length > 0) {
-              o = o.concat(["Options:", formatList(l), ""]);
+            if (this.showGlobalOptions) {
+              const i4 = e3.visibleGlobalOptions(t3).map((t4) => formatItem(e3.optionTerm(t4), e3.optionDescription(t4)));
+              if (i4.length > 0) {
+                o = o.concat(["Global Options:", formatList(i4), ""]);
+              }
             }
-            const u = t3.visibleCommands(e3).map((e4) => formatItem(t3.subcommandTerm(e4), t3.subcommandDescription(e4)));
+            const u = e3.visibleCommands(t3).map((t4) => formatItem(e3.subcommandTerm(t4), e3.subcommandDescription(t4)));
             if (u.length > 0) {
               o = o.concat(["Commands:", formatList(u), ""]);
             }
             return o.join("\n");
           }
-          padWidth(e3, t3) {
-            return Math.max(t3.longestOptionTermLength(e3, t3), t3.longestSubcommandTermLength(e3, t3), t3.longestArgumentTermLength(e3, t3));
+          padWidth(t3, e3) {
+            return Math.max(e3.longestOptionTermLength(t3, e3), e3.longestGlobalOptionTermLength(t3, e3), e3.longestSubcommandTermLength(t3, e3), e3.longestArgumentTermLength(t3, e3));
           }
-          wrap(e3, t3, i3, n2 = 40) {
-            if (e3.match(/[\n]\s+/))
-              return e3;
-            const s = t3 - i3;
-            if (s < n2)
-              return e3;
-            const r = e3.substr(0, i3);
-            const o = e3.substr(i3);
-            const a = " ".repeat(i3);
-            const h = new RegExp(".{1," + (s - 1) + "}([\\s​]|$)|[^\\s​]+?([\\s​]|$)", "g");
-            const l = o.match(h) || [];
-            return r + l.map((e4, t4) => {
-              if (e4.slice(-1) === "\n") {
-                e4 = e4.slice(0, e4.length - 1);
-              }
-              return (t4 > 0 ? a : "") + e4.trimRight();
+          wrap(t3, e3, i3, n2 = 40) {
+            const s = " \\f\\t\\v   -   　\uFEFF";
+            const r = new RegExp(`[\\n][${s}]+`);
+            if (t3.match(r))
+              return t3;
+            const o = e3 - i3;
+            if (o < n2)
+              return t3;
+            const a = t3.slice(0, i3);
+            const l = t3.slice(i3).replace("\r\n", "\n");
+            const h = " ".repeat(i3);
+            const u = "​";
+            const c = `\\s${u}`;
+            const p = new RegExp(`
+|.{1,${o - 1}}([${c}]|$)|[^${c}]+?([${c}]|$)`, "g");
+            const m = l.match(p) || [];
+            return a + m.map((t4, e4) => {
+              if (t4 === "\n")
+                return "";
+              return (e4 > 0 ? h : "") + t4.trimEnd();
             }).join("\n");
           }
         }
-        t2.Help = Help;
-      }, 278: (e2, t2, i2) => {
-        const { InvalidArgumentError: n } = i2(967);
+        e2.Help = Help;
+      }, 437: (t2, e2, i2) => {
+        const { InvalidArgumentError: n } = i2(796);
         class Option {
-          constructor(e3, t3) {
-            this.flags = e3;
-            this.description = t3 || "";
-            this.required = e3.includes("<");
-            this.optional = e3.includes("[");
-            this.variadic = /\w\.\.\.[>\]]$/.test(e3);
+          constructor(t3, e3) {
+            this.flags = t3;
+            this.description = e3 || "";
+            this.required = t3.includes("<");
+            this.optional = t3.includes("[");
+            this.variadic = /\w\.\.\.[>\]]$/.test(t3);
             this.mandatory = false;
-            const i3 = splitOptionFlags(e3);
+            const i3 = splitOptionFlags(t3);
             this.short = i3.shortFlag;
             this.long = i3.longFlag;
             this.negate = false;
@@ -34476,48 +34629,63 @@ Expecting one of '${i3.join("', '")}'`);
             }
             this.defaultValue = void 0;
             this.defaultValueDescription = void 0;
+            this.presetArg = void 0;
             this.envVar = void 0;
             this.parseArg = void 0;
             this.hidden = false;
             this.argChoices = void 0;
+            this.conflictsWith = [];
+            this.implied = void 0;
           }
-          default(e3, t3) {
-            this.defaultValue = e3;
-            this.defaultValueDescription = t3;
+          default(t3, e3) {
+            this.defaultValue = t3;
+            this.defaultValueDescription = e3;
             return this;
           }
-          env(e3) {
-            this.envVar = e3;
+          preset(t3) {
+            this.presetArg = t3;
             return this;
           }
-          argParser(e3) {
-            this.parseArg = e3;
+          conflicts(t3) {
+            this.conflictsWith = this.conflictsWith.concat(t3);
             return this;
           }
-          makeOptionMandatory(e3 = true) {
-            this.mandatory = !!e3;
+          implies(t3) {
+            this.implied = Object.assign(this.implied || {}, t3);
             return this;
           }
-          hideHelp(e3 = true) {
-            this.hidden = !!e3;
+          env(t3) {
+            this.envVar = t3;
             return this;
           }
-          _concatValue(e3, t3) {
-            if (t3 === this.defaultValue || !Array.isArray(t3)) {
-              return [e3];
+          argParser(t3) {
+            this.parseArg = t3;
+            return this;
+          }
+          makeOptionMandatory(t3 = true) {
+            this.mandatory = !!t3;
+            return this;
+          }
+          hideHelp(t3 = true) {
+            this.hidden = !!t3;
+            return this;
+          }
+          _concatValue(t3, e3) {
+            if (e3 === this.defaultValue || !Array.isArray(e3)) {
+              return [t3];
             }
-            return t3.concat(e3);
+            return e3.concat(t3);
           }
-          choices(e3) {
-            this.argChoices = e3;
-            this.parseArg = (t3, i3) => {
-              if (!e3.includes(t3)) {
-                throw new n(`Allowed choices are ${e3.join(", ")}.`);
+          choices(t3) {
+            this.argChoices = t3.slice();
+            this.parseArg = (t4, e3) => {
+              if (!this.argChoices.includes(t4)) {
+                throw new n(`Allowed choices are ${this.argChoices.join(", ")}.`);
               }
               if (this.variadic) {
-                return this._concatValue(t3, i3);
+                return this._concatValue(t4, e3);
               }
-              return t3;
+              return t4;
             };
             return this;
           }
@@ -34530,86 +34698,117 @@ Expecting one of '${i3.join("', '")}'`);
           attributeName() {
             return camelcase(this.name().replace(/^no-/, ""));
           }
-          is(e3) {
-            return this.short === e3 || this.long === e3;
+          is(t3) {
+            return this.short === t3 || this.long === t3;
+          }
+          isBoolean() {
+            return !this.required && !this.optional && !this.negate;
           }
         }
-        function camelcase(e3) {
-          return e3.split("-").reduce((e4, t3) => e4 + t3[0].toUpperCase() + t3.slice(1));
+        class DualOptions {
+          constructor(t3) {
+            this.positiveOptions = /* @__PURE__ */ new Map();
+            this.negativeOptions = /* @__PURE__ */ new Map();
+            this.dualOptions = /* @__PURE__ */ new Set();
+            t3.forEach((t4) => {
+              if (t4.negate) {
+                this.negativeOptions.set(t4.attributeName(), t4);
+              } else {
+                this.positiveOptions.set(t4.attributeName(), t4);
+              }
+            });
+            this.negativeOptions.forEach((t4, e3) => {
+              if (this.positiveOptions.has(e3)) {
+                this.dualOptions.add(e3);
+              }
+            });
+          }
+          valueFromOption(t3, e3) {
+            const i3 = e3.attributeName();
+            if (!this.dualOptions.has(i3))
+              return true;
+            const n2 = this.negativeOptions.get(i3).presetArg;
+            const s = n2 !== void 0 ? n2 : false;
+            return e3.negate === (s === t3);
+          }
         }
-        function splitOptionFlags(e3) {
-          let t3;
+        function camelcase(t3) {
+          return t3.split("-").reduce((t4, e3) => t4 + e3[0].toUpperCase() + e3.slice(1));
+        }
+        function splitOptionFlags(t3) {
+          let e3;
           let i3;
-          const n2 = e3.split(/[ |,]+/);
+          const n2 = t3.split(/[ |,]+/);
           if (n2.length > 1 && !/^[[<]/.test(n2[1]))
-            t3 = n2.shift();
+            e3 = n2.shift();
           i3 = n2.shift();
-          if (!t3 && /^-[^-]$/.test(i3)) {
-            t3 = i3;
+          if (!e3 && /^-[^-]$/.test(i3)) {
+            e3 = i3;
             i3 = void 0;
           }
-          return { shortFlag: t3, longFlag: i3 };
+          return { shortFlag: e3, longFlag: i3 };
         }
-        t2.Option = Option;
-        t2.splitOptionFlags = splitOptionFlags;
-      }, 461: (e2, t2) => {
+        e2.Option = Option;
+        e2.splitOptionFlags = splitOptionFlags;
+        e2.DualOptions = DualOptions;
+      }, 860: (t2, e2) => {
         const i2 = 3;
-        function editDistance(e3, t3) {
-          if (Math.abs(e3.length - t3.length) > i2)
-            return Math.max(e3.length, t3.length);
+        function editDistance(t3, e3) {
+          if (Math.abs(t3.length - e3.length) > i2)
+            return Math.max(t3.length, e3.length);
           const n = [];
-          for (let t4 = 0; t4 <= e3.length; t4++) {
-            n[t4] = [t4];
-          }
           for (let e4 = 0; e4 <= t3.length; e4++) {
-            n[0][e4] = e4;
+            n[e4] = [e4];
           }
-          for (let i3 = 1; i3 <= t3.length; i3++) {
-            for (let s = 1; s <= e3.length; s++) {
+          for (let t4 = 0; t4 <= e3.length; t4++) {
+            n[0][t4] = t4;
+          }
+          for (let i3 = 1; i3 <= e3.length; i3++) {
+            for (let s = 1; s <= t3.length; s++) {
               let r = 1;
-              if (e3[s - 1] === t3[i3 - 1]) {
+              if (t3[s - 1] === e3[i3 - 1]) {
                 r = 0;
               } else {
                 r = 1;
               }
               n[s][i3] = Math.min(n[s - 1][i3] + 1, n[s][i3 - 1] + 1, n[s - 1][i3 - 1] + r);
-              if (s > 1 && i3 > 1 && e3[s - 1] === t3[i3 - 2] && e3[s - 2] === t3[i3 - 1]) {
+              if (s > 1 && i3 > 1 && t3[s - 1] === e3[i3 - 2] && t3[s - 2] === e3[i3 - 1]) {
                 n[s][i3] = Math.min(n[s][i3], n[s - 2][i3 - 2] + 1);
               }
             }
           }
-          return n[e3.length][t3.length];
+          return n[t3.length][e3.length];
         }
-        function suggestSimilar(e3, t3) {
-          if (!t3 || t3.length === 0)
+        function suggestSimilar(t3, e3) {
+          if (!e3 || e3.length === 0)
             return "";
-          t3 = Array.from(new Set(t3));
-          const n = e3.startsWith("--");
+          e3 = Array.from(new Set(e3));
+          const n = t3.startsWith("--");
           if (n) {
-            e3 = e3.slice(2);
-            t3 = t3.map((e4) => e4.slice(2));
+            t3 = t3.slice(2);
+            e3 = e3.map((t4) => t4.slice(2));
           }
           let s = [];
           let r = i2;
           const o = 0.4;
-          t3.forEach((t4) => {
-            if (t4.length <= 1)
+          e3.forEach((e4) => {
+            if (e4.length <= 1)
               return;
-            const i3 = editDistance(e3, t4);
-            const n2 = Math.max(e3.length, t4.length);
+            const i3 = editDistance(t3, e4);
+            const n2 = Math.max(t3.length, e4.length);
             const a = (n2 - i3) / n2;
             if (a > o) {
               if (i3 < r) {
                 r = i3;
-                s = [t4];
+                s = [e4];
               } else if (i3 === r) {
-                s.push(t4);
+                s.push(e4);
               }
             }
           });
-          s.sort((e4, t4) => e4.localeCompare(t4));
+          s.sort((t4, e4) => t4.localeCompare(e4));
           if (n) {
-            s = s.map((e4) => `--${e4}`);
+            s = s.map((t4) => `--${t4}`);
           }
           if (s.length > 1) {
             return `
@@ -34621,28 +34820,28 @@ Expecting one of '${i3.join("', '")}'`);
           }
           return "";
         }
-        t2.suggestSimilar = suggestSimilar;
+        e2.suggestSimilar = suggestSimilar;
       } };
-      var t = {};
+      var e = {};
       function __nccwpck_require__(i2) {
-        var n = t[i2];
+        var n = e[i2];
         if (n !== void 0) {
           return n.exports;
         }
-        var s = t[i2] = { exports: {} };
+        var s = e[i2] = { exports: {} };
         var r = true;
         try {
-          e[i2](s, s.exports, __nccwpck_require__);
+          t[i2](s, s.exports, __nccwpck_require__);
           r = false;
         } finally {
           if (r)
-            delete t[i2];
+            delete e[i2];
         }
         return s.exports;
       }
       if (typeof __nccwpck_require__ !== "undefined")
         __nccwpck_require__.ab = __dirname + "/";
-      var i = __nccwpck_require__(922);
+      var i = __nccwpck_require__(632);
       module2.exports = i;
     })();
   }
@@ -34782,12 +34981,21 @@ var require_commands = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var commands_exports = {};
     __export2(commands_exports, {
+      getArgv: () => getArgv,
       getCommand: () => getCommand,
+      getFullArgv: () => getFullArgv,
       isDevCommand: () => isDevCommand
     });
     module2.exports = __toCommonJS2(commands_exports);
+    var getFullArgv = () => {
+      var _a;
+      return ((_a = process.env.MODERN_ARGV) == null ? void 0 : _a.split(" ")) || process.argv;
+    };
+    var getArgv = () => {
+      return getFullArgv().slice(2);
+    };
     var getCommand = () => {
-      const args = process.argv.slice(2);
+      const args = getArgv();
       const command = args[0];
       return command;
     };
@@ -34798,108 +35006,6 @@ var require_commands = __commonJS({
   }
 });
 
-// ../utils/dist/format.js
-var require_format = __commonJS({
-  "../utils/dist/format.js"(exports, module2) {
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
-    };
-    var __copyProps2 = (to, from, except, desc) => {
-      if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
-      }
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var format_exports = {};
-    __export2(format_exports, {
-      formatWebpackMessages: () => formatWebpackMessages
-    });
-    module2.exports = __toCommonJS2(format_exports);
-    var friendlySyntaxErrorLabel = "SyntaxError:";
-    function isLikelyASyntaxError(message) {
-      return message.includes(friendlySyntaxErrorLabel);
-    }
-    function formatMessage(stats) {
-      let lines = [];
-      let message;
-      if (typeof stats === "object") {
-        const fileName = stats.moduleName ? `File: ${stats.moduleName}
-` : "";
-        const mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
-        const details = stats.details ? `
-Details: ${stats.details}
-` : "";
-        const stack = stats.stack ? `
-${stats.stack}` : "";
-        message = `${fileName}${mainMessage}${details}${stack}`;
-      } else {
-        message = stats;
-      }
-      lines = message.split("\n");
-      lines = lines.map((line) => {
-        const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(
-          line
-        );
-        if (!parsingError) {
-          return line;
-        }
-        const [, errorLine, errorColumn, errorMessage] = parsingError;
-        return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
-      });
-      message = lines.join("\n");
-      message = message.replace(
-        /SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g,
-        `${friendlySyntaxErrorLabel} $3 ($1:$2)
-`
-      );
-      lines = message.split("\n");
-      if (lines.length > 2 && lines[1].trim() === "") {
-        lines.splice(1, 1);
-      }
-      lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
-      if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
-        lines[1] = lines[1].replace("Error: ", "");
-      }
-      message = lines.join("\n");
-      message = message.replace(
-        /^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm,
-        ""
-      );
-      message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, "");
-      lines = message.split("\n");
-      lines = lines.filter(
-        (line, index, arr) => index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim()
-      );
-      message = lines.join("\n");
-      return message.trim();
-    }
-    function formatWebpackMessages(json) {
-      var _a, _b, _c;
-      const formattedErrors = (_a = json == null ? void 0 : json.errors) == null ? void 0 : _a.map(formatMessage);
-      const formattedWarnings = (_b = json == null ? void 0 : json.warnings) == null ? void 0 : _b.map(formatMessage);
-      const result = {
-        errors: formattedErrors || [],
-        warnings: formattedWarnings || []
-      };
-      if ((_c = result.errors) == null ? void 0 : _c.some(isLikelyASyntaxError)) {
-        result.errors = result.errors.filter(isLikelyASyntaxError);
-      }
-      if (result.errors.length > 1) {
-        result.errors.length = 1;
-      }
-      return result;
-    }
-  }
-});
-
 // ../utils/dist/logger.js
 var require_logger = __commonJS({
   "../utils/dist/logger.js"(exports, module2) {
@@ -35684,10 +35790,10 @@ var require_constants = __commonJS({
       API_DIR: () => API_DIR,
       CONFIG_CACHE_DIR: () => CONFIG_CACHE_DIR,
       CONFIG_FILE_EXTENSIONS: () => CONFIG_FILE_EXTENSIONS,
+      DEFAULT_BABEL_PRESET_TYPESCRIPT_OPTIONS: () => DEFAULT_BABEL_PRESET_TYPESCRIPT_OPTIONS,
       DEFAULT_DEV_HOST: () => DEFAULT_DEV_HOST,
       DEFAULT_SERVER_CONFIG: () => DEFAULT_SERVER_CONFIG,
       ENTRY_NAME_PATTERN: () => ENTRY_NAME_PATTERN,
-      HMR_SOCK_PATH: () => HMR_SOCK_PATH,
       INTERNAL_APP_TOOLS_PLUGINS: () => INTERNAL_APP_TOOLS_PLUGINS,
       INTERNAL_APP_TOOLS_RUNTIME_PLUGINS: () => INTERNAL_APP_TOOLS_RUNTIME_PLUGINS,
       INTERNAL_CLI_PLUGINS: () => INTERNAL_CLI_PLUGINS,
@@ -35701,8 +35807,7 @@ var require_constants = __commonJS({
       MAIN_ENTRY_NAME: () => MAIN_ENTRY_NAME,
       OUTPUT_CONFIG_FILE: () => OUTPUT_CONFIG_FILE,
       PLUGIN_SCHEMAS: () => PLUGIN_SCHEMAS,
-      ROUTE_MANIFEST: () => ROUTE_MANIFEST,
-      ROUTE_MINIFEST_FILE: () => ROUTE_MINIFEST_FILE,
+      ROUTE_MANIFEST_FILE: () => ROUTE_MANIFEST_FILE,
       ROUTE_SPEC_FILE: () => ROUTE_SPEC_FILE,
       SERVER_BUNDLE_DIRECTORY: () => SERVER_BUNDLE_DIRECTORY,
       SERVER_DIR: () => SERVER_DIR,
@@ -35718,7 +35823,6 @@ var require_constants = __commonJS({
       SHARED_DIR: () => SHARED_DIR
     });
     module2.exports = __toCommonJS2(constants_exports);
-    var HMR_SOCK_PATH = "/webpack-hmr";
     var ROUTE_SPEC_FILE = "route.json";
     var MAIN_ENTRY_NAME = "main";
     var LAUNCH_EDITOR_ENDPOINT = "/__open-stack-frame-in-editor";
@@ -35734,8 +35838,7 @@ var require_constants = __commonJS({
     var CONFIG_FILE_EXTENSIONS = [".js", ".ts", ".mjs"];
     var OUTPUT_CONFIG_FILE = "modern.config.json";
     var DEFAULT_SERVER_CONFIG = "modern.server-runtime.config";
-    var ROUTE_MINIFEST_FILE = "routes-manifest.json";
-    var ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
+    var ROUTE_MANIFEST_FILE = "routes-manifest.json";
     var LOADER_ROUTES_DIR = `loader-routes`;
     var DEFAULT_DEV_HOST = "0.0.0.0";
     var INTERNAL_APP_TOOLS_PLUGINS = {
@@ -35939,6 +36042,15 @@ var require_constants = __commonJS({
       ],
       "@modern-js/plugin-nocode": []
     };
+    var DEFAULT_BABEL_PRESET_TYPESCRIPT_OPTIONS = {
+      allowNamespaces: true,
+      allExtensions: true,
+      allowDeclareFields: true,
+      // aligns Babel's behavior with TypeScript's default behavior.
+      // https://babeljs.io/docs/en/babel-preset-typescript#optimizeconstenums
+      optimizeConstEnums: true,
+      isTSX: true
+    };
   }
 });
 
@@ -37049,19 +37161,16 @@ var require_prettyInstructions = __commonJS({
     };
     var getAddressUrls = (protocol = "http", port) => {
       const ipv4Interfaces = getIpv4Interfaces();
-      return ipv4Interfaces.reduce(
-        (memo, detail) => {
-          let type = "Network:  ";
-          let url = `${protocol}://${detail.address}:${port}`;
-          if (detail.address.includes(`localhost`) || detail.internal) {
-            type = "Local:  ";
-            url = `${protocol}://localhost:${port}`;
-          }
-          memo.push({ type, url });
-          return memo;
-        },
-        []
-      );
+      return ipv4Interfaces.reduce((memo, detail) => {
+        let label = "Network:  ";
+        let url = `${protocol}://${detail.address}:${port}`;
+        if (detail.address.includes(`localhost`) || detail.internal) {
+          label = "Local:  ";
+          url = `${protocol}://localhost:${port}`;
+        }
+        memo.push({ label, url });
+        return memo;
+      }, []);
     };
     var prettyInstructions = (appContext, config) => {
       const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
@@ -37073,15 +37182,15 @@ var require_prettyInstructions = __commonJS({
       let message = "App running at:\n\n";
       if ((0, import_is.isSingleEntry)(entrypoints) || apiOnly) {
         message += urls.map(
-          ({ type, url }) => `  ${import_compiled.chalk.bold(`> ${type.padEnd(10)}`)}${import_compiled.chalk.cyanBright(
+          ({ label, url }) => `  ${import_compiled.chalk.bold(`> ${label.padEnd(10)}`)}${import_compiled.chalk.cyanBright(
             normalizeUrl(`${url}/${routes[0].urlPath}`)
           )}
 `
         ).join("");
       } else {
         const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
-        urls.forEach(({ type, url }) => {
-          message += `  ${import_compiled.chalk.bold(`> ${type}`)}
+        urls.forEach(({ label, url }) => {
+          message += `  ${import_compiled.chalk.bold(`> ${label}`)}
 `;
           routes.forEach(({ entryName, urlPath, isSSR }) => {
             if (!checkedEntries.includes(entryName)) {
@@ -37460,9 +37569,9 @@ var require_getServerConfig = __commonJS({
   }
 });
 
-// ../utils/dist/tryResolve.js
-var require_tryResolve = __commonJS({
-  "../utils/dist/tryResolve.js"(exports, module2) {
+// ../utils/dist/resolve.js
+var require_resolve = __commonJS({
+  "../utils/dist/resolve.js"(exports, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
@@ -37480,12 +37589,13 @@ var require_tryResolve = __commonJS({
       return to;
     };
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var tryResolve_exports = {};
-    __export2(tryResolve_exports, {
+    var resolve_exports = {};
+    __export2(resolve_exports, {
+      getAntdMajorVersion: () => getAntdMajorVersion,
       isPackageInstalled: () => isPackageInstalled,
       tryResolve: () => tryResolve
     });
-    module2.exports = __toCommonJS2(tryResolve_exports);
+    module2.exports = __toCommonJS2(resolve_exports);
     var import_ensureArray = require_ensureArray();
     var tryResolve = (name, resolvePath) => {
       let filePath = "";
@@ -37508,6 +37618,17 @@ var require_tryResolve = __commonJS({
         return false;
       }
     };
+    var getAntdMajorVersion = (appDirectory) => {
+      try {
+        const pkgJsonPath = require.resolve("antd/package.json", {
+          paths: [appDirectory]
+        });
+        const { version: version2 } = require(pkgJsonPath);
+        return Number(version2.split(".")[0]);
+      } catch (err) {
+        return null;
+      }
+    };
   }
 });
 
@@ -37568,15 +37689,16 @@ var require_analyzeProject = __commonJS({
     });
     module2.exports = __toCommonJS2(analyzeProject_exports);
     var path4 = __toESM2(require("path"));
+    var import_commands = require_commands();
     var import_compiled = require_compiled();
     var isApiOnly = (appDirectory, entryDir) => __async2(void 0, null, function* () {
       const srcDir = path4.join(appDirectory, entryDir != null ? entryDir : "src");
       const existSrc = yield import_compiled.fs.pathExists(srcDir);
-      const options = (0, import_compiled.minimist)(process.argv.slice(2));
+      const options = (0, import_compiled.minimist)((0, import_commands.getArgv)());
       return !existSrc || Boolean(options["api-only"]);
     });
     var isWebOnly = () => __async2(void 0, null, function* () {
-      const options = (0, import_compiled.minimist)(process.argv.slice(2));
+      const options = (0, import_compiled.minimist)((0, import_commands.getArgv)());
       return Boolean(options["web-only"]);
     });
   }
@@ -37647,27 +37769,10 @@ var require_chainId = __commonJS({
       },
       /** Predefined rule groups */
       ONE_OF: {
-        JS: "js",
-        TS: "ts",
-        CSS: "css",
-        LESS: "less",
-        SASS: "sass",
-        YAML: "yml",
-        TOML: "toml",
-        FALLBACK: "fallback",
-        MARKDOWN: "markdown",
-        BFF_CLIENT: "bff-client",
-        CSS_MODULES: "css-modules",
-        LESS_MODULES: "less-modules",
-        SASS_MODULES: "sass-modules",
         SVG: "svg",
         SVG_URL: "svg-url",
         SVG_ASSET: "svg-asset",
-        SVG_INLINE: "svg-inline",
-        ASSETS: "assets",
-        ASSETS_URL: "assets-url",
-        ASSETS_INLINE: "assets-inline",
-        IMAGE_COMPRESS: "image-compress"
+        SVG_INLINE: "svg-inline"
       },
       /** Predefined loaders */
       USE: {
@@ -38352,7 +38457,6 @@ var require_dist = __commonJS({
     module2.exports = __toCommonJS2(src_exports2);
     __reExport(src_exports2, require_compiled(), module2.exports);
     __reExport(src_exports2, require_commands(), module2.exports);
-    __reExport(src_exports2, require_format(), module2.exports);
     __reExport(src_exports2, require_FileSizeReporter(), module2.exports);
     __reExport(src_exports2, require_printBuildError(), module2.exports);
     __reExport(src_exports2, require_debug2(), module2.exports);
@@ -38384,7 +38488,7 @@ var require_dist = __commonJS({
     __reExport(src_exports2, require_wait(), module2.exports);
     __reExport(src_exports2, require_emptyDir(), module2.exports);
     __reExport(src_exports2, require_getServerConfig(), module2.exports);
-    __reExport(src_exports2, require_tryResolve(), module2.exports);
+    __reExport(src_exports2, require_resolve(), module2.exports);
     __reExport(src_exports2, require_analyzeProject(), module2.exports);
     __reExport(src_exports2, require_chainId(), module2.exports);
     __reExport(src_exports2, require_version(), module2.exports);
@@ -67435,7 +67539,7 @@ var require_compiled2 = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/@modern-js+utils@1.21.5/node_modules/@modern-js/utils/dist/format.js
-var require_format2 = __commonJS({
+var require_format = __commonJS({
   "../../../node_modules/.pnpm/@modern-js+utils@1.21.5/node_modules/@modern-js/utils/dist/format.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -69085,7 +69189,7 @@ var require_ssr = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/@modern-js+utils@1.21.5/node_modules/@modern-js/utils/dist/tryResolve.js
-var require_tryResolve2 = __commonJS({
+var require_tryResolve = __commonJS({
   "../../../node_modules/.pnpm/@modern-js+utils@1.21.5/node_modules/@modern-js/utils/dist/tryResolve.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -69396,7 +69500,7 @@ var require_dist2 = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     __exportStar(require_compiled2(), exports);
-    __exportStar(require_format2(), exports);
+    __exportStar(require_format(), exports);
     __exportStar(require_FileSizeReporter2(), exports);
     __exportStar(require_printBuildError2(), exports);
     __exportStar(require_debug4(), exports);
@@ -69428,7 +69532,7 @@ var require_dist2 = __commonJS({
     __exportStar(require_emptyDir2(), exports);
     __exportStar(require_getServerConfig2(), exports);
     __exportStar(require_ssr(), exports);
-    __exportStar(require_tryResolve2(), exports);
+    __exportStar(require_tryResolve(), exports);
     __exportStar(require_analyzeProject2(), exports);
     __exportStar(require_chainId2(), exports);
     __exportStar(require_version2(), exports);
@@ -71171,6 +71275,306 @@ var require_browser = __commonJS({
   }
 });
 
+// ../../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
+    "use strict";
+    var os2 = require("os");
+    var tty = require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os2.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version2 >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js"(exports, module2) {
+    var tty = require("tty");
+    var util = require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.format(...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module2.exports = require_common()(exports);
+    var { formatters } = module2.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js"(exports, module2) {
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module2.exports = require_browser();
+    } else {
+      module2.exports = require_node();
+    }
+  }
+});
+
 // ../../../node_modules/.pnpm/follow-redirects@1.15.1/node_modules/follow-redirects/debug.js
 var require_debug5 = __commonJS({
   "../../../node_modules/.pnpm/follow-redirects@1.15.1/node_modules/follow-redirects/debug.js"(exports, module2) {
@@ -71178,7 +71582,7 @@ var require_debug5 = __commonJS({
     module2.exports = function() {
       if (!debug2) {
         try {
-          debug2 = require_browser()("follow-redirects");
+          debug2 = require_src()("follow-redirects");
         } catch (error) {
         }
         if (typeof debug2 !== "function") {
@@ -78312,7 +78716,7 @@ var require_codesmith = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/@modern-js+codesmith@2.0.5/node_modules/@modern-js/codesmith/dist/js/node/index.js
-var require_node = __commonJS({
+var require_node2 = __commonJS({
   "../../../node_modules/.pnpm/@modern-js+codesmith@2.0.5/node_modules/@modern-js/codesmith/dist/js/node/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", {
@@ -78418,10 +78822,10 @@ var import_utils5 = __toESM(require_dist());
 
 // src/createAction.ts
 var import_path2 = __toESM(require("path"));
-var import_codesmith = __toESM(require_node());
+var import_codesmith = __toESM(require_node2());
 
 // package.json
-var version = "2.10.0";
+var version = "2.12.0";
 
 // ../../cli/plugin-i18n/dist/esm-node/index.js
 var import_lodash2 = __toESM(require_lodash2());