@unpackjs/core 1.7.4 → 1.7.5

package/compiled/commander/index.js

@@ -20,8 +20,8 @@
       "use strict";
       module.exports = require("node:process");
     },
-    654: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      const { InvalidArgumentError } = __nccwpck_require__(829);
+    429: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      const { InvalidArgumentError } = __nccwpck_require__(848);
       class Argument {
         constructor(name, description) {
           this.description = description || "";
@@ -98,17 +98,17 @@
       exports.Argument = Argument;
       exports.humanReadableArgName = humanReadableArgName;
     },
-    955: (__unused_webpack_module, exports, __nccwpck_require__) => {
+    745: (__unused_webpack_module, exports, __nccwpck_require__) => {
       const EventEmitter = __nccwpck_require__(673).EventEmitter;
       const childProcess = __nccwpck_require__(718);
       const path = __nccwpck_require__(411);
       const fs = __nccwpck_require__(561);
       const process = __nccwpck_require__(742);
-      const { Argument, humanReadableArgName } = __nccwpck_require__(654);
-      const { CommanderError } = __nccwpck_require__(829);
-      const { Help } = __nccwpck_require__(567);
-      const { Option, DualOptions } = __nccwpck_require__(230);
-      const { suggestSimilar } = __nccwpck_require__(241);
+      const { Argument, humanReadableArgName } = __nccwpck_require__(429);
+      const { CommanderError } = __nccwpck_require__(848);
+      const { Help, stripColor } = __nccwpck_require__(613);
+      const { Option, DualOptions } = __nccwpck_require__(234);
+      const { suggestSimilar } = __nccwpck_require__(824);
       class Command extends EventEmitter {
         constructor(name) {
           super();
@@ -116,7 +116,7 @@
           this.options = [];
           this.parent = null;
           this._allowUnknownOption = false;
-          this._allowExcessArguments = true;
+          this._allowExcessArguments = false;
           this.registeredArguments = [];
           this._args = this.registeredArguments;
           this.args = [];
@@ -143,14 +143,22 @@
           this._lifeCycleHooks = {};
           this._showHelpAfterError = false;
           this._showSuggestionAfterError = true;
+          this._savedState = null;
           this._outputConfiguration = {
             writeOut: (str) => process.stdout.write(str),
             writeErr: (str) => process.stderr.write(str),
+            outputError: (str, write) => write(str),
             getOutHelpWidth: () =>
               process.stdout.isTTY ? process.stdout.columns : undefined,
             getErrHelpWidth: () =>
               process.stderr.isTTY ? process.stderr.columns : undefined,
-            outputError: (str, write) => write(str),
+            getOutHasColors: () =>
+              useColor() ??
+              (process.stdout.isTTY && process.stdout.hasColors?.()),
+            getErrHasColors: () =>
+              useColor() ??
+              (process.stderr.isTTY && process.stderr.hasColors?.()),
+            stripColor: (str) => stripColor(str),
           };
           this._hidden = false;
           this._helpOption = undefined;
@@ -641,15 +649,58 @@
           return userArgs;
         }
         parse(argv, parseOptions) {
+          this._prepareForParse();
           const userArgs = this._prepareUserArgs(argv, parseOptions);
           this._parseCommand([], userArgs);
           return this;
         }
         async parseAsync(argv, parseOptions) {
+          this._prepareForParse();
           const userArgs = this._prepareUserArgs(argv, parseOptions);
           await this._parseCommand([], userArgs);
           return this;
         }
+        _prepareForParse() {
+          if (this._savedState === null) {
+            this.saveStateBeforeParse();
+          } else {
+            this.restoreStateBeforeParse();
+          }
+        }
+        saveStateBeforeParse() {
+          this._savedState = {
+            _name: this._name,
+            _optionValues: { ...this._optionValues },
+            _optionValueSources: { ...this._optionValueSources },
+          };
+        }
+        restoreStateBeforeParse() {
+          if (this._storeOptionsAsProperties)
+            throw new Error(
+              `Can not call parse again when storeOptionsAsProperties is true.\n- either make a new Command for each call to parse, or stop storing options as properties`,
+            );
+          this._name = this._savedState._name;
+          this._scriptPath = null;
+          this.rawArgs = [];
+          this._optionValues = { ...this._savedState._optionValues };
+          this._optionValueSources = {
+            ...this._savedState._optionValueSources,
+          };
+          this.args = [];
+          this.processedArgs = [];
+        }
+        _checkForMissingExecutable(
+          executableFile,
+          executableDir,
+          subcommandName,
+        ) {
+          if (fs.existsSync(executableFile)) return;
+          const executableDirMessage = executableDir
+            ? `searched for local subcommand relative to directory '${executableDir}'`
+            : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+          const executableMissing = `'${executableFile}' does not exist\n - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;
+          throw new Error(executableMissing);
+        }
         _executeSubCommand(subcommand, args) {
           args = args.slice();
           let launchWithNode = false;
@@ -673,7 +724,7 @@
             let resolvedScriptPath;
             try {
               resolvedScriptPath = fs.realpathSync(this._scriptPath);
-            } catch (err) {
+            } catch {
               resolvedScriptPath = this._scriptPath;
             }
             executableDir = path.resolve(
@@ -712,6 +763,11 @@
               });
             }
           } else {
+            this._checkForMissingExecutable(
+              executableFile,
+              executableDir,
+              subcommand._name,
+            );
             args.unshift(executableFile);
             args = incrementNodeInspectorPort(process.execArgv).concat(args);
             proc = childProcess.spawn(process.execPath, args, {
@@ -751,11 +807,11 @@
           });
           proc.on("error", (err) => {
             if (err.code === "ENOENT") {
-              const executableDirMessage = executableDir
-                ? `searched for local subcommand relative to directory '${executableDir}'`
-                : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-              const executableMissing = `'${executableFile}' does not exist\n - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;
-              throw new Error(executableMissing);
+              this._checkForMissingExecutable(
+                executableFile,
+                executableDir,
+                subcommand._name,
+              );
             } else if (err.code === "EACCES") {
               throw new Error(`'${executableFile}' not executable`);
             }
@@ -776,6 +832,7 @@
         _dispatchSubcommand(commandName, operands, unknown) {
           const subCommand = this._findCommand(commandName);
           if (!subCommand) this.help({ error: true });
+          subCommand._prepareForParse();
           let promiseChain;
           promiseChain = this._chainOrCallSubCommandHook(
             promiseChain,
@@ -1406,26 +1463,36 @@
         }
         helpInformation(contextOptions) {
           const helper = this.createHelp();
-          if (helper.helpWidth === undefined) {
-            helper.helpWidth =
-              contextOptions && contextOptions.error
-                ? this._outputConfiguration.getErrHelpWidth()
-                : this._outputConfiguration.getOutHelpWidth();
-          }
-          return helper.formatHelp(this, helper);
+          const context = this._getOutputContext(contextOptions);
+          helper.prepareContext({
+            error: context.error,
+            helpWidth: context.helpWidth,
+            outputHasColors: context.hasColors,
+          });
+          const text = helper.formatHelp(this, helper);
+          if (context.hasColors) return text;
+          return this._outputConfiguration.stripColor(text);
         }
-        _getHelpContext(contextOptions) {
+        _getOutputContext(contextOptions) {
           contextOptions = contextOptions || {};
-          const context = { error: !!contextOptions.error };
-          let write;
-          if (context.error) {
-            write = (arg) => this._outputConfiguration.writeErr(arg);
+          const error = !!contextOptions.error;
+          let baseWrite;
+          let hasColors;
+          let helpWidth;
+          if (error) {
+            baseWrite = (str) => this._outputConfiguration.writeErr(str);
+            hasColors = this._outputConfiguration.getErrHasColors();
+            helpWidth = this._outputConfiguration.getErrHelpWidth();
           } else {
-            write = (arg) => this._outputConfiguration.writeOut(arg);
+            baseWrite = (str) => this._outputConfiguration.writeOut(str);
+            hasColors = this._outputConfiguration.getOutHasColors();
+            helpWidth = this._outputConfiguration.getOutHelpWidth();
           }
-          context.write = contextOptions.write || write;
-          context.command = this;
-          return context;
+          const write = (str) => {
+            if (!hasColors) str = this._outputConfiguration.stripColor(str);
+            return baseWrite(str);
+          };
+          return { error, write, hasColors, helpWidth };
         }
         outputHelp(contextOptions) {
           let deprecatedCallback;
@@ -1433,12 +1500,19 @@
             deprecatedCallback = contextOptions;
             contextOptions = undefined;
           }
-          const context = this._getHelpContext(contextOptions);
+          const outputContext = this._getOutputContext(contextOptions);
+          const eventContext = {
+            error: outputContext.error,
+            write: outputContext.write,
+            command: this,
+          };
           this._getCommandAndAncestors()
             .reverse()
-            .forEach((command) => command.emit("beforeAllHelp", context));
-          this.emit("beforeHelp", context);
-          let helpInformation = this.helpInformation(context);
+            .forEach((command) => command.emit("beforeAllHelp", eventContext));
+          this.emit("beforeHelp", eventContext);
+          let helpInformation = this.helpInformation({
+            error: outputContext.error,
+          });
           if (deprecatedCallback) {
             helpInformation = deprecatedCallback(helpInformation);
             if (
@@ -1450,13 +1524,13 @@
               );
             }
           }
-          context.write(helpInformation);
+          outputContext.write(helpInformation);
           if (this._getHelpOption()?.long) {
             this.emit(this._getHelpOption().long);
           }
-          this.emit("afterHelp", context);
+          this.emit("afterHelp", eventContext);
           this._getCommandAndAncestors().forEach((command) =>
-            command.emit("afterAllHelp", context),
+            command.emit("afterAllHelp", eventContext),
           );
         }
         helpOption(flags, description) {
@@ -1485,7 +1559,7 @@
         }
         help(contextOptions) {
           this.outputHelp(contextOptions);
-          let exitCode = process.exitCode || 0;
+          let exitCode = Number(process.exitCode ?? 0);
           if (
             exitCode === 0 &&
             contextOptions &&
@@ -1564,9 +1638,21 @@
           return arg;
         });
       }
+      function useColor() {
+        if (
+          process.env.NO_COLOR ||
+          process.env.FORCE_COLOR === "0" ||
+          process.env.FORCE_COLOR === "false"
+        )
+          return false;
+        if (process.env.FORCE_COLOR || process.env.CLICOLOR_FORCE !== undefined)
+          return true;
+        return undefined;
+      }
       exports.Command = Command;
+      exports.useColor = useColor;
     },
-    829: (__unused_webpack_module, exports) => {
+    848: (__unused_webpack_module, exports) => {
       class CommanderError extends Error {
         constructor(exitCode, code, message) {
           super(message);
@@ -1587,15 +1673,19 @@
       exports.CommanderError = CommanderError;
       exports.InvalidArgumentError = InvalidArgumentError;
     },
-    567: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      const { humanReadableArgName } = __nccwpck_require__(654);
+    613: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      const { humanReadableArgName } = __nccwpck_require__(429);
       class Help {
         constructor() {
           this.helpWidth = undefined;
+          this.minWidthToWrap = 40;
           this.sortSubcommands = false;
           this.sortOptions = false;
           this.showGlobalOptions = false;
         }
+        prepareContext(contextOptions) {
+          this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+        }
         visibleCommands(cmd) {
           const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
           const helpCommand = cmd._getHelpCommand();
@@ -1695,7 +1785,12 @@
             .visibleCommands(cmd)
             .reduce(
               (max, command) =>
-                Math.max(max, helper.subcommandTerm(command).length),
+                Math.max(
+                  max,
+                  this.displayWidth(
+                    helper.styleSubcommandTerm(helper.subcommandTerm(command)),
+                  ),
+                ),
               0,
             );
         }
@@ -1703,7 +1798,13 @@
           return helper
             .visibleOptions(cmd)
             .reduce(
-              (max, option) => Math.max(max, helper.optionTerm(option).length),
+              (max, option) =>
+                Math.max(
+                  max,
+                  this.displayWidth(
+                    helper.styleOptionTerm(helper.optionTerm(option)),
+                  ),
+                ),
               0,
             );
         }
@@ -1711,7 +1812,13 @@
           return helper
             .visibleGlobalOptions(cmd)
             .reduce(
-              (max, option) => Math.max(max, helper.optionTerm(option).length),
+              (max, option) =>
+                Math.max(
+                  max,
+                  this.displayWidth(
+                    helper.styleOptionTerm(helper.optionTerm(option)),
+                  ),
+                ),
               0,
             );
         }
@@ -1720,7 +1827,12 @@
             .visibleArguments(cmd)
             .reduce(
               (max, argument) =>
-                Math.max(max, helper.argumentTerm(argument).length),
+                Math.max(
+                  max,
+                  this.displayWidth(
+                    helper.styleArgumentTerm(helper.argumentTerm(argument)),
+                  ),
+                ),
               0,
             );
         }
@@ -1787,82 +1899,81 @@
             );
           }
           if (extraInfo.length > 0) {
-            const extraDescripton = `(${extraInfo.join(", ")})`;
+            const extraDescription = `(${extraInfo.join(", ")})`;
             if (argument.description) {
-              return `${argument.description} ${extraDescripton}`;
+              return `${argument.description} ${extraDescription}`;
             }
-            return extraDescripton;
+            return extraDescription;
           }
           return argument.description;
         }
         formatHelp(cmd, helper) {
           const termWidth = helper.padWidth(cmd, helper);
-          const helpWidth = helper.helpWidth || 80;
-          const itemIndentWidth = 2;
-          const itemSeparatorWidth = 2;
-          function formatItem(term, description) {
-            if (description) {
-              const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-              return helper.wrap(
-                fullText,
-                helpWidth - itemIndentWidth,
-                termWidth + itemSeparatorWidth,
-              );
-            }
-            return term;
-          }
-          function formatList(textArray) {
-            return textArray
-              .join("\n")
-              .replace(/^/gm, " ".repeat(itemIndentWidth));
-          }
-          let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+          const helpWidth = helper.helpWidth ?? 80;
+          function callFormatItem(term, description) {
+            return helper.formatItem(term, termWidth, description, helper);
+          }
+          let output = [
+            `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+            "",
+          ];
           const commandDescription = helper.commandDescription(cmd);
           if (commandDescription.length > 0) {
             output = output.concat([
-              helper.wrap(commandDescription, helpWidth, 0),
+              helper.boxWrap(
+                helper.styleCommandDescription(commandDescription),
+                helpWidth,
+              ),
               "",
             ]);
           }
           const argumentList = helper
             .visibleArguments(cmd)
             .map((argument) =>
-              formatItem(
-                helper.argumentTerm(argument),
-                helper.argumentDescription(argument),
+              callFormatItem(
+                helper.styleArgumentTerm(helper.argumentTerm(argument)),
+                helper.styleArgumentDescription(
+                  helper.argumentDescription(argument),
+                ),
               ),
             );
           if (argumentList.length > 0) {
             output = output.concat([
-              "Arguments:",
-              formatList(argumentList),
+              helper.styleTitle("Arguments:"),
+              ...argumentList,
               "",
             ]);
           }
           const optionList = helper
             .visibleOptions(cmd)
             .map((option) =>
-              formatItem(
-                helper.optionTerm(option),
-                helper.optionDescription(option),
+              callFormatItem(
+                helper.styleOptionTerm(helper.optionTerm(option)),
+                helper.styleOptionDescription(helper.optionDescription(option)),
               ),
             );
           if (optionList.length > 0) {
-            output = output.concat(["Options:", formatList(optionList), ""]);
+            output = output.concat([
+              helper.styleTitle("Options:"),
+              ...optionList,
+              "",
+            ]);
           }
-          if (this.showGlobalOptions) {
+          if (helper.showGlobalOptions) {
             const globalOptionList = helper
               .visibleGlobalOptions(cmd)
               .map((option) =>
-                formatItem(
-                  helper.optionTerm(option),
-                  helper.optionDescription(option),
+                callFormatItem(
+                  helper.styleOptionTerm(helper.optionTerm(option)),
+                  helper.styleOptionDescription(
+                    helper.optionDescription(option),
+                  ),
                 ),
               );
             if (globalOptionList.length > 0) {
               output = output.concat([
-                "Global Options:",
-                formatList(globalOptionList),
+                helper.styleTitle("Global Options:"),
+                ...globalOptionList,
                 "",
               ]);
             }
@@ -1870,16 +1981,84 @@
           const commandList = helper
             .visibleCommands(cmd)
             .map((cmd) =>
-              formatItem(
-                helper.subcommandTerm(cmd),
-                helper.subcommandDescription(cmd),
+              callFormatItem(
+                helper.styleSubcommandTerm(helper.subcommandTerm(cmd)),
+                helper.styleSubcommandDescription(
+                  helper.subcommandDescription(cmd),
+                ),
               ),
             );
           if (commandList.length > 0) {
-            output = output.concat(["Commands:", formatList(commandList), ""]);
+            output = output.concat([
+              helper.styleTitle("Commands:"),
+              ...commandList,
+              "",
+            ]);
           }
           return output.join("\n");
         }
+        displayWidth(str) {
+          return stripColor(str).length;
+        }
+        styleTitle(str) {
+          return str;
+        }
+        styleUsage(str) {
+          return str
+            .split(" ")
+            .map((word) => {
+              if (word === "[options]") return this.styleOptionText(word);
+              if (word === "[command]") return this.styleSubcommandText(word);
+              if (word[0] === "[" || word[0] === "<")
+                return this.styleArgumentText(word);
+              return this.styleCommandText(word);
+            })
+            .join(" ");
+        }
+        styleCommandDescription(str) {
+          return this.styleDescriptionText(str);
+        }
+        styleOptionDescription(str) {
+          return this.styleDescriptionText(str);
+        }
+        styleSubcommandDescription(str) {
+          return this.styleDescriptionText(str);
+        }
+        styleArgumentDescription(str) {
+          return this.styleDescriptionText(str);
+        }
+        styleDescriptionText(str) {
+          return str;
+        }
+        styleOptionTerm(str) {
+          return this.styleOptionText(str);
+        }
+        styleSubcommandTerm(str) {
+          return str
+            .split(" ")
+            .map((word) => {
+              if (word === "[options]") return this.styleOptionText(word);
+              if (word[0] === "[" || word[0] === "<")
+                return this.styleArgumentText(word);
+              return this.styleSubcommandText(word);
+            })
+            .join(" ");
+        }
+        styleArgumentTerm(str) {
+          return this.styleArgumentText(str);
+        }
+        styleOptionText(str) {
+          return str;
+        }
+        styleArgumentText(str) {
+          return str;
+        }
+        styleSubcommandText(str) {
+          return str;
+        }
+        styleCommandText(str) {
+          return str;
+        }
         padWidth(cmd, helper) {
           return Math.max(
             helper.longestOptionTermLength(cmd, helper),
@@ -1888,37 +2067,82 @@
             helper.longestArgumentTermLength(cmd, helper),
           );
         }
-        wrap(str, width, indent, minColumnWidth = 40) {
-          const indents = " \\f\\t\\v   -   　\ufeff";
-          const manualIndent = new RegExp(`[\\n][${indents}]+`);
-          if (str.match(manualIndent)) return str;
-          const columnWidth = width - indent;
-          if (columnWidth < minColumnWidth) return str;
-          const leadingStr = str.slice(0, indent);
-          const columnText = str.slice(indent).replace("\r\n", "\n");
-          const indentString = " ".repeat(indent);
-          const zeroWidthSpace = "​";
-          const breaks = `\\s${zeroWidthSpace}`;
-          const regex = new RegExp(
-            `\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,
-            "g",
+        preformatted(str) {
+          return /\n[^\S\r\n]/.test(str);
+        }
+        formatItem(term, termWidth, description, helper) {
+          const itemIndent = 2;
+          const itemIndentStr = " ".repeat(itemIndent);
+          if (!description) return itemIndentStr + term;
+          const paddedTerm = term.padEnd(
+            termWidth + term.length - helper.displayWidth(term),
           );
-          const lines = columnText.match(regex) || [];
+          const spacerWidth = 2;
+          const helpWidth = this.helpWidth ?? 80;
+          const remainingWidth =
+            helpWidth - termWidth - spacerWidth - itemIndent;
+          let formattedDescription;
+          if (
+            remainingWidth < this.minWidthToWrap ||
+            helper.preformatted(description)
+          ) {
+            formattedDescription = description;
+          } else {
+            const wrappedDescription = helper.boxWrap(
+              description,
+              remainingWidth,
+            );
+            formattedDescription = wrappedDescription.replace(
+              /\n/g,
+              "\n" + " ".repeat(termWidth + spacerWidth),
+            );
+          }
           return (
-            leadingStr +
-            lines
-              .map((line, i) => {
-                if (line === "\n") return "";
-                return (i > 0 ? indentString : "") + line.trimEnd();
-              })
-              .join("\n")
+            itemIndentStr +
+            paddedTerm +
+            " ".repeat(spacerWidth) +
+            formattedDescription.replace(/\n/g, `\n${itemIndentStr}`)
           );
         }
+        boxWrap(str, width) {
+          if (width < this.minWidthToWrap) return str;
+          const rawLines = str.split(/\r\n|\n/);
+          const chunkPattern = /[\s]*[^\s]+/g;
+          const wrappedLines = [];
+          rawLines.forEach((line) => {
+            const chunks = line.match(chunkPattern);
+            if (chunks === null) {
+              wrappedLines.push("");
+              return;
+            }
+            let sumChunks = [chunks.shift()];
+            let sumWidth = this.displayWidth(sumChunks[0]);
+            chunks.forEach((chunk) => {
+              const visibleWidth = this.displayWidth(chunk);
+              if (sumWidth + visibleWidth <= width) {
+                sumChunks.push(chunk);
+                sumWidth += visibleWidth;
+                return;
+              }
+              wrappedLines.push(sumChunks.join(""));
+              const nextChunk = chunk.trimStart();
+              sumChunks = [nextChunk];
+              sumWidth = this.displayWidth(nextChunk);
+            });
+            wrappedLines.push(sumChunks.join(""));
+          });
+          return wrappedLines.join("\n");
+        }
+      }
+      function stripColor(str) {
+        const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+        return str.replace(sgrPattern, "");
       }
       exports.Help = Help;
+      exports.stripColor = stripColor;
     },
-    230: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      const { InvalidArgumentError } = __nccwpck_require__(829);
+    234: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      const { InvalidArgumentError } = __nccwpck_require__(848);
       class Option {
         constructor(flags, description) {
           this.flags = flags;
@@ -2009,7 +2233,10 @@
           return this.short.replace(/^-/, "");
         }
         attributeName() {
-          return camelcase(this.name().replace(/^no-/, ""));
+          if (this.negate) {
+            return camelcase(this.name().replace(/^no-/, ""));
+          }
+          return camelcase(this.name());
         }
         is(arg) {
           return this.short === arg || this.long === arg;
@@ -2052,20 +2279,31 @@
       function splitOptionFlags(flags) {
         let shortFlag;
         let longFlag;
-        const flagParts = flags.split(/[ |,]+/);
-        if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-          shortFlag = flagParts.shift();
-        longFlag = flagParts.shift();
-        if (!shortFlag && /^-[^-]$/.test(longFlag)) {
-          shortFlag = longFlag;
-          longFlag = undefined;
-        }
+        const shortFlagExp = /^-[^-]$/;
+        const longFlagExp = /^--[^-]/;
+        const flagParts = flags.split(/[ |,]+/).concat("guard");
+        if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+        if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+        if (/^-[^-][^-]/.test(flagParts[0]))
+          throw new Error(
+            `invalid Option flags, short option is dash and single character: '${flags}'`,
+          );
+        if (shortFlag && shortFlagExp.test(flagParts[0]))
+          throw new Error(
+            `invalid Option flags, more than one short flag: '${flags}'`,
+          );
+        if (longFlag && longFlagExp.test(flagParts[0]))
+          throw new Error(
+            `invalid Option flags, more than one long flag: '${flags}'`,
+          );
+        if (!(shortFlag || longFlag) || flagParts[0].startsWith("-"))
+          throw new Error(`invalid Option flags: '${flags}'`);
         return { shortFlag, longFlag };
       }
       exports.Option = Option;
       exports.DualOptions = DualOptions;
     },
-    241: (__unused_webpack_module, exports) => {
+    824: (__unused_webpack_module, exports) => {
       const maxDistance = 3;
       function editDistance(a, b) {
         if (Math.abs(a.length - b.length) > maxDistance)
@@ -2167,11 +2405,11 @@
   var __webpack_exports__ = {};
   (() => {
     var exports = __webpack_exports__;
-    const { Argument } = __nccwpck_require__(654);
-    const { Command } = __nccwpck_require__(955);
-    const { CommanderError, InvalidArgumentError } = __nccwpck_require__(829);
-    const { Help } = __nccwpck_require__(567);
-    const { Option } = __nccwpck_require__(230);
+    const { Argument } = __nccwpck_require__(429);
+    const { Command } = __nccwpck_require__(745);
+    const { CommanderError, InvalidArgumentError } = __nccwpck_require__(848);
+    const { Help } = __nccwpck_require__(613);
+    const { Option } = __nccwpck_require__(234);
     exports.program = new Command();
     exports.createCommand = (name) => new Command(name);
     exports.createOption = (flags, description) =>